@spooky-sync/core 0.0.1-canary.69 → 0.0.1-canary.70

package/dist/index.js

@@ -152,12 +152,21 @@ function generateId() {
 	return Uuid.v4().toString().replace(/-/g, "");
 }
 /**
+* Read the millisecond count off a surrealdb `Duration`. Different `surrealdb`
+* releases expose it under `milliseconds` (current) or the older private
+* `_milliseconds` field, so read whichever is set; returns 0 when neither is.
+*/
+function durationMillis(duration) {
+	const d = duration;
+	return Number(d.milliseconds || d._milliseconds || 0);
+}
+/**
 * Parse duration string or Duration object to milliseconds
 */
 function parseDuration(duration) {
 	if (duration instanceof Duration) {
-		const ms = duration.milliseconds || duration._milliseconds;
-		if (ms) return Number(ms);
+		const ms = durationMillis(duration);
+		if (ms) return ms;
 		const str = duration.toString();
 		if (str !== "[object Object]") return parseDuration(str);
 		return 6e5;
@@ -209,8 +218,160 @@ async function withRetry(logger, operation, retries = 3, delayMs = 100) {
 	throw lastError;
 }
 
+//#endregion
+//#region src/modules/data/window-query.ts
+/**
+* Rewrite a windowed (`LIMIT n START m`, m>0) SELECT so its rows are
+* materialized from an explicit record-id set — the window the SSP already
+* computed — instead of re-running the original query (with its `START m`)
+* against the shared local DB.
+*
+* Why: `DataModule.processStreamUpdate` materializes a query's rows by
+* re-querying the local in-browser SurrealDB with the original surql. For an
+* offset query that re-applies `START m` against the *shared* local store —
+* which, with sparse windowing, may hold only this window's rows — so it skips
+* them all and returns nothing (the "page 2 returns 0 rows" bug). The SSP's
+* materialized view (`StreamUpdate.localArray`) is exactly this window's row
+* ids, so we select those ids directly and re-apply the original `ORDER BY` for
+* stable display order.
+*
+* Returns `null` for non-offset queries (`START` absent or 0) — the caller
+* keeps the normal re-query path, so only the broken case changes behavior.
+*
+* Preserves the `SELECT <projection>` clause and the top-level `ORDER BY`;
+* drops the original `FROM`/`WHERE`/`LIMIT`/`START`. Subqueries inside the
+* projection are preserved verbatim (the scanner is paren/quote aware), with
+* one caveat: SurrealDB v3 drops `*` in the `SELECT *, <subquery> FROM $param`
+* shape — such windowed+subquery queries are rare and were already returning 0,
+* so this is no regression.
+*/
+function buildWindowMaterialization(surql, idsParam = "__win") {
+	const kw = scanTopLevelClauses(surql);
+	if (kw.startValue === null || kw.startValue <= 0) return null;
+	if (kw.fromIndex === null) return null;
+	const selectClause = surql.slice(0, kw.fromIndex).trimEnd();
+	let orderBy = "";
+	if (kw.orderByIndex !== null) {
+		const ends = [
+			kw.limitIndex,
+			kw.startIndex,
+			kw.semicolonIndex,
+			surql.length
+		].filter((n) => n !== null && n > kw.orderByIndex);
+		const end = Math.min(...ends);
+		orderBy = " " + surql.slice(kw.orderByIndex, end).trim();
+	}
+	return { query: `${selectClause} FROM $${idsParam}${orderBy}` };
+}
+function scanTopLevelClauses(sql) {
+	const out = {
+		fromIndex: null,
+		orderByIndex: null,
+		limitIndex: null,
+		startIndex: null,
+		startValue: null,
+		semicolonIndex: null
+	};
+	let depth = 0;
+	let inStr = false;
+	for (let i = 0; i < sql.length; i++) {
+		const ch = sql[i];
+		if (inStr) {
+			if (ch === "\\") i++;
+			else if (ch === "'") inStr = false;
+			continue;
+		}
+		if (ch === "'") {
+			inStr = true;
+			continue;
+		}
+		if (ch === "(") {
+			depth++;
+			continue;
+		}
+		if (ch === ")") {
+			depth--;
+			continue;
+		}
+		if (depth !== 0) continue;
+		if (ch === ";" && out.semicolonIndex === null) {
+			out.semicolonIndex = i;
+			continue;
+		}
+		if (!isWordBoundary(sql, i)) continue;
+		if (out.fromIndex === null && matchKeyword(sql, i, "FROM")) {
+			out.fromIndex = i;
+			continue;
+		}
+		if (out.fromIndex === null) continue;
+		if (out.orderByIndex === null && matchKeyword(sql, i, "ORDER BY")) {
+			out.orderByIndex = i;
+			continue;
+		}
+		if (out.limitIndex === null && matchKeyword(sql, i, "LIMIT")) {
+			out.limitIndex = i;
+			continue;
+		}
+		if (out.startIndex === null && matchKeyword(sql, i, "START")) {
+			out.startIndex = i;
+			out.startValue = readNumberAfter(sql, i + 5);
+			continue;
+		}
+	}
+	return out;
+}
+function isWordBoundary(sql, i) {
+	if (i === 0) return true;
+	return !/[A-Za-z0-9_]/.test(sql[i - 1]);
+}
+function matchKeyword(sql, i, keyword) {
+	const parts = keyword.split(" ");
+	let pos = i;
+	for (let p = 0; p < parts.length; p++) {
+		const word = parts[p];
+		if (sql.slice(pos, pos + word.length).toUpperCase() !== word) return false;
+		pos += word.length;
+		if (p < parts.length - 1) {
+			const wsStart = pos;
+			while (pos < sql.length && /\s/.test(sql[pos])) pos++;
+			if (pos === wsStart) return false;
+		}
+	}
+	return pos >= sql.length || !/[A-Za-z0-9_]/.test(sql[pos]);
+}
+function readNumberAfter(sql, from) {
+	let pos = from;
+	while (pos < sql.length && /\s/.test(sql[pos])) pos++;
+	const m = /^\d+/.exec(sql.slice(pos));
+	return m ? parseInt(m[0], 10) : null;
+}
+
 //#endregion
 //#region src/modules/data/index.ts
+/** Push a timing sample (ms) into a rolling window, capped at the sample window. */
+function pushSample(samples, ms) {
+	samples.push(ms);
+	if (samples.length > MATERIALIZATION_SAMPLE_WINDOW) samples.shift();
+}
+/** Build a {lastMs,p50,p90,p99,count} summary from a rolling sample window. */
+function phaseStatOf(samples, lastMs) {
+	if (samples.length === 0) return {
+		lastMs,
+		p50: null,
+		p90: null,
+		p99: null,
+		count: 0
+	};
+	const sorted = [...samples].sort((a, b) => a - b);
+	const pick = (q) => sorted[Math.min(sorted.length - 1, Math.floor(q * sorted.length))];
+	return {
+		lastMs,
+		p50: pick(.5),
+		p90: pick(.9),
+		p99: pick(.99),
+		count: samples.length
+	};
+}
 /**
 * DataModule - Unified query and mutation management
 *
@@ -221,9 +382,36 @@ var DataModule = class {
 	activeQueries = /* @__PURE__ */ new Map();
 	pendingQueries = /* @__PURE__ */ new Map();
 	subscriptions = /* @__PURE__ */ new Map();
+	statusSubscriptions = /* @__PURE__ */ new Map();
 	mutationCallbacks = /* @__PURE__ */ new Set();
 	debounceTimers = /* @__PURE__ */ new Map();
 	logger;
+	/**
+	* Optional observer notified whenever a query's fetch status changes.
+	* Wired by Sp00kyClient to push status changes into DevTools. Kept as a
+	* settable field (rather than a constructor arg) because DevTools is
+	* constructed after DataModule.
+	*/
+	onQueryStatusChange;
+	/**
+	* Optional observer invoked when a still-subscribed query's TTL heartbeat
+	* fires (~90% of the TTL). Wired by Sp00kyClient to
+	* `Sp00kySync.heartbeatQuery`, which refreshes the remote `_00_query`
+	* row's `lastActiveAt` so an actively-watched query never expires. Settable
+	* field (not a constructor arg) because the sync engine is wired after
+	* DataModule is constructed — mirrors `onQueryStatusChange`.
+	*/
+	onHeartbeat;
+	/**
+	* Optional hook fired by {@link deregisterQuery} when an opt-in query (e.g. a
+	* viewport-windowed list cancelling an off-screen window) loses its last
+	* subscriber. Wired by Sp00kyClient to enqueue a `cleanup` down-event, which
+	* tears the remote `_00_query` view down (releasing its `_00_list_ref` edges)
+	* instead of leaving it for the TTL sweep. The local view + state are freed in
+	* {@link finalizeDeregister} only after that remote delete, so a fast
+	* re-subscribe (scroll back) can abort/heal the teardown — see `cleanupQuery`.
+	*/
+	onDeregister;
 	sessionId = "";
 	currentUserId = null;
 	constructor(cache, local, schema, logger, streamDebounceTime = 100) {
@@ -323,6 +511,36 @@ var DataModule = class {
 		};
 	}
 	/**
+	* Subscribe to a query's fetch-status changes (idle/fetching).
+	* With `{ immediate: true }` the callback fires synchronously with the
+	* current status (defaults to `idle` if the query isn't registered yet).
+	*/
+	subscribeStatus(queryHash, callback, options = {}) {
+		if (!this.statusSubscriptions.has(queryHash)) this.statusSubscriptions.set(queryHash, /* @__PURE__ */ new Set());
+		this.statusSubscriptions.get(queryHash)?.add(callback);
+		if (options.immediate) callback(this.activeQueries.get(queryHash)?.status ?? "idle");
+		return () => {
+			const subs = this.statusSubscriptions.get(queryHash);
+			if (subs) {
+				subs.delete(callback);
+				if (subs.size === 0) this.statusSubscriptions.delete(queryHash);
+			}
+		};
+	}
+	/**
+	* Set a query's fetch status and notify status observers (DevTools +
+	* `subscribeStatus` listeners). No-op when the status is unchanged or the
+	* query is unknown.
+	*/
+	setQueryStatus(queryHash, status) {
+		const queryState = this.activeQueries.get(queryHash);
+		if (!queryState || queryState.status === status) return;
+		queryState.status = status;
+		this.onQueryStatusChange?.(queryHash, status);
+		const subs = this.statusSubscriptions.get(queryHash);
+		if (subs) for (const callback of subs) callback(status);
+	}
+	/**
 	* Subscribe to mutations (for sync)
 	*/
 	onMutation(callback) {
@@ -336,14 +554,39 @@ var DataModule = class {
 	*/
 	async onStreamUpdate(update) {
 		const { queryHash, op } = update;
-		if (op === "UPDATE") {
-			if (this.debounceTimers.has(queryHash)) clearTimeout(this.debounceTimers.get(queryHash));
-			const timer = setTimeout(async () => {
+		if (op === "DELETE") {
+			const existing = this.debounceTimers.get(queryHash);
+			if (existing) {
+				clearTimeout(existing);
 				this.debounceTimers.delete(queryHash);
-				await this.processStreamUpdate(update);
-			}, this.streamDebounceTime);
-			this.debounceTimers.set(queryHash, timer);
-		} else await this.processStreamUpdate(update);
+			}
+			await this.processStreamUpdate(update);
+			return;
+		}
+		if (this.debounceTimers.has(queryHash)) clearTimeout(this.debounceTimers.get(queryHash));
+		const timer = setTimeout(async () => {
+			this.debounceTimers.delete(queryHash);
+			await this.processStreamUpdate(update);
+		}, this.streamDebounceTime);
+		this.debounceTimers.set(queryHash, timer);
+	}
+	async materializeRecords(queryState, sspArray) {
+		const t0 = performance.now();
+		const windowMat = buildWindowMaterialization(queryState.config.surql);
+		let records;
+		if (windowMat) {
+			const winIds = (queryState.config.remoteArray?.length && queryState.config.remoteArray || sspArray?.length && sspArray || queryState.config.localArray || []).map(([id]) => parseRecordIdString(id));
+			const [rows] = await this.local.query(windowMat.query, {
+				...queryState.config.params,
+				__win: winIds
+			});
+			records = rows || [];
+		} else {
+			const [rows] = await this.local.query(queryState.config.surql, queryState.config.params);
+			records = rows || [];
+		}
+		this.recordPhase(queryState, "localFetch", performance.now() - t0);
+		return records;
 	}
 	async processStreamUpdate(update) {
 		const { queryHash, localArray, materializationTimeMs } = update;
@@ -360,10 +603,12 @@ var DataModule = class {
 			if (queryState.materializationSamples.length > MATERIALIZATION_SAMPLE_WINDOW) queryState.materializationSamples.shift();
 			queryState.lastIngestLatencyMs = materializationTimeMs;
 		}
+		if (typeof update.storeApplyMs === "number") this.recordPhase(queryState, "sspStoreApply", update.storeApplyMs);
+		if (typeof update.circuitStepMs === "number") this.recordPhase(queryState, "sspCircuitStep", update.circuitStepMs);
+		if (typeof update.transformMs === "number") this.recordPhase(queryState, "sspTransform", update.transformMs);
 		const percentiles = this.computeMaterializationPercentiles(queryState.materializationSamples);
 		try {
-			const [records] = await this.local.query(queryState.config.surql, queryState.config.params);
-			const newRecords = records || [];
+			const newRecords = await this.materializeRecords(queryState, localArray);
 			queryState.config.localArray = localArray;
 			const prevJson = JSON.stringify(queryState.records);
 			const newJson = JSON.stringify(newRecords);
@@ -399,7 +644,7 @@ var DataModule = class {
 			if (subscribers) for (const callback of subscribers) callback(queryState.records);
 			this.logger.debug({
 				queryHash,
-				recordCount: records?.length,
+				recordCount: newRecords?.length,
 				Category: "sp00ky-client::DataModule::onStreamUpdate"
 			}, "Query updated from stream");
 		} catch (err) {
@@ -444,6 +689,45 @@ var DataModule = class {
 			p99: pick(.99)
 		};
 	}
+	/** Record a per-phase timing sample (ms) on a query's rolling window. */
+	recordPhase(qs, phase, ms) {
+		if (!Number.isFinite(ms)) return;
+		pushSample(qs.phaseSamples[phase] ?? (qs.phaseSamples[phase] = []), ms);
+		qs.phaseLast[phase] = ms;
+	}
+	/** Record the remote record-fetch time (ms) for a query. Called by the sync engine. */
+	recordRemoteFetch(hash, ms) {
+		const qs = this.activeQueries.get(hash);
+		if (qs) this.recordPhase(qs, "remoteFetch", ms);
+	}
+	/**
+	* Record the frontend reconcile time (ms) for a query. Called from `useQuery`
+	* via `Sp00kyClient.reportFrontendTiming` after it applies an update to its store.
+	*/
+	recordFrontendTiming(hash, ms) {
+		const qs = this.activeQueries.get(hash);
+		if (qs) this.recordPhase(qs, "frontend", ms);
+	}
+	/**
+	* Build the per-query processing-time breakdown surfaced to the DevTools panel
+	* and the MCP. `ssp` is the WASM-ingest wall time (from `materializationSamples`);
+	* the rest come from the per-phase rolling windows + one-shot registration timings.
+	*/
+	phaseTimings(q) {
+		const stat = (phase) => phaseStatOf(q.phaseSamples[phase] ?? [], q.phaseLast[phase] ?? null);
+		return {
+			ssp: phaseStatOf(q.materializationSamples, q.lastIngestLatencyMs),
+			sspStoreApply: stat("sspStoreApply"),
+			sspCircuitStep: stat("sspCircuitStep"),
+			sspTransform: stat("sspTransform"),
+			localFetch: stat("localFetch"),
+			remoteFetch: stat("remoteFetch"),
+			frontend: stat("frontend"),
+			registration: q.registrationTimings,
+			updateCount: q.updateCount,
+			errorCount: q.errorCount
+		};
+	}
 	/**
 	* Get query state (for sync and devtools)
 	*/
@@ -451,6 +735,84 @@ var DataModule = class {
 		return this.activeQueries.get(hash);
 	}
 	/**
+	* Cold-query guard for instant-hydrate: true when the query exists, hasn't been
+	* hydrated, and has NOT yet fetched its server result (`remoteArray` empty).
+	* We gate on `remoteArray`, not local `records`: a windowed query is often
+	* partially pre-seeded from the circuit (e.g. the dashboard's 5-row preview),
+	* but it still hasn't loaded its own full window from the server — so it should
+	* still hydrate. A warm re-subscribe (remoteArray already populated) is skipped.
+	*/
+	isCold(hash) {
+		const qs = this.activeQueries.get(hash);
+		return !!qs && !qs.hydrated && (qs.config.remoteArray?.length ?? 0) === 0;
+	}
+	/**
+	* Instant-hydrate: ingest rows fetched one-shot from the remote (the query's own
+	* surql run directly) so the query DISPLAYS immediately, while the full realtime
+	* registration proceeds in the background. Ingests with versions (`_00_rv`) so the
+	* later `syncRecords` dedup skips re-pulling unchanged bodies, and seeds
+	* `remoteArray` so windowed queries materialize the correct window (no sparse
+	* local-circuit issue). Runs at most once per query (the `hydrated` flag).
+	*/
+	async applyHydration(hash, rows) {
+		const queryState = this.activeQueries.get(hash);
+		if (!queryState) return;
+		queryState.hydrated = true;
+		if (rows.length === 0) return;
+		const tableName = queryState.config.tableName;
+		const batch = rows.map((record) => ({
+			table: tableName,
+			op: "CREATE",
+			record,
+			version: record._00_rv || 1
+		}));
+		await this.cache.saveBatch(batch);
+		queryState.config.remoteArray = rows.map((r) => [encodeRecordId(r.id), r._00_rv || 1]);
+		queryState.records = await this.materializeRecords(queryState);
+		const subscribers = this.subscriptions.get(hash);
+		if (subscribers) for (const cb of subscribers) cb(queryState.records);
+	}
+	/** True while ≥1 live subscriber is watching this query (refcount guard). */
+	hasSubscribers(hash) {
+		return (this.subscriptions.get(hash)?.size ?? 0) > 0;
+	}
+	/**
+	* Opt-in eager teardown for a query whose LAST subscriber just left — used by
+	* viewport-windowed lists to cancel off-screen windows instead of leaving
+	* their remote views to expire on the TTL sweep. No-op while any subscriber
+	* remains (refcount). Only enqueues the remote cleanup here; the local WASM
+	* view + in-memory state are freed in {@link finalizeDeregister} after the
+	* remote delete completes, so a re-subscribe in between aborts/heals it.
+	*
+	* NOTE: most queries should NOT use this — the default keep-alive on
+	* unsubscribe avoids re-registration churn on navigation.
+	*/
+	deregisterQuery(hash) {
+		if (this.hasSubscribers(hash)) return;
+		if (!this.activeQueries.has(hash)) return;
+		this.onDeregister?.(hash);
+	}
+	/**
+	* Final local teardown after the remote `_00_query` row was deleted: free the
+	* WASM view, heartbeat timer, debounce timer, and in-memory state. Caller
+	* (`cleanupQuery`) guarantees no subscriber remains.
+	*/
+	finalizeDeregister(hash) {
+		const qs = this.activeQueries.get(hash);
+		if (qs?.ttlTimer) {
+			clearTimeout(qs.ttlTimer);
+			qs.ttlTimer = null;
+		}
+		const debounce = this.debounceTimers.get(hash);
+		if (debounce) {
+			clearTimeout(debounce);
+			this.debounceTimers.delete(hash);
+		}
+		this.cache.unregisterQuery(hash);
+		this.activeQueries.delete(hash);
+		this.subscriptions.delete(hash);
+	}
+	/**
 	* Get query state by id (for sync and devtools)
 	*/
 	getQueryById(id) {
@@ -502,8 +864,7 @@ var DataModule = class {
 	async notifyQuerySynced(queryHash) {
 		const queryState = this.activeQueries.get(queryHash);
 		if (!queryState) return;
-		const [records] = await this.local.query(queryState.config.surql, queryState.config.params);
-		const newRecords = records || [];
+		const newRecords = await this.materializeRecords(queryState);
 		const changed = JSON.stringify(queryState.records) !== JSON.stringify(newRecords);
 		queryState.records = newRecords;
 		if (changed || queryState.updateCount === 0) {
@@ -645,8 +1006,24 @@ var DataModule = class {
 			id: rid,
 			mid: mutationId
 		}));
-		await this.cache.delete(table, id, true, beforeRecord);
-		for (const [queryHash, queryState] of this.activeQueries) if (queryState.config.tableName === tableName) await this.notifyQuerySynced(queryHash);
+		try {
+			await this.cache.delete(table, id, true, beforeRecord);
+		} catch (err) {
+			this.logger.error({
+				err,
+				id,
+				Category: "sp00ky-client::DataModule::delete"
+			}, "SSP delete-ingest failed; relying on query re-materialize to reflect the delete");
+		}
+		for (const [queryHash, queryState] of this.activeQueries) if (queryState.config.tableName === tableName) try {
+			await this.notifyQuerySynced(queryHash);
+		} catch (err) {
+			this.logger.error({
+				err,
+				queryHash,
+				Category: "sp00ky-client::DataModule::delete"
+			}, "notifyQuerySynced failed after delete");
+		}
 		const mutationEvent = {
 			type: "delete",
 			mutation_id: mutationId,
@@ -740,7 +1117,7 @@ var DataModule = class {
 			tableName
 		});
 		const t0 = performance.now();
-		const { localArray } = this.cache.registerQuery({
+		const { localArray, registrationTimings } = this.cache.registerQuery({
 			queryHash: hash,
 			surql: surqlString,
 			params,
@@ -748,6 +1125,12 @@ var DataModule = class {
 			lastActiveAt: /* @__PURE__ */ new Date()
 		});
 		const registrationTime = performance.now() - t0;
+		queryState.registrationTimings = {
+			parseMs: registrationTimings?.parseMs ?? null,
+			planMs: registrationTimings?.planMs ?? null,
+			snapshotMs: registrationTimings?.snapshotMs ?? null,
+			wallMs: registrationTime
+		};
 		await withRetry(this.logger, () => this.local.query(surql.seal(surql.updateSet("id", [
 			"localArray",
 			"registrationTime",
@@ -758,8 +1141,23 @@ var DataModule = class {
 			registrationTime,
 			rowCount: localArray.length
 		}));
+		const windowMat = buildWindowMaterialization(surqlString);
+		if (windowMat && localArray.length > 0) try {
+			const winIds = localArray.map(([id]) => parseRecordIdString(id));
+			const [seeded] = await this.local.query(windowMat.query, {
+				...params,
+				__win: winIds
+			});
+			queryState.records = seeded || [];
+		} catch (err) {
+			this.logger.warn({
+				err,
+				hash,
+				Category: "sp00ky-client::DataModule::createAndRegisterQuery"
+			}, "Failed to seed windowed initial records from localArray");
+		}
 		this.activeQueries.set(hash, queryState);
-		this.startTTLHeartbeat(queryState);
+		this.startTTLHeartbeat(queryState, hash);
 		this.logger.debug({
 			hash,
 			tableName,
@@ -797,7 +1195,7 @@ var DataModule = class {
 			params: parseParams(tableSchema.columns, configRecord.params)
 		};
 		let records = [];
-		try {
+		if (buildWindowMaterialization(surqlString) === null) try {
 			const [result] = await this.local.query(surqlString, params);
 			records = result || [];
 		} catch (err) {
@@ -816,7 +1214,16 @@ var DataModule = class {
 			updateCount: persistedUpdateCount,
 			materializationSamples: [],
 			lastIngestLatencyMs: null,
-			errorCount: persistedErrorCount
+			errorCount: persistedErrorCount,
+			status: "idle",
+			phaseSamples: {},
+			phaseLast: {},
+			registrationTimings: {
+				parseMs: null,
+				planMs: null,
+				snapshotMs: null,
+				wallMs: null
+			}
 		};
 	}
 	async calculateHash(data) {
@@ -828,23 +1235,27 @@ var DataModule = class {
 		const hashBuffer = await crypto.subtle.digest("SHA-256", msgBuffer);
 		return Array.from(new Uint8Array(hashBuffer)).map((b) => b.toString(16).padStart(2, "0")).join("");
 	}
-	startTTLHeartbeat(queryState) {
+	startTTLHeartbeat(queryState, hash) {
 		if (queryState.ttlTimer) return;
 		const heartbeatTime = Math.floor(queryState.ttlDurationMs * .9);
 		queryState.ttlTimer = setTimeout(() => {
+			queryState.ttlTimer = null;
+			if ((this.subscriptions.get(hash)?.size ?? 0) === 0) {
+				this.logger.debug({
+					hash,
+					Category: "sp00ky-client::DataModule::startTTLHeartbeat"
+				}, "TTL heartbeat: no subscribers, stopping");
+				return;
+			}
+			this.onHeartbeat?.(hash);
 			this.logger.debug({
+				hash,
 				id: encodeRecordId(queryState.config.id),
 				Category: "sp00ky-client::DataModule::startTTLHeartbeat"
-			}, "TTL heartbeat");
-			this.startTTLHeartbeat(queryState);
+			}, "TTL heartbeat sent");
+			this.startTTLHeartbeat(queryState, hash);
 		}, heartbeatTime);
 	}
-	stopTTLHeartbeat(queryState) {
-		if (queryState.ttlTimer) {
-			clearTimeout(queryState.ttlTimer);
-			queryState.ttlTimer = null;
-		}
-	}
 	async replaceRecordInQueries(record) {
 		for (const [queryHash, queryState] of this.activeQueries.entries()) {
 			const index = queryState.records.findIndex((r) => r.id === record.id);
@@ -1137,38 +1548,153 @@ var LocalDatabaseService = class extends AbstractDatabaseService {
 	}
 	async connect() {
 		const { namespace, database } = this.getConfig();
+		const store = this.getConfig().store ?? "memory";
+		const storeUrl = store === "memory" ? "mem://" : "indxdb://sp00ky";
 		this.logger.info({
 			namespace,
 			database,
+			storeUrl,
 			Category: "sp00ky-client::LocalDatabaseService::connect"
 		}, "Connecting to local database");
+		this.registerUnloadClose();
 		try {
-			const storeUrl = (this.getConfig().store ?? "memory") === "memory" ? "mem://" : "indxdb://sp00ky";
-			this.logger.debug({
-				storeUrl,
-				Category: "sp00ky-client::LocalDatabaseService::connect"
-			}, "[LocalDatabaseService] Calling client.connect");
-			await this.client.connect(storeUrl, {});
-			this.logger.debug({
-				namespace,
-				database,
-				Category: "sp00ky-client::LocalDatabaseService::connect"
-			}, "[LocalDatabaseService] client.connect returned. Calling client.use");
-			await this.client.use({
-				namespace,
-				database
-			});
-			this.logger.debug({ Category: "sp00ky-client::LocalDatabaseService::connect" }, "[LocalDatabaseService] client.use returned");
+			await this.openStore(storeUrl, namespace, database);
 			this.logger.info({ Category: "sp00ky-client::LocalDatabaseService::connect" }, "Connected to local database");
+			return;
 		} catch (err) {
-			this.logger.error({
+			if (store === "memory" || !isLocalStoreOpenError(err)) {
+				this.logger.error({
+					err,
+					Category: "sp00ky-client::LocalDatabaseService::connect"
+				}, "Failed to connect to local database");
+				throw err;
+			}
+			this.logger.warn({
 				err,
 				Category: "sp00ky-client::LocalDatabaseService::connect"
-			}, "Failed to connect to local database");
-			throw err;
+			}, "Local IndexedDB store failed to open; retrying before clearing");
+		}
+		for (let attempt = 1; attempt <= 2; attempt++) {
+			try {
+				await this.client.close();
+			} catch {}
+			await delay(150 * attempt);
+			try {
+				await this.openStore(storeUrl, namespace, database);
+				this.logger.info({
+					attempt,
+					Category: "sp00ky-client::LocalDatabaseService::connect"
+				}, "Connected to local database on retry (cache preserved)");
+				return;
+			} catch (retryErr) {
+				this.logger.warn({
+					err: retryErr,
+					attempt,
+					Category: "sp00ky-client::LocalDatabaseService::connect"
+				}, "Local store retry failed");
+			}
+		}
+		try {
+			await this.client.close();
+		} catch {}
+		await dropLocalIndexedDbStores(this.logger);
+		try {
+			await this.openStore(storeUrl, namespace, database);
+			this.logger.info({ Category: "sp00ky-client::LocalDatabaseService::connect" }, "Reconnected to local database after clearing the corrupt store");
+		} catch (retryErr) {
+			this.logger.error({
+				err: retryErr,
+				Category: "sp00ky-client::LocalDatabaseService::connect"
+			}, "Local store still failing after clear; falling back to in-memory");
+			try {
+				await this.client.close();
+			} catch {}
+			await this.openStore("mem://", namespace, database);
+			this.logger.warn({ Category: "sp00ky-client::LocalDatabaseService::connect" }, "Connected to local database (in-memory fallback)");
 		}
 	}
+	unloadCloseRegistered = false;
+	/**
+	* Close the local DB on page unload so the SurrealDB-WASM worker releases its
+	* IndexedDB connection cleanly. Without this, the previous page's connection
+	* lingers; the next load's `client.connect` opens the store but the first
+	* write transaction in `client.use` hits an "IndexedDB error" — which then
+	* (mis)triggered the corrupt-store recovery and WIPED the cache on every
+	* reload, making warm loads as slow as cold ones. `pagehide` is the reliable
+	* unload signal (fires on bfcache + normal navigation); `close()` is async but
+	* the WASM worker initiates the IndexedDB connection teardown synchronously.
+	*/
+	registerUnloadClose() {
+		if (this.unloadCloseRegistered || typeof window === "undefined") return;
+		this.unloadCloseRegistered = true;
+		const close = () => {
+			try {
+				this.client.close();
+			} catch {}
+		};
+		window.addEventListener("pagehide", close);
+		window.addEventListener("beforeunload", close);
+	}
+	async openStore(storeUrl, namespace, database) {
+		this.logger.debug({
+			storeUrl,
+			Category: "sp00ky-client::LocalDatabaseService::connect"
+		}, "[LocalDatabaseService] Calling client.connect");
+		await this.client.connect(storeUrl, {});
+		this.logger.debug({
+			namespace,
+			database,
+			Category: "sp00ky-client::LocalDatabaseService::connect"
+		}, "[LocalDatabaseService] client.connect returned. Calling client.use");
+		await this.client.use({
+			namespace,
+			database
+		});
+		this.logger.debug({ Category: "sp00ky-client::LocalDatabaseService::connect" }, "[LocalDatabaseService] client.use returned");
+	}
 };
+function delay(ms) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/** True for the SurrealDB-WASM error raised when its IndexedDB-backed key-value
+*  store can't be opened (corrupt / version-incompatible / blocked). Exported
+*  for unit testing the error-message match. */
+function isLocalStoreOpenError(err) {
+	const msg = (err instanceof Error ? err.message : String(err)).toLowerCase();
+	return msg.includes("indexeddb") || msg.includes("idb error") || msg.includes("key-value store");
+}
+/** Best-effort delete of this client's IndexedDB store(s). The persistent local
+*  DB lives at `indxdb://sp00ky`; SurrealDB-WASM backs it with one or more
+*  IndexedDB databases whose names include `sp00ky`. Resolves even on
+*  error/blocked so startup can proceed. No-op outside a browser. */
+async function dropLocalIndexedDbStores(logger) {
+	if (typeof indexedDB === "undefined") return;
+	const remove = (name) => new Promise((resolve) => {
+		try {
+			const req = indexedDB.deleteDatabase(name);
+			req.onsuccess = () => resolve();
+			req.onerror = () => resolve();
+			req.onblocked = () => resolve();
+		} catch {
+			resolve();
+		}
+	});
+	try {
+		let names = [];
+		if (typeof indexedDB.databases === "function") names = (await indexedDB.databases()).map((d) => d.name).filter((n) => !!n && n.toLowerCase().includes("sp00ky"));
+		if (names.length === 0) names = ["sp00ky"];
+		await Promise.all(names.map(remove));
+		logger.info({
+			names,
+			Category: "sp00ky-client::LocalDatabaseService::connect"
+		}, "Cleared local IndexedDB store(s)");
+	} catch (e) {
+		logger.warn({
+			err: e,
+			Category: "sp00ky-client::LocalDatabaseService::connect"
+		}, "Failed to enumerate/clear IndexedDB; proceeding anyway");
+	}
+}
 
 //#endregion
 //#region src/services/database/remote.ts
@@ -1727,36 +2253,54 @@ function resolveListRefPollInterval(opt) {
 	return opt;
 }
 /**
-* When the LIVE feed has delivered an event within this window, treat
-* the LIVE subscription as healthy and back the poll off to
-* {@link LIVE_HEALTHY_POLL_INTERVAL_MS}. As soon as LIVE quiets for
-* longer than this, the poll snaps back to the aggressive default.
+* Ceiling for the adaptive list_ref poll backoff. An idle page (no LIVE
+* events, no poll-detected list_ref changes) coasts up to this cadence;
+* the existing healthy-LIVE safety net runs at the same 5s, so this keeps
+* the worst-case catch-up latency for a missed cross-session change at the
+* cadence the codebase already treats as acceptable.
 */
-const LIVE_HEALTHY_COOLDOWN_MS = 5e3;
+const LIST_REF_POLL_MAX_INTERVAL_MS = 5e3;
 /**
-* Poll interval while LIVE is delivering events. The aggressive
-* default 500ms costs ~120 queries / minute / session — wasted work
-* when LIVE is already covering us. 5s keeps the safety net in place
-* at 1/10th the load.
+* Adaptive poll delay: stay at the responsive `baseIntervalMs` while
+* changes are arriving, and exponentially back off toward `maxIntervalMs`
+* while the `_00_list_ref` is quiet.
+*
+* `idleStreak` is the count of consecutive poll cycles that observed *no*
+* change. `Sp00kySync` resets it to 0 whenever a poll detects a real
+* remoteArray change OR a LIVE event lands, so any activity snaps the poll
+* straight back to `baseIntervalMs`. A streak of 0 (something just
+* happened) → base; otherwise `base * 2^streak` capped at `maxIntervalMs`.
+*
+* This replaces {@link nextPollDelayMs}: the old helper slowed the poll
+* only while LIVE was *delivering*, but the cross-session LIVE-permission
+* gap means LIVE frequently never fires here, so it left a fully idle page
+* polling every `base` ms forever (the "continuous queries while idle"
+* symptom). Backing off on observed idleness instead covers the
+* LIVE-healthy case for free (LIVE applies the change → the next poll sees
+* nothing new → the streak grows → it backs off).
 */
-const LIVE_HEALTHY_POLL_INTERVAL_MS = 5e3;
+function listRefPollDelayMs(args) {
+	const { idleStreak, baseIntervalMs, maxIntervalMs = LIST_REF_POLL_MAX_INTERVAL_MS } = args;
+	const cap = Math.max(baseIntervalMs, maxIntervalMs);
+	if (idleStreak <= 0) return baseIntervalMs;
+	const exponent = Math.min(idleStreak, 30);
+	return Math.min(baseIntervalMs * 2 ** exponent, cap);
+}
 /**
-* Pick the next poll delay based on whether LIVE has been healthy
-* recently. If a LIVE event fired within `cooldownMs`, use the slow
-* (`healthyIntervalMs`) cadence; otherwise the fast (`baseIntervalMs`)
-* cadence. Pure so it's unit-testable; `Sp00kySync.startListRefPoll`
-* calls it from a self-rescheduling timer.
-*
-* The healthy interval is clamped to at least `baseIntervalMs` so
-* configuring an aggressive base (e.g. 100ms) never gets implicitly
-* widened by this helper.
+* Order-insensitive equality for two `RecordVersionArray`s (each a list of
+* `[recordIdString, version]`). The `_00_list_ref` SELECT has no `ORDER
+* BY`, so row order can differ between polls without anything having
+* actually changed — comparing as an id→version map avoids false
+* "changed" verdicts that would defeat the idle backoff. Record ids are
+* unique within a query's list_ref, so a map is a faithful representation.
 */
-function nextPollDelayMs(args) {
-	const { now, lastLiveEventAt, baseIntervalMs, cooldownMs = LIVE_HEALTHY_COOLDOWN_MS, healthyIntervalMs = LIVE_HEALTHY_POLL_INTERVAL_MS } = args;
-	if (lastLiveEventAt === null) return baseIntervalMs;
-	const sinceLive = now - lastLiveEventAt;
-	if (sinceLive < 0 || sinceLive >= cooldownMs) return baseIntervalMs;
-	return Math.max(healthyIntervalMs, baseIntervalMs);
+function recordVersionArraysEqual(a, b) {
+	if (a === b) return true;
+	if (a.length !== b.length) return false;
+	const byId = /* @__PURE__ */ new Map();
+	for (const [id, version] of a) byId.set(id, version);
+	for (const [id, version] of b) if (byId.get(id) !== version) return false;
+	return true;
 }
 
 //#endregion
@@ -1789,13 +2333,19 @@ var SyncEngine = class {
 			removed,
 			Category: "sp00ky-client::SyncEngine::syncRecords"
 		}, "SyncEngine.syncRecords diff");
-		if (removed.length > 0) await this.handleRemovedRecords(removed);
+		let stillRemoteIds = [];
+		if (removed.length > 0) stillRemoteIds = await this.handleRemovedRecords(removed);
 		const toFetch = [...added, ...updated];
 		const idsToFetch = toFetch.map((x) => x.id);
-		if (idsToFetch.length === 0) return;
+		if (idsToFetch.length === 0) return {
+			remoteFetchMs: 0,
+			stillRemoteIds
+		};
 		const versionMap = /* @__PURE__ */ new Map();
 		for (const item of toFetch) versionMap.set(encodeRecordId(item.id), item.version);
+		const remoteFetchStart = performance.now();
 		const [remoteResults] = await this.remote.query("SELECT * FROM $idsToFetch", { idsToFetch });
+		const remoteFetchMs = performance.now() - remoteFetchStart;
 		const cacheBatch = [];
 		for (const record of remoteResults) {
 			if (!record?.id) {
@@ -1831,6 +2381,10 @@ var SyncEngine = class {
 		}
 		if (cacheBatch.length > 0) await this.cache.saveBatch(cacheBatch);
 		this.events.emit(SyncEventTypes.RemoteDataIngested, { records: remoteResults });
+		return {
+			remoteFetchMs,
+			stillRemoteIds
+		};
 	}
 	/**
 	* Handle records that exist locally but not in remote array.
@@ -1851,30 +2405,19 @@ var SyncEngine = class {
 			removed: removed.map((r) => r.toString()),
 			Category: "sp00ky-client::SyncEngine::handleRemovedRecords"
 		}, "Checking removed records");
-		const byTable = /* @__PURE__ */ new Map();
-		for (const r of removed) {
-			const list = byTable.get(r.table.name) ?? [];
-			list.push(r);
-			byTable.set(r.table.name, list);
-		}
 		let existingRemoteIds;
 		try {
-			existingRemoteIds = /* @__PURE__ */ new Set();
-			for (const [table, ids] of byTable) {
-				const [existing] = await this.remote.query("SELECT id FROM type::table($table) WHERE id IN $ids", {
-					table,
-					ids
-				});
-				for (const row of existing) existingRemoteIds.add(encodeRecordId(row.id));
-			}
+			const [existing] = await this.remote.query("SELECT id FROM $ids", { ids: removed });
+			existingRemoteIds = new Set((existing ?? []).map((row) => encodeRecordId(row.id)));
 		} catch (err) {
 			this.logger.warn({
 				err,
 				removed: removed.map((r) => r.toString()),
 				Category: "sp00ky-client::SyncEngine::handleRemovedRecords"
 			}, "Remote existence check failed, skipping deletion to avoid clobbering fresh data");
-			return;
+			return [];
 		}
+		const stillRemoteIds = [];
 		for (const recordId of removed) {
 			const recordIdStr = encodeRecordId(recordId);
 			if (!existingRemoteIds.has(recordIdStr)) {
@@ -1883,8 +2426,9 @@ var SyncEngine = class {
 					Category: "sp00ky-client::SyncEngine::handleRemovedRecords"
 				}, "Deleting confirmed removed record");
 				await this.cache.delete(recordId.table.name, recordIdStr);
-			}
+			} else stillRemoteIds.push(recordIdStr);
 		}
+		return stillRemoteIds;
 	}
 };
 
@@ -2025,6 +2569,8 @@ var Sp00kySync = class {
 	listRefPollTimer = null;
 	listRefPollRunning = false;
 	refSyncIntervalMs;
+	listRefIdleStreak = 0;
+	stillRemoteStreaks = /* @__PURE__ */ new Map();
 	lastLiveEventAt = null;
 	_liveRetryCount = 0;
 	get liveRetryCount() {
@@ -2126,13 +2672,14 @@ var Sp00kySync = class {
 		const schedule = (delayMs) => {
 			this.listRefPollTimer = setTimeout(async () => {
 				if (!this.listRefPollRunning) return;
+				let changed = false;
 				try {
-					await this.pollListRefForActiveQueries();
+					changed = await this.pollListRefForActiveQueries();
 				} finally {
 					if (!this.listRefPollRunning) return;
-					schedule(nextPollDelayMs({
-						now: Date.now(),
-						lastLiveEventAt: this.lastLiveEventAt,
+					this.listRefIdleStreak = changed ? 0 : this.listRefIdleStreak + 1;
+					schedule(listRefPollDelayMs({
+						idleStreak: this.listRefIdleStreak,
 						baseIntervalMs: this.refSyncIntervalMs
 					}));
 				}
@@ -2147,11 +2694,17 @@ var Sp00kySync = class {
 			this.listRefPollTimer = null;
 		}
 	}
+	/**
+	* One poll cycle: refetch `_00_list_ref` for every active query. Returns
+	* whether ANY query's remoteArray actually changed — the scheduler uses this
+	* to drive the adaptive idle backoff.
+	*/
 	async pollListRefForActiveQueries() {
 		const hashes = this.dataModule.getActiveQueryHashes();
-		if (hashes.length === 0) return;
+		if (hashes.length === 0) return false;
+		let anyChanged = false;
 		for (const hash of hashes) try {
-			await this.refetchListRefForQuery(hash);
+			if (await this.refetchListRefForQuery(hash)) anyChanged = true;
 		} catch (err) {
 			this.logger.debug({
 				err: err?.message ?? err,
@@ -2159,6 +2712,7 @@ var Sp00kySync = class {
 				Category: "sp00ky-client::Sp00kySync::pollListRefForActiveQueries"
 			}, "Per-query list_ref poll failed");
 		}
+		return anyChanged;
 	}
 	/**
 	* Pull the upstream list_ref entries for `queryHash`, diff them
@@ -2170,12 +2724,16 @@ var Sp00kySync = class {
 	*/
 	async refetchListRefForQuery(queryHash) {
 		const queryState = this.dataModule.getQueryByHash(queryHash);
-		if (!queryState) return;
+		if (!queryState) return false;
 		const listRefTbl = this.listRefTable();
 		const [items] = await this.remote.query(buildListRefSelect(listRefTbl), { in: queryState.config.id });
-		if (!Array.isArray(items)) return;
+		if (!Array.isArray(items)) return false;
 		const fresh = items.map((item) => [encodeRecordId(item.out), item.version]);
-		await this.dataModule.updateQueryRemoteArray(queryHash, fresh);
+		const prevRemote = queryState.config.remoteArray ?? [];
+		const freshIds = new Set(fresh.map(([id]) => id));
+		const removedIds = prevRemote.filter(([id]) => !freshIds.has(id)).map(([id]) => id);
+		const changed = !recordVersionArraysEqual(fresh, queryState.config.remoteArray);
+		if (changed) await this.dataModule.updateQueryRemoteArray(queryHash, fresh);
 		try {
 			await this.syncQuery(queryHash);
 		} catch (err) {
@@ -2185,6 +2743,16 @@ var Sp00kySync = class {
 				Category: "sp00ky-client::Sp00kySync::refetchListRefForQuery"
 			}, "syncQuery failed during poll");
 		}
+		if (removedIds.length > 0) try {
+			await this.dataModule.notifyQuerySynced(queryHash);
+		} catch (err) {
+			this.logger.info({
+				err: err?.message ?? err,
+				queryHash,
+				Category: "sp00ky-client::Sp00kySync::refetchListRefForQuery"
+			}, "notifyQuerySynced failed during poll-removal re-render");
+		}
+		return changed;
 	}
 	/**
 	* Resolve the current `_00_list_ref` table name for the active auth
@@ -2237,6 +2805,12 @@ var Sp00kySync = class {
 				type: "register",
 				payload: { hash }
 			});
+			if (this.currentUserId) this.restartRefLiveQuery().catch((err) => {
+				this.logger.debug({
+					err,
+					Category: "sp00ky-client::Sp00kySync::onReconnect"
+				}, "LIVE restart after reconnect failed; relying on poll fallback");
+			});
 		});
 	}
 	async startRefLiveQueries() {
@@ -2253,6 +2827,7 @@ var Sp00kySync = class {
 				Category: "sp00ky-client::Sp00kySync::startRefLiveQueries"
 			}, "Live update received");
 			if (message.action === "KILLED") return;
+			if (message.value.parent != null) return;
 			this.handleRemoteListRefChange(message.action, message.value.in, message.value.out, message.value.version).catch((err) => {
 				this.logger.error({
 					err,
@@ -2263,14 +2838,7 @@ var Sp00kySync = class {
 	}
 	async handleRemoteListRefChange(action, queryId, recordId, version) {
 		this.lastLiveEventAt = Date.now();
-		if (action === "DELETE") {
-			this.logger.debug({
-				queryId: queryId.toString(),
-				recordId: recordId.toString(),
-				Category: "sp00ky-client::Sp00kySync::handleRemoteListRefChange"
-			}, "Ignoring DELETE on list_ref — should not happen");
-			return;
-		}
+		this.listRefIdleStreak = 0;
 		const existing = this.dataModule.getQueryById(queryId);
 		if (!existing) {
 			this.logger.warn({
@@ -2289,7 +2857,8 @@ var Sp00kySync = class {
 			Category: "sp00ky-client::Sp00kySync::handleRemoteListRefChange"
 		}, "Live update is being processed");
 		const diff = createDiffFromDbOp(action, recordId, version, localArray);
-		await this.syncEngine.syncRecords(diff);
+		const hash = extractIdPart(existing.config.id);
+		await this.runSyncForQuery(hash, diff);
 	}
 	/**
 	* Enqueues a 'down' event (from remote to local) for processing.
@@ -2396,7 +2965,70 @@ var Sp00kySync = class {
 		}
 		const diff = new ArraySyncer(queryState.config.localArray, queryState.config.remoteArray).nextSet();
 		if (!diff) return;
-		return this.syncEngine.syncRecords(diff);
+		return this.runSyncForQuery(hash, diff);
+	}
+	/**
+	* Run a sync for a single query while reflecting its fetch status. Marks the
+	* query `fetching` for the duration when the diff actually pulls records
+	* (added/updated), then resets to `idle` in a `finally` so a failed sync
+	* never leaves a query stuck `fetching`. Part A's notification coalescing
+	* means the single resulting UI update lands after this completes.
+	*/
+	async runSyncForQuery(hash, diff) {
+		if (diff.added.length > 0 || diff.updated.length > 0) {
+			const pendingDeletes = await this.getPendingDeleteIds();
+			if (pendingDeletes.size > 0) diff = {
+				added: diff.added.filter((r) => !pendingDeletes.has(encodeRecordId(r.id))),
+				updated: diff.updated.filter((r) => !pendingDeletes.has(encodeRecordId(r.id))),
+				removed: diff.removed
+			};
+		}
+		const fetching = diff.added.length + diff.updated.length > 0;
+		if (fetching) this.dataModule.setQueryStatus(hash, "fetching");
+		try {
+			const { remoteFetchMs, stillRemoteIds } = await this.syncEngine.syncRecords(diff);
+			if (fetching) this.dataModule.recordRemoteFetch(hash, remoteFetchMs);
+			if (stillRemoteIds.length > 0) {
+				const CONVERGE_AFTER = 3;
+				const toConverge = [];
+				for (const id of stillRemoteIds) {
+					const key = `${hash}:${id}`;
+					const n = (this.stillRemoteStreaks.get(key) ?? 0) + 1;
+					if (n >= CONVERGE_AFTER) {
+						this.stillRemoteStreaks.delete(key);
+						toConverge.push(id);
+					} else this.stillRemoteStreaks.set(key, n);
+				}
+				if (toConverge.length > 0) {
+					const local = this.dataModule.getQueryByHash(hash)?.config.localArray;
+					if (local && local.length > 0) {
+						const drop = new Set(toConverge);
+						const next = local.filter(([id]) => !drop.has(id));
+						if (next.length !== local.length) await this.dataModule.updateQueryLocalArray(hash, next);
+					}
+				}
+			}
+		} finally {
+			if (fetching) this.dataModule.setQueryStatus(hash, "idle");
+		}
+	}
+	/**
+	* Record ids with a pending local DELETE in the outbox (`_00_pending_mutations`).
+	* Sync must not re-fetch/re-insert these — the remote delete is async, so the
+	* server's `_00_list_ref` still lists them until it's processed, and the diff
+	* would otherwise resurrect a just-deleted record.
+	*/
+	async getPendingDeleteIds() {
+		try {
+			const [rows] = await this.local.query("SELECT recordId FROM _00_pending_mutations WHERE mutationType = 'delete'");
+			return new Set((rows ?? []).map((r) => encodeRecordId(r.recordId)));
+		} catch (err) {
+			this.logger.warn({
+				err,
+				Category: "sp00ky-client::Sp00kySync::getPendingDeleteIds"
+			}, "Failed to read pending deletes; sync may briefly resurrect a just-deleted record");
+			return /* @__PURE__ */ new Set();
+		}
 	}
 	/**
 	* Enqueues a list of mutations (up events) to be sent to the remote.
@@ -2465,14 +3097,17 @@ var Sp00kySync = class {
 	}
 	async cleanupQuery(queryHash) {
 		const queryState = this.dataModule.getQueryByHash(queryHash);
-		if (!queryState) {
-			this.logger.warn({
-				queryHash,
-				Category: "sp00ky-client::Sp00kySync::cleanupQuery"
-			}, "Query to register not found");
-			throw new Error("Query to register not found");
-		}
+		if (!queryState) return;
+		if (this.dataModule.hasSubscribers(queryHash)) return;
 		await this.remote.query(`DELETE $id`, { id: queryState.config.id });
+		if (this.dataModule.hasSubscribers(queryHash)) {
+			this.enqueueDownEvent({
+				type: "register",
+				payload: { hash: queryHash }
+			});
+			return;
+		}
+		this.dataModule.finalizeDeregister(queryHash);
 	}
 };
 
@@ -2483,12 +3118,64 @@ function createAuthEventSystem() {
 	return createEventSystem([AuthEventTypes.AuthStateChanged]);
 }
 
+//#endregion
+//#region src/modules/devtools/versions.ts
+const UNAVAILABLE = "unavailable";
+function emptyBackendVersions() {
+	return {
+		ssp: UNAVAILABLE,
+		scheduler: UNAVAILABLE,
+		surrealdb: UNAVAILABLE
+	};
+}
+function emptyBackendInfo() {
+	return {
+		versions: emptyBackendVersions(),
+		entities: []
+	};
+}
+/** Strip a leading `surrealdb-` so versions read as bare semver (e.g. `2.0.3`). */
+function normalizeServerVersion(v) {
+	return String(v).replace(/^surrealdb-/i, "").trim();
+}
+/**
+* Normalize whatever `RETURN fn::spooky::info()` resolves to into the entity
+* array. The SurrealQL function returns the parsed `/info` array; depending on
+* how the result is unwrapped it may arrive as the array itself, a single
+* object, or `null`. Tolerant of all three.
+*/
+function toEntityArray(raw) {
+	if (Array.isArray(raw)) return raw.filter((e) => !!e && typeof e === "object");
+	if (raw && typeof raw === "object") return [raw];
+	return [];
+}
+/**
+* Derive component versions + the full entity list from a `/info` entity array.
+* `surrealdb` is taken from whichever entity reports `surrealdb_version` (ssp or
+* scheduler). Never throws; missing pieces stay `'unavailable'`.
+*/
+function parseBackendInfo(raw) {
+	const entities = toEntityArray(raw);
+	const versions = emptyBackendVersions();
+	for (const entity of entities) {
+		const version = entity.version ? String(entity.version) : void 0;
+		if (entity.entity === "ssp" && version) versions.ssp = version;
+		else if (entity.entity === "scheduler" && version) versions.scheduler = version;
+		if (versions.surrealdb === UNAVAILABLE && entity.surrealdb_version) versions.surrealdb = normalizeServerVersion(String(entity.surrealdb_version));
+	}
+	return {
+		versions,
+		entities
+	};
+}
+
 //#endregion
 //#region src/modules/devtools/index.ts
 var DevToolsService = class {
 	eventsHistory = [];
 	eventIdCounter = 0;
-	version = "1.0.0";
+	version = "0.0.1-canary.70";
+	backendInfo = emptyBackendInfo();
 	constructor(databaseService, remoteDatabaseService, logger, schema, authService, dataManager) {
 		this.databaseService = databaseService;
 		this.remoteDatabaseService = remoteDatabaseService;
@@ -2500,8 +3187,27 @@ var DevToolsService = class {
 		this.authService.eventSystem.subscribe(AuthEventTypes.AuthStateChanged, () => {
 			this.notifyDevTools();
 		});
+		this.refreshBackendVersions();
 		this.logger.debug({ Category: "sp00ky-client::DevToolsService::init" }, "Service initialized");
 	}
+	/**
+	* Re-read backend stack info via the `fn::spooky::info()` SurrealQL function
+	* over the open remote connection (no HTTP/CORS), then notify the panel.
+	* Never throws: on failure the info stays empty/'unavailable'.
+	*/
+	async refreshBackendVersions() {
+		try {
+			const result = await this.remoteDatabaseService.query("RETURN fn::spooky::info()");
+			this.backendInfo = parseBackendInfo(Array.isArray(result) ? result[0] : result);
+		} catch (err) {
+			this.logger.debug({
+				err,
+				Category: "sp00ky-client::DevToolsService::versions"
+			}, "fn::spooky::info() unavailable; backend versions stay unavailable");
+			this.backendInfo = emptyBackendInfo();
+		}
+		this.notifyDevTools();
+	}
 	getActiveQueries() {
 		const result = /* @__PURE__ */ new Map();
 		if (!this.dataManager) return result;
@@ -2510,6 +3216,8 @@ var DevToolsService = class {
 			result.set(queryHash, {
 				queryHash,
 				status: "active",
+				fetchStatus: q.status,
+				isFetching: q.status === "fetching",
 				createdAt: q.config.lastActiveAt instanceof Date ? q.config.lastActiveAt.getTime() : new Date(q.config.lastActiveAt || Date.now()).getTime(),
 				lastUpdate: Date.now(),
 				updateCount: q.updateCount,
@@ -2518,7 +3226,8 @@ var DevToolsService = class {
 				dataSize: q.records?.length || 0,
 				data: q.records,
 				localArray: q.config.localArray,
-				remoteArray: q.config.remoteArray
+				remoteArray: q.config.remoteArray,
+				timings: this.dataManager.phaseTimings(q)
 			});
 		});
 		return result;
@@ -2598,6 +3307,15 @@ var DevToolsService = class {
 				userId: this.authService.currentUser?.id
 			},
 			version: this.version,
+			versions: {
+				frontend: {
+					core: "0.0.1-canary.70",
+					wasm: "0.0.1-canary.70",
+					surrealdb: "3.0.3"
+				},
+				backend: this.backendInfo.versions,
+				entities: this.backendInfo.entities
+			},
 			database: {
 				tables: this.schema.tables.map((t) => t.name),
 				tableData: {}
@@ -2640,6 +3358,7 @@ var DevToolsService = class {
 					this.eventsHistory = [];
 					this.notifyDevTools();
 				},
+				refreshVersions: () => this.refreshBackendVersions(),
 				getTableData: async (tableName) => {
 					try {
 						const result = await this.databaseService.query(`SELECT * FROM ${tableName}`);
@@ -2893,6 +3612,8 @@ var StreamProcessorService = class {
 	processor;
 	isInitialized = false;
 	receivers = [];
+	batching = false;
+	batchBuffer = /* @__PURE__ */ new Map();
 	constructor(events, db, persistenceClient, logger) {
 		this.events = events;
 		this.db = db;
@@ -2907,9 +3628,75 @@ var StreamProcessorService = class {
 		this.receivers.push(receiver);
 	}
 	notifyUpdates(updates) {
+		if (this.batching) {
+			for (const update of updates) {
+				const prev = this.batchBuffer.get(update.queryHash);
+				const sum = (a, b) => (a ?? 0) + (b ?? 0);
+				this.batchBuffer.set(update.queryHash, {
+					...update,
+					op: "CREATE",
+					materializationTimeMs: sum(prev?.materializationTimeMs, update.materializationTimeMs),
+					storeApplyMs: sum(prev?.storeApplyMs, update.storeApplyMs),
+					circuitStepMs: sum(prev?.circuitStepMs, update.circuitStepMs),
+					transformMs: sum(prev?.transformMs, update.transformMs)
+				});
+			}
+			return;
+		}
+		this.dispatchUpdates(updates);
+	}
+	dispatchUpdates(updates) {
 		for (const update of updates) for (const receiver of this.receivers) receiver.onStreamUpdate(update);
 	}
 	/**
+	* Ingest a batch of record changes as a single bulk operation, firing only
+	* one coalesced `StreamUpdate` per affected query once every record has been
+	* ingested (instead of one update per record). Use this whenever multiple
+	* records land at once — e.g. sync fetching N missing rows — so a list query
+	* re-runs and the UI re-renders once for the whole batch rather than
+	* row-by-row.
+	*
+	* Internally opens a coalescing window, ingests each record, then flushes;
+	* processor state is persisted once for the whole batch. No-op for an empty
+	* batch.
+	*/
+	ingestMany(records) {
+		if (records.length === 0) return;
+		this.beginCoalescing();
+		try {
+			for (const record of records) this.ingest(record.table, record.op, record.id, record.record);
+		} finally {
+			this.flushCoalescing();
+		}
+	}
+	/**
+	* Open a coalescing window. While open, the per-record stream updates
+	* emitted by `ingest` are buffered (one entry per queryHash) instead of
+	* dispatched. Always paired with `flushCoalescing()` in a try/finally by
+	* `ingestMany` so the window always closes — otherwise the processor stays
+	* stuck buffering forever.
+	*
+	* No-op if a window is already open (nested batches aren't expected here).
+	*/
+	beginCoalescing() {
+		if (this.batching) return;
+		this.batching = true;
+		this.batchBuffer.clear();
+	}
+	/**
+	* Close the coalescing window and flush: dispatch one coalesced
+	* `StreamUpdate` per buffered queryHash, then persist processor state once
+	* for the whole batch (instead of once per ingest).
+	*/
+	flushCoalescing() {
+		if (!this.batching) return;
+		this.batching = false;
+		const buffered = Array.from(this.batchBuffer.values());
+		this.batchBuffer.clear();
+		if (buffered.length > 0) this.dispatchUpdates(buffered);
+		this.saveState();
+	}
+	/**
 	* Initialize the WASM module and processor.
 	* This must be called before using other methods.
 	*/
@@ -2950,6 +3737,23 @@ var StreamProcessorService = class {
 			}, "Failed to load state");
 		}
 	}
+	/**
+	* Seed per-table `select` permission predicates ({ [table]: whereText }).
+	* Must run after the processor exists and before any `register_view`, else
+	* non-`_00_` tables are default-denied and registration fails.
+	*/
+	setPermissions(permissions) {
+		if (!this.processor) return;
+		if (typeof this.processor.set_permissions !== "function") {
+			this.logger.warn({ Category: "sp00ky-client::StreamProcessorService::setPermissions" }, "set_permissions not found on processor (stale WASM build?)");
+			return;
+		}
+		this.processor.set_permissions(permissions);
+		this.logger.info({
+			tables: Object.keys(permissions).length,
+			Category: "sp00ky-client::StreamProcessorService::setPermissions"
+		}, "Seeded table permissions");
+	}
 	async saveState() {
 		if (!this.processor) return;
 		try {
@@ -3001,11 +3805,14 @@ var StreamProcessorService = class {
 					queryHash: u.query_id,
 					localArray: u.result_data,
 					op,
-					materializationTimeMs
+					materializationTimeMs,
+					storeApplyMs: u.timing_store_apply_ms,
+					circuitStepMs: u.timing_circuit_step_ms,
+					transformMs: u.timing_transform_ms
 				}));
 				this.notifyUpdates(updates);
 			}
-			this.saveState();
+			if (!this.batching) this.saveState();
 			return rawUpdates;
 		} catch (e) {
 			this.logger.error({
@@ -3047,7 +3854,12 @@ var StreamProcessorService = class {
 			if (!initialUpdate) throw new Error("Failed to register query plan");
 			const update = {
 				queryHash: initialUpdate.query_id,
-				localArray: initialUpdate.result_data
+				localArray: initialUpdate.result_data,
+				registration: {
+					parseMs: initialUpdate.timing_parse_ms ?? 0,
+					planMs: initialUpdate.timing_plan_ms ?? 0,
+					snapshotMs: initialUpdate.timing_snapshot_ms ?? 0
+				}
 			};
 			this.saveState();
 			this.logger.debug({
@@ -3108,6 +3920,51 @@ var StreamProcessorService = class {
 	}
 };
 
+//#endregion
+//#region src/services/stream-processor/permissions.ts
+/**
+* Extract per-table `select` permission predicates from a raw `.surql` schema.
+*
+* The in-browser SSP default-denies any non-`_00_` table that has no permission
+* predicate registered (see `permission_inject::build_predicate`). The client
+* already holds the full schema text (`config.schemaSurql`), so we parse each
+* `DEFINE TABLE … PERMISSIONS …` clause and hand the `select` predicate to the
+* processor via `set_permissions` at boot — mirroring the native path that
+* seeds the same map from `INFO FOR DB`.
+*
+* Returns `{ [table]: whereText }` where `whereText` is the raw SurrealQL
+* expression (`'true'` for `FULL`, `'false'` for `NONE` or a table with no
+* `select` permission).
+*/
+function extractSelectPermissions(schemaSurql) {
+	const out = {};
+	if (!schemaSurql) return out;
+	const cleaned = schemaSurql.replace(/--[^\n]*/g, "");
+	const tableStmt = /DEFINE\s+TABLE\s+(?:OVERWRITE\s+|IF\s+NOT\s+EXISTS\s+)?([A-Za-z_][\w]*)\b([^;]*);/gi;
+	let m;
+	while ((m = tableStmt.exec(cleaned)) !== null) {
+		const table = m[1];
+		const body = m[2];
+		out[table] = selectPredicateFromBody(body);
+	}
+	return out;
+}
+function selectPredicateFromBody(body) {
+	const permIdx = body.search(/\bPERMISSIONS\b/i);
+	if (permIdx === -1) return "false";
+	const perms = body.slice(permIdx + 11).trim();
+	if (/^FULL\b/i.test(perms)) return "true";
+	if (/^NONE\b/i.test(perms)) return "false";
+	const groups = perms.split(/\bFOR\b/i).map((g) => g.trim()).filter(Boolean);
+	for (const group of groups) {
+		const where = group.search(/\bWHERE\b/i);
+		if (where === -1) continue;
+		const actions = group.slice(0, where).toLowerCase();
+		if (/\bselect\b/.test(actions)) return group.slice(where + 5).trim();
+	}
+	return "false";
+}
+
 //#endregion
 //#region src/modules/cache/index.ts
 /**
@@ -3185,11 +4042,17 @@ var CacheModule = class {
 				}, {});
 				await this.local.execute(query, params);
 			}
-			for (const record of populatedRecords) {
+			const bulk = populatedRecords.map((record) => {
 				const recordId = encodeRecordId(record.record.id);
 				this.versionLookups[recordId] = record.version;
-				this.streamProcessor.ingest(record.table, record.op, recordId, record.record);
-			}
+				return {
+					table: record.table,
+					op: record.op,
+					id: recordId,
+					record: record.record
+				};
+			});
+			this.streamProcessor.ingestMany(bulk);
 			this.logger.debug({
 				count: records.length,
 				Category: "sp00ky-client::CacheModule::saveBatch"
@@ -3258,7 +4121,10 @@ var CacheModule = class {
 				arrayLength: update.localArray?.length,
 				Category: "sp00ky-client::CacheModule::registerQuery"
 			}, "Query registered successfully");
-			return { localArray: update.localArray };
+			return {
+				localArray: update.localArray,
+				registrationTimings: update.registration
+			};
 		} catch (err) {
 			this.logger.error({
 				err,
@@ -3729,7 +4595,13 @@ var CrdtManager = class {
 	killTableSubscription(table) {
 		const uuid = this.liveByTable.get(table);
 		if (uuid) {
-			this.remote.query("KILL $uuid", { uuid }).catch(() => {});
+			this.remote.query("KILL $uuid", { uuid }).catch((err) => {
+				this.logger.debug({
+					err,
+					table,
+					Category: "sp00ky-client::CrdtManager::killTableSubscription"
+				}, "KILL of table LIVE failed (already closed?)");
+			});
 			this.liveByTable.delete(table);
 		}
 	}
@@ -3843,7 +4715,13 @@ var ResilientPersistenceClient = class {
 				error: e,
 				Category: "sp00ky-client::ResilientPersistenceClient::get"
 			}, "Persistence read failed, dropping key");
-			await this.inner.remove(key).catch(() => {});
+			await this.inner.remove(key).catch((removeErr) => {
+				this.logger.debug({
+					key,
+					error: removeErr,
+					Category: "sp00ky-client::ResilientPersistenceClient::get"
+				}, "Failed to drop corrupt persistence key");
+			});
 			return null;
 		}
 	}
@@ -3956,6 +4834,27 @@ var Sp00kyClient = class {
 	* Setup direct callbacks instead of event subscriptions
 	*/
 	setupCallbacks() {
+		this.dataModule.onQueryStatusChange = (queryHash, status) => {
+			this.devTools.logEvent("QUERY_STATUS_CHANGED", {
+				queryHash,
+				status
+			});
+		};
+		this.dataModule.onHeartbeat = (queryHash) => {
+			this.sync.heartbeatQuery(queryHash).catch((err) => {
+				this.logger.warn({
+					err,
+					queryHash,
+					Category: "sp00ky-client::Sp00kyClient::onHeartbeat"
+				}, "TTL heartbeat failed");
+			});
+		};
+		this.dataModule.onDeregister = (queryHash) => {
+			this.sync.enqueueDownEvent({
+				type: "cleanup",
+				payload: { hash: queryHash }
+			});
+		};
 		this.dataModule.onMutation((mutations) => {
 			this.devTools.onMutation(mutations);
 			if (mutations.length > 0) this.sync.enqueueMutation(mutations);
@@ -3996,6 +4895,7 @@ var Sp00kyClient = class {
 			await this.remote.connect();
 			this.logger.debug({ Category: "sp00ky-client::Sp00kyClient::init" }, "Remote database connected");
 			await this.streamProcessor.init();
+			this.streamProcessor.setPermissions(extractSelectPermissions(this.config.schemaSurql));
 			this.logger.debug({ Category: "sp00ky-client::Sp00kyClient::init" }, "StreamProcessor initialized");
 			await this.auth.init();
 			this.logger.debug({ Category: "sp00ky-client::Sp00kyClient::init" }, "Auth initialized");
@@ -4063,7 +4963,18 @@ var Sp00kyClient = class {
 	async initQuery(table, q, ttl) {
 		const tableSchema = this.config.schema.tables.find((t) => t.name === table);
 		if (!tableSchema) throw new Error(`Table ${table} not found`);
-		const hash = await this.dataModule.query(table, q.selectQuery.query, parseParams(tableSchema.columns, q.selectQuery.vars ?? {}), ttl);
+		const params = parseParams(tableSchema.columns, q.selectQuery.vars ?? {});
+		const hash = await this.dataModule.query(table, q.selectQuery.query, params, ttl);
+		if (this.config.instantHydrate !== false && this.dataModule.isCold(hash)) try {
+			const [rows] = await this.remote.query(q.selectQuery.query, params);
+			await this.dataModule.applyHydration(hash, rows ?? []);
+		} catch (err) {
+			this.logger.warn({
+				err,
+				hash,
+				Category: "sp00ky-client::Sp00kyClient::instantHydrate"
+			}, "Instant hydrate failed; proceeding with registration");
+		}
 		await this.sync.enqueueDownEvent({
 			type: "register",
 			payload: { hash }
@@ -4077,6 +4988,32 @@ var Sp00kyClient = class {
 	async subscribe(queryHash, callback, options) {
 		return this.dataModule.subscribe(queryHash, callback, options);
 	}
+	/**
+	* Opt-in eager teardown for a query whose last subscriber has gone away
+	* (e.g. a viewport-windowed list cancelling an off-screen window). No-op
+	* while any subscriber remains. Tears down the remote `_00_query` view +
+	* local WASM view instead of waiting for the TTL sweep. Default behavior
+	* (no call here) keeps the view resident for cheap re-subscription.
+	*/
+	deregisterQuery(queryHash) {
+		this.dataModule.deregisterQuery(queryHash);
+	}
+	/**
+	* Subscribe to a query's fetch-status changes (idle/fetching). With
+	* `{ immediate: true }` the callback fires synchronously with the current
+	* status. Powers the `useQuery` hook's `isFetching()` accessor.
+	*/
+	subscribeQueryStatus(queryHash, callback, options) {
+		return this.dataModule.subscribeStatus(queryHash, callback, options);
+	}
+	/**
+	* Report the frontend processing time (ms) a client framework spent applying
+	* an update for a query (e.g. `useQuery`'s `reconcile()`), so DevTools/MCP can
+	* surface the "frontend" phase of the per-query timing breakdown.
+	*/
+	reportFrontendTiming(queryHash, ms) {
+		this.dataModule.recordFrontendTiming(queryHash, ms);
+	}
 	run(backend, path, payload, options) {
 		return this.dataModule.run(backend, path, payload, options);
 	}