@1agh/maude 0.36.0 → 0.36.1

package/apps/studio/test/edit-source-command.test.ts

@@ -0,0 +1,119 @@
+import { beforeAll, describe, expect, mock, test } from 'bun:test';
+
+import {
+  buildEditSourceRecord,
+  createEditSourceCommand,
+  EDIT_SOURCE_KIND,
+  type EditSourceApplyFn,
+  type EditSourcePayload,
+} from '../commands/edit-source-command.ts';
+import { type CommandSinks, rebuildCommand, registerCommand } from '../undo-stack.ts';
+
+const cssEdit: EditSourcePayload = {
+  op: 'css',
+  canvas: '.design/ui/Foo.tsx',
+  id: 'cd-1',
+  key: 'color',
+  before: 'red',
+  after: 'blue',
+};
+
+describe('createEditSourceCommand', () => {
+  test('do() applies the AFTER value', async () => {
+    const applyFn = mock(() => {});
+    const cmd = createEditSourceCommand({ payload: cssEdit, applyFn });
+    await cmd.do();
+    expect(applyFn).toHaveBeenCalledTimes(1);
+    expect(applyFn.mock.calls[0]?.[0]).toEqual({
+      op: 'css',
+      canvas: '.design/ui/Foo.tsx',
+      id: 'cd-1',
+      key: 'color',
+      value: 'blue',
+    });
+  });
+
+  test('undo() applies the BEFORE value', async () => {
+    const applyFn = mock(() => {});
+    const cmd = createEditSourceCommand({ payload: cssEdit, applyFn });
+    await cmd.undo();
+    expect(applyFn.mock.calls[0]?.[0]?.value).toBe('red');
+  });
+
+  test('undo() of a NEW prop (before:null) applies null = reset', async () => {
+    const applyFn = mock(() => {});
+    const cmd = createEditSourceCommand({
+      payload: { ...cssEdit, before: null, after: 'blue' },
+      applyFn,
+    });
+    await cmd.undo();
+    expect(applyFn.mock.calls[0]?.[0]?.value).toBeNull();
+  });
+
+  test('do() of a RESET (after:null) applies null = remove the prop', async () => {
+    const applyFn = mock(() => {});
+    const cmd = createEditSourceCommand({
+      payload: { ...cssEdit, before: 'red', after: null },
+      applyFn,
+    });
+    await cmd.do();
+    expect(applyFn.mock.calls[0]?.[0]?.value).toBeNull();
+  });
+
+  test('label reflects op + key', () => {
+    expect(createEditSourceCommand({ payload: cssEdit, applyFn: () => {} }).label).toBe(
+      'edit color'
+    );
+    expect(
+      createEditSourceCommand({ payload: { ...cssEdit, after: null }, applyFn: () => {} }).label
+    ).toBe('reset color');
+    expect(
+      createEditSourceCommand({
+        payload: { op: 'attr', canvas: 'x', id: 'y', key: 'data-x', before: null, after: '1' },
+        applyFn: () => {},
+      }).label
+    ).toBe('edit @data-x');
+    expect(
+      createEditSourceCommand({
+        payload: { op: 'text', canvas: 'x', id: 'y', key: '', before: 'a', after: 'b' },
+        applyFn: () => {},
+      }).label
+    ).toBe('edit text');
+  });
+});
+
+describe('buildEditSourceRecord', () => {
+  test('produces a serializable record under the edit-source kind', () => {
+    const rec = buildEditSourceRecord(cssEdit);
+    expect(rec.kind).toBe(EDIT_SOURCE_KIND);
+    expect(rec.payload).toEqual(cssEdit);
+    expect(JSON.parse(JSON.stringify(rec))).toEqual(rec); // round-trips
+  });
+});
+
+describe('edit-source registry', () => {
+  // The module self-registers on import, but sibling test files wipe the shared
+  // builder registry in their beforeEach — re-register here so this block is
+  // order-independent. Mirrors the real registration in edit-source-command.ts.
+  beforeAll(() => {
+    registerCommand<EditSourcePayload>(EDIT_SOURCE_KIND, (record, sinks) => {
+      const applyFn = sinks.editSourceApplyFn as EditSourceApplyFn | undefined;
+      if (!applyFn) return null;
+      return createEditSourceCommand({ payload: record.payload, applyFn, label: record.label });
+    });
+  });
+
+  test('rebuildCommand returns null when the editSourceApplyFn sink is unbound', () => {
+    expect(rebuildCommand(buildEditSourceRecord(cssEdit), {} as CommandSinks)).toBeNull();
+  });
+
+  test('rebuildCommand wires the bound sink into a runnable command', async () => {
+    const applyFn = mock(() => {});
+    const cmd = rebuildCommand(buildEditSourceRecord(cssEdit), {
+      editSourceApplyFn: applyFn,
+    } as CommandSinks);
+    expect(cmd).not.toBeNull();
+    await cmd?.do();
+    expect(applyFn.mock.calls[0]?.[0]?.value).toBe('blue');
+  });
+});

package/apps/studio/test/use-undo-stack.test.tsx

@@ -155,6 +155,36 @@ describe('use-undo-stack / runner side-effects', () => {
   });
 });
 
+describe('use-undo-stack / record (already-applied edits)', () => {
+  test('record() appends WITHOUT running do()', async () => {
+    const v = captureProvider(undefined, { layoutPatchFn: () => {} });
+    v.record(rec('inline-edit', 'X'));
+    // undo() is enqueued after record(), so awaiting it flushes record first.
+    await v.undo();
+    expect(doSpy).toHaveBeenCalledTimes(0); // record never runs do()
+    expect(undoSpy).toHaveBeenCalledTimes(1);
+    expect(undoSpy.mock.calls[0]?.[0]).toBe('X');
+  });
+
+  test('record() then redo() (after undo) re-runs do()', async () => {
+    const v = captureProvider(undefined, { layoutPatchFn: () => {} });
+    v.record(rec('e', 'Y'));
+    await v.undo();
+    await v.redo();
+    expect(doSpy).toHaveBeenCalledTimes(1); // only redo's do(), not the record
+    expect(doSpy.mock.calls[0]?.[0]).toBe('Y');
+  });
+
+  test('record() clears the redo future', async () => {
+    const v = captureProvider(undefined, { layoutPatchFn: () => {} });
+    await v.push(rec('a', 'A')); // doSpy: 1
+    await v.undo(); // future = [a]
+    v.record(rec('b', 'B')); // clears future
+    await v.redo(); // future empty → no-op, no extra do()
+    expect(doSpy).toHaveBeenCalledTimes(1);
+  });
+});
+
 describe('use-undo-stack / cross-canvas persistence', () => {
   test('history under a canvasFile survives a fresh provider mount with the same canvasFile', async () => {
     // First mount: push 2 records.

package/apps/studio/undo-stack.ts

@@ -71,6 +71,16 @@ export interface CommandSinks {
   layoutPatchFn?: unknown;
   /** Wired by `AnnotationsLayer`. */
   strokesPutFn?: unknown;
+  /**
+   * Wired by `CanvasShell` (canvas-shell.tsx). Applies a single inline source
+   * edit (CSS / text / attr) by posting `dgn:'apply-edit'` to the parent shell,
+   * which owns the main-origin-only `/_api/edit-*` write (DDR-054 — the canvas
+   * iframe can't call those routes directly). Drives undo/redo of inspector
+   * CSS edits, inline text rewrites, and custom-attribute edits, which write
+   * the canvas `.tsx` source and were previously unrecoverable (no command, no
+   * snapshot). See `commands/edit-source-command.ts`.
+   */
+  editSourceApplyFn?: unknown;
 }
 
 export type CommandBuilder<P = unknown> = (

package/apps/studio/use-undo-stack.tsx

@@ -51,6 +51,14 @@ export interface UndoStackValue {
    * Awaiting the returned promise is optional.
    */
   push: (record: CommandRecord) => Promise<void>;
+  /**
+   * Record an ALREADY-APPLIED command — appends to `past` + clears `future`
+   * WITHOUT running `do()`. Use when the side-effect happened outside the
+   * stack (e.g. an inspector CSS commit / inline text edit that already POSTed
+   * `/_api/edit-*`), so re-running `do()` would double-apply. `undo()` / `redo()`
+   * still drive the command's `undo()` / `do()` normally afterwards.
+   */
+  record: (record: CommandRecord) => void;
   /** Undo the top of `past`. No-op when empty. */
   undo: () => Promise<void>;
   /** Redo the top of `future`. No-op when empty. */
@@ -69,6 +77,7 @@ const UndoStackContext = createContext<UndoStackValue | null>(null);
 
 const NOOP_VALUE: UndoStackValue = {
   push: () => Promise.resolve(),
+  record: () => {},
   undo: () => Promise.resolve(),
   redo: () => Promise.resolve(),
   clear: () => {},
@@ -213,6 +222,16 @@ export function UndoStackProvider({
     [enqueue, build, reportError, bumpLabel, writeState]
   );
 
+  const record = useCallback(
+    (rec: CommandRecord): void => {
+      void enqueue(async () => {
+        writeState(undoReducer(stateRef.current, { type: 'push', record: rec }));
+        bumpLabel(rec.label);
+      });
+    },
+    [enqueue, writeState, bumpLabel]
+  );
+
   const undo = useCallback(
     (): Promise<void> =>
       enqueue(async () => {
@@ -306,6 +325,7 @@ export function UndoStackProvider({
   const value = useMemo<UndoStackValue>(
     () => ({
       push,
+      record,
       undo,
       redo,
       clear,
@@ -318,7 +338,7 @@ export function UndoStackProvider({
     // `lastTick` (bumped by every push/undo/redo/clear) as the proxy so the
     // memoized canUndo/canRedo readouts re-evaluate on each transition.
     // eslint-disable-next-line react-hooks/exhaustive-deps
-    [push, undo, redo, clear, lastLabel, lastTick]
+    [push, record, undo, redo, clear, lastLabel, lastTick]
   );
 
   return (

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@1agh/maude",
-  "version": "0.36.0",
+  "version": "0.36.1",
   "description": "Marketplace of Claude Code plugins by Michal Dovrtěl: `design` (canvas-first design iteration) + `flow` (generic agentic workflow loop with .ai second brain). Ships the `maude` CLI (with `mdcc` legacy alias) to scaffold workspace, run the design dev server, and manage configs.",
   "type": "module",
   "engines": {
@@ -48,13 +48,13 @@
     "test:e2e:desktop:switchrepos": "pnpm --filter @maude/desktop-e2e e2e:switchrepos"
   },
   "optionalDependencies": {
-    "@1agh/maude-darwin-arm64": "0.36.0",
-    "@1agh/maude-darwin-x64": "0.36.0",
-    "@1agh/maude-linux-arm64": "0.36.0",
-    "@1agh/maude-linux-arm64-musl": "0.36.0",
-    "@1agh/maude-linux-x64": "0.36.0",
-    "@1agh/maude-linux-x64-musl": "0.36.0",
-    "@1agh/maude-win32-x64": "0.36.0"
+    "@1agh/maude-darwin-arm64": "0.36.1",
+    "@1agh/maude-darwin-x64": "0.36.1",
+    "@1agh/maude-linux-arm64": "0.36.1",
+    "@1agh/maude-linux-arm64-musl": "0.36.1",
+    "@1agh/maude-linux-x64": "0.36.1",
+    "@1agh/maude-linux-x64-musl": "0.36.1",
+    "@1agh/maude-win32-x64": "0.36.1"
   },
   "files": [
     "cli",