@babylonjs/loaders 9.26.0 → 9.26.2

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

@@ -0,0 +1,773 @@
+import { getMappingForDeclaration, getNoOpMappingForDeclaration, ParseDebugLogTemplate, } from "./declarationMapper.js";
+/**
+ * Ratified KHR_interactivity specification baseline used by this importer.
+ */
+export const KHR_INTERACTIVITY_SPECIFICATION_COMMIT = "f798712c5685bc9223a628140fba707db8889300";
+/**
+ * Runtime representation of every ratified built-in KHR_interactivity type.
+ */
+// eslint-disable-next-line @typescript-eslint/naming-convention
+export const gltfTypeToBabylonType = {
+    float: { length: 1, flowGraphType: "number" /* FlowGraphTypes.Number */, elementType: "number" },
+    bool: { length: 1, flowGraphType: "boolean" /* FlowGraphTypes.Boolean */, elementType: "boolean" },
+    float2: { length: 2, flowGraphType: "Vector2" /* FlowGraphTypes.Vector2 */, elementType: "number" },
+    float3: { length: 3, flowGraphType: "Vector3" /* FlowGraphTypes.Vector3 */, elementType: "number" },
+    float4: { length: 4, flowGraphType: "Vector4" /* FlowGraphTypes.Vector4 */, elementType: "number" },
+    float4x4: { length: 16, flowGraphType: "Matrix" /* FlowGraphTypes.Matrix */, elementType: "number" },
+    float2x2: { length: 4, flowGraphType: "Matrix2D" /* FlowGraphTypes.Matrix2D */, elementType: "number" },
+    float3x3: { length: 9, flowGraphType: "Matrix3D" /* FlowGraphTypes.Matrix3D */, elementType: "number" },
+    int: { length: 1, flowGraphType: "FlowGraphInteger" /* FlowGraphTypes.Integer */, elementType: "number" },
+    ref: { length: 1, flowGraphType: "string" /* FlowGraphTypes.String */, elementType: "string" },
+    custom: { length: 0, flowGraphType: "any" /* FlowGraphTypes.Any */, elementType: "any" },
+};
+function _cloneJson(value) {
+    if (Array.isArray(value)) {
+        return value.map((entry) => _cloneJson(entry));
+    }
+    if (value !== null && typeof value === "object") {
+        const clone = {};
+        for (const [key, entry] of Object.entries(value)) {
+            Object.defineProperty(clone, key, {
+                configurable: true,
+                enumerable: true,
+                value: _cloneJson(entry),
+                writable: true,
+            });
+        }
+        return clone;
+    }
+    return value;
+}
+/**
+ * Creates a detached JSON copy of a KHR_interactivity graph.
+ * @param graph source graph
+ * @returns a lossless JSON copy
+ */
+export function CloneKHRInteractivityGraph(graph) {
+    return _cloneJson(graph);
+}
+function _isValidIndex(value, length) {
+    return typeof value === "number" && Number.isInteger(value) && value >= 0 && value < length;
+}
+function _addError(diagnostics, path, message) {
+    diagnostics.push({ path, message, severity: "error" });
+}
+function _addWarning(diagnostics, path, message) {
+    diagnostics.push({ path, message, severity: "warning" });
+}
+function _isValidJsonPointer(value) {
+    return value === "" || /^(?:\/(?:[^~]|~[01])*)*$/.test(value);
+}
+function _matchesOutputSocket(mapping, socket, declaration, node, graph, defaultSocket) {
+    if (mapping && Object.prototype.hasOwnProperty.call(mapping, socket)) {
+        return true;
+    }
+    if (socket === defaultSocket && mapping && Object.prototype.hasOwnProperty.call(mapping, defaultSocket)) {
+        return true;
+    }
+    if (!Object.keys(mapping ?? {}).some((name) => name.startsWith("[") && name.endsWith("]"))) {
+        return false;
+    }
+    if (declaration.operation === "event/receive") {
+        const eventIndex = node.configuration?.event?.value?.[0];
+        return typeof eventIndex === "number" && Object.prototype.hasOwnProperty.call(graph.events?.[eventIndex]?.values ?? {}, socket);
+    }
+    return true;
+}
+function _validateTypeIndex(typeIndex, graph, diagnostics, path) {
+    if (!_isValidIndex(typeIndex, graph.types?.length ?? 0)) {
+        _addError(diagnostics, path, `Type index ${String(typeIndex)} is out of range.`);
+        return false;
+    }
+    return true;
+}
+function _validateValue(value, graph, diagnostics, path) {
+    if (!_validateTypeIndex(value.type, graph, diagnostics, `${path}/type`)) {
+        return;
+    }
+    if (value.value === undefined) {
+        return;
+    }
+    const type = graph.types[value.type];
+    const runtimeType = gltfTypeToBabylonType[type.signature];
+    if (runtimeType && type.signature !== "custom" && value.value.length !== runtimeType.length) {
+        _addError(diagnostics, `${path}/value`, `Expected ${runtimeType.length} value component(s) for type "${type.signature}", received ${value.value.length}.`);
+    }
+    for (let componentIndex = 0; componentIndex < value.value.length; componentIndex++) {
+        const component = value.value[componentIndex];
+        let valid = true;
+        switch (type.signature) {
+            case "bool":
+                valid = typeof component === "boolean";
+                break;
+            case "int":
+                valid = typeof component === "number" && Number.isInteger(component) && component >= -2147483648 && component <= 2147483647;
+                break;
+            case "float":
+            case "float2":
+            case "float3":
+            case "float4":
+            case "float2x2":
+            case "float3x3":
+            case "float4x4":
+                valid = typeof component === "number" && Number.isFinite(component);
+                break;
+            case "ref":
+                valid = typeof component === "string" && _isValidJsonPointer(component);
+                break;
+            default:
+                break;
+        }
+        if (!valid) {
+            _addError(diagnostics, `${path}/value/${componentIndex}`, `Value component is invalid for type "${type.signature}".`);
+        }
+    }
+}
+function _getDeclarationMapping(declaration, graph, supportedExtensions) {
+    const extensionEnabled = !declaration.extension || !supportedExtensions || supportedExtensions.has(declaration.extension);
+    const mapping = extensionEnabled ? getMappingForDeclaration(declaration, false) : undefined;
+    if (mapping) {
+        if (declaration.extension && mapping.declarationSchema && !_isCompatibleExtensionDeclaration(declaration, graph, mapping.declarationSchema)) {
+            return { mapping: undefined, support: "unsupported-extension" };
+        }
+        return { mapping, support: declaration.extension ? "extension" : "core" };
+    }
+    return {
+        mapping: undefined,
+        support: declaration.extension ? "unsupported-extension" : "unknown-core",
+    };
+}
+function _isCompatibleExtensionDeclaration(declaration, graph, schema) {
+    const matches = (actual, expected) => {
+        const actualKeys = Object.keys(actual ?? {}).sort();
+        const expectedKeys = Object.keys(expected).sort();
+        if (actualKeys.length !== expectedKeys.length || actualKeys.some((key, index) => key !== expectedKeys[index])) {
+            return false;
+        }
+        return actualKeys.every((key) => graph.types?.[actual[key].type]?.signature === expected[key]);
+    };
+    return matches(declaration.inputValueSockets, schema.inputValueSockets) && matches(declaration.outputValueSockets, schema.outputValueSockets);
+}
+function _validateConfigurationValue(value, type) {
+    if (!value) {
+        return false;
+    }
+    const isInt = (entry) => typeof entry === "number" && Number.isInteger(entry) && entry >= -2147483648 && entry <= 2147483647;
+    switch (type) {
+        case "bool":
+            return value.length === 1 && typeof value[0] === "boolean";
+        case "int":
+            return value.length === 1 && isInt(value[0]);
+        case "int[]":
+            return value.every(isInt);
+        case "string":
+            return value.length === 1 && typeof value[0] === "string";
+        default:
+            return value.length > 0;
+    }
+}
+function _getIndexedArrayLength(graph, source, assetNodeCount) {
+    switch (source) {
+        case "types":
+            return graph.types?.length ?? 0;
+        case "variables":
+            return graph.variables?.length ?? 0;
+        case "events":
+            return graph.events?.length ?? 0;
+        case "nodes":
+            return graph.nodes?.length ?? 0;
+        case "assetNodes":
+            return assetNodeCount ?? 0;
+        default:
+            return 0;
+    }
+}
+function _isEffectiveConfigurationValue(configuration, property, graph, assetNodeCount) {
+    if (!configuration || !_validateConfigurationValue(configuration.value, property.configurationType) || !configuration.value) {
+        return false;
+    }
+    if (property.minItems !== undefined && configuration.value.length < property.minItems) {
+        return false;
+    }
+    if (property.minimum !== undefined && configuration.value.some((value) => typeof value !== "number" || value < property.minimum)) {
+        return false;
+    }
+    if (property.maximum !== undefined && configuration.value.some((value) => typeof value !== "number" || value > property.maximum)) {
+        return false;
+    }
+    if (property.indexSource) {
+        const length = _getIndexedArrayLength(graph, property.indexSource, assetNodeCount);
+        if (configuration.value.some((value) => !_isValidIndex(value, length))) {
+            return false;
+        }
+    }
+    if (property.allowedSignatures) {
+        const typeIndex = configuration.value[0];
+        const signature = typeof typeIndex === "number" ? graph.types?.[typeIndex]?.signature : undefined;
+        if (!signature || !property.allowedSignatures.includes(signature)) {
+            return false;
+        }
+    }
+    if (property.debugLogTemplate && !ParseDebugLogTemplate(configuration.value[0]).valid) {
+        return false;
+    }
+    return true;
+}
+function _getAllowedDynamicFlowOutputSockets(node, mapping, graph, assetNodeCount) {
+    for (const [key, property] of Object.entries(mapping.configuration ?? {})) {
+        if (!property.generatesOutputFlowSockets) {
+            continue;
+        }
+        const configured = node.configuration?.[key];
+        const values = _isEffectiveConfigurationValue(configured, property, graph, assetNodeCount) ? configured.value : property.defaultValue;
+        return new Set(Array.isArray(values) ? values.map(String) : []);
+    }
+    return undefined;
+}
+function _matchesFlowOutputSocket(mapping, socket, allowedDynamicSockets) {
+    const flowMappings = mapping.outputs?.flows;
+    if (flowMappings && Object.prototype.hasOwnProperty.call(flowMappings, socket)) {
+        return true;
+    }
+    const hasWildcard = Object.keys(flowMappings ?? {}).some((name) => name.startsWith("[") && name.endsWith("]"));
+    return !hasWildcard || !allowedDynamicSockets || allowedDynamicSockets.has(socket);
+}
+/**
+ * Creates the executable graph view with all ratified configuration defaults and fallback rules
+ * applied without modifying the lossless source graph.
+ * @param graph source graph
+ * @param declarations canonical declarations
+ * @param assetNodeCount number of glTF nodes in the containing asset
+ * @returns normalized executable graph
+ */
+export function CreateEffectiveKHRInteractivityGraph(graph, declarations, assetNodeCount) {
+    const effective = CloneKHRInteractivityGraph(graph);
+    for (let nodeIndex = 0; nodeIndex < (effective.nodes?.length ?? 0); nodeIndex++) {
+        const node = effective.nodes[nodeIndex];
+        const declaration = declarations[node.declaration];
+        if (!declaration || declaration.support === "unknown-core" || declaration.support === "unsupported-extension") {
+            continue;
+        }
+        const mapping = getMappingForDeclaration(declaration.source, false);
+        if (!mapping?.configuration) {
+            continue;
+        }
+        const groupedValidity = new Map();
+        for (const [key, property] of Object.entries(mapping.configuration)) {
+            if (property.configurationGroup) {
+                const valid = _isEffectiveConfigurationValue(node.configuration?.[key], property, effective, assetNodeCount);
+                groupedValidity.set(property.configurationGroup, (groupedValidity.get(property.configurationGroup) ?? true) && valid);
+            }
+        }
+        for (const [key, property] of Object.entries(mapping.configuration)) {
+            const valid = (!property.configurationGroup || groupedValidity.get(property.configurationGroup) === true) &&
+                _isEffectiveConfigurationValue(node.configuration?.[key], property, effective, assetNodeCount);
+            if (!valid && property.defaultValue !== undefined) {
+                node.configuration ?? (node.configuration = {});
+                node.configuration[key] = {
+                    value: Array.isArray(property.defaultValue) ? _cloneJson(property.defaultValue) : [property.defaultValue],
+                };
+            }
+            else if (valid && property.uniqueValues && node.configuration?.[key]?.value) {
+                node.configuration[key].value = Array.from(new Set(node.configuration[key].value));
+            }
+        }
+    }
+    return effective;
+}
+function _getPointerTemplateSockets(pointer) {
+    const sockets = [];
+    for (const segment of pointer.split("/")) {
+        const signature = segment.startsWith("[") && !segment.startsWith("[[") ? "int" : segment.startsWith("{") && !segment.startsWith("{{") ? "ref" : undefined;
+        if (signature) {
+            const name = segment
+                .substring(1, segment.length - 1)
+                .replace(/~1/g, "/")
+                .replace(/~0/g, "~");
+            sockets.push({ name, signature });
+        }
+    }
+    return sockets;
+}
+function _resolveValueTypeIndex(value, graph, declarations, visited = new Set()) {
+    if ("node" in value) {
+        return _resolveOutputTypeIndex(value.node, value.socket ?? "value", graph, declarations, visited);
+    }
+    return value.type;
+}
+function _resolveOutputTypeIndex(nodeIndex, socket, graph, declarations, visited = new Set()) {
+    const key = `${nodeIndex}:${socket}`;
+    if (visited.has(key)) {
+        return undefined;
+    }
+    visited.add(key);
+    if (!_isValidIndex(nodeIndex, graph.nodes?.length ?? 0)) {
+        return undefined;
+    }
+    const sourceNode = graph.nodes[nodeIndex];
+    if (!_isValidIndex(sourceNode.declaration, declarations.length)) {
+        return undefined;
+    }
+    const declaration = declarations[sourceNode.declaration];
+    const declaredType = declaration.source.outputValueSockets?.[socket]?.type;
+    if (declaredType !== undefined) {
+        return declaredType;
+    }
+    const booleanType = () => graph.types?.findIndex((type) => type.signature === "bool");
+    if (socket === "isValid") {
+        return booleanType();
+    }
+    if (declaration.operation === "pointer/get" && socket === "value") {
+        const configuredType = sourceNode.configuration?.type?.value?.[0];
+        return typeof configuredType === "number" ? configuredType : undefined;
+    }
+    if (declaration.operation === "variable/get" && socket === "value") {
+        const variableIndex = sourceNode.configuration?.variable?.value?.[0];
+        return typeof variableIndex === "number" ? graph.variables?.[variableIndex]?.type : undefined;
+    }
+    if (declaration.operation === "math/switch" && socket === "value") {
+        const defaultInput = sourceNode.values?.default;
+        return defaultInput ? _resolveValueTypeIndex(defaultInput, graph, declarations, visited) : undefined;
+    }
+    if (declaration.operation === "event/receive" && socket !== "event") {
+        const eventIndex = sourceNode.configuration?.event?.value?.[0];
+        return typeof eventIndex === "number" ? graph.events?.[eventIndex]?.values?.[socket]?.type : undefined;
+    }
+    const fixedSignature = _getFixedOutputSignature(declaration.operation, socket);
+    if (fixedSignature) {
+        return graph.types?.findIndex((type) => type.signature === fixedSignature);
+    }
+    const mapping = getMappingForDeclaration(declaration.source, false);
+    const outputMapping = mapping?.outputs?.values?.[socket];
+    const mappedType = outputMapping?.gltfType;
+    const signature = mappedType === "number" ? "float" : mappedType === "boolean" ? "bool" : mappedType;
+    if (signature && signature in gltfTypeToBabylonType) {
+        return graph.types?.findIndex((type) => type.signature === signature);
+    }
+    const typeSource = outputMapping?.typeSourceInput ? sourceNode.values?.[outputMapping.typeSourceInput] : undefined;
+    return typeSource ? _resolveValueTypeIndex(typeSource, graph, declarations, visited) : undefined;
+}
+function _getFixedOutputSignature(operation, socket) {
+    if (socket !== "value") {
+        if ((operation === "math/rgbToOkLCh" && ["l", "c", "h"].includes(socket)) ||
+            (operation === "math/rgbFromOkLCh" && ["r", "g", "b"].includes(socket)) ||
+            operation.startsWith("math/extract")) {
+            return "float";
+        }
+        if (operation === "math/matDecompose") {
+            return socket === "rotation" ? "float4" : socket === "translation" || socket === "scale" ? "float3" : undefined;
+        }
+        if (operation === "math/quatToAxisAngle") {
+            return socket === "axis" ? "float3" : socket === "angle" ? "float" : undefined;
+        }
+        if ((operation === "flow/doN" && socket === "currentCount") || (operation === "flow/for" && socket === "index")) {
+            return "int";
+        }
+        if (operation === "flow/setDelay" && socket === "lastDelay") {
+            return "ref";
+        }
+        if (operation === "flow/throttle" && socket === "lastRemainingTime") {
+            return "float";
+        }
+        if ((operation === "event/onStart" || operation === "event/onTick" || operation === "event/receive") && socket === "event") {
+            return "ref";
+        }
+        if (operation === "event/onTick" && socket === "timeSinceLastTick") {
+            return "float";
+        }
+        if (operation === "event/onTick" && socket === "timeSinceStart") {
+            return "float";
+        }
+        return undefined;
+    }
+    if (["math/E", "math/Pi", "math/Tau", "math/Inf", "math/NaN", "math/random", "math/length", "math/dot", "math/determinant", "math/quatAngleBetween"].includes(operation)) {
+        return "float";
+    }
+    if (["math/eq", "ref/eq", "math/lt", "math/le", "math/gt", "math/ge", "math/isNaN", "math/isInf", "type/intToBool", "type/floatToBool"].includes(operation)) {
+        return "bool";
+    }
+    if (["math/clz", "math/ctz", "math/popcnt", "type/boolToInt", "type/floatToInt"].includes(operation)) {
+        return "int";
+    }
+    if (["type/boolToFloat", "type/intToFloat"].includes(operation)) {
+        return "float";
+    }
+    return undefined;
+}
+function _validateNode(node, nodeIndex, graph, declarations, diagnostics, graphPath, assetNodeCount) {
+    const path = `${graphPath}/nodes/${nodeIndex}`;
+    if (!_isValidIndex(node.declaration, declarations.length)) {
+        _addError(diagnostics, `${path}/declaration`, `Declaration index ${String(node.declaration)} is out of range.`);
+        return;
+    }
+    const declarationModel = declarations[node.declaration];
+    const mapping = declarationModel.support === "unsupported-extension" ? getNoOpMappingForDeclaration(declarationModel.source) : getMappingForDeclaration(declarationModel.source, false);
+    if (declarationModel.support === "unknown-core" || !mapping) {
+        return;
+    }
+    const reportConfigurationIssue = (property, issuePath, message) => {
+        if (property.invalidUsesDefault || property.defaultValue !== undefined) {
+            _addWarning(diagnostics, issuePath, `${message} The default configuration will be used.`);
+        }
+        else {
+            _addError(diagnostics, issuePath, message);
+        }
+    };
+    for (const [key, configuration] of Object.entries(node.configuration ?? {})) {
+        if (configuration.value && configuration.value.length === 0) {
+            _addError(diagnostics, `${path}/configuration/${key}/value`, "Configuration value arrays must contain at least one item when present.");
+        }
+    }
+    for (const [key, property] of Object.entries(mapping.configuration ?? {})) {
+        const configuration = node.configuration?.[key];
+        const isConfigurationValid = !!configuration && _validateConfigurationValue(configuration.value, property.configurationType);
+        if (!configuration && property.required) {
+            _addError(diagnostics, `${path}/configuration/${key}`, `Required configuration "${key}" is missing.`);
+        }
+        else if (configuration && !isConfigurationValid) {
+            reportConfigurationIssue(property, `${path}/configuration/${key}`, `Configuration "${key}" is invalid.`);
+        }
+        if (isConfigurationValid && configuration.value && property.minItems !== undefined && configuration.value.length < property.minItems) {
+            _addError(diagnostics, `${path}/configuration/${key}/value`, `Configuration "${key}" requires at least ${property.minItems} value(s).`);
+        }
+        if (isConfigurationValid && configuration.value && property.indexSource) {
+            const length = _getIndexedArrayLength(graph, property.indexSource, assetNodeCount);
+            for (let index = 0; index < configuration.value.length; index++) {
+                if (!_isValidIndex(configuration.value[index], length)) {
+                    reportConfigurationIssue(property, `${path}/configuration/${key}/value/${index}`, `Index is out of range for graph ${property.indexSource}.`);
+                }
+            }
+        }
+        if (isConfigurationValid && configuration.value && property.allowedSignatures) {
+            const typeIndex = configuration.value[0];
+            const signature = typeof typeIndex === "number" ? graph.types?.[typeIndex]?.signature : undefined;
+            if (!signature || !property.allowedSignatures.includes(signature)) {
+                reportConfigurationIssue(property, `${path}/configuration/${key}/value/0`, `Type "${String(signature)}" is not supported by this operation.`);
+            }
+        }
+        if (isConfigurationValid && configuration.value && property.debugLogTemplate && !ParseDebugLogTemplate(configuration.value[0]).valid) {
+            reportConfigurationIssue(property, `${path}/configuration/${key}/value/0`, `Configuration "${key}" is not a valid debug message template.`);
+        }
+        if (isConfigurationValid && configuration.value && (property.minimum !== undefined || property.maximum !== undefined)) {
+            const numericValue = configuration.value[0];
+            if ((property.minimum !== undefined && numericValue < property.minimum) || (property.maximum !== undefined && numericValue > property.maximum)) {
+                reportConfigurationIssue(property, `${path}/configuration/${key}/value/0`, `Configuration "${key}" must be between ${String(property.minimum)} and ${String(property.maximum)}.`);
+            }
+        }
+        if (isConfigurationValid && configuration.value && property.generatesInputValueSockets) {
+            for (const configuredIndex of configuration.value) {
+                if (typeof configuredIndex !== "number" || !_isValidIndex(configuredIndex, graph.variables?.length ?? 0)) {
+                    continue;
+                }
+                const socket = node.values?.[String(configuredIndex)];
+                if (!socket) {
+                    _addError(diagnostics, `${path}/values/${configuredIndex}`, `Required configured input value socket "${configuredIndex}" is missing.`);
+                }
+                else if (_resolveValueTypeIndex(socket, graph, declarations) !== graph.variables[configuredIndex].type) {
+                    _addError(diagnostics, `${path}/values/${configuredIndex}/type`, `Configured input value socket "${configuredIndex}" has the wrong type.`);
+                }
+            }
+        }
+        if (isConfigurationValid && configuration.value && property.generatesCaseInputValueSockets) {
+            const defaultType = node.values?.default ? _resolveValueTypeIndex(node.values.default, graph, declarations) : undefined;
+            for (const caseValue of configuration.value) {
+                const socket = node.values?.[String(caseValue)];
+                if (!socket) {
+                    _addError(diagnostics, `${path}/values/${caseValue}`, `Required case input value socket "${caseValue}" is missing.`);
+                }
+                else if (defaultType !== undefined && _resolveValueTypeIndex(socket, graph, declarations) !== defaultType) {
+                    _addError(diagnostics, `${path}/values/${caseValue}/type`, `Case input value socket "${caseValue}" must match the default socket type.`);
+                }
+            }
+        }
+        if (isConfigurationValid && configuration.value && property.pointerTemplate && typeof configuration.value[0] === "string") {
+            for (const socketDefinition of _getPointerTemplateSockets(configuration.value[0])) {
+                const socket = node.values?.[socketDefinition.name];
+                const expectedType = graph.types?.findIndex((type) => type.signature === socketDefinition.signature) ?? -1;
+                if (!socket) {
+                    _addError(diagnostics, `${path}/values/${socketDefinition.name}`, `Required pointer template input "${socketDefinition.name}" is missing.`);
+                }
+                else if (expectedType < 0 || _resolveValueTypeIndex(socket, graph, declarations) !== expectedType) {
+                    _addError(diagnostics, `${path}/values/${socketDefinition.name}/type`, `Pointer template input "${socketDefinition.name}" must have type "${socketDefinition.signature}".`);
+                }
+            }
+        }
+    }
+    if (declarationModel.operation === "debug/log") {
+        const severityProperty = mapping.configuration?.severity;
+        const messageProperty = mapping.configuration?.message;
+        const severityValid = !!severityProperty && _isEffectiveConfigurationValue(node.configuration?.severity, severityProperty, graph, assetNodeCount);
+        const messageValid = !!messageProperty && _isEffectiveConfigurationValue(node.configuration?.message, messageProperty, graph, assetNodeCount);
+        const message = severityValid && messageValid ? node.configuration.message.value[0] : "";
+        for (const socket of ParseDebugLogTemplate(message).sockets) {
+            if (!node.values?.[socket]) {
+                _addError(diagnostics, `${path}/values/${socket}`, `Required debug message template input "${socket}" is missing.`);
+            }
+        }
+    }
+    for (const [key, property] of Object.entries(mapping.inputs?.values ?? {})) {
+        if (!key.startsWith("[") && !node.values?.[key]) {
+            _addError(diagnostics, `${path}/values/${key}`, `Required input value socket "${key}" is missing.`);
+        }
+        if (declarationModel.operation === "event/send") {
+            const eventIndex = node.configuration?.event?.value?.[0];
+            const event = typeof eventIndex === "number" ? graph.events?.[eventIndex] : undefined;
+            for (const [socket, eventValue] of Object.entries(event?.values ?? {})) {
+                const source = node.values?.[socket];
+                if (!source) {
+                    _addError(diagnostics, `${path}/values/${socket}`, `Required custom event input value socket "${socket}" is missing.`);
+                }
+                else if (_resolveValueTypeIndex(source, graph, declarations) !== eventValue.type) {
+                    _addError(diagnostics, `${path}/values/${socket}/type`, `Custom event input value socket "${socket}" has the wrong type.`);
+                }
+            }
+        }
+        const expectedSignature = property.gltfType === "number" ? "float" : property.gltfType === "boolean" ? "bool" : property.gltfType;
+        const source = node.values?.[key];
+        if (source && expectedSignature && expectedSignature in gltfTypeToBabylonType) {
+            const typeIndex = _resolveValueTypeIndex(source, graph, declarations);
+            if (typeIndex !== undefined && graph.types?.[typeIndex]?.signature !== expectedSignature) {
+                _addError(diagnostics, `${path}/values/${key}/type`, `Input value socket "${key}" must have type "${expectedSignature}".`);
+            }
+        }
+    }
+    if (mapping.validation) {
+        try {
+            const validationNode = _cloneJson(node);
+            for (const value of Object.values(validationNode.values ?? {})) {
+                if (value.type === undefined) {
+                    value.type = _resolveValueTypeIndex(value, graph, declarations);
+                }
+            }
+            const result = mapping.validation(validationNode, graph);
+            if (!result.valid) {
+                _addError(diagnostics, path, result.error ?? `Operation "${declarationModel.operation}" is invalid.`);
+            }
+        }
+        catch (error) {
+            _addError(diagnostics, path, error.message);
+        }
+    }
+    for (const [key, value] of Object.entries(node.values ?? {})) {
+        if (declarationModel.support === "unsupported-extension" && !declarationModel.source.inputValueSockets?.[key]) {
+            _addError(diagnostics, `${path}/values/${key}`, `Input value socket "${key}" is not defined by operation "${declarationModel.operation}".`);
+        }
+        if ("node" in value) {
+            if ("value" in value) {
+                _addError(diagnostics, `${path}/values/${key}`, "An input value socket cannot define both inline and node sources.");
+            }
+            if (!_isValidIndex(value.node, graph.nodes?.length ?? 0)) {
+                _addError(diagnostics, `${path}/values/${key}/node`, `Node index ${String(value.node)} is out of range.`);
+                continue;
+            }
+            if (value.node >= nodeIndex) {
+                _addError(diagnostics, `${path}/values/${key}/node`, "Value connections must reference an earlier node.");
+            }
+            if (value.type !== undefined) {
+                _validateTypeIndex(value.type, graph, diagnostics, `${path}/values/${key}/type`);
+            }
+            const sourceNode = graph.nodes[value.node];
+            if (_isValidIndex(sourceNode.declaration, declarations.length)) {
+                const sourceDeclaration = declarations[sourceNode.declaration];
+                const sourceMapping = sourceDeclaration.support === "unsupported-extension"
+                    ? getNoOpMappingForDeclaration(sourceDeclaration.source)
+                    : getMappingForDeclaration(sourceDeclaration.source, false);
+                const sourceSocket = value.socket ?? "value";
+                const hasMappedSocket = _matchesOutputSocket(sourceMapping?.outputs?.values, sourceSocket, sourceDeclaration, sourceNode, graph, "value");
+                if (sourceMapping && !hasMappedSocket) {
+                    _addError(diagnostics, `${path}/values/${key}/socket`, `Output value socket "${sourceSocket}" does not exist on node ${value.node}.`);
+                }
+                const declaredOutputType = sourceDeclaration.source.outputValueSockets?.[sourceSocket]?.type;
+                const effectiveOutputType = declaredOutputType ?? _resolveOutputTypeIndex(value.node, sourceSocket, graph, declarations);
+                if (value.type !== undefined && effectiveOutputType !== undefined && value.type !== effectiveOutputType) {
+                    _addError(diagnostics, `${path}/values/${key}/type`, `Type assertion does not match output socket "${sourceSocket}".`);
+                }
+            }
+        }
+        else {
+            _validateValue(value, graph, diagnostics, `${path}/values/${key}`);
+        }
+    }
+    for (const [key, flow] of Object.entries(node.flows ?? {})) {
+        const allowedDynamicSockets = _getAllowedDynamicFlowOutputSockets(node, mapping, graph, assetNodeCount);
+        if (!_matchesFlowOutputSocket(mapping, key, allowedDynamicSockets)) {
+            _addError(diagnostics, `${path}/flows/${key}`, `Output flow socket "${key}" is not defined by operation "${declarationModel.operation}".`);
+        }
+        if (!_isValidIndex(flow.node, graph.nodes?.length ?? 0)) {
+            _addError(diagnostics, `${path}/flows/${key}/node`, `Node index ${String(flow.node)} is out of range.`);
+            continue;
+        }
+        if (flow.node <= nodeIndex) {
+            _addError(diagnostics, `${path}/flows/${key}/node`, "Flow connections must reference a later node.");
+        }
+    }
+}
+/**
+ * Creates and validates a canonical copy of one KHR_interactivity graph.
+ * @param graph source graph
+ * @param index graph index in the root extension
+ * @param supportedExtensions enabled extensions that may provide executable operations
+ * @param assetNodeCount number of nodes in the containing glTF asset
+ * @returns the canonical graph model
+ */
+export function CreateKHRInteractivityGraphModel(graph, index = 0, supportedExtensions, assetNodeCount) {
+    const diagnostics = [];
+    const path = `/extensions/KHR_interactivity/graphs/${index}`;
+    if (graph === null || typeof graph !== "object" || Array.isArray(graph)) {
+        _addError(diagnostics, path, "Behavior graph must be an object.");
+        graph = {};
+    }
+    else {
+        graph = CloneKHRInteractivityGraph(graph);
+    }
+    const invalidEntryDefaults = {
+        types: () => ({ signature: "custom" }),
+        variables: () => ({ type: -1 }),
+        events: () => ({}),
+        declarations: () => ({ op: "" }),
+        nodes: () => ({ declaration: -1 }),
+    };
+    for (const key of ["types", "variables", "events", "declarations", "nodes"]) {
+        const collection = graph[key];
+        if (collection !== undefined && !Array.isArray(collection)) {
+            _addError(diagnostics, `${path}/${key}`, `"${key}" must be an array when present.`);
+            graph[key] = [];
+        }
+        else if (Array.isArray(collection) && collection.length === 0) {
+            _addError(diagnostics, `${path}/${key}`, `"${key}" must contain at least one item when present.`);
+        }
+        else if (Array.isArray(collection)) {
+            graph[key] = collection.map((entry, entryIndex) => {
+                if (entry === null || typeof entry !== "object" || Array.isArray(entry)) {
+                    _addError(diagnostics, `${path}/${key}/${entryIndex}`, `Each "${key}" item must be an object.`);
+                    return invalidEntryDefaults[key]();
+                }
+                return entry;
+            });
+        }
+    }
+    for (let eventIndex = 0; eventIndex < (graph.events?.length ?? 0); eventIndex++) {
+        if (graph.events[eventIndex].values && Object.keys(graph.events[eventIndex].values).length === 0) {
+            _addError(diagnostics, `${path}/events/${eventIndex}/values`, '"values" must contain at least one property when present.');
+        }
+    }
+    for (let declarationIndex = 0; declarationIndex < (graph.declarations?.length ?? 0); declarationIndex++) {
+        const declaration = graph.declarations[declarationIndex];
+        for (const key of ["inputValueSockets", "outputValueSockets"]) {
+            if (declaration[key] && Object.keys(declaration[key]).length === 0) {
+                _addError(diagnostics, `${path}/declarations/${declarationIndex}/${key}`, `"${key}" must contain at least one property when present.`);
+            }
+        }
+    }
+    for (let nodeIndex = 0; nodeIndex < (graph.nodes?.length ?? 0); nodeIndex++) {
+        const node = graph.nodes[nodeIndex];
+        for (const key of ["configuration", "values", "flows"]) {
+            if (node[key] && Object.keys(node[key]).length === 0) {
+                _addError(diagnostics, `${path}/nodes/${nodeIndex}/${key}`, `"${key}" must contain at least one property when present.`);
+            }
+        }
+    }
+    const declarationKeys = new Set();
+    const declarations = (graph.declarations ?? []).map((declaration, declarationIndex) => {
+        const inputSockets = Object.keys(declaration.inputValueSockets ?? {})
+            .sort()
+            .map((key) => `${JSON.stringify(key)}:${declaration.inputValueSockets[key].type}`)
+            .join(",");
+        const declarationKey = `${JSON.stringify(declaration.op)}:${JSON.stringify(declaration.extension ?? "")}:${inputSockets}`;
+        if (declarationKeys.has(declarationKey)) {
+            _addError(diagnostics, `${path}/declarations/${declarationIndex}`, "Duplicate equivalent declaration.");
+        }
+        declarationKeys.add(declarationKey);
+        const { support } = _getDeclarationMapping(declaration, graph, supportedExtensions);
+        if (support === "unknown-core") {
+            _addError(diagnostics, `${path}/declarations/${declarationIndex}/op`, `Unknown core operation "${declaration.op}".`);
+        }
+        if (!declaration.extension && (declaration.inputValueSockets || declaration.outputValueSockets)) {
+            _addError(diagnostics, `${path}/declarations/${declarationIndex}`, "Core operation declarations cannot define dynamic value sockets.");
+        }
+        for (const [socket, definition] of Object.entries(declaration.inputValueSockets ?? {})) {
+            _validateTypeIndex(definition.type, graph, diagnostics, `${path}/declarations/${declarationIndex}/inputValueSockets/${socket}/type`);
+        }
+        for (const [socket, definition] of Object.entries(declaration.outputValueSockets ?? {})) {
+            _validateTypeIndex(definition.type, graph, diagnostics, `${path}/declarations/${declarationIndex}/outputValueSockets/${socket}/type`);
+        }
+        return {
+            index: declarationIndex,
+            operation: declaration.extension ? `${declaration.op}:${declaration.extension}` : declaration.op,
+            support,
+            source: declaration,
+        };
+    });
+    const signatures = new Set();
+    for (let typeIndex = 0; typeIndex < (graph.types?.length ?? 0); typeIndex++) {
+        const signature = graph.types[typeIndex].signature;
+        if (signature !== "custom" && signatures.has(signature)) {
+            _addError(diagnostics, `${path}/types/${typeIndex}/signature`, `Duplicate built-in type signature "${signature}".`);
+        }
+        signatures.add(signature);
+        if (signature !== "custom" && !gltfTypeToBabylonType[signature]) {
+            _addError(diagnostics, `${path}/types/${typeIndex}/signature`, `Unknown built-in type signature "${signature}".`);
+        }
+    }
+    for (let variableIndex = 0; variableIndex < (graph.variables?.length ?? 0); variableIndex++) {
+        _validateValue(graph.variables[variableIndex], graph, diagnostics, `${path}/variables/${variableIndex}`);
+    }
+    for (let eventIndex = 0; eventIndex < (graph.events?.length ?? 0); eventIndex++) {
+        const eventId = graph.events[eventIndex].id;
+        if (eventId !== undefined && graph.events.slice(0, eventIndex).some((event) => event.id === eventId)) {
+            _addError(diagnostics, `${path}/events/${eventIndex}/id`, `Duplicate event id "${eventId}".`);
+        }
+        if (graph.events[eventIndex].values && Object.prototype.hasOwnProperty.call(graph.events[eventIndex].values, "event")) {
+            _addError(diagnostics, `${path}/events/${eventIndex}/values/event`, 'Custom event value socket id "event" is reserved.');
+        }
+        for (const [socket, value] of Object.entries(graph.events[eventIndex].values ?? {})) {
+            _validateValue(value, graph, diagnostics, `${path}/events/${eventIndex}/values/${socket}`);
+        }
+    }
+    for (let nodeIndex = 0; nodeIndex < (graph.nodes?.length ?? 0); nodeIndex++) {
+        _validateNode(graph.nodes[nodeIndex], nodeIndex, graph, declarations, diagnostics, path, assetNodeCount);
+    }
+    return {
+        index,
+        path,
+        name: graph.name ?? `Graph ${index + 1}`,
+        source: graph,
+        effectiveSource: CreateEffectiveKHRInteractivityGraph(graph, declarations, assetNodeCount),
+        declarations,
+        diagnostics,
+        valid: !diagnostics.some((diagnostic) => diagnostic.severity === "error"),
+    };
+}
+/**
+ * Creates an immutable canonical KHR_interactivity document and validates all graph-local references.
+ * @param extension source extension object from the glTF document
+ * @param supportedExtensions enabled extensions that may provide executable operations
+ * @param assetNodeCount number of nodes in the containing glTF asset
+ * @returns the canonical document
+ */
+export function CreateKHRInteractivityDocument(extension, supportedExtensions, assetNodeCount) {
+    const source = _cloneJson(extension);
+    const diagnostics = [];
+    if (!Array.isArray(source.graphs)) {
+        _addError(diagnostics, "/extensions/KHR_interactivity/graphs", '"graphs" must be an array.');
+        source.graphs = [];
+    }
+    if (source.graphs.length === 0) {
+        _addError(diagnostics, "/extensions/KHR_interactivity/graphs", "At least one behavior graph is required.");
+    }
+    const requestedDefaultGraphIndex = source.graph ?? 0;
+    const defaultGraphIndex = _isValidIndex(requestedDefaultGraphIndex, source.graphs.length) ? requestedDefaultGraphIndex : -1;
+    if (defaultGraphIndex === -1) {
+        _addError(diagnostics, "/extensions/KHR_interactivity/graph", `Default graph index ${String(requestedDefaultGraphIndex)} is out of range.`);
+    }
+    const graphs = source.graphs.map((graph, index) => CreateKHRInteractivityGraphModel(graph, index, supportedExtensions, assetNodeCount));
+    source.graphs = graphs.map((graph) => graph.source);
+    return {
+        specificationCommit: KHR_INTERACTIVITY_SPECIFICATION_COMMIT,
+        source,
+        defaultGraphIndex,
+        graphs,
+        diagnostics,
+    };
+}
+//# sourceMappingURL=interactivityGraphModel.js.map