@bian-womp/spark-graph 0.3.51 → 0.3.53

package/lib/cjs/index.cjs

@@ -998,39 +998,494 @@ const LOG_LEVEL_VALUES = {
     silent: 4,
 };
 
-/**
- * Shared utility functions for runtime components
- */
-/**
- * Type guard to check if a value is a Promise
- */
-function isPromise(value) {
-    return !!value && typeof value.then === "function";
+function parseJsonPath(path) {
+    if (typeof path === "string") {
+        return path.split(".").flatMap((segment) => {
+            const arrayMatch = segment.match(/^(.+)\[(\d+)\]$/);
+            if (arrayMatch) {
+                const index = parseInt(arrayMatch[2], 10);
+                return arrayMatch[1] ? [arrayMatch[1], index] : [index];
+            }
+            return [segment];
+        });
+    }
+    return path;
 }
-/**
- * Unwrap a value that might be a Promise
- */
-async function unwrapMaybePromise(value) {
-    return isPromise(value) ? await value : value;
+function getValueAtPath(obj, pathSegments) {
+    if (pathSegments.length === 0) {
+        return { value: obj, parent: null, key: "" };
+    }
+    let current = obj;
+    for (let i = 0; i < pathSegments.length - 1; i++) {
+        const segment = pathSegments[i];
+        if (current === null ||
+            current === undefined ||
+            typeof current !== "object") {
+            return null;
+        }
+        if (typeof segment === "string") {
+            if (Array.isArray(current)) {
+                const index = parseInt(segment, 10);
+                if (isNaN(index))
+                    return null;
+                current = current[index];
+            }
+            else {
+                current = current[segment];
+            }
+        }
+        else if (typeof segment === "number") {
+            if (Array.isArray(current)) {
+                if (segment >= 0 && segment < current.length) {
+                    current = current[segment];
+                }
+                else {
+                    return null;
+                }
+            }
+            else {
+                return null;
+            }
+        }
+        else if (segment instanceof RegExp) {
+            if (Array.isArray(current)) {
+                return null;
+            }
+            const obj = current;
+            const matchingKey = Object.keys(obj).find((key) => segment.test(key));
+            if (!matchingKey)
+                return null;
+            current = obj[matchingKey];
+        }
+        else {
+            return null;
+        }
+    }
+    const lastSegment = pathSegments[pathSegments.length - 1];
+    if (typeof lastSegment === "string") {
+        if (Array.isArray(current)) {
+            const index = parseInt(lastSegment, 10);
+            if (isNaN(index))
+                return null;
+            return { value: current[index], parent: current, key: index };
+        }
+        else if (current !== null &&
+            current !== undefined &&
+            typeof current === "object") {
+            return {
+                value: current[lastSegment],
+                parent: current,
+                key: lastSegment,
+            };
+        }
+    }
+    else if (typeof lastSegment === "number") {
+        if (Array.isArray(current)) {
+            if (lastSegment >= 0 && lastSegment < current.length) {
+                return {
+                    value: current[lastSegment],
+                    parent: current,
+                    key: lastSegment,
+                };
+            }
+        }
+        return null;
+    }
+    else if (lastSegment instanceof RegExp) {
+        if (Array.isArray(current)) {
+            return null;
+        }
+        const obj = current;
+        const matchingKey = Object.keys(obj).find((key) => lastSegment.test(key));
+        if (!matchingKey)
+            return null;
+        return { value: obj[matchingKey], parent: current, key: matchingKey };
+    }
+    return null;
+}
+function setValueAtPath(obj, pathSegments, newValue) {
+    const result = getValueAtPath(obj, pathSegments);
+    if (!result || result.parent === null)
+        return false;
+    if (Array.isArray(result.parent)) {
+        result.parent[result.key] = newValue;
+    }
+    else {
+        result.parent[result.key] = newValue;
+    }
+    return true;
 }
 /**
- * Shallow/deep-ish equality check to avoid unnecessary runs on identical values
+ * Sets a value at a path, creating intermediate objects as needed.
+ * Mutates the root object in place.
+ * @param root - The root object to modify (must be an object, will be initialized if needed)
+ * @param pathSegments - The path segments to traverse
+ * @param value - The value to set, or null to delete the path
+ * @throws Error if path cannot be created (e.g., array indices not supported, invalid parent types)
  */
-function valuesEqual(a, b) {
-    if (a === b)
-        return true;
-    if (typeof a !== typeof b)
-        return false;
-    if (a && b && typeof a === "object") {
-        try {
-            return JSON.stringify(a) === JSON.stringify(b);
+function setValueAtPathWithCreation(root, pathSegments, value) {
+    if (value === null) {
+        const result = getValueAtPath(root, pathSegments);
+        if (result && result.parent !== null && !Array.isArray(result.parent)) {
+            delete result.parent[result.key];
         }
-        catch {
+        return;
+    }
+    if (!root || typeof root !== "object" || Array.isArray(root)) {
+        throw new Error("Root must be an object");
+    }
+    let current = root;
+    for (let i = 0; i < pathSegments.length - 1; i++) {
+        const segment = pathSegments[i];
+        if (typeof segment === "string") {
+            if (!current ||
+                typeof current !== "object" ||
+                Array.isArray(current) ||
+                !(segment in current) ||
+                typeof current[segment] !== "object" ||
+                current[segment] === null ||
+                Array.isArray(current[segment])) {
+                if (!current || typeof current !== "object" || Array.isArray(current)) {
+                    throw new Error(`Cannot create path: parent at segment ${i} is not an object`);
+                }
+                current[segment] = {};
+            }
+            current = current[segment];
+        }
+        else {
+            throw new Error("Array indices not supported in extData paths");
+        }
+    }
+    const lastSegment = pathSegments[pathSegments.length - 1];
+    if (typeof lastSegment === "string") {
+        if (!current || typeof current !== "object" || Array.isArray(current)) {
+            throw new Error(`Cannot set value: parent at final segment is not an object`);
+        }
+        current[lastSegment] = value;
+    }
+    else {
+        throw new Error("Array indices not supported in extData paths");
+    }
+}
+function findMatchingPaths(obj, pathSegments, currentPath = []) {
+    if (pathSegments.length === 0) {
+        return [{ path: currentPath, value: obj }];
+    }
+    const [currentSegment, ...remainingSegments] = pathSegments;
+    const results = [];
+    if (currentSegment === undefined) {
+        return results;
+    }
+    if (typeof currentSegment === "string") {
+        if (Array.isArray(obj)) {
+            const index = parseInt(currentSegment, 10);
+            if (!isNaN(index) && index >= 0 && index < obj.length) {
+                results.push(...findMatchingPaths(obj[index], remainingSegments, [
+                    ...currentPath,
+                    index,
+                ]));
+            }
+        }
+        else if (obj !== null && obj !== undefined && typeof obj === "object") {
+            const objRecord = obj;
+            if (currentSegment in objRecord) {
+                results.push(...findMatchingPaths(objRecord[currentSegment], remainingSegments, [
+                    ...currentPath,
+                    currentSegment,
+                ]));
+            }
+        }
+    }
+    else if (typeof currentSegment === "number") {
+        if (Array.isArray(obj)) {
+            if (currentSegment >= 0 && currentSegment < obj.length) {
+                results.push(...findMatchingPaths(obj[currentSegment], remainingSegments, [
+                    ...currentPath,
+                    currentSegment,
+                ]));
+            }
+        }
+    }
+    else if (currentSegment instanceof RegExp) {
+        if (Array.isArray(obj)) {
+            for (let i = 0; i < obj.length; i++) {
+                results.push(...findMatchingPaths(obj[i], remainingSegments, [...currentPath, i]));
+            }
+        }
+        else if (obj !== null && obj !== undefined && typeof obj === "object") {
+            const objRecord = obj;
+            for (const key of Object.keys(objRecord)) {
+                if (currentSegment.test(key)) {
+                    results.push(...findMatchingPaths(objRecord[key], remainingSegments, [
+                        ...currentPath,
+                        key,
+                    ]));
+                }
+            }
+        }
+    }
+    return results;
+}
+function stringifyJson(obj, oneLiner) {
+    // No formatting requested: behave exactly like native JSON.stringify.
+    if (!oneLiner)
+        return JSON.stringify(obj);
+    const indentSize = Number.isFinite(oneLiner.indent)
+        ? Math.max(0, Math.floor(oneLiner.indent))
+        : 2;
+    const maxDepth = typeof oneLiner.maxDepth === "number" && Number.isFinite(oneLiner.maxDepth)
+        ? oneLiner.maxDepth
+        : undefined;
+    const patterns = (oneLiner.paths || []).filter(Boolean);
+    // Preserve JSON.stringify semantics for things like toJSON(), dropping functions/undefined, etc.
+    // Note: this still throws on circular structures (same as JSON.stringify).
+    const base = JSON.stringify(obj);
+    if (base === undefined)
+        return base;
+    const value = JSON.parse(base);
+    const pathMatchers = patterns.map((p) => compilePathMatcher(String(p)));
+    const formatKey = (k) => JSON.stringify(k);
+    const shouldInline = (path, key, v, depth) => {
+        if (maxDepth !== undefined && depth > maxDepth)
+            return true;
+        if (oneLiner.criteria?.({ path, key, value: v, depth }))
+            return true;
+        if (!pathMatchers.length)
             return false;
+        const tokensWithRoot = tokenizePath(path);
+        const tokensNoRoot = tokensWithRoot[0] === "$" ? tokensWithRoot.slice(1) : tokensWithRoot;
+        return pathMatchers.some((m) => m(tokensWithRoot, tokensNoRoot));
+    };
+    const stringifyInline = (v, depth, path) => {
+        if (v === null)
+            return "null";
+        const t = typeof v;
+        if (t === "string")
+            return JSON.stringify(v);
+        if (t === "number" || t === "boolean")
+            return String(v);
+        if (Array.isArray(v)) {
+            if (!v.length)
+                return "[]";
+            const parts = v.map((vv, i) => stringifyInline(vv));
+            return `[${parts.join(", ")}]`;
+        }
+        if (t === "object") {
+            const keys = Object.keys(v);
+            if (!keys.length)
+                return "{}";
+            const parts = keys.map((k) => `${formatKey(k)}: ${stringifyInline(v[k])}`);
+            return `{ ${parts.join(", ")} }`;
+        }
+        // Shouldn't happen after JSON.parse(JSON.stringify(...)), but keep output valid JSON.
+        return "null";
+    };
+    const stringifyPretty = (v, depth, path, key) => {
+        if (shouldInline(path, key, v, depth))
+            return stringifyInline(v);
+        if (v === null)
+            return "null";
+        const t = typeof v;
+        if (t === "string")
+            return JSON.stringify(v);
+        if (t === "number" || t === "boolean")
+            return String(v);
+        const indentCur = " ".repeat(indentSize * depth);
+        const indentInner = " ".repeat(indentSize * (depth + 1));
+        if (Array.isArray(v)) {
+            if (!v.length)
+                return "[]";
+            // Compact array style: `[{...}, {...}]` while still allowing multi-line objects within.
+            const parts = v.map((vv, i) => stringifyPretty(vv, depth, `${path}[${i}]`, String(i)));
+            return `[${parts.join(", ")}]`;
+        }
+        if (t === "object") {
+            const keys = Object.keys(v);
+            if (!keys.length)
+                return "{}";
+            const lines = keys.map((k, idx) => {
+                const childPath = `${path}.${k}`;
+                const rendered = stringifyPretty(v[k], depth + 1, childPath, k);
+                const comma = idx === keys.length - 1 ? "" : ",";
+                return `${indentInner}${formatKey(k)}: ${rendered}${comma}`;
+            });
+            return `{\n${lines.join("\n")}\n${indentCur}}`;
+        }
+        return "null";
+    };
+    return stringifyPretty(value, 0, "$", "$");
+}
+function tokenizePath(path) {
+    // Path format we generate: `$`, `$.a.b[0].c`
+    // Tokens: ["$", "a", "b", "[0]", "c"]
+    const tokens = [];
+    let i = 0;
+    if (path.startsWith("$")) {
+        tokens.push("$");
+        i = 1;
+    }
+    while (i < path.length) {
+        const ch = path[i];
+        if (ch === ".") {
+            i++;
+            const start = i;
+            while (i < path.length && path[i] !== "." && path[i] !== "[")
+                i++;
+            if (i > start)
+                tokens.push(path.slice(start, i));
+            continue;
         }
+        if (ch === "[") {
+            const end = path.indexOf("]", i + 1);
+            if (end < 0) {
+                tokens.push(path.slice(i));
+                break;
+            }
+            tokens.push(path.slice(i, end + 1));
+            i = end + 1;
+            continue;
+        }
+        // Unexpected char; skip.
+        i++;
     }
-    return false;
+    return tokens.filter((t) => t.length);
+}
+function tokenizePattern(pattern) {
+    // Pattern format: `$`, `$.a.*.b`, `**.graph.**`, `arr[2].z`
+    // Tokens: ["$", "a", "*", "b"] etc. Brackets become their own token: ["arr","[2]","z"]
+    const tokens = [];
+    let i = 0;
+    if (pattern.startsWith("$")) {
+        tokens.push("$");
+        i = 1;
+    }
+    while (i < pattern.length) {
+        const ch = pattern[i];
+        if (ch === ".") {
+            i++;
+            continue;
+        }
+        if (ch === "[") {
+            const end = pattern.indexOf("]", i + 1);
+            if (end < 0) {
+                tokens.push(pattern.slice(i));
+                break;
+            }
+            tokens.push(pattern.slice(i, end + 1));
+            i = end + 1;
+            continue;
+        }
+        const start = i;
+        while (i < pattern.length && pattern[i] !== "." && pattern[i] !== "[")
+            i++;
+        if (i > start)
+            tokens.push(pattern.slice(start, i));
+    }
+    return tokens.filter((t) => t.length);
 }
+function compilePathMatcher(pattern) {
+    // Wildcard semantics (case-insensitive):
+    // - `*` matches exactly 1 path segment (key or `[index]`)
+    // - `**` matches 0 or more segments
+    // - `#` matches exactly 1 numeric segment (e.g. `"0"` or `[0]`)
+    // - `##` matches 0 or more numeric segments
+    // - `[*]` matches exactly 1 index segment
+    const pat = tokenizePattern(pattern);
+    const expectsRoot = pat[0] === "$";
+    const eq = (a, b) => a.localeCompare(b, undefined, { sensitivity: "accent" }) === 0;
+    const isIndex = (t) => t.startsWith("[") && t.endsWith("]");
+    const isNumericKey = (t) => /^[0-9]+$/.test(t);
+    const isNumericSegment = (t) => isNumericKey(t) || (isIndex(t) && /^[0-9]+$/.test(t.slice(1, -1)));
+    const match = (patTokens, pathTokens) => {
+        const memo = new Map();
+        const go = (pi, ti) => {
+            const key = `${pi},${ti}`;
+            const cached = memo.get(key);
+            if (cached !== undefined)
+                return cached;
+            let res = false;
+            if (pi === patTokens.length) {
+                res = ti === pathTokens.length;
+            }
+            else {
+                const p = patTokens[pi];
+                if (p === "**") {
+                    // Match any number of segments, including zero.
+                    for (let k = ti; k <= pathTokens.length; k++) {
+                        if (go(pi + 1, k)) {
+                            res = true;
+                            break;
+                        }
+                    }
+                }
+                else if (p === "##") {
+                    // Match any number of numeric segments, including zero.
+                    for (let k = ti; k <= pathTokens.length; k++) {
+                        let ok = true;
+                        for (let j = ti; j < k; j++) {
+                            if (!isNumericSegment(pathTokens[j])) {
+                                ok = false;
+                                break;
+                            }
+                        }
+                        if (ok && go(pi + 1, k)) {
+                            res = true;
+                            break;
+                        }
+                    }
+                }
+                else if (p === "*") {
+                    res = ti < pathTokens.length && go(pi + 1, ti + 1);
+                }
+                else if (p === "#") {
+                    res =
+                        ti < pathTokens.length &&
+                            isNumericSegment(pathTokens[ti]) &&
+                            go(pi + 1, ti + 1);
+                }
+                else if (p === "[*]") {
+                    res =
+                        ti < pathTokens.length &&
+                            isIndex(pathTokens[ti]) &&
+                            go(pi + 1, ti + 1);
+                }
+                else {
+                    res =
+                        ti < pathTokens.length &&
+                            eq(p.toLowerCase(), pathTokens[ti].toLowerCase()) &&
+                            go(pi + 1, ti + 1);
+                }
+            }
+            memo.set(key, res);
+            return res;
+        };
+        return go(0, 0);
+    };
+    return (tokensWithRoot, tokensNoRoot) => match(pat, expectsRoot ? tokensWithRoot : tokensNoRoot);
+}
+function stringifySceneAndOps(obj) {
+    return stringifyJson(obj, {
+        indent: 2,
+        paths: [
+            "**.camera.animation.*",
+            "**.animations.*",
+            "**.nodes.#.*",
+            "**.graphs.#.*",
+            "**.instances.#.*",
+            "**.shaders.#.*",
+            "**.materials.#.*",
+            "**.ext.#",
+            "**.ext.*.#.*",
+            "**.perUserExt.*.#",
+            "**.perUserExt.*.*.#",
+        ],
+        criteria: ({ value, key }) => (typeof value === "object" &&
+            value &&
+            Object.keys(value).sort().join(",") === "x,y,z") ||
+            key === "value",
+    });
+}
+
 /**
  * A reusable logger class that supports configurable log levels and prefixes.
  * Can be instantiated with a default log level and optionally override per call.
@@ -1108,7 +1563,7 @@ class LevelLogger {
             const contextStr = rest && Object.keys(rest).length > 0
                 ? `${formatJson ? "\n" : " "}${Object.entries(rest)
                     .map(([k, v]) => formatJson
-                    ? `${k}=${JSON.stringify(v, undefined, 2)}`
+                    ? `${k}=${stringifySceneAndOps(v)}`
                     : `${k}=${JSON.stringify(v)}`)
                     .join(formatJson ? "\n" : " ")}`
                 : "";
@@ -1413,29 +1868,63 @@ class RunContextManager {
         for (const id of toCancel) {
             this.graph.clearNodeRunContextIds(id);
         }
-    }
-    /**
-     * Resolve all pending run-context promises (for cleanup)
-     */
-    resolveAll() {
-        const count = this.runContexts.size;
-        this.logger.info("resolve-all-run-contexts", {
-            count,
-            runContextIds: Array.from(this.runContexts.keys()),
-        });
-        for (const ctx of this.runContexts.values()) {
-            if (ctx.resolve)
-                ctx.resolve();
+    }
+    /**
+     * Resolve all pending run-context promises (for cleanup)
+     */
+    resolveAll() {
+        const count = this.runContexts.size;
+        this.logger.info("resolve-all-run-contexts", {
+            count,
+            runContextIds: Array.from(this.runContexts.keys()),
+        });
+        for (const ctx of this.runContexts.values()) {
+            if (ctx.resolve)
+                ctx.resolve();
+        }
+    }
+    /**
+     * Clear all run-contexts
+     */
+    clear() {
+        const count = this.runContexts.size;
+        this.logger.info("clear-all-run-contexts", { count });
+        this.runContexts.clear();
+    }
+}
+
+/**
+ * Shared utility functions for runtime components
+ */
+/**
+ * Type guard to check if a value is a Promise
+ */
+function isPromise(value) {
+    return !!value && typeof value.then === "function";
+}
+/**
+ * Unwrap a value that might be a Promise
+ */
+async function unwrapMaybePromise(value) {
+    return isPromise(value) ? await value : value;
+}
+/**
+ * Shallow/deep-ish equality check to avoid unnecessary runs on identical values
+ */
+function valuesEqual(a, b) {
+    if (a === b)
+        return true;
+    if (typeof a !== typeof b)
+        return false;
+    if (a && b && typeof a === "object") {
+        try {
+            return JSON.stringify(a) === JSON.stringify(b);
+        }
+        catch {
+            return false;
         }
     }
-    /**
-     * Clear all run-contexts
-     */
-    clear() {
-        const count = this.runContexts.size;
-        this.logger.info("clear-all-run-contexts", { count });
-        this.runContexts.clear();
-    }
+    return false;
 }
 
 function tryHandleResolving(def, registry, environment) {
@@ -5553,235 +6042,6 @@ function createValidationGraphRegistry(id) {
     return registry;
 }
 
-function parseJsonPath(path) {
-    if (typeof path === "string") {
-        return path.split(".").flatMap((segment) => {
-            const arrayMatch = segment.match(/^(.+)\[(\d+)\]$/);
-            if (arrayMatch) {
-                const index = parseInt(arrayMatch[2], 10);
-                return arrayMatch[1] ? [arrayMatch[1], index] : [index];
-            }
-            return [segment];
-        });
-    }
-    return path;
-}
-function getValueAtPath(obj, pathSegments) {
-    if (pathSegments.length === 0) {
-        return { value: obj, parent: null, key: "" };
-    }
-    let current = obj;
-    for (let i = 0; i < pathSegments.length - 1; i++) {
-        const segment = pathSegments[i];
-        if (current === null ||
-            current === undefined ||
-            typeof current !== "object") {
-            return null;
-        }
-        if (typeof segment === "string") {
-            if (Array.isArray(current)) {
-                const index = parseInt(segment, 10);
-                if (isNaN(index))
-                    return null;
-                current = current[index];
-            }
-            else {
-                current = current[segment];
-            }
-        }
-        else if (typeof segment === "number") {
-            if (Array.isArray(current)) {
-                if (segment >= 0 && segment < current.length) {
-                    current = current[segment];
-                }
-                else {
-                    return null;
-                }
-            }
-            else {
-                return null;
-            }
-        }
-        else if (segment instanceof RegExp) {
-            if (Array.isArray(current)) {
-                return null;
-            }
-            const obj = current;
-            const matchingKey = Object.keys(obj).find((key) => segment.test(key));
-            if (!matchingKey)
-                return null;
-            current = obj[matchingKey];
-        }
-        else {
-            return null;
-        }
-    }
-    const lastSegment = pathSegments[pathSegments.length - 1];
-    if (typeof lastSegment === "string") {
-        if (Array.isArray(current)) {
-            const index = parseInt(lastSegment, 10);
-            if (isNaN(index))
-                return null;
-            return { value: current[index], parent: current, key: index };
-        }
-        else if (current !== null &&
-            current !== undefined &&
-            typeof current === "object") {
-            return {
-                value: current[lastSegment],
-                parent: current,
-                key: lastSegment,
-            };
-        }
-    }
-    else if (typeof lastSegment === "number") {
-        if (Array.isArray(current)) {
-            if (lastSegment >= 0 && lastSegment < current.length) {
-                return {
-                    value: current[lastSegment],
-                    parent: current,
-                    key: lastSegment,
-                };
-            }
-        }
-        return null;
-    }
-    else if (lastSegment instanceof RegExp) {
-        if (Array.isArray(current)) {
-            return null;
-        }
-        const obj = current;
-        const matchingKey = Object.keys(obj).find((key) => lastSegment.test(key));
-        if (!matchingKey)
-            return null;
-        return { value: obj[matchingKey], parent: current, key: matchingKey };
-    }
-    return null;
-}
-function setValueAtPath(obj, pathSegments, newValue) {
-    const result = getValueAtPath(obj, pathSegments);
-    if (!result || result.parent === null)
-        return false;
-    if (Array.isArray(result.parent)) {
-        result.parent[result.key] = newValue;
-    }
-    else {
-        result.parent[result.key] = newValue;
-    }
-    return true;
-}
-/**
- * Sets a value at a path, creating intermediate objects as needed.
- * Mutates the root object in place.
- * @param root - The root object to modify (must be an object, will be initialized if needed)
- * @param pathSegments - The path segments to traverse
- * @param value - The value to set, or null to delete the path
- * @throws Error if path cannot be created (e.g., array indices not supported, invalid parent types)
- */
-function setValueAtPathWithCreation(root, pathSegments, value) {
-    if (value === null) {
-        const result = getValueAtPath(root, pathSegments);
-        if (result && result.parent !== null && !Array.isArray(result.parent)) {
-            delete result.parent[result.key];
-        }
-        return;
-    }
-    if (!root || typeof root !== "object" || Array.isArray(root)) {
-        throw new Error("Root must be an object");
-    }
-    let current = root;
-    for (let i = 0; i < pathSegments.length - 1; i++) {
-        const segment = pathSegments[i];
-        if (typeof segment === "string") {
-            if (!current ||
-                typeof current !== "object" ||
-                Array.isArray(current) ||
-                !(segment in current) ||
-                typeof current[segment] !== "object" ||
-                current[segment] === null ||
-                Array.isArray(current[segment])) {
-                if (!current || typeof current !== "object" || Array.isArray(current)) {
-                    throw new Error(`Cannot create path: parent at segment ${i} is not an object`);
-                }
-                current[segment] = {};
-            }
-            current = current[segment];
-        }
-        else {
-            throw new Error("Array indices not supported in extData paths");
-        }
-    }
-    const lastSegment = pathSegments[pathSegments.length - 1];
-    if (typeof lastSegment === "string") {
-        if (!current || typeof current !== "object" || Array.isArray(current)) {
-            throw new Error(`Cannot set value: parent at final segment is not an object`);
-        }
-        current[lastSegment] = value;
-    }
-    else {
-        throw new Error("Array indices not supported in extData paths");
-    }
-}
-function findMatchingPaths(obj, pathSegments, currentPath = []) {
-    if (pathSegments.length === 0) {
-        return [{ path: currentPath, value: obj }];
-    }
-    const [currentSegment, ...remainingSegments] = pathSegments;
-    const results = [];
-    if (currentSegment === undefined) {
-        return results;
-    }
-    if (typeof currentSegment === "string") {
-        if (Array.isArray(obj)) {
-            const index = parseInt(currentSegment, 10);
-            if (!isNaN(index) && index >= 0 && index < obj.length) {
-                results.push(...findMatchingPaths(obj[index], remainingSegments, [
-                    ...currentPath,
-                    index,
-                ]));
-            }
-        }
-        else if (obj !== null && obj !== undefined && typeof obj === "object") {
-            const objRecord = obj;
-            if (currentSegment in objRecord) {
-                results.push(...findMatchingPaths(objRecord[currentSegment], remainingSegments, [
-                    ...currentPath,
-                    currentSegment,
-                ]));
-            }
-        }
-    }
-    else if (typeof currentSegment === "number") {
-        if (Array.isArray(obj)) {
-            if (currentSegment >= 0 && currentSegment < obj.length) {
-                results.push(...findMatchingPaths(obj[currentSegment], remainingSegments, [
-                    ...currentPath,
-                    currentSegment,
-                ]));
-            }
-        }
-    }
-    else if (currentSegment instanceof RegExp) {
-        if (Array.isArray(obj)) {
-            for (let i = 0; i < obj.length; i++) {
-                results.push(...findMatchingPaths(obj[i], remainingSegments, [...currentPath, i]));
-            }
-        }
-        else if (obj !== null && obj !== undefined && typeof obj === "object") {
-            const objRecord = obj;
-            for (const key of Object.keys(objRecord)) {
-                if (currentSegment.test(key)) {
-                    results.push(...findMatchingPaths(objRecord[key], remainingSegments, [
-                        ...currentPath,
-                        key,
-                    ]));
-                }
-            }
-        }
-    }
-    return results;
-}
-
 function mergeGraphDefinitions(target, source) {
     const existingNodeIds = new Set(target.nodes.map((n) => n.nodeId));
     const existingEdgeIds = new Set(target.edges.map((e) => e.id));
@@ -6420,6 +6680,8 @@ exports.registerDelayNode = registerDelayNode;
 exports.registerProgressNodes = registerProgressNodes;
 exports.setValueAtPath = setValueAtPath;
 exports.setValueAtPathWithCreation = setValueAtPathWithCreation;
+exports.stringifyJson = stringifyJson;
+exports.stringifySceneAndOps = stringifySceneAndOps;
 exports.typed = typed;
 exports.unwrapTypeId = unwrapTypeId;
 exports.unwrapValue = unwrapValue;