@1agh/maude 0.60.4 → 0.60.6

package/apps/studio/test/hmr-classify.test.ts

@@ -59,7 +59,24 @@ describe('classifyChange', () => {
 
   test('unrelated extensions → null', () => {
     expect(classifyChange('ui/notes.md', noSibling)).toBeNull();
-    expect(classifyChange('assets/logo.svg', noSibling)).toBeNull();
+    expect(classifyChange('assets/photo.png.part', noSibling)).toBeNull();
+    expect(classifyChange('system/x/assets/fonts/Gators-Bold.woff2', noSibling)).toBeNull();
+  });
+
+  test('media files → asset heal signal (2026-08-15 annotations-assets RCA)', () => {
+    // A synced-down media file landing on disk heals still-broken <img>/<image>
+    // elements in open canvases — no reload. Top-level assets/ and DS trees both.
+    for (const f of [
+      'assets/65c3a940.png',
+      'assets/807d7ba7.jpg',
+      'assets/logo.svg',
+      'assets/clip.mp4',
+      'system/alligators/assets/photos-cut/frame-helmet.jpg',
+    ]) {
+      const msg = classifyChange(f, noSibling);
+      expect(msg?.mode).toBe('asset');
+      expect(msg?.file).toBe(f);
+    }
   });
 
   test('backslash paths are normalised before classification', () => {

package/apps/studio/test/input-router.test.ts

@@ -9,6 +9,7 @@ import {
   DRAG_THRESHOLD_PX,
   isArtboardDragChrome,
   isEditableTarget,
+  isOverlayTarget,
   type Tool,
   yieldsClickToArtboardChrome,
   yieldsToArtboardDrag,
@@ -496,6 +497,74 @@ describe('input-router / isArtboardDragChrome', () => {
   });
 });
 
+// issue-90 — once comment mode is armed, a bare click anywhere on the shell's
+// floating chrome (tool palette, zoom pill, minimap, right-click context
+// menu) was claimed as `drop-comment` and dropped a stray pin at the
+// chrome's own coordinates instead of reaching the chrome's own React
+// onClick — the palette became unusable the moment the user picked the
+// Comment tool. `classifyContextKind` (canvas-shell.tsx) already treats
+// these same selectors as non-canvas `'overlay'` chrome; `isOverlayTarget`
+// was the one claim gate that didn't.
+describe('input-router / isOverlayTarget — shell chrome exemptions (issue-90)', () => {
+  // isOverlayTarget makes ONE `closest(a, b, c, ...)` call against the full
+  // comma-joined selector list, unlike isArtboardDragChrome's fakeTarget
+  // above (which mimics one call per bare selector) — so the stub instead
+  // checks whether any of the target's own classes appears among the
+  // selector's comma-separated parts, same as a real `Element.closest` would
+  // resolve for a node carrying that class.
+  const fakeTarget = (memberOf: string[]): EventTarget =>
+    ({
+      closest: (sel: string) => (memberOf.some((cls) => sel.includes(cls)) ? {} : null),
+    }) as unknown as EventTarget;
+
+  test('null target → false', () => {
+    expect(isOverlayTarget(null)).toBe(false);
+  });
+
+  test('a click on the tool palette is exempt', () => {
+    expect(isOverlayTarget(fakeTarget(['.dc-tool-palette']))).toBe(true);
+  });
+
+  test('a click on the zoom toolbar is exempt', () => {
+    expect(isOverlayTarget(fakeTarget(['.dc-zoom-tb']))).toBe(true);
+  });
+
+  test('a click on the minimap is exempt', () => {
+    expect(isOverlayTarget(fakeTarget(['.dc-mm']))).toBe(true);
+  });
+
+  test('a click on the right-click context menu is exempt', () => {
+    expect(isOverlayTarget(fakeTarget(['.dc-context-menu']))).toBe(true);
+  });
+
+  test('a click on ordinary canvas content is NOT exempt', () => {
+    expect(isOverlayTarget(fakeTarget([]))).toBe(false);
+  });
+
+  test('the pre-existing comment-overlay exemptions still hold', () => {
+    expect(isOverlayTarget(fakeTarget(['.cm-composer']))).toBe(true);
+    expect(isOverlayTarget(fakeTarget(['.cm-thread']))).toBe(true);
+    expect(isOverlayTarget(fakeTarget(['.cm-mention-popup']))).toBe(true);
+    expect(isOverlayTarget(fakeTarget(['.cm-pin']))).toBe(true);
+    expect(isOverlayTarget(fakeTarget(['[data-mediaref-player]']))).toBe(true);
+  });
+
+  // Security review finding (issue-90) — `.dc-world` is where the ACTIVE
+  // CANVAS's own untrusted, AI/user-authored JSX renders. None of the real
+  // chrome ever lives there, so an element inside `.dc-world` that ALSO
+  // carries one of these class names is necessarily a same-name imposter —
+  // untrusted canvas content spoofing the shell's own chrome to make the
+  // router yield (skip preventDefault) on it instead of claiming the
+  // gesture. Must be rejected regardless of which chrome class it copies.
+  test('an element inside .dc-world carrying a spoofed chrome class is NOT exempt', () => {
+    expect(isOverlayTarget(fakeTarget(['.dc-world', '.dc-tool-palette']))).toBe(false);
+    expect(isOverlayTarget(fakeTarget(['.dc-world', '.dc-zoom-tb']))).toBe(false);
+    expect(isOverlayTarget(fakeTarget(['.dc-world', '.dc-mm']))).toBe(false);
+    expect(isOverlayTarget(fakeTarget(['.dc-world', '.dc-context-menu']))).toBe(false);
+    expect(isOverlayTarget(fakeTarget(['.dc-world', '.cm-composer']))).toBe(false);
+  });
+});
+
 // issue-71 — the actual regression: before this fix, useInputRouter's
 // pointerdown/mousedown handlers called `stopImmediatePropagation()` on EVERY
 // claimed action, including a bare click on an artboard's own drag chrome —

package/apps/studio/test/mode-toggle.test.tsx

@@ -0,0 +1,226 @@
+// mode-toggle — DDR-223 (issue #93). The preview/edit mode layer over the
+// DDR-187 browse/move tool split: boot posture, the mode⇄tool invariant
+// (arming a resting tool moves the mode; annotation tools are mode-neutral),
+// resetTool, read-only preview boot, and the palette's segmented toggle.
+//
+// Needs a live DOM (context callbacks fired via act) — register happy-dom +
+// drive a createRoot, same convention as browse-posture.test.tsx.
+
+import { afterAll, afterEach, beforeAll, describe, expect, test } from 'bun:test';
+import { GlobalRegistrator } from '@happy-dom/global-registrator';
+
+beforeAll(() => {
+  GlobalRegistrator.register();
+  (globalThis as unknown as { IS_REACT_ACT_ENVIRONMENT?: boolean }).IS_REACT_ACT_ENVIRONMENT = true;
+});
+afterAll(() => {
+  GlobalRegistrator.unregister();
+});
+
+import { act, type ReactNode } from 'react';
+import { createRoot, type Root } from 'react-dom/client';
+import type { Tool } from '../input-router.tsx';
+import { _resetReadOnlyCache } from '../read-only-mode.ts';
+import { ToolPalette } from '../tool-palette.tsx';
+import { type CanvasMode, ToolProvider, useToolMode } from '../use-tool-mode.tsx';
+
+// Capture the live context value so tests can drive setMode/setTool/resetTool
+// directly and assert the resulting (tool, mode) pair.
+let ctx: ReturnType<typeof useToolMode> | null = null;
+function Capture() {
+  ctx = useToolMode();
+  return null;
+}
+
+let root: Root | null = null;
+let host: HTMLElement | null = null;
+
+function mount(ui: ReactNode): void {
+  host = document.createElement('div');
+  document.body.appendChild(host);
+  root = createRoot(host);
+  act(() => {
+    root?.render(ui);
+  });
+}
+
+afterEach(() => {
+  act(() => {
+    root?.unmount();
+  });
+  host?.remove();
+  root = null;
+  host = null;
+  ctx = null;
+  _resetReadOnlyCache();
+  setPageUrl('http://localhost/');
+});
+
+// happy-dom: `history.replaceState` does not update `location.search`; the
+// DetachedWindowAPI `setURL` is the supported seam.
+function setPageUrl(url: string): void {
+  (window as unknown as { happyDOM?: { setURL?: (u: string) => void } }).happyDOM?.setURL?.(url);
+}
+
+const pair = (): { tool: Tool; mode: CanvasMode } => ({
+  tool: ctx?.tool as Tool,
+  mode: ctx?.mode as CanvasMode,
+});
+
+describe('mode-toggle / boot posture (DDR-223)', () => {
+  test('default boot = edit with move armed', () => {
+    mount(
+      <ToolProvider>
+        <Capture />
+      </ToolProvider>
+    );
+    expect(pair()).toEqual({ tool: 'move', mode: 'edit' });
+  });
+
+  test('initial="browse" boots preview (comment-mount specimen posture)', () => {
+    mount(
+      <ToolProvider initial="browse">
+        <Capture />
+      </ToolProvider>
+    );
+    expect(pair()).toEqual({ tool: 'browse', mode: 'preview' });
+  });
+
+  test('read-only (?ro=1) boots preview/browse — the DDR-187 viewer posture', () => {
+    setPageUrl('http://localhost/?ro=1');
+    _resetReadOnlyCache();
+    mount(
+      <ToolProvider>
+        <Capture />
+      </ToolProvider>
+    );
+    expect(pair()).toEqual({ tool: 'browse', mode: 'preview' });
+  });
+});
+
+describe('mode-toggle / mode⇄tool invariant', () => {
+  test('setMode arms the resting tool both ways', () => {
+    mount(
+      <ToolProvider>
+        <Capture />
+      </ToolProvider>
+    );
+    act(() => ctx?.setMode('preview'));
+    expect(pair()).toEqual({ tool: 'browse', mode: 'preview' });
+    act(() => ctx?.setMode('edit'));
+    expect(pair()).toEqual({ tool: 'move', mode: 'edit' });
+  });
+
+  test('arming a resting tool moves the mode (V / tool-set / escape hatch)', () => {
+    mount(
+      <ToolProvider>
+        <Capture />
+      </ToolProvider>
+    );
+    act(() => ctx?.setTool('browse'));
+    expect(pair()).toEqual({ tool: 'browse', mode: 'preview' });
+    // The Cmd+click-in-browse escape hatch is a plain setTool('move') at its
+    // call site — the invariant is what turns it into a coherent mode flip.
+    act(() => ctx?.setTool('move'));
+    expect(pair()).toEqual({ tool: 'move', mode: 'edit' });
+  });
+
+  test('annotation tools are mode-neutral — pen in preview stays preview', () => {
+    mount(
+      <ToolProvider initial="browse">
+        <Capture />
+      </ToolProvider>
+    );
+    act(() => ctx?.setTool('pen'));
+    expect(pair()).toEqual({ tool: 'pen', mode: 'preview' });
+    act(() => ctx?.setTool('comment'));
+    expect(pair()).toEqual({ tool: 'comment', mode: 'preview' });
+  });
+
+  test('resetTool arms the CURRENT mode’s resting tool', () => {
+    mount(
+      <ToolProvider initial="browse">
+        <Capture />
+      </ToolProvider>
+    );
+    // Preview: drawing an annotation then resetting returns to browse (the
+    // alive posture) — never to move.
+    act(() => ctx?.setTool('pen'));
+    act(() => ctx?.resetTool());
+    expect(pair()).toEqual({ tool: 'browse', mode: 'preview' });
+    // Edit: byte-identical to the pre-DDR-223 hardcoded setTool('move').
+    act(() => ctx?.setMode('edit'));
+    act(() => ctx?.setTool('pen'));
+    act(() => ctx?.resetTool());
+    expect(pair()).toEqual({ tool: 'move', mode: 'edit' });
+  });
+});
+
+describe('mode-toggle / palette segmented toggle', () => {
+  const mountPalette = () =>
+    mount(
+      <ToolProvider>
+        <Capture />
+        <ToolPalette />
+      </ToolProvider>
+    );
+  const seg = (which: 'preview' | 'edit' | 'present'): HTMLButtonElement | null =>
+    document.querySelector(`[data-testid="palette-mode-${which}"]`);
+
+  test('renders three icon segments; Edit is pressed on boot; no browse/move tool buttons', () => {
+    mountPalette();
+    expect(seg('preview')).not.toBeNull();
+    expect(seg('edit')?.getAttribute('aria-pressed')).toBe('true');
+    expect(seg('preview')?.getAttribute('aria-pressed')).toBe('false');
+    // Owner steer 2026-08-15 — icon-only segments (lucide eye / pencil-ruler /
+    // presentation); the words live in aria-label/title.
+    expect(seg('preview')?.querySelector('svg')).not.toBeNull();
+    expect(seg('edit')?.querySelector('svg')).not.toBeNull();
+    expect(seg('present')?.querySelector('svg')).not.toBeNull();
+    // The segments ARE the resting-tool affordances — no separate Select /
+    // Browse buttons in the nav group.
+    expect(document.querySelector('[aria-label^="Select (V)"]')).toBeNull();
+    expect(document.querySelector('[aria-label^="Browse ("]')).toBeNull();
+    // Present moved INTO the toggle — exactly one presentation affordance, and
+    // it is the segment (the palette's right-end button is gone).
+    const present = document.querySelectorAll('[aria-label^="Presentation mode"]');
+    expect(present.length).toBe(1);
+    expect(present[0]).toBe(seg('present') as Element);
+    expect(seg('present')?.getAttribute('aria-pressed')).toBe('false');
+  });
+
+  test('clicking Preview flips the posture; insert (+) is edit-only', () => {
+    mountPalette();
+    expect(
+      document.querySelector('[aria-label="Insert element — Div, Text, or Image"]')
+    ).not.toBeNull();
+    act(() => {
+      seg('preview')?.click();
+    });
+    expect(pair()).toEqual({ tool: 'browse', mode: 'preview' });
+    expect(seg('preview')?.getAttribute('aria-pressed')).toBe('true');
+    expect(
+      document.querySelector('[aria-label="Insert element — Div, Text, or Image"]')
+    ).toBeNull();
+    // Draw tools stay available in preview (issue #93: annotations in preview).
+    expect(document.querySelector('[aria-label^="Pen (B)"]')).not.toBeNull();
+    // And the Edit segment arms move again.
+    act(() => {
+      seg('edit')?.click();
+    });
+    expect(pair()).toEqual({ tool: 'move', mode: 'edit' });
+  });
+
+  test('clicking the ACTIVE segment re-arms the resting tool', () => {
+    mountPalette();
+    act(() => {
+      seg('preview')?.click();
+    });
+    act(() => ctx?.setTool('pen'));
+    expect(pair()).toEqual({ tool: 'pen', mode: 'preview' });
+    act(() => {
+      seg('preview')?.click();
+    });
+    expect(pair()).toEqual({ tool: 'browse', mode: 'preview' });
+  });
+});

package/apps/studio/test/sync-annotations-cold-start.test.ts

@@ -0,0 +1,302 @@
+// Per-lane annotations cold start — the 2026-08-14 annotations eraser.
+//
+// The eraser: annotations used to follow the BODY winner at cold start, and
+// the emptiness guard was `!== ''` — so a hub doc holding the bare 72-byte
+// wrapper (`<svg …></svg>`, a non-empty STRING carrying zero strokes)
+// overwrote a peer's real strokes whenever the hub won the body, taking the
+// `assets/<sha8>` references the asset pull scans with them. Confirmed on
+// alligators: a sidecar committed with two `<image>` strokes at 12:45 was the
+// empty wrapper on every peer two minutes after the next fleet roll.
+//
+// The fix has three parts, each pinned here:
+//   1. `isEmptyAnnotationsSvg` — the wrapper counts as empty.
+//   2. `decideAnnotationsColdStart` — per-lane table; unstamped emptiness
+//      never beats content, stamped delete-all is honored by time.
+//   3. `stampAnnotationsEdit` riding every local→doc annotations apply
+//      (applyFromFs, cold-start seed, adopt) in the same transaction.
+
+import { afterEach, beforeEach, describe, expect, test } from 'bun:test';
+import { mkdtempSync, readFileSync, rmSync, utimesSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import * as Y from 'yjs';
+
+import { type CanvasSyncAgent, createCanvasSyncAgent } from '../sync/agent.ts';
+import {
+  annotationsEditAtFromDoc,
+  annotationsFromDoc,
+  applyHtmlToDoc,
+  isEmptyAnnotationsSvg,
+  stampAnnotationsEdit,
+} from '../sync/codec.ts';
+import { type AnnotationsColdStartInput, decideAnnotationsColdStart } from '../sync/cold-start.ts';
+import { createEchoGuard, hashBytes } from '../sync/echo-guard.ts';
+import { migrateSeed } from '../sync/migrate-seed.ts';
+
+/** The exact serialization `strokesToSvg([])` emits — the eraser's payload. */
+const EMPTY_WRAPPER = '<svg xmlns="http://www.w3.org/2000/svg" data-mdcc-annotations="1"></svg>';
+const STROKES =
+  '<svg xmlns="http://www.w3.org/2000/svg" data-mdcc-annotations="1"><image data-id="s_1" data-tool="image" x="0" y="0" width="160" height="160" href="assets/0327a8e5.png"/></svg>';
+const STROKES_B =
+  '<svg xmlns="http://www.w3.org/2000/svg" data-mdcc-annotations="1"><rect data-id="s_2" x="1" y="1" width="10" height="10"/></svg>';
+
+/* ------------------------------------------------- isEmptyAnnotationsSvg */
+
+describe('isEmptyAnnotationsSvg', () => {
+  test('null / empty / whitespace are empty', () => {
+    expect(isEmptyAnnotationsSvg(null)).toBe(true);
+    expect(isEmptyAnnotationsSvg('')).toBe(true);
+    expect(isEmptyAnnotationsSvg('  \n\t ')).toBe(true);
+  });
+
+  test('the bare wrapper is empty — the eraser regression pin', () => {
+    expect(isEmptyAnnotationsSvg(EMPTY_WRAPPER)).toBe(true);
+  });
+
+  test('wrapper with surrounding whitespace is empty', () => {
+    expect(isEmptyAnnotationsSvg(`  ${EMPTY_WRAPPER}\n`)).toBe(true);
+  });
+
+  test('a single stroke is NOT empty', () => {
+    expect(isEmptyAnnotationsSvg(STROKES)).toBe(false);
+  });
+});
+
+/* ------------------------------------------- decideAnnotationsColdStart */
+
+function input(over: Partial<AnnotationsColdStartInput>): AnnotationsColdStartInput {
+  return {
+    local: null,
+    doc: '',
+    isEmpty: isEmptyAnnotationsSvg,
+    localMtimeMs: null,
+    docEditAtMs: null,
+    bodyWinner: 'hub',
+    ...over,
+  };
+}
+
+describe('decideAnnotationsColdStart — emptiness vs content', () => {
+  test('both empty → none', () => {
+    expect(decideAnnotationsColdStart(input({})).winner).toBe('none');
+    expect(
+      decideAnnotationsColdStart(input({ local: EMPTY_WRAPPER, doc: EMPTY_WRAPPER })).winner
+    ).toBe('none');
+  });
+
+  test('THE ERASER: unstamped hub wrapper + local strokes + hub body winner → local', () => {
+    const d = decideAnnotationsColdStart(
+      input({ local: STROKES, doc: EMPTY_WRAPPER, localMtimeMs: 1000, bodyWinner: 'hub' })
+    );
+    expect(d.winner).toBe('local');
+  });
+
+  test('unset hub lane + local strokes → local (seed up), even with hub body winner', () => {
+    const d = decideAnnotationsColdStart(
+      input({ local: STROKES, doc: '', localMtimeMs: 1000, bodyWinner: 'hub' })
+    );
+    expect(d.winner).toBe('local');
+  });
+
+  test('STAMPED hub delete-all newer than local strokes → hub (deletes are honored)', () => {
+    const d = decideAnnotationsColdStart(
+      input({ local: STROKES, doc: EMPTY_WRAPPER, localMtimeMs: 1000, docEditAtMs: 2000 })
+    );
+    expect(d.winner).toBe('hub');
+  });
+
+  test('stamped hub delete-all OLDER than local strokes → local', () => {
+    const d = decideAnnotationsColdStart(
+      input({ local: STROKES, doc: EMPTY_WRAPPER, localMtimeMs: 2000, docEditAtMs: 1000 })
+    );
+    expect(d.winner).toBe('local');
+  });
+
+  test('local absent + hub strokes → hub (clean first sync materializes)', () => {
+    const d = decideAnnotationsColdStart(input({ doc: STROKES }));
+    expect(d.winner).toBe('hub');
+  });
+
+  test('local delete-all (wrapper on disk) newer than hub stamp → local', () => {
+    const d = decideAnnotationsColdStart(
+      input({ local: EMPTY_WRAPPER, doc: STROKES, localMtimeMs: 2000, docEditAtMs: 1000 })
+    );
+    expect(d.winner).toBe('local');
+  });
+
+  test('local wrapper with no doc stamp → hub (unstamped local emptiness loses too)', () => {
+    const d = decideAnnotationsColdStart(
+      input({ local: EMPTY_WRAPPER, doc: STROKES, localMtimeMs: 2000 })
+    );
+    expect(d.winner).toBe('hub');
+  });
+});
+
+describe('decideAnnotationsColdStart — both non-empty', () => {
+  test('equal content → none', () => {
+    const d = decideAnnotationsColdStart(input({ local: STROKES, doc: STROKES }));
+    expect(d.winner).toBe('none');
+  });
+
+  test('newest wins by per-lane stamp: local newer → local', () => {
+    const d = decideAnnotationsColdStart(
+      input({ local: STROKES, doc: STROKES_B, localMtimeMs: 2000, docEditAtMs: 1000 })
+    );
+    expect(d.winner).toBe('local');
+  });
+
+  test('newest wins by per-lane stamp: doc newer → hub', () => {
+    const d = decideAnnotationsColdStart(
+      input({ local: STROKES, doc: STROKES_B, localMtimeMs: 1000, docEditAtMs: 2000 })
+    );
+    expect(d.winner).toBe('hub');
+  });
+
+  test('no per-lane stamp → follows the body winner (legacy coupling)', () => {
+    expect(
+      decideAnnotationsColdStart(
+        input({ local: STROKES, doc: STROKES_B, localMtimeMs: 1000, bodyWinner: 'local' })
+      ).winner
+    ).toBe('local');
+    expect(
+      decideAnnotationsColdStart(
+        input({ local: STROKES, doc: STROKES_B, localMtimeMs: 1000, bodyWinner: 'hub' })
+      ).winner
+    ).toBe('hub');
+  });
+});
+
+/* ------------------------------------------------------- codec round-trip */
+
+describe('stampAnnotationsEdit / annotationsEditAtFromDoc', () => {
+  test('round-trips; absent stamp reads null', () => {
+    const doc = new Y.Doc();
+    expect(annotationsEditAtFromDoc(doc)).toBe(null);
+    stampAnnotationsEdit(doc, undefined, 12345);
+    expect(annotationsEditAtFromDoc(doc)).toBe(12345);
+  });
+});
+
+/* ------------------------------------------------------ agent integration */
+
+let dir: string;
+let agent: CanvasSyncAgent;
+let docA: Y.Doc;
+let docB: Y.Doc;
+
+function paths() {
+  return {
+    html: join(dir, 'screen.html'),
+    comments: join(dir, '_comments', 'screen.json'),
+    annotations: join(dir, 'screen.annotations.svg'),
+  };
+}
+
+beforeEach(() => {
+  dir = mkdtempSync(join(tmpdir(), 'sync-ann-cold-'));
+  docA = new Y.Doc();
+  docB = new Y.Doc();
+  const TRANSPORT = Symbol('transport');
+  docA.on('update', (update: Uint8Array, origin: unknown) => {
+    if (origin === TRANSPORT) return;
+    Y.applyUpdate(docB, update, TRANSPORT);
+  });
+  docB.on('update', (update: Uint8Array, origin: unknown) => {
+    if (origin === TRANSPORT) return;
+    Y.applyUpdate(docA, update, TRANSPORT);
+  });
+});
+
+afterEach(() => {
+  agent?.stop();
+  rmSync(dir, { recursive: true, force: true });
+});
+
+function makeAgent(): CanvasSyncAgent {
+  const a = createCanvasSyncAgent({
+    slug: 'screen',
+    doc: docB,
+    paths: paths(),
+    echoGuard: createEchoGuard(),
+    flushMs: 0,
+  });
+  a.start();
+  return a;
+}
+
+describe('cold start — the eraser scenario end to end', () => {
+  test('unstamped hub wrapper does NOT erase local strokes; local seeds up + stamps', async () => {
+    // Hub holds the stale empty wrapper (what the eraser propagated) with no
+    // per-lane stamp — the exact pre-fix state of every wiped canvas.
+    docA.getMap('annotations').set('svg', EMPTY_WRAPPER);
+    // Local disk holds real strokes with an image reference.
+    writeFileSync(paths().annotations, STROKES);
+
+    agent = makeAgent();
+    await agent.reconcile();
+
+    // Disk keeps the strokes; the doc now carries them, stamped.
+    expect(readFileSync(paths().annotations, 'utf8')).toBe(STROKES);
+    expect(annotationsFromDoc(docB)).toBe(STROKES);
+    expect(annotationsFromDoc(docA)).toBe(STROKES); // propagated to the hub side
+    expect(annotationsEditAtFromDoc(docB)).not.toBe(null);
+  });
+
+  test('stamped hub delete-all newer than local strokes IS honored on disk', async () => {
+    writeFileSync(paths().annotations, STROKES);
+    // Backdate the local file so the hub's delete-all stamp is provably newer.
+    const past = new Date(Date.now() - 60_000);
+    utimesSync(paths().annotations, past, past);
+    docA.transact(() => {
+      docA.getMap('annotations').set('svg', EMPTY_WRAPPER);
+    });
+    stampAnnotationsEdit(docA, undefined, Date.now());
+
+    agent = makeAgent();
+    await agent.reconcile();
+
+    expect(readFileSync(paths().annotations, 'utf8')).toBe(EMPTY_WRAPPER);
+  });
+
+  test('clean first sync still materializes hub strokes to disk', async () => {
+    docA.getMap('annotations').set('svg', STROKES);
+
+    agent = makeAgent();
+    await agent.reconcile();
+
+    expect(readFileSync(paths().annotations, 'utf8')).toBe(STROKES);
+  });
+
+  test('SHARED-DOC eraser: migrateSeed rescues local strokes from an unstamped hub wrapper', async () => {
+    // The cell-side copy of the eraser: hub doc has a newer body (so the body
+    // resolution keeps the hub) and a stale unstamped wrapper in the
+    // annotations lane; local disk has real strokes.
+    const doc = new Y.Doc();
+    applyHtmlToDoc(doc, '<main>hub body</main>');
+    doc.getMap('annotations').set('svg', EMPTY_WRAPPER);
+    writeFileSync(paths().html, '<main>hub body</main>'); // body identical → noop path
+    writeFileSync(paths().annotations, STROKES);
+
+    await migrateSeed({ slug: 'screen', doc, paths: paths() });
+
+    // The doc now carries the local strokes, stamped — so the collab room's
+    // persistJson materializes strokes, not the wrapper.
+    expect(annotationsFromDoc(doc)).toBe(STROKES);
+    expect(annotationsEditAtFromDoc(doc)).not.toBe(null);
+  });
+
+  test('applyFromFs stamps annotationsEditAt in the same update', () => {
+    agent = makeAgent();
+    const bytes = new TextEncoder().encode(STROKES);
+    const changed = agent.applyFromFs({
+      path: paths().annotations,
+      bytes,
+      hash: hashBytes(STROKES),
+    });
+    expect(changed).toBe(true);
+    expect(annotationsFromDoc(docB)).toBe(STROKES);
+    expect(annotationsEditAtFromDoc(docB)).not.toBe(null);
+    // The stamp crossed to the other peer with the same update.
+    expect(annotationsEditAtFromDoc(docA)).not.toBe(null);
+  });
+});