@bian-womp/spark-graph 0.1.12 → 0.1.14

package/lib/cjs/index.cjs

@@ -464,6 +464,39 @@ class GraphRuntime {
                 stats: { runs: 0, inFlight: false, progress: 0 },
             };
         });
+        // After nodes and edges exist, seed registry- and graph-level defaults
+        for (const n of def.nodes) {
+            const node = gr.nodes.get(n.nodeId);
+            const desc = registry.nodes.get(n.typeId);
+            if (!node || !desc)
+                continue;
+            // Resolve registry-level defaults (object or function)
+            const regDefaults = typeof desc.inputDefaults === "function"
+                ? desc.inputDefaults({
+                    params: n.params,
+                    environment: gr.environment,
+                })
+                : desc.inputDefaults ?? {};
+            const graphDefaults = n.initialInputs ?? {};
+            // Apply precedence: graph-level overrides registry-level
+            const merged = {
+                ...regDefaults,
+                ...graphDefaults,
+            };
+            for (const [handle, value] of Object.entries(merged)) {
+                // Only seed if input has no inbound wiring
+                const hasInbound = gr.edges.some((e) => e.target.nodeId === n.nodeId && e.target.handle === handle);
+                if (hasInbound)
+                    continue;
+                if (value === undefined)
+                    continue;
+                // Clone to avoid accidental shared references
+                node.inputs[handle] =
+                    typeof structuredClone === "function"
+                        ? structuredClone(value)
+                        : JSON.parse(JSON.stringify(value));
+            }
+        }
         return gr;
     }
     on(event, handler) {
@@ -494,8 +527,11 @@ class GraphRuntime {
             // Emit value event for input updates
             this.emit("value", { nodeId, handle, value, io: "input" });
         }
-        if (!this.paused)
-            this.scheduleInputsChanged(nodeId);
+        if (!this.paused) {
+            // Only schedule if all inbound inputs are present (or there are none)
+            if (this.allInboundHaveValue(nodeId))
+                this.scheduleInputsChanged(nodeId);
+        }
     }
     getOutput(nodeId, output) {
         const node = this.nodes.get(nodeId);
@@ -586,7 +622,7 @@ class GraphRuntime {
                         await new Promise((r) => setTimeout(r, delay));
                         return exec(attempt + 1);
                     }
-                    this.emit("error", { nodeId, runId, err });
+                    this.emit("error", { kind: "node-run", nodeId, runId, err });
                 }
                 finally {
                     if (timeoutId)
@@ -641,6 +677,20 @@ class GraphRuntime {
         // switch or merge
         startRun(rid, { ...node.inputs });
     }
+    // Returns true if all inbound handles for the node currently have a value
+    allInboundHaveValue(nodeId) {
+        const node = this.nodes.get(nodeId);
+        if (!node)
+            return false;
+        const inbound = this.edges.filter((e) => e.target.nodeId === nodeId);
+        if (inbound.length === 0)
+            return true;
+        for (const e of inbound) {
+            if (!(e.target.handle in node.inputs))
+                return false;
+        }
+        return true;
+    }
     invalidateDownstream(nodeId) {
         // Notifies dependents; for now we propagate current outputs
         for (const e of this.edges.filter((e) => e.source.nodeId === nodeId)) {
@@ -676,7 +726,7 @@ class GraphRuntime {
                     value: v,
                     io: "input",
                 });
-                if (!this.paused)
+                if (!this.paused && this.allInboundHaveValue(e.target.nodeId))
                     this.scheduleInputsChanged(e.target.nodeId);
             };
             if (e.convertAsync) {
@@ -732,6 +782,14 @@ class GraphRuntime {
             }
         }
     }
+    reemitNodeOutputs(nodeId) {
+        const node = this.nodes.get(nodeId);
+        if (!node)
+            return;
+        for (const [handle, value] of Object.entries(node.outputs)) {
+            this.propagate(nodeId, handle, value);
+        }
+    }
     launch() {
         // call onActivated for nodes that implement it
         for (const node of this.nodes.values()) {
@@ -756,6 +814,11 @@ class GraphRuntime {
             });
             node.runtime.onActivated?.(ctx);
         }
+        // After activation, schedule nodes that have all inbound inputs present
+        for (const nodeId of this.nodes.keys()) {
+            if (this.allInboundHaveValue(nodeId))
+                this.scheduleInputsChanged(nodeId);
+        }
     }
     triggerExternal(nodeId, event) {
         const node = this.nodes.get(nodeId);
@@ -791,8 +854,11 @@ class GraphRuntime {
         this.edges = [];
         this.listeners.clear();
     }
+    getNodeIds() {
+        return Array.from(this.nodes.keys());
+    }
     // Unsafe helpers for serializer: read-only accessors and hydration
-    __unsafe_getNodeData(nodeId) {
+    getNodeData(nodeId) {
         const node = this.nodes.get(nodeId);
         if (!node)
             return undefined;
@@ -804,33 +870,12 @@ class GraphRuntime {
             stats: { ...node.stats },
         };
     }
-    __unsafe_getEnvironment() {
+    getEnvironment() {
         return { ...this.environment };
     }
     setEnvironment(env) {
         this.environment = { ...env };
     }
-    __unsafe_setEnvironment(env) {
-        this.setEnvironment(env);
-    }
-    __unsafe_hydrateNode(nodeId, data, opts) {
-        const node = this.nodes.get(nodeId);
-        if (!node)
-            return;
-        if (opts?.replace) {
-            node.inputs = {};
-            node.outputs = {};
-            node.state = {};
-        }
-        if (data.inputs)
-            Object.assign(node.inputs, data.inputs);
-        if (data.outputs)
-            Object.assign(node.outputs, data.outputs);
-        if (data.state !== undefined)
-            node.state = data.state;
-        if (data.params)
-            node.params = data.params;
-    }
     async whenIdle() {
         const isIdle = () => {
             for (const n of this.nodes.values()) {
@@ -862,14 +907,6 @@ class GraphRuntime {
     __unsafe_invalidateDownstream(nodeId) {
         this.invalidateDownstream(nodeId);
     }
-    __unsafe_reemitNodeOutputs(nodeId) {
-        const node = this.nodes.get(nodeId);
-        if (!node)
-            return;
-        for (const [handle, value] of Object.entries(node.outputs)) {
-            this.propagate(nodeId, handle, value);
-        }
-    }
     __unsafe_scheduleInputsChanged(nodeId) {
         this.scheduleInputsChanged(nodeId);
     }
@@ -1033,12 +1070,41 @@ class GraphRuntime {
                     }
                 }
             }
-            if (changed)
+            // If input lost inbound, try to re-seed from defaults
+            if (changed) {
+                const defNode = def.nodes.find((n) => n.nodeId === nodeId);
+                if (defNode) {
+                    const desc = registry.nodes.get(defNode.typeId);
+                    if (desc) {
+                        const regDefaults = typeof desc.inputDefaults === "function"
+                            ? desc.inputDefaults({
+                                params: defNode.params,
+                                environment: this.environment,
+                            })
+                            : desc.inputDefaults ?? {};
+                        const graphDefaults = defNode.initialInputs ?? {};
+                        const merged = {
+                            ...regDefaults,
+                            ...graphDefaults,
+                        };
+                        for (const h of Array.from(prevSet)) {
+                            if (!currSet.has(h) && node.inputs[h] === undefined) {
+                                const v = merged[h];
+                                if (v !== undefined)
+                                    node.inputs[h] =
+                                        typeof structuredClone === "function"
+                                            ? structuredClone(v)
+                                            : JSON.parse(JSON.stringify(v));
+                            }
+                        }
+                    }
+                }
                 this.scheduleInputsChanged(nodeId);
+            }
         }
         // Re-emit existing outputs to populate new edges
         for (const nodeId of this.nodes.keys()) {
-            this.__unsafe_reemitNodeOutputs(nodeId);
+            this.reemitNodeOutputs(nodeId);
         }
     }
 }
@@ -1668,6 +1734,9 @@ function setupBasicGraphRegistry() {
             Factor: "base.float",
         },
         outputs: { Value: "base.float[]" },
+        inputDefaults: {
+            Factor: 0.5,
+        },
         impl: (ins) => {
             const [a, b] = broadcast(ins.ValueA, ins.ValueB);
             const t = Number(ins.Factor ?? 0);
@@ -1719,6 +1788,8 @@ function setupBasicGraphRegistry() {
             B: "base.float[]",
         },
         outputs: { Result: "base.float[]" },
+        // Registry-level defaults: Add by default, A=[1], B=[1]
+        inputDefaults: { Operation: 0, A: [1], B: [1] },
         impl: (ins) => {
             // Gracefully handle missing inputs by treating them as zeros
             const a = ins.A === undefined ? [] : asArray(ins.A);
@@ -1841,6 +1912,8 @@ function setupBasicGraphRegistry() {
             Seed: "base.float",
         },
         outputs: { Values: "base.vec3[]" },
+        // Registry-level defaults for convenience
+        inputDefaults: { Domain: 10, Min: [0, 0, 0], Max: [1, 1, 1], Seed: 1 },
         impl: (ins) => {
             const len = Math.trunc(ins.Domain);
             const min = ins.Min ?? [0, 0, 0];
@@ -1860,12 +1933,14 @@ function registerDelayNode(registry) {
     registry.registerNode({
         id: "async.delay",
         categoryId: "compute",
-        inputs: { x: "base.float", ms: "base.float" },
-        outputs: { out: "base.float" },
+        inputs: { Value: "base.float", DelayMs: "base.float" },
+        outputs: { Output: "base.float" },
         impl: async (ins, ctx) => {
-            const ms = Number(ins.ms ?? 200);
-            const xRaw = ins.x;
-            if (xRaw === undefined || xRaw === null || Number.isNaN(Number(xRaw))) {
+            const ms = Number(ins.DelayMs ?? 200);
+            const valueRaw = ins.Value;
+            if (valueRaw === undefined ||
+                valueRaw === null ||
+                Number.isNaN(Number(valueRaw))) {
                 return; // wait until x is present to avoid NaN emissions
             }
             await new Promise((resolve, reject) => {
@@ -1878,7 +1953,7 @@ function registerDelayNode(registry) {
                     return onAbort();
                 ctx.abortSignal.addEventListener("abort", onAbort, { once: true });
             });
-            return { out: Number(xRaw) };
+            return { Output: Number(valueRaw) };
         },
     });
 }
@@ -1933,7 +2008,12 @@ function makeBasicGraphDefinition() {
     return {
         nodes: [
             { nodeId: "n1", typeId: "base.math" },
-            { nodeId: "n2", typeId: "base.math" },
+            {
+                nodeId: "n2",
+                typeId: "base.math",
+                // Graph-level defaults override registry if provided
+                initialInputs: { Operation: 2, B: [10] }, // Multiply by 10
+            },
             // Transitivity demo nodes
             { nodeId: "n3", typeId: "base.compare" },
             { nodeId: "n4", typeId: "base.randomXYZs" },
@@ -1992,7 +2072,7 @@ function createAsyncGraphDef() {
             {
                 id: "e1",
                 source: { nodeId: "n1", handle: "Result" },
-                target: { nodeId: "n2", handle: "x" },
+                target: { nodeId: "n2", handle: "Value" },
             },
             // Demonstrate async edge conversion: vec3[] -> float[] using coercion
             {
@@ -2031,7 +2111,7 @@ function createProgressGraphDef() {
     const def = {
         nodes: [
             { nodeId: "steps", typeId: "base.number" },
-            { nodeId: "async.delay", typeId: "base.number" },
+            { nodeId: "delay", typeId: "base.number" },
             { nodeId: "work", typeId: "async.progress" },
         ],
         edges: [
@@ -2042,7 +2122,7 @@ function createProgressGraphDef() {
             },
             {
                 id: "e2",
-                source: { nodeId: "async.delay", handle: "Result" },
+                source: { nodeId: "delay", handle: "Result" },
                 target: { nodeId: "work", handle: "DelayMs" },
             },
             // not wiring ShouldError to show manual input driven error later