@spooky-sync/core 0.0.1-canary.33 → 0.0.1-canary.331

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

@@ -0,0 +1,199 @@
+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 { fetchRows, landChunk } from './fetch.saga';
+import type { StatementResult } from '../kernel/effects';
+
+const env = defaultEnv({ tables: [{ name: 'thing', columns: { a: {} } }] } as any);
+const ok = (result: unknown): StatementResult => ({ status: 'OK', result });
+const live = { phase: 'live' } as const;
+const primed = (s: ReturnType<typeof buildState>) => ({ ...s, primed: true });
+
+describe('fetchRows', () => {
+  it('waits for the prime and returns on an empty plan (resetting the attempt counter)', async () => {
+    const s = R.patchSync({ fetchAttempts: 3 })(buildState());
+    const out = await runPure(fetchRows(env), { state: s, handlers: { 'state.wait': (_e, ctx) => void (ctx.state = { ...ctx.state, primed: true }) } });
+    expect(out.state.sync.fetchAttempts).toBe(0);
+    expect(out.log.filter((e) => e.kind === 'remote.query')).toHaveLength(0);
+  });
+
+  it('fetches the deduped set once, writes + ingests bodies, records versions, balances fetch depth', async () => {
+    const s = primed(
+      buildState(
+        [
+          buildEntry({ def: { hash: 'a' }, lifecycle: live, remoteArray: [['thing:1', 2], ['thing:2', 1]] }),
+          buildEntry({ def: { hash: 'b' }, lifecycle: live, remoteArray: [['thing:2', 1], ['thing:3', 1]] }),
+        ],
+        R.setVersions([['thing:3', 1], ['thing:1', 1]]),
+        R.outboxReplace([buildOutboxItem({ type: 'delete', recordId: 'thing:2' })])
+      )
+    );
+    const depths: number[] = [];
+    const out = await runPure(fetchRows(env), {
+      state: s,
+      epoch: 7,
+      handlers: {
+        'remote.query': (e: any, ctx) => {
+          depths.push(ctx.state.queries.get('a')!.lifecycle.fetchDepth);
+          expect(e.sql).toBe('SELECT * FROM $ids');
+          expect(e.vars.ids).toEqual([new RecordId('thing', '1')]);
+          return [ok([{ id: new RecordId('thing', '1'), a: 'x', junk: true }])];
+        },
+        'local.execute': () => undefined,
+        'ssp.ingest': () => undefined,
+      },
+    });
+    expect(depths).toEqual([1]);
+    expect(out.state.queries.get('a')!.lifecycle.fetchDepth).toBe(0);
+    expect(out.state.versions.get('thing:1')).toBe(2);
+    const exec = out.log.find((e) => e.kind === 'local.execute') as any;
+    expect(exec.vars.content0).toEqual({ a: 'x', _00_rv: 2 });
+    expect(exec.epoch).toBe(7);
+    expect(out.log.findIndex((e) => e.kind === 'local.epoch')).toBeLessThan(out.log.findIndex((e) => e.kind === 'all'));
+    const ingest = out.log.find((e) => e.kind === 'ssp.ingest') as any;
+    expect(ingest.records).toEqual([{ table: 'thing', op: 'UPDATE', id: 'thing:1', record: { id: new RecordId('thing', '1'), a: 'x', _00_rv: 2 } }]);
+    expect(out.dispatched).toEqual([{ type: 'SyncOutcome', ok: true, error: undefined }]);
+    expect(out.state.dirty.has('a')).toBe(true);
+  });
+
+  it('a body the server does not return is remembered at the requested version so the plan converges', async () => {
+    const s = primed(buildState([buildEntry({ def: { hash: 'a' }, lifecycle: live, remoteArray: [['thing:1', 1], ['other:2', 1]] })]));
+    let calls = 0;
+    const out = await runPure(fetchRows(env), {
+      state: s,
+      handlers: {
+        'remote.query': () => {
+          calls++;
+          return [ok([{ id: new RecordId('other', '2'), z: 1 }, { nope: true }])];
+        },
+        'local.execute': () => undefined,
+        'ssp.ingest': () => undefined,
+      },
+    });
+    expect(calls).toBe(1);
+    expect(out.state.versions.get('thing:1')).toBe(1);
+    expect(out.state.versions.get('other:2')).toBe(1);
+    const extra = await runPure(fetchRows(env), {
+      state: s,
+      handlers: {
+        'remote.query': () => [ok([{ id: new RecordId('thing', '1') }, { id: new RecordId('thing', 'unrequested') }])],
+        'local.execute': () => undefined,
+        'ssp.ingest': (e: any) => {
+          expect(e.records[1]).toMatchObject({ id: 'thing:unrequested', record: { _00_rv: 0 } });
+        },
+      },
+    });
+    expect(extra.state.versions.has('thing:unrequested')).toBe(false);
+    const ingest = out.log.find((e) => e.kind === 'ssp.ingest') as any;
+    expect(ingest.records[0]).toMatchObject({ table: 'other', op: 'CREATE', record: { z: 1, _00_rv: 1 } });
+  });
+
+  it('failures back off: transport error, ERR statement, non-array result, local write error; ingest errors are logged only', async () => {
+    const s = primed(buildState([buildEntry({ def: { hash: 'a' }, lifecycle: live, remoteArray: [['thing:1', 1]] })]));
+    const expectBackoff = (out: Awaited<ReturnType<typeof runPure>>, attempts: number) => {
+      expect(out.state.sync.fetchAttempts).toBe(attempts);
+      expect(out.timers.get('fetch')).toEqual({ ms: 500 * 2 ** (attempts - 1), event: { type: 'FetchRows' } });
+      expect(out.state.queries.get('a')!.lifecycle.fetchDepth).toBe(0);
+      expect(out.dispatched.at(-1)).toMatchObject({ type: 'SyncOutcome', ok: false });
+    };
+    expectBackoff(await runPure(fetchRows(env), { state: s, handlers: { 'remote.query': () => { throw new Error('offline'); } } }), 1);
+    expectBackoff(await runPure(fetchRows(env), { state: s, handlers: { 'remote.query': () => [{ status: 'ERR', error: 'x' }] } }), 1);
+    expectBackoff(await runPure(fetchRows(env), { state: s, handlers: { 'remote.query': () => [ok('nope')] } }), 1);
+    expectBackoff(
+      await runPure(fetchRows(env), {
+        state: R.patchSync({ fetchAttempts: 1 })(s),
+        handlers: {
+          'remote.query': () => [ok([{ id: new RecordId('thing', '1') }])],
+          'local.execute': () => {
+            throw new Error('stale epoch');
+          },
+        },
+      }),
+      2
+    );
+    const ingestFail = await runPure(fetchRows(env), {
+      state: s,
+      handlers: {
+        'remote.query': () => [ok([{ id: new RecordId('thing', '1') }])],
+        'local.execute': () => undefined,
+        'ssp.ingest': () => {
+          throw new Error('wasm');
+        },
+      },
+    });
+    expect(ingestFail.state.sync.fetchAttempts).toBe(0);
+    expect(ingestFail.emitted).toContainEqual(expect.objectContaining({ message: 'circuit ingest failed' }));
+  });
+
+  it('a leader relays landed bodies to followers', async () => {
+    const s = { ...primed(buildState([buildEntry({ def: { hash: 'a' }, lifecycle: live, remoteArray: [['thing:1', 1]] })])), tabRole: 'leader' as const };
+    const out = await runPure(fetchRows(env), {
+      state: s,
+      handlers: { 'remote.query': () => [ok([{ id: new RecordId('thing', '1') }])], 'local.execute': () => undefined, 'ssp.ingest': () => undefined },
+    });
+    expect(out.emitted).toContainEqual({ type: 'tabs:broadcast', message: { type: 'ingest', records: [expect.objectContaining({ id: 'thing:1' })] } });
+  });
+
+  it('loops until the plan is empty', async () => {
+    const s = primed(buildState([buildEntry({ def: { hash: 'a' }, lifecycle: live, remoteArray: [['thing:1', 1]] })]));
+    let calls = 0;
+    const out = await runPure(fetchRows(env), {
+      state: s,
+      handlers: {
+        'remote.query': (_e, ctx) => {
+          calls++;
+          if (calls === 1) ctx.state = R.commitMembership('a', [['thing:1', 1], ['thing:2', 1]], true)(ctx.state);
+          return [ok([])];
+        },
+      },
+    });
+    expect(calls).toBe(2);
+    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

@@ -0,0 +1,120 @@
+import type { RecordId } from 'surrealdb';
+import type { Saga } from '../kernel/saga';
+import type { Settled, StatementResult } from '../kernel/effects';
+import { fx } from '../kernel/effects';
+import { backoffMs } from '../kernel/constants';
+import type { IngestRecord } from '../services/stream-processor/index';
+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 { absentOptionalColumns, cleanRecord } from '../utils/parser';
+import type { SagaEnv } from './env';
+import * as sql from './sql';
+
+/**
+ * The unified row fetcher (the poke analogue). Runs on the serial `fetch`
+ * lane: computes the cross-query set of bodies missing or stale locally,
+ * pulls them in parallel chunks, writes + ingests them, and loops until the
+ * plan is empty. A row shared by N queries is fetched once. Bodies are never
+ * deleted here; ids that left membership simply stop rendering.
+ */
+export function* fetchRows(env: SagaEnv): Saga<void> {
+  yield fx.state.wait((s) => s.primed);
+  for (;;) {
+    const state = (yield fx.state.read((s) => s)) as ClientState;
+    const plan = planFetch(state);
+    if (plan.chunks.length === 0) {
+      if (state.sync.fetchAttempts !== 0) yield fx.state.update(R.patchSync({ fetchAttempts: 0 }));
+      return;
+    }
+    // The engine's epoch, not a mirrored counter: it also moves on transport
+    // failover, and a stale value makes the store drop every body write.
+    const epoch = (yield fx.local.epoch()) as number;
+    yield fx.state.update(R.compose(...plan.hashes.map((h) => R.applyLifecycle(h, { type: 'fetch-begin' }))));
+    let failed = 0;
+    try {
+      const results = (yield fx.all(
+        plan.chunks.map((ids) => fx.remote.query(sql.bodySelect(), { ids: ids.map(parseRecordIdString) }, env.remoteTimeoutMs))
+      )) as Settled[];
+      for (let i = 0; i < results.length; i++) {
+        const r = results[i];
+        const first = r.ok ? (r.value as StatementResult[])[0] : undefined;
+        if (!r.ok || !first || first.status === 'ERR' || !Array.isArray(first.result)) {
+          failed++;
+          continue;
+        }
+        const landed = yield* landChunk(env, plan.chunks[i], first.result as Array<Record<string, unknown>>, plan.versions, state, epoch);
+        if (!landed) failed++;
+      }
+    } finally {
+      yield fx.state.update(R.compose(...plan.hashes.map((h) => R.applyLifecycle(h, { type: 'fetch-end' }))));
+    }
+    yield fx.dispatch({ type: 'SyncOutcome', ok: failed === 0, error: failed > 0 ? 'body fetch failed' : undefined });
+    if (failed > 0) {
+      const attempt = (yield fx.state.read((s) => s.sync.fetchAttempts)) as number;
+      yield fx.state.update(R.patchSync({ fetchAttempts: attempt + 1 }));
+      yield fx.timer.set('fetch', backoffMs(attempt), { type: 'FetchRows' });
+      return;
+    }
+  }
+}
+
+/**
+ * Write one chunk's bodies to the store and circuit; record their versions.
+ *
+ * Shared with the LIVE path: a body that arrives on a notification is landed
+ * through here so it is indistinguishable from a fetched one, which is what
+ * makes `planFetch` stop asking for it.
+ */
+export function* landChunk(
+  env: SagaEnv,
+  requested: string[],
+  rows: Array<Record<string, unknown>>,
+  versions: ReadonlyMap<string, number>,
+  state: ClientState,
+  epoch: number
+): Saga<boolean> {
+  const bodies: Array<{ id: unknown; content: Record<string, unknown> }> = [];
+  const ingest: IngestRecord[] = [];
+  const seen = new Set<string>();
+  for (const row of rows) {
+    const rid = row?.id as RecordId<string> | undefined;
+    if (!rid || typeof rid !== 'object') continue;
+    const id = encodeRecordId(rid);
+    const table = rid.table.name;
+    const version = versions.get(id) ?? 0;
+    const columns = env.schema.tables.find((t) => t.name === table)?.columns;
+    const cleaned = columns ? cleanRecord(columns, row) : row;
+    const { id: _id, ...content } = cleaned;
+    // 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);
+  }
+  if (bodies.length > 0) {
+    try {
+      const tx = sql.upsertBodiesTx(bodies);
+      yield fx.local.execute(tx.query, tx.vars, epoch);
+    } catch (error) {
+      yield fx.emit({ type: 'log', level: 'warn', message: 'body write failed', data: { error } });
+      return false;
+    }
+    try {
+      yield fx.ssp.ingest(ingest);
+    } catch (error) {
+      yield fx.emit({ type: 'log', level: 'warn', message: 'circuit ingest failed', data: { error } });
+    }
+    if (state.tabRole === 'leader') yield fx.emit({ type: 'tabs:broadcast', message: { type: 'ingest', records: ingest } });
+  }
+  // Ids the server did not return (deleted or unreadable upstream) count as
+  // known at the requested version, so the plan stops asking for them; their
+  // absence from the store is what the render shows.
+  const entries: Array<readonly [string, number]> = requested.map((id) => [id, versions.get(id) as number]);
+  yield fx.state.update(R.setVersions(entries));
+  return true;
+}

package/src/query/hash.test.ts

@@ -0,0 +1,14 @@
+import { describe, expect, it } from 'vitest';
+import { queryHashInput, viewKeyInput } from './hash';
+
+describe('hash inputs (golden against the previous DataModule formulas)', () => {
+  const input = { surql: 'SELECT * FROM t WHERE a = $a', params: { a: 1, b: 'x' } };
+  it('salted key is JSON.stringify({surql, params, sessionId}) in that key order', () => {
+    expect(queryHashInput(input, 'sess')).toBe(JSON.stringify({ ...input, sessionId: 'sess' }));
+    expect(queryHashInput(input, null)).toBe(JSON.stringify({ ...input, sessionId: null }));
+  });
+  it('view key is the same input minus the salt', () => {
+    expect(viewKeyInput(input)).toBe(JSON.stringify(input));
+    expect(viewKeyInput(input)).not.toBe(queryHashInput(input, 'sess'));
+  });
+});

package/src/query/hash.ts

@@ -0,0 +1,18 @@
+/**
+ * Hash inputs for the two query keys. Kept byte-identical to the previous
+ * implementation (`DataModule.calculateHash` / `calculateMembershipKey`):
+ * the salted key names the remote `_00_query` row, the unsalted one names the
+ * durable `_00_view` row, and both are `sha256(JSON.stringify(input))`.
+ */
+export interface QueryKeyInput {
+  surql: string;
+  params: Record<string, unknown>;
+}
+
+/** Session-salted: two tabs of one user must not share a remote view. */
+export const queryHashInput = (input: QueryKeyInput, sessionId: string | null): string =>
+  JSON.stringify({ surql: input.surql, params: input.params, sessionId });
+
+/** Session-independent: survives reload and bucket switch. */
+export const viewKeyInput = (input: QueryKeyInput): string =>
+  JSON.stringify({ surql: input.surql, params: input.params });

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 (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 (SELECT * 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([]);
+  });
+});