@bian-womp/spark-graph 0.3.71 → 0.3.73

package/lib/cjs/index.cjs

@@ -4,9 +4,7 @@ function typed(typeId, value) {
     return { __spark_type: typeId, __spark_value: value };
 }
 function isTyped(v) {
-    return (!!v &&
-        typeof v === "object" &&
-        Object.prototype.hasOwnProperty.call(v, "__spark_type"));
+    return !!v && typeof v === "object" && Object.prototype.hasOwnProperty.call(v, "__spark_type");
 }
 function unwrapTypeId(v) {
     if (isTyped(v))
@@ -66,12 +64,8 @@ function mergeInputHandleDescriptors(staticDesc, dynamicDesc) {
         (typeof dynamicDesc === "string" || Array.isArray(dynamicDesc))) {
         return dynamicDesc;
     }
-    const staticObj = typeof staticDesc === "string" || Array.isArray(staticDesc)
-        ? { typeId: staticDesc }
-        : staticDesc;
-    const dynamicObj = typeof dynamicDesc === "string" || Array.isArray(dynamicDesc)
-        ? { typeId: dynamicDesc }
-        : dynamicDesc;
+    const staticObj = typeof staticDesc === "string" || Array.isArray(staticDesc) ? { typeId: staticDesc } : staticDesc;
+    const dynamicObj = typeof dynamicDesc === "string" || Array.isArray(dynamicDesc) ? { typeId: dynamicDesc } : dynamicDesc;
     // Merge: dynamic takes precedence, but merge metadata objects
     const merged = {
         typeId: dynamicObj.typeId ?? staticObj.typeId,
@@ -152,7 +146,7 @@ class Registry {
                 };
                 this.types.set(arrayId, arrayDesc);
             }
-            this.registerCoercion(desc.id, arrayId, (value) => Array.isArray(value) ? value : [value]);
+            this.registerCoercion(desc.id, arrayId, (value) => (Array.isArray(value) ? value : [value]));
             this.registerCoercion(arrayId, desc.id, (value) => {
                 if (!Array.isArray(value))
                     return value;
@@ -178,8 +172,8 @@ class Registry {
         const arrayId = `${typeId}[]`;
         if (this.types.has(arrayId) && !this.serializers.has(arrayId)) {
             this.serializers.set(arrayId, {
-                serialize: (value) => Array.isArray(value) ? value.map((el) => s.serialize(el)) : value,
-                deserialize: (data) => Array.isArray(data) ? data.map((el) => s.deserialize(el)) : data,
+                serialize: (value) => (Array.isArray(value) ? value.map((el) => s.serialize(el)) : value),
+                deserialize: (data) => (Array.isArray(data) ? data.map((el) => s.deserialize(el)) : data),
             });
         }
         return this;
@@ -355,8 +349,7 @@ class Registry {
             let i = 0;
             while (i < queue.length) {
                 const q = queue[i];
-                if (e.cost.edges < q.cost.edges ||
-                    (e.cost.edges === q.cost.edges && e.cost.async < q.cost.async)) {
+                if (e.cost.edges < q.cost.edges || (e.cost.edges === q.cost.edges && e.cost.async < q.cost.async)) {
                     break;
                 }
                 i++;
@@ -475,9 +468,7 @@ class Registry {
             const rec = this.enums.get(id);
             if (!rec)
                 return value;
-            return rec.valueToLabel.has(n)
-                ? n
-                : Array.from(rec.valueToLabel.keys())[0] ?? 0;
+            return rec.valueToLabel.has(n) ? n : (Array.from(rec.valueToLabel.keys())[0] ?? 0);
         });
         this.registerCoercion(id, labelType, (value) => {
             const n = Number(value);
@@ -924,8 +915,7 @@ class Graph {
         if (inbound.length === 0)
             return true;
         for (const e of inbound) {
-            if (node.resolvedHandles?.inputs?.[e.target.handle] &&
-                !node.inputs[e.target.handle]) {
+            if (node.resolvedHandles?.inputs?.[e.target.handle] && !node.inputs[e.target.handle]) {
                 return false;
             }
         }
@@ -1003,9 +993,7 @@ function getValueAtPath(obj, pathSegments) {
     let current = obj;
     for (let i = 0; i < pathSegments.length - 1; i++) {
         const segment = pathSegments[i];
-        if (current === null ||
-            current === undefined ||
-            typeof current !== "object") {
+        if (current === null || current === undefined || typeof current !== "object") {
             return null;
         }
         if (typeof segment === "string") {
@@ -1054,9 +1042,7 @@ function getValueAtPath(obj, pathSegments) {
                 return null;
             return { value: current[index], parent: current, key: index };
         }
-        else if (current !== null &&
-            current !== undefined &&
-            typeof current === "object") {
+        else if (current !== null && current !== undefined && typeof current === "object") {
             return {
                 value: current[lastSegment],
                 parent: current,
@@ -1170,29 +1156,20 @@ function findMatchingPaths(obj, pathSegments, currentPath = []) {
         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,
-                ]));
+                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,
-                ]));
+                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,
-                ]));
+                results.push(...findMatchingPaths(obj[currentSegment], remainingSegments, [...currentPath, currentSegment]));
             }
         }
     }
@@ -1206,10 +1183,7 @@ function findMatchingPaths(obj, pathSegments, currentPath = []) {
             const objRecord = obj;
             for (const key of Object.keys(objRecord)) {
                 if (currentSegment.test(key)) {
-                    results.push(...findMatchingPaths(objRecord[key], remainingSegments, [
-                        ...currentPath,
-                        key,
-                    ]));
+                    results.push(...findMatchingPaths(objRecord[key], remainingSegments, [...currentPath, key]));
                 }
             }
         }
@@ -1220,12 +1194,8 @@ 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 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).
@@ -1428,22 +1398,13 @@ function compilePathMatcher(pattern) {
                     res = ti < pathTokens.length && go(pi + 1, ti + 1);
                 }
                 else if (p === "#") {
-                    res =
-                        ti < pathTokens.length &&
-                            isNumericSegment(pathTokens[ti]) &&
-                            go(pi + 1, ti + 1);
+                    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);
+                    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);
+                    res = ti < pathTokens.length && eq(p.toLowerCase(), pathTokens[ti].toLowerCase()) && go(pi + 1, ti + 1);
                 }
             }
             memo.set(key, res);
@@ -1469,10 +1430,7 @@ function stringifySceneAndOps(obj) {
             "**.perUserExt.*.#",
             "**.perUserExt.*.*.#",
         ],
-        criteria: ({ value, key }) => (typeof value === "object" &&
-            value &&
-            Object.keys(value).sort().join(",") === "x,y,z") ||
-            key === "value",
+        criteria: ({ value, key }) => (typeof value === "object" && value && Object.keys(value).sort().join(",") === "x,y,z") || key === "value",
     });
 }
 
@@ -1542,8 +1500,7 @@ class LevelLogger {
     parseJsonStringIfFull(str) {
         const trimmed = str.trim();
         // Check if the string starts with { or [ and ends with } or ]
-        if ((trimmed.startsWith("{") && trimmed.endsWith("}")) ||
-            (trimmed.startsWith("[") && trimmed.endsWith("]"))) {
+        if ((trimmed.startsWith("{") && trimmed.endsWith("}")) || (trimmed.startsWith("[") && trimmed.endsWith("]"))) {
             try {
                 const parsed = JSON.parse(trimmed);
                 return JSON.stringify(parsed, null, 2);
@@ -1562,8 +1519,7 @@ class LevelLogger {
     parseJsonStringToObject(str) {
         const trimmed = str.trim();
         // Check if the string starts with { or [ and ends with } or ]
-        if ((trimmed.startsWith("{") && trimmed.endsWith("}")) ||
-            (trimmed.startsWith("[") && trimmed.endsWith("]"))) {
+        if ((trimmed.startsWith("{") && trimmed.endsWith("}")) || (trimmed.startsWith("[") && trimmed.endsWith("]"))) {
             try {
                 return JSON.parse(trimmed);
             }
@@ -1664,10 +1620,7 @@ class LevelLogger {
                     // (starts with { or [ and contains newlines indicating it was formatted),
                     // output it directly without stringifySceneAndOps to preserve formatting
                     // Wrap it with json`...` to distinguish it as formatted JSON
-                    if (parseJsonString &&
-                        typeof v === "string" &&
-                        v.trim().match(/^[{\[]/) &&
-                        v.includes("\n")) {
+                    if (parseJsonString && typeof v === "string" && v.trim().match(/^[{\[]/) && v.includes("\n")) {
                         return `${k}=json\`${v}\``;
                     }
                     // If this key had a JSON string parsed and we're formatting JSON,
@@ -1682,9 +1635,7 @@ class LevelLogger {
                 })
                     .join(formatJson ? "\n" : " ")}`
                 : "";
-            const prefixedMessage = this.prefix
-                ? `${this.prefix} ${message}${contextStr}`
-                : `${message}${contextStr}`;
+            const prefixedMessage = this.prefix ? `${this.prefix} ${message}${contextStr}` : `${message}${contextStr}`;
             switch (requestedLevel) {
                 case "debug":
                     console.info(prefixedMessage);
@@ -1919,10 +1870,7 @@ class RunContextManager {
             });
             return;
         }
-        if (ctx.pendingNodes > 0 ||
-            ctx.pendingEdges > 0 ||
-            ctx.pendingResolvers > 0 ||
-            ctx.pendingQueued > 0) {
+        if (ctx.pendingNodes > 0 || ctx.pendingEdges > 0 || ctx.pendingResolvers > 0 || ctx.pendingQueued > 0) {
             return; // Still has pending work
         }
         this.logger.info("finish-run-context", {
@@ -2041,6 +1989,19 @@ function valuesEqual(a, b) {
     }
     return false;
 }
+/**
+ * Format a node reference as <typeId>.<nodeId> for logs.
+ */
+function formatNodeRef(graph, nodeId) {
+    const node = graph.getNode(nodeId);
+    return `${node?.typeId ?? "unknown"}.${nodeId}`;
+}
+/**
+ * Format a node handle reference as <typeId>.<nodeId>.<handle> for logs.
+ */
+function formatNodeHandleRef(graph, nodeId, handle) {
+    return `${formatNodeRef(graph, nodeId)}.${handle}`;
+}
 
 function tryHandleResolving(def, registry, environment) {
     const out = new Map();
@@ -2148,9 +2109,7 @@ function extractEdgeTypes(sourceNodeId, sourceHandle, targetNodeId, targetHandle
     const srcDeclared = srcResolved
         ? srcResolved.outputs[sourceHandle]
         : registry.nodes.get(graph.getNode(sourceNodeId)?.typeId || "")?.outputs[sourceHandle];
-    const dstDeclared = getInputDeclaredTypes(dstResolved
-        ? dstResolved.inputs
-        : registry.nodes.get(graph.getNode(targetNodeId)?.typeId || "")?.inputs, targetHandle);
+    const dstDeclared = getInputDeclaredTypes(dstResolved ? dstResolved.inputs : registry.nodes.get(graph.getNode(targetNodeId)?.typeId || "")?.inputs, targetHandle);
     return {
         srcDeclared,
         dstDeclared,
@@ -2246,9 +2205,7 @@ function buildEdgeConverters(srcDeclared, dstDeclared, registry, edgeLabel) {
                 const { typeId, payload } = extractPayload(v);
                 const res = getCoercion(typeId);
                 if (!res) {
-                    const fallbackType = isDstUnion && typeId && dstTypes.includes(typeId)
-                        ? typeId
-                        : undefined;
+                    const fallbackType = isDstUnion && typeId && dstTypes.includes(typeId) ? typeId : undefined;
                     return wrapIfDstUnion(fallbackType, payload);
                 }
                 if (res.kind === "async" && res.convertAsync) {
@@ -2269,9 +2226,7 @@ function buildEdgeConverters(srcDeclared, dstDeclared, registry, edgeLabel) {
             const { typeId, payload } = extractPayload(v);
             const res = getCoercion(typeId);
             if (!res) {
-                const fallbackType = isDstUnion && typeId && dstTypes.includes(typeId)
-                    ? typeId
-                    : undefined;
+                const fallbackType = isDstUnion && typeId && dstTypes.includes(typeId) ? typeId : undefined;
                 return wrapIfDstUnion(fallbackType, payload);
             }
             if (res.kind === "async") {
@@ -2445,15 +2400,11 @@ class HandleResolver {
             // Update edge properties via Graph
             this.graph.updateEdgeProperties(e.id, {
                 dstDeclared,
-                srcUnionTypes: Array.isArray(srcDeclared)
-                    ? [...srcDeclared]
-                    : undefined,
+                srcUnionTypes: Array.isArray(srcDeclared) ? [...srcDeclared] : undefined,
                 convert: conv.convert,
                 convertAsync: conv.convertAsync,
             });
-            if (e.target.nodeId === nodeId &&
-                oldDstDeclared === undefined &&
-                dstDeclared !== undefined) {
+            if (e.target.nodeId === nodeId && oldDstDeclared === undefined && dstDeclared !== undefined) {
                 const srcNode = this.graph.getNode(e.source.nodeId);
                 if (srcNode) {
                     const srcValue = srcNode.outputs[e.source.handle];
@@ -2489,7 +2440,7 @@ class HandleResolver {
             const nodeLogValue = LOG_LEVEL_VALUES[nodeLogLevel] ?? 1;
             const shouldLog = nodeLogValue <= LOG_LEVEL_VALUES.debug && nodeLogLevel !== "silent";
             if (shouldLog) {
-                console.info(`[node:${nodeId}:${node.typeId}] resolveHandles-start`);
+                console.info(`[node:${formatNodeRef(this.graph, nodeId)}] resolveHandles-start`);
             }
             let resolved;
             try {
@@ -2504,13 +2455,13 @@ class HandleResolver {
             catch {
                 // Log resolveHandles-done even on error
                 if (shouldLog) {
-                    console.info(`[node:${nodeId}:${node.typeId}] resolveHandles-done (error)`);
+                    console.info(`[node:${formatNodeRef(this.graph, nodeId)}] resolveHandles-done (error)`);
                 }
                 return;
             }
             // Log resolveHandles-done
             if (shouldLog) {
-                console.info(`[node:${nodeId}:${node.typeId}] resolveHandles-done`);
+                console.info(`[node:${formatNodeRef(this.graph, nodeId)}] resolveHandles-done`);
             }
             // If a newer recompute was scheduled, drop this result
             if ((this.recomputeTokenByNode.get(nodeId) ?? 0) !== token)
@@ -2572,11 +2523,10 @@ class HandleResolver {
  * EdgePropagator component - handles value propagation through edges
  */
 class EdgePropagator {
-    constructor(graph, eventEmitter, runContextManager, handleResolver, nodeExecutor, runtime) {
+    constructor(graph, eventEmitter, runContextManager, nodeExecutor, runtime) {
         this.graph = graph;
         this.eventEmitter = eventEmitter;
         this.runContextManager = runContextManager;
-        this.handleResolver = handleResolver;
         this.nodeExecutor = nodeExecutor;
         this.runtime = runtime;
         this.arrayInputBuckets = new Map();
@@ -2606,9 +2556,7 @@ class EdgePropagator {
         const effectiveRunContexts = runContextIds && runContextIds.size > 0
             ? this.filterEffectiveRunContexts(edge, srcNodeId, runContextIds)
             : undefined;
-        if (runContextIds &&
-            runContextIds.size > 0 &&
-            !(effectiveRunContexts && effectiveRunContexts.size > 0)) {
+        if (runContextIds && runContextIds.size > 0 && !(effectiveRunContexts && effectiveRunContexts.size > 0)) {
             return; // No valid run-contexts for this edge
         }
         // Validate union types
@@ -2649,12 +2597,16 @@ class EdgePropagator {
         const isUnion = Array.isArray(edge.srcUnionTypes);
         const isTypedValue = isTyped(value);
         if (isUnion && !isTypedValue) {
+            const sourceTypeId = this.graph.getNode(edge.source.nodeId)?.typeId;
+            const targetTypeId = this.graph.getNode(edge.target.nodeId)?.typeId;
             const err = new Error(`Output ${srcNodeId}.${edge.source.handle} requires typed value for union output (allowed: ${edge.srcUnionTypes.join("|")})`);
             this.eventEmitter.emit("error", {
                 kind: "edge-convert",
                 edgeId: edge.id,
                 source: { nodeId: edge.source.nodeId, handle: edge.source.handle },
                 target: { nodeId: edge.target.nodeId, handle: edge.target.handle },
+                sourceTypeId,
+                targetTypeId,
                 err,
             });
             return false;
@@ -2670,7 +2622,14 @@ class EdgePropagator {
             convertedValue = edge.convert(value);
         }
         else {
-            console.warn(`No convert function for edge ${edge.id} of type ${edge.source.nodeId}.${edge.source.handle} -> ${edge.target.nodeId}.${edge.target.handle}`);
+            const fromType = (Array.isArray(edge.srcUnionTypes) && edge.srcUnionTypes.length > 0
+                ? edge.srcUnionTypes.join("|")
+                : undefined) ??
+                unwrapTypeId(value) ??
+                edge.typeId ??
+                "unknown";
+            const toType = Array.isArray(edge.dstDeclared) ? edge.dstDeclared.join("|") : (edge.dstDeclared ?? "unknown");
+            console.warn(`No convert function for edge ${edge.id} [${formatNodeHandleRef(this.graph, edge.source.nodeId, edge.source.handle)} -> ${formatNodeHandleRef(this.graph, edge.target.nodeId, edge.target.handle)}] from:${fromType} to:${toType}`);
         }
         this.applyToTarget(edge, convertedValue, effectiveRunContexts);
     }
@@ -2681,20 +2640,22 @@ class EdgePropagator {
         if (!edge.convertAsync)
             return;
         // Track edge run-context IDs for pendingEdges tracking
-        const edgeRunContextIds = effectiveRunContexts
-            ? Array.from(effectiveRunContexts)
-            : undefined;
+        const edgeRunContextIds = effectiveRunContexts ? Array.from(effectiveRunContexts) : undefined;
         if (edgeRunContextIds) {
             for (const id of edgeRunContextIds) {
                 this.runContextManager.startEdgeConversion(id, edge.id);
             }
         }
+        const sourceTypeId = this.graph.getNode(edge.source.nodeId)?.typeId;
+        const targetTypeId = this.graph.getNode(edge.target.nodeId)?.typeId;
         this.eventEmitter.emit("stats", {
             kind: "edge-start",
             edgeId: edge.id,
             typeId: edge.typeId,
             source: { nodeId: edge.source.nodeId, handle: edge.source.handle },
             target: { nodeId: edge.target.nodeId, handle: edge.target.handle },
+            sourceTypeId,
+            targetTypeId,
         });
         const controller = new AbortController();
         const startAt = Date.now();
@@ -2754,7 +2715,7 @@ class EdgePropagator {
         // Set input value (respecting skipPropagateValues)
         const shouldSetValue = this.shouldSetInputValue(effectiveRunContexts);
         if (shouldSetValue && valueChanged) {
-            this.setTargetInput(edge, processedValue);
+            this.runtime.setTargetInput(edge, processedValue, "applyToTarget");
         }
         else if (shouldSetValue && !valueChanged) {
             // Even if value didn't change, update timestamp if we're forcing execution
@@ -2772,7 +2733,7 @@ class EdgePropagator {
         if (!dstIsArray) {
             return value;
         }
-        const toArray = (x) => Array.isArray(x) ? x : x === undefined ? [] : [x];
+        const toArray = (x) => (Array.isArray(x) ? x : x === undefined ? [] : [x]);
         let forNode = this.arrayInputBuckets.get(edge.target.nodeId);
         if (!forNode) {
             forNode = new Map();
@@ -2810,13 +2771,6 @@ class EdgePropagator {
         }
         return true;
     }
-    /**
-     * Set target input value and emit event
-     */
-    setTargetInput(edge, value) {
-        this.graph.updateNodeInput(edge.target.nodeId, edge.target.handle, value);
-        this.handleResolver.scheduleRecomputeHandles(edge.target.nodeId);
-    }
     /**
      * Execute downstream if conditions are met
      */
@@ -2863,6 +2817,8 @@ class EdgePropagator {
             typeId: edge.typeId,
             source: { nodeId: edge.source.nodeId, handle: edge.source.handle },
             target: { nodeId: edge.target.nodeId, handle: edge.target.handle },
+            sourceTypeId: this.graph.getNode(edge.source.nodeId)?.typeId,
+            targetTypeId: this.graph.getNode(edge.target.nodeId)?.typeId,
             durationMs: duration,
         });
     }
@@ -2879,6 +2835,8 @@ class EdgePropagator {
             edgeId: edge.id,
             source: { nodeId: edge.source.nodeId, handle: edge.source.handle },
             target: { nodeId: edge.target.nodeId, handle: edge.target.handle },
+            sourceTypeId: this.graph.getNode(edge.source.nodeId)?.typeId,
+            targetTypeId: this.graph.getNode(edge.target.nodeId)?.typeId,
             err,
         });
     }
@@ -2923,9 +2881,7 @@ class EdgePropagator {
             return;
         // Get resolved handles to filter out invalid outputs
         const resolved = this.graph.getResolvedHandles(nodeId);
-        const validOutputHandles = resolved?.outputs
-            ? new Set(Object.keys(resolved.outputs))
-            : new Set();
+        const validOutputHandles = resolved?.outputs ? new Set(Object.keys(resolved.outputs)) : new Set();
         // Use node's activeRunContexts to propagate to new nodes that were added
         const activeRunContextIds = this.graph.getNodeRunContextIds(nodeId);
         for (const [handle, value] of Object.entries(node.outputs)) {
@@ -2996,7 +2952,7 @@ class NodeExecutor {
         // Create log function that respects node's logLevel using LevelLogger
         const node = this.graph.getNode(nodeId);
         const nodeLogLevel = node?.logLevel ?? "info";
-        const logger = new LevelLogger(nodeLogLevel, `[node:${runId || nodeId}:${node?.typeId ?? ""}]`);
+        const logger = new LevelLogger(nodeLogLevel, `[node:${formatNodeRef(this.graph, nodeId)}:${runId}]`);
         const log = (level, message, context) => {
             switch (level) {
                 case "debug":
@@ -3024,11 +2980,8 @@ class NodeExecutor {
             execute: (opts) => {
                 if (this.graph.allInboundHaveValue(nodeId)) {
                     let runContextIdsToUse = this.runtime.getRunMode() === "auto" ? undefined : runContextIds;
-                    if (this.runtime.getRunMode() === "manual" &&
-                        (!runContextIds || runContextIds.size === 0)) {
-                        runContextIdsToUse = new Set([
-                            this.runContextManager.createRunContext(nodeId, opts),
-                        ]);
+                    if (this.runtime.getRunMode() === "manual" && (!runContextIds || runContextIds.size === 0)) {
+                        runContextIdsToUse = new Set([this.runContextManager.createRunContext(nodeId, opts)]);
                     }
                     this.execute(nodeId, {
                         runContextIds: runContextIdsToUse,
@@ -3064,24 +3017,22 @@ class NodeExecutor {
             return;
         const runMode = this.runtime.getRunMode();
         if (!runMode) {
-            console.trace(`NodeExecutor.execute[${nodeId}:${reason}]: no runMode, skipping execution`);
+            console.trace(`NodeExecutor.execute[${formatNodeRef(this.graph, nodeId)}:${reason}]: no runMode, skipping execution`);
             return;
         }
         // In manual mode, require runContextIds unless autoRun policy is set
         if (runMode === "manual" && (!runContextIds || runContextIds.size === 0)) {
             // If autoRun is true, auto-generate a run context (similar to createExecutionContext pattern)
             if (node.policy?.autoRun === true) {
-                runContextIds = new Set([
-                    this.runContextManager.createRunContext(nodeId, { propagate: false }),
-                ]);
+                runContextIds = new Set([this.runContextManager.createRunContext(nodeId, { propagate: false })]);
             }
             else {
-                console.trace(`NodeExecutor.execute[${nodeId}:${reason}]: no runContextIds provided in manual mode, skipping execution`);
+                console.trace(`NodeExecutor.execute[${formatNodeRef(this.graph, nodeId)}:${reason}]: no runContextIds provided in manual mode, skipping execution`);
                 return;
             }
         }
         if (runMode === "auto" && runContextIds && runContextIds.size > 0) {
-            console.trace(`NodeExecutor.execute[${nodeId}:${reason}]: runContextIds provided in auto mode, ignoring`);
+            console.trace(`NodeExecutor.execute[${formatNodeRef(this.graph, nodeId)}:${reason}]: runContextIds provided in auto mode, ignoring`);
             runContextIds = undefined;
         }
         // Early validation for auto-mode paused state
@@ -3096,6 +3047,7 @@ class NodeExecutor {
                 code: runtimeValidationError.code || "RUNTIME_VALIDATION_BLOCKED",
                 details: {
                     nodeId,
+                    nodeTypeId: node?.typeId,
                     ...runtimeValidationError.details,
                 },
             });
@@ -3106,8 +3058,7 @@ class NodeExecutor {
         if (runContextIds) {
             this.graph.addNodeRunContextIds(nodeId, runContextIds);
         }
-        if (!canSkipHandleResolution &&
-            !this.handleResolver.getPendingResolution(nodeId)) {
+        if (!canSkipHandleResolution && !this.handleResolver.getPendingResolution(nodeId)) {
             this.handleResolver.scheduleRecomputeHandles(nodeId);
         }
         // Check if handles are being resolved - wait for resolution before executing
@@ -3158,9 +3109,7 @@ class NodeExecutor {
             return false;
         const policy = node.policy ?? {};
         const lastScheduledAt = node.lastScheduledAt;
-        return !!(policy.debounceMs &&
-            lastScheduledAt &&
-            now - lastScheduledAt < policy.debounceMs);
+        return !!(policy.debounceMs && lastScheduledAt && now - lastScheduledAt < policy.debounceMs);
     }
     /**
      * Handle debounced scheduling by replacing the latest queued item
@@ -3443,6 +3392,7 @@ class NodeExecutor {
                 this.eventEmitter.emit("error", {
                     kind: "node-run",
                     nodeId,
+                    nodeTypeId: node.typeId,
                     runId: plan.runId,
                     err,
                 });
@@ -3475,9 +3425,7 @@ class NodeExecutor {
             return;
         const controllers = this.graph.getNodeControllers(nodeId);
         const lastEndAt = Date.now();
-        const lastDurationMs = node.stats.lastStartAt && lastEndAt
-            ? lastEndAt - node.stats.lastStartAt
-            : undefined;
+        const lastDurationMs = node.stats.lastStartAt && lastEndAt ? lastEndAt - node.stats.lastStartAt : undefined;
         this.graph.updateNodeStats(nodeId, {
             active: Math.max(0, controllers.size),
             lastEndAt,
@@ -3645,7 +3593,7 @@ class RuntimeValidatorManager {
             }
             catch (err) {
                 // Don't let validator errors break execution - log and continue
-                console.error(`Runtime validator error for node ${nodeId}:`, err);
+                console.error(`Runtime validator error for node ${formatNodeRef(this.graph, nodeId)}:`, err);
             }
         }
         return null;
@@ -3666,7 +3614,7 @@ class GraphRuntime {
         this.graph = new Graph(this.eventEmitter);
         this.runContextManager = new RunContextManager(this.graph, "warn");
         this.handleResolver = new HandleResolver(this.graph, this.eventEmitter, this.runContextManager, this);
-        this.edgePropagator = new EdgePropagator(this.graph, this.eventEmitter, this.runContextManager, this.handleResolver, this, this);
+        this.edgePropagator = new EdgePropagator(this.graph, this.eventEmitter, this.runContextManager, this, this);
         // Create NodeExecutor with EdgePropagator and HandleResolver
         this.nodeExecutor = new NodeExecutor(this.graph, this.eventEmitter, this.runContextManager, this.handleResolver, this, this);
         // Create RuntimeValidatorManager
@@ -3755,6 +3703,30 @@ class GraphRuntime {
     on(event, handler) {
         return this.eventEmitter.on(event, handler);
     }
+    /**
+     * Check if an event is an invalidate event that should trigger re-execution
+     */
+    isInvalidateEvent(event) {
+        if (!event || typeof event !== "object")
+            return false;
+        // Check if event has action === "invalidate"
+        const e = event;
+        return e.action === "invalidate";
+    }
+    executeNodeAutoRun(nodeId, opts) {
+        const node = this.graph.getNode(nodeId);
+        const shouldAutoRun = this.runMode === "auto" || node?.policy?.autoRun === true;
+        let runContextIdsToUse = undefined;
+        if (this.runMode === "manual") {
+            runContextIdsToUse = new Set([this.runContextManager.createRunContext(nodeId, { propagate: false })]);
+        }
+        if (shouldAutoRun && this.graph.allInboundHaveValue(nodeId)) {
+            this.execute(nodeId, {
+                runContextIds: runContextIdsToUse,
+                reason: opts?.reason ?? "executeNodeAutoRun",
+            });
+        }
+    }
     setInputs(nodeId, inputs) {
         const node = this.graph.getNode(nodeId);
         if (!node)
@@ -3780,11 +3752,7 @@ class GraphRuntime {
                     : desc
                         ? getInputDeclaredTypes(desc.inputs, handle)
                         : undefined;
-                const typeIds = Array.isArray(declaredTypes)
-                    ? declaredTypes
-                    : declaredTypes
-                        ? [declaredTypes]
-                        : [];
+                const typeIds = Array.isArray(declaredTypes) ? declaredTypes : declaredTypes ? [declaredTypes] : [];
                 if (typeIds.length > 0) {
                     const isValidForAny = typeIds.some((tId) => {
                         const typeDesc = registry.types.get(tId);
@@ -3795,10 +3763,11 @@ class GraphRuntime {
                     });
                     if (value !== undefined && !isValidForAny) {
                         const typeLabel = typeIds.join("|");
-                        const errorMessage = `Invalid value for input ${nodeId}.${handle} (type ${typeLabel}): ${JSON.stringify(value)}`;
+                        const errorMessage = `Invalid value for input ${formatNodeRef(this.graph, nodeId)}.${handle} (type ${typeLabel}): ${JSON.stringify(value)}`;
                         this.eventEmitter.emit("error", {
                             kind: "input-validation",
                             nodeId,
+                            nodeTypeId: node.typeId,
                             handle,
                             typeId: typeLabel,
                             value,
@@ -3813,8 +3782,6 @@ class GraphRuntime {
             const same = valuesEqual(prev, value);
             if (!same) {
                 this.graph.updateNodeInput(nodeId, handle, value);
-                // Emit value event for input updates
-                this.eventEmitter.emit("value", { nodeId, handle, value, io: "input" });
                 anyChanged = true;
             }
         }
@@ -3866,16 +3833,6 @@ class GraphRuntime {
         // Forward event to node's onExternalEvent handler for custom actions
         node.runtime.onExternalEvent?.(event, node.state);
     }
-    /**
-     * Check if an event is an invalidate event that should trigger re-execution
-     */
-    isInvalidateEvent(event) {
-        if (!event || typeof event !== "object")
-            return false;
-        // Check if event has action === "invalidate"
-        const e = event;
-        return e.action === "invalidate";
-    }
     cancelNodeRuns(nodeIds) {
         this.nodeExecutor.cancelNodeRuns(nodeIds);
     }
@@ -3903,6 +3860,7 @@ class GraphRuntime {
         this.nodeExecutor.setEnvironment(this.environment);
         for (const nodeId of this.graph.getNodeIds()) {
             this.handleResolver.scheduleRecomputeHandles(nodeId);
+            this.executeNodeAutoRun(nodeId, { reason: "setEnvironment" });
         }
     }
     setCustomNodeData(customNodeData) {
@@ -4050,21 +4008,10 @@ class GraphRuntime {
             }
         }
     }
-    executeNodeAutoRun(nodeId, opts) {
-        const node = this.graph.getNode(nodeId);
-        const shouldAutoRun = this.runMode === "auto" || node?.policy?.autoRun === true;
-        let runContextIdsToUse = undefined;
-        if (this.runMode === "manual") {
-            runContextIdsToUse = new Set([
-                this.runContextManager.createRunContext(nodeId, { propagate: false }),
-            ]);
-        }
-        if (shouldAutoRun && this.graph.allInboundHaveValue(nodeId)) {
-            this.execute(nodeId, {
-                runContextIds: runContextIdsToUse,
-                reason: opts?.reason ?? "executeNodeAutoRun",
-            });
-        }
+    setTargetInput(edge, value, reason) {
+        this.graph.updateNodeInput(edge.target.nodeId, edge.target.handle, value);
+        this.handleResolver.scheduleRecomputeHandles(edge.target.nodeId);
+        this.executeNodeAutoRun(edge.target.nodeId, { reason });
     }
     copyOutputs(fromNodeId, toNodeId, options) {
         const fromNode = this.getNodeData(fromNodeId);
@@ -4230,8 +4177,7 @@ class GraphRuntime {
                 set.add(e.target.handle);
                 beforeInbound.set(e.target.nodeId, set);
                 // Build beforeOutTargets map
-                const tmap = beforeOutTargets.get(e.source.nodeId) ??
-                    new Map();
+                const tmap = beforeOutTargets.get(e.source.nodeId) ?? new Map();
                 const tset = tmap.get(e.source.handle) ?? new Set();
                 tset.add(`${e.target.nodeId}.${e.target.handle}`);
                 tmap.set(e.source.handle, tset);
@@ -4251,8 +4197,7 @@ class GraphRuntime {
                 const changedHandles = {};
                 for (const [nodeId, newHandles] of result.resolved) {
                     const oldHandles = this.graph.getResolvedHandles(nodeId);
-                    if (!oldHandles ||
-                        JSON.stringify(oldHandles) !== JSON.stringify(newHandles)) {
+                    if (!oldHandles || JSON.stringify(oldHandles) !== JSON.stringify(newHandles)) {
                         changedHandles[nodeId] = newHandles;
                     }
                 }
@@ -4304,8 +4249,7 @@ class GraphRuntime {
                 // Propagate changes on edges added
                 const afterOutTargets = new Map();
                 this.graph.forEachEdge((e) => {
-                    const targetMap = afterOutTargets.get(e.source.nodeId) ??
-                        new Map();
+                    const targetMap = afterOutTargets.get(e.source.nodeId) ?? new Map();
                     const targetSet = targetMap.get(e.source.handle) ?? new Set();
                     targetSet.add(`${e.target.nodeId}.${e.target.handle}`);
                     targetMap.set(e.source.handle, targetSet);
@@ -4330,10 +4274,7 @@ class GraphRuntime {
                 for (const nodeId of nodesToCheck) {
                     const beforeMap = beforeOutTargets.get(nodeId) ?? new Map();
                     const afterMap = afterOutTargets.get(nodeId) ?? new Map();
-                    const handles = new Set([
-                        ...Array.from(beforeMap.keys()),
-                        ...Array.from(afterMap.keys()),
-                    ]);
+                    const handles = new Set([...Array.from(beforeMap.keys()), ...Array.from(afterMap.keys())]);
                     for (const handle of handles) {
                         const beforeTargetSet = beforeMap.get(handle) ?? new Set();
                         const afterTargetSet = afterMap.get(handle) ?? new Set();
@@ -4454,7 +4395,10 @@ class GraphBuilder {
             effByNodeId.set(n.nodeId, getEffectiveHandles(n));
             const nodeType = this.registry.nodes.get(n.typeId);
             if (!nodeType) {
-                pushIssue("error", "NODE_TYPE_MISSING", `Unknown node type ${n.typeId}`, { typeId: n.typeId, nodeId: n.nodeId });
+                pushIssue("error", "NODE_TYPE_MISSING", `Unknown node type ${n.typeId}`, {
+                    typeId: n.typeId,
+                    nodeId: n.nodeId,
+                });
                 continue;
             }
             if (!this.registry.categories.has(nodeType.categoryId)) {
@@ -4474,9 +4418,7 @@ class GraphBuilder {
                         typeof paramValue === "number" &&
                         !enumTypes.some((et) => validateEnumValue(et, paramValue, n.nodeId))) {
                         const enumDef = this.registry.enums.get(enumTypes[0]);
-                        const validValues = enumDef
-                            ? Array.from(enumDef.valueToLabel.keys()).join(", ")
-                            : "unknown";
+                        const validValues = enumDef ? Array.from(enumDef.valueToLabel.keys()).join(", ") : "unknown";
                         pushIssue("error", "ENUM_VALUE_INVALID", `Node ${n.nodeId} param ${paramKey} has invalid enum value ${paramValue}. Valid values: ${validValues}`, {
                             nodeId: n.nodeId,
                             input: paramKey,
@@ -4496,9 +4438,7 @@ class GraphBuilder {
                         typeof defaultValue === "number" &&
                         !enumTypes.some((et) => validateEnumValue(et, defaultValue, n.nodeId))) {
                         const enumDef = this.registry.enums.get(enumTypes[0]);
-                        const validValues = enumDef
-                            ? Array.from(enumDef.valueToLabel.keys()).join(", ")
-                            : "unknown";
+                        const validValues = enumDef ? Array.from(enumDef.valueToLabel.keys()).join(", ") : "unknown";
                         pushIssue("warning", "ENUM_DEFAULT_INVALID", `Node ${n.nodeId} input default ${handle} has invalid enum value ${defaultValue}. Valid values: ${validValues}`, {
                             nodeId: n.nodeId,
                             input: handle,
@@ -4541,7 +4481,9 @@ class GraphBuilder {
             if (e.typeId) {
                 const type = this.registry.types.get(e.typeId);
                 if (!type) {
-                    pushIssue("error", "TYPE_MISSING", `Edge ${e.id} explicit type ${e.typeId} is missing or unknown`, { edgeId: e.id });
+                    pushIssue("error", "TYPE_MISSING", `Edge ${e.id} explicit type ${e.typeId} is missing or unknown`, {
+                        edgeId: e.id,
+                    });
                 }
             }
             if (srcNode) {
@@ -4630,19 +4572,13 @@ class GraphBuilder {
         const outputTypes = {};
         for (const [outerIn, map] of Object.entries(exposure.inputs)) {
             const innerNode = def.nodes.find((n) => n.nodeId === map.nodeId);
-            const innerDesc = innerNode
-                ? this.registry.nodes.get(innerNode.typeId)
-                : undefined;
-            const typeIds = innerDesc
-                ? getInputDeclaredTypes(innerDesc.inputs, map.handle)
-                : undefined;
+            const innerDesc = innerNode ? this.registry.nodes.get(innerNode.typeId) : undefined;
+            const typeIds = innerDesc ? getInputDeclaredTypes(innerDesc.inputs, map.handle) : undefined;
             inputTypes[outerIn] = typeIds ?? "unknown";
         }
         for (const [outerOut, map] of Object.entries(exposure.outputs)) {
             const innerNode = def.nodes.find((n) => n.nodeId === map.nodeId);
-            const innerDesc = innerNode
-                ? this.registry.nodes.get(innerNode.typeId)
-                : undefined;
+            const innerDesc = innerNode ? this.registry.nodes.get(innerNode.typeId) : undefined;
             const typeId = innerDesc ? innerDesc.outputs[map.handle] : undefined;
             const single = Array.isArray(typeId) ? typeId[0] : typeId;
             outputTypes[outerOut] = single ?? "unknown";
@@ -4845,7 +4781,7 @@ const CompositeCategory = (registry) => ({
 });
 
 // Helpers
-const asArray = (v) => Array.isArray(v) ? v : [Number(v)];
+const asArray = (v) => (Array.isArray(v) ? v : [Number(v)]);
 const broadcast = (a, b) => {
     const aa = asArray(a);
     const bb = asArray(b);
@@ -4858,7 +4794,7 @@ const broadcast = (a, b) => {
     const len = Math.max(aa.length, bb.length);
     return [new Array(len).fill(aa[0] ?? 0), new Array(len).fill(bb[0] ?? 0)];
 };
-const asBoolArray = (v) => Array.isArray(v) ? v.map((x) => Boolean(x)) : [Boolean(v)];
+const asBoolArray = (v) => (Array.isArray(v) ? v.map((x) => Boolean(x)) : [Boolean(v)]);
 const broadcastBool = (a, b) => {
     const aa = asBoolArray(a);
     const bb = asBoolArray(b);
@@ -4869,10 +4805,7 @@ const broadcastBool = (a, b) => {
     if (bb.length === 1)
         return [aa, new Array(aa.length).fill(bb[0])];
     const len = Math.max(aa.length, bb.length);
-    return [
-        new Array(len).fill(aa[0] ?? false),
-        new Array(len).fill(bb[0] ?? false),
-    ];
+    return [new Array(len).fill(aa[0] ?? false), new Array(len).fill(bb[0] ?? false)];
 };
 const clamp = (x, min, max) => Math.min(max, Math.max(min, x));
 const lerp = (a, b, t) => a + (b - a) * t;
@@ -4922,8 +4855,7 @@ function jsonPointerSet(obj, pointer, value) {
             if (next === undefined || next === null) {
                 // create container heuristically
                 const nextKey = parts[i + 1];
-                cur[key] =
-                    typeof nextKey === "string" && /^[0-9]+$/.test(nextKey) ? [] : {};
+                cur[key] = typeof nextKey === "string" && /^[0-9]+$/.test(nextKey) ? [] : {};
             }
             cur = cur[key];
         }
@@ -5057,9 +4989,7 @@ function setupBasicGraphRegistry(id) {
     }, { withArray: false });
     registry.registerType({
         id: "base.vec3",
-        validate: (v) => Array.isArray(v) &&
-            v.length === 3 &&
-            v.every((x) => typeof x === "number"),
+        validate: (v) => Array.isArray(v) && v.length === 3 && v.every((x) => typeof x === "number"),
         bakeTarget: { nodeTypeId: "base.input.vec3", inputHandle: "Value" },
     }, { withArray: true, arrayPickFirstDefined: true });
     // float -> vec3 : map x to [x,0,0]
@@ -5104,9 +5034,7 @@ function setupBasicGraphRegistry(id) {
     });
     registry.registerCoercion("base.object", "base.vec3", (v) => {
         try {
-            if (Array.isArray(v) &&
-                v.length === 3 &&
-                v.every((x) => typeof x === "number")) {
+            if (Array.isArray(v) && v.length === 3 && v.every((x) => typeof x === "number")) {
                 return v;
             }
             return undefined;
@@ -5236,9 +5164,7 @@ function setupBasicGraphRegistry(id) {
             const [a, b] = broadcast(ins.ValueA, ins.ValueB);
             const t = Number(ins.Factor ?? 0);
             const len = Math.max(a.length, b.length);
-            const out = new Array(len)
-                .fill(0)
-                .map((_, i) => lerp(Number(a[i] ?? 0), Number(b[i] ?? 0), t));
+            const out = new Array(len).fill(0).map((_, i) => lerp(Number(a[i] ?? 0), Number(b[i] ?? 0), t));
             return { Value: out };
         },
     });
@@ -5266,9 +5192,7 @@ function setupBasicGraphRegistry(id) {
             const out = vals.map((v) => {
                 const t = (Number(v) - fromMin) / (fromMax - fromMin || 1);
                 const r = toMin + t * (toMax - toMin);
-                return doClamp
-                    ? clamp(r, Math.min(toMin, toMax), Math.max(toMin, toMax))
-                    : r;
+                return doClamp ? clamp(r, Math.min(toMin, toMax), Math.max(toMin, toMax)) : r;
             });
             return { Value: out };
         },
@@ -5312,8 +5236,8 @@ function setupBasicGraphRegistry(id) {
                     const sum = arr.reduce((s, x) => s + Number(x || 0), 0);
                     return arr.length ? sum / arr.length : 0;
                 },
-                [BaseMathOperation.MinAll]: (arr) => arr.length ? Math.min(...arr.map((x) => Number(x))) : 0,
-                [BaseMathOperation.MaxAll]: (arr) => arr.length ? Math.max(...arr.map((x) => Number(x))) : 0,
+                [BaseMathOperation.MinAll]: (arr) => (arr.length ? Math.min(...arr.map((x) => Number(x))) : 0),
+                [BaseMathOperation.MaxAll]: (arr) => (arr.length ? Math.max(...arr.map((x) => Number(x))) : 0),
             };
             if (aggregateByOp[op] !== undefined)
                 return { Result: [aggregateByOp[op](a)] };
@@ -5330,8 +5254,8 @@ function setupBasicGraphRegistry(id) {
             const fn = binaryByOp[op] || binaryByOp[BaseMathOperation.Add];
             const len = Math.max(a.length, b.length);
             const out = new Array(len).fill(0).map((_, i) => {
-                const ax = a.length === 1 && len > 1 ? a[0] : a[i] ?? 0;
-                const bx = b.length === 1 && len > 1 ? b[0] : b[i] ?? 0;
+                const ax = a.length === 1 && len > 1 ? a[0] : (a[i] ?? 0);
+                const bx = b.length === 1 && len > 1 ? b[0] : (b[i] ?? 0);
                 return fn(Number(ax), Number(bx));
             });
             return { Result: out };
@@ -5472,9 +5396,7 @@ function setupBasicGraphRegistry(id) {
         impl: (ins) => {
             const arr = Array.isArray(ins.Items) ? ins.Items : [];
             const s = Math.trunc(Number(ins.Start ?? 0));
-            const e = Number.isFinite(Number(ins.End))
-                ? Math.trunc(Number(ins.End))
-                : undefined;
+            const e = Number.isFinite(Number(ins.End)) ? Math.trunc(Number(ins.End)) : undefined;
             return { Result: arr.slice(s, e) };
         },
     });
@@ -5749,11 +5671,7 @@ function setupBasicGraphRegistry(id) {
         outputs: { Keys: "base.string[]" },
         impl: (ins) => {
             const obj = ins.Object;
-            const keys = isPlainObject(obj)
-                ? Object.keys(obj)
-                : Array.isArray(obj)
-                    ? Object.keys(obj)
-                    : [];
+            const keys = isPlainObject(obj) ? Object.keys(obj) : Array.isArray(obj) ? Object.keys(obj) : [];
             return { Keys: keys };
         },
     });
@@ -5764,11 +5682,7 @@ function setupBasicGraphRegistry(id) {
         outputs: { Values: "base.object" },
         impl: (ins) => {
             const obj = ins.Object;
-            const vals = isPlainObject(obj)
-                ? Object.values(obj)
-                : Array.isArray(obj)
-                    ? Object.values(obj)
-                    : [];
+            const vals = isPlainObject(obj) ? Object.values(obj) : Array.isArray(obj) ? Object.values(obj) : [];
             return { Values: vals };
         },
     });
@@ -5780,11 +5694,7 @@ function setupBasicGraphRegistry(id) {
         impl: (ins) => {
             const root = structuredClone(ins.Object);
             const opsRaw = ins.Ops;
-            const ops = Array.isArray(opsRaw)
-                ? opsRaw
-                : opsRaw
-                    ? [opsRaw]
-                    : [];
+            const ops = Array.isArray(opsRaw) ? opsRaw : opsRaw ? [opsRaw] : [];
             let cur = root;
             for (const op of ops) {
                 if (!op || typeof op !== "object")
@@ -5875,9 +5785,7 @@ function registerDelayNode(registry) {
         impl: async (ins, ctx) => {
             const ms = Number(ins.DelayMs ?? 200);
             const valueRaw = ins.Value;
-            if (valueRaw === undefined ||
-                valueRaw === null ||
-                Number.isNaN(Number(valueRaw))) {
+            if (valueRaw === undefined || valueRaw === null || Number.isNaN(Number(valueRaw))) {
                 return; // wait until x is present to avoid NaN emissions
             }
             await new Promise((resolve, reject) => {
@@ -5947,9 +5855,7 @@ function generateId(prefix, used = new Set()) {
         id = `${prefix}${Math.random().toString(36).slice(2, 8)}`;
         attempts++;
         if (attempts > 1000) {
-            id = `${prefix}${Date.now().toString(36)}${Math.random()
-                .toString(36)
-                .slice(2, 4)}`;
+            id = `${prefix}${Date.now().toString(36)}${Math.random().toString(36).slice(2, 4)}`;
         }
     } while (used.has(id));
     return id;
@@ -5990,12 +5896,10 @@ function installLogging(engine) {
             console.warn(`[error] input-validation: ${e.nodeId}.${e.handle} (type ${e.typeId})`, e.message);
         }
         else if (e.kind === "registry") {
-            console.warn(`[error] registry:`, e.err?.message ?? e.err, e.attempt !== undefined
-                ? `(attempt ${e.attempt}/${e.maxAttempts ?? "?"})`
-                : "");
+            console.warn(`[error] registry:`, e.err?.message ?? e.err, e.attempt !== undefined ? `(attempt ${e.attempt}/${e.maxAttempts ?? "?"})` : "");
         }
         else if (e.kind === "system") {
-            console.warn(`[error] system: ${e.message}`, e.code ? `(code: ${e.code})` : "", e.err ? e.err?.message ?? e.err : "", e.details ? JSON.stringify(e.details) : "");
+            console.warn(`[error] system: ${e.message}`, e.code ? `(code: ${e.code})` : "", e.err ? (e.err?.message ?? e.err) : "", e.details ? JSON.stringify(e.details) : "");
         }
         else {
             // Log any other error kinds (shouldn't happen, but handle gracefully)
@@ -6320,11 +6224,7 @@ function buildTypeMaps(def) {
         }
         if (node.resolvedHandles?.outputs) {
             for (const [handleId, handleDesc] of Object.entries(node.resolvedHandles.outputs)) {
-                const typeId = typeof handleDesc === "string"
-                    ? handleDesc
-                    : Array.isArray(handleDesc)
-                        ? handleDesc[0]
-                        : undefined;
+                const typeId = typeof handleDesc === "string" ? handleDesc : Array.isArray(handleDesc) ? handleDesc[0] : undefined;
                 if (typeId)
                     nodeOutputTypes.set(handleId, typeId);
             }
@@ -6375,8 +6275,7 @@ function applyConversion(items, values, converter, type) {
         });
         if (convertedValue === null) {
             delete values[item.nodeId]?.[item.handleId];
-            if (values[item.nodeId] &&
-                Object.keys(values[item.nodeId]).length === 0) {
+            if (values[item.nodeId] && Object.keys(values[item.nodeId]).length === 0) {
                 delete values[item.nodeId];
             }
         }
@@ -6422,7 +6321,7 @@ function convertSnapshot(snapshot, converter) {
     }
     const { converted: convertedInputs, toConvert: inputsToConvert } = collectValuesToConvert(snapshot.inputs ?? {}, nodeTypeMap, inputHandleTypeMap, outputHandleTypeMap, "input");
     const { converted: convertedOutputs, toConvert: outputsToConvert } = collectValuesToConvert(snapshot.outputs ?? {}, nodeTypeMap, inputHandleTypeMap, outputHandleTypeMap, "output");
-    const { converted: convertedInputDefaults, toConvert: inputDefaultsToConvert, } = collectValuesToConvert(inputDefaults, nodeTypeMap, inputHandleTypeMap, outputHandleTypeMap, "inputDefault");
+    const { converted: convertedInputDefaults, toConvert: inputDefaultsToConvert } = collectValuesToConvert(inputDefaults, nodeTypeMap, inputHandleTypeMap, outputHandleTypeMap, "inputDefault");
     applyConversion(inputsToConvert, convertedInputs, converter, "input");
     applyConversion(outputsToConvert, convertedOutputs, converter, "output");
     applyConversion(inputDefaultsToConvert, convertedInputDefaults, converter, "inputDefault");
@@ -6612,7 +6511,7 @@ function matchesPattern(value, pattern) {
  */
 function buildValueConverter(config) {
     return (converterConfig) => {
-        const { nodeId, handleId, value, type, nodeTypeId, handleDataType, runtimeTypeId, } = converterConfig;
+        const { nodeId, handleId, value, type, nodeTypeId, handleDataType, runtimeTypeId } = converterConfig;
         const isValueTyped = isTyped(value);
         for (const mapping of config.mappings) {
             if (mapping.type && mapping.type !== type)
@@ -6655,8 +6554,7 @@ function buildValueConverter(config) {
                                     }
                                 }
                                 else {
-                                    if (typeof matchValue === "string" ||
-                                        typeof matchValue === "number") {
+                                    if (typeof matchValue === "string" || typeof matchValue === "number") {
                                         const key = String(matchValue);
                                         if (key in mapping.valueMap) {
                                             newValue = mapping.valueMap[key];
@@ -6690,8 +6588,7 @@ function buildValueConverter(config) {
                             }
                         }
                         else {
-                            if (typeof innerValue === "string" ||
-                                typeof innerValue === "number") {
+                            if (typeof innerValue === "string" || typeof innerValue === "number") {
                                 const key = String(innerValue);
                                 if (key in mapping.valueMap) {
                                     newValue = mapping.valueMap[key];
@@ -6718,8 +6615,7 @@ function buildValueConverter(config) {
                             : firstSegment instanceof RegExp
                                 ? null
                                 : String(firstSegment);
-                        if (firstSegmentStr !== "__spark_value" &&
-                            firstSegmentStr !== "__spark_type") {
+                        if (firstSegmentStr !== "__spark_value" && firstSegmentStr !== "__spark_type") {
                             pathSegments = ["__spark_value", ...pathSegments];
                         }
                     }
@@ -6739,8 +6635,7 @@ function buildValueConverter(config) {
                                 }
                             }
                             else {
-                                if (typeof matchValue === "string" ||
-                                    typeof matchValue === "number") {
+                                if (typeof matchValue === "string" || typeof matchValue === "number") {
                                     const key = String(matchValue);
                                     if (key in mapping.valueMap) {
                                         newValue = mapping.valueMap[key];