@1agh/maude 1.0.9 → 1.2.0

package/apps/studio/test/collab-readonly-gate.test.ts

@@ -1,194 +0,0 @@
-// Unit: the read-only role gate on collab sync writes — the cloud collab lane
-// (RCA issue-cloud-live-collaboration-dead).
-//
-// A cell's proxy opens the canvas iframe's collab socket at the member's real
-// role; a viewer's socket arrives with readOnly=true. The room mirrors the role
-// matrix at the WS door the same way the inspector channel does for
-// comments-patch/delete: a read-only conn receives everything and publishes
-// awareness (presence for viewers is the point of the channel), but its sync
-// writes are gated to the COMMENT lane — the one write a viewer holds
-// (`viewer.comment === true`). Composes with, never replaces, the DDR-122
-// canvas-realm body-lane gate (test/collab-origin-gate.test.ts).
-
-import { describe, expect, test } from 'bun:test';
-
-import * as encoding from 'lib0/encoding';
-import { writeUpdate } from 'y-protocols/sync';
-import * as Y from 'yjs';
-
-import { MESSAGE_SYNC } from '../collab/protocol.ts';
-import { createRoom, type RoomCallbacks, type RoomConn } from '../collab/room.ts';
-
-function makeConn(
-  id: string,
-  opts: { realm?: 'main' | 'canvas'; readOnly?: boolean } = {}
-): RoomConn & { recv: Uint8Array[] } {
-  const recv: Uint8Array[] = [];
-  return {
-    id,
-    ...(opts.realm ? { realm: opts.realm } : {}),
-    ...(opts.readOnly !== undefined ? { readOnly: opts.readOnly } : {}),
-    send(payload: Uint8Array) {
-      recv.push(payload);
-    },
-    recv,
-  };
-}
-
-function makeCallbacks(): RoomCallbacks {
-  return {
-    seed() {},
-    persistJson() {},
-    persistBinary() {},
-  };
-}
-
-function syncUpdateFrame(update: Uint8Array): Uint8Array {
-  const encoder = encoding.createEncoder();
-  encoding.writeVarUint(encoder, MESSAGE_SYNC);
-  writeUpdate(encoder, update);
-  return encoding.toUint8Array(encoder);
-}
-
-function peerDelta(room: { doc: Y.Doc }, mutate: (doc: Y.Doc) => void): Uint8Array {
-  const peer = new Y.Doc();
-  Y.applyUpdate(peer, Y.encodeStateAsUpdate(room.doc));
-  const before = Y.encodeStateVector(peer);
-  mutate(peer);
-  return Y.encodeStateAsUpdate(peer, before);
-}
-
-describe('room read-only gate — cloud viewer sockets', () => {
-  test('a read-only canvas conn may write COMMENTS (the viewer capability)', async () => {
-    const room = createRoom('viewer-comments', makeCallbacks());
-    const viewer = makeConn('viewer', { realm: 'canvas', readOnly: true });
-    await room.connect(viewer);
-
-    room.receive(
-      viewer,
-      syncUpdateFrame(
-        peerDelta(room, (d) => d.getArray('comments').push([{ id: 'c1', text: 'a viewer note' }]))
-      )
-    );
-
-    expect(room.doc.getArray('comments').toArray()).toEqual([{ id: 'c1', text: 'a viewer note' }]);
-    expect(room.gateRefusals()).toBe(0);
-    await room.destroy();
-  });
-
-  test('a read-only conn may NOT write annotations — refused, doc untouched, not broadcast', async () => {
-    const room = createRoom('viewer-annotations', makeCallbacks());
-    const editor = makeConn('editor', { realm: 'canvas', readOnly: false });
-    const viewer = makeConn('viewer', { realm: 'canvas', readOnly: true });
-    await room.connect(editor);
-    await room.connect(viewer);
-    editor.recv.length = 0;
-    viewer.recv.length = 0;
-
-    room.receive(
-      viewer,
-      syncUpdateFrame(peerDelta(room, (d) => d.getMap('annotations').set('svg', '<svg/>')))
-    );
-
-    expect(room.doc.getMap('annotations').get('svg')).toBeUndefined();
-    expect(room.gateRefusals()).toBe(1);
-    expect(editor.recv.length).toBe(0);
-    // The refused peer got a corrective full-state frame instead.
-    expect(viewer.recv.length).toBe(1);
-    await room.destroy();
-  });
-
-  test('a read-only conn may not write body lanes either — even on the main realm', async () => {
-    const room = createRoom('viewer-body', makeCallbacks());
-    const viewer = makeConn('viewer', { realm: 'main', readOnly: true });
-    await room.connect(viewer);
-
-    room.receive(
-      viewer,
-      syncUpdateFrame(peerDelta(room, (d) => d.getText('html').insert(0, 'PWNED')))
-    );
-
-    expect(room.doc.getText('html').toString()).toBe('');
-    expect(room.gateRefusals()).toBe(1);
-    await room.destroy();
-  });
-
-  test('a WRITABLE canvas conn (an owner through the cloud lane) still annotates', async () => {
-    // The reason the role claim exists at all: annotations are exactly what the
-    // cloud complaint was about, and they need an editor-or-better socket.
-    const room = createRoom('owner-annotates', makeCallbacks());
-    const owner = makeConn('owner', { realm: 'canvas', readOnly: false });
-    await room.connect(owner);
-
-    room.receive(
-      owner,
-      syncUpdateFrame(
-        peerDelta(room, (d) => d.getMap('annotations').set('svg', '<svg><rect/></svg>'))
-      )
-    );
-
-    expect(room.doc.getMap('annotations').get('svg')).toBe('<svg><rect/></svg>');
-    expect(room.gateRefusals()).toBe(0);
-    await room.destroy();
-  });
-
-  test('awareness frames from a read-only conn pass — presence for viewers is the point', async () => {
-    const room = createRoom('viewer-presence', makeCallbacks());
-    const viewer = makeConn('viewer', { realm: 'canvas', readOnly: true });
-    await room.connect(viewer);
-
-    const peerDoc = new Y.Doc();
-    const { Awareness, encodeAwarenessUpdate } = await import('y-protocols/awareness');
-    const peerAwareness = new Awareness(peerDoc);
-    peerAwareness.setLocalState({ name: 'viewing member' });
-    const encoder = encoding.createEncoder();
-    encoding.writeVarUint(encoder, 1 /* MESSAGE_AWARENESS */);
-    encoding.writeVarUint8Array(
-      encoder,
-      encodeAwarenessUpdate(peerAwareness, [peerAwareness.clientID])
-    );
-    room.receive(viewer, encoding.toUint8Array(encoder));
-
-    expect(room.awareness.getStates().get(peerAwareness.clientID)).toEqual({
-      name: 'viewing member',
-    });
-    expect(room.gateRefusals()).toBe(0);
-    await room.destroy();
-  });
-
-  test('a mixed frame (comment + annotation) from a read-only conn is refused wholesale', async () => {
-    const room = createRoom('viewer-mixed', makeCallbacks());
-    const viewer = makeConn('viewer', { realm: 'canvas', readOnly: true });
-    await room.connect(viewer);
-
-    room.receive(
-      viewer,
-      syncUpdateFrame(
-        peerDelta(room, (d) => {
-          d.getArray('comments').push([{ id: 'decoy' }]);
-          d.getMap('annotations').set('svg', '<svg/>');
-        })
-      )
-    );
-
-    expect(room.gateRefusals()).toBe(1);
-    expect(room.doc.getArray('comments').length).toBe(0);
-    expect(room.doc.getMap('annotations').get('svg')).toBeUndefined();
-    await room.destroy();
-  });
-
-  test('absent readOnly defaults to writable — pre-existing loopback callers unchanged', async () => {
-    const room = createRoom('legacy-writable', makeCallbacks());
-    const legacy = makeConn('legacy', { realm: 'canvas' });
-    await room.connect(legacy);
-
-    room.receive(
-      legacy,
-      syncUpdateFrame(peerDelta(room, (d) => d.getMap('annotations').set('svg', '<svg/>')))
-    );
-
-    expect(room.doc.getMap('annotations').get('svg')).toBe('<svg/>');
-    expect(room.gateRefusals()).toBe(0);
-    await room.destroy();
-  });
-});

package/apps/studio/test/collab-reseed-guard.test.ts

@@ -1,78 +0,0 @@
-// Gap 1 (file-sync clobber fix) — the syncRoomFrom* no-op guards.
-//
-// createCollab now re-seeds a live room from disk whenever a synced file
-// changes externally (sync-agent hub-push or `design:edit` write), so the
-// room stops clobbering the external change back. That re-seed reuses
-// syncRoomFromComments/syncRoomFromAnnotations, which ALSO run on the room's
-// own persist → file → fs-event path. Without an equality short-circuit that
-// would spin an 800ms persist storm. These tests pin the guard: an identical
-// re-seed emits NO doc update (→ no persist → no loop); a real change emits one.
-
-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('Gap 1 — syncRoomFromComments no-op guard', () => {
-  test('re-seeding identical comments emits NO doc update (loop-safe)', () => {
-    const r = createRegistry(noopCallbacks());
-    const room = r.get('s');
-    const list = [{ id: 'c1', text: 'hi' }];
-    r.syncRoomFromComments('s', list);
-
-    let updates = 0;
-    room.doc.on('update', () => {
-      updates++;
-    });
-    // Identical content (the room's-own-persist echo, or a redundant hub push)
-    // → must not emit, or the reseed↔persist loop never settles.
-    r.syncRoomFromComments('s', [{ id: 'c1', text: 'hi' }]);
-    expect(updates).toBe(0);
-
-    // A genuine change still propagates — exactly one update.
-    r.syncRoomFromComments('s', [
-      { id: 'c1', text: 'hi' },
-      { id: 'c2', text: 'yo' },
-    ]);
-    expect(updates).toBe(1);
-  });
-
-  test('re-seed brings a STALE room up to the on-disk list (the clobber fix)', () => {
-    const r = createRegistry(noopCallbacks());
-    const room = r.get('s');
-    const arr = room.doc.getArray(Y_TYPES.comments);
-    expect(arr.length).toBe(0); // room opened empty (the "B shows []" state)
-
-    // Sync agent wrote a hub-pushed comment to disk → createCollab re-seeds:
-    r.syncRoomFromComments('s', [{ id: 'c1', text: 'from peer A' }]);
-    expect(arr.toArray()).toEqual([{ id: 'c1', text: 'from peer A' }]);
-  });
-});
-
-describe('Gap 1 — syncRoomFromAnnotations no-op guard', () => {
-  test('re-seeding the identical svg emits NO doc update', () => {
-    const r = createRegistry(noopCallbacks());
-    const room = r.get('s');
-    const svg = '<svg xmlns="http://www.w3.org/2000/svg"><g/></svg>';
-    r.syncRoomFromAnnotations('s', svg);
-
-    let updates = 0;
-    room.doc.on('update', () => {
-      updates++;
-    });
-    r.syncRoomFromAnnotations('s', svg); // identical → no-op
-    expect(updates).toBe(0);
-
-    r.syncRoomFromAnnotations('s', '<svg xmlns="http://www.w3.org/2000/svg"><rect/></svg>');
-    expect(updates).toBe(1);
-  });
-});

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

@@ -1,188 +0,0 @@
-// Unit: Room behavior — two in-memory peers see each other, debounced flush
-// fires, flush is idempotent, room teardown is clean.
-
-import { describe, expect, test } from 'bun:test';
-
-import { Awareness } from 'y-protocols/awareness';
-import * as Y from 'yjs';
-
-import { encodeAwarenessFrame, handleMessage } from '../collab/protocol.ts';
-import { createRoom, type RoomCallbacks, type RoomConn } from '../collab/room.ts';
-
-function makeConn(id: string): RoomConn & { recv: Uint8Array[] } {
-  const recv: Uint8Array[] = [];
-  return {
-    id,
-    send(payload: Uint8Array) {
-      recv.push(payload);
-    },
-    recv,
-  };
-}
-
-function makeCallbacks(): RoomCallbacks & {
-  jsonCalls: number;
-  binaryCalls: number;
-  lastJson: { slug: string; commentsLen: number } | null;
-} {
-  const cb = {
-    jsonCalls: 0,
-    binaryCalls: 0,
-    lastJson: null as { slug: string; commentsLen: number } | null,
-    async seed(_slug: string, _doc: Y.Doc) {
-      /* empty */
-    },
-    async persistJson(slug: string, doc: Y.Doc) {
-      cb.jsonCalls++;
-      cb.lastJson = { slug, commentsLen: doc.getArray('comments').length };
-    },
-    async persistBinary(_slug: string, _state: Uint8Array) {
-      cb.binaryCalls++;
-    },
-  };
-  return cb;
-}
-
-const DEBOUNCE_MS = 800;
-const SETTLE_MS = DEBOUNCE_MS + 100;
-
-describe('Room', () => {
-  test('two peers converge on Y.Doc updates', async () => {
-    const cb = makeCallbacks();
-    const room = createRoom('test-slug', cb);
-    const A = makeConn('a');
-    const B = makeConn('b');
-
-    await room.connect(A);
-    await room.connect(B);
-
-    // Drain handshake frames each peer received.
-    A.recv.length = 0;
-    B.recv.length = 0;
-
-    // Peer A produces an update; route it through the room (as the protocol
-    // would). Easiest path: mutate doc directly through a transaction tagged
-    // with A.
-    room.doc.transact(() => {
-      room.doc.getArray('comments').push([{ id: 'c1', text: 'hello' }]);
-    }, A);
-
-    // Room broadcasts the encoded update to all peers except A.
-    expect(A.recv.length).toBe(0);
-    expect(B.recv.length).toBe(1);
-
-    // B replays the frame against its own doc; the comment lands.
-    const docB = new Y.Doc();
-    const awBStub = (await import('y-protocols/awareness')).Awareness;
-    const awB = new awBStub(docB);
-    // biome-ignore lint/style/noNonNullAssertion: recv.length asserted in the prior expect()
-    handleMessage(B.recv[0]!, docB, awB, { send() {} });
-    expect(docB.getArray('comments').length).toBe(1);
-
-    await room.destroy();
-  });
-
-  test('debounced flush fires after 800ms of quiescence', async () => {
-    const cb = makeCallbacks();
-    const room = createRoom('debounce-slug', cb);
-    const A = makeConn('a');
-    await room.connect(A);
-
-    room.doc.transact(() => {
-      room.doc.getArray('comments').push([{ id: 'c1', text: 'one' }]);
-    }, A);
-    expect(cb.jsonCalls).toBe(0); // not yet — still inside debounce window
-
-    await Bun.sleep(SETTLE_MS);
-    expect(cb.jsonCalls).toBe(1);
-    expect(cb.binaryCalls).toBe(1);
-    expect(cb.lastJson?.commentsLen).toBe(1);
-
-    await room.destroy();
-  });
-
-  test('rapid updates collapse to a single flush at quiescence', async () => {
-    const cb = makeCallbacks();
-    const room = createRoom('coalesce-slug', cb);
-    const A = makeConn('a');
-    await room.connect(A);
-
-    for (let i = 0; i < 5; i++) {
-      room.doc.transact(() => {
-        room.doc.getArray('comments').push([{ id: `c${i}`, text: `n${i}` }]);
-      }, A);
-    }
-    expect(cb.jsonCalls).toBe(0);
-    await Bun.sleep(SETTLE_MS);
-    expect(cb.jsonCalls).toBe(1);
-    expect(cb.lastJson?.commentsLen).toBe(5);
-
-    await room.destroy();
-  });
-
-  test('explicit flush() bypasses the debounce', async () => {
-    const cb = makeCallbacks();
-    const room = createRoom('force-flush-slug', cb);
-    const A = makeConn('a');
-    await room.connect(A);
-
-    room.doc.transact(() => {
-      room.doc.getArray('comments').push([{ id: 'c1', text: 'one' }]);
-    }, A);
-    expect(cb.jsonCalls).toBe(0);
-
-    await room.flush();
-    expect(cb.jsonCalls).toBe(1);
-
-    // Idempotent — second flush with no further mutations doesn't write again.
-    await room.flush();
-    expect(cb.jsonCalls).toBe(1);
-
-    await room.destroy();
-  });
-
-  test('disconnect removes the awareness states a conn published', async () => {
-    const cb = makeCallbacks();
-    const room = createRoom('aw-cleanup-slug', cb);
-    const A = makeConn('a');
-    await room.connect(A);
-
-    // Alice (conn A) publishes her awareness over the wire — the server learns
-    // her clientID belongs to conn 'a' from the update origin (server-authoritative;
-    // it does NOT trust a client-supplied __connId). Mirrors the real receive path.
-    const clientDoc = new Y.Doc();
-    const clientAw = new Awareness(clientDoc);
-    clientAw.setLocalState({ name: 'Alice' });
-    room.receive(A, encodeAwarenessFrame(clientAw, [clientAw.clientID]));
-    expect(room.awareness.getStates().has(clientAw.clientID)).toBe(true);
-
-    room.disconnect(A);
-    expect(room.size()).toBe(0);
-    // The disconnected conn's awareness state is dropped immediately — no waiting
-    // out the ~30s awareness timeout (the phantom-accumulation bug).
-    expect(room.awareness.getStates().has(clientAw.clientID)).toBe(false);
-
-    clientAw.destroy();
-    clientDoc.destroy();
-    await room.destroy();
-  });
-
-  test('seed is called once even with concurrent connects', async () => {
-    let seedCalls = 0;
-    const cb: RoomCallbacks = {
-      async seed(_slug, _doc) {
-        seedCalls++;
-        await Bun.sleep(10);
-      },
-      async persistJson() {},
-      async persistBinary() {},
-    };
-    const room = createRoom('seed-once-slug', cb);
-    const A = makeConn('a');
-    const B = makeConn('b');
-    await Promise.all([room.connect(A), room.connect(B)]);
-    expect(seedCalls).toBe(1);
-
-    await room.destroy();
-  });
-});

package/apps/studio/test/collab-session-survival.test.tsx

@@ -1,176 +0,0 @@
-// Collab session survives a canvas hot-swap remount — F4 regression.
-//
-// RCA: `.ai/logs/rca/issue-collab-observer-tsx-reload-flicker.md`. A cross-peer
-// synced edit hot-swaps the canvas module in place, which REMOUNTS the whole
-// canvas subtree — including <CollabProvider>. If the Y.Doc + Awareness + socket
-// were per-component, that remount would close + re-handshake the awareness
-// socket and every peer's cursor/avatar would blink. The fix makes the session
-// a module-level, refcounted singleton keyed by slug, so a same-slug remount
-// reuses the SAME live socket + Awareness (stable clientID → the server never
-// sees the peer leave + rejoin → no blink).
-//
-// We register happy-dom (error boundaries / real createRoot need a live DOM,
-// like canvas-hmr-runtime.test.tsx) and stub WebSocket + fetch.
-
-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, createElement, useEffect } from 'react';
-import { createRoot, type Root } from 'react-dom/client';
-import type * as Y from 'yjs';
-
-import { CollabProvider, useCollab } from '../use-collab.tsx';
-
-// ── Fake WebSocket: count constructions + closes; never touches the network ──
-let wsConstructed = 0;
-let wsClosed = 0;
-class FakeWS {
-  static OPEN = 1;
-  static CLOSING = 2;
-  static CLOSED = 3;
-  readyState = 1; // OPEN immediately — the provider only broadcasts when OPEN
-  url: string;
-  private handlers: Record<string, Array<(e: unknown) => void>> = {};
-  constructor(url: string) {
-    this.url = url;
-    wsConstructed++;
-    // Fire `open` on the next microtask so the provider's open handler runs.
-    queueMicrotask(() => this.dispatch('open', {}));
-  }
-  addEventListener(type: string, fn: (e: unknown) => void) {
-    const bucket = this.handlers[type] ?? [];
-    bucket.push(fn);
-    this.handlers[type] = bucket;
-  }
-  removeEventListener() {}
-  send() {}
-  close() {
-    if (this.readyState === FakeWS.CLOSED) return;
-    this.readyState = FakeWS.CLOSED;
-    wsClosed++;
-    this.dispatch('close', {});
-  }
-  private dispatch(type: string, e: unknown) {
-    for (const fn of this.handlers[type] ?? []) fn(e);
-  }
-}
-
-const realWebSocket = globalThis.WebSocket;
-const realFetch = globalThis.fetch;
-
-beforeAll(() => {
-  (globalThis as unknown as { WebSocket: unknown }).WebSocket = FakeWS;
-  (globalThis as unknown as { fetch: unknown }).fetch = () =>
-    Promise.resolve({ json: () => Promise.resolve({ name: 'Tester' }) });
-});
-afterAll(() => {
-  (globalThis as unknown as { WebSocket: unknown }).WebSocket = realWebSocket;
-  (globalThis as unknown as { fetch: unknown }).fetch = realFetch;
-});
-
-afterEach(() => {
-  wsConstructed = 0;
-  wsClosed = 0;
-});
-
-// Captures the live doc + awareness clientID for the mounted provider.
-let captured: { doc: Y.Doc; clientID: number } | null = null;
-function Probe() {
-  const collab = useCollab();
-  useEffect(() => {
-    if (collab) captured = { doc: collab.doc, clientID: collab.awareness.clientID };
-  });
-  return null;
-}
-
-function mount(el: HTMLElement): Root {
-  let root!: Root;
-  act(() => {
-    root = createRoot(el);
-  });
-  return root;
-}
-
-function renderProvider(root: Root, slug: string) {
-  act(() => {
-    root.render(createElement(CollabProvider, { slug }, createElement(Probe)));
-  });
-}
-
-describe('collab session survival across a hot-swap remount', () => {
-  test('a same-slug remount reuses the live socket + Awareness (no reconnect)', () => {
-    captured = null;
-    const host = document.createElement('div');
-    const root = mount(host);
-
-    renderProvider(root, 'survival-slug');
-    expect(wsConstructed).toBe(1);
-    const first = captured;
-    expect(first).not.toBeNull();
-
-    // Hot-swap = unmount the canvas subtree, then immediately remount the SAME
-    // slug (what CanvasHmrRuntime's key=attempt does on a synced module swap).
-    act(() => {
-      root.render(createElement('div', null));
-    });
-    renderProvider(root, 'survival-slug');
-
-    // The session was reused within the grace window — NO second socket, and the
-    // SAME doc + Awareness clientID (the server never saw a leave/rejoin).
-    expect(wsConstructed).toBe(1);
-    expect(wsClosed).toBe(0);
-    expect(captured?.doc).toBe(first?.doc);
-    expect(captured?.clientID).toBe(first?.clientID);
-
-    act(() => root.unmount());
-  });
-
-  test('the session registry is anchored on window under a non-enumerable Symbol', () => {
-    // A hot-swap re-imports the canvas bundle with a `?v=` cache-buster, and
-    // use-collab is INLINED into that bundle — so a module-scoped `const
-    // SESSIONS = new Map()` would be FRESH (empty) on every hot-swap and spin a
-    // new clientID each time (phantom self-avatars pile up). Anchoring the map
-    // on `window` (under a global Symbol so the re-imported module resolves the
-    // same key) is what makes the session survive the swap. This pins that
-    // invariant — the registry holds the slug — AND the security posture: the
-    // key is a NON-ENUMERABLE Symbol so untrusted same-realm canvas script can't
-    // harvest the live network handles via a for-in / Object.keys sweep.
-    captured = null;
-    const host = document.createElement('div');
-    const root = mount(host);
-    renderProvider(root, 'window-anchored-slug');
-    const w = window as unknown as Record<symbol, Map<string, unknown> | undefined>;
-    const reg = w[Symbol.for('maude.collab.sessions.v1')];
-    expect(reg).toBeInstanceOf(Map);
-    expect(reg?.has('window-anchored-slug')).toBe(true);
-    // Not reachable via string-key enumeration (defense in depth).
-    expect(Object.keys(window)).not.toContain('__maudeCollabSessions');
-    act(() => root.unmount());
-  });
-
-  test('a different slug opens its own session (no cross-slug sharing)', () => {
-    captured = null;
-    const host = document.createElement('div');
-    const root = mount(host);
-
-    renderProvider(root, 'slug-a');
-    const a = captured;
-    renderProvider(root, 'slug-b');
-    const b = captured;
-
-    // slug-b reuses slug-a's <CollabProvider> instance but a NEW session →
-    // a second socket + a distinct doc.
-    expect(wsConstructed).toBe(2);
-    expect(b?.doc).not.toBe(a?.doc);
-
-    act(() => root.unmount());
-  });
-});