BabylonJS/Babylon.js · error · Error

`Block ${connection.inputBlock} does not have a connection p

Error message

`Block ${connection.inputBlock} does not have a connection point named ${connection.inputConnectionPoint}`

What it means

The target block exists, but no input connection point on it matches connection.inputConnectionPoint (or the found point is not a valid object). Connections must land on a declared input endpoint; a mismatch means the serialized graph references an input the block does not provide.

Source

Thrown at packages/dev/smartFilters/src/serialization/smartFilterDeserializer.ts:111

            if (!sourceBlock) {
                throw new Error(`Source block ${connection.outputBlock} not found`);
            }
            const sourceConnectionPoint = sourceBlock.outputs.find((output) => output.name === connection.outputConnectionPoint);
            if (!sourceConnectionPoint || typeof sourceConnectionPoint.connectTo !== "function") {
                throw new Error(`Block ${connection.outputBlock} does not have an connection point named ${connection.outputConnectionPoint}`);
            }
            const sourceConnectToFunction = sourceConnectionPoint.connectTo.bind(sourceConnectionPoint);

            // Find the target block and its connection point
            const targetBlock = typeof connection.inputBlock === "string" ? blockNameMap.get(connection.inputBlock) : blockIdMap.get(connection.inputBlock);
            if (!targetBlock) {
                throw new Error(`Target block ${connection.inputBlock} not found`);
            }

            const targetConnectionPoint = targetBlock.inputs.find((input) => input.name === connection.inputConnectionPoint);
            if (!targetConnectionPoint || typeof targetConnectionPoint !== "object") {
                throw new Error(`Block ${connection.inputBlock} does not have a connection point named ${connection.inputConnectionPoint}`);
            }

            // Create the connection
            sourceConnectToFunction.call(sourceBlock, targetConnectionPoint);
        });

        return smartFilter;
    }

    private async _deserializeBlockV1Async(
        smartFilter: SmartFilter,
        serializedBlock: ISerializedBlockV1,
        engine: ThinEngine,
        blockTypesWhichCouldNotBeDeserialized: string[],
        blockIdMap: Map<number, BaseBlock>,
        blockNameMap: Map<string, BaseBlock>
    ): Promise<void> {
        let newBlock: Nullable<BaseBlock> = null;

View on GitHub (pinned to 0592b347b8)

Solutions

Correct inputConnectionPoint to the block's actual input name (check the block class's inputs list).
Re-export the filter from the current tooling so endpoint names are regenerated.
Update the block implementation to retain the legacy input name or write a migration for old serialized names.
Verify the resolved block type is the intended one (same lookup caveat as error 866).
Pre-validate connections against block input declarations before calling the deserializer.

Example fix

// before
{ "inputBlock": "GrayScale", "inputConnectionPoint": "texture", ... } // actual input "input"
// after
{ "inputBlock": "GrayScale", "inputConnectionPoint": "input", ... }

Defensive patterns

Strategy: validation

Validate before calling

function validateTargetConnectionPoints(serialized, blockRegistry) {
  for (const c of serialized.connections) {
    const block = serialized.blocks.find((b) => b.name === c.inputBlock || b.uniqueId === c.inputBlock);
    if (block && !blockRegistry.getInputs(block).includes(c.inputConnectionPoint)) {
      throw new Error(`Block ${c.inputBlock} has no input '${c.inputConnectionPoint}'`);
    }
  }
}

Type guard

function hasInput(block, name) {
  return block?.inputs?.some((i) => i.name === name) ?? false;
}

Try / catch

try {
  const filter = await SmartFilterDeserializer.DeserializeAsync(runtime, container, json);
} catch (e) {
  const m = e.message.match(/Block (.+) does not have a connection point named (.+)/);
  if (m) throw new Error(`Fix input endpoint: block '${m[1]}' has no input '${m[2]}'`);
  throw e;
}

Prevention

Verify input names against block class declarations after any refactor.
Regenerate filter files with current tooling after block version bumps.
Write endpoint-name migrations for legacy files.
Do not reuse connection entries across block types.
Run connection validation in CI for filter assets.

When it happens

Trigger: connection.inputConnectionPoint does not equal any of targetBlock.inputs' names — input renamed in a block refactor, typo in JSON, or connection copied from a different block type with different input names.

Common situations: Custom block inputs renamed between versions, hand-edited filter files, mixing blocks serialized from different filter versions, block type resolved to a different class than when serialized.

Related errors

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