@babylonjs/loaders 9.26.1 → 9.27.0

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

@@ -11,40 +11,125 @@ export function getMappingForFullOperationName(fullOperationName) {
     const [op, extension] = fullOperationName.split(":");
     return getMappingForDeclaration({ op, extension });
 }
-export function getMappingForDeclaration(declaration, returnNoOpIfNotAvailable = true) {
-    const mapping = declaration.extension ? gltfExtensionsToFlowGraphMapping[declaration.extension]?.[declaration.op] : gltfToFlowGraphMapping[declaration.op];
-    if (!mapping) {
-        Logger.Warn(`No mapping found for operation ${declaration.op} and extension ${declaration.extension || "KHR_interactivity"}`);
-        if (returnNoOpIfNotAvailable) {
-            const inputs = {};
-            const outputs = {
-                flows: {},
-            };
-            if (declaration.inputValueSockets) {
-                inputs.values = {};
-                for (const key in declaration.inputValueSockets) {
-                    inputs.values[key] = {
-                        name: key,
-                    };
-                }
+/**
+ * Returns whether a KHR operation accepts the conventional `in` flow socket when the registry
+ * does not need a renamed or dynamic input mapping.
+ * @param operation full KHR operation name
+ * @returns true when the operation accepts the conventional input flow
+ */
+export function HasDefaultInteractivityFlowInput(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");
+}
+/**
+ * Normalizes serialized or runtime FlowGraph custom-event configuration for inverse comparison.
+ * @param value serialized event-data entries or the runtime event-data dictionary
+ * @returns stable event-data entries sorted by socket id
+ */
+export function NormalizeInteractivityEventDataConfiguration(value) {
+    const normalizeValue = (entry) => {
+        if (Array.isArray(entry)) {
+            return entry.slice();
+        }
+        if (entry !== null && typeof entry === "object") {
+            if (typeof entry.asArray === "function") {
+                return Array.from(entry.asArray());
             }
-            if (declaration.outputValueSockets) {
-                outputs.values = {};
-                Object.keys(declaration.outputValueSockets).forEach((key) => {
-                    outputs.values[key] = {
-                        name: key,
-                    };
-                });
+            if (Object.prototype.hasOwnProperty.call(entry, "value")) {
+                const nested = entry.value;
+                return Array.isArray(nested) ? nested.slice() : [nested];
+            }
+        }
+        return [entry];
+    };
+    if (Array.isArray(value)) {
+        return value
+            .filter((entry) => entry !== null && typeof entry === "object" && typeof entry.id === "string")
+            .map((entry) => ({
+            id: entry.id,
+            type: entry.type,
+            ...(entry.value === undefined ? {} : { value: normalizeValue(entry.value) }),
+        }))
+            .sort((left, right) => left.id.localeCompare(right.id));
+    }
+    if (value !== null && typeof value === "object") {
+        return Object.entries(value)
+            .map(([id, entry]) => {
+            if (entry === null || typeof entry !== "object") {
+                return { id, malformed: true };
             }
+            const definition = entry;
             return {
-                blocks: [], // no blocks, just mapping
-                inputs,
-                outputs,
+                id,
+                type: typeof definition.type === "string" ? definition.type : definition.type?.typeName,
+                ...(definition.value === undefined ? {} : { value: normalizeValue(definition.value) }),
             };
+        })
+            .sort((left, right) => left.id.localeCompare(right.id));
+    }
+    return value;
+}
+export function getMappingForDeclaration(declaration, returnNoOpIfNotAvailable = true) {
+    const extensionMappings = declaration.extension ? _GetOwnRegistryValue(gltfExtensionsToFlowGraphMapping, declaration.extension) : undefined;
+    const mapping = declaration.extension ? _GetOwnRegistryValue(extensionMappings, declaration.op) : _GetOwnRegistryValue(gltfToFlowGraphMapping, declaration.op);
+    if (!mapping) {
+        if (returnNoOpIfNotAvailable) {
+            Logger.Warn(`No mapping found for operation ${declaration.op} and extension ${declaration.extension || "KHR_interactivity"}`);
+            return getNoOpMappingForDeclaration(declaration);
         }
     }
     return mapping;
 }
+/**
+ * Creates the typed no-op mapping required for an unsupported extension declaration.
+ * @param declaration unsupported extension declaration
+ * @returns a mapping that preserves the declared value sockets
+ */
+export function getNoOpMappingForDeclaration(declaration) {
+    const inputs = {};
+    const outputs = {
+        flows: {},
+    };
+    if (declaration.inputValueSockets) {
+        inputs.values = Object.create(null);
+        for (const key in declaration.inputValueSockets) {
+            if (Object.prototype.hasOwnProperty.call(declaration.inputValueSockets, key)) {
+                Object.defineProperty(inputs.values, key, {
+                    configurable: true,
+                    enumerable: true,
+                    value: { name: key },
+                    writable: true,
+                });
+            }
+        }
+    }
+    if (declaration.outputValueSockets) {
+        outputs.values = Object.create(null);
+        Object.keys(declaration.outputValueSockets).forEach((key) => {
+            Object.defineProperty(outputs.values, key, {
+                configurable: true,
+                enumerable: true,
+                value: { name: key },
+                writable: true,
+            });
+        });
+    }
+    return {
+        blocks: [],
+        inputs,
+        outputs,
+    };
+}
 /**
  * This function will add new mapping to glTF interactivity.
  * Other extensions can define new types of blocks, this is the way to let interactivity know how to parse them.
@@ -53,8 +138,47 @@ export function getMappingForDeclaration(declaration, returnNoOpIfNotAvailable =
  * @param mapping The mapping object. See documentation or examples below.
  */
 export function addNewInteractivityFlowGraphMapping(key, extension, mapping) {
-    gltfExtensionsToFlowGraphMapping[extension] || (gltfExtensionsToFlowGraphMapping[extension] = {});
-    gltfExtensionsToFlowGraphMapping[extension][key] = mapping;
+    let extensionMappings = _GetOwnRegistryValue(gltfExtensionsToFlowGraphMapping, extension);
+    if (!extensionMappings) {
+        extensionMappings = Object.create(null);
+        Object.defineProperty(gltfExtensionsToFlowGraphMapping, extension, {
+            configurable: true,
+            enumerable: true,
+            value: extensionMappings,
+            writable: true,
+        });
+    }
+    Object.defineProperty(extensionMappings, key, {
+        configurable: true,
+        enumerable: true,
+        value: mapping,
+        writable: true,
+    });
+}
+function _GetOwnRegistryValue(registry, key) {
+    return registry && Object.prototype.hasOwnProperty.call(registry, key) ? registry[key] : undefined;
+}
+/**
+ * Gets a deterministic snapshot of the registered KHR_interactivity operation mappings.
+ * Export analysis uses this same registry as import lowering so the two directions cannot
+ * independently drift.
+ * @returns registered mappings sorted by extension and operation
+ */
+export function GetInteractivityOperationRegistry() {
+    const entries = Object.keys(gltfToFlowGraphMapping).map((op) => ({
+        op,
+        mapping: gltfToFlowGraphMapping[op],
+    }));
+    for (const extension of Object.keys(gltfExtensionsToFlowGraphMapping).sort()) {
+        for (const op of Object.keys(gltfExtensionsToFlowGraphMapping[extension]).sort()) {
+            entries.push({
+                op,
+                extension,
+                mapping: gltfExtensionsToFlowGraphMapping[extension][op],
+            });
+        }
+    }
+    return entries.sort((left, right) => `${left.extension ?? ""}:${left.op}`.localeCompare(`${right.extension ?? ""}:${right.op}`));
 }
 const gltfExtensionsToFlowGraphMapping = {
     /**
@@ -74,6 +198,12 @@ const gltfExtensionsToFlowGraphMapping = {
             inputs: {
                 values: {
                     message: { name: "message" },
+                    "[segment]": { name: "$1", compatibilityOnly: true },
+                },
+            },
+            outputs: {
+                flows: {
+                    out: { name: "out", compatibilityOnly: true },
                 },
             },
         },
@@ -98,6 +228,7 @@ const gltfToFlowGraphMapping = {
         inputs: {},
         outputs: {
             values: {
+                timeSinceStart: { name: "timeSinceStart", gltfType: "number" },
                 timeSinceLastTick: { name: "deltaTime", gltfType: "number" /*, dataTransformer: (time: number) => time / 1000*/ },
                 // KHR_interactivity `ref event` output (the event reference).
                 event: { name: "event" },
@@ -109,11 +240,30 @@ const gltfToFlowGraphMapping = {
     },
     "event/send": {
         blocks: ["FlowGraphSendCustomEventBlock" /* FlowGraphBlockNames.SendCustomEvent */],
+        configuration: {
+            event: {
+                name: "eventId",
+                configurationType: "int",
+                required: true,
+                indexSource: "events",
+                validationOnly: true,
+            },
+        },
+        inputs: {
+            values: {
+                "[segment]": { name: "$1" },
+            },
+        },
+        outputs: {
+            flows: {
+                out: { name: "out" },
+            },
+        },
         extraProcessor(gltfBlock, declaration, _mapping, parser, serializedObjects) {
             // set eventId and eventData. The configuration object of the glTF should have a single object.
             // validate that we are running it on the right block.
-            if (declaration.op !== "event/send" || !gltfBlock.configuration || Object.keys(gltfBlock.configuration).length !== 1) {
-                throw new Error("Receive event should have a single configuration object, the event itself");
+            if (declaration.op !== "event/send" || !gltfBlock.configuration?.event) {
+                throw new Error("Send event should have a single configuration object, the event itself");
             }
             const eventConfiguration = gltfBlock.configuration["event"];
             const eventId = eventConfiguration.value?.[0];
@@ -130,10 +280,20 @@ const gltfToFlowGraphMapping = {
     },
     "event/receive": {
         blocks: ["FlowGraphReceiveCustomEventBlock" /* FlowGraphBlockNames.ReceiveCustomEvent */],
+        configuration: {
+            event: {
+                name: "eventId",
+                configurationType: "int",
+                required: true,
+                indexSource: "events",
+                validationOnly: true,
+            },
+        },
         outputs: {
             values: {
                 // KHR_interactivity `ref event` output (the event reference).
                 event: { name: "event" },
+                "[segment]": { name: "$1" },
             },
             flows: {
                 out: { name: "done" },
@@ -164,7 +324,7 @@ const gltfToFlowGraphMapping = {
         extraProcessor(gltfBlock, declaration, _mapping, parser, serializedObjects) {
             // set eventId and eventData. The configuration object of the glTF should have a single object.
             // validate that we are running it on the right block.
-            if (declaration.op !== "event/receive" || !gltfBlock.configuration || Object.keys(gltfBlock.configuration).length !== 1) {
+            if (declaration.op !== "event/receive" || !gltfBlock.configuration?.event) {
                 throw new Error("Receive event should have a single configuration object, the event itself");
             }
             const eventConfiguration = gltfBlock.configuration["event"];
@@ -197,11 +357,11 @@ const gltfToFlowGraphMapping = {
             },
         },
     },
-    "math/E": getSimpleInputMapping("FlowGraphEBlock" /* FlowGraphBlockNames.E */),
-    "math/Pi": getSimpleInputMapping("FlowGraphPIBlock" /* FlowGraphBlockNames.PI */),
-    "math/Tau": getSimpleInputMapping("FlowGraphTauBlock" /* FlowGraphBlockNames.Tau */),
-    "math/Inf": getSimpleInputMapping("FlowGraphInfBlock" /* FlowGraphBlockNames.Inf */),
-    "math/NaN": getSimpleInputMapping("FlowGraphNaNBlock" /* FlowGraphBlockNames.NaN */),
+    "math/E": getSimpleInputMapping("FlowGraphEBlock" /* FlowGraphBlockNames.E */, []),
+    "math/Pi": getSimpleInputMapping("FlowGraphPIBlock" /* FlowGraphBlockNames.PI */, []),
+    "math/Tau": getSimpleInputMapping("FlowGraphTauBlock" /* FlowGraphBlockNames.Tau */, []),
+    "math/Inf": getSimpleInputMapping("FlowGraphInfBlock" /* FlowGraphBlockNames.Inf */, []),
+    "math/NaN": getSimpleInputMapping("FlowGraphNaNBlock" /* FlowGraphBlockNames.NaN */, []),
     "math/abs": getSimpleInputMapping("FlowGraphAbsBlock" /* FlowGraphBlockNames.Abs */),
     "math/sign": getSimpleInputMapping("FlowGraphSignBlock" /* FlowGraphBlockNames.Sign */),
     "math/trunc": getSimpleInputMapping("FlowGraphTruncBlock" /* FlowGraphBlockNames.Trunc */),
@@ -217,7 +377,7 @@ const gltfToFlowGraphMapping = {
         },
         outputs: {
             values: {
-                value: { name: "value" },
+                value: { name: "value", typeSourceInput: "a" },
             },
         },
         extraProcessor(gltfBlock, declaration, _mapping, parser, serializedObjects) {
@@ -234,6 +394,17 @@ const gltfToFlowGraphMapping = {
     "math/sub": getSimpleInputMapping("FlowGraphSubtractBlock" /* FlowGraphBlockNames.Subtract */, ["a", "b"], true),
     "math/mul": {
         blocks: ["FlowGraphMultiplyBlock" /* FlowGraphBlockNames.Multiply */],
+        inputs: {
+            values: {
+                a: { name: "a" },
+                b: { name: "b" },
+            },
+        },
+        outputs: {
+            values: {
+                value: { name: "value", typeSourceInput: "a" },
+            },
+        },
         extraProcessor(_gltfBlock, _declaration, _mapping, _parser, serializedObjects) {
             var _a;
             // configure it to work the way glTF specifies
@@ -339,7 +510,7 @@ const gltfToFlowGraphMapping = {
         },
         outputs: {
             values: {
-                value: { name: "output" },
+                value: { name: "output", typeSourceInput: "a" },
             },
         },
     },
@@ -347,7 +518,7 @@ const gltfToFlowGraphMapping = {
         blocks: ["FlowGraphRandomBlock" /* FlowGraphBlockNames.Random */],
         outputs: {
             values: {
-                value: { name: "value" },
+                value: { name: "value", gltfType: "float" },
             },
         },
     },
@@ -372,7 +543,15 @@ const gltfToFlowGraphMapping = {
     "math/cbrt": getSimpleInputMapping("FlowGraphCubeRootBlock" /* FlowGraphBlockNames.CubeRoot */),
     "math/pow": getSimpleInputMapping("FlowGraphPowerBlock" /* FlowGraphBlockNames.Power */, ["a", "b"]),
     "math/length": getSimpleInputMapping("FlowGraphLengthBlock" /* FlowGraphBlockNames.Length */),
-    "math/normalize": getSimpleInputMapping("FlowGraphNormalizeBlock" /* FlowGraphBlockNames.Normalize */),
+    "math/normalize": {
+        ...getSimpleInputMapping("FlowGraphNormalizeBlock" /* FlowGraphBlockNames.Normalize */),
+        outputs: {
+            values: {
+                value: { name: "value", typeSourceInput: "a" },
+                isValid: { name: "isValid", gltfType: "bool" },
+            },
+        },
+    },
     "math/dot": getSimpleInputMapping("FlowGraphDotBlock" /* FlowGraphBlockNames.Dot */, ["a", "b"]),
     "math/cross": getSimpleInputMapping("FlowGraphCrossBlock" /* FlowGraphBlockNames.Cross */, ["a", "b"]),
     "math/rotate2D": {
@@ -385,7 +564,7 @@ const gltfToFlowGraphMapping = {
         },
         outputs: {
             values: {
-                value: { name: "value" },
+                value: { name: "value", typeSourceInput: "a" },
             },
         },
     },
@@ -399,7 +578,7 @@ const gltfToFlowGraphMapping = {
         },
         outputs: {
             values: {
-                value: { name: "value" },
+                value: { name: "value", typeSourceInput: "a" },
             },
         },
     },
@@ -414,7 +593,7 @@ const gltfToFlowGraphMapping = {
         },
         outputs: {
             values: {
-                value: { name: "value" },
+                value: { name: "value", typeSourceInput: "a" },
             },
         },
     },
@@ -428,7 +607,7 @@ const gltfToFlowGraphMapping = {
         },
         outputs: {
             values: {
-                value: { name: "value" },
+                value: { name: "value", gltfType: "float2" },
             },
         },
     },
@@ -443,7 +622,7 @@ const gltfToFlowGraphMapping = {
         },
         outputs: {
             values: {
-                value: { name: "value" },
+                value: { name: "value", gltfType: "float3" },
             },
         },
     },
@@ -459,7 +638,7 @@ const gltfToFlowGraphMapping = {
         },
         outputs: {
             values: {
-                value: { name: "value" },
+                value: { name: "value", gltfType: "float4" },
             },
         },
     },
@@ -511,7 +690,15 @@ const gltfToFlowGraphMapping = {
     },
     "math/transpose": getSimpleInputMapping("FlowGraphTransposeBlock" /* FlowGraphBlockNames.Transpose */),
     "math/determinant": getSimpleInputMapping("FlowGraphDeterminantBlock" /* FlowGraphBlockNames.Determinant */),
-    "math/inverse": getSimpleInputMapping("FlowGraphInvertMatrixBlock" /* FlowGraphBlockNames.InvertMatrix */),
+    "math/inverse": {
+        ...getSimpleInputMapping("FlowGraphInvertMatrixBlock" /* FlowGraphBlockNames.InvertMatrix */),
+        outputs: {
+            values: {
+                value: { name: "value", typeSourceInput: "a" },
+                isValid: { name: "isValid", gltfType: "bool" },
+            },
+        },
+    },
     "math/matMul": getSimpleInputMapping("FlowGraphMatrixMultiplicationBlock" /* FlowGraphBlockNames.MatrixMultiplication */, ["a", "b"]),
     "math/matCompose": {
         blocks: ["FlowGraphMatrixCompose" /* FlowGraphBlockNames.MatrixCompose */],
@@ -524,7 +711,7 @@ const gltfToFlowGraphMapping = {
         },
         outputs: {
             values: {
-                value: { name: "value" },
+                value: { name: "value", gltfType: "float4x4" },
             },
         },
         extraProcessor(_gltfBlock, _declaration, _mapping, _parser, serializedObjects, context) {
@@ -552,6 +739,8 @@ const gltfToFlowGraphMapping = {
                 translation: { name: "position" },
                 rotation: { name: "rotationQuaternion" },
                 scale: { name: "scaling" },
+                scaling: { name: "scaling", compatibilityOnly: true },
+                isValid: { name: "isValid", compatibilityOnly: true },
             },
         },
         extraProcessor(_gltfBlock, _declaration, _mapping, _parser, serializedObjects) {
@@ -570,13 +759,13 @@ const gltfToFlowGraphMapping = {
         blocks: ["FlowGraphMultiplyBlock" /* FlowGraphBlockNames.Multiply */],
         inputs: {
             values: {
-                a: { name: "a", gltfType: "vector4" },
-                b: { name: "b", gltfType: "vector4" },
+                a: { name: "a", gltfType: "float4" },
+                b: { name: "b", gltfType: "float4" },
             },
         },
         outputs: {
             values: {
-                value: { name: "value" },
+                value: { name: "value", gltfType: "float4" },
             },
         },
         extraProcessor(_gltfBlock, _declaration, _mapping, _parser, serializedObjects) {
@@ -597,12 +786,32 @@ const gltfToFlowGraphMapping = {
         },
         outputs: {
             values: {
-                value: { name: "value" },
+                value: { name: "value", gltfType: "float4" },
+            },
+        },
+    },
+    "math/quatToAxisAngle": {
+        blocks: ["FlowGraphAxisAngleFromQuaternionBlock" /* FlowGraphBlockNames.AxisAngleFromQuaternion */],
+        inputs: {
+            values: {
+                a: { name: "a", gltfType: "float4" },
+            },
+        },
+        outputs: {
+            values: {
+                axis: { name: "axis", gltfType: "float3" },
+                angle: { name: "angle", gltfType: "float" },
+            },
+        },
+    },
+    "math/quatFromDirections": {
+        ...getSimpleInputMapping("FlowGraphQuaternionFromDirectionsBlock" /* FlowGraphBlockNames.QuaternionFromDirections */, ["a", "b"]),
+        outputs: {
+            values: {
+                value: { name: "value", gltfType: "float4" },
             },
         },
     },
-    "math/quatToAxisAngle": getSimpleInputMapping("FlowGraphAxisAngleFromQuaternionBlock" /* FlowGraphBlockNames.AxisAngleFromQuaternion */, ["a"]),
-    "math/quatFromDirections": getSimpleInputMapping("FlowGraphQuaternionFromDirectionsBlock" /* FlowGraphBlockNames.QuaternionFromDirections */, ["a", "b"]),
     "math/quatFromUpForward": {
         blocks: ["FlowGraphQuaternionFromUpForwardBlock" /* FlowGraphBlockNames.QuaternionFromUpForward */],
         inputs: {
@@ -613,7 +822,7 @@ const gltfToFlowGraphMapping = {
         },
         outputs: {
             values: {
-                value: { name: "value" },
+                value: { name: "value", gltfType: "float4" },
             },
         },
     },
@@ -622,7 +831,13 @@ const gltfToFlowGraphMapping = {
     "math/quatFromAngles": {
         blocks: ["FlowGraphQuaternionFromAnglesBlock" /* FlowGraphBlockNames.QuaternionFromAngles */],
         configuration: {
-            order: { name: "order", defaultValue: ["yxz"] },
+            order: {
+                name: "order",
+                defaultValue: ["yxz"],
+                configurationType: "string",
+                invalidUsesDefault: true,
+                allowedValues: ["xyz", "xzy", "yxz", "yzx", "zxy", "zyx"],
+            },
         },
         inputs: {
             values: {
@@ -633,7 +848,7 @@ const gltfToFlowGraphMapping = {
         },
         outputs: {
             values: {
-                value: { name: "value" },
+                value: { name: "value", gltfType: "float4" },
             },
         },
     },
@@ -649,7 +864,7 @@ const gltfToFlowGraphMapping = {
         },
         outputs: {
             values: {
-                value: { name: "value" },
+                value: { name: "value", gltfType: "float2x2" },
             },
         },
     },
@@ -686,7 +901,7 @@ const gltfToFlowGraphMapping = {
         },
         outputs: {
             values: {
-                value: { name: "value" },
+                value: { name: "value", gltfType: "float3x3" },
             },
         },
     },
@@ -735,7 +950,7 @@ const gltfToFlowGraphMapping = {
         },
         outputs: {
             values: {
-                value: { name: "value" },
+                value: { name: "value", gltfType: "float4x4" },
             },
         },
     },
@@ -777,7 +992,7 @@ const gltfToFlowGraphMapping = {
         },
         outputs: {
             values: {
-                value: { name: "value" },
+                value: { name: "value", typeSourceInput: "a" },
             },
         },
         extraProcessor(_gltfBlock, _declaration, _mapping, _parser, serializedObjects, context) {
@@ -800,7 +1015,7 @@ const gltfToFlowGraphMapping = {
         },
         outputs: {
             values: {
-                value: { name: "value" },
+                value: { name: "value", typeSourceInput: "a" },
             },
         },
         extraProcessor(_gltfBlock, _declaration, _mapping, _parser, serializedObjects, context) {
@@ -825,7 +1040,7 @@ const gltfToFlowGraphMapping = {
         },
         outputs: {
             values: {
-                value: { name: "value" },
+                value: { name: "value", typeSourceInput: "a" },
             },
         },
         extraProcessor(_gltfBlock, _declaration, _mapping, _parser, serializedObjects, context) {
@@ -850,7 +1065,7 @@ const gltfToFlowGraphMapping = {
         },
         outputs: {
             values: {
-                value: { name: "value" },
+                value: { name: "value", typeSourceInput: "a" },
             },
         },
         extraProcessor(_gltfBlock, _declaration, _mapping, _parser, serializedObjects, context) {
@@ -881,6 +1096,11 @@ const gltfToFlowGraphMapping = {
     // flows
     "flow/sequence": {
         blocks: ["FlowGraphSequenceBlock" /* FlowGraphBlockNames.Sequence */],
+        outputs: {
+            flows: {
+                "[segment]": { name: "$1" },
+            },
+        },
         extraProcessor(gltfBlock, _declaration, _mapping, _arrays, serializedObjects) {
             const serializedObject = serializedObjects[0];
             serializedObject.config || (serializedObject.config = {});
@@ -893,6 +1113,11 @@ const gltfToFlowGraphMapping = {
     },
     "flow/branch": {
         blocks: ["FlowGraphBranchBlock" /* FlowGraphBlockNames.Branch */],
+        inputs: {
+            values: {
+                condition: { name: "condition", gltfType: "boolean" },
+            },
+        },
         outputs: {
             flows: {
                 true: { name: "onTrue" },
@@ -903,7 +1128,16 @@ const gltfToFlowGraphMapping = {
     "flow/switch": {
         blocks: ["FlowGraphSwitchBlock" /* FlowGraphBlockNames.Switch */],
         configuration: {
-            cases: { name: "cases", isArray: true, inOptions: true, defaultValue: [] },
+            cases: {
+                name: "cases",
+                isArray: true,
+                inOptions: true,
+                defaultValue: [],
+                configurationType: "int[]",
+                invalidUsesDefault: true,
+                generatesOutputFlowSockets: true,
+                uniqueValues: true,
+            },
         },
         inputs: {
             values: {
@@ -911,13 +1145,16 @@ const gltfToFlowGraphMapping = {
                 default: { name: "default" },
             },
         },
+        outputs: {
+            flows: {
+                default: { name: "default" },
+                "[segment]": { name: "$1" },
+            },
+        },
         validation(gltfBlock) {
             const cases = gltfBlock.configuration?.cases;
             if (cases && cases.value) {
-                const onlyIntegers = cases.value.every((caseValue) => {
-                    // case value should be an integer. Since Number.isInteger(1.0) is true, we need to check if toString has only digits.
-                    return typeof caseValue === "number" && /^-?\d+$/.test(caseValue.toString());
-                });
+                const onlyIntegers = cases.value.every((caseValue) => typeof caseValue === "number" && Number.isInteger(caseValue) && caseValue >= -2147483648 && caseValue <= 2147483647);
                 if (!onlyIntegers) {
                     Logger.Warn("Switch cases should be integers. Using empty array instead.");
                     cases.value = [];
@@ -945,21 +1182,34 @@ const gltfToFlowGraphMapping = {
     },
     "flow/while": {
         blocks: ["FlowGraphWhileLoopBlock" /* FlowGraphBlockNames.WhileLoop */],
+        inputs: {
+            values: {
+                condition: { name: "condition", gltfType: "boolean" },
+            },
+        },
         outputs: {
             flows: {
                 loopBody: { name: "executionFlow" },
+                completed: { name: "completed" },
             },
         },
     },
     "flow/for": {
         blocks: ["FlowGraphForLoopBlock" /* FlowGraphBlockNames.ForLoop */],
         configuration: {
-            initialIndex: { name: "initialIndex", gltfType: "number", inOptions: true, defaultValue: 0 },
+            initialIndex: {
+                name: "initialIndex",
+                gltfType: "int",
+                inOptions: true,
+                defaultValue: 0,
+                configurationType: "int",
+                invalidUsesDefault: true,
+            },
         },
         inputs: {
             values: {
-                startIndex: { name: "startIndex", gltfType: "number" },
-                endIndex: { name: "endIndex", gltfType: "number" },
+                startIndex: { name: "startIndex", gltfType: "int" },
+                endIndex: { name: "endIndex", gltfType: "int" },
             },
         },
         outputs: {
@@ -968,6 +1218,7 @@ const gltfToFlowGraphMapping = {
             },
             flows: {
                 loopBody: { name: "executionFlow" },
+                completed: { name: "completed" },
             },
         },
         extraProcessor(_gltfBlock, _declaration, _mapping, _arrays, serializedObjects) {
@@ -987,10 +1238,16 @@ const gltfToFlowGraphMapping = {
         configuration: {},
         inputs: {
             values: {
-                n: { name: "maxExecutions", gltfType: "number" },
+                n: { name: "maxExecutions", gltfType: "int" },
+            },
+            flows: {
+                reset: { name: "reset" },
             },
         },
         outputs: {
+            flows: {
+                out: { name: "out" },
+            },
             values: {
                 currentCount: { name: "executionCount" },
             },
@@ -998,17 +1255,46 @@ const gltfToFlowGraphMapping = {
     },
     "flow/multiGate": {
         blocks: ["FlowGraphMultiGateBlock" /* FlowGraphBlockNames.MultiGate */],
+        inputs: {
+            flows: {
+                reset: { name: "reset" },
+            },
+        },
         configuration: {
-            isRandom: { name: "isRandom", gltfType: "boolean", inOptions: true, defaultValue: false },
-            isLoop: { name: "isLoop", gltfType: "boolean", inOptions: true, defaultValue: false },
+            isRandom: {
+                name: "isRandom",
+                gltfType: "boolean",
+                inOptions: true,
+                defaultValue: false,
+                configurationType: "bool",
+                invalidUsesDefault: true,
+                configurationGroup: "multiGate",
+            },
+            isLoop: {
+                name: "isLoop",
+                gltfType: "boolean",
+                inOptions: true,
+                defaultValue: false,
+                configurationType: "bool",
+                invalidUsesDefault: true,
+                configurationGroup: "multiGate",
+            },
+        },
+        outputs: {
+            flows: {
+                "[segment]": { name: "$1" },
+            },
+            values: {
+                lastIndex: { name: "lastIndex", gltfType: "int" },
+            },
         },
         extraProcessor(gltfBlock, declaration, _mapping, _arrays, serializedObjects) {
-            if (declaration.op !== "flow/multiGate" || !gltfBlock.flows || Object.keys(gltfBlock.flows).length === 0) {
-                throw new Error("MultiGate should have a single configuration object, the number of output flows");
+            if (declaration.op !== "flow/multiGate") {
+                throw new Error("Invalid operation for MultiGate mapping");
             }
             const serializedObject = serializedObjects[0];
             serializedObject.config || (serializedObject.config = {});
-            serializedObject.config.outputSignalCount = Object.keys(gltfBlock.flows).length;
+            serializedObject.config.outputSignalCount = Object.keys(gltfBlock.flows ?? {}).length;
             serializedObject.signalOutputs.forEach((output, index) => {
                 output.name = "out_" + index;
             });
@@ -1018,7 +1304,17 @@ const gltfToFlowGraphMapping = {
     "flow/waitAll": {
         blocks: ["FlowGraphWaitAllBlock" /* FlowGraphBlockNames.WaitAll */],
         configuration: {
-            inputFlows: { name: "inputSignalCount", gltfType: "number", inOptions: true, defaultValue: 0 },
+            inputFlows: {
+                name: "inputSignalCount",
+                gltfType: "number",
+                inOptions: true,
+                defaultValue: [0],
+                configurationType: "int",
+                invalidUsesDefault: true,
+                minimum: 0,
+                maximum: 64,
+                generatesInputFlowSockets: true,
+            },
         },
         inputs: {
             flows: {
@@ -1026,9 +1322,19 @@ const gltfToFlowGraphMapping = {
                 "[segment]": { name: "in_$1" },
             },
         },
+        outputs: {
+            flows: {
+                out: { name: "out" },
+                completed: { name: "completed" },
+            },
+            values: {
+                remainingInputs: { name: "remainingInputs", gltfType: "int" },
+            },
+        },
         validation(gltfBlock) {
-            // check that the configuration value is an integer
-            if (typeof gltfBlock.configuration?.inputFlows?.value?.[0] !== "number") {
+            const inputFlowsConfiguration = gltfBlock.configuration?.inputFlows?.value;
+            const inputFlows = inputFlowsConfiguration?.[0];
+            if (inputFlowsConfiguration?.length !== 1 || typeof inputFlows !== "number" || !Number.isInteger(inputFlows) || inputFlows < 0 || inputFlows > 64) {
                 gltfBlock.configuration = gltfBlock.configuration || {
                     inputFlows: { value: [0] },
                 };
@@ -1039,22 +1345,45 @@ const gltfToFlowGraphMapping = {
     },
     "flow/throttle": {
         blocks: ["FlowGraphThrottleBlock" /* FlowGraphBlockNames.Throttle */],
+        inputs: {
+            values: {
+                duration: { name: "duration", gltfType: "number" },
+            },
+            flows: {
+                reset: { name: "reset" },
+            },
+        },
         outputs: {
             flows: {
+                out: { name: "out" },
                 err: { name: "error" },
             },
+            values: {
+                lastRemainingTime: { name: "lastRemainingTime", gltfType: "number" },
+            },
         },
     },
     "flow/setDelay": {
         blocks: ["FlowGraphSetDelayBlock" /* FlowGraphBlockNames.SetDelay */],
+        inputs: {
+            values: {
+                duration: { name: "duration", gltfType: "number" },
+            },
+            flows: {
+                cancel: { name: "cancel" },
+            },
+        },
         outputs: {
             flows: {
+                out: { name: "out" },
                 err: { name: "error" },
+                done: { name: "done" },
             },
             values: {
                 // New spec renames this output to `lastDelay` (ref). Internally we still produce a
                 // FlowGraphInteger; the index is unique per delay so it acts as the opaque handle.
                 lastDelay: { name: "lastDelayIndex" },
+                lastDelayIndex: { name: "lastDelayIndex", compatibilityOnly: true },
             },
         },
     },
@@ -1062,9 +1391,12 @@ const gltfToFlowGraphMapping = {
         blocks: ["FlowGraphCancelDelayBlock" /* FlowGraphBlockNames.CancelDelay */],
         inputs: {
             values: {
-                // New spec renames this input to `delay` (ref). The underlying block reads an int
-                // from `delayIndex`; when a ref-string flows in we coerce it via the path converter.
-                delay: { name: "delayIndex" },
+                delay: { name: "delayIndex", gltfType: "ref" },
+            },
+        },
+        outputs: {
+            flows: {
+                out: { name: "out" },
             },
         },
     },
@@ -1081,6 +1413,9 @@ const gltfToFlowGraphMapping = {
             variable: {
                 name: "variable",
                 gltfType: "number",
+                configurationType: "int",
+                required: true,
+                indexSource: "variables",
                 flowGraphType: "string",
                 inOptions: true,
                 isVariable: true,
@@ -1089,13 +1424,28 @@ const gltfToFlowGraphMapping = {
                 },
             },
         },
+        outputs: {
+            values: {
+                value: { name: "value" },
+            },
+        },
     },
     "variable/set": {
         blocks: ["FlowGraphSetVariableBlock" /* FlowGraphBlockNames.SetVariable */],
+        inputs: {
+            values: {
+                "[segment]": { name: "$1" },
+            },
+        },
         configuration: {
             variables: {
                 name: "variables",
                 gltfType: "number",
+                configurationType: "int[]",
+                required: true,
+                indexSource: "variables",
+                minItems: 1,
+                generatesInputValueSockets: true,
                 flowGraphType: "string",
                 inOptions: true,
                 isArray: true,
@@ -1104,6 +1454,11 @@ const gltfToFlowGraphMapping = {
                 },
             },
         },
+        outputs: {
+            flows: {
+                out: { name: "out", compatibilityOnly: true },
+            },
+        },
         extraProcessor(_gltfBlock, _declaration, _mapping, parser, serializedObjects) {
             // variable/get configuration
             const serializedGetVariable = serializedObjects[0];
@@ -1124,6 +1479,9 @@ const gltfToFlowGraphMapping = {
         configuration: {
             variable: {
                 name: "propertyName",
+                configurationType: "int",
+                required: true,
+                indexSource: "variables",
                 inOptions: true,
                 isVariable: true,
                 dataTransformer(index, parser) {
@@ -1132,8 +1490,9 @@ const gltfToFlowGraphMapping = {
             },
             useSlerp: {
                 name: "animationType",
+                configurationType: "bool",
+                required: true,
                 inOptions: true,
-                defaultValue: false,
                 dataTransformer(value) {
                     return value === true ? "Quaternion" /* FlowGraphTypes.Quaternion */ : undefined;
                 },
@@ -1213,15 +1572,28 @@ const gltfToFlowGraphMapping = {
     },
     "pointer/get": {
         blocks: ["FlowGraphGetPropertyBlock" /* FlowGraphBlockNames.GetProperty */, "FlowGraphJsonPointerParserBlock" /* FlowGraphBlockNames.JsonPointerParser */],
-        validation: ValidateJsonPointerTemplate,
+        validation: (node) => ValidateJsonPointerTemplate(node),
         configuration: {
-            pointer: { name: "jsonPointer", toBlock: "FlowGraphJsonPointerParserBlock" /* FlowGraphBlockNames.JsonPointerParser */ },
+            pointer: { name: "jsonPointer", toBlock: "FlowGraphJsonPointerParserBlock" /* FlowGraphBlockNames.JsonPointerParser */, configurationType: "string", required: true, pointerTemplate: true },
+            type: {
+                name: "type",
+                configurationType: "int",
+                required: true,
+                validationOnly: true,
+                indexSource: "types",
+            },
         },
         inputs: {
             values: {
                 "[segment]": { name: "$1", toBlock: "FlowGraphJsonPointerParserBlock" /* FlowGraphBlockNames.JsonPointerParser */ },
             },
         },
+        outputs: {
+            values: {
+                value: { name: "value" },
+                isValid: { name: "isValid", gltfType: "bool" },
+            },
+        },
         interBlockConnectors: [
             {
                 input: "object",
@@ -1258,9 +1630,16 @@ const gltfToFlowGraphMapping = {
     },
     "pointer/set": {
         blocks: ["FlowGraphSetPropertyBlock" /* FlowGraphBlockNames.SetProperty */, "FlowGraphJsonPointerParserBlock" /* FlowGraphBlockNames.JsonPointerParser */],
-        validation: ValidateJsonPointerTemplate,
+        validation: (node) => ValidateJsonPointerTemplate(node, new Set(["value"])),
         configuration: {
-            pointer: { name: "jsonPointer", toBlock: "FlowGraphJsonPointerParserBlock" /* FlowGraphBlockNames.JsonPointerParser */ },
+            pointer: { name: "jsonPointer", toBlock: "FlowGraphJsonPointerParserBlock" /* FlowGraphBlockNames.JsonPointerParser */, configurationType: "string", required: true, pointerTemplate: true },
+            type: {
+                name: "type",
+                configurationType: "int",
+                required: true,
+                validationOnly: true,
+                indexSource: "types",
+            },
         },
         inputs: {
             values: {
@@ -1272,6 +1651,7 @@ const gltfToFlowGraphMapping = {
         outputs: {
             flows: {
                 err: { name: "error" },
+                out: { name: "out", compatibilityOnly: true },
             },
         },
         interBlockConnectors: [
@@ -1311,9 +1691,17 @@ const gltfToFlowGraphMapping = {
     "pointer/interpolate": {
         // interpolate, parse the pointer and play the animation generated. 3 blocks!
         blocks: ["FlowGraphInterpolationBlock" /* FlowGraphBlockNames.ValueInterpolation */, "FlowGraphJsonPointerParserBlock" /* FlowGraphBlockNames.JsonPointerParser */, "FlowGraphPlayAnimationBlock" /* FlowGraphBlockNames.PlayAnimation */, "FlowGraphBezierCurveEasing" /* FlowGraphBlockNames.BezierCurveEasing */],
-        validation: ValidateJsonPointerTemplate,
+        validation: (node) => ValidateJsonPointerTemplate(node, new Set(["value", "duration", "p1", "p2"])),
         configuration: {
-            pointer: { name: "jsonPointer", toBlock: "FlowGraphJsonPointerParserBlock" /* FlowGraphBlockNames.JsonPointerParser */ },
+            pointer: { name: "jsonPointer", toBlock: "FlowGraphJsonPointerParserBlock" /* FlowGraphBlockNames.JsonPointerParser */, configurationType: "string", required: true, pointerTemplate: true },
+            type: {
+                name: "type",
+                configurationType: "int",
+                required: true,
+                validationOnly: true,
+                indexSource: "types",
+                allowedSignatures: ["float", "float2", "float3", "float4", "float2x2", "float3x3", "float4x4"],
+            },
         },
         inputs: {
             values: {
@@ -1406,7 +1794,7 @@ const gltfToFlowGraphMapping = {
         blocks: ["FlowGraphPlayAnimationBlock" /* FlowGraphBlockNames.PlayAnimation */, "FlowGraphArrayIndexBlock" /* FlowGraphBlockNames.ArrayIndex */, "KHR_interactivity/FlowGraphGLTFDataProvider"],
         inputs: {
             values: {
-                animation: { name: "index", gltfType: "number", toBlock: "FlowGraphArrayIndexBlock" /* FlowGraphBlockNames.ArrayIndex */ },
+                animation: { name: "index", gltfType: "ref", toBlock: "FlowGraphArrayIndexBlock" /* FlowGraphBlockNames.ArrayIndex */ },
                 speed: { name: "speed", gltfType: "number" },
                 startTime: {
                     name: "from",
@@ -1424,7 +1812,9 @@ const gltfToFlowGraphMapping = {
         },
         outputs: {
             flows: {
+                out: { name: "out" },
                 err: { name: "error" },
+                done: { name: "done" },
             },
         },
         interBlockConnectors: [
@@ -1444,6 +1834,14 @@ const gltfToFlowGraphMapping = {
             },
         ],
         extraProcessor(_gltfBlock, _declaration, _mapping, _arrays, serializedObjects, _context, globalGLTF) {
+            const playAnimationBlock = serializedObjects.find((block) => block.className === "FlowGraphPlayAnimationBlock" /* FlowGraphBlockNames.PlayAnimation */);
+            if (playAnimationBlock) {
+                playAnimationBlock.config.useVirtualTimeline = true;
+            }
+            const arrayIndexBlock = serializedObjects.find((block) => block.className === "FlowGraphArrayIndexBlock" /* FlowGraphBlockNames.ArrayIndex */);
+            if (arrayIndexBlock) {
+                arrayIndexBlock.config.referenceCollection = "animations";
+            }
             // add the glTF to the configuration of the last serialized object
             const serializedObject = serializedObjects[serializedObjects.length - 1];
             serializedObject.config || (serializedObject.config = {});
@@ -1455,11 +1853,12 @@ const gltfToFlowGraphMapping = {
         blocks: ["FlowGraphStopAnimationBlock" /* FlowGraphBlockNames.StopAnimation */, "FlowGraphArrayIndexBlock" /* FlowGraphBlockNames.ArrayIndex */, "KHR_interactivity/FlowGraphGLTFDataProvider"],
         inputs: {
             values: {
-                animation: { name: "index", gltfType: "number", toBlock: "FlowGraphArrayIndexBlock" /* FlowGraphBlockNames.ArrayIndex */ },
+                animation: { name: "index", gltfType: "ref", toBlock: "FlowGraphArrayIndexBlock" /* FlowGraphBlockNames.ArrayIndex */ },
             },
         },
         outputs: {
             flows: {
+                out: { name: "out" },
                 err: { name: "error" },
             },
         },
@@ -1480,6 +1879,14 @@ const gltfToFlowGraphMapping = {
             },
         ],
         extraProcessor(_gltfBlock, _declaration, _mapping, _arrays, serializedObjects, _context, globalGLTF) {
+            const stopAnimationBlock = serializedObjects.find((block) => block.className === "FlowGraphStopAnimationBlock" /* FlowGraphBlockNames.StopAnimation */);
+            if (stopAnimationBlock) {
+                stopAnimationBlock.config.skipOnAnimationEnd = true;
+            }
+            const arrayIndexBlock = serializedObjects.find((block) => block.className === "FlowGraphArrayIndexBlock" /* FlowGraphBlockNames.ArrayIndex */);
+            if (arrayIndexBlock) {
+                arrayIndexBlock.config.referenceCollection = "animations";
+            }
             // add the glTF to the configuration of the last serialized object
             const serializedObject = serializedObjects[serializedObjects.length - 1];
             serializedObject.config || (serializedObject.config = {});
@@ -1492,7 +1899,7 @@ const gltfToFlowGraphMapping = {
         configuration: {},
         inputs: {
             values: {
-                animation: { name: "index", gltfType: "number", toBlock: "FlowGraphArrayIndexBlock" /* FlowGraphBlockNames.ArrayIndex */ },
+                animation: { name: "index", gltfType: "ref", toBlock: "FlowGraphArrayIndexBlock" /* FlowGraphBlockNames.ArrayIndex */ },
                 stopTime: {
                     name: "stopAtFrame",
                     gltfType: "number",
@@ -1503,7 +1910,9 @@ const gltfToFlowGraphMapping = {
         },
         outputs: {
             flows: {
+                out: { name: "out" },
                 err: { name: "error" },
+                done: { name: "done" },
             },
         },
         interBlockConnectors: [
@@ -1523,6 +1932,15 @@ const gltfToFlowGraphMapping = {
             },
         ],
         extraProcessor(_gltfBlock, _declaration, _mapping, _arrays, serializedObjects, _context, globalGLTF) {
+            const stopAnimationBlock = serializedObjects.find((block) => block.className === "FlowGraphStopAnimationBlock" /* FlowGraphBlockNames.StopAnimation */);
+            if (stopAnimationBlock) {
+                stopAnimationBlock.config.useVirtualStopAt = true;
+                stopAnimationBlock.config.skipOnAnimationEnd = true;
+            }
+            const arrayIndexBlock = serializedObjects.find((block) => block.className === "FlowGraphArrayIndexBlock" /* FlowGraphBlockNames.ArrayIndex */);
+            if (arrayIndexBlock) {
+                arrayIndexBlock.config.referenceCollection = "animations";
+            }
             // add the glTF to the configuration of the last serialized object
             const serializedObject = serializedObjects[serializedObjects.length - 1];
             serializedObject.config || (serializedObject.config = {});
@@ -1533,11 +1951,27 @@ const gltfToFlowGraphMapping = {
     "math/switch": {
         blocks: ["FlowGraphDataSwitchBlock" /* FlowGraphBlockNames.DataSwitch */],
         configuration: {
-            cases: { name: "cases", isArray: true, inOptions: true, defaultValue: [] },
+            cases: {
+                name: "cases",
+                isArray: true,
+                inOptions: true,
+                defaultValue: [],
+                configurationType: "int[]",
+                invalidUsesDefault: true,
+                generatesCaseInputValueSockets: true,
+                uniqueValues: true,
+            },
         },
         inputs: {
             values: {
-                selection: { name: "case" },
+                selection: { name: "case", gltfType: "int" },
+                default: { name: "default" },
+                "[case]": { name: "$1" },
+            },
+        },
+        outputs: {
+            values: {
+                value: { name: "value" },
             },
         },
         validation(gltfBlock) {
@@ -1572,8 +2006,37 @@ const gltfToFlowGraphMapping = {
     },
     "debug/log": {
         blocks: ["FlowGraphConsoleLogBlock" /* FlowGraphBlockNames.ConsoleLog */],
+        inputs: {
+            flows: {
+                in: { name: "in" },
+            },
+            values: {
+                "[parameter]": { name: "$1" },
+            },
+        },
+        outputs: {
+            flows: {
+                out: { name: "out" },
+            },
+        },
         configuration: {
-            message: { name: "messageTemplate", inOptions: true },
+            severity: {
+                name: "severity",
+                configurationType: "int",
+                defaultValue: 0,
+                invalidUsesDefault: true,
+                validationOnly: true,
+                configurationGroup: "debugLog",
+            },
+            message: {
+                name: "messageTemplate",
+                configurationType: "string",
+                defaultValue: "",
+                invalidUsesDefault: true,
+                inOptions: true,
+                configurationGroup: "debugLog",
+                debugLogTemplate: true,
+            },
         },
     },
 };
@@ -1588,7 +2051,7 @@ function getSimpleInputMapping(type, inputs = ["a"], inferType) {
         },
         outputs: {
             values: {
-                value: { name: "value" },
+                value: { name: "value", typeSourceInput: inputs[0] },
             },
         },
         extraProcessor(gltfBlock, _declaration, _mapping, _parser, serializedObjects) {
@@ -1657,15 +2120,69 @@ function HasOddBracketRun(segment) {
     }
     return false;
 }
+/**
+ * Parses a ratified `debug/log` message template.
+ * Literal braces must be doubled; non-empty text inside a single brace pair defines a socket id.
+ * @param message message template to parse
+ * @returns template validity and its exact dynamic socket ids
+ */
+export function ParseDebugLogTemplate(message) {
+    let state = 0;
+    let parameterStart = -1;
+    const sockets = [];
+    const seen = new Set();
+    for (let index = 0; index < message.length; index++) {
+        const character = message[index];
+        if (character === "{") {
+            if (state === 0) {
+                state = 1;
+            }
+            else if (state === 1) {
+                state = 0;
+            }
+            else {
+                return { valid: false, sockets: [] };
+            }
+        }
+        else if (character === "}") {
+            if (state === 0) {
+                state = 3;
+            }
+            else if (state === 3) {
+                state = 0;
+            }
+            else if (state === 2) {
+                const socket = message.substring(parameterStart + 1, index);
+                if (!seen.has(socket)) {
+                    seen.add(socket);
+                    sockets.push(socket);
+                }
+                state = 0;
+            }
+            else {
+                return { valid: false, sockets: [] };
+            }
+        }
+        else if (state === 1) {
+            parameterStart = index - 1;
+            state = 2;
+        }
+        else if (state === 3) {
+            return { valid: false, sockets: [] };
+        }
+    }
+    return { valid: state === 0, sockets: state === 0 ? sockets : [] };
+}
 /**
  * Validates the `pointer` configuration value of a `pointer/*` operation, following the JSON Pointer Template
  * Parsing steps of the KHR_interactivity specification. A template parameter must span an entire path segment, so
  * a template such as `/materials/{materialRef}pbrMetallicRoughness/...` is a syntax error, and the specification
  * requires the whole behavior graph to be rejected.
  * @param gltfBlock the glTF interactivity node
+ * @param reservedSocketIds input ids owned by the operation rather than template parameters
  * @returns the validation result
  */
-function ValidateJsonPointerTemplate(gltfBlock) {
+function ValidateJsonPointerTemplate(gltfBlock, reservedSocketIds = new Set()) {
     const pointer = gltfBlock.configuration?.pointer?.value?.[0];
     if (typeof pointer !== "string") {
         return { valid: false, error: "A pointer operation requires a string `pointer` configuration value" };
@@ -1677,6 +2194,9 @@ function ValidateJsonPointerTemplate(gltfBlock) {
     const invalid = (reason) => ({ valid: false, error: `The JSON Pointer Template "${pointer}" is invalid: ${reason}` });
     const socketIds = new Set();
     for (const segment of pointer.split("/")) {
+        if (/~(?:[^01]|$)/.test(segment)) {
+            return invalid(`the path segment "${segment}" contains an invalid RFC 6901 escape`);
+        }
         const isIntegerParameter = segment[0] === "[" && segment[1] !== "[";
         const isReferenceParameter = segment[0] === "{" && segment[1] !== "{";
         if (!isIntegerParameter && !isReferenceParameter) {
@@ -1691,6 +2211,9 @@ function ValidateJsonPointerTemplate(gltfBlock) {
             return invalid(`the template parameter path segment "${segment}" is malformed`);
         }
         const socketId = body.replace(/~1/g, "/").replace(/~0/g, "~");
+        if (reservedSocketIds.has(socketId)) {
+            return invalid(`the template parameter "${socketId}" uses a reserved input socket id`);
+        }
         if (socketIds.has(socketId)) {
             return invalid(`the template parameter "${socketId}" is used more than once`);
         }