Block ${connection.outputBlock} does not have an connection

Error message

Block ${connection.outputBlock} does not have an connection point named ${connection.outputConnectionPoint}

What it means

The source block was found, but none of its output connection points matches connection.outputConnectionPoint, or that output has no connectTo function. Connection endpoints are validated by name during deserialization, so a connection pointing at a nonexistent output makes the serialized graph invalid.

Source

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

        });
        await Promise.all(blockDeserializationWork);

        // If any block definitions could not be deserialized, throw an error
        if (blockDefinitionsWhichCouldNotBeDeserialized.length > 0) {
            throw new Error(`Could not deserialize the following block definitions: ${blockDefinitionsWhichCouldNotBeDeserialized.join(", ")}`);
        }

        // Deserialize the connections
        serializedSmartFilter.connections.forEach((connection: ISerializedConnectionV1) => {
            // Find the source block and its connection point's connectTo function
            const sourceBlock = typeof connection.outputBlock === "string" ? blockNameMap.get(connection.outputBlock) : blockIdMap.get(connection.outputBlock);

            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);
        });

View on GitHub (pinned to 0592b347b8)

Solutions

Correct outputConnectionPoint in the JSON to match the block's actual output name (inspect the block class's outputs).
Re-export the filter from the current editor/tooling version so connection point names are regenerated.
Update custom block code to keep the historical output name, or migrate the serialized connections.
Confirm the block type resolved is the intended one — a wrong blockType lookup can yield a block with different outputs.
Add a pre-deserialization validator comparing connection endpoints against each block's declared inputs/outputs.

Example fix

// before
{ "outputBlock": "Blur", "outputConnectionPoint": "output", ... } // actual name "out"
// after
{ "outputBlock": "Blur", "outputConnectionPoint": "out", ... }

Defensive patterns

Strategy: validation

Validate before calling

function validateSourceConnectionPoints(serialized, blockRegistry) {
  for (const c of serialized.connections) {
    const block = serialized.blocks.find((b) => b.name === c.outputBlock || b.uniqueId === c.outputBlock);
    if (block && !blockRegistry.getOutputs(block).includes(c.outputConnectionPoint)) {
      throw new Error(`Block ${c.outputBlock} has no output '${c.outputConnectionPoint}'`);
    }
  }
}

Type guard

function hasOutput(block, name) {
  return block?.outputs?.some((o) => o.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 an connection point named (.+)/);
  if (m) throw new Error(`Fix output endpoint: block '${m[1]}' has no output '${m[2]}'`);
  throw e;
}

Prevention

Check block class outputs for exact connection point names after refactors.
Re-export filters when block implementations change output names.
Write migrations renaming endpoints across versions.
Never copy connection entries between different block types.
Add endpoint validation as a pre-deserialization step in tooling.

When it happens

Trigger: connection.outputConnectionPoint names an output the block does not expose — renamed connection points between versions, a typo in hand-edited JSON, or a connection serialized from a block of a different type that has differently named outputs.

Common situations: Upgrading block implementations whose output names changed, hand-editing filter JSON, copying connection entries between blocks of different types, custom blocks whose outputs were refactored.

Related errors

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