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

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

@@ -0,0 +1,311 @@
+import { describe, expect, it } from 'vitest';
+import { RecordId } from 'surrealdb';
+import { runPure, sha256Hex } from '../testing/run-pure';
+import { buildEntry, buildState } from '../testing/build';
+import { defaultEnv } from './env';
+import { queryHashInput } from './hash';
+import { ensureRegistered, isNotAllowlisted, registerLocal, registerRemote } from './register.saga';
+import * as R from '../state/reducers';
+import { emptyState } from '../state/client-state';
+import type { StatementResult } from '../kernel/effects';
+
+const env = defaultEnv({ tables: [{ name: 'thing', columns: {} }] } as any);
+const input = { tableName: 'thing', surql: 'SELECT * FROM thing', params: {}, ttl: '10m' as const };
+const sspOk = () => ({ localArray: [['thing:9', 1]], timings: { parseMs: 1, planMs: 1, snapshotMs: 1, wallMs: 1 } });
+const okStmt = (result: unknown): StatementResult => ({ status: 'OK', result });
+
+describe('registerLocal', () => {
+  it('cold: no view row -> cold entry, SSP view, EnsureRegistered', async () => {
+    const state = { ...emptyState({ tabId: 't' }), sessionId: 'sess' };
+    const out = await runPure(registerLocal(env, input), {
+      state,
+      handlers: { 'local.getById': () => null, 'ssp.register': sspOk },
+    });
+    const hash = await sha256Hex(queryHashInput(input, 'sess'));
+    expect(out.result).toBe(hash);
+    const entry = out.state.queries.get(hash)!;
+    expect(entry.lifecycle.phase).toBe('cold');
+    expect(entry.remoteArray).toEqual([]);
+    expect(entry.localArray).toEqual([['thing:9', 1]]);
+    expect(entry.def.ttlMs).toBe(600_000);
+    expect(entry.telemetry.registrationTimings.wallMs).toBe(1);
+    expect(out.state.dirty.has(hash)).toBe(true);
+    expect(out.state.registering.size).toBe(0);
+    expect(out.dispatched).toEqual([{ type: 'EnsureRegistered' }]);
+    const reg = out.log.find((e) => e.kind === 'ssp.register');
+    expect(reg).toMatchObject({ plan: { queryHash: hash, tableName: 'thing', ttl: '10m' } });
+  });
+
+  it('cached: a durable view row seeds membership; unconfirmed empty stays cold; a failing read is cold', async () => {
+    const cached = await runPure(registerLocal(env, input), {
+      handlers: { 'local.getById': () => ({ ids: [['thing:1', 2]], confirmed: false }), 'ssp.register': sspOk },
+    });
+    const e1 = cached.state.queries.get(cached.result)!;
+    expect(e1.lifecycle.phase).toBe('cached');
+    expect(e1.remoteArray).toEqual([['thing:1', 2]]);
+    const confirmedEmpty = await runPure(registerLocal(env, input), {
+      handlers: { 'local.getById': () => ({ ids: [], confirmed: true }), 'ssp.register': sspOk },
+    });
+    expect(confirmedEmpty.state.queries.get(confirmedEmpty.result)!.lifecycle.phase).toBe('cached');
+    const unconfirmed = await runPure(registerLocal(env, input), {
+      handlers: { 'local.getById': () => ({ ids: [], confirmed: false }), 'ssp.register': sspOk },
+    });
+    expect(unconfirmed.state.queries.get(unconfirmed.result)!.lifecycle.phase).toBe('cold');
+    const failing = await runPure(registerLocal(env, input), {
+      handlers: {
+        'local.getById': () => {
+          throw new Error('no table');
+        },
+        'ssp.register': sspOk,
+      },
+    });
+    expect(failing.state.queries.get(failing.result)!.lifecycle.phase).toBe('cold');
+  });
+
+  it('dedupes: active returns immediately, pending waits for the other registration', async () => {
+    const hash = await sha256Hex(queryHashInput(input, null));
+    const active = buildState([buildEntry({ def: { hash } })]);
+    const a = await runPure(registerLocal(env, input), { state: active });
+    expect(a.result).toBe(hash);
+    expect(a.log.filter((e) => e.kind === 'ssp.register')).toHaveLength(0);
+    const pending = R.beginRegistering(hash)(emptyState({ tabId: 't' }));
+    const p = await runPure(registerLocal(env, input), {
+      state: pending,
+      handlers: { 'state.wait': (_e, ctx) => void (ctx.state = R.endRegistering(hash)(ctx.state)) },
+    });
+    expect(p.result).toBe(hash);
+    expect(p.log.some((e) => e.kind === 'state.wait')).toBe(true);
+  });
+
+  it('a failing SSP registration clears the in-flight marker and rethrows', async () => {
+    await expect(
+      runPure(registerLocal(env, input), {
+        handlers: {
+          'local.getById': () => null,
+          'ssp.register': () => {
+            throw new Error('wasm down');
+          },
+        },
+      })
+    ).rejects.toThrow('wasm down');
+  });
+});
+
+describe('ensureRegistered', () => {
+  it('dispatches RegisterRemote for every unregistered query only', async () => {
+    const s = buildState([buildEntry({ def: { hash: 'a' } }), buildEntry({ def: { hash: 'b' }, lifecycle: { remote: 'registered' } })]);
+    const out = await runPure(ensureRegistered(env), { state: s });
+    expect(out.dispatched).toEqual([{ type: 'RegisterRemote', hash: 'a' }]);
+    const none = await runPure(ensureRegistered(env), { state: buildState() });
+    expect(none.dispatched).toEqual([]);
+  });
+  it('with requireAuth: probes $auth.id, retries on a timer, gives up after the budget, skips when anonymous', async () => {
+    const s = { ...buildState([buildEntry({ def: { hash: 'a' } })]), userId: 'user:1' };
+    const authed = await runPure(ensureRegistered(env, { requireAuth: true }), {
+      state: s,
+      handlers: { 'remote.query': () => [okStmt('user:1')] },
+    });
+    expect(authed.dispatched).toEqual([{ type: 'RegisterRemote', hash: 'a' }]);
+    const notYet = await runPure(ensureRegistered(env, { requireAuth: true, attempt: 2 }), {
+      state: s,
+      handlers: { 'remote.query': () => [okStmt(null)] },
+    });
+    expect(notYet.dispatched).toEqual([]);
+    expect(notYet.timers.get('ensure-registered')).toEqual({ ms: 500, event: { type: 'EnsureRegistered', requireAuth: true, attempt: 3 } });
+    const thrown = await runPure(ensureRegistered(env, { requireAuth: true }), {
+      state: s,
+      handlers: {
+        'remote.query': () => {
+          throw new Error('offline');
+        },
+      },
+    });
+    expect(thrown.timers.has('ensure-registered')).toBe(true);
+    const exhausted = await runPure(ensureRegistered(env, { requireAuth: true, attempt: 9 }), {
+      state: s,
+      handlers: { 'remote.query': () => [okStmt(null)] },
+    });
+    expect(exhausted.timers.size).toBe(0);
+    expect(exhausted.emitted).toEqual([expect.objectContaining({ type: 'log', level: 'warn' })]);
+    const anon = await runPure(ensureRegistered(env, { requireAuth: true }), { state: { ...s, userId: null } });
+    expect(anon.dispatched).toEqual([{ type: 'RegisterRemote', hash: 'a' }]);
+  });
+});
+
+describe('registerRemote', () => {
+  const entry = buildEntry({ def: { hash: 'a' }, lifecycle: { phase: 'cold' } });
+  const happy = () => [
+    okStmt(null),
+    okStmt([{ out: new RecordId('thing', '1'), version: 1 }]),
+    okStmt({ rowCount: 1, state: 'ready' }),
+    okStmt([{ out: new RecordId('child', 'c'), version: 1 }]),
+  ];
+  it('registers, applies membership + children, flips registered, fetch-begin/end balanced', async () => {
+    const out = await runPure(registerRemote(env, 'a'), {
+      state: buildState([entry]),
+      handlers: { 'remote.query': happy, 'local.upsert': () => undefined },
+    });
+    const e = out.state.queries.get('a')!;
+    expect(e.lifecycle).toMatchObject({ phase: 'live', remote: 'registered', fetchDepth: 0 });
+    expect(e.remoteArray).toEqual([['thing:1', 1]]);
+    expect(e.subqueryRemoteArray).toEqual([['child:c', 1]]);
+    expect(e.serverState).toBe('ready');
+    const req = out.log.find((x) => x.kind === 'remote.query') as any;
+    expect(req.sql.startsWith('fn::query::register($config);')).toBe(true);
+    expect(req.vars.config).toMatchObject({ surql: entry.def.surql, ttl: '10m' });
+    expect(out.dispatched).toEqual([{ type: 'FetchRows' }, { type: 'FetchRows' }, { type: 'SyncOutcome', ok: true }]);
+    expect(out.emitted).toContainEqual({ type: 'query:authority', hash: 'a', known: true });
+  });
+  it('a cold registration is foreground; a cached or live one is background', async () => {
+    for (const [phase, background] of [['cold', 0], ['cached', 1], ['live', 1]] as const) {
+      const seen: Array<[number, number]> = [];
+      const out = await runPure(registerRemote(env, 'a'), {
+        state: buildState([buildEntry({ def: { hash: 'a' }, lifecycle: { phase } })]),
+        handlers: {
+          'remote.query': (_e: unknown, ctx) => {
+            const l = ctx.state.queries.get('a')!.lifecycle;
+            seen.push([l.fetchDepth, l.backgroundDepth]);
+            return happy();
+          },
+          'local.upsert': () => undefined,
+        },
+      });
+      expect(seen).toEqual([[1, background]]);
+      expect(out.state.queries.get('a')!.lifecycle).toMatchObject({ fetchDepth: 0, backgroundDepth: 0 });
+    }
+  });
+  it('guards: missing entry, already registered / failed, registering without retry', async () => {
+    const none = await runPure(registerRemote(env, 'zzz'), { state: buildState([]) });
+    expect(none.log.filter((x) => x.kind === 'remote.query')).toHaveLength(0);
+    for (const remote of ['registered', 'failed', 'registering'] as const) {
+      const out = await runPure(registerRemote(env, 'a'), { state: buildState([buildEntry({ def: { hash: 'a' }, lifecycle: { remote } })]) });
+      expect(out.log.filter((x) => x.kind === 'remote.query')).toHaveLength(0);
+    }
+    const retry = await runPure(registerRemote(env, 'a', true), {
+      state: buildState([buildEntry({ def: { hash: 'a' }, lifecycle: { remote: 'registering' } })]),
+      handlers: { 'remote.query': happy, 'local.upsert': () => undefined },
+    });
+    expect(retry.state.queries.get('a')!.lifecycle.remote).toBe('registered');
+  });
+  it('materializing answer schedules the re-read ladder', async () => {
+    const out = await runPure(registerRemote(env, 'a'), {
+      state: buildState([entry]),
+      handlers: { 'remote.query': () => [okStmt(null), okStmt([]), okStmt({ rowCount: 3, state: 'materializing' }), okStmt([])] },
+    });
+    expect(out.state.membershipDirty.has('a')).toBe(true);
+    expect(out.state.membershipReread.get('a')).toBe(1);
+    expect(out.timers.get('membership')).toEqual({ ms: 150, event: { type: 'ReadDirtyMembership' } });
+    expect(out.state.queries.get('a')!.lifecycle).toMatchObject({ phase: 'cold', remote: 'registered' });
+  });
+  it('errors: transport failure backs off, statement errors count as failures, budget exhausts to failed', async () => {
+    const boom = () => {
+      throw new Error('socket closed');
+    };
+    const first = await runPure(registerRemote(env, 'a'), { state: buildState([entry]), handlers: { 'remote.query': boom } });
+    expect(first.state.queries.get('a')!.lifecycle).toMatchObject({ remote: 'registering', fetchDepth: 0 });
+    expect(first.state.queries.get('a')!.registerAttempts).toBe(1);
+    expect(first.timers.get('register:a')).toEqual({ ms: 1000, event: { type: 'RegisterRemote', hash: 'a', retry: true } });
+    expect(first.dispatched).toContainEqual({ type: 'SyncOutcome', ok: false, error: new Error('socket closed') });
+    const errStmt = await runPure(registerRemote(env, 'a'), {
+      state: buildState([entry]),
+      handlers: { 'remote.query': () => [{ status: 'ERR', error: 'denied' }] },
+    });
+    expect(errStmt.state.queries.get('a')!.registerAttempts).toBe(1);
+    // The register statement answered but the read-back did not: the query
+    // IS registered, and its membership is read again rather than guessed.
+    for (const readBack of [
+      [okStmt(null), { status: 'ERR', error: 'no table' }, okStmt(null), okStmt(null)],
+      [okStmt(null), okStmt('nope'), okStmt(null), okStmt(null)],
+    ] as StatementResult[][]) {
+      const out = await runPure(registerRemote(env, 'a'), { state: buildState([entry]), handlers: { 'remote.query': () => readBack } });
+      const e = out.state.queries.get('a')!;
+      expect(e.registerAttempts).toBe(0);
+      expect(e.lifecycle).toMatchObject({ remote: 'registered', fetchDepth: 0 });
+      expect(out.state.membershipDirty.has('a')).toBe(true);
+      expect(out.timers.get('membership')).toEqual({ ms: 50, event: { type: 'ReadDirtyMembership' } });
+      expect(out.dispatched).toContainEqual({ type: 'SyncOutcome', ok: false, error: 'registration read-back failed' });
+    }
+    const empty = await runPure(registerRemote(env, 'a'), { state: buildState([entry]), handlers: { 'remote.query': () => [] } });
+    expect(empty.state.queries.get('a')!.registerAttempts).toBe(1);
+    const last = await runPure(registerRemote(env, 'a'), {
+      state: buildState([buildEntry({ def: { hash: 'a' }, registerAttempts: 2 })]),
+      handlers: { 'remote.query': boom },
+    });
+    expect(last.state.queries.get('a')!.lifecycle.remote).toBe('failed');
+    expect(last.timers.size).toBe(0);
+  });
+  it('not allowlisted: 403/Forbidden/not_allowlisted fails after ONE attempt with an error log, no retry timer', async () => {
+    for (const text of ['HTTP 403 Forbidden', 'There was an error processing a remote HTTP request: {"error":"not_allowlisted"}', 'status 403']) {
+      const out = await runPure(registerRemote(env, 'a'), {
+        state: buildState([entry]),
+        handlers: { 'remote.query': () => [{ status: 'ERR', error: text }] },
+      });
+      const e = out.state.queries.get('a')!;
+      expect(e.lifecycle).toMatchObject({ remote: 'failed', phase: 'cold', fetchDepth: 0 });
+      expect(e.registerAttempts).toBe(0);
+      expect(out.timers.size).toBe(0);
+      expect(out.emitted).toContainEqual(
+        expect.objectContaining({
+          type: 'log',
+          level: 'error',
+          message: 'query refused: not allowlisted',
+          data: expect.objectContaining({ hash: 'a', table: entry.def.tableName, surql: entry.def.surql, params: [] }),
+        })
+      );
+      expect(out.dispatched).toContainEqual(expect.objectContaining({ type: 'SyncOutcome', ok: false }));
+    }
+    const thrown = await runPure(registerRemote(env, 'a'), {
+      state: buildState([entry]),
+      handlers: {
+        'remote.query': () => {
+          throw new Error('Forbidden');
+        },
+      },
+    });
+    expect(thrown.state.queries.get('a')!.lifecycle.remote).toBe('failed');
+    expect(thrown.timers.size).toBe(0);
+    expect(isNotAllowlisted(new Error('socket closed'))).toBe(false);
+    expect(isNotAllowlisted('HTTP 4030')).toBe(false);
+  });
+
+  it('an ERR meta or children statement applies nothing and re-reads, instead of reading as a lost row', async () => {
+    const lostBefore = buildEntry({ def: { hash: 'a' }, lifecycle: { phase: 'view-lost' }, remoteArray: [['thing:1', 1]], viewLostCount: 1 });
+    for (const [meta, kids] of [
+      [{ status: 'ERR', error: 'meta' }, okStmt([])],
+      [okStmt({ rowCount: 1, state: 'ready' }), { status: 'ERR', error: 'kids' }],
+    ] as StatementResult[][]) {
+      const out = await runPure(registerRemote(env, 'a'), {
+        state: buildState([lostBefore]),
+        handlers: { 'remote.query': () => [okStmt(null), okStmt([{ out: new RecordId('thing', '1'), version: 1 }]), meta, kids] },
+      });
+      const e = out.state.queries.get('a')!;
+      expect(e.lifecycle).toMatchObject({ phase: 'view-lost', remote: 'registered' });
+      expect(e.viewLostCount).toBe(1);
+      expect(out.dispatched.filter((d) => d.type === 'EnsureRegistered')).toEqual([]);
+      expect(out.state.membershipDirty.has('a')).toBe(true);
+    }
+  });
+  it('stops when the entry disappears mid-flight', async () => {
+    const out = await runPure(registerRemote(env, 'a'), {
+      state: buildState([entry]),
+      handlers: {
+        'remote.query': (_e, ctx) => {
+          ctx.state = R.removeQuery('a')(ctx.state);
+          return happy();
+        },
+      },
+    });
+    expect(out.state.queries.has('a')).toBe(false);
+    expect(out.dispatched).toEqual([]);
+    const gone = await runPure(registerRemote(env, 'a'), {
+      state: buildState([entry]),
+      handlers: {
+        'remote.query': (_e, ctx) => {
+          ctx.state = R.removeQuery('a')(ctx.state);
+          throw new Error('x');
+        },
+      },
+    });
+    expect(gone.dispatched).toEqual([]);
+  });
+});

package/src/query/register.saga.ts

@@ -0,0 +1,235 @@
+import type { QueryPlan } from '@spooky-sync/query-builder';
+import { RecordId } from 'surrealdb';
+import type { QueryHash, QueryTimeToLive } from '../types';
+import type { Saga } from '../kernel/saga';
+import type { RegisterResult, StatementResult } from '../kernel/effects';
+import { fx } from '../kernel/effects';
+import { AUTH_READY_MAX_ATTEMPTS, AUTH_READY_RETRY_MS, REGISTER_MAX_RETRIES, backoffMs } from '../kernel/constants';
+import type { ClientState, QueryEntry } from '../state/client-state';
+import { emptyTelemetry } from '../state/client-state';
+import { seedLifecycle } from '../state/lifecycle';
+import * as R from '../state/reducers';
+import { desiredRegistrations } from '../state/selectors';
+import { parseDuration } from '../utils/index';
+import type { SagaEnv } from './env';
+import { listRefTable } from './env';
+import { queryHashInput, viewKeyInput } from './hash';
+import { FAILED, isResolvedBefore, parseViewRow, snapshotFromSingle } from './membership';
+import { applyMembership, applySubqueryChildren, markMembershipDirty } from './membership.saga';
+import * as sql from './sql';
+
+export interface RegisterInput {
+  tableName: string;
+  surql: string;
+  params: Record<string, unknown>;
+  ttl: QueryTimeToLive;
+  plan?: QueryPlan;
+}
+
+/**
+ * Register a query locally: compute its keys, read the durable `_00_view`
+ * row, build the SSP local view and publish the entry. Returns as soon as the
+ * entry exists (the first paint comes from `materialize`); the remote
+ * registration is dispatched, never awaited.
+ */
+export function* registerLocal(env: SagaEnv, input: RegisterInput): Saga<QueryHash> {
+  const sessionId = (yield fx.state.read((s) => s.sessionId)) as string | null;
+  const hash = (yield fx.hash(queryHashInput(input, sessionId))) as string;
+  const status = (yield fx.state.read((s) => (s.queries.has(hash) ? 'active' : s.registering.has(hash) ? 'pending' : 'new'))) as
+    | 'active'
+    | 'pending'
+    | 'new';
+  if (status === 'active') return hash;
+  if (status === 'pending') {
+    yield fx.state.wait((s) => !s.registering.has(hash));
+    return hash;
+  }
+  yield fx.state.update(R.beginRegistering(hash));
+  try {
+    const viewKey = (yield fx.hash(viewKeyInput(input))) as string;
+    let viewRow: unknown = null;
+    try {
+      viewRow = yield fx.local.getById(sql.VIEW_TABLE, sql.viewRecordId(viewKey));
+    } catch {
+      viewRow = null;
+    }
+    const view = parseViewRow(viewRow);
+    const now = (yield fx.now()) as number;
+    const reg = (yield fx.ssp.register({
+      queryHash: hash,
+      surql: input.surql,
+      params: input.params,
+      ttl: input.ttl,
+      tableName: input.tableName,
+    })) as RegisterResult;
+    const entry: QueryEntry = {
+      def: {
+        id: new RecordId('_00_query', hash),
+        hash,
+        viewKey,
+        surql: input.surql,
+        params: input.params,
+        plan: input.plan,
+        ttl: input.ttl,
+        ttlMs: parseDuration(input.ttl),
+        tableName: input.tableName,
+        createdAt: now,
+      },
+      lifecycle: seedLifecycle(isResolvedBefore(view)),
+      remoteArray: view?.ids ?? [],
+      localArray: reg.localArray,
+      subqueryRemoteArray: [],
+      records: [],
+      serverState: null,
+      subscribers: 0,
+      lastSubscriberLeftAt: now,
+      lastHeartbeatAt: null,
+      lastPolledAt: null,
+      registerAttempts: 0,
+      viewLostCount: 0,
+      viewLostRetryAt: null,
+      telemetry: { ...emptyTelemetry(), registrationTimings: reg.timings },
+    };
+    yield fx.state.update(R.putQuery(entry));
+    yield fx.dispatch({ type: 'EnsureRegistered' });
+    return hash;
+  } finally {
+    yield fx.state.update(R.endRegistering(hash));
+  }
+}
+
+/**
+ * Make the remote match the desired set: start a registration for every
+ * query that has none. Idempotent. With `requireAuth` (after a reconnect or
+ * while degraded) it first waits for `$auth.id` to be visible on the socket:
+ * a register issued before that stamps the view with an empty identity.
+ */
+export function* ensureRegistered(env: SagaEnv, opts: { requireAuth?: boolean; attempt?: number } = {}): Saga<void> {
+  const [hashes, userId] = (yield fx.state.read((s) => [desiredRegistrations(s), s.userId])) as [QueryHash[], string | null];
+  if (hashes.length === 0) return;
+  if (opts.requireAuth && userId !== null) {
+    let authed = false;
+    try {
+      const res = (yield fx.remote.query('RETURN $auth.id', undefined, env.remoteTimeoutMs)) as StatementResult[];
+      authed = res[0]?.status === 'OK' && res[0].result != null;
+    } catch {
+      authed = false;
+    }
+    if (!authed) {
+      const attempt = (opts.attempt ?? 0) + 1;
+      if (attempt >= AUTH_READY_MAX_ATTEMPTS) {
+        yield fx.emit({ type: 'log', level: 'warn', message: 'auth identity never became visible; not registering', data: { attempt } });
+        return;
+      }
+      yield fx.timer.set('ensure-registered', AUTH_READY_RETRY_MS, { type: 'EnsureRegistered', requireAuth: true, attempt });
+      return;
+    }
+  }
+  for (const hash of hashes) yield fx.dispatch({ type: 'RegisterRemote', hash });
+}
+
+const stmt = (results: StatementResult[], i: number): StatementResult | undefined => results[i];
+
+/**
+ * The SSP answers a registration whose shape is not on the query allowlist
+ * with HTTP 403 `{"error":"not_allowlisted"}`. It reaches the client as the
+ * `fn::query::register` statement error carrying SurrealDB's http error text
+ * (status reason and/or body), and no retry can change the answer.
+ */
+export const isNotAllowlisted = (error: unknown): boolean =>
+  /not_allowlisted|\b403\b|forbidden/i.test(String((error as { message?: unknown })?.message ?? error));
+
+/**
+ * One remote registration: `fn::query::register` plus the edge/meta/children
+ * read in ONE request, then membership application. Concurrent with every
+ * other registration; retried on its own backoff; stops when the entry is
+ * gone.
+ */
+export function* registerRemote(env: SagaEnv, hash: QueryHash, retry = false): Saga<void> {
+  const state = (yield fx.state.read((s) => s)) as ClientState;
+  const entry = state.queries.get(hash);
+  if (!entry) return;
+  const { remote } = entry.lifecycle;
+  if (remote === 'registered' || remote === 'failed' || (remote === 'registering' && !retry)) return;
+  // A query that already shows rows (cached or live) only re-verifies them
+  // here: the cycle holds `fetching` but is not traffic the user waits on.
+  const background = entry.lifecycle.phase !== 'cold';
+  yield fx.state.update(
+    R.compose(R.applyLifecycle(hash, { type: 'remote-registering' }), R.applyLifecycle(hash, { type: 'fetch-begin', background }))
+  );
+  try {
+    const table = listRefTable(env, state);
+    const results = (yield fx.remote.query(
+      sql.registerSelect(table),
+      sql.registerVars({
+        id: entry.def.id,
+        surql: entry.def.surql,
+        params: { ...entry.def.params },
+        ttl: entry.def.ttl,
+        ...(state.ownerSecret ? { owner: state.ownerSecret } : {}),
+      }),
+      env.remoteTimeoutMs
+    )) as StatementResult[];
+    const stillThere = (yield fx.state.read((s) => s.queries.has(hash))) as boolean;
+    if (!stillThere) return;
+    const register = stmt(results, 0);
+    if (!register || register.status === 'ERR') throw new Error(register?.status === 'ERR' ? register.error : 'register returned nothing');
+    const answer = (r: StatementResult | undefined): unknown => (r?.status === 'OK' ? r.result : FAILED);
+    const snap = snapshotFromSingle(
+      answer(stmt(results, 1)) as never,
+      answer(stmt(results, 2)) as never,
+      answer(stmt(results, 3)) as never
+    );
+    if (!snap) {
+      // Registered, but the read-back did not answer. That says nothing about
+      // the row, so read membership again rather than guess: a guess of
+      // "gone" re-registered the query, and under load the next read-back
+      // failed the same way.
+      yield fx.state.update(R.compose(R.applyLifecycle(hash, { type: 'remote-registered' }), R.resetRegisterAttempts(hash)));
+      yield fx.emit({ type: 'log', level: 'debug', message: 'registration read-back did not answer; re-reading membership', data: { hash } });
+      yield* markMembershipDirty([hash]);
+      yield fx.dispatch({ type: 'SyncOutcome', ok: false, error: 'registration read-back failed' });
+      return;
+    }
+    const outcome = yield* applyMembership(hash, snap.primary, snap.meta);
+    if (outcome === 'ignored' && snap.meta.present && snap.meta.state === 'materializing') {
+      yield fx.state.update(R.compose(R.markMembershipDirty([hash]), R.setMembershipReread(hash, 1)));
+      yield fx.timer.set('membership', 150, { type: 'ReadDirtyMembership' });
+    }
+    yield* applySubqueryChildren(hash, snap.subquery);
+    yield fx.state.update(R.compose(R.applyLifecycle(hash, { type: 'remote-registered' }), R.resetRegisterAttempts(hash)));
+    yield fx.dispatch({ type: 'SyncOutcome', ok: true });
+  } catch (error) {
+    const current = (yield fx.state.read((s) => s.queries.get(hash))) as QueryEntry | undefined;
+    if (!current) return;
+    if (isNotAllowlisted(error)) {
+      yield fx.state.update(R.applyLifecycle(hash, { type: 'remote-failed' }));
+      yield fx.emit({
+        type: 'log',
+        level: 'error',
+        message: 'query refused: not allowlisted',
+        data: {
+          hash,
+          table: entry.def.tableName,
+          surql: entry.def.surql,
+          params: Object.keys(entry.def.params),
+          hint: 'Add or regenerate the query allowlist: spky generate, then spky deploy (or restart spky dev).',
+        },
+      });
+      yield fx.dispatch({ type: 'SyncOutcome', ok: false, error });
+      return;
+    }
+    const attempts = current.registerAttempts + 1;
+    yield fx.state.update(R.bumpRegisterAttempts(hash));
+    yield fx.emit({ type: 'log', level: 'warn', message: 'remote registration failed', data: { hash, attempts, error } });
+    yield fx.dispatch({ type: 'SyncOutcome', ok: false, error });
+    if (attempts >= REGISTER_MAX_RETRIES) {
+      yield fx.state.update(R.applyLifecycle(hash, { type: 'remote-failed' }));
+    } else {
+      yield fx.timer.set(`register:${hash}`, backoffMs(attempts), { type: 'RegisterRemote', hash, retry: true });
+    }
+  } finally {
+    const stillThere = (yield fx.state.read((s) => s.queries.has(hash))) as boolean;
+    if (stillThere) yield fx.state.update(R.applyLifecycle(hash, { type: 'fetch-end', background }));
+  }
+}

package/src/query/render-set.test.ts

@@ -0,0 +1,47 @@
+import { describe, expect, it } from 'vitest';
+import { buildRenderIds, paintsCold, resolveMembership } from './render-set';
+
+const ov = (writes: string[] = [], deletes: string[] = []) => ({ writes: new Set(writes), deletes: new Set(deletes) });
+
+describe('resolveMembership', () => {
+  it('cold scans, cold window uses the local view, anything else uses membership', () => {
+    const remoteArray: [string, number][] = [['t:1', 1]];
+    const localArray: [string, number][] = [['t:2', 1]];
+    expect(resolveMembership({ phase: 'cold', remoteArray, localArray, isWindow: false })).toBeNull();
+    expect(resolveMembership({ phase: 'cold', remoteArray, localArray, isWindow: true })).toBe(localArray);
+    expect(resolveMembership({ phase: 'cached', remoteArray, localArray, isWindow: false })).toBe(remoteArray);
+    expect(resolveMembership({ phase: 'view-lost', remoteArray, localArray, isWindow: true })).toBe(remoteArray);
+  });
+});
+
+describe('buildRenderIds', () => {
+  const opts = { hasExplicitOrder: false, isWindow: false };
+  it('membership minus deletes, sorted', () => {
+    expect(buildRenderIds([['t:b', 1], ['t:a', 1], ['t:c', 1]], [], ov([], ['t:c']), opts)).toEqual(['t:a', 't:b']);
+  });
+  it('adds pending writes the local view admits, never twice, never deleted', () => {
+    const ids = buildRenderIds(
+      [['t:1', 1]],
+      [['t:1', 1], ['t:2', 1], ['t:3', 1], ['t:4', 1]],
+      ov(['t:1', 't:2', 't:3', 't:9'], ['t:3']),
+      opts
+    );
+    expect(ids).toEqual(['t:1', 't:2']);
+  });
+  it('keeps server order for windows and explicit orderBy; dedupes membership', () => {
+    const m: [string, number][] = [['t:b', 1], ['t:a', 1], ['t:b', 1]];
+    expect(buildRenderIds(m, [], ov(), { hasExplicitOrder: true, isWindow: false })).toEqual(['t:b', 't:a']);
+    expect(buildRenderIds(m, [], ov(), { hasExplicitOrder: false, isWindow: true })).toEqual(['t:b', 't:a']);
+  });
+});
+
+describe('paintsCold', () => {
+  it('only vouched bodies, optimistic writes and bookkeeping paint before the server answers', () => {
+    const vouched = new Set(['t:1']);
+    expect(paintsCold('t:1', vouched, ov())).toBe(true);
+    expect(paintsCold('t:2', vouched, ov(['t:2']))).toBe(true);
+    expect(paintsCold('_00_user_feature:f', vouched, ov())).toBe(true);
+    expect(paintsCold('t:3', vouched, ov([], ['t:3']))).toBe(false);
+    expect(paintsCold('t:3', vouched, ov())).toBe(false);
+  });
+});

package/src/query/render-set.ts

@@ -0,0 +1,71 @@
+import type { RecordVersionArray } from '../types';
+import type { QueryPhase } from '../state/lifecycle';
+import type { Overlay } from '../state/selectors';
+
+export interface RenderInput {
+  phase: QueryPhase;
+  remoteArray: RecordVersionArray;
+  localArray: RecordVersionArray;
+  isWindow: boolean;
+}
+
+/**
+ * The id-set a query renders from, or `null` when it must fall back to a
+ * local predicate scan (a cold query that was never resolved on this device).
+ * A cold window has no usable scan (re-applying `START m` against the shared
+ * store returns the wrong rows), so it renders the SSP's local window instead.
+ */
+export function resolveMembership(input: RenderInput): RecordVersionArray | null {
+  if (input.phase !== 'cold') return input.remoteArray;
+  if (input.isWindow) return input.localArray;
+  return null;
+}
+
+/**
+ * Whether a body may paint before the server has answered (`cold`). One no
+ * durable view vouches for and no optimistic write touches is an orphan:
+ * deleted upstream while no view watched it, or dropped from every view since.
+ * The predicate scan would otherwise resurrect it until the server answers,
+ * and indefinitely offline.
+ */
+export function paintsCold(id: string, vouched: ReadonlySet<string>, overlay: Overlay): boolean {
+  return id.startsWith('_00_') || vouched.has(id) || overlay.writes.has(id);
+}
+
+export interface RenderOptions {
+  hasExplicitOrder: boolean;
+  isWindow: boolean;
+}
+
+/**
+ *   render = (membership ∪ (writes ∩ localView)) − deletes
+ *
+ * `writes`/`deletes` are the outbox overlay (pending and acked items). The
+ * middle term keeps optimistic writes visible without re-admitting stale rows:
+ * `localView` (the SSP's local id-set) says whether the written row matches
+ * the query per local truth. Sorted unless the query orders itself or is a
+ * window (whose id order is the slice order).
+ */
+export function buildRenderIds(
+  membership: RecordVersionArray,
+  localView: RecordVersionArray,
+  overlay: Overlay,
+  opts: RenderOptions
+): string[] {
+  const ordered: string[] = [];
+  const seen = new Set<string>();
+  for (const [id] of membership) {
+    if (overlay.deletes.has(id) || seen.has(id)) continue;
+    seen.add(id);
+    ordered.push(id);
+  }
+  if (overlay.writes.size > 0) {
+    for (const [id] of localView) {
+      if (!overlay.writes.has(id) || overlay.deletes.has(id) || seen.has(id)) continue;
+      seen.add(id);
+      ordered.push(id);
+    }
+  }
+  if (!opts.hasExplicitOrder && !opts.isWindow) ordered.sort();
+  return ordered;
+}