@bian-womp/spark-remote 0.2.32 → 0.2.33

package/lib/cjs/index.cjs

@@ -525,191 +525,189 @@ async function createRuntimeAdapter(createRegistry, send, extensions) {
         extData,
     });
     // Original implementations - define as separate functions first to allow cross-references
-    const originals = {};
-    // Define methods that can reference each other
-    originals.coerce = async (from, to, value) => {
-        const resolved = registry.resolveCoercion(from, to);
-        if (!resolved)
-            return value;
-        if (resolved.kind === "sync")
-            return resolved.convert(value);
-        const ac = new AbortController();
-        return await resolved.convertAsync(value, ac.signal);
-    };
-    originals.getEnvironment = () => {
-        return graphRuntime?.getEnvironment?.() ?? {};
-    };
-    originals.applyRegistry = async (deltas) => {
-        // Pause runtime if exists
-        // Apply each delta to the live registry
-        for (const d of deltas || []) {
-            if (!d || typeof d !== "object")
-                continue;
-            if (d.kind === "register-enum") {
-                registry.registerEnum({
-                    id: d.id,
-                    displayName: d.displayName,
-                    options: d.options || [],
-                    bakeTarget: d.bakeTarget,
-                    opts: d.opts,
-                });
+    const originalApi = {
+        coerce: async (from, to, value) => {
+            const resolved = registry.resolveCoercion(from, to);
+            if (!resolved)
+                return value;
+            if (resolved.kind === "sync")
+                return resolved.convert(value);
+            const ac = new AbortController();
+            return await resolved.convertAsync(value, ac.signal);
+        },
+        getEnvironment: () => {
+            return graphRuntime?.getEnvironment?.() ?? {};
+        },
+        applyRegistry: async (deltas) => {
+            // Pause runtime if exists
+            // Apply each delta to the live registry
+            for (const d of deltas || []) {
+                if (!d || typeof d !== "object")
+                    continue;
+                if (d.kind === "register-enum") {
+                    registry.registerEnum({
+                        id: d.id,
+                        displayName: d.displayName,
+                        options: d.options || [],
+                        bakeTarget: d.bakeTarget,
+                        opts: d.opts,
+                    });
+                }
+                else if (d.kind === "register-type") {
+                    registry.registerType({
+                        id: d.id,
+                        displayName: d.displayName,
+                        bakeTarget: d.bakeTarget,
+                        validate: (_v) => true,
+                    });
+                }
+                else if (d.kind === "register-node") {
+                    const desc = d.desc || {};
+                    registry.registerNode({
+                        id: String(desc.id || ""),
+                        categoryId: String(desc.categoryId || "compute"),
+                        displayName: desc.displayName,
+                        inputs: desc.inputs || {},
+                        outputs: desc.outputs || {},
+                        // impl must be empty per frontend registration contract
+                        impl: () => { },
+                    });
+                }
             }
-            else if (d.kind === "register-type") {
-                registry.registerType({
-                    id: d.id,
-                    displayName: d.displayName,
-                    bakeTarget: d.bakeTarget,
-                    validate: (_v) => true,
-                });
+            // Notify clients (include deltas in invalidate payload)
+            send({
+                message: {
+                    type: "invalidate",
+                    payload: { reason: "registry-changed", deltas },
+                },
+            });
+        },
+        build: async (def, opts) => {
+            const env = opts || {};
+            graphRuntime = builder.build(def, { environment: env });
+            graphRuntime.on("value", (p) => send({ message: { type: "value", payload: p } }));
+            graphRuntime.on("invalidate", (p) => send({ message: { type: "invalidate", payload: p } }));
+            graphRuntime.on("error", (p) => send({ message: { type: "error", payload: p } }));
+            graphRuntime.on("stats", (p) => send({ message: { type: "stats", payload: p } }));
+        },
+        setExtData: (data) => {
+            if (!data || typeof data !== "object") {
+                extData = {};
+                return;
             }
-            else if (d.kind === "register-node") {
-                const desc = d.desc || {};
-                registry.registerNode({
-                    id: String(desc.id || ""),
-                    categoryId: String(desc.categoryId || "compute"),
-                    displayName: desc.displayName,
-                    inputs: desc.inputs || {},
-                    outputs: desc.outputs || {},
-                    // impl must be empty per frontend registration contract
-                    impl: () => { },
-                });
+            // Replace to keep semantics deterministic
+            extData = { ...data };
+        },
+        getExtData: () => {
+            return extData;
+        },
+        snapshot: () => {
+            const inputs = {};
+            const outputs = {};
+            if (!graphRuntime)
+                return { inputs, outputs };
+            const nodes = graphRuntime.getNodeIds();
+            for (const nodeId of nodes) {
+                const data = graphRuntime.getNodeData(nodeId);
+                if (data?.inputs && Object.keys(data.inputs).length > 0) {
+                    inputs[nodeId] = { ...data.inputs };
+                }
+                if (data?.outputs && Object.keys(data.outputs).length > 0) {
+                    outputs[nodeId] = { ...data.outputs };
+                }
             }
-        }
-        // Notify clients (include deltas in invalidate payload)
-        send({
-            message: {
-                type: "invalidate",
-                payload: { reason: "registry-changed", deltas },
-            },
-        });
-    };
-    originals.build = async (def, opts) => {
-        const env = opts || {};
-        graphRuntime = builder.build(def, { environment: env });
-        graphRuntime.on("value", (p) => send({ message: { type: "value", payload: p } }));
-        graphRuntime.on("invalidate", (p) => send({ message: { type: "invalidate", payload: p } }));
-        graphRuntime.on("error", (p) => send({ message: { type: "error", payload: p } }));
-        graphRuntime.on("stats", (p) => send({ message: { type: "stats", payload: p } }));
-    };
-    originals.setExtData = (data) => {
-        if (!data || typeof data !== "object") {
-            extData = {};
-            return;
-        }
-        // Replace to keep semantics deterministic
-        extData = { ...data };
-    };
-    originals.getExtData = () => {
-        return extData;
-    };
-    originals.snapshot = () => {
-        const inputs = {};
-        const outputs = {};
-        if (!graphRuntime)
             return { inputs, outputs };
-        const nodes = graphRuntime.getNodeIds();
-        for (const nodeId of nodes) {
-            const data = graphRuntime.getNodeData(nodeId);
-            if (data?.inputs && Object.keys(data.inputs).length > 0) {
-                inputs[nodeId] = { ...data.inputs };
-            }
-            if (data?.outputs && Object.keys(data.outputs).length > 0) {
-                outputs[nodeId] = { ...data.outputs };
-            }
-        }
-        return { inputs, outputs };
-    };
-    originals.snapshotFull = () => {
-        const snap = originals.snapshot();
-        const env = graphRuntime?.getEnvironment?.() ?? {};
-        const def = graphRuntime?.getGraphDef();
-        return {
-            def,
-            environment: env,
-            inputs: snap.inputs,
-            outputs: snap.outputs,
-        };
-    };
-    originals.applySnapshotFull = async (payload) => {
-        const def = payload.def;
-        if (!def)
-            return;
-        await originals.build(def, payload.environment);
-        // Hydrate inputs/outputs exactly, then re-emit outputs without scheduling runs
-        graphRuntime?.hydrate({ inputs: payload.inputs, outputs: payload.outputs }, { reemit: true });
-    };
-    originals.describeRegistry = () => {
-        // types (include enum options when available)
-        const types = Array.from(registry.types.entries()).map(([id, d]) => {
-            const en = registry.enums.get(id);
+        },
+        snapshotFull: () => {
+            const snap = originalApi.snapshot();
+            const env = graphRuntime?.getEnvironment?.() ?? {};
+            const def = graphRuntime?.getGraphDef();
             return {
-                id,
-                displayName: d.displayName,
-                bakeTarget: d.bakeTarget,
-                ...(en ? { options: en.options } : {}),
+                def,
+                environment: env,
+                inputs: snap.inputs,
+                outputs: snap.outputs,
             };
-        });
-        // categories: not directly enumerable; derive from node descriptors
-        const nodeDescs = Array.from(registry.nodes.values());
-        const catIds = new Set(nodeDescs.map((n) => n.categoryId));
-        const categories = Array.from(catIds).map((id) => {
-            const cat = registry.categories.get?.(id);
-            return { id, displayName: cat?.displayName };
-        });
-        const nodes = nodeDescs.map((n) => ({
-            id: n.id,
-            categoryId: n.categoryId,
-            displayName: n.displayName,
-            inputs: n.inputs || {},
-            outputs: n.outputs || {},
-            inputDefaults: n.inputDefaults || {},
-        }));
-        const coercions = registry.listCoercions();
-        return { types, categories, nodes, coercions, schemaVersion: 4 };
-    };
-    originals.update = async (def) => {
-        if (!graphRuntime)
-            return;
-        graphRuntime.update(def, registry);
-        send({
-            message: {
-                type: "invalidate",
-                payload: { reason: "graph-updated" },
-            },
-        });
-    };
-    originals.setEnvironment = (env, opts) => {
-        if (!graphRuntime)
-            return;
-        if (opts?.merge) {
-            const current = graphRuntime.getEnvironment();
-            const next = { ...(current || {}), ...(env || {}) };
-            graphRuntime.setEnvironment(next);
-            return;
-        }
-        graphRuntime.setEnvironment(env);
-    };
-    originals.setInput = (nodeId, handle, value) => {
-        graphRuntime?.setInput(nodeId, handle, value);
-    };
-    originals.setInputs = (nodeId, inputs) => {
-        graphRuntime?.setInputs(nodeId, inputs);
-    };
-    originals.triggerExternal = (nodeId, event) => {
-        graphRuntime?.triggerExternal(nodeId, event);
-    };
-    originals.launch = (invalidate) => {
-        graphRuntime?.launch(invalidate);
-    };
-    originals.whenIdle = () => {
-        return graphRuntime?.whenIdle?.() ?? Promise.resolve();
-    };
-    originals.dispose = () => {
-        graphRuntime?.dispose?.();
-        graphRuntime = undefined;
+        },
+        applySnapshotFull: async (payload) => {
+            const def = payload.def;
+            if (!def)
+                return;
+            await originalApi.build(def, payload.environment);
+            // Hydrate inputs/outputs exactly, then re-emit outputs without scheduling runs
+            graphRuntime?.hydrate({ inputs: payload.inputs, outputs: payload.outputs }, { reemit: true });
+        },
+        describeRegistry: () => {
+            // types (include enum options when available)
+            const types = Array.from(registry.types.entries()).map(([id, d]) => {
+                const en = registry.enums.get(id);
+                return {
+                    id,
+                    displayName: d.displayName,
+                    bakeTarget: d.bakeTarget,
+                    ...(en ? { options: en.options } : {}),
+                };
+            });
+            // categories: not directly enumerable; derive from node descriptors
+            const nodeDescs = Array.from(registry.nodes.values());
+            const catIds = new Set(nodeDescs.map((n) => n.categoryId));
+            const categories = Array.from(catIds).map((id) => {
+                const cat = registry.categories.get?.(id);
+                return { id, displayName: cat?.displayName };
+            });
+            const nodes = nodeDescs.map((n) => ({
+                id: n.id,
+                categoryId: n.categoryId,
+                displayName: n.displayName,
+                inputs: n.inputs || {},
+                outputs: n.outputs || {},
+                inputDefaults: n.inputDefaults || {},
+            }));
+            const coercions = registry.listCoercions();
+            return { types, categories, nodes, coercions, schemaVersion: 4 };
+        },
+        update: async (def) => {
+            if (!graphRuntime)
+                return;
+            graphRuntime.update(def, registry);
+            send({
+                message: {
+                    type: "invalidate",
+                    payload: { reason: "graph-updated" },
+                },
+            });
+        },
+        setEnvironment: (env, opts) => {
+            if (!graphRuntime)
+                return;
+            if (opts?.merge) {
+                const current = graphRuntime.getEnvironment();
+                const next = { ...(current || {}), ...(env || {}) };
+                graphRuntime.setEnvironment(next);
+                return;
+            }
+            graphRuntime.setEnvironment(env);
+        },
+        setInput: (nodeId, handle, value) => {
+            graphRuntime?.setInput(nodeId, handle, value);
+        },
+        setInputs: (nodeId, inputs) => {
+            graphRuntime?.setInputs(nodeId, inputs);
+        },
+        triggerExternal: (nodeId, event) => {
+            graphRuntime?.triggerExternal(nodeId, event);
+        },
+        launch: (invalidate) => {
+            graphRuntime?.launch(invalidate);
+        },
+        whenIdle: () => {
+            return graphRuntime?.whenIdle?.() ?? Promise.resolve();
+        },
+        dispose: () => {
+            graphRuntime?.dispose?.();
+            graphRuntime = undefined;
+        },
     };
-    // Cast to RuntimeApi now that all methods are defined
-    const originalsApi = originals;
     // Helper to wrap a method with extension support
     const wrapMethod = (key, original) => {
         const extension = extensions?.[key];
@@ -721,27 +719,27 @@ async function createRuntimeAdapter(createRegistry, send, extensions) {
         });
     };
     // Create API with extensions applied
-    const api = {
-        coerce: wrapMethod("coerce", originalsApi.coerce),
-        getEnvironment: wrapMethod("getEnvironment", originalsApi.getEnvironment),
-        applyRegistry: wrapMethod("applyRegistry", originalsApi.applyRegistry),
-        build: wrapMethod("build", originalsApi.build),
-        setExtData: wrapMethod("setExtData", originalsApi.setExtData),
-        getExtData: wrapMethod("getExtData", originalsApi.getExtData),
-        snapshot: wrapMethod("snapshot", originalsApi.snapshot),
-        snapshotFull: wrapMethod("snapshotFull", originalsApi.snapshotFull),
-        applySnapshotFull: wrapMethod("applySnapshotFull", originalsApi.applySnapshotFull),
-        describeRegistry: wrapMethod("describeRegistry", originalsApi.describeRegistry),
-        update: wrapMethod("update", originalsApi.update),
-        setEnvironment: wrapMethod("setEnvironment", originalsApi.setEnvironment),
-        setInput: wrapMethod("setInput", originalsApi.setInput),
-        setInputs: wrapMethod("setInputs", originalsApi.setInputs),
-        triggerExternal: wrapMethod("triggerExternal", originalsApi.triggerExternal),
-        launch: wrapMethod("launch", originalsApi.launch),
-        whenIdle: wrapMethod("whenIdle", originalsApi.whenIdle),
-        dispose: wrapMethod("dispose", originalsApi.dispose),
+    const extendedApi = {
+        coerce: wrapMethod("coerce", originalApi.coerce),
+        getEnvironment: wrapMethod("getEnvironment", originalApi.getEnvironment),
+        applyRegistry: wrapMethod("applyRegistry", originalApi.applyRegistry),
+        build: wrapMethod("build", originalApi.build),
+        setExtData: wrapMethod("setExtData", originalApi.setExtData),
+        getExtData: wrapMethod("getExtData", originalApi.getExtData),
+        snapshot: wrapMethod("snapshot", originalApi.snapshot),
+        snapshotFull: wrapMethod("snapshotFull", originalApi.snapshotFull),
+        applySnapshotFull: wrapMethod("applySnapshotFull", originalApi.applySnapshotFull),
+        describeRegistry: wrapMethod("describeRegistry", originalApi.describeRegistry),
+        update: wrapMethod("update", originalApi.update),
+        setEnvironment: wrapMethod("setEnvironment", originalApi.setEnvironment),
+        setInput: wrapMethod("setInput", originalApi.setInput),
+        setInputs: wrapMethod("setInputs", originalApi.setInputs),
+        triggerExternal: wrapMethod("triggerExternal", originalApi.triggerExternal),
+        launch: wrapMethod("launch", originalApi.launch),
+        whenIdle: wrapMethod("whenIdle", originalApi.whenIdle),
+        dispose: wrapMethod("dispose", originalApi.dispose),
     };
-    return api;
+    return extendedApi;
 }
 
 exports.HttpPollingTransport = HttpPollingTransport;