@synnaxlabs/client 0.54.2 → 0.56.0

package/src/schematic/actions.ts

@@ -0,0 +1,168 @@
+// Copyright 2026 Synnax Labs, Inc.
+//
+// Use of this software is governed by the Business Source License included in the file
+// licenses/BSL.txt.
+//
+// As of the Change Date specified in that file, in accordance with the Business Source
+// License, use of this software will be governed by the Apache License, Version 2.0,
+// included in the file licenses/APL.txt.
+
+import { color, type record } from "@synnaxlabs/x";
+import { current, type Draft, isDraft } from "immer";
+
+import {
+  type Action,
+  addEdge,
+  createReduceAll,
+  type HandlerResult,
+  type Handlers,
+  removeEdge,
+  removeNode,
+  rename,
+  setConfig,
+  setNode,
+  setNodePosition,
+} from "@/schematic/actions.gen";
+
+const NO_OP: HandlerResult = { inverse: [], targets: [] };
+
+// Snapshots a value out of an Immer draft so the result is safe to embed in an
+// action stored on the undo stack. When reduceAll applies multiple actions in
+// one produce(), an earlier action's wholesale assignment (e.g. state.configs[k]
+// = {...existing, ...payload.config}) leaves the slot as a plain object — the
+// next action would crash if it called current() unconditionally.
+const snapshot = <T>(v: T): T => (isDraft(v) ? current(v as Draft<T>) : v);
+
+const handlers: Handlers = {
+  rename: (state, payload) => {
+    const oldName = state.name;
+    state.name = payload.name;
+    return {
+      inverse: [rename({ name: oldName })],
+      targets: [state.key],
+    };
+  },
+  setNodePosition: (state, payload) => {
+    const node = state.nodes.find((n) => n.key === payload.key);
+    if (node == null) return NO_OP;
+    const oldPosition = { x: node.position.x, y: node.position.y };
+    node.position = payload.position;
+    return {
+      inverse: [setNodePosition({ key: payload.key, position: oldPosition })],
+      targets: [payload.key],
+    };
+  },
+
+  // set_node_measured carries layout-derived dimensions, not user intent.
+  // Both the inverse and the target list are empty so it neither contributes
+  // to the undo stack nor invalidates undoables targeting the same node when
+  // a remote session emits it.
+  setNodeMeasured: (state, payload) => {
+    const node = state.nodes.find((n) => n.key === payload.key);
+    if (node == null) return NO_OP;
+    node.measured = payload.measured;
+    return { inverse: [], targets: [] };
+  },
+  setNode: (state, payload) => {
+    const idx = state.nodes.findIndex((n) => n.key === payload.node.key);
+    if (idx === -1) {
+      state.nodes.push(payload.node);
+      if (payload.config != null) state.configs[payload.node.key] = payload.config;
+      return {
+        inverse: [removeNode({ key: payload.node.key })],
+        targets: [payload.node.key],
+      };
+    }
+    const oldNode = snapshot(state.nodes[idx]);
+    const oldConfigRaw = state.configs[payload.node.key];
+    const oldConfig = oldConfigRaw != null ? snapshot(oldConfigRaw) : undefined;
+    state.nodes[idx] = payload.node;
+    if (payload.config != null) state.configs[payload.node.key] = payload.config;
+    return {
+      inverse: [
+        setNode(
+          oldConfig != null
+            ? { node: oldNode, config: oldConfig }
+            : { node: oldNode, config: undefined },
+        ),
+      ],
+      targets: [payload.node.key],
+    };
+  },
+  removeNode: (state, payload) => {
+    const idx = state.nodes.findIndex((n) => n.key === payload.key);
+    if (idx === -1) return NO_OP;
+    const oldNode = snapshot(state.nodes[idx]);
+    const oldConfigRaw = state.configs[payload.key];
+    const oldConfig = oldConfigRaw != null ? snapshot(oldConfigRaw) : undefined;
+    state.nodes.splice(idx, 1);
+    delete state.configs[payload.key];
+    return {
+      inverse: [
+        setNode(
+          oldConfig != null
+            ? { node: oldNode, config: oldConfig }
+            : { node: oldNode, config: undefined },
+        ),
+      ],
+      targets: [payload.key],
+    };
+  },
+  addEdge: (state, payload) => {
+    if (state.edges.some((e) => e.key === payload.edge.key)) return NO_OP;
+    state.edges.push(payload.edge);
+    return {
+      inverse: [removeEdge({ key: payload.edge.key })],
+      targets: [payload.edge.key],
+    };
+  },
+
+  removeEdge: (state, payload) => {
+    const idx = state.edges.findIndex((e) => e.key === payload.key);
+    if (idx === -1) return NO_OP;
+    const oldEdge = snapshot(state.edges[idx]);
+    state.edges.splice(idx, 1);
+    return {
+      inverse: [addEdge({ edge: oldEdge })],
+      targets: [payload.key],
+    };
+  },
+  // The inverse of SetConfig is imperfect for keys the action newly
+  // introduces: SetConfig only merges, so it cannot remove keys that did not
+  // previously exist. The inverse here restores values for keys that DID
+  // exist before the merge; keys added by the action remain on undo as
+  // phantom fields. A future ReplaceConfig action can close the gap by
+  // enabling wholesale replacement.
+  setConfig: (state, payload) => {
+    const existingRaw = state.configs[payload.key];
+    if (existingRaw != null) {
+      const existing = snapshot(existingRaw);
+      const restoreFields: record.Unknown = {};
+      for (const k of Object.keys(payload.config))
+        if (existing[k] !== undefined) restoreFields[k] = existing[k];
+      state.configs[payload.key] = { ...existing, ...payload.config };
+      if (Object.keys(restoreFields).length === 0)
+        return { inverse: [], targets: [payload.key] };
+      return {
+        inverse: [setConfig({ key: payload.key, config: restoreFields })],
+        targets: [payload.key],
+      };
+    }
+    let cfg = payload.config;
+    const edge = state.edges.find((e) => e.key === payload.key);
+    if (edge != null) {
+      const srcCfg = state.configs[edge.source.node] as
+        | { color?: color.Crude }
+        | undefined;
+      if (srcCfg?.color != null && !color.isZero(srcCfg.color))
+        cfg = { ...cfg, color: srcCfg.color };
+    }
+    state.configs[payload.key] = cfg;
+    return { inverse: [], targets: [payload.key] };
+  },
+};
+
+export const reduceAll = createReduceAll(handlers);
+
+export const isUndoable = (action: Action): boolean =>
+  action.type !== "set_node_measured";

package/src/schematic/client.ts

@@ -7,10 +7,15 @@
 // License, use of this software will be governed by the Apache License, Version 2.0,
 // included in the file licenses/APL.txt.
 
-import { sendRequired, type UnaryClient } from "@synnaxlabs/freighter";
-import { array, caseconv, record } from "@synnaxlabs/x";
+import { type UnaryClient } from "@synnaxlabs/freighter";
+import { array } from "@synnaxlabs/x";
 import { z } from "zod";
 
+import {
+  type Action,
+  dispatchReqZ,
+  rename as renameAction,
+} from "@/schematic/actions.gen";
 import { symbol } from "@/schematic/symbol";
 import {
   type Key,
@@ -23,12 +28,11 @@ import {
 import { checkForMultipleOrNoResults } from "@/util/retrieve";
 import { workspace } from "@/workspace";
 
-const renameReqZ = z.object({ key: keyZ, name: z.string() });
+export const SET_CHANNEL_NAME = "sy_schematic_set";
 
-const setDataReqZ = z.object({
-  key: keyZ,
-  data: caseconv.preserveCase(record.unknownZ()),
-});
+const setDataBodyZ = schematicZ.omit({ key: true, name: true, snapshot: true });
+export type SetDataBody = z.input<typeof setDataBodyZ>;
+const setDataReqZ = z.object({ key: keyZ, data: setDataBodyZ });
 const deleteReqZ = z.object({ keys: keyZ.array() });
 
 const copyReqZ = z.object({
@@ -75,8 +79,7 @@ export class Client {
     schematics: New | New[],
   ): Promise<Schematic | Schematic[]> {
     const isMany = Array.isArray(schematics);
-    const res = await sendRequired(
-      this.client,
+    const res = await this.client.send(
       "/schematic/create",
       { workspace, schematics: array.toArray(schematics) },
       createReqZ,
@@ -86,18 +89,11 @@ export class Client {
   }
 
   async rename(key: Key, name: string): Promise<void> {
-    await sendRequired(
-      this.client,
-      "/schematic/rename",
-      { key, name },
-      renameReqZ,
-      emptyResZ,
-    );
+    await this.dispatch(key, "", [renameAction({ name })]);
   }
 
-  async setData(key: Key, data: record.Unknown): Promise<void> {
-    await sendRequired(
-      this.client,
+  async setData(key: Key, data: SetDataBody): Promise<void> {
+    await this.client.send(
       "/schematic/set-data",
       { key, data },
       setDataReqZ,
@@ -105,14 +101,22 @@ export class Client {
     );
   }
 
+  async dispatch(key: Key, dispatchKey: string, actions: Action[]): Promise<void> {
+    await this.client.send(
+      "/schematic/dispatch",
+      { key, dispatchKey, actions },
+      dispatchReqZ,
+      emptyResZ,
+    );
+  }
+
   async retrieve(args: RetrieveSingleParams): Promise<Schematic>;
   async retrieve(args: RetrieveMultipleParams): Promise<Schematic[]>;
   async retrieve(
     args: RetrieveSingleParams | RetrieveMultipleParams,
   ): Promise<Schematic | Schematic[]> {
     const isSingle = singleRetrieveArgsZ.safeParse(args).success;
-    const res = await sendRequired(
-      this.client,
+    const res = await this.client.send(
       "/schematic/retrieve",
       args,
       retrieveArgsZ,
@@ -123,8 +127,7 @@ export class Client {
   }
 
   async delete(keys: Key | Key[]): Promise<void> {
-    await sendRequired(
-      this.client,
+    await this.client.send(
       "/schematic/delete",
       { keys: array.toArray(keys) },
       deleteReqZ,
@@ -133,13 +136,14 @@ export class Client {
   }
 
   async copy(args: CopyArgs): Promise<Schematic> {
-    const res = await sendRequired(
-      this.client,
-      "/schematic/copy",
-      args,
-      copyReqZ,
-      copyResZ,
-    );
+    const res = await this.client.send("/schematic/copy", args, copyReqZ, copyResZ);
     return res.schematic;
   }
 }
+
+export const ZERO_NEW: New = {
+  name: "",
+  nodes: [],
+  edges: [],
+  configs: {},
+};

package/src/schematic/external.ts

@@ -7,6 +7,8 @@
 // License, use of this software will be governed by the Apache License, Version 2.0,
 // included in the file licenses/APL.txt.
 
+export * from "@/schematic/actions";
+export * from "@/schematic/actions.gen";
 export * from "@/schematic/client";
 export * from "@/schematic/symbol";
 export * from "@/schematic/types.gen";

package/src/schematic/schematic.spec.ts

@@ -11,8 +11,18 @@ import { uuid } from "@synnaxlabs/x";
 import { describe, expect, it, test } from "vitest";
 
 import { NotFoundError, ValidationError } from "@/errors";
+import { schematic } from "@/schematic";
 import { createTestClient } from "@/testutil/client";
 
+const newWorkspaceSchematic = async (client: ReturnType<typeof createTestClient>) => {
+  const ws = await client.workspaces.create({ name: "dispatch", layout: {} });
+  const schem = await client.schematics.create(ws.key, {
+    ...schematic.ZERO_NEW,
+    name: "dispatch",
+  });
+  return { ws, schem };
+};
+
 const client = createTestClient();
 
 describe("Schematic", () => {
@@ -22,17 +32,14 @@ describe("Schematic", () => {
         name: "Schematic",
         layout: { one: 1 },
       });
-      const schematic = await client.schematics.create(ws.key, {
+      const schem = await client.schematics.create(ws.key, {
+        ...schematic.ZERO_NEW,
         name: "Schematic",
-        data: { One: 1 },
-      });
-      expect(schematic.name).toEqual("Schematic");
-      expect(schematic.key).not.toEqual(uuid.ZERO);
-      expect(schematic.data.One).toEqual(1);
-      const retrieved = await client.schematics.retrieve({
-        key: schematic.key,
       });
-      expect(retrieved.data.One).toEqual(1);
+      expect(schem.name).toEqual("Schematic");
+      expect(schem.key).not.toEqual(uuid.ZERO);
+      const retrieved = await client.schematics.retrieve({ key: schem.key });
+      expect(retrieved.key).toEqual(schem.key);
     });
   });
 
@@ -42,33 +49,36 @@ describe("Schematic", () => {
         name: "Schematic",
         layout: { one: 1 },
       });
-      const schematic = await client.schematics.create(ws.key, {
+      const schem = await client.schematics.create(ws.key, {
+        ...schematic.ZERO_NEW,
         name: "Schematic",
-        data: { one: 1 },
-      });
-      await client.schematics.rename(schematic.key, "Schematic2");
-      const res = await client.schematics.retrieve({
-        key: schematic.key,
       });
+      await client.schematics.rename(schem.key, "Schematic2");
+      const res = await client.schematics.retrieve({ key: schem.key });
       expect(res.name).toEqual("Schematic2");
     });
   });
 
   describe("setData", () => {
-    test("set data", async () => {
+    test("set data replaces body fields while preserving key and name", async () => {
       const ws = await client.workspaces.create({
         name: "Schematic",
         layout: { one: 1 },
       });
-      const schematic = await client.schematics.create(ws.key, {
+      const schem = await client.schematics.create(ws.key, {
+        ...schematic.ZERO_NEW,
         name: "Schematic",
-        data: { one: 1 },
       });
-      await client.schematics.setData(schematic.key, { two: 2 });
-      const res = await client.schematics.retrieve({
-        key: schematic.key,
+      await client.schematics.setData(schem.key, {
+        ...schematic.ZERO_NEW,
+        nodes: [{ key: "n1", position: { x: 10, y: 20 }, zIndex: 0 }],
+        configs: { n1: { variant: "valve" } },
       });
-      expect(res.data.two).toEqual(2);
+      const res = await client.schematics.retrieve({ key: schem.key });
+      expect(res.name).toEqual("Schematic");
+      expect(res.nodes).toHaveLength(1);
+      expect(res.nodes[0].key).toEqual("n1");
+      expect((res.configs.n1 as Record<string, unknown>).variant).toEqual("valve");
     });
   });
 
@@ -78,57 +88,48 @@ describe("Schematic", () => {
         name: "Schematic",
         layout: { one: 1 },
       });
-      const schematic = await client.schematics.create(ws.key, {
+      const schem = await client.schematics.create(ws.key, {
+        ...schematic.ZERO_NEW,
         name: "Schematic",
-        data: { one: 1 },
       });
-      await client.schematics.delete(schematic.key);
-      await expect(client.schematics.retrieve({ key: schematic.key })).rejects.toThrow(
+      await client.schematics.delete(schem.key);
+      await expect(client.schematics.retrieve({ key: schem.key })).rejects.toThrow(
         NotFoundError,
       );
     });
   });
-  describe("case preservation", () => {
-    test("should preserve key casing in data field on create/retrieve cycle", async () => {
-      const ws = await client.workspaces.create({
-        name: "CaseTest",
-        layout: {},
-      });
-      const schematic = await client.schematics.create(ws.key, {
-        name: "CaseTest",
-        data: {
-          camelCaseKey: "value1",
-          PascalCaseKey: "value2",
-          snake_case_key: "value3",
-          nested: {
-            innerCamelCase: 123,
-            InnerPascalCase: { deepKey: true },
+
+  describe("config case preservation", () => {
+    test("preserves arbitrary key casing within config values", async () => {
+      const ws = await client.workspaces.create({ name: "CaseTest", layout: {} });
+      const schem = await client.schematics.create(ws.key, {
+        ...schematic.ZERO_NEW,
+        configs: {
+          n1: {
+            camelCaseKey: "value1",
+            PascalCaseKey: "value2",
+            snake_case_key: "value3",
+            nested: {
+              innerCamelCase: 123,
+              InnerPascalCase: { deepKey: true },
+            },
           },
         },
       });
-
-      const retrieved = await client.schematics.retrieve({
-        key: schematic.key,
-      });
-
-      const data = retrieved.data as Record<string, unknown>;
-      expect(data.camelCaseKey).toEqual("value1");
-      expect(data.PascalCaseKey).toEqual("value2");
-      expect(data.snake_case_key).toEqual("value3");
-      expect((data.nested as Record<string, unknown>).innerCamelCase).toEqual(123);
+      const retrieved = await client.schematics.retrieve({ key: schem.key });
+      const config = retrieved.configs.n1 as Record<string, unknown>;
+      expect(config.camelCaseKey).toEqual("value1");
+      expect(config.PascalCaseKey).toEqual("value2");
+      expect(config.snake_case_key).toEqual("value3");
+      expect((config.nested as Record<string, unknown>).innerCamelCase).toEqual(123);
       expect(
         (
-          (data.nested as Record<string, unknown>).InnerPascalCase as Record<
+          (config.nested as Record<string, unknown>).InnerPascalCase as Record<
             string,
             unknown
           >
         ).deepKey,
       ).toEqual(true);
-      expect(Object.keys(data)).toContain("camelCaseKey");
-      expect(Object.keys(data)).toContain("PascalCaseKey");
-      expect(Object.keys(data)).toContain("snake_case_key");
-      expect(Object.keys(data)).not.toContain("camel_case_key");
-      expect(Object.keys(data)).not.toContain("pascal_case_key");
     });
   });
 
@@ -138,18 +139,17 @@ describe("Schematic", () => {
         name: "Schematic",
         layout: { one: 1 },
       });
-      const schematic = await client.schematics.create(ws.key, {
+      const schem = await client.schematics.create(ws.key, {
+        ...schematic.ZERO_NEW,
         name: "Schematic",
-        data: { one: 1 },
       });
-      const schematic2 = await client.schematics.copy({
-        key: schematic.key,
+      const schem2 = await client.schematics.copy({
+        key: schem.key,
         name: "Schematic2",
         snapshot: false,
       });
-      expect(schematic2.name).toEqual("Schematic2");
-      expect(schematic2.key).not.toEqual(uuid.ZERO);
-      expect(schematic2.data.one).toEqual(1);
+      expect(schem2.name).toEqual("Schematic2");
+      expect(schem2.key).not.toEqual(uuid.ZERO);
     });
 
     describe("snapshot", () => {
@@ -158,19 +158,183 @@ describe("Schematic", () => {
           name: "Schematic",
           layout: { one: 1 },
         });
-        const schematic = await client.schematics.create(ws.key, {
+        const schem = await client.schematics.create(ws.key, {
+          ...schematic.ZERO_NEW,
           name: "Schematic",
-          data: { one: 1 },
         });
-        const schematic2 = await client.schematics.copy({
-          key: schematic.key,
+        const schem2 = await client.schematics.copy({
+          key: schem.key,
           name: "Schematic2",
           snapshot: true,
         });
         await expect(
-          client.schematics.setData(schematic2.key, { two: 2 }),
+          client.schematics.setData(schem2.key, { ...schematic.ZERO_NEW }),
         ).rejects.toThrow(ValidationError);
       });
     });
   });
+
+  describe("dispatch", () => {
+    test("setNodePosition moves the matching node", async () => {
+      const { schem } = await newWorkspaceSchematic(client);
+      await client.schematics.setData(schem.key, {
+        ...schematic.ZERO_NEW,
+        nodes: [{ key: "n1", position: { x: 0, y: 0 } }],
+      });
+      await client.schematics.dispatch(schem.key, "sess-1", [
+        schematic.setNodePosition({ key: "n1", position: { x: 100, y: 200 } }),
+      ]);
+      const res = await client.schematics.retrieve({ key: schem.key });
+      expect(res.nodes).toHaveLength(1);
+      expect(res.nodes[0].position).toEqual({ x: 100, y: 200 });
+    });
+
+    test("setNode inserts a node and writes its config", async () => {
+      const { schem } = await newWorkspaceSchematic(client);
+      await client.schematics.dispatch(schem.key, "sess-1", [
+        schematic.setNode({
+          node: { key: "n1", position: { x: 1, y: 2 } },
+          config: { label: "Pump" },
+        }),
+      ]);
+      const res = await client.schematics.retrieve({ key: schem.key });
+      expect(res.nodes).toHaveLength(1);
+      expect(res.nodes[0]).toMatchObject({ key: "n1", position: { x: 1, y: 2 } });
+      expect(res.configs.n1.label).toBe("Pump");
+    });
+
+    test("removeNode removes the node and drops its config", async () => {
+      const { schem } = await newWorkspaceSchematic(client);
+      await client.schematics.setData(schem.key, {
+        ...schematic.ZERO_NEW,
+        nodes: [
+          { key: "n1", position: { x: 0, y: 0 } },
+          { key: "n2", position: { x: 1, y: 1 } },
+        ],
+        configs: { n1: { label: "Pump" }, n2: { label: "Tank" } },
+      });
+      await client.schematics.dispatch(schem.key, "sess-1", [
+        schematic.removeNode({ key: "n1" }),
+      ]);
+      const res = await client.schematics.retrieve({ key: schem.key });
+      expect(res.nodes).toHaveLength(1);
+      expect(res.nodes[0]).toMatchObject({ key: "n2", position: { x: 1, y: 1 } });
+      expect(res.configs).toEqual({ n2: { label: "Tank" } });
+    });
+
+    test("addEdge appends new edges and is a no-op on duplicate keys", async () => {
+      const { schem } = await newWorkspaceSchematic(client);
+      const e = (
+        key: string,
+        srcNode: string,
+        srcParam: string,
+        tgtNode: string,
+        tgtParam: string,
+      ) => ({
+        key,
+        source: { node: srcNode, param: srcParam },
+        target: { node: tgtNode, param: tgtParam },
+      });
+      await client.schematics.setData(schem.key, {
+        ...schematic.ZERO_NEW,
+        edges: [e("e1", "a", "o", "b", "i"), e("e2", "b", "o", "c", "i")],
+      });
+      await client.schematics.dispatch(schem.key, "sess-1", [
+        schematic.addEdge({ edge: e("e2", "x", "y", "z", "w") }),
+        schematic.addEdge({ edge: e("e3", "c", "o", "d", "i") }),
+      ]);
+      const res = await client.schematics.retrieve({ key: schem.key });
+      expect(res.edges).toEqual([
+        e("e1", "a", "o", "b", "i"),
+        e("e2", "b", "o", "c", "i"),
+        e("e3", "c", "o", "d", "i"),
+      ]);
+    });
+
+    test("removeEdge removes the matching edge", async () => {
+      const { schem } = await newWorkspaceSchematic(client);
+      await client.schematics.setData(schem.key, {
+        ...schematic.ZERO_NEW,
+        edges: [
+          {
+            key: "e1",
+            source: { node: "a", param: "o" },
+            target: { node: "b", param: "i" },
+          },
+        ],
+      });
+      await client.schematics.dispatch(schem.key, "sess-1", [
+        schematic.removeEdge({ key: "e1" }),
+      ]);
+      const res = await client.schematics.retrieve({ key: schem.key });
+      expect(res.edges).toEqual([]);
+    });
+
+    test("setConfig upserts config under the given key", async () => {
+      const { schem } = await newWorkspaceSchematic(client);
+      await client.schematics.dispatch(schem.key, "sess-1", [
+        schematic.setConfig({ key: "n1", config: { label: "Original" } }),
+        schematic.setConfig({ key: "n1", config: { label: "Replaced" } }),
+      ]);
+      const res = await client.schematics.retrieve({ key: schem.key });
+      expect(res.configs.n1.label).toBe("Replaced");
+    });
+
+    test("applies a multi-action sequence atomically", async () => {
+      const { schem } = await newWorkspaceSchematic(client);
+      await client.schematics.dispatch(schem.key, "sess-1", [
+        schematic.setNode({ node: { key: "pump", position: { x: 0, y: 0 } } }),
+        schematic.setNode({ node: { key: "valve", position: { x: 100, y: 0 } } }),
+        schematic.addEdge({
+          edge: {
+            key: "e1",
+            source: { node: "pump", param: "out" },
+            target: { node: "valve", param: "in" },
+          },
+        }),
+        schematic.setConfig({ key: "pump", config: { label: "Main Pump" } }),
+      ]);
+      const res = await client.schematics.retrieve({ key: schem.key });
+      expect(res.nodes).toHaveLength(2);
+      expect(res.edges).toHaveLength(1);
+      expect(res.configs.pump.label).toBe("Main Pump");
+    });
+
+    test("converges to the final position after a 30-action drag storm", async () => {
+      const { schem } = await newWorkspaceSchematic(client);
+      await client.schematics.setData(schem.key, {
+        ...schematic.ZERO_NEW,
+        nodes: [{ key: "pump", position: { x: 0, y: 0 } }],
+      });
+      const actions = Array.from({ length: 30 }, (_, i) =>
+        schematic.setNodePosition({ key: "pump", position: { x: i, y: i * 2 } }),
+      );
+      await client.schematics.dispatch(schem.key, "sess-1", actions);
+      const res = await client.schematics.retrieve({ key: schem.key });
+      expect(res.nodes[0].position).toEqual({ x: 29, y: 58 });
+    });
+
+    test("preserves arbitrary key casing within config values through dispatch", async () => {
+      const { schem } = await newWorkspaceSchematic(client);
+      await client.schematics.dispatch(schem.key, "sess-1", [
+        schematic.setConfig({
+          key: "n1",
+          config: {
+            camelCaseKey: "v1",
+            PascalCaseKey: "v2",
+            snake_case_key: "v3",
+            nested: { innerCamelCase: 1, InnerPascalCase: { deepKey: true } },
+          },
+        }),
+      ]);
+      const res = await client.schematics.retrieve({ key: schem.key });
+      const config = res.configs.n1;
+      expect(config.camelCaseKey).toBe("v1");
+      expect(config.PascalCaseKey).toBe("v2");
+      expect(config.snake_case_key).toBe("v3");
+      const nested = config.nested as Record<string, unknown>;
+      expect(nested.innerCamelCase).toBe(1);
+      expect((nested.InnerPascalCase as Record<string, unknown>).deepKey).toBe(true);
+    });
+  });
 });