@spooky-sync/core 0.0.1-canary.283 → 0.0.1-canary.287

package/dist/sqlite-open.js

@@ -182,6 +182,33 @@ function serializeRow(row) {
 		return v;
 	});
 }
+/**
+* Serialize a MERGE row ONCE for both halves of the merge upsert: the row a
+* fresh INSERT stores and the RFC 7396 delta `json_patch` applies on conflict.
+*
+* A top-level own key holding `undefined` means "clear this field", which is
+* what SurrealDB's MERGE does with it (the SDK sends it as NONE). JSON drops
+* such a key, so a patch built by {@link serializeRow} alone never mentioned
+* it and the stored value survived every merge: a field cleared on the server
+* stayed set locally. The patch therefore carries each one as a `null` member,
+* which `json_patch` removes; the insert row simply lacks it, exactly as
+* before. Appended to the already-serialized text, so the common case costs no
+* second stringify. Nested `undefined` stays dropped (never a clear here).
+*/
+function serializeMergeRow(row) {
+	const insert = serializeRow(row);
+	const cleared = [];
+	for (const key of Object.keys(row)) if (row[key] === void 0) cleared.push(`${JSON.stringify(key)}:null`);
+	if (cleared.length === 0 || insert[0] !== "{") return {
+		insert,
+		patch: insert
+	};
+	const members = cleared.join(",");
+	return {
+		insert,
+		patch: insert === "{}" ? `{${members}}` : `${insert.slice(0, -1)},${members}}`
+	};
+}
 function reviveRow(json) {
 	if (json.indexOf("\"__u8\"") === -1) return JSON.parse(json);
 	return JSON.parse(json, (_k, v) => {
@@ -328,4 +355,4 @@ async function openDb(sqlite3, dbName, useOpfs, opts = {}) {
 }
 
 //#endregion
-export { renderOrderSql as a, serializeRow as c, projectedDataSql as i, resolveRelations as l, openDb as n, renderWhereSql as o, project as r, reviveRow as s, PROMOTION_OPEN_OPTIONS as t, stableKey as u };
+export { renderOrderSql as a, serializeMergeRow as c, stableKey as d, projectedDataSql as i, serializeRow as l, openDb as n, renderWhereSql as o, project as r, reviveRow as s, PROMOTION_OPEN_OPTIONS as t, resolveRelations as u };

package/dist/sqlite-worker.js

@@ -1,4 +1,4 @@
-import { a as renderOrderSql, i as projectedDataSql, l as resolveRelations, n as openDb, o as renderWhereSql, r as project, s as reviveRow, u as stableKey } from "./sqlite-open.js";
+import { a as renderOrderSql, d as stableKey, i as projectedDataSql, n as openDb, o as renderWhereSql, r as project, s as reviveRow, u as resolveRelations } from "./sqlite-open.js";
 import sqlite3InitModule from "@sqlite.org/sqlite-wasm";
 
 //#region src/services/database/sqlite-lock-verify.ts

package/dist/worker-edges.js

@@ -103,11 +103,19 @@ const surql = {
 const VIEW_TABLE = "_00_view";
 const LEGACY_VIEW_TABLE = "_00_window";
 const viewRecordId = (viewKey) => new RecordId(VIEW_TABLE, viewKey);
-const viewRow = (ids, confirmed, now) => ({
+/**
+* The durable `_00_view` row: the confirmed membership plus the subquery
+* children, which the GC must keep and a cold scan may paint as much as the
+* members.
+*/
+const viewRow = (ids, children, confirmed, now) => ({
 	ids,
+	children,
 	confirmed,
 	updatedAt: now
 });
+/** Every `_00_view` row: the durable view index and the GC read it. */
+const readViewRows = () => `SELECT * FROM ${VIEW_TABLE}`;
 /** Copy every legacy `_00_window` row into `_00_view` once. */
 const readLegacyViewRows = () => `SELECT * FROM ${LEGACY_VIEW_TABLE}`;
 const countViewRows = () => `SELECT count() FROM ${VIEW_TABLE} GROUP ALL`;
@@ -412,4 +420,4 @@ function rowOfEdge(value) {
 }
 
 //#endregion
-export { registerVars as A, heartbeatRowGone as C, queryRowCountSelect as D, queryRowCountBatchSelect as E, viewRow as F, surql as I, sha256Hex as L, subqueryListRefSelect as M, upsertBodiesTx as N, readLegacyViewRows as O, viewRecordId as P, queryHashInput as R, heartbeatBatch as S, listRefSelect as T, LEGACY_VIEW_TABLE as _, metaFromRow as a, bodySelect as b, parseDuration as c, parseQueryParams as d, ANON_USER_ID as f, sanitizeUserId as g, listRefTableFor as h, dedupeRecordVersions as i, singleSnapshotSelect as j, registerSelect as k, parseRecordIdString as l, bucketIdForUser as m, rowOfEdge as n, snapshotFromSingle as o, DEFAULT_REF_MODE as p, FAILED as r, encodeRecordId as s, hashOfEdge as t, withTimeout as u, VIEW_TABLE as v, listRefBatchSelect as w, countViewRows as x, batchSnapshotSelect as y, viewKeyInput as z };
+export { registerSelect as A, viewKeyInput as B, heartbeatRowGone as C, queryRowCountSelect as D, queryRowCountBatchSelect as E, viewRecordId as F, viewRow as I, surql as L, singleSnapshotSelect as M, subqueryListRefSelect as N, readLegacyViewRows as O, upsertBodiesTx as P, sha256Hex as R, heartbeatBatch as S, listRefSelect as T, LEGACY_VIEW_TABLE as _, metaFromRow as a, bodySelect as b, parseDuration as c, parseQueryParams as d, ANON_USER_ID as f, sanitizeUserId as g, listRefTableFor as h, dedupeRecordVersions as i, registerVars as j, readViewRows as k, parseRecordIdString as l, bucketIdForUser as m, rowOfEdge as n, snapshotFromSingle as o, DEFAULT_REF_MODE as p, FAILED as r, encodeRecordId as s, hashOfEdge as t, withTimeout as u, VIEW_TABLE as v, listRefBatchSelect as w, countViewRows as x, batchSnapshotSelect as y, queryHashInput as z };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@spooky-sync/core",
-  "version": "0.0.1-canary.283",
+  "version": "0.0.1-canary.287",
   "type": "module",
   "sideEffects": false,
   "main": "./dist/index.js",
@@ -75,8 +75,8 @@
     }
   },
   "dependencies": {
-    "@spooky-sync/query-builder": "0.0.1-canary.283",
-    "@spooky-sync/ssp-wasm": "0.0.1-canary.283",
+    "@spooky-sync/query-builder": "0.0.1-canary.287",
+    "@spooky-sync/ssp-wasm": "0.0.1-canary.287",
     "@sqlite.org/sqlite-wasm": "3.53.0-build1",
     "@surrealdb/wasm": "^3.0.3",
     "blurhash": "^2.0.5",

package/skills/sp00ky-core/SKILL.md

@@ -182,12 +182,15 @@ Backend runs let you trigger server-side HTTP operations via an **outbox pattern
 ### `db.run()` Signature
 
 ```typescript
-db.run<B extends BackendNames<S>, R extends BackendRoutes<S, B>>(
-  backend: B,        // Backend name from sp00ky.yml (e.g., 'api')
-  route: R,          // Route path from OpenAPI spec (e.g., '/spookify')
-  payload: RoutePayload<S, B, R>,  // Typed args for the route
-  options?: RunOptions
-): Promise<void>
+// A method of the client: called as `db.run(backend, route, payload, options)`.
+interface Sp00kyClient<S> {
+  run<B extends BackendNames<S>, R extends BackendRoutes<S, B>>(
+    backend: B, // Backend name from sp00ky.yml (e.g., 'api')
+    route: R, // Route path from OpenAPI spec (e.g., '/spookify')
+    payload: RoutePayload<S, B, R>, // Typed args for the route
+    options?: RunOptions
+  ): Promise<void>;
+}
 ```
 
 All parameters are type-safe — `backend`, `route`, and `payload` are inferred from the generated schema.

package/src/boot/boot.saga.test.ts

@@ -19,7 +19,11 @@ describe('boot', () => {
       'auth.access': () => 'account',
     });
     const out = await runPure(boot(env, { sharedTabs: false }), {
-      handlers: { service: svc.handler, 'local.query': (e: any) => (e.sql.startsWith('SELECT count()') ? [[{ count: 1 }]] : []) },
+      handlers: {
+        service: svc.handler,
+        'local.query': (e: any) =>
+          e.sql.startsWith('SELECT count()') ? [[{ count: 1 }]] : e.sql === 'SELECT * FROM _00_view' ? [[{ id: '_00_view:k', ids: [['t:1', 1]] }]] : [],
+      },
     });
     expect(svc.names()).toEqual([
       'hint.read',
@@ -39,7 +43,10 @@ describe('boot', () => {
     ]);
     expect(svc.calls[1]).toEqual(['local.connect', ['u1']]);
     expect(out.state).toMatchObject({ bucketId: 'u1', userId: 'user:u1', saltUserId: 'user:u1', sessionId: 'salt-1', localReady: true });
-    expect(out.dispatched.map((d) => d.type)).toEqual(['WarmBlobs', 'PrimeCircuit', 'LifecycleTick', 'GcTick', 'StartRemote']);
+    expect(out.dispatched.map((d) => d.type)).toEqual(['WarmBlobs', 'PrimeCircuit', 'LifecycleTick', 'StartRemote']);
+    // The view index is loaded before anything can paint; the first GC waits out the boot.
+    expect(out.state.views).toEqual(new Map([['k', ['t:1']]]));
+    expect(out.timers.get('gc')).toEqual({ ms: 30_000, event: { type: 'GcTick' } });
     expect(svc.names()).not.toContain('remote.connect');
   });
   it('shared tabs: takes the role from the coordinator, or falls back to solo; schemaless engines skip provisioning; anonymous skips session auth', async () => {

package/src/boot/boot.saga.ts

@@ -6,6 +6,8 @@ import { ANON_USER_ID } from '../modules/ref-tables';
 import type { SagaEnv } from '../query/env';
 import * as sql from '../query/sql';
 import { loadOutbox } from '../mutation/push.saga';
+import { loadViews } from '../query/lifecycle.saga';
+import { GC_BOOT_DELAY_MS } from '../kernel/constants';
 
 export interface BootOptions {
   /** A shared-tabs coordinator is available: ask it for a role instead of opening the store alone. */
@@ -34,6 +36,7 @@ export function* boot(env: SagaEnv, opts: BootOptions): Saga<void> {
   yield fx.state.update(R.setIdentity({ bucketId: bucket }));
   if ((yield fx.service('local.usesSurqlSchema')) as boolean) yield fx.service('migrator.provision');
   yield* migrateWindowToView();
+  yield* loadViews();
   yield fx.dispatch({ type: 'WarmBlobs' });
   yield fx.service('ssp.init');
   yield fx.service('ssp.setPermissions');
@@ -51,7 +54,7 @@ export function* boot(env: SagaEnv, opts: BootOptions): Saga<void> {
   yield fx.service('features.init');
   yield fx.service('releases.init');
   yield fx.dispatch({ type: 'LifecycleTick' });
-  yield fx.dispatch({ type: 'GcTick' });
+  yield fx.timer.set('gc', GC_BOOT_DELAY_MS, { type: 'GcTick' });
   yield fx.state.update(R.setIdentity({ localReady: true }));
   yield fx.dispatch({ type: 'StartRemote' });
 }

package/src/boot/bucket-switch.saga.ts

@@ -10,6 +10,7 @@ import type { SagaEnv } from '../query/env';
 import { queryHashInput } from '../query/hash';
 import { isResolvedBefore, parseViewRow } from '../query/membership';
 import * as sql from '../query/sql';
+import { loadViews } from '../query/lifecycle.saga';
 import { loadOutbox } from '../mutation/push.saga';
 
 export interface BucketSwitchOptions {
@@ -71,6 +72,7 @@ export function* bucketSwitch(env: SagaEnv, target: string, release: (() => void
       yield fx.emit({ type: 'log', level: 'warn', message: 'failed to re-persist the auth token', data: { error } });
     }
   }
+  yield* loadViews();
   yield* rebindQueries();
   yield* loadOutbox(env);
   yield fx.dispatch({ type: 'EnsureRegistered' });

package/src/client/runtime.test.ts

@@ -73,7 +73,10 @@ describe('Runtime lanes', () => {
 
 describe('Runtime state hooks', () => {
   it('dirty queries are materialized after the debounce, once per burst', async () => {
-    const { a, rt } = make({ local: { select: async () => [{ id: 'thing:1' }] } }, buildState([buildEntry({ def: { hash: 'q', plan: { table: 'thing' } as any } })]));
+    const { a, rt } = make(
+      { local: { select: async () => [{ id: 'thing:1' }] } },
+      buildState([buildEntry({ def: { hash: 'q', plan: { table: 'thing' } as any } })], R.reloadViews(new Map([['v', ['thing:1']]])))
+    );
     const seen: unknown[] = [];
     rt.subscribe('q', (rows) => seen.push(rows));
     rt.update(R.markDirty(['q']));

package/src/client/sp00ky-client.test.ts

@@ -49,7 +49,14 @@ describe('Sp00kyClient facade', () => {
   });
 
   it('queryRaw registers locally and returns the hash before any remote work; subscribers paint from the local store', async () => {
-    const { client, a } = makeClient({ local: { query: (async (sql: string) => (sql.startsWith('SELECT * FROM thing') ? [[{ id: 'thing:1' }]] : [])) as any } });
+    // Boot loads the view index: `thing:1` is vouched for, `thing:2` is an orphan and stays hidden.
+    const stored = (sql: string) =>
+      sql.startsWith('SELECT * FROM thing')
+        ? [[{ id: 'thing:1' }, { id: 'thing:2' }]]
+        : sql === 'SELECT * FROM _00_view'
+          ? [[{ id: '_00_view:k', ids: [['thing:1', 1]] }]]
+          : [];
+    const { client, a } = makeClient({ local: { query: (async (sql: string) => stored(sql)) as any } });
     await client.init();
     const hash = await client.queryRaw('SELECT * FROM thing', {}, '10m');
     expect(client.state.queries.get(hash)!.lifecycle.phase).toBe('cold');

package/src/kernel/constants.ts

@@ -48,8 +48,21 @@ export const AUTH_READY_RETRY_MS = 500;
 export const AUTH_READY_MAX_ATTEMPTS = 10;
 /** Heartbeat at this fraction of the shortest ttl in state. */
 export const TTL_HEARTBEAT_FRACTION = 0.5;
-/** Orphan body garbage collection cadence. */
-export const GC_INTERVAL_MS = 7 * 24 * 60 * 60 * 1000;
+/**
+ * Orphan body garbage collection: the first sweep waits this long after boot
+ * (off the first paint and the first sync round), then repeats on the interval.
+ */
+export const GC_BOOT_DELAY_MS = 30_000;
+export const GC_INTERVAL_MS = 60 * 60 * 1000;
+/** Ids deleted per GC step. */
+export const GC_CHUNK = 200;
+/**
+ * A `_00_view` row no query has resolved for this long stops vouching for its
+ * ids (the sweep deletes it, so its bodies can be collected). Each session
+ * that resolves a query rewrites its row, so this only retires query shapes
+ * the app no longer runs.
+ */
+export const VIEW_RETENTION_MS = 14 * 24 * 60 * 60 * 1000;
 /** Remote adapter slot limit. */
 export const REMOTE_CONCURRENCY = 16;
 /** Rolling telemetry sample window per query. */

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

@@ -4,7 +4,7 @@ import { runPure } from '../testing/run-pure';
 import { buildEntry, buildOutboxItem, buildState } from '../testing/build';
 import * as R from '../state/reducers';
 import { defaultEnv } from './env';
-import { fetchRows } from './fetch.saga';
+import { fetchRows, landChunk } from './fetch.saga';
 import type { StatementResult } from '../kernel/effects';
 
 const env = defaultEnv({ tables: [{ name: 'thing', columns: { a: {} } }] } as any);
@@ -154,3 +154,46 @@ describe('fetchRows', () => {
     expect(out.state.versions.get('thing:2')).toBe(1);
   });
 });
+
+describe('landChunk', () => {
+  const typed = defaultEnv({
+    tables: [
+      {
+        name: 'broadcast',
+        columns: {
+          title: { type: 'string', optional: false },
+          owner: { type: 'string', recordId: true, optional: false },
+          club: { type: 'string', recordId: true, optional: true },
+          note: { type: 'string', optional: true },
+        },
+      },
+    ],
+  } as any);
+
+  // `UPDATE broadcast:x UNSET club` leaves no `club` key in the body the server
+  // returns, and a MERGE that does not name it kept the stale local club.
+  it('names each optional column the body lacks as undefined so the MERGE clears it', async () => {
+    const rid = new RecordId('broadcast', 'x');
+    const out = await runPure(landChunk(typed, ['broadcast:x'], [{ id: rid, title: 't', note: 'n', _00_extra: 1 }], new Map([['broadcast:x', 4]]), buildState(), 3), {
+      handlers: { 'local.execute': () => undefined, 'ssp.ingest': () => undefined },
+    });
+    expect(out.result).toBe(true);
+    const exec = out.log.find((e) => e.kind === 'local.execute') as any;
+    expect(exec.query.sql).toContain('UPSERT ONLY $id0 MERGE $content0');
+    expect(exec.vars.content0).toStrictEqual({ club: undefined, title: 't', note: 'n', _00_extra: 1, _00_rv: 4 });
+    expect(Object.prototype.hasOwnProperty.call(exec.vars.content0, 'club')).toBe(true);
+    // A required column (`owner`) is never cleared: its absence means hidden, not unset.
+    expect(Object.prototype.hasOwnProperty.call(exec.vars.content0, 'owner')).toBe(false);
+    // The circuit record carries no clear: CREATE/UPDATE replace the circuit row.
+    const ingest = out.log.find((e) => e.kind === 'ssp.ingest') as any;
+    expect(ingest.records[0].record).toStrictEqual({ id: rid, title: 't', note: 'n', _00_extra: 1, _00_rv: 4 });
+  });
+
+  it('names nothing for a table without a schema', async () => {
+    const out = await runPure(landChunk(typed, ['other:1'], [{ id: new RecordId('other', '1'), z: 1 }], new Map([['other:1', 1]]), buildState(), 0), {
+      handlers: { 'local.execute': () => undefined, 'ssp.ingest': () => undefined },
+    });
+    const exec = out.log.find((e) => e.kind === 'local.execute') as any;
+    expect(exec.vars.content0).toStrictEqual({ z: 1, _00_rv: 1 });
+  });
+});

package/src/query/fetch.saga.ts

@@ -8,7 +8,7 @@ import type { ClientState } from '../state/client-state';
 import * as R from '../state/reducers';
 import { planFetch } from '../state/selectors';
 import { encodeRecordId, parseRecordIdString } from '../utils/index';
-import { cleanRecord } from '../utils/parser';
+import { absentOptionalColumns, cleanRecord } from '../utils/parser';
 import type { SagaEnv } from './env';
 import * as sql from './sql';
 
@@ -87,7 +87,12 @@ export function* landChunk(
     const columns = env.schema.tables.find((t) => t.name === table)?.columns;
     const cleaned = columns ? cleanRecord(columns, row) : row;
     const { id: _id, ...content } = cleaned;
-    bodies.push({ id: rid, content: { ...content, _00_rv: version } });
+    // The row is the server's whole body, so an optional column it lacks was
+    // cleared upstream: name it (as `undefined`) so the MERGE removes the local
+    // copy instead of keeping it. `_00_*` local bookkeeping is never named, so
+    // MERGE (not REPLACE) still preserves it. The circuit record below needs no
+    // such key: CREATE/UPDATE replace the circuit's row outright.
+    bodies.push({ id: rid, content: { ...absentOptionalColumns(columns, row), ...content, _00_rv: version } });
     ingest.push({ table, op: state.versions.has(id) ? 'UPDATE' : 'CREATE', id, record: { ...cleaned, _00_rv: version } });
     seen.add(id);
   }

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

@@ -4,7 +4,7 @@ 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 } from './lifecycle.saga';
+import { ackPrune, evictQuery, gcTick, lifecycleTick, loadViews } from './lifecycle.saga';
 import type { StatementResult } from '../kernel/effects';
 
 const env = defaultEnv({ tables: [] } as any);
@@ -75,31 +75,158 @@ describe('ackPrune', () => {
   });
 });
 
+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', () => {
-  it('deletes bodies no view names and no outbox item touches; keeps _00_ rows; reschedules', async () => {
+  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(
-      [],
-      R.setVersions([['thing:keep', 1], ['thing:gone', 1], ['thing:pending', 1], ['_00_view:x', 1], ['thing:failed', 1]]),
+      [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 deleted: string[] = [];
+    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': () => [[{ ids: [['thing:keep', 1]] }, { ids: 'bad' }]],
+        'local.query': (e: any) => {
+          expect(e.sql).toBe('SELECT * FROM _00_view');
+          return [rows];
+        },
         'local.delete': (e: any) => {
-          deleted.push(e.id);
-          if (e.id === 'thing:failed') throw new Error('busy');
+          if (e.id === 'thing:failed' || e.id?.id === 'stuck') throw new Error('busy');
         },
         'ssp.ingest': () => undefined,
       },
     });
-    expect(deleted).toEqual(['thing:gone', 'thing:failed']);
-    expect([...out.state.versions.keys()]).toEqual(['thing:keep', 'thing:pending', '_00_view:x', 'thing:failed']);
+    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:gone', record: {} }]);
-    expect(out.timers.get('gc')!.event).toEqual({ type: 'GcTick' });
-    const failing = await runPure(gcTick(), {
+    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': () => {
@@ -107,10 +234,35 @@ describe('gcTick', () => {
         },
       },
     });
-    expect(failing.emitted).toEqual([expect.objectContaining({ message: 'orphan gc failed' })]);
-    expect(failing.timers.has('gc')).toBe(true);
-    const nothing = await runPure(gcTick(), { state: buildState(), handlers: { 'local.query': () => [] } });
-    expect(nothing.log.filter((e) => e.kind === 'ssp.ingest')).toHaveLength(0);
+    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([]);
   });
 });