@bian-womp/spark-remote 0.2.68 → 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,6 +663,12 @@ 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;
 }
@@ -1051,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({
@@ -1157,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.
@@ -1412,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();