@spooky-sync/core 0.0.1-canary.256 → 0.0.1-canary.258

package/dist/index.d.ts

@@ -1127,6 +1127,9 @@ type RuntimeEvent = {
   type: 'AckPrune';
 } | {
   type: 'ReadDirtyMembership';
+} | {
+  type: 'RecoverLostView';
+  hash: QueryHash;
 } | {
   type: 'ReadMembership';
   hashes: QueryHash[];
@@ -1501,6 +1504,13 @@ interface QueryEntry {
   readonly lastHeartbeatAt: number | null;
   readonly lastPolledAt: number | null;
   readonly registerAttempts: number;
+  /**
+   * Re-registrations issued because the `_00_query` row read as gone, since
+   * the row was last seen. Paces the next one (see `applyMembership`).
+   */
+  readonly viewLostCount: number;
+  /** When the paced re-registration is due; null when none is pending. */
+  readonly viewLostRetryAt: number | null;
   readonly telemetry: QueryTelemetry;
 }
 type OutboxStatus = 'pending' | 'acked';

package/dist/index.js

@@ -1073,8 +1073,8 @@ function selfAllowlistedVariant(flag, userId) {
 
 //#endregion
 //#region src/modules/devtools/index.ts
-const CORE_VERSION = "0.0.1-canary.256";
-const WASM_VERSION = "0.0.1-canary.256";
+const CORE_VERSION = "0.0.1-canary.258";
+const WASM_VERSION = "0.0.1-canary.258";
 const SURREAL_VERSION = "3.0.3";
 var DevToolsService = class DevToolsService {
 	eventsHistory = [];
@@ -1686,6 +1686,13 @@ const RETRY_BASE_MS = 500;
 const RETRY_MAX_MS = 15e3;
 /** Registration attempts before a query is reported as failed to settle. */
 const REGISTER_MAX_RETRIES = 3;
+/**
+* Pacing of repeated view-lost recovery. The first re-registration after a
+* `_00_query` row reads as gone is immediate; each further one for the same
+* query, before the row has been seen again, waits on this backoff.
+*/
+const VIEW_LOST_RETRY_BASE_MS = 1e3;
+const VIEW_LOST_RETRY_MAX_MS = 3e4;
 /** `_00_list_ref` poll cadence (fallback when LIVE is quiet). */
 const LIST_REF_POLL_BASE_MS = 500;
 /** Self-heal cadence while sync health is degraded. */
@@ -1877,6 +1884,12 @@ const bumpRegisterAttempts = (hash) => (s) => withEntry(s, hash, (e) => ({
 	...e,
 	registerAttempts: e.registerAttempts + 1
 }));
+/** View-lost recovery pacing; see `QueryEntry.viewLostCount`. */
+const setViewLost = (hash, viewLostCount, viewLostRetryAt) => (s) => withEntry(s, hash, (e) => e.viewLostCount === viewLostCount && e.viewLostRetryAt === viewLostRetryAt ? e : {
+	...e,
+	viewLostCount,
+	viewLostRetryAt
+});
 const resetRegisterAttempts = (hash) => (s) => withEntry(s, hash, (e) => e.registerAttempts === 0 ? e : {
 	...e,
 	registerAttempts: 0
@@ -2087,7 +2100,9 @@ const rebindQuery = (hash, next) => (s) => {
 		serverState: null,
 		lastHeartbeatAt: null,
 		lastPolledAt: null,
-		registerAttempts: 0
+		registerAttempts: 0,
+		viewLostCount: 0,
+		viewLostRetryAt: null
 	}));
 	return rebound === s ? s : {
 		...rebound,
@@ -2658,10 +2673,21 @@ function decideMembershipOutcome(input) {
 	if (!meta || !meta.present) return held > 0 || phase !== "cold" ? "view-lost" : "ignored";
 	return meta.rowCount === 0 && meta.state !== "materializing" ? "applied" : "ignored";
 }
+/**
+* A statement that did not answer (an ERR, or no result at all). Kept apart
+* from a `null` result, which is the server saying "no such row": reading a
+* failed statement as a missing row turned every timeout under load into a
+* lost view and re-registered it, over and over (whitepawn, 2026-09-16).
+*/
+const FAILED = Symbol("statement failed");
 const toPairs = (rows) => dedupeRecordVersions(Array.isArray(rows) ? rows.map((r) => [encodeRecordId(r.out), r.version]) : []);
-/** Fold the single-query statement batch (edges, meta, children) into a snapshot. */
+/**
+* Fold the single-query statement batch (edges, meta, children) into a
+* snapshot. `null` when any of the three did not answer: half an answer is
+* not one, and a missing meta would read as a lost view.
+*/
 function snapshotFromSingle(items, metaRow, children) {
-	if (!Array.isArray(items)) return null;
+	if (!Array.isArray(items) || metaRow === FAILED || children === FAILED) return null;
 	return {
 		primary: toPairs(items),
 		subquery: toPairs(children),
@@ -2671,11 +2697,11 @@ function snapshotFromSingle(items, metaRow, children) {
 /**
 * Fold the many-query statement batch into one snapshot per hash. Every hash
 * in `hashById` gets a snapshot; a query whose row did not come back reads
-* `present: false`.
+* `present: false`. Empty when either statement did not answer.
 */
 function snapshotsFromBatch(edges, counts, hashById) {
 	const out = /* @__PURE__ */ new Map();
-	if (!Array.isArray(edges)) return out;
+	if (!Array.isArray(edges) || counts === FAILED) return out;
 	for (const hash of hashById.values()) out.set(hash, {
 		primary: [],
 		subquery: [],
@@ -2938,6 +2964,7 @@ function* applyMembership(hash, remoteArray, meta, verifiedRemoval) {
 	const entry = yield fx.state.read((s) => s.queries.get(hash));
 	if (!entry) return "ignored";
 	if (meta) yield fx.state.update(setServerState(hash, meta.present ? meta.state : null));
+	if (meta?.present && (entry.viewLostCount > 0 || entry.viewLostRetryAt !== null)) yield fx.state.update(setViewLost(hash, 0, null));
 	const outcome = decideMembershipOutcome({
 		phase: entry.lifecycle.phase,
 		held: entry.remoteArray.length,
@@ -2954,8 +2981,30 @@ function* applyMembership(hash, remoteArray, meta, verifiedRemoval) {
 				hash
 			});
 		}
-		if (entry.lifecycle.remote !== "unregistered") yield fx.state.update(applyLifecycle(hash, { type: "remote-dropped" }));
-		yield fx.dispatch({ type: "EnsureRegistered" });
+		if (entry.viewLostRetryAt !== null) return outcome;
+		if (entry.viewLostCount === 0) {
+			yield fx.state.update(setViewLost(hash, 1, null));
+			if (entry.lifecycle.remote !== "unregistered") yield fx.state.update(applyLifecycle(hash, { type: "remote-dropped" }));
+			yield fx.dispatch({ type: "EnsureRegistered" });
+			return outcome;
+		}
+		const delay = backoffMs(entry.viewLostCount - 1, VIEW_LOST_RETRY_BASE_MS, VIEW_LOST_RETRY_MAX_MS);
+		const now = yield fx.now();
+		yield fx.state.update(setViewLost(hash, entry.viewLostCount + 1, now + delay));
+		yield fx.emit({
+			type: "log",
+			level: "debug",
+			message: "view still lost; re-registering after a delay",
+			data: {
+				hash,
+				attempt: entry.viewLostCount + 1,
+				delayMs: delay
+			}
+		});
+		yield fx.timer.set(`view-lost:${hash}`, delay, {
+			type: "RecoverLostView",
+			hash
+		});
 		return outcome;
 	}
 	const wasAuthoritative = isAuthoritative(entry.lifecycle);
@@ -2982,6 +3031,21 @@ function* applyMembership(hash, remoteArray, meta, verifiedRemoval) {
 	yield fx.dispatch({ type: "FetchRows" });
 	return outcome;
 }
+/**
+* The paced view-lost re-registration. A no-op when the row has been seen
+* since (the pacing was reset) or the query recovered or went away.
+*/
+function* recoverLostView(hash) {
+	const entry = yield fx.state.read((s) => s.queries.get(hash));
+	if (!entry || entry.viewLostRetryAt === null) return;
+	yield fx.state.update(setViewLost(hash, entry.viewLostCount, null));
+	if (entry.lifecycle.phase !== "view-lost") return;
+	if (entry.lifecycle.remote !== "unregistered") yield fx.state.update(applyLifecycle(hash, { type: "remote-dropped" }));
+	yield fx.dispatch({
+		type: "RegisterRemote",
+		hash
+	});
+}
 /** Replace the subquery child set; bodies follow through the fetch plan. */
 function* applySubqueryChildren(hash, children) {
 	const entry = yield fx.state.read((s) => s.queries.get(hash));
@@ -2990,10 +3054,11 @@ function* applySubqueryChildren(hash, children) {
 	yield fx.dispatch({ type: "FetchRows" });
 }
 const ok = (r) => r.ok;
+/** One statement's result, or `FAILED` when it did not answer (see `FAILED`). */
 const stmt$1 = (results, i) => {
-	if (!Array.isArray(results)) return null;
+	if (!Array.isArray(results)) return FAILED;
 	const r = results[i];
-	return r && r.status === "OK" ? r.result : null;
+	return r && r.status === "OK" ? r.result : FAILED;
 };
 /**
 * Read the server membership of many queries in as few round trips as the
@@ -3031,11 +3096,17 @@ function* readMembership(env, hashes, opts = {}) {
 		if (chunk.length === 1) {
 			const snap = snapshotFromSingle(stmt$1(r.value, 0), stmt$1(r.value, 1), stmt$1(r.value, 2));
 			if (snap) snapshots.set(chunk[0], snap);
+			else failed = true;
 			return;
 		}
 		const hashById = new Map(chunk.map((h) => [encodeRecordId(byHash.get(h).def.id), h]));
 		const edges = stmt$1(r.value, 0);
-		const batch = snapshotsFromBatch(edges, stmt$1(r.value, 1), hashById);
+		const counts = stmt$1(r.value, 1);
+		if (!Array.isArray(edges) || counts === FAILED) {
+			failed = true;
+			return;
+		}
+		const batch = snapshotsFromBatch(edges, counts, hashById);
 		const held = new Map(chunk.map((h) => [h, byHash.get(h).remoteArray.length]));
 		const suspect = new Set(suspectHashes(batch, held, Array.isArray(edges) ? edges.length : 0));
 		for (const [h, snap] of batch) if (suspect.has(h)) rereads.push(byHash.get(h));
@@ -3048,6 +3119,7 @@ function* readMembership(env, hashes, opts = {}) {
 		}
 		const snap = snapshotFromSingle(stmt$1(r.value, 0), stmt$1(r.value, 1), stmt$1(r.value, 2));
 		if (snap) snapshots.set(rereads[i].def.hash, snap);
+		else failed = true;
 	});
 	let changed = false;
 	const stillMaterializing = [];
@@ -3164,6 +3236,8 @@ function* registerLocal(env, input) {
 			lastHeartbeatAt: null,
 			lastPolledAt: null,
 			registerAttempts: 0,
+			viewLostCount: 0,
+			viewLostRetryAt: null,
 			telemetry: {
 				...emptyTelemetry(),
 				registrationTimings: reg.timings
@@ -3249,11 +3323,24 @@ function* registerRemote(env, hash, retry = false) {
 		if (!(yield fx.state.read((s) => s.queries.has(hash)))) return;
 		const register = stmt(results, 0);
 		if (!register || register.status === "ERR") throw new Error(register?.status === "ERR" ? register.error : "register returned nothing");
-		const edges = stmt(results, 1);
-		const meta = stmt(results, 2);
-		const children = stmt(results, 3);
-		const snap = snapshotFromSingle(edges?.status === "OK" ? edges.result : null, meta?.status === "OK" ? meta.result : null, children?.status === "OK" ? children.result : null);
-		if (!snap) throw new Error(edges?.status === "ERR" ? edges.error : "edge read returned no array");
+		const answer = (r) => r?.status === "OK" ? r.result : FAILED;
+		const snap = snapshotFromSingle(answer(stmt(results, 1)), answer(stmt(results, 2)), answer(stmt(results, 3)));
+		if (!snap) {
+			yield fx.state.update(compose(applyLifecycle(hash, { type: "remote-registered" }), 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;
+		}
 		if ((yield* applyMembership(hash, snap.primary, snap.meta)) === "ignored" && snap.meta.present && snap.meta.state === "materializing") {
 			yield fx.state.update(compose(markMembershipDirty$1([hash]), setMembershipReread(hash, 1)));
 			yield fx.timer.set("membership", 150, { type: "ReadDirtyMembership" });
@@ -5574,6 +5661,10 @@ function route(env, event) {
 			saga: registerRemote(env, event.hash, event.retry),
 			lane: dedupe(`register:${event.hash}`)
 		};
+		case "RecoverLostView": return {
+			saga: recoverLostView(event.hash),
+			lane: dedupe(`view-lost:${event.hash}`)
+		};
 		case "ReadDirtyMembership": return {
 			saga: readDirtyMembership(env),
 			lane: serial("membership")
@@ -12544,7 +12635,7 @@ function createTabsCoordinator(config, s, host) {
 	return new TabsCoordinator({
 		tabId: s.tabId,
 		fingerprint: computeTabsFingerprint({
-			coreVersion: "0.0.1-canary.256",
+			coreVersion: "0.0.1-canary.258",
 			schemaHash: hash53(config.schemaSurql),
 			endpoint: config.database.endpoint ?? "",
 			namespace: config.database.namespace,

package/package.json

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

package/src/client/router.ts

@@ -2,7 +2,7 @@ import type { RuntimeEvent } from '../kernel/events';
 import type { Lane, Saga } from '../kernel/saga';
 import type { SagaEnv } from '../query/env';
 import { ensureRegistered, registerRemote } from '../query/register.saga';
-import { readDirtyMembership, readMembership } from '../query/membership.saga';
+import { readDirtyMembership, readMembership, recoverLostView } from '../query/membership.saga';
 import { fetchRows } from '../query/fetch.saga';
 import { materialize, streamUpdate } from '../query/materialize.saga';
 import { ackPrune, gcTick, lifecycleTick } from '../query/lifecycle.saga';
@@ -37,6 +37,8 @@ export function route(env: SagaEnv, event: RuntimeEvent): RouteTarget {
       return { saga: ensureRegistered(env, { requireAuth: event.requireAuth, attempt: event.attempt }), lane: serial('ensure') };
     case 'RegisterRemote':
       return { saga: registerRemote(env, event.hash, event.retry), lane: dedupe(`register:${event.hash}`) };
+    case 'RecoverLostView':
+      return { saga: recoverLostView(event.hash), lane: dedupe(`view-lost:${event.hash}`) };
     case 'ReadDirtyMembership':
       return { saga: readDirtyMembership(env), lane: serial('membership') };
     case 'ReadMembership':

package/src/kernel/constants.ts

@@ -23,6 +23,13 @@ export const RETRY_BASE_MS = 500;
 export const RETRY_MAX_MS = 15_000;
 /** Registration attempts before a query is reported as failed to settle. */
 export const REGISTER_MAX_RETRIES = 3;
+/**
+ * Pacing of repeated view-lost recovery. The first re-registration after a
+ * `_00_query` row reads as gone is immediate; each further one for the same
+ * query, before the row has been seen again, waits on this backoff.
+ */
+export const VIEW_LOST_RETRY_BASE_MS = 1_000;
+export const VIEW_LOST_RETRY_MAX_MS = 30_000;
 /** `_00_list_ref` poll cadence (fallback when LIVE is quiet). */
 export const LIST_REF_POLL_BASE_MS = 500;
 export const LIST_REF_POLL_MAX_MS = 5_000;

package/src/kernel/events.ts

@@ -12,6 +12,7 @@ export type RuntimeEvent =
   | { type: 'SyncOutcome'; ok: boolean; error?: unknown }
   | { type: 'AckPrune' }
   | { type: 'ReadDirtyMembership' }
+  | { type: 'RecoverLostView'; hash: QueryHash }
   | { type: 'ReadMembership'; hashes: QueryHash[] }
   | { type: 'FetchRows' }
   | { type: 'Materialize'; hash: QueryHash }

package/src/query/membership.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 { applyMembership, applySubqueryChildren, markMembershipDirty, readDirtyMembership, readMembership } from './membership.saga';
+import { applyMembership, applySubqueryChildren, markMembershipDirty, readDirtyMembership, readMembership, recoverLostView } from './membership.saga';
 import type { StatementResult } from '../kernel/effects';
 
 const env = defaultEnv({ tables: [] } as any);
@@ -26,9 +26,51 @@ describe('applyMembership', () => {
     expect(out.state.queries.get('a')!.lifecycle).toMatchObject({ phase: 'view-lost', remote: 'unregistered' });
     expect(out.emitted).toEqual([{ type: 'query:view-lost', hash: 'a' }]);
     expect(out.dispatched).toEqual([{ type: 'EnsureRegistered' }]);
-    const again = await runPure(applyMembership('a', []), { state: out.state });
-    expect(again.emitted).toEqual([]);
-    expect(again.dispatched).toEqual([{ type: 'EnsureRegistered' }]);
+    expect(out.state.queries.get('a')!).toMatchObject({ viewLostCount: 1, viewLostRetryAt: null });
+  });
+  it('view-lost again before the row is seen: paced, and reads while it waits do nothing', async () => {
+    const lost = buildState([
+      buildEntry({ def: { hash: 'a' }, lifecycle: { phase: 'view-lost', remote: 'registered' }, remoteArray: [['t:1', 1]], viewLostCount: 1 }),
+    ]);
+    const again = await runPure(applyMembership('a', []), { state: lost, now: 1_000 });
+    expect(again.result).toBe('view-lost');
+    expect(again.emitted.filter((e) => e.type === 'query:view-lost')).toEqual([]);
+    expect(again.dispatched).toEqual([]);
+    expect(again.state.queries.get('a')!).toMatchObject({ viewLostCount: 2, viewLostRetryAt: 2_000 });
+    expect(again.state.queries.get('a')!.lifecycle.remote).toBe('registered');
+    expect(again.timers.get('view-lost:a')).toEqual({ ms: 1_000, event: { type: 'RecoverLostView', hash: 'a' } });
+
+    const waiting = await runPure(applyMembership('a', []), { state: again.state, now: 1_500 });
+    expect(waiting.dispatched).toEqual([]);
+    expect(waiting.timers.size).toBe(0);
+    expect(waiting.state.queries.get('a')!).toMatchObject({ viewLostCount: 2, viewLostRetryAt: 2_000 });
+
+    // The next retry waits longer.
+    const third = buildState([
+      buildEntry({ def: { hash: 'a' }, lifecycle: { phase: 'view-lost', remote: 'registered' }, remoteArray: [['t:1', 1]], viewLostCount: 3 }),
+    ]);
+    expect((await runPure(applyMembership('a', []), { state: third })).timers.get('view-lost:a')!.ms).toBe(4_000);
+  });
+  it('recoverLostView re-registers only while still lost and still scheduled', async () => {
+    const scheduled = (phase: 'view-lost' | 'live', retryAt: number | null) =>
+      buildState([
+        buildEntry({ def: { hash: 'a' }, lifecycle: { phase, remote: 'registered' }, remoteArray: [['t:1', 1]], viewLostCount: 2, viewLostRetryAt: retryAt }),
+      ]);
+    const due = await runPure(recoverLostView('a'), { state: scheduled('view-lost', 2_000) });
+    expect(due.dispatched).toEqual([{ type: 'RegisterRemote', hash: 'a' }]);
+    expect(due.state.queries.get('a')!).toMatchObject({ viewLostRetryAt: null, viewLostCount: 2 });
+    expect(due.state.queries.get('a')!.lifecycle.remote).toBe('unregistered');
+    expect((await runPure(recoverLostView('a'), { state: scheduled('view-lost', null) })).dispatched).toEqual([]);
+    expect((await runPure(recoverLostView('a'), { state: scheduled('live', 2_000) })).dispatched).toEqual([]);
+    expect((await runPure(recoverLostView('zz'), { state: scheduled('view-lost', 2_000) })).dispatched).toEqual([]);
+  });
+  it('seeing the row again resets the pacing', async () => {
+    const s = buildState([
+      buildEntry({ def: { hash: 'a' }, lifecycle: { phase: 'view-lost', remote: 'registered' }, remoteArray: [['t:1', 1]], viewLostCount: 3, viewLostRetryAt: 9_000 }),
+    ]);
+    const out = await runPure(applyMembership('a', [], { present: true, rowCount: 1, state: 'materializing' }), { state: s });
+    expect(out.result).toBe('ignored');
+    expect(out.state.queries.get('a')!).toMatchObject({ viewLostCount: 0, viewLostRetryAt: null });
   });
   it('applied: commits, writes the view row, flips authority once, releases acked items, asks for bodies', async () => {
     const s = buildState(
@@ -100,6 +142,32 @@ describe('readMembership', () => {
     expect(out.state.membershipDirty.size).toBe(0);
     expect(out.dispatched.at(-1)).toEqual({ type: 'SyncOutcome', ok: true, error: undefined });
   });
+  it('a meta statement that errored is a failed read, not a lost row', async () => {
+    const s = buildState([buildEntry({ def: { hash: 'a', id: qid('a') }, lifecycle: { phase: 'live', remote: 'registered' }, remoteArray: [['thing:1', 1]] })]);
+    const out = await runPure(readMembership(env, ['a']), {
+      state: s,
+      handlers: {
+        'remote.query': () => [ok([]), { status: 'ERR', error: 'The query was not executed due to a failed transaction' }, ok([])],
+      },
+    });
+    expect(out.result).toEqual({ changed: false, failed: true });
+    expect(out.state.queries.get('a')!.lifecycle).toMatchObject({ phase: 'live', remote: 'registered' });
+    expect(out.dispatched.filter((e) => e.type === 'EnsureRegistered')).toEqual([]);
+    expect(out.dispatched.at(-1)).toEqual({ type: 'SyncOutcome', ok: false, error: 'membership read failed' });
+  });
+  it('a batch whose meta statement errored is a failed read for every query in it', async () => {
+    const s = buildState([
+      buildEntry({ def: { hash: 'a', id: qid('a') }, lifecycle: { phase: 'cached', remote: 'registered' } }),
+      buildEntry({ def: { hash: 'b', id: qid('b') }, lifecycle: { phase: 'cached', remote: 'registered' } }),
+    ]);
+    const out = await runPure(readMembership(env, ['a', 'b']), {
+      state: s,
+      handlers: { 'remote.query': () => [ok([]), { status: 'ERR', error: 'timeout' }] },
+    });
+    expect(out.result.failed).toBe(true);
+    for (const h of ['a', 'b']) expect(out.state.queries.get(h)!.lifecycle.phase).toBe('cached');
+    expect(out.dispatched.filter((e) => e.type === 'EnsureRegistered')).toEqual([]);
+  });
   it('equal set on a live query applies nothing; a cached query with the same set still flips to live', async () => {
     const live = buildState([buildEntry({ def: { hash: 'a', id: qid('a') }, lifecycle: { phase: 'live' }, remoteArray: [['thing:1', 1]], serverState: 'ready' })]);
     const handlers = { 'remote.query': () => [ok([out1('1')]), ok({ rowCount: 1, state: 'ready' }), ok([])], 'local.upsert': () => undefined };
@@ -137,7 +205,7 @@ describe('readMembership', () => {
     expect(out.state.queries.get('b')!.remoteArray).toEqual([['thing:2', 1], ['thing:3', 1]]);
     expect(out.result.changed).toBe(true);
   });
-  it('failures: a failed chunk or re-read reports failed; a non-array primary is skipped', async () => {
+  it('failures: a failed chunk or re-read reports failed; a non-array primary is a failed read', async () => {
     const s = buildState([
       buildEntry({ def: { hash: 'a', id: qid('a') }, lifecycle: { phase: 'live' }, remoteArray: [['thing:1', 1]] }),
       buildEntry({ def: { hash: 'b', id: qid('b') }, lifecycle: { phase: 'live' }, remoteArray: [['thing:2', 1]] }),
@@ -167,13 +235,16 @@ describe('readMembership', () => {
     expect(n).toBe(3);
     const single = buildState([buildEntry({ def: { hash: 'a', id: qid('a') }, lifecycle: { phase: 'live' }, remoteArray: [['thing:1', 1]] })]);
     const notArray = await runPure(readMembership(env, ['a']), { state: single, handlers: { 'remote.query': () => [ok('x'), ok(null), ok(null)] } });
-    expect(notArray.result).toEqual({ changed: false, failed: false });
+    expect(notArray.result).toEqual({ changed: false, failed: true });
+    expect(notArray.state.queries.get('a')!.lifecycle.phase).toBe('live');
     const batchNotArray = await runPure(readMembership(env, ['a', 'b']), { state: s, handlers: { 'remote.query': () => [ok(null), ok(null)] } });
-    expect(batchNotArray.result).toEqual({ changed: false, failed: false });
+    expect(batchNotArray.result).toEqual({ changed: false, failed: true });
     const undefinedResult = await runPure(readMembership(env, ['a']), { state: single, handlers: { 'remote.query': () => undefined } });
-    expect(undefinedResult.result).toEqual({ changed: false, failed: false });
+    expect(undefinedResult.result).toEqual({ changed: false, failed: true });
     const errStmt = await runPure(readMembership(env, ['a']), { state: single, handlers: { 'remote.query': () => [{ status: 'ERR', error: 'x' }, ok(null), ok(null)] } });
-    expect(errStmt.result).toEqual({ changed: false, failed: false });
+    expect(errStmt.result).toEqual({ changed: false, failed: true });
+    // None of those is evidence the view is gone.
+    for (const r of [notArray, undefinedResult, errStmt]) expect(r.dispatched.filter((d) => d.type === 'EnsureRegistered')).toEqual([]);
   });
   it('materializing views walk the re-read ladder then stop', async () => {
     const s = buildState([buildEntry({ def: { hash: 'a', id: qid('a') }, lifecycle: { phase: 'cold' } })]);

package/src/query/membership.saga.ts

@@ -2,7 +2,13 @@ import type { QueryHash, RecordVersionArray, ServerViewMeta } from '../types';
 import type { Saga } from '../kernel/saga';
 import type { Settled, StatementResult } from '../kernel/effects';
 import { fx } from '../kernel/effects';
-import { MATERIALIZING_REREAD_LADDER_MS, MEMBERSHIP_COALESCE_MS } from '../kernel/constants';
+import {
+  MATERIALIZING_REREAD_LADDER_MS,
+  MEMBERSHIP_COALESCE_MS,
+  VIEW_LOST_RETRY_BASE_MS,
+  VIEW_LOST_RETRY_MAX_MS,
+  backoffMs,
+} from '../kernel/constants';
 import type { ClientState, QueryEntry } from '../state/client-state';
 import { isAuthoritative } from '../state/lifecycle';
 import * as R from '../state/reducers';
@@ -12,6 +18,7 @@ import type { SagaEnv } from './env';
 import { listRefTable } from './env';
 import * as sql from './sql';
 import {
+  FAILED,
   decideMembershipOutcome,
   snapshotFromSingle,
   snapshotsFromBatch,
@@ -34,6 +41,10 @@ export function* applyMembership(
   const entry = (yield fx.state.read((s) => s.queries.get(hash))) as QueryEntry | undefined;
   if (!entry) return 'ignored';
   if (meta) yield fx.state.update(R.setServerState(hash, meta.present ? meta.state : null));
+  // The row is there: whatever made it read as gone has passed.
+  if (meta?.present && (entry.viewLostCount > 0 || entry.viewLostRetryAt !== null)) {
+    yield fx.state.update(R.setViewLost(hash, 0, null));
+  }
   const outcome = decideMembershipOutcome({
     phase: entry.lifecycle.phase,
     held: entry.remoteArray.length,
@@ -47,10 +58,30 @@ export function* applyMembership(
       yield fx.state.update(R.applyLifecycle(hash, { type: 'row-missing' }));
       yield fx.emit({ type: 'query:view-lost', hash });
     }
-    if (entry.lifecycle.remote !== 'unregistered') {
-      yield fx.state.update(R.applyLifecycle(hash, { type: 'remote-dropped' }));
+    // A recovery is already scheduled: every read in the meantime would
+    // otherwise re-register again.
+    if (entry.viewLostRetryAt !== null) return outcome;
+    if (entry.viewLostCount === 0) {
+      yield fx.state.update(R.setViewLost(hash, 1, null));
+      if (entry.lifecycle.remote !== 'unregistered') {
+        yield fx.state.update(R.applyLifecycle(hash, { type: 'remote-dropped' }));
+      }
+      yield fx.dispatch({ type: 'EnsureRegistered' });
+      return outcome;
     }
-    yield fx.dispatch({ type: 'EnsureRegistered' });
+    // Re-registered already and the row still reads as gone. Under load that
+    // repeated every read, each one costing the server a registration while it
+    // was still publishing the last, so from here on it is paced.
+    const delay = backoffMs(entry.viewLostCount - 1, VIEW_LOST_RETRY_BASE_MS, VIEW_LOST_RETRY_MAX_MS);
+    const now = (yield fx.now()) as number;
+    yield fx.state.update(R.setViewLost(hash, entry.viewLostCount + 1, now + delay));
+    yield fx.emit({
+      type: 'log',
+      level: 'debug',
+      message: 'view still lost; re-registering after a delay',
+      data: { hash, attempt: entry.viewLostCount + 1, delayMs: delay },
+    });
+    yield fx.timer.set(`view-lost:${hash}`, delay, { type: 'RecoverLostView', hash });
     return outcome;
   }
   const wasAuthoritative = isAuthoritative(entry.lifecycle);
@@ -66,6 +97,21 @@ export function* applyMembership(
   return outcome;
 }
 
+/**
+ * The paced view-lost re-registration. A no-op when the row has been seen
+ * since (the pacing was reset) or the query recovered or went away.
+ */
+export function* recoverLostView(hash: QueryHash): Saga<void> {
+  const entry = (yield fx.state.read((s) => s.queries.get(hash))) as QueryEntry | undefined;
+  if (!entry || entry.viewLostRetryAt === null) return;
+  yield fx.state.update(R.setViewLost(hash, entry.viewLostCount, null));
+  if (entry.lifecycle.phase !== 'view-lost') return;
+  if (entry.lifecycle.remote !== 'unregistered') {
+    yield fx.state.update(R.applyLifecycle(hash, { type: 'remote-dropped' }));
+  }
+  yield fx.dispatch({ type: 'RegisterRemote', hash });
+}
+
 /** Replace the subquery child set; bodies follow through the fetch plan. */
 export function* applySubqueryChildren(hash: QueryHash, children: RecordVersionArray): Saga<void> {
   const entry = (yield fx.state.read((s) => s.queries.get(hash))) as QueryEntry | undefined;
@@ -75,10 +121,11 @@ export function* applySubqueryChildren(hash: QueryHash, children: RecordVersionA
 }
 
 const ok = (r: Settled): r is { ok: true; value: unknown } => r.ok;
+/** One statement's result, or `FAILED` when it did not answer (see `FAILED`). */
 const stmt = (results: unknown, i: number): unknown => {
-  if (!Array.isArray(results)) return null;
+  if (!Array.isArray(results)) return FAILED;
   const r = (results as StatementResult[])[i];
-  return r && r.status === 'OK' ? r.result : null;
+  return r && r.status === 'OK' ? r.result : FAILED;
 };
 
 /**
@@ -123,11 +170,17 @@ export function* readMembership(
     if (chunk.length === 1) {
       const snap = snapshotFromSingle(stmt(r.value, 0) as never, stmt(r.value, 1) as never, stmt(r.value, 2) as never);
       if (snap) snapshots.set(chunk[0], snap);
+      else failed = true;
       return;
     }
     const hashById = new Map(chunk.map((h) => [encodeRecordId(byHash.get(h)!.def.id), h]));
     const edges = stmt(r.value, 0) as never[] | null;
-    const batch = snapshotsFromBatch(edges, stmt(r.value, 1) as never, hashById);
+    const counts = stmt(r.value, 1);
+    if (!Array.isArray(edges) || counts === FAILED) {
+      failed = true;
+      return;
+    }
+    const batch = snapshotsFromBatch(edges, counts as never, hashById);
     const held = new Map(chunk.map((h) => [h, byHash.get(h)!.remoteArray.length]));
     const suspect = new Set(suspectHashes(batch, held, Array.isArray(edges) ? edges.length : 0));
     for (const [h, snap] of batch) {
@@ -144,6 +197,7 @@ export function* readMembership(
       }
       const snap = snapshotFromSingle(stmt(r.value, 0) as never, stmt(r.value, 1) as never, stmt(r.value, 2) as never);
       if (snap) snapshots.set(rereads[i].def.hash, snap);
+      else failed = true;
     });
   }
 

package/src/query/membership.ts

@@ -76,6 +76,15 @@ export function decideMembershipOutcome(input: MembershipDecisionInput): Members
 
 // ---- list_ref snapshots ------------------------------------------------------
 
+/**
+ * A statement that did not answer (an ERR, or no result at all). Kept apart
+ * from a `null` result, which is the server saying "no such row": reading a
+ * failed statement as a missing row turned every timeout under load into a
+ * lost view and re-registered it, over and over (whitepawn, 2026-09-16).
+ */
+export const FAILED: unique symbol = Symbol('statement failed');
+export type Answer<T> = T | null | typeof FAILED;
+
 export interface ListRefEdgeRow {
   in: RecordId<string>;
   out: RecordId<string>;
@@ -92,28 +101,32 @@ export interface ListRefSnapshot {
 const toPairs = (rows: Array<{ out: RecordId<string>; version: number }> | null | undefined): RecordVersionArray =>
   dedupeRecordVersions(Array.isArray(rows) ? rows.map((r) => [encodeRecordId(r.out), r.version]) : []);
 
-/** Fold the single-query statement batch (edges, meta, children) into a snapshot. */
+/**
+ * Fold the single-query statement batch (edges, meta, children) into a
+ * snapshot. `null` when any of the three did not answer: half an answer is
+ * not one, and a missing meta would read as a lost view.
+ */
 export function snapshotFromSingle(
-  items: Array<{ out: RecordId<string>; version: number }> | null,
-  metaRow: QueryMetaRow | null,
-  children: Array<{ out: RecordId<string>; version: number }> | null
+  items: Answer<Array<{ out: RecordId<string>; version: number }>>,
+  metaRow: Answer<QueryMetaRow>,
+  children: Answer<Array<{ out: RecordId<string>; version: number }>>
 ): ListRefSnapshot | null {
-  if (!Array.isArray(items)) return null;
+  if (!Array.isArray(items) || metaRow === FAILED || children === FAILED) return null;
   return { primary: toPairs(items), subquery: toPairs(children), meta: metaFromRow(metaRow) };
 }
 
 /**
  * Fold the many-query statement batch into one snapshot per hash. Every hash
  * in `hashById` gets a snapshot; a query whose row did not come back reads
- * `present: false`.
+ * `present: false`. Empty when either statement did not answer.
  */
 export function snapshotsFromBatch(
-  edges: ListRefEdgeRow[] | null,
-  counts: Array<QueryMetaRow | null> | null,
+  edges: Answer<ListRefEdgeRow[]>,
+  counts: Answer<Array<QueryMetaRow | null>>,
   hashById: ReadonlyMap<string, string>
 ): Map<string, ListRefSnapshot> {
   const out = new Map<string, ListRefSnapshot>();
-  if (!Array.isArray(edges)) return out;
+  if (!Array.isArray(edges) || counts === FAILED) return out;
   for (const hash of hashById.values()) {
     out.set(hash, { primary: [], subquery: [], meta: { present: false, rowCount: null, state: null } });
   }

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

@@ -193,16 +193,20 @@ describe('registerRemote', () => {
       handlers: { 'remote.query': () => [{ status: 'ERR', error: 'denied' }] },
     });
     expect(errStmt.state.queries.get('a')!.registerAttempts).toBe(1);
-    const edgesErr = await runPure(registerRemote(env, 'a'), {
-      state: buildState([entry]),
-      handlers: { 'remote.query': () => [okStmt(null), { status: 'ERR', error: 'no table' }, okStmt(null), okStmt(null)] },
-    });
-    expect(edgesErr.state.queries.get('a')!.registerAttempts).toBe(1);
-    const noArray = await runPure(registerRemote(env, 'a'), {
-      state: buildState([entry]),
-      handlers: { 'remote.query': () => [okStmt(null), okStmt('nope'), okStmt(null), okStmt(null)] },
-    });
-    expect(noArray.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'), {
@@ -246,18 +250,22 @@ describe('registerRemote', () => {
     expect(isNotAllowlisted('HTTP 4030')).toBe(false);
   });
 
-  it('tolerates ERR meta/children statements: edges still apply, missing meta reads as no row', async () => {
-    const out = await runPure(registerRemote(env, 'a'), {
-      state: buildState([entry]),
-      handlers: {
-        'remote.query': () => [okStmt(null), okStmt([{ out: new RecordId('thing', '1'), version: 1 }]), { status: 'ERR', error: 'meta' }, { status: 'ERR', error: 'kids' }],
-        'local.upsert': () => undefined,
-      },
-    });
-    const e = out.state.queries.get('a')!;
-    expect(e.lifecycle).toMatchObject({ phase: 'live', remote: 'registered' });
-    expect(e.serverState).toBeNull();
-    expect(e.subqueryRemoteArray).toEqual([]);
+  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'), {

package/src/query/register.saga.ts

@@ -14,8 +14,8 @@ import { parseDuration } from '../utils/index';
 import type { SagaEnv } from './env';
 import { listRefTable } from './env';
 import { queryHashInput, viewKeyInput } from './hash';
-import { isResolvedBefore, parseViewRow, snapshotFromSingle } from './membership';
-import { applyMembership, applySubqueryChildren } from './membership.saga';
+import { FAILED, isResolvedBefore, parseViewRow, snapshotFromSingle } from './membership';
+import { applyMembership, applySubqueryChildren, markMembershipDirty } from './membership.saga';
 import * as sql from './sql';
 
 export interface RegisterInput {
@@ -86,6 +86,8 @@ export function* registerLocal(env: SagaEnv, input: RegisterInput): Saga<QueryHa
       lastHeartbeatAt: null,
       lastPolledAt: null,
       registerAttempts: 0,
+      viewLostCount: 0,
+      viewLostRetryAt: null,
       telemetry: { ...emptyTelemetry(), registrationTimings: reg.timings },
     };
     yield fx.state.update(R.putQuery(entry));
@@ -163,15 +165,23 @@ export function* registerRemote(env: SagaEnv, hash: QueryHash, retry = false): S
     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 edges = stmt(results, 1);
-    const meta = stmt(results, 2);
-    const children = stmt(results, 3);
+    const answer = (r: StatementResult | undefined): unknown => (r?.status === 'OK' ? r.result : FAILED);
     const snap = snapshotFromSingle(
-      edges?.status === 'OK' ? (edges.result as never) : null,
-      meta?.status === 'OK' ? (meta.result as never) : null,
-      children?.status === 'OK' ? (children.result as never) : null
+      answer(stmt(results, 1)) as never,
+      answer(stmt(results, 2)) as never,
+      answer(stmt(results, 3)) as never
     );
-    if (!snap) throw new Error(edges?.status === 'ERR' ? edges.error : 'edge read returned no array');
+    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)));

package/src/state/client-state.ts

@@ -58,6 +58,13 @@ export interface QueryEntry {
   readonly lastHeartbeatAt: number | null;
   readonly lastPolledAt: number | null;
   readonly registerAttempts: number;
+  /**
+   * Re-registrations issued because the `_00_query` row read as gone, since
+   * the row was last seen. Paces the next one (see `applyMembership`).
+   */
+  readonly viewLostCount: number;
+  /** When the paced re-registration is due; null when none is pending. */
+  readonly viewLostRetryAt: number | null;
   readonly telemetry: QueryTelemetry;
 }
 

package/src/state/reducers.ts

@@ -188,6 +188,16 @@ export const bumpRegisterAttempts =
   (s) =>
     withEntry(s, hash, (e) => ({ ...e, registerAttempts: e.registerAttempts + 1 }));
 
+/** View-lost recovery pacing; see `QueryEntry.viewLostCount`. */
+export const setViewLost =
+  (hash: QueryHash, viewLostCount: number, viewLostRetryAt: number | null): Reducer =>
+  (s) =>
+    withEntry(s, hash, (e) =>
+      e.viewLostCount === viewLostCount && e.viewLostRetryAt === viewLostRetryAt
+        ? e
+        : { ...e, viewLostCount, viewLostRetryAt }
+    );
+
 export const resetRegisterAttempts =
   (hash: QueryHash): Reducer =>
   (s) =>
@@ -421,6 +431,8 @@ export const rebindQuery =
       lastHeartbeatAt: null,
       lastPolledAt: null,
       registerAttempts: 0,
+      viewLostCount: 0,
+      viewLostRetryAt: null,
     }));
     return rebound === s ? s : { ...rebound, dirty: addAll(rebound.dirty, [hash]) };
   };

package/src/testing/build.ts

@@ -38,6 +38,8 @@ export function buildEntry(over: DeepPartial<QueryEntry> & { def?: Partial<Query
     lastHeartbeatAt: over.lastHeartbeatAt ?? null,
     lastPolledAt: over.lastPolledAt ?? null,
     registerAttempts: over.registerAttempts ?? 0,
+    viewLostCount: over.viewLostCount ?? 0,
+    viewLostRetryAt: over.viewLostRetryAt ?? null,
     telemetry: { ...emptyTelemetry(), ...(over.telemetry as object) },
   };
 }