@bian-womp/spark-remote 0.2.67 → 0.2.69

package/lib/cjs/index.cjs

@@ -445,6 +445,14 @@ async function createRuntimeAdapter(createRegistry, send, extensions) {
             });
             originalApi.setExtData(payload.extData || {});
         },
+        cancelNodeRuns: (nodeIds) => {
+            graphRuntime?.cancelNodeRuns(nodeIds);
+        },
+        commit: async () => { },
+        undo: async () => false,
+        redo: async () => false,
+        canUndo: async () => false,
+        canRedo: async () => false,
         describeRegistry: () => {
             // types (include enum options when available)
             const types = Array.from(registry.types.entries()).map(([id, d]) => {
@@ -655,10 +663,38 @@ async function createRuntimeAdapter(createRegistry, send, extensions) {
         launch: wrapMethod("launch", originalApi.launch),
         whenIdle: wrapMethod("whenIdle", originalApi.whenIdle),
         dispose: wrapMethod("dispose", originalApi.dispose),
+        commit: wrapMethod("commit", originalApi.commit),
+        cancelNodeRuns: wrapMethod("cancelNodeRuns", originalApi.cancelNodeRuns),
+        undo: wrapMethod("undo", originalApi.undo),
+        redo: wrapMethod("redo", originalApi.redo),
+        canUndo: wrapMethod("canUndo", originalApi.canUndo),
+        canRedo: wrapMethod("canRedo", originalApi.canRedo),
     };
     return extendedApi;
 }
 
+const UNSET_MARKER = { __sparkUnset: true };
+function isUnsetMarker(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        "__sparkUnset" in value &&
+        value.__sparkUnset === true);
+}
+function encodeInputsForTransport(inputs) {
+    const encoded = {};
+    for (const [key, value] of Object.entries(inputs)) {
+        encoded[key] = value === undefined ? UNSET_MARKER : value;
+    }
+    return encoded;
+}
+function decodeInputsFromTransport(inputs) {
+    const decoded = {};
+    for (const [key, value] of Object.entries(inputs)) {
+        decoded[key] = isUnsetMarker(value) ? undefined : value;
+    }
+    return decoded;
+}
+
 class RemoteEngine {
     constructor(transport) {
         this.transport = transport;
@@ -696,12 +732,12 @@ class RemoteEngine {
             },
         });
     }
-    // Batch inputs for a single network round-trip
     setInputs(nodeId, inputs, options) {
+        const encodedInputs = encodeInputsForTransport(inputs);
         this.transport.send({
             message: {
                 type: "SetInputs",
-                payload: { nodeId, inputs },
+                payload: { nodeId, inputs: encodedInputs },
                 dry: options?.dry,
             },
         });
@@ -1029,6 +1065,16 @@ class RuntimeApiClient {
             message: { type: "RegistryApply", payload: { deltas } },
         });
     }
+    async setInputs(nodeId, inputs, options) {
+        const transport = await this.ensureConnected();
+        await transport.request({
+            message: {
+                type: "SetInputs",
+                payload: { nodeId, inputs },
+                dry: options?.dry,
+            },
+        });
+    }
     async snapshot() {
         const transport = await this.ensureConnected();
         const res = await transport.request({
@@ -1135,6 +1181,44 @@ class RuntimeApiClient {
             message: { type: "SetExtData", payload: data },
         });
     }
+    async commit() {
+        const transport = await this.ensureConnected();
+        await transport.request({
+            message: { type: "Commit" },
+        });
+    }
+    async undo() {
+        const transport = await this.ensureConnected();
+        const res = await transport.request({
+            message: { type: "Undo" },
+        });
+        const payload = res?.message || {};
+        return payload.success ?? false;
+    }
+    async redo() {
+        const transport = await this.ensureConnected();
+        const res = await transport.request({
+            message: { type: "Redo" },
+        });
+        const payload = res?.message || {};
+        return payload.success ?? false;
+    }
+    async canUndo() {
+        const transport = await this.ensureConnected();
+        const res = await transport.request({
+            message: { type: "CanUndo" },
+        });
+        const payload = res?.message || {};
+        return payload.canUndo ?? false;
+    }
+    async canRedo() {
+        const transport = await this.ensureConnected();
+        const res = await transport.request({
+            message: { type: "CanRedo" },
+        });
+        const payload = res?.message || {};
+        return payload.canRedo ?? false;
+    }
     /**
      * Dispose the client and close the transport connection.
      * Idempotent: safe to call multiple times.
@@ -1257,7 +1341,7 @@ class RuntimeApiServer {
                     dry: !!dry,
                 });
                 const nodeId = msg.payload.nodeId;
-                const inputs = msg.payload.inputs;
+                const inputs = decodeInputsFromTransport(msg.payload.inputs);
                 this.runtimeApi.setInputs(nodeId, inputs, { dry });
                 ack();
                 break;
@@ -1390,6 +1474,36 @@ class RuntimeApiServer {
                 ack();
                 break;
             }
+            case "Commit": {
+                this.logCommand("Commit", env);
+                await this.runtimeApi.commit();
+                ack();
+                break;
+            }
+            case "Undo": {
+                this.logCommand("Undo", env);
+                const success = await this.runtimeApi.undo();
+                ack({ success });
+                break;
+            }
+            case "Redo": {
+                this.logCommand("Redo", env);
+                const success = await this.runtimeApi.redo();
+                ack({ success });
+                break;
+            }
+            case "CanUndo": {
+                this.logCommand("CanUndo", env);
+                const canUndo = await this.runtimeApi.canUndo();
+                ack({ canUndo });
+                break;
+            }
+            case "CanRedo": {
+                this.logCommand("CanRedo", env);
+                const canRedo = await this.runtimeApi.canRedo();
+                ack({ canRedo });
+                break;
+            }
             default: {
                 this.logCommand("Unknown type", env);
                 ack();