Cannot register an input connection point with no internal c

Error message

Cannot register an input connection point with no internal connection points

What it means

_registerSubfilterInput derives the external input's connection type from the first internal connection point. Registering an input with an empty internalConnectionPoints array leaves the type undefined, so the constructor throws. This is a programming error in the aggregate block's setup.

Source

Thrown at packages/dev/smartFilters/src/blockFoundation/aggregateBlock.ts:127

            }
        }
    }

    /**
     * Registers an input connection from the internal graph as an input of the aggregated graph.
     * @param name - The name of the exposed input connection point
     * @param internalConnectionPoints - The input connection points in the inner graph to wire up to the new subfilter input
     * @param defaultValue - The default value to use for the input connection point
     * @returns the connection point referencing the input block
     */
    protected _registerSubfilterInput<U extends ConnectionPointType>(
        name: string,
        internalConnectionPoints: ConnectionPoint<U>[],
        defaultValue: Nullable<RuntimeData<U>> = null
    ): ConnectionPoint<U> {
        const type = internalConnectionPoints[0]?.type;
        if (type === undefined) {
            throw new Error("Cannot register an input connection point with no internal connection points");
        }
        const externalInputConnectionPoint = this._registerInput(name, type, defaultValue);

        this._aggregatedInputs.push([internalConnectionPoints, externalInputConnectionPoint]);

        return externalInputConnectionPoint;
    }

    /**
     * Registers an output connection point from the internal graph as an output of the aggregated graph.
     * @param name - The name of the exposed output connection point
     * @param internalConnectionPoint - The output connection point in the inner graph to expose as an output on the aggregate block
     * @returns the connection point referencing the output connection point
     */
    protected _registerSubfilterOutput<U extends ConnectionPointType>(name: string, internalConnectionPoint: ConnectionPoint<U>): ConnectionPoint<U> {
        const externalOutputConnectionPoint = this._registerOutput(name, internalConnectionPoint.type);

        this._aggregatedOutputs.push([internalConnectionPoint, externalOutputConnectionPoint]);

View on GitHub (pinned to 0592b347b8)

Solutions

Ensure the internal connection points array is non-empty before registering (guard or assert length > 0).
Fix the lookup/filter that builds internalConnectionPoints so it actually matches inner block inputs.
Skip registering the external input when there is nothing to aggregate, if that is valid for your block.
Check the inner Smart Filter was fully constructed before the aggregate block's registration code runs.

Example fix

// before
block._registerSubfilterInput("input", innerPoints.filter(p => p.type === t));
// after
const pts = innerPoints.filter(p => p.type === t);
if (pts.length > 0) block._registerSubfilterInput("input", pts);

Defensive patterns

Strategy: validation

Validate before calling

if (internalConnectionPoints.length === 0) {
    throw new Error('refusing to register subfilter input: no internal connection points');
}
block._registerSubfilterInput(name, internalConnectionPoints);

Type guard

function hasPoints<U extends ConnectionPointType>(pts: ConnectionPoint<U>[]): pts is [ConnectionPoint<U>, ...ConnectionPoint<U>[]] {
    return pts.length > 0;
}

Try / catch

try {
    registerAggregateInputs(block, collected);
} catch (e) {
    if (e instanceof Error && e.message.includes('no internal connection points')) {
        // log which input name produced an empty list and fix the lookup
    } else throw e;
}

Prevention

Assert non-empty internal connection point arrays at collection time.
Verify inner filter input names/types before constructing aggregate blocks.
Keep the inner filter fully constructed before registration runs.

When it happens

Trigger: Calling _registerSubfilterInput (directly or via aggregate block constructors) with internalConnectionPoints: [], e.g. after filtering out all candidate connection points, or before the inner filter's blocks have created their inputs.

Common situations: Building a CustomAggregateBlock whose inner filter has no matching inputs; conditional code that collects connection points and can produce an empty list; refactoring that renamed inputs so the lookup returns nothing.

Related errors

AI-assisted analysis of BabylonJS/Babylon.js@0592b347b8 (2026-08-30). Data as JSON: /api/errors/4f603ca4571929b7. Report an issue: GitHub.