@bian-womp/spark-remote 0.2.61 → 0.2.63

package/lib/esm/index.js

@@ -428,7 +428,7 @@ async function createRuntimeAdapter(createRegistry, send, extensions) {
             if (!def)
                 return;
             // Only build if skipBuild is not true
-            if (options?.skipBuild !== true) {
+            if (!options?.skipBuild) {
                 await originalApi.build(def, payload.environment);
             }
             else if (!graphRuntime) {
@@ -472,42 +472,93 @@ async function createRuntimeAdapter(createRegistry, send, extensions) {
             const coercions = registry.listCoercions();
             return { types, categories, nodes, coercions, schemaVersion: 4 };
         },
-        update: async (def) => {
+        update: async (def, options) => {
             if (!graphRuntime)
                 return;
-            graphRuntime.update(def, registry);
-            send({
-                message: {
-                    type: "invalidate",
-                    payload: { reason: "graph-updated" },
-                },
-            });
+            const wasPaused = graphRuntime.isPaused();
+            if (options?.dry && !wasPaused)
+                graphRuntime.pause();
+            try {
+                graphRuntime.update(def, registry);
+                send({
+                    message: {
+                        type: "invalidate",
+                        payload: { reason: "graph-updated" },
+                    },
+                });
+            }
+            finally {
+                if (options?.dry && !wasPaused)
+                    graphRuntime.resume();
+            }
         },
         setEnvironment: (env, opts) => {
             if (!graphRuntime)
                 return;
-            if (opts?.merge) {
-                const current = graphRuntime.getEnvironment();
-                const next = { ...(current || {}), ...(env || {}) };
-                graphRuntime.setEnvironment(next);
-                return;
+            const wasPaused = graphRuntime.isPaused();
+            if (opts?.dry && !wasPaused)
+                graphRuntime.pause();
+            try {
+                if (opts?.merge) {
+                    const current = graphRuntime.getEnvironment();
+                    const next = { ...(current || {}), ...(env || {}) };
+                    graphRuntime.setEnvironment(next);
+                }
+                else {
+                    graphRuntime.setEnvironment(env);
+                }
+            }
+            finally {
+                if (opts?.dry && !wasPaused)
+                    graphRuntime.resume();
             }
-            graphRuntime.setEnvironment(env);
         },
-        setInputs: (nodeId, inputs) => {
-            if (engine) {
-                engine.setInputs(nodeId, inputs);
+        setInputs: (nodeId, inputs, options) => {
+            if (!graphRuntime)
+                return;
+            const wasPaused = graphRuntime.isPaused();
+            if (options?.dry && !wasPaused)
+                graphRuntime.pause();
+            try {
+                if (engine) {
+                    engine.setInputs(nodeId, inputs);
+                }
+                else {
+                    graphRuntime.setInputs(nodeId, inputs);
+                }
             }
-            else {
-                graphRuntime?.setInputs(nodeId, inputs);
+            finally {
+                if (options?.dry && !wasPaused)
+                    graphRuntime.resume();
             }
         },
-        triggerExternal: (nodeId, event) => {
-            if (engine) {
-                engine.triggerExternal(nodeId, event);
+        copyOutputs: (fromNodeId, toNodeId, options) => {
+            if (!graphRuntime)
+                return;
+            // Get outputs from source node
+            const fromNode = graphRuntime.getNodeData(fromNodeId);
+            if (!fromNode?.outputs)
+                return;
+            // Copy outputs to target node using hydrate
+            graphRuntime.hydrate({ outputs: { [toNodeId]: { ...fromNode.outputs } } }, { reemit: !options?.dry });
+        },
+        triggerExternal: (nodeId, event, options) => {
+            if (!graphRuntime)
+                return;
+            const wasPaused = graphRuntime.isPaused();
+            if (options?.dry && !wasPaused)
+                graphRuntime.pause();
+            try {
+                if (engine) {
+                    engine.triggerExternal(nodeId, event);
+                }
+                else {
+                    graphRuntime.triggerExternal(nodeId, event);
+                }
             }
-            else {
-                graphRuntime?.triggerExternal(nodeId, event);
+            finally {
+                if (options?.dry && !wasPaused)
+                    graphRuntime.resume();
             }
         },
         launch: (opts) => {
@@ -594,6 +645,7 @@ async function createRuntimeAdapter(createRegistry, send, extensions) {
         update: wrapMethod("update", originalApi.update),
         setEnvironment: wrapMethod("setEnvironment", originalApi.setEnvironment),
         setInputs: wrapMethod("setInputs", originalApi.setInputs),
+        copyOutputs: wrapMethod("copyOutputs", originalApi.copyOutputs),
         triggerExternal: wrapMethod("triggerExternal", originalApi.triggerExternal),
         step: wrapMethod("step", originalApi.step),
         computeNode: wrapMethod("computeNode", originalApi.computeNode),
@@ -643,14 +695,22 @@ class RemoteEngine {
         });
     }
     // Batch inputs for a single network round-trip
-    setInputs(nodeId, inputs) {
+    setInputs(nodeId, inputs, options) {
         this.transport.send({
-            message: { type: "SetInputs", payload: { nodeId, inputs } },
+            message: {
+                type: "SetInputs",
+                payload: { nodeId, inputs },
+                dry: options?.dry,
+            },
         });
     }
-    triggerExternal(nodeId, event) {
+    triggerExternal(nodeId, event, options) {
         this.transport.send({
-            message: { type: "TriggerExternal", payload: { nodeId, event } },
+            message: {
+                type: "TriggerExternal",
+                payload: { nodeId, event },
+                dry: options?.dry,
+            },
         });
     }
     on(event, handler) {
@@ -941,10 +1001,10 @@ class RuntimeApiClient {
             },
         });
     }
-    async update(def) {
+    async update(def, options) {
         const transport = await this.ensureConnected();
         await transport.request({
-            message: { type: "Update", payload: { def } },
+            message: { type: "Update", payload: { def }, dry: options?.dry },
         });
     }
     async describeRegistry() {
@@ -1004,6 +1064,7 @@ class RuntimeApiClient {
             message: {
                 type: "SetEnvironment",
                 payload: { environment, merge: opts?.merge },
+                dry: opts?.dry,
             },
         });
     }
@@ -1015,6 +1076,16 @@ class RuntimeApiClient {
         const payload = res?.message || {};
         return payload.environment || {};
     }
+    async copyOutputs(fromNodeId, toNodeId, options) {
+        const transport = await this.ensureConnected();
+        await transport.request({
+            message: {
+                type: "CopyOutputs",
+                payload: { fromNodeId, toNodeId },
+                dry: options?.dry,
+            },
+        });
+    }
     async coerce(from, to, value) {
         const transport = await this.ensureConnected();
         const res = await transport.request({
@@ -1156,39 +1227,60 @@ class RuntimeApiServer {
                 break;
             }
             case "Update": {
+                const dry = msg.dry;
                 this.logCommand("Update", env, {
                     nodes: msg.payload.def.nodes?.length ?? 0,
                     edges: msg.payload.def.edges?.length ?? 0,
+                    dry: !!dry,
                 });
-                await this.runtimeApi.update(msg.payload.def);
+                await this.runtimeApi.update(msg.payload.def, { dry });
                 ack();
                 break;
             }
             case "SetEnvironment": {
-                this.logCommand("SetEnvironment", env);
+                const dry = msg.dry;
+                this.logCommand("SetEnvironment", env, dry ? { dry: true } : undefined);
                 this.runtimeApi.setEnvironment(msg.payload.environment, {
                     merge: Boolean(msg.payload.merge),
+                    dry,
                 });
                 ack();
                 break;
             }
             case "SetInputs": {
+                const dry = msg.dry;
                 this.logCommand("SetInputs", env, {
                     nodeId: msg.payload.nodeId,
                     keys: Object.keys(msg.payload.inputs || {}).join(","),
+                    dry: !!dry,
                 });
                 const nodeId = msg.payload.nodeId;
                 const inputs = msg.payload.inputs;
-                this.runtimeApi.setInputs(nodeId, inputs);
+                this.runtimeApi.setInputs(nodeId, inputs, { dry });
+                ack();
+                break;
+            }
+            case "CopyOutputs": {
+                const dry = msg.dry;
+                this.logCommand("CopyOutputs", env, {
+                    fromNodeId: msg.payload.fromNodeId,
+                    toNodeId: msg.payload.toNodeId,
+                    dry: !!dry,
+                });
+                this.runtimeApi.copyOutputs(msg.payload.fromNodeId, msg.payload.toNodeId, { dry });
                 ack();
                 break;
             }
             case "TriggerExternal": {
+                const dry = msg.dry;
                 this.logCommand("TriggerExternal", env, {
                     nodeId: msg.payload.nodeId,
                     event: summarize(msg.payload.event),
+                    dry: !!dry,
+                });
+                this.runtimeApi.triggerExternal(msg.payload.nodeId, msg.payload.event, {
+                    dry,
                 });
-                this.runtimeApi.triggerExternal(msg.payload.nodeId, msg.payload.event);
                 ack();
                 break;
             }