@1agh/maude 0.19.1 → 0.21.0

package/plugins/design/dev-server/server.ts

@@ -18,12 +18,15 @@ import { spawn } from 'node:child_process';
 
 import { createApi } from './api.ts';
 import { bootSelfHeal } from './boot-self-heal.ts';
+import { createAiActivity } from './collab/ai-activity.ts';
+import { createGitLifecycle } from './collab/git-lifecycle.ts';
+import { createCollab } from './collab/index.ts';
 import { createContext } from './context.ts';
 import { createFsWatch } from './fs-watch.ts';
 import { createHttp } from './http.ts';
 import { createInspect } from './inspect.ts';
 import { startHeapWatch } from './mem.ts';
-import { createWs } from './ws.ts';
+import { type WsData, createWs, isLoopbackHost, parseCollabSlug } from './ws.ts';
 
 // Phase 19 / DDR-044 — covers the marketplace-cache-install gap where
 // node_modules/ ships empty (git clone honors .gitignore). Auto-installs +
@@ -32,17 +35,41 @@ await bootSelfHeal();
 
 const ctx = createContext();
 
-const api = createApi(ctx, async (file) => {
-  // After every comments mutation, re-broadcast the updated list.
-  const comments = await api.loadCommentsForFile(file);
-  ctx.bus.emit('comments', { file, comments });
+// Forward-declared so the api.commentsAdd/patch/delete/addReply callback can
+// reach into the collab registry (Phase 8 Task 3 bridge). collab is initialized
+// synchronously below; the callback only fires at runtime, by which point the
+// binding is set.
+let collab: ReturnType<typeof createCollab> | null = null;
+
+const api = createApi(ctx, {
+  onCommentsChanged: async (file) => {
+    // After every comments mutation, re-broadcast the updated list.
+    const comments = await api.loadCommentsForFile(file);
+    ctx.bus.emit('comments', { file, comments });
+    // Phase 8 Task 3 — bridge into the live Y.Array so collab peers see the
+    // change without waiting for cold-open re-seeding. No-op when no room is
+    // live for this canvas slug.
+    if (collab) {
+      collab.registry.syncRoomFromComments(api.fileSlug(file), comments);
+    }
+  },
+  // Phase 8 Task 5 — same bridge for annotations. PUT /_api/annotations writes
+  // the SVG blob to disk; we mirror it into the live Y.Map for collab peers.
+  onAnnotationsChanged: (file, svg) => {
+    if (collab) {
+      collab.registry.syncRoomFromAnnotations(api.fileSlug(file), svg);
+    }
+  },
 });
 
 const inspect = createInspect(ctx, (file) => api.loadCommentsForFile(file));
 await inspect.load();
 
-const ws = createWs(ctx, api, inspect);
-const http = createHttp(ctx, api, inspect);
+collab = createCollab(ctx, api);
+const aiActivity = createAiActivity(ctx);
+const gitLifecycle = createGitLifecycle(ctx, collab.registry);
+const ws = createWs(ctx, api, inspect, collab);
+const http = createHttp(ctx, api, inspect, aiActivity);
 const fsWatch = createFsWatch(ctx);
 
 // Port: --port arg > $PORT > $MDCC_DEV_PORT > 4399.
@@ -59,21 +86,46 @@ function resolvePort(): { port: number; explicit: boolean } {
 
 const { port: BASE_PORT, explicit: PORT_EXPLICIT } = resolvePort();
 
-type BunServer = ReturnType<typeof Bun.serve<{ id: string; remote: string }, never>>;
+type BunServer = ReturnType<typeof Bun.serve<WsData, never>>;
 
 function startServer(port: number): BunServer {
-  return Bun.serve<{ id: string; remote: string }, never>({
+  return Bun.serve<WsData, never>({
     port,
     hostname: '127.0.0.1',
     development: process.env.NODE_ENV !== 'production',
     routes: http.routes,
     async fetch(req, srv) {
-      // WebSocket upgrade.
-      if (new URL(req.url).pathname.startsWith('/_ws')) {
+      const pathname = new URL(req.url).pathname;
+
+      // Phase 8 — collab WS, binary y-websocket protocol. Loopback-only;
+      // DDR-047 makes cross-machine collab a Phase 9 hub-deploy story, not
+      // a `--bind 0.0.0.0` flag on this server.
+      const collabSlug = parseCollabSlug(pathname);
+      if (collabSlug !== null) {
+        if (!isLoopbackHost(req.headers.get('host'))) {
+          return new Response('cross-machine collab requires Phase 9 hub deploy', {
+            status: 403,
+          });
+        }
         const ok = srv.upgrade(req, {
           data: {
             id: crypto.randomUUID(),
             remote: req.headers.get('x-forwarded-for') ?? '127.0.0.1',
+            kind: 'collab',
+            slug: collabSlug,
+          },
+        });
+        if (ok) return undefined as unknown as Response;
+        return new Response('Upgrade failed', { status: 400 });
+      }
+
+      // Legacy inspector WS — JSON frames, designer-facing live tab state.
+      if (pathname.startsWith('/_ws')) {
+        const ok = srv.upgrade(req, {
+          data: {
+            id: crypto.randomUUID(),
+            remote: req.headers.get('x-forwarded-for') ?? '127.0.0.1',
+            kind: 'inspector',
           },
         });
         if (ok) return undefined as unknown as Response;
@@ -167,6 +219,21 @@ if (!process.env.NO_OPEN) {
 async function shutdown() {
   console.log('\n  Stopping…');
   fsWatch.stop();
+  try {
+    if (collab) await collab.registry.destroyAll();
+  } catch {
+    /* best-effort flush; the JSON snapshot is the ground truth anyway */
+  }
+  try {
+    aiActivity.stop();
+  } catch {
+    /* janitor cleanup is best-effort */
+  }
+  try {
+    gitLifecycle.stop();
+  } catch {
+    /* watcher cleanup is best-effort */
+  }
   try {
     await Bun.write(ctx.paths.serverInfoFile, '').catch(() => {});
     // Remove the file by writing empty then unlinking.

package/plugins/design/dev-server/test/ai-activity.test.ts

@@ -0,0 +1,113 @@
+// Unit: AI activity tracker (Phase 8 Task 4).
+
+import { describe, expect, test } from 'bun:test';
+
+import { HEARTBEAT_GRACE_MS, createAiActivity } from '../collab/ai-activity.ts';
+import { type Context, createBus } from '../context.ts';
+
+function makeCtx(): { ctx: Context; events: { file: string; entry: unknown }[] } {
+  const events: { file: string; entry: unknown }[] = [];
+  const bus = createBus();
+  bus.on('ai-activity', (p: { file: string; entry: unknown }) => events.push(p));
+  const ctx = {
+    cfg: {} as Context['cfg'],
+    projectLabel: 'test',
+    paths: {} as Context['paths'],
+    bus,
+  };
+  return { ctx, events };
+}
+
+describe('AiActivity', () => {
+  test('start adds an entry and emits bus event', () => {
+    const { ctx, events } = makeCtx();
+    const clock = 1000;
+    const ai = createAiActivity(ctx, () => clock);
+    const entry = ai.start('ui/Foo.tsx', 'Claude');
+    expect(entry.file).toBe('ui/Foo.tsx');
+    expect(entry.author).toBe('Claude');
+    expect(entry.startedAt).toBe(1000);
+    expect(entry.lastHeartbeat).toBe(1000);
+    expect(events).toHaveLength(1);
+    expect(events[0]?.entry).toBe(entry);
+    ai.stop();
+  });
+
+  test('start preserves startedAt across restart for the same file', () => {
+    const { ctx } = makeCtx();
+    let clock = 1000;
+    const ai = createAiActivity(ctx, () => clock);
+    ai.start('ui/Foo.tsx', 'Claude');
+    clock = 5000;
+    const restarted = ai.start('ui/Foo.tsx', 'Claude');
+    expect(restarted.startedAt).toBe(1000);
+    expect(restarted.lastHeartbeat).toBe(5000);
+    ai.stop();
+  });
+
+  test('heartbeat refreshes lastHeartbeat + emits', () => {
+    const { ctx, events } = makeCtx();
+    let clock = 1000;
+    const ai = createAiActivity(ctx, () => clock);
+    ai.start('ui/Foo.tsx', 'Claude');
+    clock = 2000;
+    const refreshed = ai.heartbeat('ui/Foo.tsx');
+    expect(refreshed?.lastHeartbeat).toBe(2000);
+    expect(refreshed?.startedAt).toBe(1000);
+    // Two bus events — one for start, one for heartbeat.
+    expect(events.length).toBe(2);
+    ai.stop();
+  });
+
+  test('heartbeat returns null when no entry exists', () => {
+    const { ctx } = makeCtx();
+    const ai = createAiActivity(ctx);
+    expect(ai.heartbeat('ui/Absent.tsx')).toBeNull();
+    ai.stop();
+  });
+
+  test('end clears the entry and emits a null', () => {
+    const { ctx, events } = makeCtx();
+    const clock = 1000;
+    const ai = createAiActivity(ctx, () => clock);
+    ai.start('ui/Foo.tsx', 'Claude');
+    const ok = ai.end('ui/Foo.tsx');
+    expect(ok).toBe(true);
+    expect(ai.get('ui/Foo.tsx')).toBeNull();
+    const last = events.at(-1);
+    expect(last?.entry).toBeNull();
+    ai.stop();
+  });
+
+  test('end on absent entry returns false (no emit)', () => {
+    const { ctx, events } = makeCtx();
+    const ai = createAiActivity(ctx);
+    expect(ai.end('ui/Absent.tsx')).toBe(false);
+    expect(events.length).toBe(0);
+    ai.stop();
+  });
+
+  test('list returns all live entries', () => {
+    const { ctx } = makeCtx();
+    const clock = 1000;
+    const ai = createAiActivity(ctx, () => clock);
+    ai.start('ui/Foo.tsx', 'Claude');
+    ai.start('ui/Bar.tsx', 'Claude');
+    expect(ai.list().length).toBe(2);
+    ai.end('ui/Foo.tsx');
+    expect(ai.list().length).toBe(1);
+    ai.stop();
+  });
+
+  test('grace period — entry stays inside HEARTBEAT_GRACE_MS', () => {
+    const { ctx } = makeCtx();
+    let clock = 1000;
+    const ai = createAiActivity(ctx, () => clock);
+    ai.start('ui/Foo.tsx', 'Claude');
+    // 29 s later — still within grace.
+    clock = 1000 + HEARTBEAT_GRACE_MS - 1000;
+    // We don't auto-tick the janitor in tests; just confirm entry still exists.
+    expect(ai.get('ui/Foo.tsx')).not.toBeNull();
+    ai.stop();
+  });
+});

package/plugins/design/dev-server/test/annotation-strokes-command.test.ts

@@ -0,0 +1,149 @@
+import { describe, expect, mock, test } from 'bun:test';
+
+import type { PenStroke, RectStroke, Stroke } from '../annotations-layer.tsx';
+import { createAnnotationStrokesCommand } from '../commands/annotation-strokes-command.ts';
+
+const pen1: PenStroke = {
+  id: 'pen-1',
+  tool: 'pen',
+  color: '#000',
+  width: 2,
+  points: [
+    [0, 0],
+    [10, 10],
+  ],
+};
+
+const pen2: PenStroke = {
+  id: 'pen-2',
+  tool: 'pen',
+  color: '#f00',
+  width: 4,
+  points: [[20, 20]],
+};
+
+const rect1: RectStroke = {
+  id: 'rect-1',
+  tool: 'rect',
+  color: '#000',
+  width: 2,
+  x: 0,
+  y: 0,
+  w: 50,
+  h: 30,
+  fill: null,
+};
+
+describe('createAnnotationStrokesCommand', () => {
+  test('do() PUTs the AFTER set', async () => {
+    const putFn = mock(() => Promise.resolve());
+    const cmd = createAnnotationStrokesCommand({
+      before: [],
+      after: [pen1],
+      putFn,
+    });
+    await cmd.do();
+    expect(putFn).toHaveBeenCalledTimes(1);
+    expect(putFn.mock.calls[0]?.[0]).toEqual([pen1]);
+  });
+
+  test('undo() PUTs the BEFORE set', async () => {
+    const putFn = mock(() => Promise.resolve());
+    const cmd = createAnnotationStrokesCommand({
+      before: [pen1],
+      after: [pen1, pen2],
+      putFn,
+    });
+    await cmd.undo();
+    expect(putFn).toHaveBeenCalledTimes(1);
+    expect(putFn.mock.calls[0]?.[0]).toEqual([pen1]);
+  });
+
+  test('round-trip — add stroke then undo restores empty', async () => {
+    const calls: Stroke[][] = [];
+    const putFn: (next: readonly Stroke[]) => Promise<void> = (next) => {
+      calls.push([...next]);
+      return Promise.resolve();
+    };
+    const cmd = createAnnotationStrokesCommand({
+      before: [],
+      after: [pen1],
+      putFn,
+    });
+    await cmd.do();
+    await cmd.undo();
+    await cmd.do(); // redo
+    expect(calls).toEqual([[pen1], [], [pen1]]);
+  });
+
+  test('eraser path — before has stroke, after is empty', async () => {
+    const putFn = mock(() => Promise.resolve());
+    const cmd = createAnnotationStrokesCommand({
+      before: [pen1],
+      after: [],
+      putFn,
+    });
+    expect(cmd.label).toBe('erase 1 stroke');
+    await cmd.do();
+    expect(putFn.mock.calls[0]?.[0]).toEqual([]);
+    await cmd.undo();
+    expect(putFn.mock.calls[1]?.[0]).toEqual([pen1]);
+  });
+
+  test('default label — add 2 strokes', () => {
+    const cmd = createAnnotationStrokesCommand({
+      before: [pen1],
+      after: [pen1, pen2, rect1],
+      putFn: () => {},
+    });
+    expect(cmd.label).toBe('add 2 strokes');
+  });
+
+  test('default label — same-count edit', () => {
+    const cmd = createAnnotationStrokesCommand({
+      before: [pen1],
+      after: [{ ...pen1, color: '#f00' }],
+      putFn: () => {},
+    });
+    expect(cmd.label).toBe('edit 1 stroke');
+  });
+
+  test('snapshots are deep-cloned — mutating source after construction does not poison', async () => {
+    // Use locally-owned strokes so the test's mutation only affects the
+    // source arrays, never the module-scope `pen1`/`pen2` shared with other
+    // tests.
+    const localPen: PenStroke = {
+      id: 'local',
+      tool: 'pen',
+      color: '#000',
+      width: 1,
+      points: [
+        [1, 1],
+        [2, 2],
+      ],
+    };
+    const localPenAfter: PenStroke = {
+      id: 'local-after',
+      tool: 'pen',
+      color: '#111',
+      width: 1,
+      points: [[3, 3]],
+    };
+    const sourceBefore: Stroke[] = [localPen];
+    const sourceAfter: Stroke[] = [localPen, localPenAfter];
+    const putFn = mock(() => Promise.resolve());
+    const cmd = createAnnotationStrokesCommand({
+      before: sourceBefore,
+      after: sourceAfter,
+      putFn,
+    });
+    // Mutate source arrays after construction — replace entries entirely so
+    // we don't reach through into shared sub-arrays.
+    sourceAfter[0] = { ...localPen, color: '#POISONED' };
+    sourceBefore.length = 0;
+    await cmd.do();
+    expect(putFn.mock.calls[0]?.[0]).toEqual([localPen, localPenAfter]);
+    await cmd.undo();
+    expect(putFn.mock.calls[1]?.[0]).toEqual([localPen]);
+  });
+});

package/plugins/design/dev-server/test/annotations-layer.test.ts

@@ -20,6 +20,7 @@ import {
   penPathD,
   rid,
   strokeHitTest,
+  strokesShallowEqual,
   strokesToSvg,
 } from '../annotations-layer.tsx';
 
@@ -417,3 +418,46 @@ describe('annotations-layer / strokes round-trip is stable for arrays', () => {
     expect(strokesToSvg(sample)).toBe(strokesToSvg(sample));
   });
 });
+
+describe('annotations-layer / strokesShallowEqual (drag no-op gate)', () => {
+  const pen: PenStroke = {
+    id: 'p',
+    tool: 'pen',
+    color: '#000',
+    width: 2,
+    points: [[0, 0]],
+  };
+  const rect: RectStroke = {
+    id: 'r',
+    tool: 'rect',
+    color: '#000',
+    width: 2,
+    x: 0,
+    y: 0,
+    w: 10,
+    h: 10,
+    fill: null,
+  };
+
+  test('same reference → true', () => {
+    const arr = [pen, rect];
+    expect(strokesShallowEqual(arr, arr)).toBe(true);
+  });
+
+  test('different references but same entries (same order) → true', () => {
+    expect(strokesShallowEqual([pen, rect], [pen, rect])).toBe(true);
+  });
+
+  test('different entry reference at any slot → false', () => {
+    const penClone: PenStroke = { ...pen };
+    expect(strokesShallowEqual([pen, rect], [penClone, rect])).toBe(false);
+  });
+
+  test('different length → false', () => {
+    expect(strokesShallowEqual([pen], [pen, rect])).toBe(false);
+  });
+
+  test('empty arrays → true', () => {
+    expect(strokesShallowEqual([], [])).toBe(true);
+  });
+});

package/plugins/design/dev-server/test/canvas-lib-motion.test.ts

@@ -0,0 +1,131 @@
+// canvas-lib-motion — Phase 3.7 Task 14 / DDR-049.
+//
+// Pure-logic + AST tests for the canvas-lib motion helpers. The full DOM
+// path (MotionDemo render, useMotionTokens MutationObserver, ReducedMotionToggle
+// click) belongs to the agent-browser smoke step — bun:test runs in a
+// non-DOM environment, so we exercise (a) the role config table shape, (b)
+// easingFromToken's pure mapping, (c) the canvas-lib export surface (the
+// motion helpers must be exported by name so handoff inlining can resolve
+// them), (d) the canvas-lib-inline pass A walk picking up motion helpers
+// transitively.
+
+import { describe, expect, test } from 'bun:test';
+
+import { buildLibMap, inlineUsedExports } from '../canvas-lib-inline.ts';
+import { canvasLibPath } from '../canvas-lib-resolver.ts';
+
+const PROJECT_DESIGN_ROOT = `${process.cwd()}/.design`;
+
+describe('canvas-lib motion exports', () => {
+  test('motion helpers exported by name', async () => {
+    const libPath = canvasLibPath(PROJECT_DESIGN_ROOT);
+    const libSource = await Bun.file(libPath).text();
+    const map = buildLibMap(libPath, libSource);
+    for (const name of [
+      'MotionDemo',
+      'MotionTrack',
+      'TokenPlayback',
+      'ReducedMotionToggle',
+      'useMotionTokens',
+      'easingFromToken',
+    ]) {
+      expect(map.has(name), `expected '${name}' to be a top-level export`).toBe(true);
+    }
+  });
+
+  test('motion helpers are re-exported under canonical names', async () => {
+    // The lib aliases motion/react primitives to _motionImpl / _useReducedMotion /
+    // _MotionAnimatePresence but re-exports them as `motion`, `useReducedMotion`,
+    // `AnimatePresence`. Handoff inlining relies on the canonical names being in
+    // the libMap (so a canvas importing `useReducedMotion` from @maude/canvas-lib
+    // resolves correctly).
+    const libPath = canvasLibPath(PROJECT_DESIGN_ROOT);
+    const libSource = await Bun.file(libPath).text();
+    expect(libSource).toContain("from 'motion/react'");
+    expect(libSource).toMatch(/_motionImpl\s+as\s+motion/);
+    expect(libSource).toMatch(/_useReducedMotion\s+as\s+useReducedMotion/);
+    expect(libSource).toMatch(/_MotionAnimatePresence\s+as\s+AnimatePresence/);
+  });
+});
+
+describe('canvas-lib motion inline (handoff path)', () => {
+  test('inlining MotionDemo carries transitive deps', async () => {
+    const libPath = canvasLibPath(PROJECT_DESIGN_ROOT);
+    const libSource = await Bun.file(libPath).text();
+    const map = buildLibMap(libPath, libSource);
+
+    // Synthetic canvas that imports just MotionDemo from canvas-lib.
+    const canvas = [
+      'import { MotionDemo } from "@maude/canvas-lib";',
+      '',
+      'export default function Probe() {',
+      '  return <MotionDemo role="flip" />;',
+      '}',
+      '',
+    ].join('\n');
+
+    const inlined = inlineUsedExports(canvas, map);
+    expect(inlined.droppedImport).toBe(true);
+
+    const inlinedNames = new Set(inlined.inlined);
+    // MotionDemo's body references useMotionTokens + easingFromToken + the
+    // aliased _motionImpl + _useReducedMotion. Transitive walk should pull
+    // useMotionTokens + easingFromToken (the function symbols), and the
+    // module-level role table constant.
+    expect(inlinedNames.has('MotionDemo')).toBe(true);
+    // The role config table.
+    expect(inlinedNames.has('MOTION_ROLE_DEFAULTS')).toBe(true);
+    // Reads-tokens hook (referenced inside MotionDemo).
+    expect(inlinedNames.has('useMotionTokens')).toBe(true);
+    expect(inlinedNames.has('easingFromToken')).toBe(true);
+  });
+
+  test('inlined motion code references aliased motion/react imports', async () => {
+    const libPath = canvasLibPath(PROJECT_DESIGN_ROOT);
+    const libSource = await Bun.file(libPath).text();
+    const map = buildLibMap(libPath, libSource);
+
+    const canvas = [
+      'import { MotionDemo } from "@maude/canvas-lib";',
+      '',
+      'export default function Probe() {',
+      '  return <MotionDemo role="soft" />;',
+      '}',
+      '',
+    ].join('\n');
+
+    const inlined = inlineUsedExports(canvas, map);
+    // The inlined body must reference the aliased symbols (handoff.ts then
+    // splices a synthetic import re-binding them to motion/react). If this
+    // assertion fails, the handoff path will produce a TSX with undefined
+    // identifiers.
+    expect(inlined.content).toMatch(/_motionImpl\b/);
+    expect(inlined.content).toMatch(/_useReducedMotion\b/);
+  });
+
+  test('role keys are stable (8-role vocabulary fixed per DDR-049)', async () => {
+    const libPath = canvasLibPath(PROJECT_DESIGN_ROOT);
+    const libSource = await Bun.file(libPath).text();
+    // The 8-role vocabulary is part of the DS contract — design-system-keeper
+    // + motion-critic both grep against it. Lock the role list with a
+    // structural assertion against the source.
+    for (const role of ['flip', 'panel', 'route', 'soft', 'spring', 'scroll', 'drag', 'presence']) {
+      expect(libSource).toContain(`  ${role}: {`);
+    }
+  });
+});
+
+describe('motion peer-dep in package.json', () => {
+  test('motion declared in dependencies', async () => {
+    const pkg = await Bun.file('./package.json').json();
+    expect(pkg.dependencies.motion).toBeDefined();
+    expect(typeof pkg.dependencies.motion).toBe('string');
+  });
+
+  test('motion + motion/react in RUNTIME_PACKAGES', async () => {
+    const { RUNTIME_PACKAGES } = await import('../runtime-bundle.ts');
+    const list = [...RUNTIME_PACKAGES];
+    expect(list).toContain('motion');
+    expect(list).toContain('motion/react');
+  });
+});

package/plugins/design/dev-server/test/collab-annotations-bridge.test.ts

@@ -0,0 +1,55 @@
+// Unit: Task 5 — Registry.syncRoomFromAnnotations bridges PUT /_api/annotations
+// writes into the live Y.Map so collab peers see the SVG without cold-open.
+
+import { describe, expect, test } from 'bun:test';
+
+import { Y_TYPES } from '../collab/persistence.ts';
+import { createRegistry } from '../collab/registry.ts';
+import type { RoomCallbacks } from '../collab/room.ts';
+
+function noopCallbacks(): RoomCallbacks {
+  return {
+    async seed() {},
+    async persistJson() {},
+    async persistBinary() {},
+  };
+}
+
+describe('Registry.syncRoomFromAnnotations', () => {
+  test('populates Y.Map.svg', () => {
+    const r = createRegistry(noopCallbacks());
+    const room = r.get('canvas-slug');
+    const map = room.doc.getMap<string>(Y_TYPES.annotations);
+    expect(map.get('svg')).toBeUndefined();
+
+    const svg = '<svg xmlns="http://www.w3.org/2000/svg"><g/></svg>';
+    r.syncRoomFromAnnotations('canvas-slug', svg);
+    expect(map.get('svg')).toBe(svg);
+  });
+
+  test('replaces existing svg on each call (LWW)', () => {
+    const r = createRegistry(noopCallbacks());
+    const room = r.get('canvas-slug');
+    r.syncRoomFromAnnotations('canvas-slug', '<svg>1</svg>');
+    r.syncRoomFromAnnotations('canvas-slug', '<svg>2</svg>');
+    expect(room.doc.getMap(Y_TYPES.annotations).get('svg')).toBe('<svg>2</svg>');
+  });
+
+  test('no-op when no room exists for slug', () => {
+    const r = createRegistry(noopCallbacks());
+    r.syncRoomFromAnnotations('absent', '<svg/>');
+    expect(r.peek('absent')).toBeNull();
+    expect(r.size()).toBe(0);
+  });
+
+  test('inspector-write origin propagates through doc.update', () => {
+    const r = createRegistry(noopCallbacks());
+    const room = r.get('echo-slug');
+    let lastOrigin: unknown = undefined;
+    room.doc.on('update', (_update, origin) => {
+      lastOrigin = origin;
+    });
+    r.syncRoomFromAnnotations('echo-slug', '<svg/>');
+    expect(lastOrigin).toBe('inspector-write');
+  });
+});