@spooky-sync/core 0.0.1-canary.323 → 0.0.1-canary.324

package/src/modules/crdt/mirror.ts

@@ -0,0 +1,37 @@
+import type { Container, LoroDoc, LoroList, LoroMap } from 'loro-crdt';
+
+/**
+ * The plain text a `@crdt` field shows as its column value, rendered the same
+ * way the SSP fold renders it (`packages/ssp-node/src/crdt/mirror.rs`).
+ */
+
+export type CrdtKind = 'text' | 'prosemirror';
+
+const PM_ROOT = 'doc';
+const PM_NODE_NAME = 'nodeName';
+const PM_CHILDREN = 'children';
+const PM_LINE_BREAKS = new Set(['hard_break', 'hardBreak']);
+
+export function renderText(doc: LoroDoc, field: string, kind: CrdtKind): string {
+  return kind === 'text' ? doc.getText(field).toString() : nodeText(doc.getMap(PM_ROOT));
+}
+
+/** A node holding text runs is inline content (its children concatenate); a
+ *  node holding only nodes is a block container (its children are lines). */
+function nodeText(node: LoroMap): string {
+  const name = node.get(PM_NODE_NAME);
+  if (typeof name === 'string' && PM_LINE_BREAKS.has(name)) return '\n';
+  const children = node.get(PM_CHILDREN) as Container | undefined;
+  if (!children || children.kind() !== 'List') return '';
+  const list = children as LoroList;
+  const parts: Array<{ text: boolean; value: string }> = [];
+  for (let i = 0; i < list.length; i++) {
+    const child = list.get(i) as Container | unknown;
+    if (!child || typeof child !== 'object' || !('kind' in child)) continue;
+    const c = child as Container;
+    if (c.kind() === 'Text') parts.push({ text: true, value: c.toString() });
+    else if (c.kind() === 'Map') parts.push({ text: false, value: nodeText(c as LoroMap) });
+  }
+  const inline = parts.some((p) => p.text);
+  return parts.map((p) => p.value).join(inline ? '' : '\n');
+}

package/src/mutation/push.saga.test.ts

@@ -80,6 +80,22 @@ describe('drain', () => {
     expect(out.dispatched.at(-1)).toEqual({ type: 'SyncOutcome', ok: true, error: undefined });
   });
 
+  it('a CRDT edit-log CREATE that finds its row already there is acked, any other duplicate rolls back', async () => {
+    const logEnv = defaultEnv({ tables: [{ name: 'thing', columns: {} }, { name: 'doc__crdt_log', columns: {} }] } as any, { outboxBatchSize: 2 });
+    const out = await runPure(drain(logEnv), {
+      state: stateWith([1, 2]),
+      handlers: {
+        'local.query': (e: any) =>
+          e.sql === 'SELECT * FROM $ids'
+            ? [[pendingRow(1, 'create', { tableName: 'doc__crdt_log', recordId: 'doc__crdt_log:1' }), pendingRow(2)]]
+            : [],
+        'remote.query': () => [err('Database record `doc__crdt_log:1` already exists'), err('Database record `thing:2` already exists')],
+      },
+    });
+    expect(out.state.outbox.find((i) => i.id === '_00_pending_mutations:m1')?.status).toBe('acked');
+    expect(out.state.outbox.some((i) => i.id === '_00_pending_mutations:m2')).toBe(false);
+  });
+
   it('transport failures keep the tail queued behind a backoff timer (thrown, or a network ERR mid-batch, or a short result list)', async () => {
     const thrown = await runPure(drain(env), {
       state: stateWith([1, 2]),

package/src/mutation/push.saga.ts

@@ -67,6 +67,14 @@ export function* refreshFailedCount(): Saga<void> {
 
 const ERR = (r: StatementResult | undefined): string | null => (r && r.status === 'ERR' ? r.error : null);
 
+/**
+ * A CRDT edit-log row (`<table>__crdt_log`) is written once and never changes,
+ * so a CREATE retried after its first attempt committed (and only the answer
+ * was lost) finds it already there: that is a success, not a rejection.
+ */
+const isRepeatedLogCreate = (row: { mutationType: string; tableName: string }, err: string): boolean =>
+  row.mutationType === 'create' && row.tableName.endsWith('__crdt_log') && /already exists/i.test(err);
+
 /**
  * Drain the outbox: one serial lane, FIFO, up to `outboxBatchSize` statements
  * per request, per-statement outcome. Accepted rows are acked (they stay in
@@ -127,7 +135,7 @@ export function* drain(env: SagaEnv): Saga<void> {
         break;
       }
       const err = ERR(r);
-      if (err === null) {
+      if (err === null || isRepeatedLogCreate(row, err)) {
         const del = deletePendingRow(row.id);
         try {
           yield fx.local.query(del.sql, del.vars);

package/src/query/anon-query-isolation.integration.test.ts

@@ -449,6 +449,37 @@ describe('anonymous _00_query isolation (real SurrealDB)', () => {
     expect(await heartbeatFound(g, qg)).toBe(true);
   });
 
+  // Without `anonymousLiveQueries` the SSP stores a signed-out registration
+  // with no identity at all (`auth_id = ''`). The rule admitted only `'anon'`
+  // rows to their subscribers, so such a page could not read its own row back
+  // and its preload never settled.
+  it("a signed-out view stored with no identity (anonymous live queries off) answers to its own session, and to nobody else", async (ctx) => {
+    if (!reachable) ctx.skip();
+    const [a, sidA] = await guest();
+    const [b] = await guest();
+    const [u] = await member('alice');
+    const qa = viewId();
+    await register(qa, sidA, '');
+    expect((await row(qa))?.auth_id).toBe('');
+
+    expect(await readBack(a, qa)).toEqual({ rowCount: 3, state: 'ready' });
+    expect(await heartbeatFound(a, qa)).toBe(true);
+
+    const before = await row(qa);
+    for (const other of [b, u]) {
+      expect(await readBack(other, qa)).toBeNull();
+      expect(await heartbeatFound(other, qa)).toBe(false);
+      expect(await other.query('SELECT id FROM _00_query')).toEqual([[]]);
+      await other.query('DELETE $id', { id: qa });
+    }
+    expect(await row(qa)).toEqual(before);
+
+    expect(await a.query('RETURN fn::query::unsubscribe($id)', { id: qa })).toEqual([
+      { released: true, remaining: 0 },
+    ]);
+    expect(await row(qa)).toBeUndefined();
+  });
+
   it('the owning guest can still release its view', async (ctx) => {
     if (!reachable) ctx.skip();
     const [a, sidA] = await guest();

package/src/query/env.ts

@@ -49,6 +49,15 @@ export function listRefTable(env: SagaEnv, s: ClientState): string {
   return listRefTableFor(env.refMode, userId);
 }
 
+/**
+ * Whether this session can be sent a view's membership at all. A signed-out
+ * session reads edges only from `_00_list_ref_anon`, and only with
+ * `enableAnonymousLiveQueries`: without it the SSP files its views under no
+ * identity in `_00_list_ref`, whose rule shows those edges to no caller. Such
+ * a view can register and report its row count, but never its rows.
+ */
+export const receivesMembership = (env: SagaEnv, s: ClientState): boolean => s.userId !== null || env.anonLive;
+
 export function columnsFor(env: SagaEnv, table: string): Record<string, unknown> | null {
   const found = env.schema.tables.find((t) => t.name === table);
   if (found) return found.columns as Record<string, unknown>;

package/src/services/database/local-migrator.ts

@@ -17,10 +17,11 @@ export const sha1 = async (str: string): Promise<string> => {
 
 /**
  * Local-only state a schema change must not throw away: the outbox, the
- * failed-mutation tray and debounced patches not yet in the outbox. Cached
- * rows refill from the server; these exist nowhere else.
+ * failed-mutation tray, debounced patches not yet in the outbox and CRDT
+ * documents with edits not yet sent. Cached rows refill from the server;
+ * these exist nowhere else.
  */
-const KEPT_TABLES = ['_00_pending_mutations', '_00_failed_mutations', '_00_pending_writes'] as const;
+const KEPT_TABLES = ['_00_pending_mutations', '_00_failed_mutations', '_00_pending_writes', '_00_crdt_local'] as const;
 
 export class LocalMigrator {
   private logger: Logger;
@@ -59,6 +60,7 @@ export class LocalMigrator {
       DEFINE TABLE IF NOT EXISTS _00_pending_mutations SCHEMALESS PERMISSIONS FOR select, create, update, delete WHERE true;
       DEFINE TABLE IF NOT EXISTS _00_pending_writes SCHEMALESS PERMISSIONS FOR select, create, update, delete WHERE true;
       DEFINE TABLE IF NOT EXISTS _00_blob SCHEMALESS PERMISSIONS FOR select, create, update, delete WHERE true;
+      DEFINE TABLE IF NOT EXISTS _00_crdt_local SCHEMALESS PERMISSIONS FOR select, create, update, delete WHERE true;
     `;
     const fullSchema = schemaSurql + '\n' + systemSchema;
 

package/src/services/database/sqlite-cache-engine.ts

@@ -73,6 +73,8 @@ const SYSTEM_TABLES = [
   // asks for the ids it found in OPFS), so it has to exist up front like the
   // rest — otherwise the very first reconcile throws and the cache runs cold.
   '_00_blob',
+  // CRDT documents per open field, with edits not yet in the outbox.
+  '_00_crdt_local',
   // Server-written, synced-down meta tables (see meta_tables_client.surql).
   // DEFINE is a noop on this engine, so without seeding them here their synced
   // rows have no local table to land in: feature flags silently fall back to

package/src/testing/fake-services.ts

@@ -37,7 +37,7 @@ export function fakeServiceBundle<S extends SchemaStructure>(over: Partial<Servi
     persistence: { set: async () => undefined, get: async () => null, remove: async () => undefined },
     streamProcessor: { addReceiver: (r: unknown) => void receivers.push(r), checkpoint: async () => undefined, dispose: noop } as any,
     migrator: {} as any,
-    crdt: { closeAll: noop, dispose: noop, open: async () => 'field', close: noop } as any,
+    crdt: { attach: noop, setSessionId: noop, closeAll: noop, dispose: noop, open: async () => 'field', close: async () => {} } as any,
     auth: { subscribe: (cb: (u: string | null) => void) => (authListeners.push(cb), noop), subscribeImpersonation: () => noop, onBeforeSignOut: () => noop, currentUser: null, isAuthenticated: false, token: null, impersonation: null, eventSystem: { subscribe: noop } } as any,
     tabs: null,
     tabsUnsupportedReason: 'test',

package/src/types.ts

@@ -259,11 +259,11 @@ export interface Sp00kyConfig<S extends SchemaStructure> {
   streamDebounceTime?: number;
   /**
    * Debounce time in milliseconds for syncing collaborative (CRDT) field
-   * changes to the remote database. Local writes happen immediately on
-   * every keystroke (so reload/offline works), but the remote UPSERT is
-   * coalesced over this window. Lower = snappier remote propagation +
-   * more network traffic; higher = less traffic + more lag for other
-   * collaborators. Defaults to 500ms.
+   * edits to the server. Local state is kept on every change (so reload and
+   * offline work), but a field's own new ops go out as one edit-log row per
+   * pause of this length (at most 2 s apart while typing continues).
+   * Lower = snappier propagation and more rows; higher = fewer rows and more
+   * lag for other collaborators. Defaults to 300ms.
    */
   crdtDebounceMs?: number;
   /**
@@ -321,7 +321,8 @@ export interface Sp00kyConfig<S extends SchemaStructure> {
    * page gets live `useQuery` updates over world-readable tables. Requires the
    * server to be deployed with `anonymousLiveQueries: true` in `sp00ky.yml`
    * (this flag must match it). Defaults to `false`: anonymous clients can read
-   * one-shot but never sync live.
+   * one-shot but never sync live, and a `preload` made while signed out returns
+   * at once rather than wait for membership that never comes.
    */
   enableAnonymousLiveQueries?: boolean;
   /**

package/src/utils/surql.ts

@@ -120,10 +120,9 @@ export const surql: SurqlHelper = {
     return `UPSERT ONLY $${idVar} REPLACE $${dataVar}`;
   },
 
-  // Use this for sync-down ingestion: the remote payload omits local-only
-  // fields injected by the CLI's local-schema setup (`_00_crdt`,
-  // `_00_cursor`), and REPLACE would wipe them on every round-trip and
-  // break offline reload of CRDT state.
+  // Use this for sync-down ingestion: the remote payload can omit local-only
+  // fields injected by the CLI's local-schema setup, and REPLACE would wipe
+  // them on every round-trip.
   upsertMerge(idVar: string, dataVar: string) {
     return `UPSERT ONLY $${idVar} MERGE $${dataVar}`;
   },

package/src/modules/crdt/crdt-hydration.test.ts

@@ -1,210 +0,0 @@
-import { describe, it, expect, vi } from 'vitest';
-import { LoroDoc } from 'loro-crdt';
-import type { SchemaStructure } from '@spooky-sync/query-builder';
-import { CrdtManager } from './index';
-import type { LocalStore, RemoteDatabaseService } from '../../services/database/index';
-import type { Logger } from '../../services/logger/index';
-
-// Regression test for the offline-reload formatting-loss class of bug.
-//
-// Repro pattern: app uses `store: 'memory'` for the local SurrealDB (or
-// any scenario where the local row exists without a CRDT snapshot —
-// fresh device, post-sync-down with stale meta, …). On reload, the
-// editor mounts but stays empty until some unrelated edit fires the
-// parent LIVE feed. From the user's POV, formatting is gone.
-//
-// Fix: when `CrdtManager.open` finds no local snapshot, it must fetch
-// the parent row from remote (the snapshot lives inline on the row in
-// the consolidated design) and dispatch its CRDT field. This test pins
-// that behavior across both shapes — `@crdt`-only fields where the
-// snapshot IS the field value, and `@crdt @cursor` fields where the
-// snapshot lives at `<field>.state`.
-
-function silentLogger(): Logger {
-  const noop = () => {};
-  const fake: any = {};
-  fake.info = noop;
-  fake.warn = noop;
-  fake.debug = noop;
-  fake.error = noop;
-  fake.trace = noop;
-  fake.child = () => fake;
-  return fake as Logger;
-}
-
-function singleTableSchema(opts: { cursor?: boolean } = {}): SchemaStructure {
-  return {
-    tables: [
-      {
-        name: 'thread',
-        columns: {
-          body: {
-            type: 'string',
-            optional: false,
-            crdt: 'text',
-            ...(opts.cursor ? { cursor: true } : {}),
-          },
-        },
-        primaryKey: ['id'],
-      },
-    ],
-    relationships: [],
-    backends: {},
-  };
-}
-
-function buildSnapshot(text: string): Uint8Array {
-  const doc = new LoroDoc();
-  doc.getText('text').insert(0, text);
-  return doc.export({ mode: 'snapshot' });
-}
-
-function makeRemote(handlers: {
-  selectRow?: () => unknown;
-}): RemoteDatabaseService {
-  const remote = {
-    query: vi.fn().mockImplementation(async (sql: string) => {
-      if (sql.includes('LIVE SELECT')) return ['live-uuid'];
-      if (sql.includes('SELECT * FROM ONLY')) {
-        return [handlers.selectRow ? handlers.selectRow() : null];
-      }
-      return [];
-    }),
-    getClient: () =>
-      ({
-        liveOf: async () => ({
-          subscribe: () => () => {},
-        }),
-      }) as any,
-    // CrdtManager watches transport events so it can re-issue table LIVEs after
-    // a reconnect. These tests never drop the socket, so a no-op is enough.
-    getStatus: () => 'connected' as const,
-    subscribeConnection: vi.fn().mockReturnValue(() => {}),
-  } satisfies Partial<RemoteDatabaseService> as unknown as RemoteDatabaseService;
-  return remote;
-}
-
-describe('CrdtManager.open hydration', () => {
-  it('@crdt-only: fetches the parent row from remote when local is empty', async () => {
-    const remoteSnapshot = buildSnapshot('hello world');
-
-    const local = {
-      query: vi.fn().mockImplementation(async (sql: string) => {
-        if (sql.includes('SELECT VALUE body FROM ONLY')) return [null];
-        return [];
-      }),
-    } satisfies Partial<LocalStore> as unknown as LocalStore;
-
-    const remote = makeRemote({
-      selectRow: () => ({ id: 'thread:abc', body: remoteSnapshot }),
-    });
-
-    const manager = new CrdtManager(singleTableSchema(), local, remote, silentLogger());
-    manager.setSessionId('session-under-test');
-
-    const field = await manager.open('thread', 'thread:abc', 'body');
-
-    await vi.waitFor(() => {
-      expect(field.getDoc().getText('text').toString()).toBe('hello world');
-    });
-
-    const sqls = (remote.query as ReturnType<typeof vi.fn>).mock.calls.map(
-      (c) => c[0] as string
-    );
-    expect(sqls.some((s) => s.includes('SELECT * FROM ONLY'))).toBe(true);
-  });
-
-  it('@crdt @cursor: extracts the snapshot from the object shape', async () => {
-    const remoteSnapshot = buildSnapshot('object shape');
-
-    const local = {
-      query: vi.fn().mockImplementation(async () => [null]),
-    } satisfies Partial<LocalStore> as unknown as LocalStore;
-
-    // Cursor-enabled field stores `{ state, cursors }`. The remote row
-    // returns this shape; the manager must drill into `.state` for the
-    // snapshot bytes.
-    const remote = makeRemote({
-      selectRow: () => ({
-        id: 'thread:abc',
-        body: { state: remoteSnapshot, cursors: {} },
-      }),
-    });
-
-    const manager = new CrdtManager(
-      singleTableSchema({ cursor: true }),
-      local,
-      remote,
-      silentLogger()
-    );
-    manager.setSessionId('session-under-test');
-
-    const field = await manager.open('thread', 'thread:abc', 'body');
-
-    await vi.waitFor(() => {
-      expect(field.getDoc().getText('text').toString()).toBe('object shape');
-    });
-  });
-
-  it('skips the remote fetch when a local snapshot already exists', async () => {
-    const localSnapshot = buildSnapshot('cached');
-
-    const local = {
-      query: vi.fn().mockImplementation(async (sql: string) => {
-        if (sql.includes('SELECT VALUE body FROM ONLY')) return [localSnapshot];
-        return [];
-      }),
-    } satisfies Partial<LocalStore> as unknown as LocalStore;
-
-    const remote = makeRemote({});
-
-    const manager = new CrdtManager(singleTableSchema(), local, remote, silentLogger());
-    manager.setSessionId('session-under-test');
-
-    const field = await manager.open('thread', 'thread:def', 'body');
-
-    expect(field.getDoc().getText('text').toString()).toBe('cached');
-
-    // Give any stray async work a tick to land before asserting absence.
-    await new Promise((r) => setTimeout(r, 20));
-
-    const sqls = (remote.query as ReturnType<typeof vi.fn>).mock.calls.map(
-      (c) => c[0] as string
-    );
-    expect(sqls.some((s) => s.includes('SELECT * FROM ONLY'))).toBe(false);
-  });
-
-  // Regression: SurrealDB returns bytes nested inside a FLEXIBLE object as a
-  // plain `number[]` from the local WASM engine (e.g. `state: [108, 111, 114,
-  // 111, ...]` — the literal LoroDoc magic header bytes). The cursor-enabled
-  // extractSnapshot path used to only accept Uint8Array and would silently
-  // return undefined for the array form, leaving every editor empty and
-  // killing realtime updates for `@crdt @cursor` fields.
-  it('@crdt @cursor: accepts number[] as the state shape (local WASM transport)', async () => {
-    const remoteSnapshot = buildSnapshot('from local wasm');
-    const remoteAsArray = Array.from(remoteSnapshot) as unknown as number[];
-
-    const local = {
-      query: vi.fn().mockImplementation(async (sql: string) => {
-        if (sql.includes('SELECT VALUE body FROM ONLY')) {
-          return [{ state: remoteAsArray, cursors: {} }];
-        }
-        return [];
-      }),
-    } satisfies Partial<LocalStore> as unknown as LocalStore;
-
-    const remote = makeRemote({});
-
-    const manager = new CrdtManager(
-      singleTableSchema({ cursor: true }),
-      local,
-      remote,
-      silentLogger()
-    );
-    manager.setSessionId('session-under-test');
-
-    const field = await manager.open('thread', 'thread:wasm', 'body');
-
-    expect(field.getDoc().getText('text').toString()).toBe('from local wasm');
-  });
-});

package/src/modules/crdt/crdt-reconnect.test.ts

@@ -1,195 +0,0 @@
-import { describe, it, expect, vi } from 'vitest';
-import type { SchemaStructure } from '@spooky-sync/query-builder';
-import { CrdtManager } from './index';
-import type { LocalStore, RemoteDatabaseService } from '../../services/database/index';
-import type { Logger } from '../../services/logger/index';
-
-// A LIVE subscription lives and dies with its WebSocket session, and
-// `ensureTableSubscription` is memoized on `liveByTable`. Without a reconnect
-// hook, the first dropped socket kills CRDT realtime for good: the map still
-// holds a uuid for a subscription the server has forgotten, so every later
-// `open()` short-circuits and no LIVE is ever re-issued.
-
-const noop = () => {};
-
-/** A promise plus its resolver, so a test can hold an RPC open on demand. */
-function deferred<T>(): { promise: Promise<T>; resolve: (v: T) => void } {
-  let resolve!: (v: T) => void;
-  const promise = new Promise<T>((r) => {
-    resolve = r;
-  });
-  return { promise, resolve };
-}
-
-function silentLogger(): Logger {
-  const fake: any = {};
-  fake.info = noop;
-  fake.warn = noop;
-  fake.debug = noop;
-  fake.error = noop;
-  fake.trace = noop;
-  fake.child = () => fake;
-  return fake as Logger;
-}
-
-function singleTableSchema(): SchemaStructure {
-  return {
-    tables: [
-      {
-        name: 'thread',
-        columns: { body: { type: 'string', optional: false, crdt: 'text' } },
-        primaryKey: ['id'],
-      },
-    ],
-    relationships: [],
-    backends: {},
-  };
-}
-
-function makeRemote() {
-  const handlers = new Map<string, Array<(...a: any[]) => void>>();
-  const remote = {
-    query: vi.fn().mockImplementation(async (sql: string) => {
-      if (sql.includes('LIVE SELECT')) return ['live-uuid'];
-      if (sql.includes('SELECT * FROM ONLY')) return [null];
-      return [];
-    }),
-    getClient: () =>
-      ({ liveOf: async () => ({ subscribe: () => () => {} }) }) as any,
-    getStatus: () => 'connected' as const,
-    subscribeConnection: (event: string, cb: (...a: any[]) => void) => {
-      handlers.set(event, [...(handlers.get(event) ?? []), cb]);
-      return () => {
-        handlers.set(event, (handlers.get(event) ?? []).filter((h) => h !== cb));
-      };
-    },
-  } satisfies Partial<RemoteDatabaseService> as unknown as RemoteDatabaseService;
-  const emit = (event: string) => {
-    for (const cb of Array.from(handlers.get(event) ?? [])) cb();
-  };
-  return { remote, emit };
-}
-
-function makeLocal(): LocalStore {
-  return {
-    query: vi.fn().mockResolvedValue([null]),
-  } satisfies Partial<LocalStore> as unknown as LocalStore;
-}
-
-const liveSelects = (remote: RemoteDatabaseService) =>
-  (remote.query as ReturnType<typeof vi.fn>).mock.calls
-    .map((c) => c[0] as string)
-    .filter((s) => s.includes('LIVE SELECT'));
-
-describe('CrdtManager reconnect', () => {
-  it('re-issues the table LIVE after a recovered drop', async () => {
-    const { remote, emit } = makeRemote();
-    const manager = new CrdtManager(singleTableSchema(), makeLocal(), remote, silentLogger());
-    manager.setSessionId('s1');
-
-    await manager.open('thread', 'thread:abc', 'body');
-    await vi.waitFor(() => expect(liveSelects(remote)).toHaveLength(1));
-
-    // The SDK's own reconnect path: `reconnecting` then `connected`, never
-    // `disconnected`.
-    emit('reconnecting');
-    emit('connected');
-
-    await vi.waitFor(() => expect(liveSelects(remote)).toHaveLength(2));
-    // No KILL: that uuid belonged to a session that no longer exists.
-    const sqls = (remote.query as ReturnType<typeof vi.fn>).mock.calls.map((c) => c[0] as string);
-    expect(sqls.some((s) => s.includes('KILL'))).toBe(false);
-  });
-
-  it('re-issues the table LIVE after the SDK gives up', async () => {
-    const { remote, emit } = makeRemote();
-    const manager = new CrdtManager(singleTableSchema(), makeLocal(), remote, silentLogger());
-    manager.setSessionId('s1');
-
-    await manager.open('thread', 'thread:abc', 'body');
-    await vi.waitFor(() => expect(liveSelects(remote)).toHaveLength(1));
-
-    emit('disconnected');
-    emit('connected');
-
-    await vi.waitFor(() => expect(liveSelects(remote)).toHaveLength(2));
-  });
-
-  it('does not resurrect a LIVE for a table whose fields were all closed', async () => {
-    const { remote, emit } = makeRemote();
-    const manager = new CrdtManager(singleTableSchema(), makeLocal(), remote, silentLogger());
-    manager.setSessionId('s1');
-
-    await manager.open('thread', 'thread:abc', 'body');
-    await vi.waitFor(() => expect(liveSelects(remote)).toHaveLength(1));
-
-    // A drop can outlive the editor that needed the feed.
-    emit('reconnecting');
-    manager.close('thread', 'thread:abc', 'body');
-    emit('connected');
-
-    await new Promise((r) => setTimeout(r, 10));
-    expect(liveSelects(remote)).toHaveLength(1);
-  });
-
-  it('discards and re-registers a LIVE that was mid-flight when the socket dropped', async () => {
-    const handlers = new Map<string, Array<() => void>>();
-    const firstLive = deferred<void>();
-    let liveCalls = 0;
-    const remote = {
-      query: vi.fn().mockImplementation(async (sql: string) => {
-        if (sql.includes('LIVE SELECT')) {
-          liveCalls++;
-          // Hold the FIRST registration open so the drop lands mid-flight.
-          if (liveCalls === 1) {
-            await firstLive.promise;
-            return ['dead-session-uuid'];
-          }
-          return ['fresh-uuid'];
-        }
-        return [null];
-      }),
-      getClient: () => ({ liveOf: async () => ({ subscribe: () => () => {} }) }) as any,
-      getStatus: () => 'connected' as const,
-      subscribeConnection: (event: string, cb: () => void) => {
-        handlers.set(event, [...(handlers.get(event) ?? []), cb]);
-        return () => {};
-      },
-    } satisfies Partial<RemoteDatabaseService> as unknown as RemoteDatabaseService;
-    const emit = (event: string) => {
-      for (const cb of Array.from(handlers.get(event) ?? [])) cb();
-    };
-
-    const manager = new CrdtManager(singleTableSchema(), makeLocal(), remote, silentLogger());
-    manager.setSessionId('s1');
-    await manager.open('thread', 'thread:abc', 'body');
-    await vi.waitFor(() => expect(liveCalls).toBe(1));
-
-    // Drop + recover while the first registration is still awaiting its uuid.
-    emit('reconnecting');
-    emit('connected');
-    firstLive.resolve();
-
-    // The doomed uuid must never be recorded — if it were, `liveByTable` would
-    // short-circuit every future restart and CRDT realtime would be dead for
-    // good. A fresh registration must take its place.
-    await vi.waitFor(() => expect(liveCalls).toBe(2));
-    expect((manager as any).liveByTable.get('thread')).toBe('fresh-uuid');
-  });
-
-  it('stops reacting to transport events after dispose', async () => {
-    const { remote, emit } = makeRemote();
-    const manager = new CrdtManager(singleTableSchema(), makeLocal(), remote, silentLogger());
-    manager.setSessionId('s1');
-
-    await manager.open('thread', 'thread:abc', 'body');
-    await vi.waitFor(() => expect(liveSelects(remote)).toHaveLength(1));
-
-    manager.dispose();
-    emit('reconnecting');
-    emit('connected');
-
-    await new Promise((r) => setTimeout(r, 10));
-    expect(liveSelects(remote)).toHaveLength(1);
-  });
-});