@spooky-sync/core 0.0.1-canary.8 → 0.0.1-canary.80

package/dist/index.js

@@ -2,13 +2,14 @@ import { DateTime, Duration, RecordId, Surreal, Uuid, applyDiagnostics, createRe
 import { QueryBuilder, RecordId as RecordId$1 } from "@spooky-sync/query-builder";
 import { createWasmWorkerEngines } from "@surrealdb/wasm";
 import pino from "pino";
-import { BatchLogRecordProcessor, LoggerProvider } from "@opentelemetry/sdk-logs";
-import { OTLPLogExporter } from "@opentelemetry/exporter-logs-otlp-proto";
-import { resourceFromAttributes } from "@opentelemetry/resources";
-import { ATTR_SERVICE_NAME } from "@opentelemetry/semantic-conventions";
-import { createContextKey } from "@opentelemetry/api";
-import init, { SpookyProcessor } from "@spooky-sync/ssp-wasm";
+import init, { Sp00kyProcessor } from "@spooky-sync/ssp-wasm";
+import { LoroDoc } from "loro-crdt";
 
+//#region src/types.ts
+/** Cap on the rolling materialization-sample window kept per query in memory. */
+const MATERIALIZATION_SAMPLE_WINDOW = 100;
+
+//#endregion
 //#region src/utils/surql.ts
 const surql = {
 	seal(query, options) {
@@ -33,7 +34,7 @@ const surql = {
 		return `SELECT ${returnValues.join(",")} FROM ONLY $${idVar}`;
 	},
 	selectByFieldsAnd(table, whereVar, returnValues) {
-		return `SELECT ${returnValues.map((returnValues) => typeof returnValues === "string" ? returnValues : `${returnValues.field} as ${returnValues.alias}`).join(",")} FROM ${table} WHERE ${whereVar.map((whereVar) => typeof whereVar === "string" ? `${whereVar} = $${whereVar}` : `${whereVar.field} = $${whereVar.variable}`).join(" AND ")}`;
+		return `SELECT ${returnValues.map((rv) => typeof rv === "string" ? rv : `${rv.field} as ${rv.alias}`).join(",")} FROM ${table} WHERE ${whereVar.map((wv) => typeof wv === "string" ? `${wv} = $${wv}` : `${wv.field} = $${wv.variable}`).join(" AND ")}`;
 	},
 	create(idVar, dataVar) {
 		return `CREATE ONLY $${idVar} CONTENT $${dataVar}`;
@@ -44,11 +45,14 @@ const surql = {
 	upsert(idVar, dataVar) {
 		return `UPSERT ONLY $${idVar} REPLACE $${dataVar}`;
 	},
+	upsertMerge(idVar, dataVar) {
+		return `UPSERT ONLY $${idVar} MERGE $${dataVar}`;
+	},
 	updateMerge(idVar, dataVar) {
 		return `UPDATE ONLY $${idVar} MERGE $${dataVar}`;
 	},
 	updateSet(idVar, keyDataVar) {
-		return `UPDATE $${idVar} SET ${keyDataVar.map((keyDataVar) => typeof keyDataVar === "string" ? `${keyDataVar} = $${keyDataVar}` : "statement" in keyDataVar ? keyDataVar.statement : `${keyDataVar.key} = $${keyDataVar.variable}`).join(", ")}`;
+		return `UPDATE $${idVar} SET ${keyDataVar.map((kdv) => typeof kdv === "string" ? `${kdv} = $${kdv}` : "statement" in kdv ? kdv.statement : `${kdv.key} = $${kdv.variable}`).join(", ")}`;
 	},
 	delete(idVar) {
 		return `DELETE $${idVar}`;
@@ -76,7 +80,7 @@ const surql = {
 //#region src/utils/parser.ts
 function cleanRecord(tableSchema, record) {
 	const cleaned = {};
-	for (const [key, value] of Object.entries(record)) if (key === "id" || key in tableSchema) cleaned[key] = value;
+	for (const [key, value] of Object.entries(record)) if (key === "id" || key.startsWith("_00_") || key in tableSchema) cleaned[key] = value;
 	return cleaned;
 }
 function parseParams(tableSchema, params) {
@@ -148,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;
@@ -162,7 +175,7 @@ function parseDuration(duration) {
 	if (typeof duration !== "string") return 6e5;
 	const match = duration.match(/^(\d+)([smh])$/);
 	if (!match) return 6e5;
-	const val = parseInt(match[1], 10);
+	const val = Number.parseInt(match[1], 10);
 	switch (match[2]) {
 		case "s": return val * 1e3;
 		case "h": return val * 36e5;
@@ -174,6 +187,13 @@ async function fileToUint8Array(file) {
 	return new Uint8Array(buffer);
 }
 /**
+* Convert plain text to simple HTML paragraphs.
+* Useful for seeding a rich-text editor (e.g. TipTap/ProseMirror) with fallback content.
+*/
+function textToHtml(text) {
+	return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").split("\n").map((l) => `<p>${l || "<br>"}</p>`).join("");
+}
+/**
 * Helper for retrying DB operations with exponential backoff
 */
 async function withRetry(logger, operation, retries = 3, delayMs = 100) {
@@ -188,7 +208,7 @@ async function withRetry(logger, operation, retries = 3, delayMs = 100) {
 				attempt: i + 1,
 				retries,
 				error: msg,
-				Category: "spooky-client::utils::withRetry"
+				Category: "sp00ky-client::utils::withRetry"
 			}, "Retrying DB operation");
 			await new Promise((res) => setTimeout(res, delayMs * (i + 1)));
 			continue;
@@ -198,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
 *
@@ -210,9 +382,38 @@ 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) {
 		this.cache = cache;
 		this.local = local;
@@ -220,8 +421,35 @@ var DataModule = class {
 		this.streamDebounceTime = streamDebounceTime;
 		this.logger = logger.child({ service: "DataModule" });
 	}
-	async init() {
-		this.logger.info({ Category: "spooky-client::DataModule::init" }, "DataModule initialized");
+	async init(sessionId) {
+		this.sessionId = sessionId;
+		this.logger.info({
+			sessionId,
+			Category: "sp00ky-client::DataModule::init"
+		}, "DataModule initialized");
+	}
+	/**
+	* Update the session salt used in query-id hashing. Call this when the
+	* SurrealDB session changes (sign-in, sign-out, reconnect). Subsequently
+	* registered queries will get fresh, session-scoped IDs.
+	*/
+	setSessionId(sessionId) {
+		this.sessionId = sessionId;
+	}
+	/**
+	* Update the authenticated user record id. Pass `null` on sign-out.
+	* Read by `Sp00kySync.listRefTable()` so the LIVE subscription and
+	* the poll route to the same per-user `_00_list_ref_user_<id>` the
+	* SSP writes to.
+	*/
+	setCurrentUserId(userId) {
+		this.currentUserId = userId;
+	}
+	/** Read-only view of the authenticated user id used for per-user
+	* `_00_list_ref` routing. Other modules consult this so they pick the
+	* same table name DataModule does. */
+	getCurrentUserId() {
+		return this.currentUserId;
 	}
 	/**
 	* Register a query and return its hash for subscriptions
@@ -233,27 +461,27 @@ var DataModule = class {
 		});
 		this.logger.debug({
 			hash,
-			Category: "spooky-client::DataModule::query"
+			Category: "sp00ky-client::DataModule::query"
 		}, "Query Initialization: started");
-		const recordId = new RecordId("_spooky_query", hash);
+		const recordId = new RecordId("_00_query", hash);
 		if (this.activeQueries.has(hash)) {
 			this.logger.debug({
 				hash,
-				Category: "spooky-client::DataModule::query"
+				Category: "sp00ky-client::DataModule::query"
 			}, "Query Initialization: exists, returning");
 			return hash;
 		}
 		if (this.pendingQueries.has(hash)) {
 			this.logger.debug({
 				hash,
-				Category: "spooky-client::DataModule::query"
+				Category: "sp00ky-client::DataModule::query"
 			}, "Query Initialization: pending, waiting for existing creation");
 			await this.pendingQueries.get(hash);
 			return hash;
 		}
 		this.logger.debug({
 			hash,
-			Category: "spooky-client::DataModule::query"
+			Category: "sp00ky-client::DataModule::query"
 		}, "Query Initialization: not found, creating new query");
 		const promise = this.createAndRegisterQuery(hash, recordId, surqlString, params, ttl, tableName);
 		this.pendingQueries.set(hash, promise);
@@ -283,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) {
@@ -296,66 +554,298 @@ 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 } = update;
+		const { queryHash, localArray, materializationTimeMs } = update;
 		const queryState = this.activeQueries.get(queryHash);
 		if (!queryState) {
 			this.logger.warn({
 				queryHash,
-				Category: "spooky-client::DataModule::onStreamUpdate"
+				Category: "sp00ky-client::DataModule::onStreamUpdate"
 			}, "Received update for unknown query. Skipping...");
 			return;
 		}
+		if (typeof materializationTimeMs === "number") {
+			queryState.materializationSamples.push(materializationTimeMs);
+			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;
-			await this.local.query(surql.seal(surql.updateSet("id", ["localArray"])), {
-				id: queryState.config.id,
-				localArray
-			});
 			const prevJson = JSON.stringify(queryState.records);
 			const newJson = JSON.stringify(newRecords);
 			queryState.records = newRecords;
-			if (prevJson === newJson) {
+			const recordsChanged = prevJson !== newJson;
+			if (recordsChanged) queryState.updateCount++;
+			await this.local.query(surql.seal(surql.updateSet("id", [
+				"localArray",
+				"rowCount",
+				"updateCount",
+				"lastIngestLatency",
+				"materializationP55",
+				"materializationP90",
+				"materializationP99"
+			])), {
+				id: queryState.config.id,
+				localArray,
+				rowCount: localArray.length,
+				updateCount: queryState.updateCount,
+				lastIngestLatency: queryState.lastIngestLatencyMs,
+				materializationP55: percentiles.p55,
+				materializationP90: percentiles.p90,
+				materializationP99: percentiles.p99
+			});
+			if (!recordsChanged) {
 				this.logger.debug({
 					queryHash,
-					Category: "spooky-client::DataModule::onStreamUpdate"
+					Category: "sp00ky-client::DataModule::onStreamUpdate"
 				}, "Query records unchanged, skipping notification");
 				return;
 			}
-			queryState.updateCount++;
 			const subscribers = this.subscriptions.get(queryHash);
 			if (subscribers) for (const callback of subscribers) callback(queryState.records);
 			this.logger.debug({
 				queryHash,
-				recordCount: records?.length,
-				Category: "spooky-client::DataModule::onStreamUpdate"
+				recordCount: newRecords?.length,
+				Category: "sp00ky-client::DataModule::onStreamUpdate"
 			}, "Query updated from stream");
 		} catch (err) {
+			queryState.errorCount++;
 			this.logger.error({
 				err,
 				queryHash,
-				Category: "spooky-client::DataModule::onStreamUpdate"
+				Category: "sp00ky-client::DataModule::onStreamUpdate"
 			}, "Failed to fetch records for stream update");
+			try {
+				await this.local.query(surql.seal(surql.updateSet("id", ["errorCount"])), {
+					id: queryState.config.id,
+					errorCount: queryState.errorCount
+				});
+			} catch (persistErr) {
+				this.logger.warn({
+					err: persistErr,
+					queryHash,
+					Category: "sp00ky-client::DataModule::onStreamUpdate"
+				}, "Failed to persist incremented errorCount");
+			}
 		}
 	}
 	/**
+	* Compute p55/p90/p99 from a rolling window of materialization samples.
+	* Returns nulls for any percentile that has no samples yet so SurrealDB
+	* `option<float>` columns stay NONE rather than 0 before the first ingest.
+	*/
+	computeMaterializationPercentiles(samples) {
+		if (samples.length === 0) return {
+			p55: null,
+			p90: null,
+			p99: null
+		};
+		const sorted = [...samples].sort((a, b) => a - b);
+		const pick = (q) => {
+			return sorted[Math.min(sorted.length - 1, Math.floor(q * sorted.length))];
+		};
+		return {
+			p55: pick(.55),
+			p90: pick(.9),
+			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)
 	*/
 	getQueryByHash(hash) {
 		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;
+	}
+	/**
+	* Walk a hydrated record's fields and append any EMBEDDED child records to
+	* `batch` (recursing for nested related fields). An embedded child is a
+	* value that is itself a record — a non-null object whose `id` is a
+	* `RecordId` — or an array of such records (one-to-many vs one-to-one). A
+	* bare `RecordId` (a foreign-key reference) or any other value is skipped,
+	* so this never mistakes a FK column for an embedded body. Children are
+	* keyed by their own `record.id.table`, versioned by `_00_rv`, and cleaned
+	* to their table's real columns (which strips the alias/related fields).
+	* `seen` dedupes within the batch.
+	*/
+	collectEmbeddedChildren(record, batch, seen) {
+		const isEmbeddedRecord = (v) => !!v && typeof v === "object" && !(v instanceof RecordId) && v.id instanceof RecordId;
+		for (const value of Object.values(record)) {
+			const children = Array.isArray(value) ? value.filter(isEmbeddedRecord) : isEmbeddedRecord(value) ? [value] : [];
+			for (const child of children) {
+				const key = encodeRecordId(child.id);
+				if (seen.has(key)) continue;
+				seen.add(key);
+				this.collectEmbeddedChildren(child, batch, seen);
+				const table = child.id.table.toString();
+				const tableSchema = this.schema.tables.find((t) => t.name === table);
+				batch.push({
+					table,
+					op: "CREATE",
+					record: tableSchema ? cleanRecord(tableSchema.columns, child) : child,
+					version: child._00_rv || 1
+				});
+			}
+		}
+	}
+	/**
+	* 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
+		}));
+		const seen = new Set(rows.map((r) => encodeRecordId(r.id)));
+		for (const record of rows) this.collectEmbeddedChildren(record, batch, seen);
+		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) {
@@ -367,12 +857,15 @@ var DataModule = class {
 	getActiveQueries() {
 		return Array.from(this.activeQueries.values());
 	}
+	getActiveQueryHashes() {
+		return Array.from(this.activeQueries.keys());
+	}
 	async updateQueryLocalArray(id, localArray) {
 		const queryState = this.activeQueries.get(id);
 		if (!queryState) {
 			this.logger.warn({
 				id,
-				Category: "spooky-client::DataModule::updateQueryLocalArray"
+				Category: "sp00ky-client::DataModule::updateQueryLocalArray"
 			}, "Query to update local array not found");
 			return;
 		}
@@ -387,7 +880,7 @@ var DataModule = class {
 		if (!queryState) {
 			this.logger.warn({
 				hash,
-				Category: "spooky-client::DataModule::updateQueryRemoteArray"
+				Category: "sp00ky-client::DataModule::updateQueryRemoteArray"
 			}, "Query to update remote array not found");
 			return;
 		}
@@ -404,8 +897,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) {
@@ -431,6 +923,7 @@ var DataModule = class {
 			max_retries: options?.max_retries ?? 3,
 			retry_strategy: options?.retry_strategy ?? "linear"
 		};
+		if (options?.timeout != null) record.timeout = options.timeout;
 		if (options?.assignedTo) record.assigned_to = options.assignedTo;
 		const recordId = `${tableName}:${generateId()}`;
 		await this.create(recordId, record);
@@ -444,7 +937,7 @@ var DataModule = class {
 		if (!tableSchema) throw new Error(`Table ${tableName} not found`);
 		const rid = parseRecordIdString(id);
 		const params = parseParams(tableSchema.columns, data);
-		const mutationId = parseRecordIdString(`_spooky_pending_mutations:${Date.now()}`);
+		const mutationId = parseRecordIdString(`_00_pending_mutations:${Date.now()}`);
 		const dataKeys = Object.keys(params).map((key) => ({
 			key,
 			variable: `data_${key}`
@@ -474,7 +967,7 @@ var DataModule = class {
 		for (const callback of this.mutationCallbacks) callback([mutationEvent]);
 		this.logger.debug({
 			id,
-			Category: "spooky-client::DataModule::create"
+			Category: "sp00ky-client::DataModule::create"
 		}, "Record created");
 		return target;
 	}
@@ -487,10 +980,10 @@ var DataModule = class {
 		if (!tableSchema) throw new Error(`Table ${tableName} not found`);
 		const rid = parseRecordIdString(id);
 		const params = parseParams(tableSchema.columns, data);
-		const mutationId = parseRecordIdString(`_spooky_pending_mutations:${Date.now()}`);
+		const mutationId = parseRecordIdString(`_00_pending_mutations:${Date.now()}`);
 		const [beforeRecord] = await withRetry(this.logger, () => this.local.query("SELECT * FROM ONLY $id", { id: rid }));
 		const query = surql.seal(surql.tx([
-			surql.updateSet("id", [{ statement: "spooky_rv += 1" }]),
+			surql.updateSet("id", [{ statement: "_00_rv += 1" }]),
 			surql.let("updated", surql.updateMerge("id", "data")),
 			surql.createMutation("update", "mid", "id", "data"),
 			surql.returnObject([{
@@ -505,14 +998,14 @@ var DataModule = class {
 		}));
 		const updatedFields = { id: target.id };
 		for (const key of Object.keys(data)) if (key in target) updatedFields[key] = target[key];
-		if ("spooky_rv" in target) updatedFields.spooky_rv = target.spooky_rv;
+		if ("_00_rv" in target) updatedFields._00_rv = target._00_rv;
 		this.replaceRecordInQueries(updatedFields);
 		const parsedRecord = parseParams(tableSchema.columns, target);
 		await this.cache.save({
 			table,
 			op: "UPDATE",
 			record: parsedRecord,
-			version: target.spooky_rv
+			version: target._00_rv
 		}, true);
 		const pushEventOptions = parseUpdateOptions(id, data, options);
 		const mutationEvent = {
@@ -527,7 +1020,7 @@ var DataModule = class {
 		for (const callback of this.mutationCallbacks) callback([mutationEvent]);
 		this.logger.debug({
 			id,
-			Category: "spooky-client::DataModule::update"
+			Category: "sp00ky-client::DataModule::update"
 		}, "Record updated");
 		return target;
 	}
@@ -538,13 +1031,32 @@ var DataModule = class {
 		const tableName = extractTablePart(id);
 		if (!this.schema.tables.find((t) => t.name === tableName)) throw new Error(`Table ${tableName} not found`);
 		const rid = parseRecordIdString(id);
-		const mutationId = parseRecordIdString(`_spooky_pending_mutations:${Date.now()}`);
+		const mutationId = parseRecordIdString(`_00_pending_mutations:${Date.now()}`);
+		const [beforeRecords] = await this.local.query("SELECT * FROM ONLY $id", { id: rid });
+		const beforeRecord = beforeRecords ?? {};
 		const query = surql.seal(surql.tx([surql.delete("id"), surql.createMutation("delete", "mid", "id")]));
 		await withRetry(this.logger, () => this.local.execute(query, {
 			id: rid,
 			mid: mutationId
 		}));
-		await this.cache.delete(table, id, true);
+		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,
@@ -553,7 +1065,7 @@ var DataModule = class {
 		for (const callback of this.mutationCallbacks) callback([mutationEvent]);
 		this.logger.debug({
 			id,
-			Category: "spooky-client::DataModule::delete"
+			Category: "sp00ky-client::DataModule::delete"
 		}, "Record deleted");
 	}
 	/**
@@ -568,14 +1080,14 @@ var DataModule = class {
 			this.logger.info({
 				id,
 				tableName,
-				Category: "spooky-client::DataModule::rollbackCreate"
+				Category: "sp00ky-client::DataModule::rollbackCreate"
 			}, "Rolled back optimistic create");
 		} catch (err) {
 			this.logger.error({
 				err,
 				id,
 				tableName,
-				Category: "spooky-client::DataModule::rollbackCreate"
+				Category: "sp00ky-client::DataModule::rollbackCreate"
 			}, "Failed to rollback create");
 		}
 	}
@@ -596,20 +1108,20 @@ var DataModule = class {
 				table: tableName,
 				op: "UPDATE",
 				record: parsedRecord,
-				version: beforeRecord.spooky_rv || 1
+				version: beforeRecord._00_rv || 1
 			}, true);
 			await this.replaceRecordInQueries(beforeRecord);
 			this.logger.info({
 				id,
 				tableName,
-				Category: "spooky-client::DataModule::rollbackUpdate"
+				Category: "sp00ky-client::DataModule::rollbackUpdate"
 			}, "Rolled back optimistic update");
 		} catch (err) {
 			this.logger.error({
 				err,
 				id,
 				tableName,
-				Category: "spooky-client::DataModule::rollbackUpdate"
+				Category: "sp00ky-client::DataModule::rollbackUpdate"
 			}, "Failed to rollback update");
 		}
 	}
@@ -637,24 +1149,53 @@ var DataModule = class {
 			ttl,
 			tableName
 		});
-		const { localArray } = this.cache.registerQuery({
+		const t0 = performance.now();
+		const { localArray, registrationTimings } = this.cache.registerQuery({
 			queryHash: hash,
 			surql: surqlString,
 			params,
 			ttl: new Duration(ttl),
 			lastActiveAt: /* @__PURE__ */ new Date()
 		});
-		await withRetry(this.logger, () => this.local.query(surql.seal(surql.updateSet("id", ["localArray"])), {
+		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",
+			"rowCount"
+		])), {
 			id: recordId,
-			localArray
+			localArray,
+			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,
 			recordCount: queryState.records.length,
-			Category: "spooky-client::DataModule::query"
+			Category: "sp00ky-client::DataModule::query"
 		}, "Query registered");
 		return hash;
 	}
@@ -671,8 +1212,12 @@ var DataModule = class {
 					localArray: [],
 					remoteArray: [],
 					lastActiveAt: /* @__PURE__ */ new Date(),
+					createdAt: /* @__PURE__ */ new Date(),
 					ttl,
-					tableName
+					tableName,
+					updateCount: 0,
+					rowCount: 0,
+					errorCount: 0
 				}
 			}));
 			configRecord = createdRecord;
@@ -683,46 +1228,67 @@ 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) {
 			this.logger.warn({
 				err,
-				Category: "spooky-client::DataModule::createNewQuery"
+				Category: "sp00ky-client::DataModule::createNewQuery"
 			}, "Failed to load initial cached records");
 		}
+		const persistedUpdateCount = typeof configRecord?.updateCount === "number" ? configRecord.updateCount : 0;
+		const persistedErrorCount = typeof configRecord?.errorCount === "number" ? configRecord.errorCount : 0;
 		return {
 			config,
 			records,
 			ttlTimer: null,
 			ttlDurationMs: parseDuration(ttl),
-			updateCount: 0
+			updateCount: persistedUpdateCount,
+			materializationSamples: [],
+			lastIngestLatencyMs: null,
+			errorCount: persistedErrorCount,
+			status: "idle",
+			phaseSamples: {},
+			phaseLast: {},
+			registrationTimings: {
+				parseMs: null,
+				planMs: null,
+				snapshotMs: null,
+				wallMs: null
+			}
 		};
 	}
 	async calculateHash(data) {
-		const content = JSON.stringify(data);
+		const content = JSON.stringify({
+			...data,
+			sessionId: this.sessionId
+		});
 		const msgBuffer = new TextEncoder().encode(content);
 		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: "spooky-client::DataModule::startTTLHeartbeat"
-			}, "TTL heartbeat");
-			this.startTTLHeartbeat(queryState);
+				Category: "sp00ky-client::DataModule::startTTLHeartbeat"
+			}, "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);
@@ -744,7 +1310,7 @@ function parseUpdateOptions(id, data, options) {
 	let pushEventOptions = {};
 	if (options?.debounced) pushEventOptions = { debounced: {
 		delay: options.debounced !== true ? options.debounced?.delay ?? 200 : 200,
-		key: (options.debounced !== true ? options.debounced?.key ?? id : id) === "recordId_x_fields" ? `${id}::${Object.keys(data).sort().join("#")}` : id
+		key: (options.debounced !== true ? options.debounced?.key ?? id : id) === "recordId_x_fields" ? `${id}::${Object.keys(data).toSorted().join("#")}` : id
 	} };
 	return pushEventOptions;
 }
@@ -781,7 +1347,7 @@ var AbstractDatabaseService = class {
 					this.logger.debug({
 						query,
 						vars,
-						Category: "spooky-client::Database::query"
+						Category: "sp00ky-client::Database::query"
 					}, "Executing query");
 					const result = await this.client.query(query, vars);
 					const duration = performance.now() - startTime;
@@ -796,7 +1362,7 @@ var AbstractDatabaseService = class {
 					this.logger.trace({
 						query,
 						result,
-						Category: "spooky-client::Database::query"
+						Category: "sp00ky-client::Database::query"
 					}, "Query executed successfully");
 				} catch (err) {
 					const duration = performance.now() - startTime;
@@ -812,7 +1378,7 @@ var AbstractDatabaseService = class {
 						query,
 						vars,
 						err,
-						Category: "spooky-client::Database::query"
+						Category: "sp00ky-client::Database::query"
 					}, "Query execution failed");
 					reject(err);
 				}
@@ -824,7 +1390,7 @@ var AbstractDatabaseService = class {
 		return query.extract(raw);
 	}
 	async close() {
-		this.logger.info({ Category: "spooky-client::Database::close" }, "Closing database connection");
+		this.logger.info({ Category: "sp00ky-client::Database::close" }, "Closing database connection");
 		await this.client.close();
 	}
 };
@@ -1004,7 +1570,7 @@ var LocalDatabaseService = class extends AbstractDatabaseService {
 					type,
 					phase,
 					service: "surrealdb:local",
-					Category: "spooky-client::LocalDatabaseService::diagnostics"
+					Category: "sp00ky-client::LocalDatabaseService::diagnostics"
 				}, `Local SurrealDB diagnostics captured ${type}:${phase}`);
 			})
 		}), logger, events);
@@ -1015,38 +1581,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,
-			Category: "spooky-client::LocalDatabaseService::connect"
+			storeUrl,
+			Category: "sp00ky-client::LocalDatabaseService::connect"
 		}, "Connecting to local database");
+		this.registerUnloadClose();
 		try {
-			const storeUrl = (this.getConfig().store ?? "memory") === "memory" ? "mem://" : "indxdb://spooky";
-			this.logger.debug({
-				storeUrl,
-				Category: "spooky-client::LocalDatabaseService::connect"
-			}, "[LocalDatabaseService] Calling client.connect");
-			await this.client.connect(storeUrl, {});
-			this.logger.debug({
-				namespace,
-				database,
-				Category: "spooky-client::LocalDatabaseService::connect"
-			}, "[LocalDatabaseService] client.connect returned. Calling client.use");
-			await this.client.use({
-				namespace,
-				database
-			});
-			this.logger.debug({ Category: "spooky-client::LocalDatabaseService::connect" }, "[LocalDatabaseService] client.use returned");
-			this.logger.info({ Category: "spooky-client::LocalDatabaseService::connect" }, "Connected to local database");
+			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: "spooky-client::LocalDatabaseService::connect"
-			}, "Failed to connect to local database");
-			throw err;
+				Category: "sp00ky-client::LocalDatabaseService::connect"
+			}, "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
@@ -1062,7 +1743,7 @@ var RemoteDatabaseService = class extends AbstractDatabaseService {
 				type,
 				phase,
 				service: "surrealdb:remote",
-				Category: "spooky-client::RemoteDatabaseService::diagnostics"
+				Category: "sp00ky-client::RemoteDatabaseService::diagnostics"
 			}, `Remote SurrealDB diagnostics captured ${type}:${phase}`);
 		}) }), logger, events);
 		this.config = config;
@@ -1077,7 +1758,7 @@ var RemoteDatabaseService = class extends AbstractDatabaseService {
 				endpoint,
 				namespace,
 				database,
-				Category: "spooky-client::RemoteDatabaseService::connect"
+				Category: "sp00ky-client::RemoteDatabaseService::connect"
 			}, "Connecting to remote database");
 			try {
 				await this.client.connect(endpoint);
@@ -1086,18 +1767,18 @@ var RemoteDatabaseService = class extends AbstractDatabaseService {
 					database
 				});
 				if (token) {
-					this.logger.debug({ Category: "spooky-client::RemoteDatabaseService::connect" }, "Authenticating with token");
+					this.logger.debug({ Category: "sp00ky-client::RemoteDatabaseService::connect" }, "Authenticating with token");
 					await this.client.authenticate(token);
 				}
-				this.logger.info({ Category: "spooky-client::RemoteDatabaseService::connect" }, "Connected to remote database");
+				this.logger.info({ Category: "sp00ky-client::RemoteDatabaseService::connect" }, "Connected to remote database");
 			} catch (err) {
 				this.logger.error({
 					err,
-					Category: "spooky-client::RemoteDatabaseService::connect"
+					Category: "sp00ky-client::RemoteDatabaseService::connect"
 				}, "Failed to connect to remote database");
 				throw err;
 			}
-		} else this.logger.warn({ Category: "spooky-client::RemoteDatabaseService::connect" }, "No endpoint configured for remote database");
+		} else this.logger.warn({ Category: "sp00ky-client::RemoteDatabaseService::connect" }, "No endpoint configured for remote database");
 	}
 	async signin(params) {
 		return this.client.signin(params);
@@ -1115,70 +1796,14 @@ var RemoteDatabaseService = class extends AbstractDatabaseService {
 
 //#endregion
 //#region src/services/logger/index.ts
-createContextKey("Category");
-function mapLevelToSeverityNumber(level) {
-	switch (level) {
-		case "trace": return 1;
-		case "debug": return 5;
-		case "info": return 9;
-		case "warn": return 13;
-		case "error": return 17;
-		case "fatal": return 21;
-		default: return 9;
-	}
-}
-function createLogger(level = "info", otelEndpoint) {
+function createLogger(level = "info", transmit) {
 	const browserConfig = {
 		asObject: true,
 		write: (o) => {
 			console.log(JSON.stringify(o));
 		}
 	};
-	if (otelEndpoint) {
-		const loggerProvider = new LoggerProvider({
-			resource: resourceFromAttributes({ [ATTR_SERVICE_NAME]: "spooky-client" }),
-			processors: [new BatchLogRecordProcessor(new OTLPLogExporter({ url: otelEndpoint }))]
-		});
-		const otelLogger = {};
-		const getOtelLogger = (category) => {
-			if (!otelLogger[category]) otelLogger[category] = loggerProvider.getLogger(category);
-			return otelLogger[category];
-		};
-		browserConfig.transmit = {
-			level,
-			send: (levelLabel, logEvent) => {
-				try {
-					const messages = [...logEvent.messages];
-					const severityNumber = mapLevelToSeverityNumber(levelLabel);
-					let body = "";
-					const msg = messages.pop();
-					if (typeof msg === "string") body = msg;
-					else if (msg) body = JSON.stringify(msg);
-					let category = "spooky-client::unknown";
-					const attributes = {};
-					for (const msg of messages) if (typeof msg === "object") {
-						if (msg.Category) {
-							category = msg.Category;
-							delete msg.Category;
-						}
-						Object.assign(attributes, msg);
-					}
-					getOtelLogger(category).emit({
-						severityNumber,
-						severityText: levelLabel.toUpperCase(),
-						body,
-						attributes: {
-							...logEvent.bindings[0],
-							...attributes
-						},
-						timestamp: new Date(logEvent.ts)
-					});
-				} catch (e) {
-					console.warn("Failed to transmit log to OTEL endpoint", e);
-				}
-			}
-		};
-	}
+	if (transmit) browserConfig.transmit = transmit;
 	return pino({
 		level,
 		browser: browserConfig
@@ -1203,25 +1828,25 @@ var LocalMigrator = class {
 		const hash = await sha1(schemaSurql);
 		const { database } = this.localDb.getConfig();
 		if (await this.isSchemaUpToDate(hash)) {
-			this.logger.info({ Category: "spooky-client::LocalMigrator::provision" }, "[Provisioning] Schema is up to date, skipping migration");
+			this.logger.info({ Category: "sp00ky-client::LocalMigrator::provision" }, "[Provisioning] Schema is up to date, skipping migration");
 			return;
 		}
 		await this.recreateDatabase(database);
-		const fullSchema = schemaSurql + "\n\n      DEFINE TABLE IF NOT EXISTS _spooky_stream_processor_state SCHEMALESS PERMISSIONS FOR select, create, update, delete WHERE true;\n      DEFINE TABLE IF NOT EXISTS _spooky_query SCHEMALESS PERMISSIONS FOR select, create, update, delete WHERE true;\n      DEFINE TABLE IF NOT EXISTS _spooky_schema SCHEMALESS PERMISSIONS FOR select, create, update, delete WHERE true;\n      DEFINE TABLE IF NOT EXISTS _spooky_pending_mutations SCHEMALESS PERMISSIONS FOR select, create, update, delete WHERE true;\n    ";
+		const fullSchema = schemaSurql + "\n\n      DEFINE TABLE IF NOT EXISTS _00_stream_processor_state SCHEMALESS PERMISSIONS FOR select, create, update, delete WHERE true;\n      DEFINE TABLE IF NOT EXISTS _00_query SCHEMALESS PERMISSIONS FOR select, create, update, delete WHERE true;\n      DEFINE TABLE IF NOT EXISTS _00_schema SCHEMALESS PERMISSIONS FOR select, create, update, delete WHERE true;\n      DEFINE TABLE IF NOT EXISTS _00_pending_mutations SCHEMALESS PERMISSIONS FOR select, create, update, delete WHERE true;\n    ";
 		const statements = this.splitStatements(fullSchema);
 		for (let i = 0; i < statements.length; i++) {
 			const statement = statements[i];
 			const cleanStatement = statement.replace(/--.*/g, "").trim();
 			if (cleanStatement.toUpperCase().startsWith("DEFINE INDEX")) {
-				this.logger.warn({ Category: "spooky-client::LocalMigrator::provision" }, `[Provisioning] Skipping index definition (WASM hang avoidance): ${cleanStatement.substring(0, 50)}...`);
+				this.logger.warn({ Category: "sp00ky-client::LocalMigrator::provision" }, `[Provisioning] Skipping index definition (WASM hang avoidance): ${cleanStatement.substring(0, 50)}...`);
 				continue;
 			}
 			try {
-				this.logger.info({ Category: "spooky-client::LocalMigrator::provision" }, `[Provisioning] (${i + 1}/${statements.length}) Executing: ${statement.substring(0, 50)}...`);
+				this.logger.info({ Category: "sp00ky-client::LocalMigrator::provision" }, `[Provisioning] (${i + 1}/${statements.length}) Executing: ${statement.substring(0, 50)}...`);
 				await this.localDb.query(statement);
-				this.logger.info({ Category: "spooky-client::LocalMigrator::provision" }, `[Provisioning] (${i + 1}/${statements.length}) Done`);
+				this.logger.info({ Category: "sp00ky-client::LocalMigrator::provision" }, `[Provisioning] (${i + 1}/${statements.length}) Done`);
 			} catch (e) {
-				this.logger.error({ Category: "spooky-client::LocalMigrator::provision" }, `[Provisioning] (${i + 1}/${statements.length}) Error executing statement: ${statement}`);
+				this.logger.error({ Category: "sp00ky-client::LocalMigrator::provision" }, `[Provisioning] (${i + 1}/${statements.length}) Error executing statement: ${statement}`);
 				throw e;
 			}
 		}
@@ -1229,22 +1854,22 @@ var LocalMigrator = class {
 	}
 	async isSchemaUpToDate(hash) {
 		try {
-			const [lastSchemaRecord] = await this.localDb.query(`SELECT hash, created_at FROM ONLY _spooky_schema ORDER BY created_at DESC LIMIT 1;`);
+			const [lastSchemaRecord] = await this.localDb.query(`SELECT hash, created_at FROM ONLY _00_schema ORDER BY created_at DESC LIMIT 1;`);
 			return lastSchemaRecord?.hash === hash;
-		} catch (error) {
+		} catch (_error) {
 			return false;
 		}
 	}
 	async recreateDatabase(database) {
 		try {
-			await this.localDb.query(`DEFINE DATABASE _spooky_temp;`);
-		} catch (e) {}
+			await this.localDb.query(`DEFINE DATABASE _00_temp;`);
+		} catch (_e) {}
 		try {
 			await this.localDb.query(`
-        USE DB _spooky_temp;
+        USE DB _00_temp;
         REMOVE DATABASE ${database};
       `);
-		} catch (e) {}
+		} catch (_e) {}
 		await this.localDb.query(`
       DEFINE DATABASE ${database};
       USE DB ${database};
@@ -1302,7 +1927,7 @@ var LocalMigrator = class {
 		return statements;
 	}
 	async createHashRecord(hash) {
-		await this.localDb.query(`UPSERT _spooky_schema SET hash = $hash, created_at = time::now() WHERE hash = $hash;`, { hash });
+		await this.localDb.query(`UPSERT _00_schema SET hash = $hash, created_at = time::now() WHERE hash = $hash;`, { hash });
 	}
 };
 
@@ -1394,7 +2019,7 @@ var UpQueue = class {
 					this.logger.error({
 						error,
 						event,
-						Category: "spooky-client::UpQueue::next"
+						Category: "sp00ky-client::UpQueue::next"
 					}, "Network error processing mutation, re-queuing");
 					this.queue.unshift(event);
 					throw error;
@@ -1402,7 +2027,7 @@ var UpQueue = class {
 				this.logger.error({
 					error,
 					event,
-					Category: "spooky-client::UpQueue::next"
+					Category: "sp00ky-client::UpQueue::next"
 				}, "Application error processing mutation, rolling back");
 				try {
 					await this.removeEventFromDatabase(event.mutation_id);
@@ -1410,7 +2035,7 @@ var UpQueue = class {
 					this.logger.error({
 						error: removeError,
 						event,
-						Category: "spooky-client::UpQueue::next"
+						Category: "sp00ky-client::UpQueue::next"
 					}, "Failed to remove rolled-back mutation from database");
 				}
 				if (onRollback) try {
@@ -1419,7 +2044,7 @@ var UpQueue = class {
 					this.logger.error({
 						error: rollbackError,
 						event,
-						Category: "spooky-client::UpQueue::next"
+						Category: "sp00ky-client::UpQueue::next"
 					}, "Rollback handler failed");
 				}
 				this._events.addEvent({
@@ -1434,7 +2059,7 @@ var UpQueue = class {
 				this.logger.error({
 					error,
 					event,
-					Category: "spooky-client::UpQueue::next"
+					Category: "sp00ky-client::UpQueue::next"
 				}, "Failed to remove mutation from database after successful processing");
 			}
 			this._events.addEvent({
@@ -1448,7 +2073,7 @@ var UpQueue = class {
 	}
 	async loadFromDatabase() {
 		try {
-			const [records] = await this.local.query(`SELECT * FROM _spooky_pending_mutations ORDER BY created_at ASC`);
+			const [records] = await this.local.query(`SELECT * FROM _00_pending_mutations ORDER BY created_at ASC`);
 			this.queue = records.map((r) => {
 				switch (r.mutationType) {
 					case "create": return {
@@ -1474,7 +2099,7 @@ var UpQueue = class {
 						this.logger.warn({
 							mutationType: r.mutationType,
 							record: r,
-							Category: "spooky-client::UpQueue::loadFromDatabase"
+							Category: "sp00ky-client::UpQueue::loadFromDatabase"
 						}, "Unknown mutation type");
 						return null;
 				}
@@ -1482,7 +2107,7 @@ var UpQueue = class {
 		} catch (error) {
 			this.logger.error({
 				error,
-				Category: "spooky-client::UpQueue::loadFromDatabase"
+				Category: "sp00ky-client::UpQueue::loadFromDatabase"
 			}, "Failed to load pending mutations from database");
 		}
 	}
@@ -1523,7 +2148,7 @@ var DownQueue = class {
 			this.logger.error({
 				error,
 				event,
-				Category: "spooky-client::DownQueue::next"
+				Category: "sp00ky-client::DownQueue::next"
 			}, "Failed to process query");
 			this.queue.unshift(event);
 			throw error;
@@ -1538,8 +2163,8 @@ var ArraySyncer = class {
 	remoteArray;
 	needsSort = false;
 	constructor(localArray, remoteArray) {
-		this.remoteArray = remoteArray.sort((a, b) => a[0].localeCompare(b[0]));
-		this.localArray = localArray.sort((a, b) => a[0].localeCompare(b[0]));
+		this.remoteArray = remoteArray.toSorted((a, b) => a[0].localeCompare(b[0]));
+		this.localArray = localArray.toSorted((a, b) => a[0].localeCompare(b[0]));
 	}
 	/**
 	* Inserts an item into the local array
@@ -1575,7 +2200,6 @@ var ArraySyncer = class {
 			this.localArray.sort((a, b) => a[0].localeCompare(b[0]));
 			this.needsSort = false;
 		}
-		console.log("xxxx555", this.localArray, this.remoteArray);
 		return diffRecordVersionArray(this.localArray, this.remoteArray);
 	}
 };
@@ -1606,14 +2230,12 @@ function diffRecordVersionArray(local, remote) {
 	};
 }
 function createDiffFromDbOp(op, recordId, version, versions) {
-	if (op !== "DELETE") {
-		const old = versions?.find((record) => record[0] === encodeRecordId(recordId));
-		if (old && old[1] >= version) return {
-			added: [],
-			updated: [],
-			removed: []
-		};
-	}
+	const old = versions?.find((record) => record[0] === encodeRecordId(recordId));
+	if (old && old[1] >= version) return {
+		added: [],
+		updated: [],
+		removed: []
+	};
 	if (op === "CREATE") return {
 		added: [{
 			id: recordId,
@@ -1636,6 +2258,98 @@ function createDiffFromDbOp(op, recordId, version, versions) {
 		removed: [recordId]
 	};
 }
+/**
+* Default cadence for the `_00_list_ref_user_<id>` poll fallback. The
+* poll is the safety net for SurrealDB v3's occasionally-dropped LIVE
+* deliveries; 500ms is aggressive enough to feel real-time on the
+* happy path while keeping the per-session query load bounded.
+*/
+const DEFAULT_LIST_REF_POLL_INTERVAL_MS = 500;
+/**
+* Build the SurrealQL select that powers both the initial-fetch and
+* the periodic poll of `_00_list_ref[_user_<id>]`. The `parent IS NONE`
+* predicate excludes subquery entries (rows with `parent_rel` set)
+* because the client's `RecordVersionArray` only tracks primary rows;
+* including subquery rows would surface them as spurious "added"
+* diffs every tick.
+*/
+function buildListRefSelect(table) {
+	return `SELECT out, version FROM ${table} WHERE in = $in AND parent IS NONE`;
+}
+/**
+* Build the SurrealQL select for a query's SUBQUERY child edges — the
+* mirror of {@link buildListRefSelect}. `.related()` queries register a
+* correlated subquery; the SSP materializes each matched child as a
+* `_00_list_ref` edge tagged with `parent`/`parent_rel` (see
+* `apps/ssp` edge writer). `parent IS NONE` (the primary select) drops
+* these, so their bodies never reach the local cache and a cold-reload
+* re-materialization of the correlated surql yields empty related
+* fields. This `parent IS NOT NONE` variant pulls the child `out`+`version`
+* pairs (any nesting depth) so we can sync their bodies into the local
+* store SEPARATELY from the primary window array.
+*/
+function buildSubqueryListRefSelect(table) {
+	return `SELECT out, version FROM ${table} WHERE in = $in AND parent IS NOT NONE`;
+}
+/**
+* Resolve the effective list-ref poll interval. Negative or zero
+* values fall back to the default — accepting them would either
+* disable polling silently or busy-loop the event loop.
+*/
+function resolveListRefPollInterval(opt) {
+	if (typeof opt !== "number" || !Number.isFinite(opt) || opt <= 0) return DEFAULT_LIST_REF_POLL_INTERVAL_MS;
+	return opt;
+}
+/**
+* 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 LIST_REF_POLL_MAX_INTERVAL_MS = 5e3;
+/**
+* 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).
+*/
+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);
+}
+/**
+* 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 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
 //#region src/modules/sync/engine.ts
@@ -1643,7 +2357,7 @@ function createDiffFromDbOp(op, recordId, version, versions) {
 * SyncEngine handles the core sync operations: fetching remote records,
 * caching them locally, and ingesting into DBSP.
 *
-* This is extracted from SpookySync to separate "how to sync" from "when to sync".
+* This is extracted from Sp00kySync to separate "how to sync" from "when to sync".
 */
 var SyncEngine = class {
 	logger;
@@ -1652,7 +2366,7 @@ var SyncEngine = class {
 		this.remote = remote;
 		this.cache = cache;
 		this.schema = schema;
-		this.logger = logger.child({ service: "SpookySync:SyncEngine" });
+		this.logger = logger.child({ service: "Sp00kySync:SyncEngine" });
 	}
 	/**
 	* Sync missing/updated/removed records between local and remote.
@@ -1665,33 +2379,42 @@ var SyncEngine = class {
 			added,
 			updated,
 			removed,
-			Category: "spooky-client::SyncEngine::syncRecords"
+			Category: "sp00ky-client::SyncEngine::syncRecords"
 		}, "SyncEngine.syncRecords diff");
-		if (removed.length > 0) await this.handleRemovedRecords(removed);
-		const idsToFetch = [...added, ...updated].map((x) => x.id);
-		if (idsToFetch.length === 0) return;
-		const [remoteResults] = await this.remote.query("SELECT (SELECT * FROM ONLY <record>$parent.id) AS record, (SELECT version FROM ONLY _spooky_version WHERE record_id = <record>$parent.id)['version'] as spooky_rv FROM $idsToFetch", { idsToFetch });
-		console.log("remoteResults>", remoteResults);
+		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 {
+			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 { spooky_rv, record } of remoteResults) {
+		for (const record of remoteResults) {
 			if (!record?.id) {
 				this.logger.warn({
 					record,
 					idsToFetch,
-					Category: "spooky-client::SyncEngine::syncRecords"
-				}, "Remote record has no id. Skipping record");
+					Category: "sp00ky-client::SyncEngine::syncRecords"
+				}, "Remote record has no id (possibly deleted). Skipping record");
 				continue;
 			}
 			const fullId = encodeRecordId(record.id);
 			const table = record.id.table.toString();
 			const isAdded = added.some((item) => encodeRecordId(item.id) === fullId);
+			const version = versionMap.get(fullId) ?? 0;
 			const localVersion = this.cache.lookup(fullId);
-			if (localVersion && spooky_rv <= localVersion) {
+			if (localVersion && version <= localVersion) {
 				this.logger.info({
 					recordId: fullId,
-					version: spooky_rv,
+					version,
 					localVersion,
-					Category: "spooky-client::SyncEngine::syncRecords"
+					Category: "sp00ky-client::SyncEngine::syncRecords"
 				}, "Local version is higher than remote version. Skipping record");
 				continue;
 			}
@@ -1701,37 +2424,59 @@ var SyncEngine = class {
 				table,
 				op: isAdded ? "CREATE" : "UPDATE",
 				record: cleanedRecord,
-				version: spooky_rv
+				version
 			});
 		}
 		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.
+	*
+	* "Removed" here is a derived signal: the SSP's `_00_list_ref` array no
+	* longer references a record that exists locally. That can mean the row
+	* was genuinely deleted upstream — but it can also be a benign race
+	* (e.g. a record we just created hasn't propagated into the SSP's
+	* incantation list yet). Before deleting locally we verify against
+	* upstream SurrealDB: if the row still exists there, skip the delete.
+	*
+	* On verification failure we skip deletion too. Losing a stale local
+	* row to a later sync round is recoverable; deleting a fresh row that
+	* upstream still has is not.
 	*/
 	async handleRemovedRecords(removed) {
 		this.logger.debug({
 			removed: removed.map((r) => r.toString()),
-			Category: "spooky-client::SyncEngine::handleRemovedRecords"
+			Category: "sp00ky-client::SyncEngine::handleRemovedRecords"
 		}, "Checking removed records");
-		let existingRemoteIds = /* @__PURE__ */ new Set();
+		let existingRemoteIds;
 		try {
-			const [existingRemote] = await this.remote.query("SELECT id FROM $ids", { ids: removed });
-			existingRemoteIds = new Set(existingRemote.map((r) => encodeRecordId(r.id)));
-		} catch {
-			this.logger.debug({ Category: "spooky-client::SyncEngine::handleRemovedRecords" }, "Remote existence check failed, proceeding with deletion");
+			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 [];
 		}
+		const stillRemoteIds = [];
 		for (const recordId of removed) {
 			const recordIdStr = encodeRecordId(recordId);
 			if (!existingRemoteIds.has(recordIdStr)) {
 				this.logger.debug({
 					recordId: recordIdStr,
-					Category: "spooky-client::SyncEngine::handleRemovedRecords"
+					Category: "sp00ky-client::SyncEngine::handleRemovedRecords"
 				}, "Deleting confirmed removed record");
 				await this.cache.delete(recordId.table.name, recordIdStr);
-			}
+			} else stillRemoteIds.push(recordIdStr);
 		}
+		return stillRemoteIds;
 	}
 };
 
@@ -1803,23 +2548,82 @@ var SyncScheduler = class {
 	}
 };
 
+//#endregion
+//#region src/modules/ref-tables.ts
+/**
+* Default ref-storage mode for this client build. Mirrors the SSP's
+* default (`RefMode::Dedicated`) so cross-session sync works out of the
+* box.
+*/
+const DEFAULT_REF_MODE = "dedicated";
+/**
+* Sanitize a user record id (e.g. `"user:abc"`) into the segment that
+* goes into a dedicated table name (e.g. `"abc"`). Returns `null` if
+* the id is missing the `user:` prefix or contains characters that
+* aren't valid in a SurrealDB table identifier — the server-side
+* `ssp_protocol::sanitize_user_id` uses the same predicate.
+*
+* Accepts both string ids (`"user:abc"`) and SurrealDB `RecordId`
+* objects (which only stringify cleanly via `.toString()`), since
+* `AuthService` passes the record-id object as-is to its subscribers.
+*/
+function sanitizeUserId(userId) {
+	if (userId === null || userId === void 0) return null;
+	const asString = typeof userId === "string" ? userId : typeof userId.toString === "function" ? userId.toString() : null;
+	if (!asString) return null;
+	const raw = asString.startsWith("user:") ? asString.slice(5) : asString;
+	if (raw.length === 0) return null;
+	if (!/^[A-Za-z0-9_]+$/.test(raw)) return null;
+	return raw;
+}
+/**
+* Returns the `_00_list_ref` table name for `(mode, userId)`. Falls
+* back to the global `_00_list_ref` when sanitization fails or in
+* single mode.
+*/
+function listRefTableFor(mode, userId) {
+	if (mode === "single") return "_00_list_ref";
+	const uid = sanitizeUserId(userId);
+	return uid ? `_00_list_ref_user_${uid}` : "_00_list_ref";
+}
+
 //#endregion
 //#region src/modules/sync/sync.ts
 /**
-* The main synchronization engine for Spooky.
+* The main synchronization engine for Sp00ky.
 * Handles the bidirectional synchronization between the local database and the remote backend.
 * Uses a queue-based architecture with 'up' (local to remote) and 'down' (remote to local) queues.
 * @template S The schema structure type.
 */
-var SpookySync = class {
-	clientId = "";
+var Sp00kySync = class {
 	upQueue;
 	downQueue;
 	isInit = false;
 	logger;
 	syncEngine;
+	/** Engine-level events (e.g. `SYNC_REMOTE_DATA_INGESTED`). Distinct
+	*  from `this.events`, which carries Sp00kySync-level events like
+	*  `SYNC_QUERY_UPDATED` and `SYNC_MUTATION_ROLLED_BACK`. */
+	get engineEvents() {
+		return this.syncEngine.events;
+	}
 	scheduler;
+	wasDisconnected = false;
 	events = createSyncEventSystem();
+	currentUserId = null;
+	refMode = DEFAULT_REF_MODE;
+	currentLiveQueryUuid = null;
+	liveQueryUnsubscribe = null;
+	listRefPollTimer = null;
+	listRefPollRunning = false;
+	refSyncIntervalMs;
+	listRefIdleStreak = 0;
+	stillRemoteStreaks = /* @__PURE__ */ new Map();
+	lastLiveEventAt = null;
+	_liveRetryCount = 0;
+	get liveRetryCount() {
+		return this._liveRetryCount;
+	}
 	get isSyncing() {
 		return this.scheduler.isSyncing;
 	}
@@ -1834,60 +2638,275 @@ var SpookySync = class {
 			this.upQueue.events.unsubscribe(id2);
 		};
 	}
-	constructor(local, remote, cache, dataModule, schema, logger) {
+	constructor(local, remote, cache, dataModule, schema, logger, options) {
 		this.local = local;
 		this.remote = remote;
 		this.cache = cache;
 		this.dataModule = dataModule;
 		this.schema = schema;
-		this.logger = logger.child({ service: "SpookySync" });
+		this.logger = logger.child({ service: "Sp00kySync" });
 		this.upQueue = new UpQueue(this.local, this.logger);
 		this.downQueue = new DownQueue(this.local, this.logger);
 		this.syncEngine = new SyncEngine(this.remote, this.cache, this.schema, this.logger);
 		this.scheduler = new SyncScheduler(this.upQueue, this.downQueue, this.processUpEvent.bind(this), this.processDownEvent.bind(this), this.logger, this.handleRollback.bind(this));
+		this.refSyncIntervalMs = resolveListRefPollInterval(options?.refSyncIntervalMs);
 	}
 	/**
 	* Initializes the synchronization system.
 	* Starts the scheduler and initiates the initial sync cycles.
-	* @param clientId The unique identifier for this client instance.
 	* @throws Error if already initialized.
 	*/
-	async init(clientId) {
-		if (this.isInit) throw new Error("SpookySync is already initialized");
-		this.clientId = clientId;
+	async init() {
+		if (this.isInit) throw new Error("Sp00kySync is already initialized");
 		this.isInit = true;
 		await this.scheduler.init();
-		this.scheduler.syncUp();
+		this.subscribeToReconnect();
 		this.scheduler.syncUp();
 		this.scheduler.syncDown();
-		this.startRefLiveQueries();
+	}
+	/**
+	* Push the authenticated user's record id from the parent client's
+	* auth subscription. Tears down the existing `_00_list_ref` LIVE (if
+	* any) and re-registers it under the new user's dedicated table so
+	* SurrealDB binds the permission rule under the post-flip auth
+	* context. Pass `null` on sign-out.
+	*
+	* The dedicated `_00_list_ref_user_<id>` table is created lazily by
+	* the SSP when the first query registration arrives, which may be
+	* concurrent with this call. We retry the LIVE registration with a
+	* short backoff so a "table not found" race resolves without
+	* surfacing as a permanent auth-loading hang.
+	*/
+	async setCurrentUserId(userId) {
+		if (this.currentUserId === userId) return;
+		this.currentUserId = userId;
+		if (!userId) {
+			await this.killRefLiveQuery();
+			this.stopListRefPoll();
+			return;
+		}
+		this.startListRefPoll();
+		const attemptDelays = [
+			0,
+			250,
+			500,
+			1e3,
+			2e3
+		];
+		for (let i = 0; i < attemptDelays.length; i++) {
+			if (attemptDelays[i] > 0) {
+				this._liveRetryCount++;
+				await new Promise((r) => setTimeout(r, attemptDelays[i]));
+			}
+			try {
+				await this.restartRefLiveQuery();
+				return;
+			} catch (err) {
+				this.logger.debug({
+					err,
+					attempt: i + 1,
+					Category: "sp00ky-client::Sp00kySync::setCurrentUserId"
+				}, "Ref LIVE start failed; relying on periodic poll fallback");
+			}
+		}
+	}
+	startListRefPoll() {
+		if (this.listRefPollRunning) return;
+		this.listRefPollRunning = true;
+		this.logger.debug({
+			intervalMs: this.refSyncIntervalMs,
+			Category: "sp00ky-client::Sp00kySync::startListRefPoll"
+		}, "list_ref poll loop started");
+		const schedule = (delayMs) => {
+			this.listRefPollTimer = setTimeout(async () => {
+				if (!this.listRefPollRunning) return;
+				let changed = false;
+				try {
+					changed = await this.pollListRefForActiveQueries();
+				} finally {
+					if (!this.listRefPollRunning) return;
+					this.listRefIdleStreak = changed ? 0 : this.listRefIdleStreak + 1;
+					schedule(listRefPollDelayMs({
+						idleStreak: this.listRefIdleStreak,
+						baseIntervalMs: this.refSyncIntervalMs
+					}));
+				}
+			}, delayMs);
+		};
+		schedule(this.refSyncIntervalMs);
+	}
+	stopListRefPoll() {
+		this.listRefPollRunning = false;
+		if (this.listRefPollTimer !== null) {
+			clearTimeout(this.listRefPollTimer);
+			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 false;
+		let anyChanged = false;
+		for (const hash of hashes) try {
+			if (await this.refetchListRefForQuery(hash)) anyChanged = true;
+		} catch (err) {
+			this.logger.debug({
+				err: err?.message ?? err,
+				hash,
+				Category: "sp00ky-client::Sp00kySync::pollListRefForActiveQueries"
+			}, "Per-query list_ref poll failed");
+		}
+		return anyChanged;
+	}
+	/**
+	* Pull the upstream list_ref entries for `queryHash`, diff them
+	* against the local `remoteArray` cache, sync any added/updated rows
+	* through the SyncEngine, then persist the new remoteArray. This is
+	* the same shape `createRemoteQuery` does for its initial fetch and
+	* what `handleRemoteListRefChange` does per-LIVE-event — we reuse
+	* it on a timer as a fallback for missed LIVE notifications.
+	*/
+	async refetchListRefForQuery(queryHash) {
+		const queryState = this.dataModule.getQueryByHash(queryHash);
+		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 false;
+		const fresh = items.map((item) => [encodeRecordId(item.out), item.version]);
+		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) {
+			this.logger.info({
+				err: err?.message ?? err,
+				queryHash,
+				Category: "sp00ky-client::Sp00kySync::refetchListRefForQuery"
+			}, "syncQuery failed during poll");
+		}
+		await this.syncSubqueryChildren(queryHash).catch((err) => {
+			this.logger.info({
+				err: err?.message ?? err,
+				queryHash,
+				Category: "sp00ky-client::Sp00kySync::refetchListRefForQuery"
+			}, "Subquery child sync 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
+	* context. Public so the `createRemoteQuery` initial-fetch path can
+	* read from the right per-user table.
+	*
+	* Reads the user id from `DataModule` rather than the local mirror,
+	* because `DataModule.setCurrentUserId` runs synchronously from the
+	* auth callback (before any `await`), whereas `sync.setCurrentUserId`
+	* is async — the userQuery's initial fetch can fire between those
+	* two points and we need the correct table name immediately.
+	*/
+	listRefTable() {
+		return listRefTableFor(this.refMode, this.dataModule.getCurrentUserId());
+	}
+	async killRefLiveQuery() {
+		if (this.liveQueryUnsubscribe) {
+			try {
+				this.liveQueryUnsubscribe();
+			} catch {}
+			this.liveQueryUnsubscribe = null;
+		}
+		if (this.currentLiveQueryUuid !== null) {
+			try {
+				await this.remote.query("KILL $u", { u: this.currentLiveQueryUuid });
+			} catch (err) {
+				this.logger.debug({
+					err,
+					Category: "sp00ky-client::Sp00kySync::killRefLiveQuery"
+				}, "Prior LIVE KILL failed; continuing");
+			}
+			this.currentLiveQueryUuid = null;
+		}
+	}
+	async restartRefLiveQuery() {
+		await this.killRefLiveQuery();
+		await this.startRefLiveQueries();
+	}
+	subscribeToReconnect() {
+		const client = this.remote.getClient();
+		client.subscribe("disconnected", () => {
+			this.wasDisconnected = true;
+			this.logger.info({ Category: "sp00ky-client::Sp00kySync::onDisconnect" }, "Remote disconnected");
+		});
+		client.subscribe("connected", () => {
+			if (!this.wasDisconnected) return;
+			this.wasDisconnected = false;
+			this.logger.info({ Category: "sp00ky-client::Sp00kySync::onReconnect" }, "Remote reconnected, refetching active queries");
+			for (const hash of this.dataModule.getActiveQueryHashes()) this.scheduler.enqueueDownEvent({
+				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() {
+		const tableName = this.listRefTable();
 		this.logger.debug({
-			clientId: this.clientId,
-			Category: "spooky-client::SpookySync::startRefLiveQueries"
+			tableName,
+			Category: "sp00ky-client::Sp00kySync::startRefLiveQueries"
 		}, "Starting ref live queries");
-		const [queryUuid] = await this.remote.query("LIVE SELECT * FROM _spooky_list_ref");
-		(await this.remote.getClient().liveOf(queryUuid)).subscribe((message) => {
+		const [queryUuid] = await this.remote.query(`LIVE SELECT * FROM ${tableName}`);
+		this.currentLiveQueryUuid = queryUuid;
+		this.liveQueryUnsubscribe = (await this.remote.getClient().liveOf(queryUuid)).subscribe((message) => {
 			this.logger.debug({
 				message,
-				Category: "spooky-client::SpookySync::startRefLiveQueries"
+				Category: "sp00ky-client::Sp00kySync::startRefLiveQueries"
 			}, "Live update received");
 			if (message.action === "KILLED") return;
+			if (message.value.parent != null) {
+				this.handleRemoteSubqueryChange(message.action, message.value.in, message.value.out, message.value.version).catch((err) => {
+					this.logger.error({
+						err,
+						Category: "sp00ky-client::Sp00kySync::startRefLiveQueries"
+					}, "Error handling remote subquery change");
+				});
+				return;
+			}
 			this.handleRemoteListRefChange(message.action, message.value.in, message.value.out, message.value.version).catch((err) => {
 				this.logger.error({
 					err,
-					Category: "spooky-client::SpookySync::startRefLiveQueries"
+					Category: "sp00ky-client::Sp00kySync::startRefLiveQueries"
 				}, "Error handling remote list ref change");
 			});
 		});
 	}
 	async handleRemoteListRefChange(action, queryId, recordId, version) {
+		this.lastLiveEventAt = Date.now();
+		this.listRefIdleStreak = 0;
 		const existing = this.dataModule.getQueryById(queryId);
 		if (!existing) {
 			this.logger.warn({
 				queryId: queryId.toString(),
-				Category: "spooky-client::SpookySync::handleRemoteListRefChange"
+				Category: "sp00ky-client::Sp00kySync::handleRemoteListRefChange"
 			}, "Received remote update for unknown local query");
 			return;
 		}
@@ -1898,10 +2917,46 @@ var SpookySync = class {
 			recordId,
 			version,
 			localArray,
-			Category: "spooky-client::SpookySync::handleRemoteListRefChange"
+			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);
+	}
+	/**
+	* Handle a LIVE change to a SUBQUERY child edge (a `_00_list_ref` row with
+	* `parent` set) for a `.related()` query. Unlike primary rows, child rows
+	* must NOT touch the query's `localArray`/`remoteArray`/`rowCount`; we only
+	* keep the child BODY fresh in the local cache so the in-browser SSP's
+	* subquery-table dependency re-materializes the parent view.
+	*
+	* CREATE/UPDATE fetch+upsert the child body. DELETE is intentionally a
+	* no-op: a child leaving this query's set must not delete a body another
+	* query may still show (see `syncSubqueryChildren` deletion-safety note);
+	* a genuine record delete propagates via the normal delete path.
+	*/
+	async handleRemoteSubqueryChange(action, queryId, childId, version) {
+		this.lastLiveEventAt = Date.now();
+		this.listRefIdleStreak = 0;
+		if (action === "DELETE") return;
+		const existing = this.dataModule.getQueryById(queryId);
+		if (!existing) return;
+		const item = {
+			id: childId,
+			version
+		};
+		await this.syncEngine.syncRecords(action === "CREATE" ? {
+			added: [item],
+			updated: [],
+			removed: []
+		} : {
+			added: [],
+			updated: [item],
+			removed: []
+		});
+		const key = encodeRecordId(childId);
+		const prev = existing.config.subqueryRemoteArray ?? [];
+		existing.config.subqueryRemoteArray = [...prev.filter(([id]) => id !== key), [key, version]];
 	}
 	/**
 	* Enqueues a 'down' event (from remote to local) for processing.
@@ -1913,11 +2968,10 @@ var SpookySync = class {
 	async processUpEvent(event) {
 		this.logger.debug({
 			event,
-			Category: "spooky-client::SpookySync::processUpEvent"
+			Category: "sp00ky-client::Sp00kySync::processUpEvent"
 		}, "Processing up event");
-		console.log("xx1", event);
 		switch (event.type) {
-			case "create":
+			case "create": {
 				const dataKeys = Object.keys(event.data).map((key) => ({
 					key,
 					variable: `data_${key}`
@@ -1929,6 +2983,7 @@ var SpookySync = class {
 					...prefixedParams
 				});
 				break;
+			}
 			case "update":
 				await this.remote.query(`UPDATE $id MERGE $data`, {
 					id: event.record_id,
@@ -1941,7 +2996,7 @@ var SpookySync = class {
 			default:
 				this.logger.error({
 					event,
-					Category: "spooky-client::SpookySync::processUpEvent"
+					Category: "sp00ky-client::Sp00kySync::processUpEvent"
 				}, "processUpEvent unknown event type");
 				return;
 		}
@@ -1954,7 +3009,7 @@ var SpookySync = class {
 			recordId,
 			tableName,
 			error: error.message,
-			Category: "spooky-client::SpookySync::handleRollback"
+			Category: "sp00ky-client::Sp00kySync::handleRollback"
 		}, "Rolling back failed mutation");
 		switch (event.type) {
 			case "create":
@@ -1964,13 +3019,13 @@ var SpookySync = class {
 				if (event.beforeRecord) await this.dataModule.rollbackUpdate(event.record_id, tableName, event.beforeRecord);
 				else this.logger.warn({
 					recordId,
-					Category: "spooky-client::SpookySync::handleRollback"
+					Category: "sp00ky-client::Sp00kySync::handleRollback"
 				}, "Cannot rollback update: no beforeRecord available. Down-sync will reconcile.");
 				break;
 			case "delete":
 				this.logger.warn({
 					recordId,
-					Category: "spooky-client::SpookySync::handleRollback"
+					Category: "sp00ky-client::Sp00kySync::handleRollback"
 				}, "Delete rollback not implemented. Down-sync will reconcile.");
 				break;
 		}
@@ -1983,7 +3038,7 @@ var SpookySync = class {
 	async processDownEvent(event) {
 		this.logger.debug({
 			event,
-			Category: "spooky-client::SpookySync::processDownEvent"
+			Category: "sp00ky-client::Sp00kySync::processDownEvent"
 		}, "Processing down event");
 		switch (event.type) {
 			case "register": return this.registerQuery(event.payload.hash);
@@ -2002,13 +3057,76 @@ var SpookySync = class {
 		if (!queryState) {
 			this.logger.warn({
 				hash,
-				Category: "spooky-client::SpookySync::syncQuery"
+				Category: "sp00ky-client::Sp00kySync::syncQuery"
 			}, "Query not found");
 			return;
 		}
 		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.
@@ -2021,7 +3139,7 @@ var SpookySync = class {
 		try {
 			this.logger.debug({
 				queryHash,
-				Category: "spooky-client::SpookySync::registerQuery"
+				Category: "sp00ky-client::Sp00kySync::registerQuery"
 			}, "Register Query state");
 			await this.createRemoteQuery(queryHash);
 			await this.syncQuery(queryHash);
@@ -2029,7 +3147,7 @@ var SpookySync = class {
 		} catch (e) {
 			this.logger.error({
 				err: e,
-				Category: "spooky-client::SpookySync::registerQuery"
+				Category: "sp00ky-client::Sp00kySync::registerQuery"
 			}, "registerQuery error");
 			throw e;
 		}
@@ -2039,37 +3157,80 @@ var SpookySync = class {
 		if (!queryState) {
 			this.logger.warn({
 				queryHash,
-				Category: "spooky-client::SpookySync::createRemoteQuery"
+				Category: "sp00ky-client::Sp00kySync::createRemoteQuery"
 			}, "Query to register not found");
 			throw new Error("Query to register not found");
 		}
 		await this.remote.query("fn::query::register($config)", { config: {
-			clientId: this.clientId,
 			id: queryState.config.id,
 			surql: queryState.config.surql,
 			params: queryState.config.params,
 			ttl: queryState.config.ttl
 		} });
-		const [items] = await this.remote.query(surql.selectByFieldsAnd("_spooky_list_ref", ["in"], ["out", "version"]), { in: queryState.config.id });
+		const listRefTbl = this.listRefTable();
+		const [items] = await this.remote.query(buildListRefSelect(listRefTbl), { in: queryState.config.id });
 		this.logger.trace({
 			queryId: encodeRecordId(queryState.config.id),
 			items,
-			Category: "spooky-client::SpookySync::createRemoteQuery"
+			Category: "sp00ky-client::Sp00kySync::createRemoteQuery"
 		}, "Got query record version array from remote");
 		const array = items.map((item) => [encodeRecordId(item.out), item.version]);
 		this.logger.debug({
 			queryId: encodeRecordId(queryState.config.id),
 			array,
-			Category: "spooky-client::SpookySync::createRemoteQuery"
+			Category: "sp00ky-client::Sp00kySync::createRemoteQuery"
 		}, "createdRemoteQuery");
 		if (array) await this.dataModule.updateQueryRemoteArray(queryHash, array);
+		await this.syncSubqueryChildren(queryHash).catch((err) => {
+			this.logger.info({
+				err: err?.message ?? err,
+				queryHash,
+				Category: "sp00ky-client::Sp00kySync::createRemoteQuery"
+			}, "Subquery child sync failed during registration; poll will retry");
+		});
+	}
+	/**
+	* Sync the BODIES of a `.related()` query's subquery child rows into the
+	* local cache, separately from the primary window array. The SSP writes
+	* each matched child as a `_00_list_ref` edge tagged `parent`/`parent_rel`;
+	* `buildSubqueryListRefSelect` pulls those `out`+`version` pairs (any
+	* nesting depth). We diff against the in-memory `subqueryRemoteArray` and
+	* fetch added/updated bodies through the SyncEngine — which `saveBatch`s
+	* them into the local DB AND the in-browser SSP, whose subquery-table
+	* dependency then re-materializes the parent view (no explicit notify).
+	*
+	* Deletion safety: we pass `removed: []` deliberately. A child body can be
+	* shared by other queries; letting `handleRemovedRecords` delete one that
+	* merely left THIS query's child set would clobber data another query still
+	* shows. Genuine record deletes flow through the normal delete path; a
+	* lingering orphan body is invisible (the correlated WHERE stops matching).
+	*
+	* Kept off `runSyncForQuery` on purpose so child fetches never flip the
+	* query to `fetching` or skew its DevTools timings.
+	*/
+	async syncSubqueryChildren(queryHash) {
+		const queryState = this.dataModule.getQueryByHash(queryHash);
+		if (!queryState) return;
+		const listRefTbl = this.listRefTable();
+		const [items] = await this.remote.query(buildSubqueryListRefSelect(listRefTbl), { in: queryState.config.id });
+		if (!Array.isArray(items)) return;
+		const fresh = items.map((item) => [encodeRecordId(item.out), item.version]);
+		const prev = queryState.config.subqueryRemoteArray ?? [];
+		if (recordVersionArraysEqual(fresh, prev)) return;
+		const diff = diffRecordVersionArray(prev, fresh);
+		if (diff.added.length > 0 || diff.updated.length > 0) await this.syncEngine.syncRecords({
+			added: diff.added,
+			updated: diff.updated,
+			removed: []
+		});
+		queryState.config.subqueryRemoteArray = fresh;
 	}
 	async heartbeatQuery(queryHash) {
 		const queryState = this.dataModule.getQueryByHash(queryHash);
 		if (!queryState) {
 			this.logger.warn({
 				queryHash,
-				Category: "spooky-client::SpookySync::heartbeatQuery"
+				Category: "sp00ky-client::Sp00kySync::heartbeatQuery"
 			}, "Query to register not found");
 			throw new Error("Query to register not found");
 		}
@@ -2077,14 +3238,17 @@ var SpookySync = class {
 	}
 	async cleanupQuery(queryHash) {
 		const queryState = this.dataModule.getQueryByHash(queryHash);
-		if (!queryState) {
-			this.logger.warn({
-				queryHash,
-				Category: "spooky-client::SpookySync::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);
 	}
 };
 
@@ -2095,12 +3259,67 @@ 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
+const CORE_VERSION = "0.0.1-canary.80";
+const WASM_VERSION = "0.0.1-canary.80";
+const SURREAL_VERSION = "3.0.3";
 var DevToolsService = class {
 	eventsHistory = [];
 	eventIdCounter = 0;
-	version = "1.0.0";
+	version = CORE_VERSION;
+	backendInfo = emptyBackendInfo();
 	constructor(databaseService, remoteDatabaseService, logger, schema, authService, dataManager) {
 		this.databaseService = databaseService;
 		this.remoteDatabaseService = remoteDatabaseService;
@@ -2112,7 +3331,26 @@ var DevToolsService = class {
 		this.authService.eventSystem.subscribe(AuthEventTypes.AuthStateChanged, () => {
 			this.notifyDevTools();
 		});
-		this.logger.debug({ Category: "spooky-client::DevToolsService::init" }, "Service initialized");
+		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();
@@ -2122,6 +3360,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,
@@ -2130,7 +3370,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;
@@ -2138,7 +3379,7 @@ var DevToolsService = class {
 	onQueryInitialized(payload) {
 		this.logger.debug({
 			payload,
-			Category: "spooky-client::DevToolsService::onQueryInitialized"
+			Category: "sp00ky-client::DevToolsService::onQueryInitialized"
 		}, "QueryInitialized");
 		const queryHash = this.hashString(payload.queryId.toString());
 		this.addEvent("QUERY_REQUEST_INIT", {
@@ -2151,7 +3392,7 @@ var DevToolsService = class {
 	onQueryUpdated(payload) {
 		this.logger.debug({
 			id: payload.queryId?.toString(),
-			Category: "spooky-client::DevToolsService::onQueryUpdated"
+			Category: "sp00ky-client::DevToolsService::onQueryUpdated"
 		}, "QueryUpdated");
 		const queryHash = this.hashString(payload.queryId.toString());
 		this.addEvent("QUERY_UPDATED", {
@@ -2163,7 +3404,7 @@ var DevToolsService = class {
 	onStreamUpdate(update) {
 		this.logger.debug({
 			update,
-			Category: "spooky-client::DevToolsService::onStreamUpdate"
+			Category: "sp00ky-client::DevToolsService::onStreamUpdate"
 		}, "StreamUpdate");
 		this.addEvent("STREAM_UPDATE", { updates: [update] });
 		this.notifyDevTools();
@@ -2210,6 +3451,15 @@ var DevToolsService = class {
 				userId: this.authService.currentUser?.id
 			},
 			version: this.version,
+			versions: {
+				frontend: {
+					core: CORE_VERSION,
+					wasm: WASM_VERSION,
+					surrealdb: SURREAL_VERSION
+				},
+				backend: this.backendInfo.versions,
+				entities: this.backendInfo.entities
+			},
 			database: {
 				tables: this.schema.tables.map((t) => t.name),
 				tableData: {}
@@ -2218,8 +3468,8 @@ var DevToolsService = class {
 	}
 	notifyDevTools() {
 		if (typeof window !== "undefined") window.postMessage({
-			type: "SPOOKY_STATE_CHANGED",
-			source: "spooky-devtools-page",
+			type: "SP00KY_STATE_CHANGED",
+			source: "sp00ky-devtools-page",
 			state: this.getState()
 		}, "*");
 	}
@@ -2245,13 +3495,14 @@ var DevToolsService = class {
 	}
 	exposeToWindow() {
 		if (typeof window !== "undefined") {
-			window.__SPOOKY__ = {
+			window.__00__ = {
 				version: this.version,
 				getState: () => this.getState(),
 				clearHistory: () => {
 					this.eventsHistory = [];
 					this.notifyDevTools();
 				},
+				refreshVersions: () => this.refreshBackendVersions(),
 				getTableData: async (tableName) => {
 					try {
 						const result = await this.databaseService.query(`SELECT * FROM ${tableName}`);
@@ -2266,7 +3517,7 @@ var DevToolsService = class {
 					} catch (e) {
 						this.logger.error({
 							err: e,
-							Category: "spooky-client::DevToolsService::exposeToWindow"
+							Category: "sp00ky-client::DevToolsService::exposeToWindow"
 						}, "Failed to get table data");
 						return [];
 					}
@@ -2298,7 +3549,7 @@ var DevToolsService = class {
 						this.logger.debug({
 							query,
 							target,
-							Category: "spooky-client::DevToolsService::runQuery"
+							Category: "sp00ky-client::DevToolsService::runQuery"
 						}, "Running query (START)");
 						const service = target === "remote" ? this.remoteDatabaseService : this.databaseService;
 						const startTime = Date.now();
@@ -2309,7 +3560,7 @@ var DevToolsService = class {
 							time: queryTime,
 							resultType: typeof result,
 							isArray: Array.isArray(result),
-							Category: "spooky-client::DevToolsService::runQuery"
+							Category: "sp00ky-client::DevToolsService::runQuery"
 						}, "Database returned result");
 						const serializeStart = Date.now();
 						const serialized = this.serializeForDevTools(result);
@@ -2317,7 +3568,7 @@ var DevToolsService = class {
 						this.logger.debug({
 							serializeTime,
 							serializedLength: JSON.stringify(serialized).length,
-							Category: "spooky-client::DevToolsService::runQuery"
+							Category: "sp00ky-client::DevToolsService::runQuery"
 						}, "Serialization complete");
 						return {
 							success: true,
@@ -2329,7 +3580,7 @@ var DevToolsService = class {
 							err: e,
 							query,
 							target,
-							Category: "spooky-client::DevToolsService::runQuery"
+							Category: "sp00ky-client::DevToolsService::runQuery"
 						}, "Query execution failed");
 						return {
 							success: false,
@@ -2339,23 +3590,52 @@ var DevToolsService = class {
 				}
 			};
 			window.postMessage({
-				type: "SPOOKY_DETECTED",
-				source: "spooky-devtools-page",
+				type: "SP00KY_DETECTED",
+				source: "sp00ky-devtools-page",
 				data: {
 					version: this.version,
 					detected: true
 				}
 			}, "*");
+			window.dispatchEvent(new CustomEvent("sp00ky:init"));
 		}
 	}
 };
 
 //#endregion
 //#region src/modules/auth/index.ts
+/**
+* Read the `AC` (access-method name) claim from a SurrealDB record-access
+* JWT without verifying it — we only need the claim, the server enforces the
+* token. Returns null on any malformed input. The in-browser SSP needs this
+* to resolve `$access` in table permission predicates (mirrors the session's
+* `$access` that the server's `fn::query::register` reads).
+*/
+function decodeAccessFromToken(token) {
+	try {
+		const payload = token.split(".")[1];
+		if (!payload) return null;
+		let b64 = payload.replace(/-/g, "+").replace(/_/g, "/");
+		b64 += "=".repeat((4 - b64.length % 4) % 4);
+		const json = typeof atob === "function" ? atob(b64) : Buffer.from(b64, "base64").toString("binary");
+		const claims = JSON.parse(json);
+		const ac = claims.AC ?? claims.ac;
+		return typeof ac === "string" ? ac : null;
+	} catch {
+		return null;
+	}
+}
 var AuthService = class {
 	token = null;
 	currentUser = null;
 	isAuthenticated = false;
+	/**
+	* The record-access method name for the current session (e.g. `"account"`),
+	* derived from the token's `AC` claim. Consumed by the in-browser SSP's
+	* permission injection so `$access`-gated table predicates resolve locally,
+	* mirroring the server's `$access`. Null when logged out.
+	*/
+	access = null;
 	isLoading = true;
 	events = createAuthEventSystem();
 	get eventSystem() {
@@ -2396,9 +3676,9 @@ var AuthService = class {
 	async check(accessToken) {
 		this.isLoading = true;
 		try {
-			const token = accessToken || await this.persistenceClient.get("spooky_auth_token");
+			const token = accessToken || await this.persistenceClient.get("sp00ky_auth_token");
 			if (!token) {
-				this.logger.debug({ Category: "spooky-client::AuthService::check" }, "No token found in storage or arguments");
+				this.logger.debug({ Category: "sp00ky-client::AuthService::check" }, "No token found in storage or arguments");
 				this.isLoading = false;
 				this.isAuthenticated = false;
 				this.notifyListeners();
@@ -2411,22 +3691,22 @@ var AuthService = class {
 			if (user && user.id) {
 				this.logger.info({
 					user,
-					Category: "spooky-client::AuthService::check"
+					Category: "sp00ky-client::AuthService::check"
 				}, "Auth check complete (via $auth.id)");
 				await this.setSession(token, user);
 			} else {
-				this.logger.warn({ Category: "spooky-client::AuthService::check" }, "$auth.id empty, attempting manual user fetch");
+				this.logger.warn({ Category: "sp00ky-client::AuthService::check" }, "$auth.id empty, attempting manual user fetch");
 				const manualResult = await this.remote.query("SELECT * FROM user WHERE id = $auth.id LIMIT 1");
 				const manualItems = Array.isArray(manualResult) && Array.isArray(manualResult[0]) ? manualResult[0] : manualResult;
 				const manualUser = Array.isArray(manualItems) ? manualItems[0] : manualItems;
 				if (manualUser && manualUser.id) {
 					this.logger.info({
 						user: manualUser,
-						Category: "spooky-client::AuthService::check"
+						Category: "sp00ky-client::AuthService::check"
 					}, "Auth check complete (via manual fetch)");
 					await this.setSession(token, manualUser);
 				} else {
-					this.logger.warn({ Category: "spooky-client::AuthService::check" }, "Token valid but user not found via fallback");
+					this.logger.warn({ Category: "sp00ky-client::AuthService::check" }, "Token valid but user not found via fallback");
 					await this.signOut();
 				}
 			}
@@ -2434,7 +3714,7 @@ var AuthService = class {
 			this.logger.error({
 				error,
 				stack: error.stack,
-				Category: "spooky-client::AuthService::check"
+				Category: "sp00ky-client::AuthService::check"
 			}, "Auth check failed");
 			await this.signOut();
 		} finally {
@@ -2448,19 +3728,27 @@ var AuthService = class {
 		this.token = null;
 		this.currentUser = null;
 		this.isAuthenticated = false;
-		await this.persistenceClient.remove("spooky_auth_token");
+		this.access = null;
+		await this.persistenceClient.remove("sp00ky_auth_token");
 		try {
 			await this.remote.getClient().invalidate();
-		} catch (e) {}
+		} catch (_e) {}
 		this.notifyListeners();
 	}
 	async setSession(token, user) {
 		this.token = token;
 		this.currentUser = user;
 		this.isAuthenticated = true;
-		await this.persistenceClient.set("spooky_auth_token", token);
+		this.access = decodeAccessFromToken(token) ?? this.defaultAccessName();
+		await this.persistenceClient.set("sp00ky_auth_token", token);
 		this.notifyListeners();
 	}
+	/** Fallback when the token carries no `AC` claim: if the schema defines
+	*  exactly one record-access method, assume the session used it. */
+	defaultAccessName() {
+		const names = Object.keys(this.schema.access ?? {});
+		return names.length === 1 ? names[0] : null;
+	}
 	async signUp(accessName, params) {
 		const def = this.getAccessDefinition(accessName);
 		if (!def) throw new Error(`Access definition '${accessName}' not found`);
@@ -2470,13 +3758,13 @@ var AuthService = class {
 		this.logger.info({
 			accessName,
 			runtimeParams,
-			Category: "spooky-client::AuthService::signUp"
+			Category: "sp00ky-client::AuthService::signUp"
 		}, "Attempting signup");
 		const { access } = await this.remote.getClient().signup({
 			access: accessName,
 			variables: runtimeParams
 		});
-		this.logger.info({ Category: "spooky-client::AuthService::signUp" }, "Signup successful, token received");
+		this.logger.info({ Category: "sp00ky-client::AuthService::signUp" }, "Signup successful, token received");
 		await this.check(access);
 	}
 	async signIn(accessName, params) {
@@ -2487,7 +3775,7 @@ var AuthService = class {
 		if (missingParams.length > 0) throw new Error(`Missing required signin params for '${accessName}': ${missingParams.join(", ")}`);
 		this.logger.info({
 			accessName,
-			Category: "spooky-client::AuthService::signIn"
+			Category: "sp00ky-client::AuthService::signIn"
 		}, "Attempting signin");
 		const { access } = await this.remote.getClient().signin({
 			access: accessName,
@@ -2504,6 +3792,12 @@ var StreamProcessorService = class {
 	processor;
 	isInitialized = false;
 	receivers = [];
+	batching = false;
+	batchBuffer = /* @__PURE__ */ new Map();
+	sessionAuth = {
+		authId: "",
+		access: ""
+	};
 	constructor(events, db, persistenceClient, logger) {
 		this.events = events;
 		this.db = db;
@@ -2518,25 +3812,91 @@ 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.
 	*/
 	async init() {
 		if (this.isInitialized) return;
-		this.logger.info({ Category: "spooky-client::StreamProcessorService::init" }, "Initializing WASM...");
+		this.logger.info({ Category: "sp00ky-client::StreamProcessorService::init" }, "Initializing WASM...");
 		try {
 			await init();
-			this.processor = new SpookyProcessor();
+			this.processor = new Sp00kyProcessor();
 			await this.loadState();
 			this.isInitialized = true;
-			this.logger.info({ Category: "spooky-client::StreamProcessorService::init" }, "Initialized successfully");
+			this.logger.info({ Category: "sp00ky-client::StreamProcessorService::init" }, "Initialized successfully");
 		} catch (e) {
 			this.logger.error({
 				error: e,
-				Category: "spooky-client::StreamProcessorService::init"
+				Category: "sp00ky-client::StreamProcessorService::init"
 			}, "Failed to initialize");
 			throw e;
 		}
@@ -2544,37 +3904,75 @@ var StreamProcessorService = class {
 	async loadState() {
 		if (!this.processor) return;
 		try {
-			const result = await this.persistenceClient.get("_spooky_stream_processor_state");
+			const result = await this.persistenceClient.get("_00_stream_processor_state");
 			if (Array.isArray(result) && result.length > 0 && Array.isArray(result[0]) && result[0].length > 0 && result[0][0]?.state) {
 				const state = result[0][0].state;
 				this.logger.info({
 					stateLength: state.length,
-					Category: "spooky-client::StreamProcessorService::loadState"
+					Category: "sp00ky-client::StreamProcessorService::loadState"
 				}, "Loading state from DB");
 				if (typeof this.processor.load_state === "function") this.processor.load_state(state);
-				else this.logger.warn({ Category: "spooky-client::StreamProcessorService::loadState" }, "load_state method not found on processor");
-			} else this.logger.info({ Category: "spooky-client::StreamProcessorService::loadState" }, "No saved state found");
+				else this.logger.warn({ Category: "sp00ky-client::StreamProcessorService::loadState" }, "load_state method not found on processor");
+			} else this.logger.info({ Category: "sp00ky-client::StreamProcessorService::loadState" }, "No saved state found");
 		} catch (e) {
 			this.logger.error({
 				error: e,
-				Category: "spooky-client::StreamProcessorService::loadState"
+				Category: "sp00ky-client::StreamProcessorService::loadState"
 			}, "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");
+	}
+	/**
+	* Set the current session's auth identity for permission injection,
+	* mirroring the server's `fn::query::register`
+	* (`object::extend(params, { auth: { id: $auth.id }, access: $access })`).
+	* Stored as strings (empty when logged out) and applied to every
+	* `register_view` in {@link registerQueryPlan}. Must be set before a
+	* `$auth`-gated query registers (and re-set on auth state changes), or the
+	* in-browser SSP's `permission_inject` rejects it with
+	* "requires $auth but registration params lack it".
+	*/
+	setSessionAuth(authId, access) {
+		this.sessionAuth = {
+			authId: authId ?? "",
+			access: access ?? ""
+		};
+		this.logger.debug({
+			authId: this.sessionAuth.authId,
+			access: this.sessionAuth.access,
+			Category: "sp00ky-client::StreamProcessorService::setSessionAuth"
+		}, "Session auth context updated");
+	}
 	async saveState() {
 		if (!this.processor) return;
 		try {
 			if (typeof this.processor.save_state === "function") {
 				const state = this.processor.save_state();
 				if (state) {
-					await this.persistenceClient.set("_spooky_stream_processor_state", state);
-					this.logger.trace({ Category: "spooky-client::StreamProcessorService::saveState" }, "State saved");
+					await this.persistenceClient.set("_00_stream_processor_state", state);
+					this.logger.trace({ Category: "sp00ky-client::StreamProcessorService::saveState" }, "State saved");
 				}
 			}
 		} catch (e) {
 			this.logger.error({
 				error: e,
-				Category: "spooky-client::StreamProcessorService::saveState"
+				Category: "sp00ky-client::StreamProcessorService::saveState"
 			}, "Failed to save state");
 		}
 	}
@@ -2588,36 +3986,43 @@ var StreamProcessorService = class {
 			table,
 			op,
 			id,
-			Category: "spooky-client::StreamProcessorService::ingest"
+			Category: "sp00ky-client::StreamProcessorService::ingest"
 		}, "Ingesting into ssp");
 		if (!this.processor) {
-			this.logger.warn({ Category: "spooky-client::StreamProcessorService::ingest" }, "Not initialized, skipping ingest");
+			this.logger.warn({ Category: "sp00ky-client::StreamProcessorService::ingest" }, "Not initialized, skipping ingest");
 			return [];
 		}
 		try {
 			const normalizedRecord = this.normalizeValue(record);
+			const t0 = performance.now();
 			const rawUpdates = this.processor.ingest(table, op, id, normalizedRecord);
+			const materializationTimeMs = performance.now() - t0;
 			this.logger.debug({
 				table,
 				op,
 				id,
 				rawUpdates: rawUpdates.length,
-				Category: "spooky-client::StreamProcessorService::ingest"
+				materializationTimeMs,
+				Category: "sp00ky-client::StreamProcessorService::ingest"
 			}, "Ingesting into ssp done");
 			if (rawUpdates && Array.isArray(rawUpdates) && rawUpdates.length > 0) {
 				const updates = rawUpdates.map((u) => ({
 					queryHash: u.query_id,
 					localArray: u.result_data,
-					op
+					op,
+					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({
 				error: e,
-				Category: "spooky-client::StreamProcessorService::ingest"
+				Category: "sp00ky-client::StreamProcessorService::ingest"
 			}, "Ingesting into ssp failed");
 		}
 		return [];
@@ -2628,46 +4033,55 @@ var StreamProcessorService = class {
 	*/
 	registerQueryPlan(queryPlan) {
 		if (!this.processor) {
-			this.logger.warn({ Category: "spooky-client::StreamProcessorService::registerQueryPlan" }, "Not initialized, skipping registration");
+			this.logger.warn({ Category: "sp00ky-client::StreamProcessorService::registerQueryPlan" }, "Not initialized, skipping registration");
 			return;
 		}
 		this.logger.debug({
 			queryHash: queryPlan.queryHash,
 			surql: queryPlan.surql,
 			params: queryPlan.params,
-			Category: "spooky-client::StreamProcessorService::registerQueryPlan"
+			Category: "sp00ky-client::StreamProcessorService::registerQueryPlan"
 		}, "Registering query plan");
 		try {
-			const normalizedParams = this.normalizeValue(queryPlan.params);
+			const paramsWithAuth = {
+				...this.normalizeValue(queryPlan.params),
+				auth: { id: this.sessionAuth.authId },
+				access: this.sessionAuth.access
+			};
 			const initialUpdate = this.processor.register_view({
 				id: queryPlan.queryHash,
 				surql: queryPlan.surql,
-				params: normalizedParams,
+				params: paramsWithAuth,
 				clientId: "local",
 				ttl: queryPlan.ttl.toString(),
 				lastActiveAt: (/* @__PURE__ */ new Date()).toISOString()
 			});
 			this.logger.debug({
 				initialUpdate,
-				Category: "spooky-client::StreamProcessorService::registerQueryPlan"
+				Category: "sp00ky-client::StreamProcessorService::registerQueryPlan"
 			}, "register_view result");
 			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({
 				queryHash: queryPlan.queryHash,
 				surql: queryPlan.surql,
 				params: queryPlan.params,
-				Category: "spooky-client::StreamProcessorService::registerQueryPlan"
+				Category: "sp00ky-client::StreamProcessorService::registerQueryPlan"
 			}, "Registered query plan");
 			return update;
 		} catch (e) {
 			this.logger.error({
 				error: e,
-				Category: "spooky-client::StreamProcessorService::registerQueryPlan"
+				Category: "sp00ky-client::StreamProcessorService::registerQueryPlan"
 			}, "Error registering query plan");
 			throw e;
 		}
@@ -2683,13 +4097,14 @@ var StreamProcessorService = class {
 		} catch (e) {
 			this.logger.error({
 				error: e,
-				Category: "spooky-client::StreamProcessorService::unregisterQueryPlan"
+				Category: "sp00ky-client::StreamProcessorService::unregisterQueryPlan"
 			}, "Error unregistering query plan");
 		}
 	}
 	normalizeValue(value) {
 		if (value === null || value === void 0) return value;
 		if (typeof value === "object") {
+			if (value instanceof Uint8Array || value instanceof ArrayBuffer || ArrayBuffer.isView(value)) return null;
 			const hasTable = "table" in value && typeof value.table?.toString === "function";
 			const hasId = "id" in value;
 			const hasToString = typeof value.toString === "function";
@@ -2698,7 +4113,7 @@ var StreamProcessorService = class {
 				const result = value.toString();
 				this.logger.trace({
 					result,
-					Category: "spooky-client::StreamProcessorService::normalizeValue"
+					Category: "sp00ky-client::StreamProcessorService::normalizeValue"
 				}, "RecordId detected");
 				return result;
 			}
@@ -2714,6 +4129,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
 /**
@@ -2741,7 +4201,7 @@ var CacheModule = class {
 		this.logger.debug({
 			queryHash: update.queryHash,
 			arrayLength: update.localArray?.length,
-			Category: "spooky-client::CacheModule::onStreamUpdate"
+			Category: "sp00ky-client::CacheModule::onStreamUpdate"
 		}, "Stream update received");
 		this.streamUpdateCallback(update);
 	}
@@ -2764,7 +4224,7 @@ var CacheModule = class {
 		if (records.length === 0) return;
 		this.logger.debug({
 			count: records.length,
-			Category: "spooky-client::CacheModule::saveBatch"
+			Category: "sp00ky-client::CacheModule::saveBatch"
 		}, "Saving record batch");
 		try {
 			const populatedRecords = records.map((record) => {
@@ -2773,13 +4233,13 @@ var CacheModule = class {
 					...record,
 					record: {
 						...record.record,
-						spooky_rv: record.version
+						_00_rv: record.version
 					}
 				};
 			});
 			if (!skipDbInsert) {
 				const query = surql.seal(surql.tx(populatedRecords.map((_, i) => {
-					return surql.upsert(`id${i}`, `content${i}`);
+					return surql.upsertMerge(`id${i}`, `content${i}`);
 				})));
 				const params = populatedRecords.reduce((acc, record, i) => {
 					const { id, ...content } = record.record;
@@ -2791,20 +4251,26 @@ 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: "spooky-client::CacheModule::saveBatch"
+				Category: "sp00ky-client::CacheModule::saveBatch"
 			}, "Batch saved successfully");
 		} catch (err) {
 			this.logger.error({
 				err,
 				count: records.length,
-				Category: "spooky-client::CacheModule::saveBatch"
+				Category: "sp00ky-client::CacheModule::saveBatch"
 			}, "Failed to save batch");
 			throw err;
 		}
@@ -2812,27 +4278,27 @@ var CacheModule = class {
 	/**
 	* Delete a record from local DB and ingest deletion into DBSP
 	*/
-	async delete(table, id, skipDbDelete = false) {
+	async delete(table, id, skipDbDelete = false, recordData = {}) {
 		this.logger.debug({
 			table,
 			id,
-			Category: "spooky-client::CacheModule::delete"
+			Category: "sp00ky-client::CacheModule::delete"
 		}, "Deleting record");
 		try {
 			if (!skipDbDelete) await this.local.query("DELETE $id", { id: parseRecordIdString(id) });
 			delete this.versionLookups[id];
-			await this.streamProcessor.ingest(table, "DELETE", id, {});
+			this.streamProcessor.ingest(table, "DELETE", id, recordData);
 			this.logger.debug({
 				table,
 				id,
-				Category: "spooky-client::CacheModule::delete"
+				Category: "sp00ky-client::CacheModule::delete"
 			}, "Record deleted successfully");
 		} catch (err) {
 			this.logger.error({
 				err,
 				table,
 				id,
-				Category: "spooky-client::CacheModule::delete"
+				Category: "sp00ky-client::CacheModule::delete"
 			}, "Failed to delete record");
 			throw err;
 		}
@@ -2845,7 +4311,7 @@ var CacheModule = class {
 		this.logger.debug({
 			queryHash: config.queryHash,
 			surql: config.surql,
-			Category: "spooky-client::CacheModule::registerQuery"
+			Category: "sp00ky-client::CacheModule::registerQuery"
 		}, "Registering query");
 		try {
 			const update = this.streamProcessor.registerQueryPlan({
@@ -2862,14 +4328,17 @@ var CacheModule = class {
 			this.logger.debug({
 				queryHash: config.queryHash,
 				arrayLength: update.localArray?.length,
-				Category: "spooky-client::CacheModule::registerQuery"
+				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,
 				queryHash: config.queryHash,
-				Category: "spooky-client::CacheModule::registerQuery"
+				Category: "sp00ky-client::CacheModule::registerQuery"
 			}, "Failed to register query");
 			throw err;
 		}
@@ -2880,24 +4349,618 @@ var CacheModule = class {
 	unregisterQuery(queryHash) {
 		this.logger.debug({
 			queryHash,
-			Category: "spooky-client::CacheModule::unregisterQuery"
+			Category: "sp00ky-client::CacheModule::unregisterQuery"
 		}, "Unregistering query");
 		try {
 			this.streamProcessor.unregisterQueryPlan(queryHash);
 			this.logger.debug({
 				queryHash,
-				Category: "spooky-client::CacheModule::unregisterQuery"
+				Category: "sp00ky-client::CacheModule::unregisterQuery"
 			}, "Query unregistered successfully");
 		} catch (err) {
 			this.logger.error({
 				err,
 				queryHash,
-				Category: "spooky-client::CacheModule::unregisterQuery"
+				Category: "sp00ky-client::CacheModule::unregisterQuery"
 			}, "Failed to unregister query");
 		}
 	}
 };
 
+//#endregion
+//#region src/modules/crdt/crdt-field.ts
+const CURSOR_COLORS = [
+	"#3b82f6",
+	"#ef4444",
+	"#22c55e",
+	"#f59e0b",
+	"#8b5cf6",
+	"#ec4899",
+	"#14b8a6",
+	"#f97316"
+];
+function cursorColorFromName(name) {
+	let hash = 0;
+	for (let i = 0; i < name.length; i++) hash = (hash << 5) - hash + name.charCodeAt(i) | 0;
+	return CURSOR_COLORS[Math.abs(hash) % CURSOR_COLORS.length];
+}
+var CrdtField = class {
+	doc;
+	pushTimer = null;
+	local = null;
+	remote = null;
+	recordId = null;
+	sessionId = "";
+	unsubscribe = null;
+	lastPushTime = 0;
+	lastCursorPushTime = 0;
+	loadedFromCrdt = false;
+	pushRetryCount = 0;
+	logger;
+	cursorsEnabled;
+	/** Remote-push debounce. Local writes happen immediately on every Loro
+	*  update; the remote UPSERT is coalesced over this window. Configured
+	*  via `Sp00kyConfig.crdtDebounceMs`, default 500. */
+	remoteDebounceMs = 500;
+	_onCursorUpdate = null;
+	pendingCursorUpdate = null;
+	/** Callback set by the editor to receive remote cursor updates.
+	*  Any cursor data that arrived before this callback was set will be replayed. */
+	set onCursorUpdate(cb) {
+		this._onCursorUpdate = cb;
+		if (cb && this.pendingCursorUpdate) {
+			try {
+				cb(this.pendingCursorUpdate);
+			} catch (e) {
+				this.logger?.warn({
+					error: e,
+					Category: "sp00ky-client::CrdtField::onCursorUpdate"
+				}, "Failed to replay pending cursor update");
+			}
+			this.pendingCursorUpdate = null;
+		}
+	}
+	get onCursorUpdate() {
+		return this._onCursorUpdate;
+	}
+	constructor(fieldName, cursorsEnabled, initialState, logger) {
+		this.fieldName = fieldName;
+		if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(fieldName)) throw new Error(`CrdtField: refusing unsafe field identifier '${fieldName}' — must match [a-zA-Z_][a-zA-Z0-9_]*`);
+		this.logger = logger ?? null;
+		this.cursorsEnabled = cursorsEnabled;
+		this.doc = new LoroDoc();
+		if (initialState && initialState.length > 0) try {
+			this.doc.import(initialState);
+			this.loadedFromCrdt = true;
+		} catch (e) {
+			this.logger?.warn({
+				error: e,
+				fieldName,
+				Category: "sp00ky-client::CrdtField::constructor"
+			}, "Initial CRDT state is not a valid LoroDoc snapshot — starting empty and will seed from fallback text");
+		}
+	}
+	getDoc() {
+		return this.doc;
+	}
+	/** Whether the LoroDoc was loaded from saved CRDT state */
+	hasContent() {
+		return this.loadedFromCrdt;
+	}
+	startSync(local, remote, recordId, sessionId, debounceMs) {
+		this.local = local;
+		this.remote = remote;
+		this.recordId = recordId;
+		this.sessionId = sessionId;
+		this.remoteDebounceMs = debounceMs;
+		this.unsubscribe = this.doc.subscribeLocalUpdates(() => {
+			this.persistLocal();
+			this.scheduleRemotePush();
+		});
+	}
+	stopSync() {
+		if (this.unsubscribe) {
+			this.unsubscribe();
+			this.unsubscribe = null;
+		}
+		if (this.pushTimer) {
+			clearTimeout(this.pushTimer);
+			this.pushTimer = null;
+		}
+		if (this.remote && this.recordId) this.pushToRemote();
+	}
+	importRemote(state) {
+		if (Date.now() - this.lastPushTime < this.remoteDebounceMs + 200) return;
+		try {
+			this.doc.import(state);
+			this.persistLocal();
+		} catch (e) {
+			this.logger?.warn({
+				error: e,
+				Category: "sp00ky-client::CrdtField::importRemote"
+			}, "Failed to import remote CRDT state");
+		}
+	}
+	exportSnapshot() {
+		return this.doc.export({ mode: "snapshot" });
+	}
+	/** Push this session's cursor blob into the parent row at
+	*  `<field>.cursors[$sid]`. No-op when cursors aren't enabled on this
+	*  field — the editor still calls this method optimistically, but
+	*  without `@cursor` on the schema there's nowhere to store the blob.
+	*  The UPDATE itself fires the parent table's LIVE feed, so other
+	*  browsers receive the cursor change without a separate `_00_rv` bump. */
+	async pushCursorState(encoded) {
+		if (!this.remote || !this.recordId) return;
+		if (!this.cursorsEnabled) return;
+		this.lastCursorPushTime = Date.now();
+		try {
+			const state = encodeBase64(encoded);
+			await this.remote.query(`UPDATE $id SET ${this.fieldName}.cursors[$sid] = $state RETURN NONE;`, {
+				id: parseRecordIdString(this.recordId),
+				sid: this.sessionId,
+				state
+			});
+		} catch (e) {
+			this.logger?.warn({
+				error: e,
+				Category: "sp00ky-client::CrdtField::pushCursorState"
+			}, "Failed to push cursor state");
+		}
+	}
+	/** Import remote cursor state (called by CrdtManager from LIVE SELECT) */
+	importRemoteCursor(base64State) {
+		if (Date.now() - this.lastCursorPushTime < 300) return;
+		try {
+			const data = decodeBase64(base64State);
+			if (this._onCursorUpdate) this._onCursorUpdate(data);
+			else this.pendingCursorUpdate = data;
+		} catch (e) {
+			this.logger?.warn({
+				error: e,
+				Category: "sp00ky-client::CrdtField::importRemoteCursor"
+			}, "Failed to apply remote cursor data");
+		}
+	}
+	scheduleRemotePush() {
+		if (this.pushTimer) clearTimeout(this.pushTimer);
+		this.pushTimer = setTimeout(() => void this.pushToRemote(), this.remoteDebounceMs);
+	}
+	/** SET path inside a parent row for the current snapshot. `@crdt`-only
+	*  fields hold the snapshot directly (`<field>`); `@crdt @cursor`
+	*  fields hold a `{ state, cursors }` object so the snapshot lives at
+	*  `<field>.state` next to per-session cursor blobs. */
+	statePath() {
+		return this.cursorsEnabled ? `${this.fieldName}.state` : this.fieldName;
+	}
+	/** Mirror the LoroDoc snapshot into the parent row locally. Runs on
+	*  every local update and every remote import so reloads (online or
+	*  offline) see the freshest content immediately. Failures are
+	*  swallowed — a stale local write must never block user input. */
+	async persistLocal() {
+		if (!this.local || !this.recordId) return;
+		try {
+			await this.local.query(`UPDATE $id SET ${this.statePath()} = $state RETURN NONE;`, {
+				id: parseRecordIdString(this.recordId),
+				state: this.exportSnapshot()
+			});
+		} catch (e) {
+			this.logger?.debug({
+				error: e,
+				Category: "sp00ky-client::CrdtField::persistLocal"
+			}, "Local CRDT persist failed (best-effort)");
+		}
+	}
+	async pushToRemote() {
+		if (!this.remote || !this.recordId) return;
+		this.lastPushTime = Date.now();
+		try {
+			await this.remote.query(`UPDATE $id SET ${this.statePath()} = $state RETURN NONE;`, {
+				id: parseRecordIdString(this.recordId),
+				state: this.exportSnapshot()
+			});
+			this.pushRetryCount = 0;
+		} catch (e) {
+			this.logger?.warn({
+				error: e,
+				Category: "sp00ky-client::CrdtField::pushToRemote"
+			}, "Failed to push CRDT state to remote");
+			if (this.pushRetryCount < 2) {
+				this.pushRetryCount++;
+				this.scheduleRemotePush();
+			}
+		}
+	}
+};
+function decodeBase64(b64) {
+	if (typeof atob === "function") {
+		const binary = atob(b64);
+		const bytes = new Uint8Array(binary.length);
+		for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
+		return bytes;
+	}
+	return new Uint8Array(Buffer.from(b64, "base64"));
+}
+function encodeBase64(bytes) {
+	if (typeof btoa === "function") {
+		let binary = "";
+		for (let i = 0; i < bytes.length; i++) binary += String.fromCharCode(bytes[i]);
+		return btoa(binary);
+	}
+	return Buffer.from(bytes).toString("base64");
+}
+
+//#endregion
+//#region src/modules/crdt/index.ts
+/**
+* CrdtManager manages active CrdtField instances and their sync channels.
+*
+* Collaborative state lives in two dedicated tables (defined in
+* `apps/cli/src/meta_tables_remote.surql`):
+*   - `_00_crdt`   { record_id, field, state } — one row per (record, field)
+*   - `_00_cursor` { record_id, session_id, field, state } — one row per
+*                    (record, session, field)
+*
+* Splitting them off the parent row is what makes offline edits mergeable:
+* each (record, field) gets its own row, so concurrent offline writes don't
+* collide on the parent's last-write-wins semantics.
+*
+* Cross-browser delivery still rides the parent table's existing LIVE feed
+* to avoid SurrealDB v3 LIVE bugs around dereference-based permission rules
+* (issues 3602, 4026). On every meta UPSERT the writer also bumps the
+* parent's `_00_rv` (a no-op assignment); that fires the parent's LIVE
+* feed, and the receiver pulls the matching `_00_crdt` / `_00_cursor` rows
+* via subquery. Permission inheritance happens server-side via
+* `record_id.id != NONE` (SELECT) and `fn::can_update_record` (UPDATE).
+*/
+var CrdtManager = class {
+	fields = /* @__PURE__ */ new Map();
+	liveByTable = /* @__PURE__ */ new Map();
+	pendingLive = /* @__PURE__ */ new Map();
+	logger;
+	sessionId = "";
+	constructor(schema, local, remote, logger, debounceMs = 500) {
+		this.schema = schema;
+		this.local = local;
+		this.remote = remote;
+		this.debounceMs = debounceMs;
+		this.logger = logger.child({ service: "CrdtManager" });
+	}
+	/** Set the session id that scopes this client's cursor entries. Must be
+	*  called before `open()` for cursors to be pushed under a stable key.
+	*  Passed in from `sp00ky.ts` at boot (it already fetches `session::id()`
+	*  for the data-module salt). */
+	setSessionId(sessionId) {
+		this.sessionId = sessionId;
+	}
+	/**
+	* Open a CRDT field for collaborative editing.
+	*
+	* @param table - Table name
+	* @param recordId - Full record ID (e.g., "thread:abc")
+	* @param field - Field name (e.g., "title", "content")
+	* @param fallbackText - Current plain text from the record, used to seed the
+	*                       LoroDoc if no CRDT state exists yet (migration path)
+	*/
+	async open(table, recordId, field, fallbackText) {
+		this.assertCrdtField(table, field);
+		const cursorsEnabled = this.fieldHasCursor(table, field);
+		const key = this.makeKey(table, recordId, field);
+		let crdtField = this.fields.get(key);
+		if (crdtField) return crdtField;
+		let initialCrdtState;
+		try {
+			const [result] = await this.local.query(`SELECT VALUE ${field} FROM ONLY $id`, { id: parseRecordIdString(recordId) });
+			const snapshot = this.extractSnapshot(result, cursorsEnabled);
+			if (snapshot) initialCrdtState = snapshot;
+		} catch (e) {
+			this.logger.info({
+				error: String(e),
+				recordId,
+				field,
+				Category: "sp00ky-client::CrdtManager::open"
+			}, "No existing CRDT state found in local cache (continuing with empty doc)");
+		}
+		crdtField = new CrdtField(field, cursorsEnabled, initialCrdtState, this.logger);
+		crdtField.startSync(this.local, this.remote, recordId, this.sessionId, this.debounceMs);
+		this.fields.set(key, crdtField);
+		this.logger.info({
+			key,
+			hasInitialState: !!initialCrdtState,
+			hasFallback: !!fallbackText,
+			Category: "sp00ky-client::CrdtManager::open"
+		}, "CrdtField opened");
+		this.ensureTableSubscription(table);
+		if (!initialCrdtState) this.fetchAndDispatchRow(table, recordId);
+		return crdtField;
+	}
+	close(table, recordId, field) {
+		const key = this.makeKey(table, recordId, field);
+		const crdtField = this.fields.get(key);
+		if (crdtField) {
+			crdtField.stopSync();
+			this.fields.delete(key);
+		}
+		const tablePrefix = `${table}:`;
+		if (!Array.from(this.fields.keys()).some((k) => k.startsWith(tablePrefix))) this.killTableSubscription(table);
+		this.logger.debug({
+			key,
+			Category: "sp00ky-client::CrdtManager::close"
+		}, "CrdtField closed");
+	}
+	closeAll() {
+		for (const [_, field] of this.fields) field.stopSync();
+		this.fields.clear();
+		for (const table of Array.from(this.liveByTable.keys())) this.killTableSubscription(table);
+	}
+	/** Ensure a single `LIVE SELECT * FROM <table>` is running, shared across
+	*  every open CrdtField on `table`. */
+	async ensureTableSubscription(table) {
+		if (this.liveByTable.has(table)) return;
+		const pending = this.pendingLive.get(table);
+		if (pending) return pending;
+		const start = (async () => {
+			try {
+				const [uuid] = await this.remote.query(`LIVE SELECT * FROM ${table}`);
+				(await this.remote.getClient().liveOf(uuid)).subscribe((message) => {
+					if (message.action === "KILLED") return;
+					if (message.action !== "CREATE" && message.action !== "UPDATE") return;
+					this.dispatchRow(table, message.value);
+				});
+				this.liveByTable.set(table, uuid);
+				this.logger.info({
+					table,
+					Category: "sp00ky-client::CrdtManager::ensureTableSubscription"
+				}, "LIVE SELECT started");
+			} catch (e) {
+				this.logger.warn({
+					error: e,
+					table,
+					Category: "sp00ky-client::CrdtManager::ensureTableSubscription"
+				}, "Failed to start LIVE SELECT");
+			}
+		})();
+		this.pendingLive.set(table, start);
+		try {
+			await start;
+		} finally {
+			this.pendingLive.delete(table);
+		}
+	}
+	/** Apply a parent-row payload from a non-LIVE source (e.g. the
+	*  list_ref-driven sync engine, when the cross-user LIVE on the
+	*  parent table is filtered out by the SurrealDB cross-session
+	*  permission gap). Same semantics as the internal `dispatchRow`. */
+	applyRow(table, row) {
+		this.dispatchRow(table, row);
+	}
+	/** Dispatch a parent-row LIVE event to every open CrdtField on that
+	*  record. Each open field reads its slice of the row directly — the
+	*  CRDT snapshot is a column on the parent now, so there is no
+	*  follow-up subquery. */
+	dispatchRow(table, row) {
+		const id = row.id != null ? String(row.id) : "";
+		if (!id) return;
+		const rowKeyPrefix = `${table}:${id}:`;
+		for (const [key, crdtField] of this.fields) {
+			if (!key.startsWith(rowKeyPrefix)) continue;
+			const fieldName = key.slice(rowKeyPrefix.length);
+			const cursorsEnabled = this.fieldHasCursor(table, fieldName);
+			const slice = row[fieldName];
+			const snapshot = this.extractSnapshot(slice, cursorsEnabled);
+			if (snapshot) crdtField.importRemote(snapshot);
+			if (cursorsEnabled && slice && typeof slice === "object") {
+				const cursors = slice.cursors;
+				if (cursors && typeof cursors === "object") for (const [sid, blob] of Object.entries(cursors)) {
+					if (sid === this.sessionId) continue;
+					if (typeof blob === "string" && blob.length > 0) crdtField.importRemoteCursor(blob);
+				}
+			}
+		}
+	}
+	/** One-shot remote fetch for a row whose CRDT field hasn't synced
+	*  locally yet (fresh device, memory-backed local DB after reload, …).
+	*  Used by `open()` when the local read came up empty. Subsequent
+	*  cross-browser updates ride `dispatchRow` via the parent LIVE feed. */
+	async fetchAndDispatchRow(table, id) {
+		try {
+			const recordId = parseRecordIdString(id);
+			const [row] = await this.remote.query(`SELECT * FROM ONLY $id`, { id: recordId });
+			if (!row || typeof row !== "object") return;
+			this.dispatchRow(table, row);
+		} catch (e) {
+			this.logger.warn({
+				error: e,
+				table,
+				id,
+				Category: "sp00ky-client::CrdtManager::fetchAndDispatchRow"
+			}, "Failed to fetch parent row for CRDT hydration");
+		}
+	}
+	/** Schema lookup: does `<table>.<field>` carry a `@cursor` annotation?
+	*  Determines the on-disk shape (plain snapshot vs. `{ state, cursors }`). */
+	fieldHasCursor(table, field) {
+		return !!this.schema.tables.find((t) => t.name === table)?.columns[field]?.cursor;
+	}
+	/** Pull the LoroDoc snapshot bytes out of a row slice. For `@crdt`-only
+	*  the slice IS the snapshot (Uint8Array); for `@crdt @cursor` it's
+	*  `{ state, cursors }` where `state` carries the snapshot bytes. */
+	extractSnapshot(value, cursorsEnabled) {
+		const asBytes = (v) => {
+			if (v instanceof Uint8Array) return v.length > 0 ? v : void 0;
+			if (v instanceof ArrayBuffer) return new Uint8Array(v);
+			if (ArrayBuffer.isView(v)) {
+				const view = v;
+				return new Uint8Array(view.buffer, view.byteOffset, view.byteLength);
+			}
+			if (Array.isArray(v) && v.length > 0 && v.every((n) => typeof n === "number")) return Uint8Array.from(v);
+		};
+		if (cursorsEnabled) {
+			if (value && typeof value === "object" && !(value instanceof Uint8Array)) return asBytes(value.state);
+			return;
+		}
+		return asBytes(value);
+	}
+	killTableSubscription(table) {
+		const uuid = this.liveByTable.get(table);
+		if (uuid) {
+			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);
+		}
+	}
+	makeKey(table, recordId, field) {
+		return `${table}:${recordId}:${field}`;
+	}
+	/**
+	* Throws if `<table>.<field>` is not annotated `@crdt` in the schema. Catches
+	* typos, removed annotations, and stale schema codegen at the call site instead
+	* of silently producing a non-CRDT writer.
+	*/
+	assertCrdtField(table, field) {
+		if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(field)) throw new Error(`openCrdtField: refusing unsafe field identifier '${field}' — must match [a-zA-Z_][a-zA-Z0-9_]*`);
+		const tableSchema = this.schema.tables.find((t) => t.name === table);
+		if (!tableSchema) throw new Error(`openCrdtField: unknown table '${table}'. Available: ${this.schema.tables.map((t) => t.name).join(", ")}`);
+		const column = tableSchema.columns[field];
+		if (!column) throw new Error(`openCrdtField: '${table}.${field}' is not in the schema. Available fields: ${Object.keys(tableSchema.columns).join(", ")}`);
+		if (!column.crdt) throw new Error(`openCrdtField: '${table}.${field}' is not annotated '@crdt' in the schema. Add '-- @crdt text' above the field's DEFINE FIELD and regenerate the client schema.`);
+	}
+};
+
+//#endregion
+//#region src/modules/feature-flag/index.ts
+const FEATURE_QUERY = "SELECT key, variant, payload FROM _00_user_feature WHERE key = $key";
+var FeatureFlagHandle = class {
+	latest = {
+		variant: void 0,
+		payload: void 0
+	};
+	listeners = /* @__PURE__ */ new Set();
+	unsubscribeFn = null;
+	onCloseFn = null;
+	closed = false;
+	constructor(key, fallback) {
+		this.key = key;
+		this.fallback = fallback;
+	}
+	attach(unsubscribe) {
+		this.unsubscribeFn?.();
+		this.unsubscribeFn = unsubscribe;
+	}
+	detach() {
+		this.unsubscribeFn?.();
+		this.unsubscribeFn = null;
+	}
+	set(snapshot) {
+		if (this.closed) return;
+		this.latest = snapshot;
+		for (const cb of this.listeners) cb(snapshot);
+	}
+	variant() {
+		return this.latest.variant ?? this.fallback;
+	}
+	payload() {
+		return this.latest.payload;
+	}
+	enabled() {
+		const v = this.variant();
+		return v !== void 0 && v !== "off";
+	}
+	subscribe(cb) {
+		this.listeners.add(cb);
+		cb({
+			variant: this.variant(),
+			payload: this.latest.payload
+		});
+		return () => {
+			this.listeners.delete(cb);
+		};
+	}
+	onClose(cb) {
+		this.onCloseFn = cb;
+	}
+	close() {
+		if (this.closed) return;
+		this.closed = true;
+		this.listeners.clear();
+		this.detach();
+		this.onCloseFn?.();
+	}
+};
+var FeatureFlagModule = class {
+	logger;
+	active = /* @__PURE__ */ new Set();
+	authUnsubscribe = null;
+	lastUserId = null;
+	constructor(deps) {
+		this.deps = deps;
+		this.logger = deps.logger.child({ service: "FeatureFlagModule" });
+	}
+	init() {
+		if (this.authUnsubscribe) return;
+		this.authUnsubscribe = this.deps.auth.subscribe((userId) => {
+			if (userId === this.lastUserId) return;
+			this.lastUserId = userId;
+			this.refreshAll();
+		});
+	}
+	feature(key, options = {}) {
+		const handle = new FeatureFlagHandle(key, options.fallback);
+		const entry = {
+			handle,
+			ttl: options.ttl ?? "10m"
+		};
+		this.active.add(entry);
+		handle.onClose(() => this.active.delete(entry));
+		this.register(entry);
+		return handle;
+	}
+	async closeAll() {
+		this.authUnsubscribe?.();
+		this.authUnsubscribe = null;
+		for (const entry of [...this.active]) entry.handle.close();
+	}
+	async refreshAll() {
+		for (const entry of this.active) {
+			entry.handle.detach();
+			entry.handle.set({
+				variant: void 0,
+				payload: void 0
+			});
+			await this.register(entry);
+		}
+	}
+	async register(entry) {
+		const { handle, ttl } = entry;
+		try {
+			const hash = await this.deps.dataModule.query("_00_user_feature", FEATURE_QUERY, { key: handle.key }, ttl);
+			this.deps.sync.enqueueDownEvent({
+				type: "register",
+				payload: { hash }
+			});
+			const unsub = this.deps.dataModule.subscribe(hash, (records) => {
+				const row = records[0];
+				handle.set({
+					variant: row?.variant,
+					payload: row?.payload
+				});
+			}, { immediate: true });
+			handle.attach(unsub);
+		} catch (err) {
+			this.logger.warn({
+				err,
+				key: handle.key,
+				Category: "sp00ky-client::FeatureFlagModule::register"
+			}, "Failed to register feature flag query");
+		}
+	}
+};
+
 //#endregion
 //#region src/services/persistence/localstorage.ts
 var LocalStoragePersistenceClient = class {
@@ -2930,7 +4993,7 @@ var SurrealDBPersistenceClient = class {
 	}
 	async set(key, val) {
 		try {
-			const id = parseRecordIdString(`_spooky_kv:${key}`);
+			const id = parseRecordIdString(`_00_kv:${key}`);
 			await this.db.query(surql.seal(surql.upsert("id", "data")), {
 				id,
 				data: { val }
@@ -2938,40 +5001,75 @@ var SurrealDBPersistenceClient = class {
 		} catch (error) {
 			this.logger.error({
 				error,
-				Category: "spooky-client::SurrealDBPersistenceClient::set"
+				Category: "sp00ky-client::SurrealDBPersistenceClient::set"
 			}, "Failed to set KV");
 			throw error;
 		}
 	}
 	async get(key) {
 		try {
-			const id = parseRecordIdString(`_spooky_kv:${key}`);
+			const id = parseRecordIdString(`_00_kv:${key}`);
 			const [result] = await this.db.query(surql.seal(surql.selectById("id", ["val"])), { id });
 			if (!result?.val) return null;
 			return result.val;
 		} catch (error) {
 			this.logger.warn({
 				error,
-				Category: "spooky-client::SurrealDBPersistenceClient::get"
+				Category: "sp00ky-client::SurrealDBPersistenceClient::get"
 			}, "Failed to get KV");
 			return null;
 		}
 	}
 	async remove(key) {
 		try {
-			const id = parseRecordIdString(`_spooky_kv:${key}`);
+			const id = parseRecordIdString(`_00_kv:${key}`);
 			await this.db.query(surql.seal(surql.delete("id")), { id });
 		} catch (err) {
 			this.logger.info({
 				err,
-				Category: "spooky-client::SurrealDBPersistenceClient::remove"
+				Category: "sp00ky-client::SurrealDBPersistenceClient::remove"
 			}, "Failed to delete KV");
 		}
 	}
 };
 
 //#endregion
-//#region src/spooky.ts
+//#region src/services/persistence/resilient.ts
+var ResilientPersistenceClient = class {
+	logger;
+	constructor(inner, logger) {
+		this.inner = inner;
+		this.logger = logger.child({ service: "ResilientPersistenceClient" });
+	}
+	set(key, value) {
+		return this.inner.set(key, value);
+	}
+	async get(key) {
+		try {
+			return await this.inner.get(key);
+		} catch (e) {
+			this.logger.warn({
+				key,
+				error: e,
+				Category: "sp00ky-client::ResilientPersistenceClient::get"
+			}, "Persistence read failed, dropping key");
+			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;
+		}
+	}
+	remove(key) {
+		return this.inner.remove(key);
+	}
+};
+
+//#endregion
+//#region src/sp00ky.ts
 var BucketHandle = class {
 	constructor(bucketName, remote) {
 		this.bucketName = bucketName;
@@ -3007,7 +5105,7 @@ var BucketHandle = class {
 		return result;
 	}
 };
-var SpookyClient = class {
+var Sp00kyClient = class {
 	local;
 	remote;
 	persistenceClient;
@@ -3016,6 +5114,8 @@ var SpookyClient = class {
 	dataModule;
 	sync;
 	devTools;
+	crdtManager;
+	featureFlags;
 	logger;
 	auth;
 	streamProcessor;
@@ -3028,33 +5128,49 @@ var SpookyClient = class {
 	get pendingMutationCount() {
 		return this.sync.pendingMutationCount;
 	}
+	/** Number of times the initial list_ref LIVE subscription retried on
+	*  the most recent `setCurrentUserId` call. 0 when the SSP's
+	*  pre-emptive user-table creation got there first; >0 when LIVE
+	*  registration hit a "table not found" race. Exposed so the e2e
+	*  suite can guard the pre-emptive path against regression. */
+	get liveRetryCount() {
+		return this.sync.liveRetryCount;
+	}
 	subscribeToPendingMutations(cb) {
 		return this.sync.subscribeToPendingMutations(cb);
 	}
 	constructor(config) {
 		this.config = config;
-		const logger = createLogger(config.logLevel ?? "info", config.otelEndpoint);
-		this.logger = logger.child({ service: "SpookyClient" });
+		const logger = createLogger(config.logLevel ?? "info", config.otelTransmit);
+		this.logger = logger.child({ service: "Sp00kyClient" });
 		this.logger.info({
 			config: {
 				...config,
 				schema: "[SchemaStructure]"
 			},
-			Category: "spooky-client::SpookyClient::constructor"
-		}, "SpookyClient initialized");
+			Category: "sp00ky-client::Sp00kyClient::constructor"
+		}, "Sp00kyClient initialized");
 		this.local = new LocalDatabaseService(this.config.database, logger);
 		this.remote = new RemoteDatabaseService(this.config.database, logger);
 		if (config.persistenceClient === "surrealdb") this.persistenceClient = new SurrealDBPersistenceClient(this.local, logger);
 		else if (config.persistenceClient === "localstorage" || !config.persistenceClient) this.persistenceClient = new LocalStoragePersistenceClient(logger);
 		else this.persistenceClient = config.persistenceClient;
+		this.persistenceClient = new ResilientPersistenceClient(this.persistenceClient, logger);
 		this.streamProcessor = new StreamProcessorService(new EventSystem(["stream_update"]), this.local, this.persistenceClient, logger);
 		this.migrator = new LocalMigrator(this.local, logger);
 		this.cache = new CacheModule(this.local, this.streamProcessor, (update) => {
 			this.dataModule.onStreamUpdate(update);
 		}, logger);
+		this.crdtManager = new CrdtManager(this.config.schema, this.local, this.remote, logger, config.crdtDebounceMs ?? 500);
 		this.dataModule = new DataModule(this.cache, this.local, this.config.schema, logger, this.config.streamDebounceTime);
 		this.auth = new AuthService(this.config.schema, this.remote, this.persistenceClient, logger);
-		this.sync = new SpookySync(this.local, this.remote, this.cache, this.dataModule, this.config.schema, this.logger);
+		this.sync = new Sp00kySync(this.local, this.remote, this.cache, this.dataModule, this.config.schema, this.logger, { refSyncIntervalMs: this.config.refSyncIntervalMs });
+		this.featureFlags = new FeatureFlagModule({
+			dataModule: this.dataModule,
+			sync: this.sync,
+			auth: this.auth,
+			logger
+		});
 		this.devTools = new DevToolsService(this.local, this.remote, logger, this.config.schema, this.auth, this.dataModule);
 		this.streamProcessor.addReceiver(this.devTools);
 		this.setupCallbacks();
@@ -3063,6 +5179,27 @@ var SpookyClient = 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);
@@ -3070,6 +5207,22 @@ var SpookyClient = class {
 		this.sync.events.subscribe("SYNC_QUERY_UPDATED", (event) => {
 			this.devTools.logEvent("SYNC_QUERY_UPDATED", event.payload);
 		});
+		this.sync.engineEvents.subscribe("SYNC_REMOTE_DATA_INGESTED", (event) => {
+			try {
+				const records = event.payload?.records ?? [];
+				for (const row of records) {
+					const id = row?.id;
+					const table = id && typeof id === "object" && id.table !== void 0 ? String(id.table) : void 0;
+					if (!table) continue;
+					this.crdtManager.applyRow(table, row);
+				}
+			} catch (err) {
+				this.logger.debug({
+					err,
+					Category: "sp00ky-client::engineEvents::ingested"
+				}, "applyRow forwarding from sync ingest failed");
+			}
+		});
 		this.local.getEvents().subscribe("DATABASE_LOCAL_QUERY", (event) => {
 			this.devTools.logEvent("LOCAL_QUERY", event.payload);
 		});
@@ -3078,44 +5231,90 @@ var SpookyClient = class {
 		});
 	}
 	async init() {
-		this.logger.info({ Category: "spooky-client::SpookyClient::init" }, "SpookyClient initialization started");
+		this.logger.info({ Category: "sp00ky-client::Sp00kyClient::init" }, "Sp00kyClient initialization started");
 		try {
-			const clientId = this.config.clientId ?? await this.loadOrGenerateClientId();
-			this.persistClientId(clientId);
-			this.logger.debug({
-				clientId,
-				Category: "spooky-client::SpookyClient::init"
-			}, "Client ID loaded");
 			await this.local.connect();
-			this.logger.debug({ Category: "spooky-client::SpookyClient::init" }, "Local database connected");
+			this.logger.debug({ Category: "sp00ky-client::Sp00kyClient::init" }, "Local database connected");
 			await this.migrator.provision(this.config.schemaSurql);
-			this.logger.debug({ Category: "spooky-client::SpookyClient::init" }, "Schema provisioned");
+			this.logger.debug({ Category: "sp00ky-client::Sp00kyClient::init" }, "Schema provisioned");
 			await this.remote.connect();
-			this.logger.debug({ Category: "spooky-client::SpookyClient::init" }, "Remote database connected");
+			this.logger.debug({ Category: "sp00ky-client::Sp00kyClient::init" }, "Remote database connected");
 			await this.streamProcessor.init();
-			this.logger.debug({ Category: "spooky-client::SpookyClient::init" }, "StreamProcessor initialized");
+			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: "spooky-client::SpookyClient::init" }, "Auth initialized");
-			await this.dataModule.init();
-			this.logger.debug({ Category: "spooky-client::SpookyClient::init" }, "DataModule initialized");
-			await this.sync.init(clientId);
-			this.logger.debug({ Category: "spooky-client::SpookyClient::init" }, "Sync initialized");
-			this.logger.info({ Category: "spooky-client::SpookyClient::init" }, "SpookyClient initialization completed successfully");
+			this.logger.debug({ Category: "sp00ky-client::Sp00kyClient::init" }, "Auth initialized");
+			const sessionId = await this.fetchSessionId();
+			await this.dataModule.init(sessionId);
+			this.crdtManager.setSessionId(sessionId);
+			this.logger.debug({
+				sessionId,
+				Category: "sp00ky-client::Sp00kyClient::init"
+			}, "DataModule initialized");
+			this.auth.subscribe(async (userId) => {
+				this.dataModule.setCurrentUserId(userId);
+				this.streamProcessor.setSessionAuth(this.auth.currentUser?.id ? encodeRecordId(this.auth.currentUser.id) : null, this.auth.access);
+				const next = await this.fetchSessionId();
+				this.dataModule.setSessionId(next);
+				this.crdtManager.setSessionId(next);
+				try {
+					await this.sync.setCurrentUserId(userId);
+				} catch (e) {
+					this.logger.error({
+						error: e,
+						Category: "sp00ky-client::Sp00kyClient::authChange"
+					}, "sync.setCurrentUserId failed");
+				}
+			});
+			await this.sync.init();
+			this.logger.debug({ Category: "sp00ky-client::Sp00kyClient::init" }, "Sync initialized");
+			this.featureFlags.init();
+			this.logger.debug({ Category: "sp00ky-client::Sp00kyClient::init" }, "FeatureFlagModule initialized");
+			this.logger.info({ Category: "sp00ky-client::Sp00kyClient::init" }, "Sp00kyClient initialization completed successfully");
 		} catch (e) {
 			this.logger.error({
 				error: e,
-				Category: "spooky-client::SpookyClient::init"
-			}, "SpookyClient initialization failed");
+				Category: "sp00ky-client::Sp00kyClient::init"
+			}, "Sp00kyClient initialization failed");
 			throw e;
 		}
 	}
 	async close() {
+		await this.featureFlags.closeAll();
+		this.crdtManager.closeAll();
 		await this.local.close();
 		await this.remote.close();
 	}
+	/**
+	* Subscribe to a feature flag for the current user. Returns a
+	* `FeatureFlagHandle` whose `variant()`, `payload()` and `enabled()`
+	* accessors reflect the latest assignment from `_00_user_feature`,
+	* and whose `subscribe(cb)` fires whenever that assignment changes.
+	*
+	* Permissions are enforced by SurrealDB: a client can only ever see
+	* its own row, and cannot create or modify assignments.
+	*/
+	feature(key, options) {
+		return this.featureFlags.feature(key, options);
+	}
 	authenticate(token) {
 		return this.remote.getClient().authenticate(token);
 	}
+	/**
+	* Open a CRDT field for collaborative editing.
+	* Returns a CrdtField with a LoroDoc that can be bound to any editor.
+	* Also starts a LIVE SELECT on the parent table for real-time sync;
+	* incoming events trigger a subquery fetch of `_00_crdt` / `_00_cursor`.
+	*/
+	async openCrdtField(table, recordId, field, fallbackText) {
+		return this.crdtManager.open(table, recordId, field, fallbackText);
+	}
+	/**
+	* Close a CRDT field when editing is done.
+	*/
+	closeCrdtField(table, recordId, field) {
+		this.crdtManager.close(table, recordId, field);
+	}
 	deauthenticate() {
 		return this.remote.getClient().invalidate();
 	}
@@ -3125,7 +5324,18 @@ var SpookyClient = 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 }
@@ -3139,6 +5349,32 @@ var SpookyClient = 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);
 	}
@@ -3157,24 +5393,25 @@ var SpookyClient = class {
 	async useRemote(fn) {
 		return fn(this.remote.getClient());
 	}
-	persistClientId(id) {
+	/**
+	* Fetch SurrealDB's `session::id()` as a string. Used as a salt for
+	* query-id hashing so two sessions for the same user get distinct
+	* `_00_query` rows. Returns empty string if the query fails (we still
+	* boot, just without session scoping for IDs).
+	*/
+	async fetchSessionId() {
 		try {
-			this.persistenceClient.set("spooky_client_id", id);
+			const [sid] = await this.remote.query("RETURN <string>session::id()");
+			return typeof sid === "string" ? sid : "";
 		} catch (e) {
 			this.logger.warn({
 				error: e,
-				Category: "spooky-client::SpookyClient::persistClientId"
-			}, "Failed to persist client ID");
+				Category: "sp00ky-client::Sp00kyClient::fetchSessionId"
+			}, "Failed to fetch session::id() — proceeding with empty salt");
+			return "";
 		}
 	}
-	async loadOrGenerateClientId() {
-		const clientId = await this.persistenceClient.get("spooky_client_id");
-		if (clientId) return clientId;
-		const newId = generateId();
-		await this.persistClientId(newId);
-		return newId;
-	}
 };
 
 //#endregion
-export { AuthEventTypes, AuthService, BucketHandle, SpookyClient, createAuthEventSystem, fileToUint8Array };
+export { AuthEventTypes, AuthService, BucketHandle, CURSOR_COLORS, CrdtField, CrdtManager, FeatureFlagHandle, FeatureFlagModule, MATERIALIZATION_SAMPLE_WINDOW, Sp00kyClient, createAuthEventSystem, cursorColorFromName, fileToUint8Array, textToHtml };