@babylonjs/loaders 9.26.0 → 9.26.2

package/glTF/2.0/Extensions/KHR_interactivity/interactivityGraphParser.js

@@ -1,22 +1,12 @@
-import { getMappingForDeclaration, getMappingForFullOperationName } from "./declarationMapper.js";
+import { getMappingForDeclaration, getNoOpMappingForDeclaration, ParseDebugLogTemplate } from "./declarationMapper.js";
 import { Logger } from "@babylonjs/core/Misc/logger.js";
 import { RandomGUID } from "@babylonjs/core/Misc/guid.js";
-// eslint-disable-next-line @typescript-eslint/naming-convention
-export const gltfTypeToBabylonType = {
-    float: { length: 1, flowGraphType: "number" /* FlowGraphTypes.Number */, elementType: "number" },
-    bool: { length: 1, flowGraphType: "boolean" /* FlowGraphTypes.Boolean */, elementType: "boolean" },
-    float2: { length: 2, flowGraphType: "Vector2" /* FlowGraphTypes.Vector2 */, elementType: "number" },
-    float3: { length: 3, flowGraphType: "Vector3" /* FlowGraphTypes.Vector3 */, elementType: "number" },
-    float4: { length: 4, flowGraphType: "Vector4" /* FlowGraphTypes.Vector4 */, elementType: "number" },
-    float4x4: { length: 16, flowGraphType: "Matrix" /* FlowGraphTypes.Matrix */, elementType: "number" },
-    float2x2: { length: 4, flowGraphType: "Matrix2D" /* FlowGraphTypes.Matrix2D */, elementType: "number" },
-    float3x3: { length: 9, flowGraphType: "Matrix3D" /* FlowGraphTypes.Matrix3D */, elementType: "number" },
-    int: { length: 1, flowGraphType: "FlowGraphInteger" /* FlowGraphTypes.Integer */, elementType: "number" },
-    // KHR_interactivity opaque reference type. Represented as a JSON Pointer string
-    // (e.g. "/nodes/17/") that addresses a glTF object. The empty string is the
-    // canonical "null reference" sentinel used by the parser.
-    ref: { length: 1, flowGraphType: "string" /* FlowGraphTypes.String */, elementType: "string" },
-};
+import { CloneKHRInteractivityGraph, CreateEffectiveKHRInteractivityGraph, gltfTypeToBabylonType } from "./interactivityGraphModel.js";
+import { DelayReferencePrefix, EventReferencePrefix } from "./interactivityReferences.js";
+export { gltfTypeToBabylonType } from "./interactivityGraphModel.js";
+function _GetOwnMapping(mapping, key) {
+    return mapping && Object.prototype.hasOwnProperty.call(mapping, key) ? mapping[key] : undefined;
+}
 /**
  * Parses a KHR_interactivity graph definition (the raw glTF JSON object) into
  * the serialized FlowGraph form consumed by {@link ParseFlowGraphAsync}.
@@ -26,10 +16,12 @@ export const gltfTypeToBabylonType = {
  * {@link serializeToFlowGraph}.
  */
 export class InteractivityGraphToFlowGraphParser {
-    constructor(_interactivityGraph, _gltf, _animationTargetFps = 60) {
-        this._interactivityGraph = _interactivityGraph;
+    constructor(interactivityGraph, _gltf, _animationTargetFps = 60, _graphIndex = 0, _supportedExtensions, _declarationModels) {
         this._gltf = _gltf;
         this._animationTargetFps = _animationTargetFps;
+        this._graphIndex = _graphIndex;
+        this._supportedExtensions = _supportedExtensions;
+        this._declarationModels = _declarationModels;
         /**
          * Note - the graph should be rejected if the same type is defined twice.
          * We currently don't validate that.
@@ -47,6 +39,9 @@ export class InteractivityGraphToFlowGraphParser {
          * the last block) is not disturbed, then concatenated into the serialized graph.
          */
         this._insertedBlocks = [];
+        this._interactivityGraph = this._declarationModels
+            ? CreateEffectiveKHRInteractivityGraph(interactivityGraph, this._declarationModels, this._gltf.nodes?.length ?? 0)
+            : CloneKHRInteractivityGraph(interactivityGraph);
         // start with types
         this._parseTypes();
         // continue with declarations
@@ -55,6 +50,74 @@ export class InteractivityGraphToFlowGraphParser {
         this._parseEvents();
         this._parseNodes();
     }
+    get _strictValidation() {
+        return !!this._declarationModels;
+    }
+    _hasDefaultFlowInput(operation) {
+        if (operation === "flow/waitAll") {
+            return false;
+        }
+        return (operation.startsWith("flow/") ||
+            operation.startsWith("animation/") ||
+            operation === "pointer/set" ||
+            operation === "pointer/interpolate" ||
+            operation === "variable/set" ||
+            operation === "variable/interpolate" ||
+            operation === "event/send" ||
+            operation === "event/stopPropagation" ||
+            operation === "flow/log:BABYLON");
+    }
+    _getAllowedDynamicValueSockets(operation, node, direction) {
+        if ((operation === "debug/log" || operation === "flow/log:BABYLON") && direction === "input") {
+            const message = node.configuration?.[operation === "debug/log" ? "message" : "messageTemplate"]?.value?.[0];
+            return new Set(typeof message === "string" ? ParseDebugLogTemplate(message).sockets : []);
+        }
+        if ((operation === "event/send" && direction === "input") || (operation === "event/receive" && direction === "output")) {
+            const eventIndex = node.configuration?.event?.value?.[0];
+            if (typeof eventIndex === "number") {
+                return new Set(Object.keys(this._interactivityGraph.events?.[eventIndex]?.values ?? {}));
+            }
+        }
+        if (operation === "variable/set" && direction === "input") {
+            return new Set((node.configuration?.variables?.value ?? []).map(String));
+        }
+        if (operation === "math/switch" && direction === "input") {
+            return new Set((node.configuration?.cases?.value ?? []).map(String));
+        }
+        if ((operation === "pointer/get" || operation === "pointer/set" || operation === "pointer/interpolate") && direction === "input") {
+            const pointer = node.configuration?.pointer?.value?.[0];
+            if (typeof pointer === "string") {
+                return new Set(pointer
+                    .split("/")
+                    .filter((segment) => (segment.startsWith("[") && !segment.startsWith("[[")) || (segment.startsWith("{") && !segment.startsWith("{{")))
+                    .map((segment) => segment
+                    .substring(1, segment.length - 1)
+                    .replace(/~1/g, "/")
+                    .replace(/~0/g, "~")));
+            }
+        }
+        return undefined;
+    }
+    _getAllowedDynamicFlowSockets(node, mapping, direction) {
+        for (const [key, property] of Object.entries(mapping.configuration ?? {})) {
+            const generatesSockets = direction === "input" ? property.generatesInputFlowSockets : property.generatesOutputFlowSockets;
+            if (!generatesSockets) {
+                continue;
+            }
+            const configuredValues = node.configuration?.[key]?.value;
+            const validValues = configuredValues &&
+                configuredValues.length > 0 &&
+                (property.configurationType !== "int" || configuredValues.length === 1) &&
+                configuredValues.every((value) => typeof value === "number" && Number.isInteger(value) && value >= (property.minimum ?? -2147483648) && value <= (property.maximum ?? 2147483647));
+            const values = validValues ? configuredValues : property.defaultValue;
+            if (direction === "input") {
+                const count = Array.isArray(values) && typeof values[0] === "number" ? values[0] : 0;
+                return new Set(Array.from({ length: count }, (_, index) => String(index)));
+            }
+            return new Set(Array.isArray(values) ? values.map(String) : []);
+        }
+        return undefined;
+    }
     get arrays() {
         return {
             types: this._types,
@@ -76,10 +139,15 @@ export class InteractivityGraphToFlowGraphParser {
         if (!this._interactivityGraph.declarations) {
             return;
         }
-        for (const declaration of this._interactivityGraph.declarations) {
-            // make sure we have the mapping for this operation
-            const mapping = getMappingForDeclaration(declaration);
-            // mapping is defined, because we generate an empty mapping if it's not found
+        for (let index = 0; index < this._interactivityGraph.declarations.length; index++) {
+            const declaration = this._interactivityGraph.declarations[index];
+            const declarationModel = this._declarationModels?.[index];
+            const extensionEnabled = !declaration.extension || !this._supportedExtensions || this._supportedExtensions.has(declaration.extension);
+            const supportedMapping = declarationModel?.support === "unsupported-extension" ? undefined : extensionEnabled ? getMappingForDeclaration(declaration, false) : undefined;
+            if (!supportedMapping && !declaration.extension) {
+                throw new Error(`Unknown core KHR_interactivity operation "${declaration.op}".`);
+            }
+            const mapping = supportedMapping ?? (declaration.extension ? getNoOpMappingForDeclaration(declaration) : undefined);
             if (!mapping) {
                 Logger.Error(["No mapping found for declaration", declaration]);
                 throw new Error("Error parsing declarations");
@@ -87,6 +155,13 @@ export class InteractivityGraphToFlowGraphParser {
             this._mappings.push({
                 flowGraphMapping: mapping,
                 fullOperationName: declaration.extension ? declaration.op + ":" + declaration.extension : declaration.op,
+                declaration: declarationModel ??
+                    {
+                        index,
+                        operation: declaration.extension ? `${declaration.op}:${declaration.extension}` : declaration.op,
+                        support: supportedMapping ? (declaration.extension ? "extension" : "core") : "unsupported-extension",
+                        source: declaration,
+                    },
             });
         }
     }
@@ -107,12 +182,12 @@ export class InteractivityGraphToFlowGraphParser {
             throw new Error("Error parsing variables");
         }
         if (variable.value) {
-            if (variable.value.length !== type.length) {
+            if (this._interactivityGraph.types?.[variable.type]?.signature !== "custom" && variable.value.length !== type.length) {
                 Logger.Error(["Invalid value length for variable", variable, type]);
                 throw new Error("Error parsing variables");
             }
         }
-        const value = variable.value || [];
+        const value = variable.value ? variable.value.slice() : [];
         if (!value.length) {
             switch (type.flowGraphType) {
                 case "boolean" /* FlowGraphTypes.Boolean */:
@@ -137,13 +212,17 @@ export class InteractivityGraphToFlowGraphParser {
                 case "Vector4" /* FlowGraphTypes.Vector4 */:
                 case "Matrix2D" /* FlowGraphTypes.Matrix2D */:
                 case "Quaternion" /* FlowGraphTypes.Quaternion */:
-                    value.fill(NaN, 0, 4);
+                    value.push(NaN, NaN, NaN, NaN);
                     break;
                 case "Matrix" /* FlowGraphTypes.Matrix */:
-                    value.fill(NaN, 0, 16);
+                    for (let i = 0; i < 16; i++) {
+                        value.push(NaN);
+                    }
                     break;
                 case "Matrix3D" /* FlowGraphTypes.Matrix3D */:
-                    value.fill(NaN, 0, 9);
+                    for (let i = 0; i < 9; i++) {
+                        value.push(NaN);
+                    }
                     break;
                 default:
                     break;
@@ -153,15 +232,52 @@ export class InteractivityGraphToFlowGraphParser {
         if (type.elementType === "number" && typeof value[0] === "string") {
             value[0] = parseFloat(value[0]);
         }
+        else if (type.flowGraphType === "string" /* FlowGraphTypes.String */ && typeof value[0] === "string") {
+            value[0] = this._normalizeStaticReference(value[0]);
+        }
         return { type: type.flowGraphType, value: dataTransform ? dataTransform(value, this) : value };
     }
+    _normalizeStaticReference(reference) {
+        if (!reference || reference.startsWith(EventReferencePrefix) || reference.startsWith(DelayReferencePrefix)) {
+            return "";
+        }
+        if (!reference.startsWith("/")) {
+            return "";
+        }
+        let current = this._gltf;
+        for (const rawSegment of reference.substring(1).split("/")) {
+            const segment = rawSegment.replace(/~1/g, "/").replace(/~0/g, "~");
+            if (Array.isArray(current)) {
+                if (!/^(0|[1-9]\d*)$/.test(segment)) {
+                    return "";
+                }
+                current = current[parseInt(segment, 10)];
+            }
+            else if (current !== null && typeof current === "object" && Object.prototype.hasOwnProperty.call(current, segment)) {
+                current = current[segment];
+            }
+            else {
+                return "";
+            }
+        }
+        return current !== null && typeof current === "object" ? reference : "";
+    }
     _parseEvents() {
         if (!this._interactivityGraph.events) {
             return;
         }
+        const eventIds = new Set(this._interactivityGraph.events.flatMap((event) => (event.id === undefined ? [] : [event.id])));
+        const internalPrefix = `__babylon_khr_internal_${this._graphIndex}_`;
         for (const event of this._interactivityGraph.events) {
+            let generatedEventId;
+            if (event.id === undefined) {
+                do {
+                    generatedEventId = internalPrefix + this._internalEventsCounter++;
+                } while (eventIds.has(generatedEventId));
+                eventIds.add(generatedEventId);
+            }
             const converted = {
-                eventId: event.id || "internalEvent_" + this._internalEventsCounter++,
+                eventId: event.id ?? generatedEventId,
             };
             if (event.values) {
                 converted.eventData = Object.keys(event.values).map((key) => {
@@ -191,7 +307,8 @@ export class InteractivityGraphToFlowGraphParser {
         if (!this._interactivityGraph.nodes) {
             return;
         }
-        for (const node of this._interactivityGraph.nodes) {
+        for (let nodeIndex = 0; nodeIndex < this._interactivityGraph.nodes.length; nodeIndex++) {
+            const node = this._interactivityGraph.nodes[nodeIndex];
             // some validation
             if (typeof node.declaration !== "number") {
                 Logger.Error(["No declaration found for node", node]);
@@ -209,16 +326,20 @@ export class InteractivityGraphToFlowGraphParser {
                 }
             }
             const blocks = [];
+            if (mapping.declaration.support === "unsupported-extension") {
+                blocks.push(this._createUnsupportedExtensionBlock(node, nodeIndex, mapping));
+            }
             // create block(s) for this node using the mapping
-            for (const blockType of mapping.flowGraphMapping.blocks) {
-                const block = this._getEmptyBlock(blockType, mapping.fullOperationName);
+            for (let role = 0; role < mapping.flowGraphMapping.blocks.length; role++) {
+                const blockType = mapping.flowGraphMapping.blocks[role];
+                const block = this._getEmptyBlock(blockType, mapping.fullOperationName, nodeIndex, node.declaration, role);
                 this._parseNodeConfiguration(node, block, mapping.flowGraphMapping, blockType);
                 blocks.push(block);
             }
             this._nodes.push({ blocks, fullOperationName: mapping.fullOperationName });
         }
     }
-    _getEmptyBlock(className, type) {
+    _getEmptyBlock(className, type, nodeIndex, declarationIndex, role) {
         return {
             uniqueId: RandomGUID(),
             className,
@@ -228,8 +349,55 @@ export class InteractivityGraphToFlowGraphParser {
             signalOutputs: [],
             config: {},
             type,
-            metadata: {},
+            metadata: nodeIndex === undefined
+                ? {}
+                : {
+                    khrInteractivity: {
+                        graphIndex: this._graphIndex,
+                        nodeIndex,
+                        declarationIndex,
+                        operation: type,
+                        role: role ?? 0,
+                        sourcePath: `/extensions/KHR_interactivity/graphs/${this._graphIndex}/nodes/${nodeIndex}`,
+                    },
+                },
+        };
+    }
+    _createUnsupportedExtensionBlock(node, nodeIndex, mapping) {
+        const block = this._getEmptyBlock("KHR_interactivity/FlowGraphUnsupportedInteractivityBlock", mapping.fullOperationName, nodeIndex, node.declaration, 0);
+        const inputFlowSockets = new Set();
+        for (const sourceNode of this._interactivityGraph.nodes ?? []) {
+            for (const flow of Object.values(sourceNode.flows ?? {})) {
+                if (flow.node === nodeIndex) {
+                    inputFlowSockets.add(flow.socket ?? "in");
+                }
+            }
+        }
+        const toSockets = (sockets) => Object.entries(sockets ?? {}).map(([name, definition]) => ({
+            name,
+            type: this._types[definition.type]?.flowGraphType,
+            signature: this._interactivityGraph.types?.[definition.type]?.signature,
+        }));
+        block.config = {
+            operation: mapping.fullOperationName,
+            inputValueSockets: toSockets(mapping.declaration.source.inputValueSockets),
+            outputValueSockets: toSockets(mapping.declaration.source.outputValueSockets),
+            inputFlowSockets: Array.from(inputFlowSockets).sort(),
+            outputFlowSockets: Object.keys(node.flows ?? {}).sort(),
         };
+        for (const socket of block.config.inputValueSockets) {
+            block.dataInputs.push(this._createNewSocketConnection(socket.name));
+        }
+        for (const socket of block.config.outputValueSockets) {
+            block.dataOutputs.push(this._createNewSocketConnection(socket.name, true));
+        }
+        for (const socket of block.config.inputFlowSockets) {
+            block.signalInputs.push(this._createNewSocketConnection(socket));
+        }
+        for (const socket of block.config.outputFlowSockets) {
+            block.signalOutputs.push(this._createNewSocketConnection(socket, true));
+        }
+        return block;
     }
     _parseNodeConfiguration(node, block, nodeMapping, blockType) {
         const gltfConfiguration = node.configuration;
@@ -240,6 +408,12 @@ export class InteractivityGraphToFlowGraphParser {
                     throw new Error("Error parsing node configuration");
                 }
                 const propertyMapping = nodeMapping.configuration?.[key];
+                if (!propertyMapping && this._strictValidation) {
+                    continue;
+                }
+                if (propertyMapping?.validationOnly) {
+                    continue;
+                }
                 const belongsToBlock = propertyMapping && propertyMapping.toBlock ? propertyMapping.toBlock === blockType : nodeMapping.blocks.indexOf(blockType) === 0;
                 if (belongsToBlock) {
                     let value = propertyMapping?.defaultValue;
@@ -297,8 +471,31 @@ export class InteractivityGraphToFlowGraphParser {
             // connect the flows
             for (const flowKey of flowsKeys) {
                 const flow = flowsFromGLTF[flowKey];
-                const flowMapping = outputMapper.flowGraphMapping.outputs?.flows?.[flowKey];
-                const socketOutName = flowMapping?.name || flowKey;
+                let flowMapping = _GetOwnMapping(outputMapper.flowGraphMapping.outputs?.flows, flowKey);
+                if (this._strictValidation && flowMapping?.compatibilityOnly) {
+                    flowMapping = undefined;
+                }
+                let outputArrayMapping = false;
+                if (!flowMapping) {
+                    for (const key in outputMapper.flowGraphMapping.outputs?.flows) {
+                        if (key.startsWith("[") && key.endsWith("]")) {
+                            const wildcardMapping = outputMapper.flowGraphMapping.outputs?.flows?.[key];
+                            if (!this._strictValidation || !wildcardMapping?.compatibilityOnly) {
+                                outputArrayMapping = true;
+                                flowMapping = wildcardMapping;
+                                break;
+                            }
+                        }
+                    }
+                }
+                const allowedDynamicOutputs = outputArrayMapping ? this._getAllowedDynamicFlowSockets(gltfNode, outputMapper.flowGraphMapping, "output") : undefined;
+                if (this._strictValidation && allowedDynamicOutputs && !allowedDynamicOutputs.has(flowKey)) {
+                    flowMapping = undefined;
+                }
+                if (!flowMapping && !this._isUnsupportedExtensionBlock(flowGraphBlocks.blocks[0])) {
+                    continue;
+                }
+                const socketOutName = flowMapping ? (outputArrayMapping ? flowMapping.name.replace("$1", flowKey) : flowMapping.name) : flowKey;
                 // get the input node of this block
                 const inputNodeId = flow.node;
                 const nodeIn = this._nodes[inputNodeId];
@@ -314,24 +511,42 @@ export class InteractivityGraphToFlowGraphParser {
                     continue;
                 }
                 // create a serialized socket
-                const socketOut = this._createNewSocketConnection(socketOutName, true);
                 const block = (flowMapping && flowMapping.toBlock && flowGraphBlocks.blocks.find((b) => b.className === flowMapping.toBlock)) || flowGraphBlocks.blocks[0];
-                block.signalOutputs.push(socketOut);
+                const socketOut = block.signalOutputs.find((socket) => socket.name === socketOutName) ?? this._createNewSocketConnection(socketOutName, true);
+                if (!block.signalOutputs.includes(socketOut)) {
+                    block.signalOutputs.push(socketOut);
+                }
                 // get the mapper for the input node - in case it mapped to multiple blocks
-                const inputMapper = getMappingForFullOperationName(nodeIn.fullOperationName);
+                const inputMapper = this._mappings[this._interactivityGraph.nodes[inputNodeId].declaration]?.flowGraphMapping;
                 if (!inputMapper) {
                     Logger.Error(["No mapping found for input node", nodeIn]);
                     throw new Error("Error parsing node connections");
                 }
-                let flowInMapping = inputMapper.inputs?.flows?.[flow.socket || "in"];
+                let flowInMapping = _GetOwnMapping(inputMapper.inputs?.flows, flow.socket || "in");
+                if (this._strictValidation && flowInMapping?.compatibilityOnly) {
+                    flowInMapping = undefined;
+                }
                 let arrayMapping = false;
                 if (!flowInMapping) {
                     for (const key in inputMapper.inputs?.flows) {
                         if (key.startsWith("[") && key.endsWith("]")) {
-                            arrayMapping = true;
-                            flowInMapping = inputMapper.inputs?.flows?.[key];
+                            const wildcardMapping = inputMapper.inputs?.flows?.[key];
+                            if (!this._strictValidation || !wildcardMapping?.compatibilityOnly) {
+                                arrayMapping = true;
+                                flowInMapping = wildcardMapping;
+                            }
                         }
                     }
+                    const allowedDynamicInputs = arrayMapping ? this._getAllowedDynamicFlowSockets(this._interactivityGraph.nodes[inputNodeId], inputMapper, "input") : undefined;
+                    if (this._strictValidation && allowedDynamicInputs && !allowedDynamicInputs.has(flow.socket ?? "in")) {
+                        flowInMapping = undefined;
+                    }
+                    if (!flowInMapping && (flow.socket ?? "in") === "in" && this._hasDefaultFlowInput(nodeIn.fullOperationName)) {
+                        flowInMapping = { name: "in" };
+                    }
+                    if (!flowInMapping && !this._isUnsupportedExtensionBlock(nodeIn.blocks[0])) {
+                        continue;
+                    }
                 }
                 const nodeInSocketName = flowInMapping ? (arrayMapping ? flowInMapping.name.replace("$1", flow.socket || "") : flowInMapping.name) : flow.socket || "in";
                 const inputBlock = (flowInMapping && flowInMapping.toBlock && nodeIn.blocks.find((b) => b.className === flowInMapping.toBlock)) || nodeIn.blocks[0];
@@ -351,21 +566,33 @@ export class InteractivityGraphToFlowGraphParser {
             const valuesKeys = Object.keys(valuesFromGLTF);
             for (const valueKey of valuesKeys) {
                 const value = valuesFromGLTF[valueKey];
-                let valueMapping = outputMapper.flowGraphMapping.inputs?.values?.[valueKey];
+                let valueMapping = _GetOwnMapping(outputMapper.flowGraphMapping.inputs?.values, valueKey);
+                if (this._strictValidation && valueMapping?.compatibilityOnly) {
+                    valueMapping = undefined;
+                }
                 let arrayMapping = false;
                 if (!valueMapping) {
                     for (const key in outputMapper.flowGraphMapping.inputs?.values) {
                         if (key.startsWith("[") && key.endsWith("]")) {
-                            arrayMapping = true;
-                            valueMapping = outputMapper.flowGraphMapping.inputs?.values?.[key];
+                            const wildcardMapping = outputMapper.flowGraphMapping.inputs?.values?.[key];
+                            if (!this._strictValidation || !wildcardMapping?.compatibilityOnly) {
+                                arrayMapping = true;
+                                valueMapping = wildcardMapping;
+                            }
                         }
                     }
                 }
+                const allowedDynamicInputs = arrayMapping ? this._getAllowedDynamicValueSockets(outputMapper.fullOperationName, gltfNode, "input") : undefined;
+                if (!valueMapping || (allowedDynamicInputs && !allowedDynamicInputs.has(valueKey))) {
+                    continue;
+                }
                 const socketInName = valueMapping ? (arrayMapping ? valueMapping.name.replace("$1", valueKey) : valueMapping.name) : valueKey;
                 // create a serialized socket
-                const socketIn = this._createNewSocketConnection(socketInName);
                 const block = (valueMapping && valueMapping.toBlock && flowGraphBlocks.blocks.find((b) => b.className === valueMapping.toBlock)) || flowGraphBlocks.blocks[0];
-                block.dataInputs.push(socketIn);
+                const socketIn = block.dataInputs.find((socket) => socket.name === socketInName) ?? this._createNewSocketConnection(socketInName);
+                if (!block.dataInputs.includes(socketIn)) {
+                    block.dataInputs.push(socketIn);
+                }
                 // Captured before the connected branch below shadows `valueMapping`. When set and the
                 // value is supplied by a connection, the seconds→frames `dataTransformer` cannot run
                 // (it is parse-time only), so the raw connected value is scaled by a runtime multiply.
@@ -390,22 +617,34 @@ export class InteractivityGraphToFlowGraphParser {
                         Logger.Warn(`Dropping value connection from no-op node #${nodeOutId} (unsupported operation: ${nodeOut.fullOperationName}) into node #${i} "${valueKey}"; consumer will use type-default value`);
                         continue;
                     }
-                    const outputMapper = getMappingForFullOperationName(nodeOut.fullOperationName);
+                    const outputMapper = this._mappings[this._interactivityGraph.nodes[nodeOutId].declaration]?.flowGraphMapping;
                     if (!outputMapper) {
                         Logger.Error(["No mapping found for output socket reference", value]);
                         throw new Error("Error parsing node connections");
                     }
-                    let valueMapping = outputMapper.outputs?.values?.[nodeOutSocketName];
+                    let valueMapping = _GetOwnMapping(outputMapper.outputs?.values, nodeOutSocketName);
+                    if (this._strictValidation && valueMapping?.compatibilityOnly) {
+                        valueMapping = undefined;
+                    }
                     let arrayMapping = false;
                     // check if there is an array mapping defined
                     if (!valueMapping) {
                         // search for a value mapping that has an array mapping
                         for (const key in outputMapper.outputs?.values) {
                             if (key.startsWith("[") && key.endsWith("]")) {
-                                arrayMapping = true;
-                                valueMapping = outputMapper.outputs?.values?.[key];
+                                const wildcardMapping = outputMapper.outputs?.values?.[key];
+                                if (!this._strictValidation || !wildcardMapping?.compatibilityOnly) {
+                                    arrayMapping = true;
+                                    valueMapping = wildcardMapping;
+                                }
                             }
                         }
+                        const allowedDynamicOutputs = arrayMapping
+                            ? this._getAllowedDynamicValueSockets(nodeOut.fullOperationName, this._interactivityGraph.nodes[nodeOutId], "output")
+                            : undefined;
+                        if (!valueMapping || (allowedDynamicOutputs && !allowedDynamicOutputs.has(nodeOutSocketName))) {
+                            continue;
+                        }
                     }
                     const socketOutName = valueMapping ? (arrayMapping ? valueMapping.name.replace("$1", nodeOutSocketName) : valueMapping?.name) : nodeOutSocketName;
                     const outBlock = (valueMapping && valueMapping.toBlock && nodeOut.blocks.find((b) => b.className === valueMapping.toBlock)) || nodeOut.blocks[0];
@@ -417,7 +656,7 @@ export class InteractivityGraphToFlowGraphParser {
                     }
                     // connect the sockets
                     if (convertConnectedTimeToFrames) {
-                        this._connectWithSecondsToFramesConversion(context, socketOut, socketIn);
+                        this._connectWithSecondsToFramesConversion(context, socketOut, socketIn, i, gltfNode.declaration);
                     }
                     else {
                         socketIn.connectedPointIds.push(socketOut.uniqueId);
@@ -456,6 +695,9 @@ export class InteractivityGraphToFlowGraphParser {
             connectedPointIds: [],
         };
     }
+    _isUnsupportedExtensionBlock(block) {
+        return block?.className === "KHR_interactivity/FlowGraphUnsupportedInteractivityBlock";
+    }
     /**
      * Wires an upstream data output into a downstream data input through a runtime multiply block that
      * scales the value by the animation target fps. This converts a KHR animation time (seconds),
@@ -465,9 +707,11 @@ export class InteractivityGraphToFlowGraphParser {
      * @param context the serialized flow graph context that stores literal socket values
      * @param upstreamOutput the data output socket providing the time value (in seconds)
      * @param downstreamInput the data input socket that expects the time in frames
+     * @param nodeIndex source node receiving the converted value
+     * @param declarationIndex source declaration used by the receiving node
      */
-    _connectWithSecondsToFramesConversion(context, upstreamOutput, downstreamInput) {
-        const multiplyBlock = this._getEmptyBlock("FlowGraphMultiplyBlock" /* FlowGraphBlockNames.Multiply */, "FlowGraphMultiplyBlock" /* FlowGraphBlockNames.Multiply */);
+    _connectWithSecondsToFramesConversion(context, upstreamOutput, downstreamInput, nodeIndex, declarationIndex) {
+        const multiplyBlock = this._getEmptyBlock("FlowGraphMultiplyBlock" /* FlowGraphBlockNames.Multiply */, "FlowGraphMultiplyBlock" /* FlowGraphBlockNames.Multiply */, nodeIndex, declarationIndex, -1);
         // Scalar (float) multiply; matches how the `math/mul` mapping configures the block.
         multiplyBlock.config = { type: "number" /* FlowGraphTypes.Number */ };
         const inputA = this._createNewSocketConnection("a");
@@ -531,6 +775,7 @@ export class InteractivityGraphToFlowGraphParser {
         }
         const allBlocks = this._nodes.reduce((acc, val) => acc.concat(val.blocks), []).concat(this._insertedBlocks);
         return {
+            name: this._interactivityGraph.name ?? `Graph ${this._graphIndex + 1}`,
             rightHanded: true,
             allBlocks,
             executionContexts: [context],