@1agh/maude 1.0.9 → 1.2.0

package/apps/studio/test/cold-start-apply.test.ts

@@ -1,303 +0,0 @@
-// The ONE cold-start application body — Sync v2 Increment 0 (DDR-226).
-//
-// Three things are pinned here:
-//
-//   1. **The tripwire.** Both architectures import `sync/cold-start-apply.ts`.
-//      DDR-102 said the decision table is "a pure module consumed by BOTH sync
-//      paths" — the table was, the APPLICATION was not, and the twin switches
-//      drifted three times (DDR-076's empty-hub guard written twice, DDR-223's
-//      eraser FIXED twice, and the `recover-seed-dup` fallthrough below). This
-//      test makes a re-split a red test, the same way
-//      `sync-file-membership.test.ts` pins the classifier's hub mirror.
-//
-//   2. **Totality.** Every `ColdStartAction` reaches a row and produces the
-//      right body winner + effect. The compile-time `never` default catches new
-//      actions at build time; this catches a hand-edited switch at test time.
-//
-//   3. **The live regression.** `migrateSeed` on a hub body that is the local
-//      body repeated must COLLAPSE it, not keep it. Before this module,
-//      migrate-seed's switch had no `recover-seed-dup` case and no default, so
-//      the decision fell through to `hub-wins` and the duplicated body was kept
-//      and materialized to disk — an un-buildable canvas (two `export default`).
-
-import { afterEach, beforeEach, describe, expect, test } from 'bun:test';
-import { mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { dirname, join } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import * as Y from 'yjs';
-
-import { applyHtmlToDoc } from '../sync/codec.ts';
-import type { ColdStartAction, ColdStartDecision } from '../sync/cold-start.ts';
-import { decideColdStart } from '../sync/cold-start.ts';
-import { applyColdStart } from '../sync/cold-start-apply.ts';
-import { migrateSeed } from '../sync/migrate-seed.ts';
-import { ORIGINS } from '../sync/origins.ts';
-
-const SYNC_DIR = join(dirname(fileURLToPath(import.meta.url)), '..', 'sync');
-
-/** Every action the table can emit. Kept as a literal list on purpose: if
- *  `ColdStartAction` grows a member, the `satisfies` below fails to compile. */
-const ALL_ACTIONS = [
-  'noop',
-  'materialize-hub',
-  'seed-local-up',
-  'fast-forward-hub',
-  'recover-seed-dup',
-  'conflict',
-] as const satisfies readonly ColdStartAction[];
-
-const silent = { warn: () => {}, error: () => {} };
-
-/** Record which effect the applier invoked. */
-function spyOps() {
-  const calls: string[] = [];
-  return {
-    calls,
-    takeHub: () => {
-      calls.push('takeHub');
-    },
-    takeLocal: (body: string) => {
-      calls.push(`takeLocal:${body}`);
-    },
-    checkpointIdentity: (body: string) => {
-      calls.push(`checkpoint:${body}`);
-    },
-  };
-}
-
-describe('cold-start-apply — the tripwire (one applier, both architectures)', () => {
-  test('agent.ts and migrate-seed.ts both import cold-start-apply.ts', () => {
-    for (const file of ['agent.ts', 'migrate-seed.ts']) {
-      const src = readFileSync(join(SYNC_DIR, file), 'utf8');
-      expect(src).toContain("from './cold-start-apply.ts'");
-      expect(src).toContain('applyColdStart(');
-    }
-  });
-
-  test('neither caller keeps a private switch over decision.action', () => {
-    // The whole point of the module: the row set lives in ONE place. A
-    // `switch (decision.action)` reappearing in either caller is the drift
-    // this test exists to catch.
-    for (const file of ['agent.ts', 'migrate-seed.ts']) {
-      const src = readFileSync(join(SYNC_DIR, file), 'utf8');
-      expect(src).not.toContain('switch (decision.action)');
-    }
-  });
-});
-
-describe('cold-start-apply — total over every action', () => {
-  test.each(ALL_ACTIONS)('%s reaches a row', async (action) => {
-    const decision: ColdStartDecision = {
-      action,
-      reason: 'test',
-      ...(action === 'conflict' ? { winner: 'hub' as const } : {}),
-    };
-    const ops = spyOps();
-    const result = await applyColdStart({
-      slug: 's',
-      decision,
-      localBody: 'LOCAL',
-      docBody: 'HUB',
-      log: silent,
-      ...ops,
-    });
-    expect(result.action).toBe(action);
-    expect(['local', 'hub']).toContain(result.bodyWinner);
-  });
-
-  test('an action with no row throws instead of silently keeping the hub', async () => {
-    const ops = spyOps();
-    await expect(
-      applyColdStart({
-        slug: 's',
-        // Deliberately outside the union — the shape a hand-edited table or a
-        // stale build would produce.
-        decision: { action: 'invented-row' as ColdStartAction, reason: 'test' },
-        localBody: 'LOCAL',
-        docBody: 'HUB',
-        log: silent,
-        ...ops,
-      })
-    ).rejects.toThrow(/unhandled action/);
-    expect(ops.calls).toEqual([]);
-  });
-
-  test('winners and effects per row', async () => {
-    const expected: Array<[ColdStartAction, 'local' | 'hub', string | null]> = [
-      ['noop', 'hub', null],
-      ['materialize-hub', 'hub', 'takeHub'],
-      ['fast-forward-hub', 'hub', 'takeHub'],
-      ['seed-local-up', 'local', 'takeLocal:LOCAL'],
-      ['recover-seed-dup', 'local', 'takeLocal:LOCAL'],
-    ];
-    for (const [action, winner, call] of expected) {
-      const ops = spyOps();
-      const result = await applyColdStart({
-        slug: 's',
-        decision: { action, reason: 'test' },
-        localBody: 'LOCAL',
-        docBody: 'HUB',
-        log: silent,
-        ...ops,
-      });
-      expect(result.bodyWinner).toBe(winner);
-      expect(ops.calls).toEqual(call === null ? [] : [call]);
-    }
-  });
-
-  test('noop checkpoints identity only when both sides carry the same bytes', async () => {
-    const same = spyOps();
-    await applyColdStart({
-      slug: 's',
-      decision: { action: 'noop', reason: 'identical' },
-      localBody: 'SAME',
-      docBody: 'SAME',
-      log: silent,
-      ...same,
-    });
-    expect(same.calls).toEqual(['checkpoint:SAME']);
-
-    const bothEmpty = spyOps();
-    await applyColdStart({
-      slug: 's',
-      decision: { action: 'noop', reason: 'both empty' },
-      localBody: null,
-      docBody: '',
-      log: silent,
-      ...bothEmpty,
-    });
-    expect(bothEmpty.calls).toEqual([]);
-  });
-});
-
-describe('cold-start-apply — DDR-102 fail-closed, in one place', () => {
-  test('hub wins normally when the snapshot lands', async () => {
-    const ops = spyOps();
-    const result = await applyColdStart({
-      slug: 's',
-      decision: { action: 'conflict', winner: 'hub', reason: 'diverged' },
-      localBody: 'LOCAL',
-      docBody: 'HUB',
-      snapshot: async () => 'ts-1',
-      log: silent,
-      ...ops,
-    });
-    expect(result.bodyWinner).toBe('hub');
-    expect(result.conflict?.snapshotFailed).toBe(false);
-    expect(ops.calls).toEqual(['takeHub']);
-  });
-
-  test('a hub-wins verdict is REFUSED when the local snapshot did not land', async () => {
-    const ops = spyOps();
-    const errors: string[] = [];
-    const result = await applyColdStart({
-      slug: 's',
-      decision: { action: 'conflict', winner: 'hub', reason: 'diverged' },
-      localBody: 'LOCAL',
-      docBody: 'HUB',
-      snapshot: async () => null, // both snapshots fail
-      log: { warn: () => {}, error: (m) => errors.push(m) },
-      ...ops,
-    });
-    expect(result.bodyWinner).toBe('local');
-    expect(result.conflict?.snapshotFailed).toBe(true);
-    expect(ops.calls).toEqual(['takeLocal:LOCAL']);
-    expect(errors.join(' ')).toContain('REFUSING to overwrite local');
-  });
-
-  test('no snapshot fn at all ⇒ plain newest-wins (standalone wiring)', async () => {
-    const ops = spyOps();
-    const result = await applyColdStart({
-      slug: 's',
-      decision: { action: 'conflict', winner: 'hub', reason: 'diverged' },
-      localBody: 'LOCAL',
-      docBody: 'HUB',
-      log: silent,
-      ...ops,
-    });
-    expect(result.bodyWinner).toBe('hub');
-    expect(result.conflict?.snapshotFailed).toBe(false);
-  });
-
-  test('the conflict report carries the POST-guard winner', async () => {
-    const seen: Array<{ winner?: string; snapshotFailed?: boolean }> = [];
-    await applyColdStart({
-      slug: 's',
-      decision: { action: 'conflict', winner: 'hub', reason: 'diverged' },
-      localBody: 'LOCAL',
-      docBody: 'HUB',
-      snapshot: async () => null,
-      onConflict: (info) => seen.push(info),
-      log: silent,
-      ...spyOps(),
-    });
-    expect(seen).toHaveLength(1);
-    expect(seen[0]?.winner).toBe('local');
-    expect(seen[0]?.snapshotFailed).toBe(true);
-  });
-});
-
-/* ---------------------------------------------------------------------- */
-
-describe('migrate-seed — the recover-seed-dup fallthrough (LIVE regression)', () => {
-  let dir: string;
-  beforeEach(() => {
-    dir = mkdtempSync(join(tmpdir(), 'cold-start-apply-'));
-  });
-  afterEach(() => {
-    rmSync(dir, { recursive: true, force: true });
-  });
-
-  const paths = () => ({
-    html: join(dir, 'screen.html'),
-    comments: join(dir, 'screen.comments.json'),
-    annotations: join(dir, 'screen.annotations.svg'),
-    meta: join(dir, 'screen.meta.json'),
-    css: join(dir, 'screen.css'),
-  });
-
-  test('a doubled hub body is COLLAPSED to one copy, not kept', async () => {
-    const p = paths();
-    const body = '<main>one copy</main>';
-    writeFileSync(p.html, body);
-
-    // The shape of a concurrent cold-seed collision: two peers each seeded the
-    // same body into an empty hub and the CRDT concatenated both insertions.
-    const doc = new Y.Doc();
-    applyHtmlToDoc(doc, body + body, ORIGINS.MIGRATION);
-
-    // Sanity: the table really does emit `recover-seed-dup` for this input.
-    expect(
-      decideColdStart({
-        localBody: body,
-        docBody: body + body,
-        journalHash: null,
-        localMtimeMs: null,
-        docBodyEditAtMs: null,
-      }).action
-    ).toBe('recover-seed-dup');
-
-    const result = await migrateSeed({ slug: 's', doc, paths: p });
-
-    // Before Increment 0 this returned 'hub-wins' and the doc kept `body+body`.
-    expect(result).toBe('recover-seed-dup');
-    expect(doc.getText('html').toString()).toBe(body);
-  });
-
-  test('a THREE-fold repeat collapses too, and re-running is a no-op', async () => {
-    const p = paths();
-    const body = '<main>x</main>';
-    writeFileSync(p.html, body);
-
-    const doc = new Y.Doc();
-    applyHtmlToDoc(doc, body.repeat(3), ORIGINS.MIGRATION);
-
-    expect(await migrateSeed({ slug: 's', doc, paths: p })).toBe('recover-seed-dup');
-    expect(doc.getText('html').toString()).toBe(body);
-
-    // Idempotent: the second pass sees identical sides.
-    expect(await migrateSeed({ slug: 's', doc, paths: p })).toBe('hub-wins');
-    expect(doc.getText('html').toString()).toBe(body);
-  });
-});

package/apps/studio/test/collab-annotations-bridge.test.ts

@@ -1,55 +0,0 @@
-// 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;
-    room.doc.on('update', (_update, origin) => {
-      lastOrigin = origin;
-    });
-    r.syncRoomFromAnnotations('echo-slug', '<svg/>');
-    expect(lastOrigin).toBe('inspector-write');
-  });
-});

package/apps/studio/test/collab-awareness-bridge.test.ts

@@ -1,223 +0,0 @@
-// Phase 9 Task 5 — awareness over WSS.
-//
-// Unit-tests the in-process Awareness bridge (collab Room ↔ sync provider) and
-// the registry wiring that owns its lifecycle, plus an end-to-end cross-peer
-// cursor relay through a simulated hub.
-
-import { describe, expect, test } from 'bun:test';
-
-import { Awareness, applyAwarenessUpdate, encodeAwarenessUpdate } from 'y-protocols/awareness';
-import * as Y from 'yjs';
-
-import { bridgeAwareness } from '../collab/awareness-bridge.ts';
-import { createRegistry } from '../collab/registry.ts';
-import type { RoomCallbacks } from '../collab/room.ts';
-
-function noopCallbacks(): RoomCallbacks {
-  return {
-    async seed() {},
-    async persistJson() {},
-    async persistBinary() {},
-  };
-}
-
-function mkAwareness(): Awareness {
-  return new Awareness(new Y.Doc());
-}
-
-// Simulate the Hocuspocus hub relay: two Awareness instances cross-linked so a
-// change on one appears on the other (keyed by the originating clientID).
-function linkAwareness(x: Awareness, y: Awareness): () => void {
-  const T = { transport: true };
-  function fwd(from: Awareness, to: Awareness) {
-    return (
-      { added, updated, removed }: { added: number[]; updated: number[]; removed: number[] },
-      origin: unknown
-    ) => {
-      if (origin === T) return;
-      const changed = added.concat(updated, removed);
-      if (changed.length === 0) return;
-      applyAwarenessUpdate(to, encodeAwarenessUpdate(from, changed), T);
-    };
-  }
-  const xy = fwd(x, y);
-  const yx = fwd(y, x);
-  x.on('update', xy);
-  y.on('update', yx);
-  return () => {
-    x.off('update', xy);
-    y.off('update', yx);
-  };
-}
-
-describe('bridgeAwareness', () => {
-  test('relays a local state set on a → b', () => {
-    const a = mkAwareness();
-    const b = mkAwareness();
-    bridgeAwareness(a, b);
-
-    a.setLocalState({ name: 'Alice', color: '#f00', cursor: { x: 1, y: 2 } });
-
-    const seen = b.getStates().get(a.clientID) as { name?: string; color?: string } | undefined;
-    expect(seen?.name).toBe('Alice');
-    expect(seen?.color).toBe('#f00');
-  });
-
-  test('relays both directions', () => {
-    const a = mkAwareness();
-    const b = mkAwareness();
-    bridgeAwareness(a, b);
-
-    b.setLocalState({ name: 'Bob' });
-    expect((a.getStates().get(b.clientID) as { name?: string } | undefined)?.name).toBe('Bob');
-  });
-
-  test('propagates removal when the source clears its state', () => {
-    const a = mkAwareness();
-    const b = mkAwareness();
-    bridgeAwareness(a, b);
-
-    a.setLocalState({ name: 'Alice' });
-    expect(b.getStates().has(a.clientID)).toBe(true);
-
-    a.setLocalState(null);
-    expect(b.getStates().has(a.clientID)).toBe(false);
-  });
-
-  test('exchanges pre-existing states at wire time', () => {
-    const a = mkAwareness();
-    const b = mkAwareness();
-    a.setLocalState({ name: 'Alice' });
-    b.setLocalState({ name: 'Bob' });
-
-    bridgeAwareness(a, b);
-
-    expect((b.getStates().get(a.clientID) as { name?: string } | undefined)?.name).toBe('Alice');
-    expect((a.getStates().get(b.clientID) as { name?: string } | undefined)?.name).toBe('Bob');
-  });
-
-  test('does not echo — a single update yields a single foreign state, no storm', () => {
-    const a = mkAwareness();
-    const b = mkAwareness();
-    bridgeAwareness(a, b);
-
-    let bUpdates = 0;
-    b.on('update', () => {
-      bUpdates++;
-    });
-
-    a.setLocalState({ name: 'Alice' });
-
-    // Exactly one relayed update; a's own state count stays 1 (no bounce-back
-    // creating phantom clients).
-    expect(bUpdates).toBe(1);
-    expect(a.getStates().size).toBe(1);
-    expect(b.getStates().size).toBe(2); // a (relayed) + b's own
-  });
-
-  test('detach stops further relay', () => {
-    const a = mkAwareness();
-    const b = mkAwareness();
-    const detach = bridgeAwareness(a, b);
-
-    detach();
-    a.setLocalState({ name: 'Alice' });
-    expect(b.getStates().has(a.clientID)).toBe(false);
-  });
-});
-
-describe('Registry.attachHubAwareness', () => {
-  test('attach-then-create wires the bridge so room state reaches the hub', () => {
-    const r = createRegistry(noopCallbacks());
-    const hub = mkAwareness();
-    r.attachHubAwareness('s', hub);
-
-    const room = r.get('s');
-    room.awareness.setLocalState({ name: 'Alice' });
-
-    expect((hub.getStates().get(room.awareness.clientID) as { name?: string })?.name).toBe('Alice');
-  });
-
-  test('create-then-attach wires immediately', () => {
-    const r = createRegistry(noopCallbacks());
-    const room = r.get('s');
-    room.awareness.setLocalState({ name: 'Alice' });
-
-    const hub = mkAwareness();
-    r.attachHubAwareness('s', hub);
-
-    // Pre-existing room state is exchanged at wire time.
-    expect((hub.getStates().get(room.awareness.clientID) as { name?: string })?.name).toBe('Alice');
-  });
-
-  test('detach stops relaying and prevents re-wire on a fresh room', async () => {
-    const r = createRegistry(noopCallbacks());
-    const hub = mkAwareness();
-    const detach = r.attachHubAwareness('s', hub);
-    r.get('s');
-
-    detach();
-    await r.drop('s'); // room had no conns → destroyed
-
-    const room2 = r.get('s');
-    room2.awareness.setLocalState({ name: 'Alice' });
-    expect(hub.getStates().has(room2.awareness.clientID)).toBe(false);
-  });
-
-  test('room churn re-wires the bridge (hub awareness persists)', async () => {
-    const r = createRegistry(noopCallbacks());
-    const hub = mkAwareness();
-    r.attachHubAwareness('s', hub);
-
-    const room1 = r.get('s');
-    room1.awareness.setLocalState({ name: 'Alice' });
-    expect(hub.getStates().has(room1.awareness.clientID)).toBe(true);
-
-    await r.drop('s'); // last browser left
-
-    const room2 = r.get('s'); // browser reconnects
-    room2.awareness.setLocalState({ name: 'Alice2' });
-    expect((hub.getStates().get(room2.awareness.clientID) as { name?: string })?.name).toBe(
-      'Alice2'
-    );
-  });
-
-  test('destroyAll tears down bridges without throwing', async () => {
-    const r = createRegistry(noopCallbacks());
-    const hub = mkAwareness();
-    r.attachHubAwareness('s', hub);
-    r.get('s').awareness.setLocalState({ name: 'Alice' });
-
-    await r.destroyAll();
-    // Hub Awareness is no longer relayed-to; setting a fresh room would not
-    // re-wire because destroyAll cleared the attachment.
-    const room = r.get('s');
-    room.awareness.setLocalState({ name: 'Bob' });
-    expect(hub.getStates().has(room.awareness.clientID)).toBe(false);
-  });
-});
-
-describe('cross-peer cursor relay (Room A → hub → Room B)', () => {
-  test('a cursor published in one peer reaches the other peer', () => {
-    // Peer A: room A ↔ hubA. Peer B: room B ↔ hubB. hubA ↔ hubB is the
-    // Hocuspocus relay (simulated by linkAwareness).
-    const regA = createRegistry(noopCallbacks());
-    const regB = createRegistry(noopCallbacks());
-    const hubA = mkAwareness();
-    const hubB = mkAwareness();
-    linkAwareness(hubA, hubB);
-    regA.attachHubAwareness('canvas', hubA);
-    regB.attachHubAwareness('canvas', hubB);
-
-    const roomA = regA.get('canvas');
-    const roomB = regB.get('canvas');
-
-    roomA.awareness.setLocalState({ name: 'Alice', cursor: { x: 10, y: 20 } });
-
-    const onB = roomB.awareness.getStates().get(roomA.awareness.clientID) as
-      | { name?: string; cursor?: { x: number; y: number } }
-      | undefined;
-    expect(onB?.name).toBe('Alice');
-    expect(onB?.cursor).toEqual({ x: 10, y: 20 });
-  });
-});

package/apps/studio/test/collab-bridge.test.ts

@@ -1,79 +0,0 @@
-// Unit: Registry inspector-bridge — REST/WS writes to api.comments* must
-// reach the live Y.Array so collab peers see the change without waiting for
-// a cold-open re-seed.
-
-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 inspector-bridge', () => {
-  test('peek returns null when no room is live', () => {
-    const r = createRegistry(noopCallbacks());
-    expect(r.peek('absent')).toBeNull();
-  });
-
-  test('peek returns the room without creating one', () => {
-    const r = createRegistry(noopCallbacks());
-    expect(r.size()).toBe(0);
-    expect(r.peek('foo')).toBeNull();
-    expect(r.size()).toBe(0);
-    r.get('foo'); // create
-    expect(r.size()).toBe(1);
-    expect(r.peek('foo')).not.toBeNull();
-  });
-
-  test('syncRoomFromComments populates the live Y.Array', () => {
-    const r = createRegistry(noopCallbacks());
-    const room = r.get('canvas-slug');
-    expect(room.doc.getArray(Y_TYPES.comments).length).toBe(0);
-
-    r.syncRoomFromComments('canvas-slug', [
-      { id: 'c1', text: 'first', status: 'open' },
-      { id: 'c2', text: 'second', status: 'open' },
-    ]);
-
-    const arr = room.doc.getArray(Y_TYPES.comments);
-    expect(arr.length).toBe(2);
-    expect((arr.get(0) as { id: string }).id).toBe('c1');
-    expect((arr.get(1) as { id: string }).id).toBe('c2');
-  });
-
-  test('syncRoomFromComments replaces existing contents (idempotent)', () => {
-    const r = createRegistry(noopCallbacks());
-    const room = r.get('canvas-slug');
-    r.syncRoomFromComments('canvas-slug', [{ id: 'c1' }, { id: 'c2' }]);
-    r.syncRoomFromComments('canvas-slug', [{ id: 'c1' }, { id: 'c2' }, { id: 'c3' }]);
-    expect(room.doc.getArray(Y_TYPES.comments).length).toBe(3);
-    r.syncRoomFromComments('canvas-slug', []);
-    expect(room.doc.getArray(Y_TYPES.comments).length).toBe(0);
-  });
-
-  test('syncRoomFromComments is a no-op for slugs with no room', () => {
-    const r = createRegistry(noopCallbacks());
-    // Must not throw, must not create a room.
-    r.syncRoomFromComments('absent', [{ id: 'x' }]);
-    expect(r.peek('absent')).toBeNull();
-    expect(r.size()).toBe(0);
-  });
-
-  test('inspector-write origin triggers doc.update broadcast', async () => {
-    const r = createRegistry(noopCallbacks());
-    const room = r.get('echo-slug');
-    let lastOrigin: unknown;
-    room.doc.on('update', (_update, origin) => {
-      lastOrigin = origin;
-    });
-    r.syncRoomFromComments('echo-slug', [{ id: 'c1' }]);
-    expect(lastOrigin).toBe('inspector-write');
-  });
-});