@bian-womp/spark-graph 0.2.7 → 0.2.9

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,
@@ -963,6 +964,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 +1141,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) => {
@@ -1227,14 +1239,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 +1260,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);
+                }
+            }
         }
     }
 }
@@ -2002,25 +2029,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 +2194,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",