@babylonjs/loaders 9.26.0 → 9.26.2

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

@@ -14,37 +14,45 @@ export function getMappingForFullOperationName(fullOperationName) {
 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,
-                    };
-                }
-            }
-            if (declaration.outputValueSockets) {
-                outputs.values = {};
-                Object.keys(declaration.outputValueSockets).forEach((key) => {
-                    outputs.values[key] = {
-                        name: key,
-                    };
-                });
-            }
-            return {
-                blocks: [], // no blocks, just mapping
-                inputs,
-                outputs,
-            };
+            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 = {};
+        for (const key in declaration.inputValueSockets) {
+            inputs.values[key] = {
+                name: key,
+            };
+        }
+    }
+    if (declaration.outputValueSockets) {
+        outputs.values = {};
+        Object.keys(declaration.outputValueSockets).forEach((key) => {
+            outputs.values[key] = {
+                name: key,
+            };
+        });
+    }
+    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.
@@ -74,6 +82,12 @@ const gltfExtensionsToFlowGraphMapping = {
             inputs: {
                 values: {
                     message: { name: "message" },
+                    "[segment]": { name: "$1", compatibilityOnly: true },
+                },
+            },
+            outputs: {
+                flows: {
+                    out: { name: "out", compatibilityOnly: true },
                 },
             },
         },
@@ -98,6 +112,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 +124,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 +164,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 +208,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 +241,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 */),
@@ -234,6 +278,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" },
+            },
+        },
         extraProcessor(_gltfBlock, _declaration, _mapping, _parser, serializedObjects) {
             var _a;
             // configure it to work the way glTF specifies
@@ -339,7 +394,7 @@ const gltfToFlowGraphMapping = {
         },
         outputs: {
             values: {
-                value: { name: "output" },
+                value: { name: "output", typeSourceInput: "a" },
             },
         },
     },
@@ -372,7 +427,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" },
+                isValid: { name: "isValid", gltfType: "bool" },
+            },
+        },
+    },
     "math/dot": getSimpleInputMapping("FlowGraphDotBlock" /* FlowGraphBlockNames.Dot */, ["a", "b"]),
     "math/cross": getSimpleInputMapping("FlowGraphCrossBlock" /* FlowGraphBlockNames.Cross */, ["a", "b"]),
     "math/rotate2D": {
@@ -511,7 +574,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" },
+                isValid: { name: "isValid", gltfType: "bool" },
+            },
+        },
+    },
     "math/matMul": getSimpleInputMapping("FlowGraphMatrixMultiplicationBlock" /* FlowGraphBlockNames.MatrixMultiplication */, ["a", "b"]),
     "math/matCompose": {
         blocks: ["FlowGraphMatrixCompose" /* FlowGraphBlockNames.MatrixCompose */],
@@ -524,7 +595,7 @@ const gltfToFlowGraphMapping = {
         },
         outputs: {
             values: {
-                value: { name: "value" },
+                value: { name: "value", gltfType: "float4x4" },
             },
         },
         extraProcessor(_gltfBlock, _declaration, _mapping, _parser, serializedObjects, context) {
@@ -552,6 +623,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) {
@@ -601,7 +674,20 @@ const gltfToFlowGraphMapping = {
             },
         },
     },
-    "math/quatToAxisAngle": getSimpleInputMapping("FlowGraphAxisAngleFromQuaternionBlock" /* FlowGraphBlockNames.AxisAngleFromQuaternion */, ["a"]),
+    "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"]),
     "math/quatFromUpForward": {
         blocks: ["FlowGraphQuaternionFromUpForwardBlock" /* FlowGraphBlockNames.QuaternionFromUpForward */],
@@ -881,6 +967,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 +984,11 @@ const gltfToFlowGraphMapping = {
     },
     "flow/branch": {
         blocks: ["FlowGraphBranchBlock" /* FlowGraphBlockNames.Branch */],
+        inputs: {
+            values: {
+                condition: { name: "condition", gltfType: "boolean" },
+            },
+        },
         outputs: {
             flows: {
                 true: { name: "onTrue" },
@@ -903,7 +999,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 +1016,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 +1053,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 +1089,7 @@ const gltfToFlowGraphMapping = {
             },
             flows: {
                 loopBody: { name: "executionFlow" },
+                completed: { name: "completed" },
             },
         },
         extraProcessor(_gltfBlock, _declaration, _mapping, _arrays, serializedObjects) {
@@ -987,10 +1109,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 +1126,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 +1175,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 +1193,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 +1216,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 +1262,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 +1284,9 @@ const gltfToFlowGraphMapping = {
             variable: {
                 name: "variable",
                 gltfType: "number",
+                configurationType: "int",
+                required: true,
+                indexSource: "variables",
                 flowGraphType: "string",
                 inOptions: true,
                 isVariable: true,
@@ -1089,13 +1295,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 +1325,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 +1350,9 @@ const gltfToFlowGraphMapping = {
         configuration: {
             variable: {
                 name: "propertyName",
+                configurationType: "int",
+                required: true,
+                indexSource: "variables",
                 inOptions: true,
                 isVariable: true,
                 dataTransformer(index, parser) {
@@ -1132,8 +1361,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 +1443,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 +1501,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 +1522,7 @@ const gltfToFlowGraphMapping = {
         outputs: {
             flows: {
                 err: { name: "error" },
+                out: { name: "out", compatibilityOnly: true },
             },
         },
         interBlockConnectors: [
@@ -1311,9 +1562,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 +1665,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 +1683,9 @@ const gltfToFlowGraphMapping = {
         },
         outputs: {
             flows: {
+                out: { name: "out" },
                 err: { name: "error" },
+                done: { name: "done" },
             },
         },
         interBlockConnectors: [
@@ -1444,6 +1705,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 +1724,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 +1750,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 +1770,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 +1781,9 @@ const gltfToFlowGraphMapping = {
         },
         outputs: {
             flows: {
+                out: { name: "out" },
                 err: { name: "error" },
+                done: { name: "done" },
             },
         },
         interBlockConnectors: [
@@ -1523,6 +1803,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 +1822,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 +1877,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 +1922,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 +1991,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 +2065,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 +2082,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`);
         }