@bian-womp/spark-graph 0.2.8 → 0.2.10

package/lib/cjs/index.cjs

@@ -342,7 +342,7 @@ class Registry {
     }
     // Enum support
     registerEnum(desc) {
-        const { id, displayName, options, opts } = desc;
+        const { id, displayName, options, opts, bakeTarget } = desc;
         const labelType = opts?.labelType ?? "base.string";
         const valueType = opts?.valueType ?? "base.float";
         const valueToLabel = new Map();
@@ -361,6 +361,7 @@ class Registry {
             id,
             displayName,
             validate: (v) => typeof v === "number" && valueToLabel.has(Number(v)),
+            bakeTarget,
         }, opts);
         this.registerSerializer(id, {
             serialize: (v) => v,
@@ -503,6 +504,7 @@ class GraphRuntime {
                 srcUnionTypes: Array.isArray(srcDeclared)
                     ? [...srcDeclared]
                     : undefined,
+                dstDeclared,
                 stats: { runs: 0, inFlight: false, progress: 0 },
             };
         });
@@ -838,17 +840,26 @@ class GraphRuntime {
                 const dstNode = this.nodes.get(e.target.nodeId);
                 if (!dstNode)
                     return;
+                const dstIsArray = typeof e.dstDeclared === "string" && e.dstDeclared.endsWith("[]");
+                let next = v;
+                // If target input is an array type, append incoming values instead of last-write wins
+                if (dstIsArray) {
+                    const toArray = (x) => Array.isArray(x) ? x : x === undefined ? [] : [x];
+                    const prev = dstNode.inputs[e.target.handle];
+                    const merged = [...toArray(prev), ...toArray(v)];
+                    next = merged;
+                }
                 const prev = dstNode.inputs[e.target.handle];
-                const same = this.valuesEqual(prev, v);
+                const same = this.valuesEqual(prev, next);
                 if (!same) {
-                    dstNode.inputs[e.target.handle] = v;
+                    dstNode.inputs[e.target.handle] = next;
                     // Emit value event for input updates
                     this.emit("value", {
                         nodeId: e.target.nodeId,
                         handle: e.target.handle,
-                        value: v,
+                        value: next,
                         io: "input",
-                        runtimeTypeId: getTypedOutputTypeId(v),
+                        runtimeTypeId: getTypedOutputTypeId(next),
                     });
                     if (!this.paused && this.allInboundHaveValue(e.target.nodeId))
                         this.scheduleInputsChanged(e.target.nodeId);
@@ -963,6 +974,15 @@ class GraphRuntime {
                 node.stats.progress = Math.max(0, Math.min(1, Number(p) || 0));
             },
         };
+        // Built-in support: invalidate event reruns or re-emits without per-node wiring
+        if (event &&
+            typeof event === "object" &&
+            event.type === "invalidate") {
+            if (this.allInboundHaveValue(nodeId))
+                this.scheduleInputsChanged(nodeId);
+            else
+                this.invalidateDownstream(nodeId);
+        }
         node.runtime.onExternalEvent?.(event, ctx);
     }
     dispose() {
@@ -1131,12 +1151,14 @@ class GraphRuntime {
             set.add(e.target.handle);
             prevInbound.set(e.target.nodeId, set);
         }
-        // Capture previous outgoing map before rebuilding edges
-        const prevOutgoing = new Map();
+        // Capture previous per-handle target sets before rebuilding edges
+        const prevOutTargets = new Map();
         for (const e of this.edges) {
-            const set = prevOutgoing.get(e.source.nodeId) ?? new Set();
-            set.add(e.source.handle);
-            prevOutgoing.set(e.source.nodeId, set);
+            const tmap = prevOutTargets.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);
+            prevOutTargets.set(e.source.nodeId, tmap);
         }
         // Rebuild edges mapping with coercions
         this.edges = def.edges.map((e) => {
@@ -1170,6 +1192,7 @@ class GraphRuntime {
                 typeId: effectiveTypeId ?? "untyped",
                 convert,
                 convertAsync,
+                dstDeclared,
                 stats: { runs: 0, inFlight: false, progress: 0 },
             };
         });
@@ -1227,14 +1250,16 @@ class GraphRuntime {
                 this.scheduleInputsChanged(nodeId);
             }
         }
-        // Re-emit outputs only for sources whose outgoing edge set changed
-        const nextOutgoing = new Map();
+        // Re-emit outputs when per-handle target sets change (precise and simple)
+        const nextOutTargets = new Map();
         for (const e of this.edges) {
-            const set = nextOutgoing.get(e.source.nodeId) ?? new Set();
-            set.add(e.source.handle);
-            nextOutgoing.set(e.source.nodeId, set);
+            const tmap = nextOutTargets.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);
+            nextOutTargets.set(e.source.nodeId, tmap);
         }
-        const setsEqual = (a, b) => {
+        const setsEqualStr = (a, b) => {
             if (!a && !b)
                 return true;
             if (!a || !b)
@@ -1246,15 +1271,28 @@ class GraphRuntime {
                     return false;
             return true;
         };
-        const reemitCandidates = new Set([
-            ...Array.from(prevOutgoing.keys()),
-            ...Array.from(nextOutgoing.keys()),
+        const nodesToCheck = new Set([
+            ...Array.from(prevOutTargets.keys()),
+            ...Array.from(nextOutTargets.keys()),
         ]);
-        for (const nodeId of reemitCandidates) {
-            const prev = prevOutgoing.get(nodeId);
-            const next = nextOutgoing.get(nodeId);
-            if (!setsEqual(prev, next))
-                this.reemitNodeOutputs(nodeId);
+        for (const nodeId of nodesToCheck) {
+            const pmap = prevOutTargets.get(nodeId) ?? new Map();
+            const nmap = nextOutTargets.get(nodeId) ?? new Map();
+            const handles = new Set([
+                ...Array.from(pmap.keys()),
+                ...Array.from(nmap.keys()),
+            ]);
+            for (const handle of handles) {
+                const pset = pmap.get(handle) ?? new Set();
+                const nset = nmap.get(handle) ?? new Set();
+                if (!setsEqualStr(pset, nset)) {
+                    const val = this.getOutput(nodeId, handle);
+                    if (val !== undefined)
+                        this.propagate(nodeId, handle, val);
+                    else if (this.allInboundHaveValue(nodeId))
+                        this.scheduleInputsChanged(nodeId);
+                }
+            }
         }
     }
 }
@@ -1300,6 +1338,8 @@ class GraphBuilder {
         }
         // edges validation: nodes exist, handles exist, type exists
         const inboundCounts = new Map();
+        // Track which inbound (nodeId::handle) are declared as array inputs, to allow multi-inbound without warning
+        const inboundArrayOk = new Set();
         for (const e of def.edges) {
             if (edgeIds.has(e.id)) {
                 issues.push({
@@ -1340,7 +1380,7 @@ class GraphBuilder {
             if (dstNode) {
                 const dstType = this.registry.nodes.get(dstNode.typeId);
                 if (dstType)
-                    _dstDeclared = dstType.inputs[e.target.handle];
+                    _dstDeclared = getInputTypeId(dstType.inputs, e.target.handle);
             }
             if (!effectiveTypeId) {
                 if (Array.isArray(_srcDeclared) && _dstDeclared) {
@@ -1487,9 +1527,19 @@ class GraphBuilder {
             // Track multiple inbound edges targeting the same input handle
             const inboundKey = `${e.target.nodeId}::${e.target.handle}`;
             inboundCounts.set(inboundKey, (inboundCounts.get(inboundKey) ?? 0) + 1);
+            // If the target input is declared as an array type, allow multi-inbound (runtime will append)
+            if (dstNode) {
+                const dstType = this.registry.nodes.get(dstNode.typeId);
+                const declaredIn = dstType
+                    ? getInputTypeId(dstType.inputs, e.target.handle)
+                    : undefined;
+                if (typeof declaredIn === "string" && declaredIn.endsWith("[]")) {
+                    inboundArrayOk.add(inboundKey);
+                }
+            }
         }
         for (const [key, count] of inboundCounts) {
-            if (count > 1) {
+            if (count > 1 && !inboundArrayOk.has(key)) {
                 issues.push({
                     level: "warning",
                     code: "MULTI_INBOUND",
@@ -2002,25 +2052,30 @@ function setupBasicGraphRegistry() {
     registry.registerType({
         id: "base.float",
         validate: (v) => typeof v === "number" && !Number.isNaN(v),
+        bakeTarget: { nodeTypeId: "base.input.number", inputHandle: "Value" },
     }, { withArray: true, arrayPickFirstDefined: true });
     registry.registerType({
         id: "base.bool",
         validate: (v) => typeof v === "boolean",
+        bakeTarget: { nodeTypeId: "base.input.bool", inputHandle: "Value" },
     }, { withArray: true, arrayPickFirstDefined: true });
     registry.registerType({
         id: "base.string",
         validate: (v) => typeof v === "string",
+        bakeTarget: { nodeTypeId: "base.input.string", inputHandle: "Value" },
     }, { withArray: true, arrayPickFirstDefined: true });
     // Generic object value (JSON-compatible; object/array/primitive/null)
     registry.registerType({
         id: "base.object",
         validate: (v) => isJson(v),
+        bakeTarget: { nodeTypeId: "base.input.object", inputHandle: "Value" },
     }, { withArray: false });
     registry.registerType({
         id: "base.vec3",
         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]
     registry.registerCoercion("base.float", "base.vec3", (v) => {
@@ -2162,6 +2217,20 @@ function setupBasicGraphRegistry() {
         outputs: { Result: "base.bool" },
         impl: (ins) => ({ Result: Boolean(ins.Value) }),
     });
+    registry.registerNode({
+        id: "base.input.object",
+        categoryId: "compute",
+        inputs: { Value: "base.object" },
+        outputs: { Result: "base.object" },
+        impl: (ins) => ({ Result: ins.Value }),
+    });
+    registry.registerNode({
+        id: "base.input.vec3",
+        categoryId: "compute",
+        inputs: { Value: "base.vec3" },
+        outputs: { Result: "base.vec3" },
+        impl: (ins) => ({ Result: ins.Value }),
+    });
     // JSON parser node: base.stringToObject
     registry.registerNode({
         id: "base.string.toObject",