@spooky-sync/core 0.0.1-canary.29 → 0.0.1-canary.291

package/src/query/id-set-plan.test.ts

@@ -0,0 +1,132 @@
+import { describe, it, expect } from 'vitest';
+import type { QueryPlan } from '@spooky-sync/query-builder';
+import { buildIdSetPlan, buildIdSetSurql, buildWindowMaterializationPlan } from './window-query';
+import { executeSelect, type SelectDb } from '../services/database/sqlite-select';
+import type { Row } from '../services/database/cache-engine';
+
+describe('buildWindowMaterializationPlan', () => {
+  it('returns null without an offset and an id-set plan with one', () => {
+    const plan: QueryPlan = { table: 't', where: [{ field: 'a', op: '=', value: 1 } as any], limit: 5 };
+    expect(buildWindowMaterializationPlan(plan, ['t:1'])).toBeNull();
+    expect(buildWindowMaterializationPlan({ ...plan, offset: 0 }, ['t:1'])).toBeNull();
+    const win = buildWindowMaterializationPlan({ ...plan, offset: 5 }, ['t:1']);
+    expect(win).toMatchObject({ ids: ['t:1'], where: undefined, limit: undefined, offset: undefined });
+  });
+});
+
+// `buildIdSetPlan` is what makes membership-authoritative rendering possible on
+// any local engine: it turns a query's plan into "these exact ids, ordered,
+// relations intact". Dropping `where` is the point — re-applying the predicate
+// against stale local bodies is what let removed rows keep rendering.
+
+const BASE: QueryPlan = {
+  table: 'thread',
+  where: [{ field: 'done', op: '=', value: false }],
+  limit: 50,
+  offset: 0,
+  orderBy: [['title', 'asc']],
+  relations: [
+    { alias: 'comments', table: 'comment', cardinality: 'many', foreignKeyField: 'thread' },
+  ],
+} as any;
+
+describe('buildIdSetPlan', () => {
+  it('binds the id-set and drops where/limit/offset, keeping orderBy + relations', () => {
+    const out = buildIdSetPlan(BASE, ['thread:A']);
+    expect(out.ids).toEqual(['thread:A']);
+    expect(out.where).toBeUndefined();
+    expect(out.limit).toBeUndefined();
+    expect(out.offset).toBeUndefined();
+    expect(out.orderBy).toEqual([['title', 'asc']]);
+    expect(out.relations).toEqual(BASE.relations);
+    expect(out.table).toBe('thread');
+  });
+
+  it('applies to non-offset plans, unlike the windowed-only helper', () => {
+    // The windowed helper deliberately bails so the old caller kept its scan;
+    // membership rendering needs the same rewrite for every query.
+    expect(buildWindowMaterializationPlan(BASE, ['thread:A'])).toBeNull();
+    expect(buildIdSetPlan(BASE, ['thread:A']).ids).toEqual(['thread:A']);
+  });
+
+  it('does not mutate the input plan', () => {
+    buildIdSetPlan(BASE, ['thread:A']);
+    expect(BASE.where).toEqual([{ field: 'done', op: '=', value: false }]);
+    expect(BASE.limit).toBe(50);
+  });
+});
+
+describe('buildIdSetSurql', () => {
+  it('rewrites a non-offset query to the id-set source, keeping ORDER BY', () => {
+    const out = buildIdSetSurql('SELECT * FROM thread WHERE done = false ORDER BY title ASC LIMIT 50;');
+    expect(out?.query).toBe('SELECT * FROM $__win ORDER BY title ASC');
+  });
+
+  it('preserves the projection', () => {
+    const out = buildIdSetSurql('SELECT id, title FROM thread WHERE done = false;');
+    expect(out?.query).toBe('SELECT id, title FROM $__win');
+  });
+
+  it('returns null when there is no top-level FROM to replace', () => {
+    expect(buildIdSetSurql('RETURN true;')).toBeNull();
+  });
+});
+
+// ---- Engine parity -------------------------------------------------------
+//
+// Both local engines short-circuit to `selectByIds` when `plan.ids` is set. This
+// pins that the id-set plan really does filter AND still resolves `.related()`
+// on the SQLite engine (the `where`-dropping path the SurrealDB engine shares).
+
+const FIXTURE: Record<string, Row[]> = {
+  thread: [
+    { id: 'thread:A', title: 'a thread', done: false },
+    { id: 'thread:B', title: 'b thread', done: false },
+  ],
+  comment: [
+    { id: 'comment:1', thread: 'thread:A', body: 'on A' },
+    { id: 'comment:2', thread: 'thread:B', body: 'on B' },
+  ],
+};
+
+function makeSelectDb(): SelectDb {
+  const respond = (sql: string, bind: unknown[] = []): { data: string }[] => {
+    const table = /FROM "([^"]+)"/.exec(sql)?.[1];
+    let rows = table ? (FIXTURE[table] ?? []) : [];
+    const rel = /WHERE json_extract\(data, '\$\.([A-Za-z0-9_.]+)'\) IN/.exec(sql);
+    if (rel) rows = rows.filter((r) => bind.includes(r[rel[1]]));
+    else if (/WHERE id IN/.test(sql)) rows = rows.filter((r) => bind.includes(r.id));
+    return rows.map((r) => ({ data: JSON.stringify(r) }));
+  };
+  return {
+    exec: (sql, bind) => respond(sql, bind ?? []),
+    run: () => {},
+    knownTables: new Set<string>(),
+  };
+}
+
+describe('id-set plan on the SQLite engine', () => {
+  it('returns only the id-set even though both bodies match the predicate', async () => {
+    const { rows } = await executeSelect(
+      buildIdSetPlan(BASE, ['thread:A']),
+      {},
+      makeSelectDb()
+    );
+    expect(rows.map((r) => r.id)).toEqual(['thread:A']);
+  });
+
+  it('still resolves .related() children for the id-set rows', async () => {
+    const { rows, relationFetches } = await executeSelect(
+      buildIdSetPlan(BASE, ['thread:A']),
+      {},
+      makeSelectDb()
+    );
+    expect(relationFetches).toBe(1);
+    expect((rows[0] as any).comments.map((c: Row) => c.id)).toEqual(['comment:1']);
+  });
+
+  it('renders nothing for an empty id-set (known-and-empty membership)', async () => {
+    const { rows } = await executeSelect(buildIdSetPlan(BASE, []), {}, makeSelectDb());
+    expect(rows).toEqual([]);
+  });
+});

package/src/query/lifecycle.saga.test.ts

@@ -0,0 +1,274 @@
+import { describe, expect, it } from 'vitest';
+import { RecordId } from 'surrealdb';
+import { runPure } from '../testing/run-pure';
+import { buildEntry, buildOutboxItem, buildState } from '../testing/build';
+import * as R from '../state/reducers';
+import { defaultEnv } from './env';
+import { ackPrune, evictQuery, gcTick, lifecycleTick, loadViews } from './lifecycle.saga';
+import type { StatementResult } from '../kernel/effects';
+
+const env = defaultEnv({ tables: [] } as any);
+const ok = (result: unknown): StatementResult => ({ status: 'OK', result });
+
+describe('lifecycleTick', () => {
+  it('evicts idle queries (even when the SSP unregister throws), heartbeats the registered rest, reschedules at half the shortest ttl', async () => {
+    const now = 1_700_000_000_000;
+    const s = buildState([
+      buildEntry({ def: { hash: 'idle', ttlMs: 100 }, lastSubscriberLeftAt: now - 200, lifecycle: { remote: 'registered' } }),
+      buildEntry({ def: { hash: 'idle2', ttlMs: 100 }, lastSubscriberLeftAt: now - 200 }),
+      buildEntry({ def: { hash: 'kept', ttlMs: 1000, id: new RecordId('_00_query', 'kept') }, subscribers: 1, lifecycle: { remote: 'registered' } }),
+      buildEntry({ def: { hash: 'unreg', ttlMs: 500 }, subscribers: 1 }),
+    ]);
+    let unregisters = 0;
+    const out = await runPure(lifecycleTick(env), {
+      state: s,
+      now,
+      handlers: {
+        'ssp.unregister': () => {
+          unregisters++;
+          if (unregisters === 1) throw new Error('gone');
+        },
+        'remote.query': (e: any) => {
+          expect(e.sql).toBe('fn::query::heartbeat($id0)');
+          expect(e.vars.id0).toEqual(new RecordId('_00_query', 'kept'));
+          return [ok([{ id: 'x' }])];
+        },
+      },
+    });
+    expect([...out.state.queries.keys()]).toEqual(['kept', 'unreg']);
+    expect(out.emitted.filter((e) => e.type === 'query:evicted')).toHaveLength(2);
+    expect(out.state.queries.get('kept')!.lastHeartbeatAt).toBe(now);
+    expect(out.dispatched).toEqual([{ type: 'SyncOutcome', ok: true }]);
+    expect(out.timers.get('lifecycle')).toEqual({ ms: 250, event: { type: 'LifecycleTick' } });
+  });
+  it('a reclaimed row drops the registration and re-registers; a failed beat reports; empty state uses the default ttl', async () => {
+    const s = buildState([buildEntry({ def: { hash: 'a' }, subscribers: 1, lifecycle: { remote: 'registered' } })]);
+    const reclaimed = await runPure(lifecycleTick(env), { state: s, handlers: { 'remote.query': () => [ok([])] } });
+    expect(reclaimed.state.queries.get('a')!.lifecycle.remote).toBe('unregistered');
+    expect(reclaimed.dispatched).toEqual([{ type: 'EnsureRegistered' }, { type: 'SyncOutcome', ok: true }]);
+    const failed = await runPure(lifecycleTick(env), {
+      state: s,
+      handlers: {
+        'remote.query': () => {
+          throw new Error('offline');
+        },
+      },
+    });
+    expect(failed.dispatched).toEqual([{ type: 'SyncOutcome', ok: false, error: new Error('offline') }]);
+    const empty = await runPure(lifecycleTick(env), { state: buildState() });
+    expect(empty.timers.get('lifecycle')!.ms).toBe(300_000);
+  });
+});
+
+describe('ackPrune', () => {
+  it('drops expired acked items and re-arms while some remain', async () => {
+    const now = 100_000;
+    const s = buildState([], R.outboxReplace([
+      buildOutboxItem({ id: 'old', status: 'acked', ackedAt: now - 31_000 }),
+      buildOutboxItem({ id: 'fresh', status: 'acked', ackedAt: now - 1000 }),
+    ]));
+    const out = await runPure(ackPrune(), { state: s, now });
+    expect(out.state.outbox.map((i) => i.id)).toEqual(['fresh']);
+    expect(out.timers.get('ack-prune')).toEqual({ ms: 30_000, event: { type: 'AckPrune' } });
+    const done = await runPure(ackPrune(), { state: out.state, now: now + 60_000 });
+    expect(done.timers.size).toBe(0);
+  });
+});
+
+describe('loadViews', () => {
+  it('fills the index from every _00_view row (members and children); a failed read leaves it empty', async () => {
+    const rows = [
+      { id: '_00_view:a', ids: [['t:1', 1]], children: [['c:1', 1], 'junk'] },
+      { id: new RecordId('_00_view', 'b'), ids: [] },
+      { id: '', ids: [] },
+      { ids: [['t:no-key', 1]] },
+      null,
+    ];
+    const out = await runPure(loadViews(), { state: buildState(), handlers: { 'local.query': () => [rows] } });
+    expect(out.state.views).toEqual(new Map([['a', ['t:1', 'c:1']], ['b', []]]));
+    const odd = await runPure(loadViews(), { state: buildState(), handlers: { 'local.query': () => undefined } });
+    expect(odd.state.views.size).toBe(0);
+    const failed = await runPure(loadViews(), {
+      state: buildState(),
+      handlers: {
+        'local.query': () => {
+          throw new Error('no table');
+        },
+      },
+    });
+    expect(failed.state.views.size).toBe(0);
+    expect(failed.emitted).toEqual([expect.objectContaining({ level: 'warn', message: 'view index read failed' })]);
+  });
+});
+
+describe('gcTick', () => {
+  const day = 24 * 60 * 60 * 1000;
+  const now = 100 * day;
+  const ready = R.setIdentity({ primed: true, bucketId: 'u1' });
+  const deletedIds = (log: Array<{ kind: string }>) =>
+    log.filter((e: any) => e.kind === 'local.delete').map((e: any) => (e.table === '_00_view' ? `view:${e.id.id}` : e.id));
+
+  it('retires stale view rows, deletes the bodies nothing retains from the store and the circuit, re-fetches, reschedules', async () => {
+    const s = buildState(
+      [buildEntry({ def: { hash: 'h', viewKey: 'held' }, lifecycle: { phase: 'cached' }, remoteArray: [['thing:mem', 1]] })],
+      ready,
+      R.setVersions(
+        ['thing:keep', 'child:1', 'thing:stale', 'thing:held', 'thing:stuck', 'thing:mem', 'thing:gone', 'thing:pending', '_00_view:x', 'thing:failed'].map(
+          (id) => [id, 1] as const
+        )
+      ),
+      R.outboxReplace([buildOutboxItem({ recordId: 'thing:pending' })])
+    );
+    const rows = [
+      { id: '_00_view:fresh', ids: [['thing:keep', 1]], children: [['child:1', 1]], updatedAt: now - day },
+      // Nobody resolved this query for 15 days: the row is retired and stops vouching.
+      { id: new RecordId('_00_view', 'old'), ids: [['thing:stale', 1]], updatedAt: now - 15 * day },
+      // As old, but a query in state holds it.
+      { id: '_00_view:held', ids: [['thing:held', 1]] },
+      // As old, but its delete fails: it keeps vouching.
+      { id: '_00_view:stuck', ids: [['thing:stuck', 1]], updatedAt: 0 },
+      { ids: 'bad' },
+    ];
+    const out = await runPure(gcTick(), {
+      state: s,
+      now,
+      handlers: {
+        'local.query': (e: any) => {
+          expect(e.sql).toBe('SELECT * FROM _00_view');
+          return [rows];
+        },
+        'local.delete': (e: any) => {
+          if (e.id === 'thing:failed' || e.id?.id === 'stuck') throw new Error('busy');
+        },
+        'ssp.ingest': () => undefined,
+      },
+    });
+    expect(deletedIds(out.log)).toEqual(['view:old', 'view:stuck', 'thing:stale', 'thing:gone', 'thing:failed']);
+    expect(out.state.views).toEqual(
+      new Map([
+        ['fresh', ['thing:keep', 'child:1']],
+        ['held', ['thing:held']],
+        ['stuck', ['thing:stuck']],
+      ])
+    );
+    expect([...out.state.versions.keys()]).toEqual(['thing:keep', 'child:1', 'thing:held', 'thing:stuck', 'thing:mem', 'thing:pending', '_00_view:x', 'thing:failed']);
+    const ingest = out.log.find((e) => e.kind === 'ssp.ingest') as any;
+    expect(ingest.records).toEqual([
+      { table: 'thing', op: 'DELETE', id: 'thing:stale', record: {} },
+      { table: 'thing', op: 'DELETE', id: 'thing:gone', record: {} },
+    ]);
+    // Solo: nobody to relay to.
+    expect(out.emitted.filter((e) => e.type === 'tabs:broadcast')).toEqual([]);
+    expect(out.emitted).toContainEqual(expect.objectContaining({ message: 'orphan gc done', data: { removed: 2, retiredViews: 1 } }));
+    expect(out.dispatched).toEqual([{ type: 'FetchRows' }]);
+    expect(out.timers.get('gc')).toEqual({ ms: 60 * 60 * 1000, event: { type: 'GcTick' } });
+  });
+
+  it('waits for the circuit prime (the versions); a leader relays its deletes to the other tabs', async () => {
+    const s = buildState([], R.setIdentity({ bucketId: 'u1' }), R.setTabRole('leader'), R.setVersions([['thing:gone', 1]]));
+    const out = await runPure(gcTick(), {
+      state: s,
+      handlers: {
+        'state.wait': (e: any, ctx) => {
+          expect(e.until(ctx.state)).toBe(false);
+          ctx.state = R.setIdentity({ primed: true })(ctx.state);
+        },
+        'local.query': () => [[]],
+        'local.delete': () => undefined,
+        'ssp.ingest': () => undefined,
+      },
+    });
+    expect(out.emitted).toContainEqual({
+      type: 'tabs:broadcast',
+      message: { type: 'ingest', records: [{ table: 'thing', op: 'DELETE', id: 'thing:gone', record: {} }] },
+    });
+  });
+
+  it('a follower only refreshes its index: no view row or body is deleted', async () => {
+    const s = buildState([], ready, R.setTabRole('follower'), R.setVersions([['thing:gone', 1]]));
+    const out = await runPure(gcTick(), {
+      state: s,
+      now,
+      handlers: { 'local.query': () => [[{ id: '_00_view:old', ids: [['thing:x', 1]], updatedAt: 0 }]] },
+    });
+    expect(out.state.views).toEqual(new Map([['old', ['thing:x']]]));
+    expect(deletedIds(out.log)).toEqual([]);
+    expect(out.state.versions.has('thing:gone')).toBe(true);
+    expect(out.timers.has('gc')).toBe(true);
+  });
+
+  it('each chunk is re-checked against fresh state, and the sweep stops when the bucket moves', async () => {
+    const ids = Array.from({ length: 250 }, (_, i) => `thing:o${i}`);
+    const s = buildState([], ready, R.setVersions(ids.map((id) => [id, 1] as const)));
+    const handlers = (onFirst: (ctx: any) => void) => ({
+      'local.query': () => [[]],
+      'local.delete': (e: any, ctx: any) => {
+        if (e.id === 'thing:o0') onFirst(ctx);
+      },
+      'ssp.ingest': () => undefined,
+    });
+    // Meanwhile a query commits o210 and o220's body goes another way: neither is deleted.
+    const recheck = await runPure(gcTick(), {
+      state: s,
+      handlers: handlers((ctx) => {
+        ctx.state = R.compose(R.putQuery(buildEntry({ def: { hash: 'q' }, remoteArray: [['thing:o210', 1]] })), R.deleteVersions(['thing:o220']))(ctx.state);
+      }),
+    });
+    const removed = deletedIds(recheck.log);
+    expect(removed).toHaveLength(248);
+    expect(removed).not.toContain('thing:o210');
+    expect(removed).not.toContain('thing:o220');
+    expect(recheck.log.filter((e) => e.kind === 'ssp.ingest')).toHaveLength(2);
+    const moved = await runPure(gcTick(), { state: s, handlers: handlers((ctx) => (ctx.state = R.setIdentity({ bucketId: 'u2' })(ctx.state))) });
+    expect(deletedIds(moved.log)).toHaveLength(200);
+    expect(moved.timers.has('gc')).toBe(true);
+  });
+
+  it('failures are logged and the tick still reschedules; a sweep that removes nothing asks for nothing', async () => {
+    const s = buildState([], ready, R.setVersions([['thing:gone', 1]]));
+    const readFails = await runPure(gcTick(), {
+      state: s,
+      handlers: {
+        'local.query': () => {
+          throw new Error('no table');
+        },
+      },
+    });
+    expect(readFails.emitted).toEqual([expect.objectContaining({ message: 'orphan gc failed' })]);
+    expect(readFails.timers.has('gc')).toBe(true);
+    const ingestFails = await runPure(gcTick(), {
+      state: s,
+      handlers: {
+        'local.query': () => [[]],
+        'local.delete': () => undefined,
+        'ssp.ingest': () => {
+          throw new Error('wasm');
+        },
+      },
+    });
+    expect(ingestFails.emitted).toEqual([expect.objectContaining({ message: 'orphan gc failed' })]);
+    expect(ingestFails.timers.has('gc')).toBe(true);
+    const deleteFails = await runPure(gcTick(), {
+      state: s,
+      handlers: {
+        'local.query': () => [[]],
+        'local.delete': () => {
+          throw new Error('busy');
+        },
+      },
+    });
+    expect(deleteFails.log.filter((e) => e.kind === 'ssp.ingest')).toHaveLength(0);
+    expect(deleteFails.dispatched).toEqual([]);
+    expect(deleteFails.emitted).toContainEqual(expect.objectContaining({ message: 'orphan gc done', data: { removed: 0, retiredViews: 0 } }));
+    const nothing = await runPure(gcTick(), { state: buildState([], ready), handlers: { 'local.query': () => [] } });
+    expect(nothing.log.filter((e) => e.kind === 'local.delete')).toHaveLength(0);
+    expect(nothing.dispatched).toEqual([]);
+  });
+});
+
+describe('evictQuery', () => {
+  it('is a no-op for unknown hashes', async () => {
+    const out = await runPure(evictQuery('zz'), { state: buildState() });
+    expect(out.emitted).toEqual([]);
+  });
+});

package/src/query/lifecycle.saga.ts

@@ -0,0 +1,159 @@
+import type { Saga } from '../kernel/saga';
+import type { Settled, StatementResult } from '../kernel/effects';
+import { fx } from '../kernel/effects';
+import { ACK_GRACE_MS, GC_CHUNK, GC_INTERVAL_MS, TTL_HEARTBEAT_FRACTION, VIEW_RETENTION_MS } from '../kernel/constants';
+import type { IngestRecord } from '../services/stream-processor/index';
+import type { ClientState, QueryEntry, TabRole } from '../state/client-state';
+import * as R from '../state/reducers';
+import { evictable, retained, shortestTtlMs } from '../state/selectors';
+import type { SagaEnv } from './env';
+import { parseViewIndex, type ViewIndexRow } from './membership';
+import * as sql from './sql';
+
+/**
+ * One tick for every query in state: evict the ones nobody has watched for a
+ * ttl, heartbeat the rest in one request, notice reclaimed rows. Reschedules
+ * itself at half the shortest ttl.
+ */
+export function* lifecycleTick(env: SagaEnv): Saga<void> {
+  const now = (yield fx.now()) as number;
+  const state = (yield fx.state.read((s) => s)) as ClientState;
+  for (const hash of evictable(state, now)) yield* evictQuery(hash);
+  const remaining = (yield fx.state.read((s) => [...s.queries.values()].filter((e) => e.lifecycle.remote === 'registered'))) as QueryEntry[];
+  if (remaining.length > 0) {
+    const beat = sql.heartbeatBatch(remaining.map((e) => e.def.id));
+    try {
+      const results = (yield fx.remote.query(beat.sql, beat.vars, env.remoteTimeoutMs)) as StatementResult[];
+      let reclaimed = 0;
+      for (let i = 0; i < remaining.length; i++) {
+        const r = results[i];
+        if (r?.status === 'OK' && sql.heartbeatRowGone(r.result)) {
+          reclaimed++;
+          yield fx.state.update(R.applyLifecycle(remaining[i].def.hash, { type: 'remote-dropped' }));
+        }
+      }
+      yield fx.state.update(R.stampHeartbeat(remaining.map((e) => e.def.hash), now));
+      if (reclaimed > 0) {
+        yield fx.emit({ type: 'log', level: 'warn', message: 'query rows reclaimed by the server; re-registering', data: { reclaimed } });
+        yield fx.dispatch({ type: 'EnsureRegistered' });
+      }
+      yield fx.dispatch({ type: 'SyncOutcome', ok: true });
+    } catch (error) {
+      yield fx.dispatch({ type: 'SyncOutcome', ok: false, error });
+    }
+  }
+  const ttl = (yield fx.state.read((s) => shortestTtlMs(s))) as number | null;
+  yield fx.timer.set('lifecycle', Math.floor((ttl ?? env.defaultTtlMs) * TTL_HEARTBEAT_FRACTION), { type: 'LifecycleTick' });
+}
+
+/** Free a query's local view and forget it. The server row expires by TTL. */
+export function* evictQuery(hash: string): Saga<void> {
+  const exists = (yield fx.state.read((s) => s.queries.has(hash))) as boolean;
+  if (!exists) return;
+  try {
+    yield fx.ssp.unregister(hash);
+  } catch (error) {
+    yield fx.emit({ type: 'log', level: 'debug', message: 'unregister failed', data: { hash, error } });
+  }
+  yield fx.state.update(R.removeQuery(hash));
+  yield fx.emit({ type: 'query:evicted', hash });
+}
+
+/** Drop acked outbox items membership never named within the grace window. */
+export function* ackPrune(): Saga<void> {
+  const now = (yield fx.now()) as number;
+  yield fx.state.update(R.outboxPruneAcked(now, ACK_GRACE_MS));
+  const stillAcked = (yield fx.state.read((s) => s.outbox.some((i) => i.status === 'acked'))) as boolean;
+  if (stillAcked) yield fx.timer.set('ack-prune', ACK_GRACE_MS, { type: 'AckPrune' });
+}
+
+/** Every `_00_view` row, parsed. Throws when the read fails. */
+function* readViews(): Saga<ViewIndexRow[]> {
+  const res = (yield fx.local.query(sql.readViewRows())) as unknown[];
+  return parseViewIndex(Array.isArray(res) ? res[0] : undefined);
+}
+
+const indexOf = (rows: ViewIndexRow[]): Map<string, string[]> => new Map(rows.map((r) => [r.key, r.ids]));
+
+/**
+ * Load the durable view index (boot, bucket switch). A failed read leaves it
+ * empty, which fails closed: cold scans paint nothing until the server answers.
+ */
+export function* loadViews(): Saga<void> {
+  try {
+    yield fx.state.update(R.reloadViews(indexOf(yield* readViews())));
+  } catch (error) {
+    yield fx.emit({ type: 'log', level: 'warn', message: 'view index read failed', data: { error } });
+  }
+}
+
+const tableOf = (id: string): string => id.slice(0, id.indexOf(':'));
+
+/**
+ * Orphan collection, `GC_BOOT_DELAY_MS` after boot and then every
+ * `GC_INTERVAL_MS`. Re-reads every `_00_view` row into the index, retires the
+ * rows no query has resolved for `VIEW_RETENTION_MS`, then deletes the bodies
+ * nothing retains (see `retained`) from the store and the circuit, a chunk at
+ * a time. Only a leader or solo tab deletes, and a leader relays the deletes
+ * so followers drop the rows too; a follower only refreshes its index.
+ */
+export function* gcTick(): Saga<void> {
+  yield fx.state.wait((s) => s.primed);
+  try {
+    const rows = yield* readViews();
+    const [role, bucket, held] = (yield fx.state.read((s) => [
+      s.tabRole,
+      s.bucketId,
+      new Set([...s.queries.values()].map((e) => e.def.viewKey)),
+    ])) as [TabRole, string | null, Set<string>];
+    const now = (yield fx.now()) as number;
+    const expired = role === 'follower' ? [] : rows.filter((r) => !held.has(r.key) && now - r.updatedAt >= VIEW_RETENTION_MS);
+    const retired = new Set<string>();
+    for (let i = 0; i < expired.length; i += GC_CHUNK) {
+      const chunk = expired.slice(i, i + GC_CHUNK);
+      const settled = (yield fx.all(chunk.map((r) => fx.local.delete(sql.VIEW_TABLE, sql.viewRecordId(r.key))))) as Settled[];
+      chunk.forEach((r, j) => settled[j].ok && retired.add(r.key));
+    }
+    yield fx.state.update(R.reloadViews(indexOf(rows.filter((r) => !retired.has(r.key)))));
+    if (role === 'follower') return;
+    const removed = yield* collectOrphans(bucket, role === 'leader');
+    yield fx.emit({ type: 'log', level: 'info', message: 'orphan gc done', data: { removed, retiredViews: retired.size } });
+  } catch (error) {
+    yield fx.emit({ type: 'log', level: 'warn', message: 'orphan gc failed', data: { error } });
+  } finally {
+    yield fx.timer.set('gc', GC_INTERVAL_MS, { type: 'GcTick' });
+  }
+}
+
+/**
+ * Delete every body nothing retains, `GC_CHUNK` at a time. Each chunk is
+ * re-checked against fresh state (a membership committed meanwhile may name
+ * an id again) and the sweep stops if the bucket moved under it.
+ */
+function* collectOrphans(bucket: string | null, relay: boolean): Saga<number> {
+  const candidates = (yield fx.state.read((s) => {
+    const keep = retained(s);
+    return [...s.versions.keys()].filter((id) => !keep(id));
+  })) as string[];
+  let removed = 0;
+  for (let i = 0; i < candidates.length; i += GC_CHUNK) {
+    const chunk = (yield fx.state.read((s) => {
+      if (!s.primed || s.bucketId !== bucket) return null;
+      const keep = retained(s);
+      return candidates.slice(i, i + GC_CHUNK).filter((id) => s.versions.has(id) && !keep(id));
+    })) as string[] | null;
+    if (chunk === null) break;
+    const settled = (yield fx.all(chunk.map((id) => fx.local.delete(tableOf(id), id)))) as Settled[];
+    const done = chunk.filter((_, j) => settled[j].ok);
+    if (done.length === 0) continue;
+    const records: IngestRecord[] = done.map((id) => ({ table: tableOf(id), op: 'DELETE', id, record: {} }));
+    yield fx.state.update(R.deleteVersions(done));
+    yield fx.ssp.ingest(records);
+    if (relay) yield fx.emit({ type: 'tabs:broadcast', message: { type: 'ingest', records } });
+    removed += done.length;
+  }
+  // A query may have committed a deleted id between its chunk's check and the
+  // delete; with its version gone, the fetch plan pulls it back.
+  if (removed > 0) yield fx.dispatch({ type: 'FetchRows' });
+  return removed;
+}