@bian-womp/spark-remote 0.2.28 → 0.2.29

package/lib/cjs/index.cjs

@@ -510,193 +510,234 @@ async function handleCommand(label, env, runtimeApi, ack) {
     }
 }
 
-async function createRuntimeAdapter(createRegistry, send) {
+async function createRuntimeAdapter(createRegistry, send, extensions) {
     const registry = await createRegistry();
     const builder = new sparkGraph.GraphBuilder(registry);
     let graphRuntime;
     let extData = {};
-    const api = {
-        async coerce(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?.() ?? {};
-        },
-        async applyRegistry(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: () => { },
-                    });
-                }
+    // Helper to get current context
+    const getContext = () => ({
+        registry,
+        builder,
+        graphRuntime,
+        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,
+                });
             }
-            // Notify clients (include deltas in invalidate payload)
-            send({
-                message: {
-                    type: "invalidate",
-                    payload: { reason: "registry-changed", deltas },
-                },
-            });
-        },
-        async build(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-type") {
+                registry.registerType({
+                    id: d.id,
+                    displayName: d.displayName,
+                    bakeTarget: d.bakeTarget,
+                    validate: (_v) => true,
+                });
             }
-            // 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 };
-                }
+            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: () => { },
+                });
             }
+        }
+        // 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 };
-        },
-        snapshotFull() {
-            const snap = api.snapshot();
-            const env = graphRuntime?.getEnvironment?.() ?? {};
-            const def = graphRuntime?.getGraphDef();
+        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);
             return {
-                def,
-                environment: env,
-                inputs: snap.inputs,
-                outputs: snap.outputs,
+                id,
+                displayName: d.displayName,
+                bakeTarget: d.bakeTarget,
+                ...(en ? { options: en.options } : {}),
             };
-        },
-        async applySnapshotFull(payload) {
-            const def = payload.def;
-            if (!def)
-                return;
-            await api.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 };
-        },
-        async update(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() {
-            graphRuntime?.launch();
-        },
-        whenIdle() {
-            return graphRuntime?.whenIdle?.() ?? Promise.resolve();
-        },
-        dispose() {
-            graphRuntime?.dispose?.();
-            graphRuntime = undefined;
-        },
+        });
+        // 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 = () => {
+        graphRuntime?.launch();
+    };
+    originals.whenIdle = () => {
+        return graphRuntime?.whenIdle?.() ?? Promise.resolve();
+    };
+    originals.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];
+        if (!extension) {
+            return original;
+        }
+        return ((...args) => {
+            return extension(original, getContext(), ...args);
+        });
+    };
+    // 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),
     };
     return api;
 }