@spooky-sync/core 0.0.1-canary.207 → 0.0.1-canary.209

package/dist/index.js

@@ -1,6 +1,6 @@
 import { a as renderOrderSql, c as serializeRow, i as projectedDataSql, l as resolveRelations, o as renderWhereSql, r as project, s as reviveRow, t as PROMOTION_OPEN_OPTIONS, u as stableKey } from "./sqlite-open.js";
 import { DateTime, Duration, RecordId, Surreal, Uuid, applyDiagnostics, createRemoteEngines } from "surrealdb";
-import { QueryBuilder, RecordId as RecordId$1, cyrb53 } from "@spooky-sync/query-builder";
+import { QueryBuilder, RecordId as RecordId$1, baseFieldOfParam, cyrb53 } from "@spooky-sync/query-builder";
 import pino from "pino";
 import { applyPatch } from "fast-json-patch";
 import init, { Sp00kyProcessor } from "@spooky-sync/ssp-wasm";
@@ -84,6 +84,10 @@ function cleanRecord(tableSchema, record) {
 	for (const [key, value] of Object.entries(record)) if (key === "id" || key.startsWith("_00_") || key in tableSchema) cleaned[key] = value;
 	return cleaned;
 }
+/**
+* Parse a RECORD's fields against the table schema. Anything the schema does not
+* know is dropped, which is what keeps a stray field out of a write.
+*/
 function parseParams(tableSchema, params) {
 	const parsedParams = {};
 	for (const [key, value] of Object.entries(params)) {
@@ -92,6 +96,26 @@ function parseParams(tableSchema, params) {
 	}
 	return parsedParams;
 }
+/**
+* Parse a QUERY's params. Unlike a record's fields, a param name is not always a
+* column: an `_or` branch binds under a synthetic `white__or0` (see
+* `orParamName` in @spooky-sync/query-builder), and the surql that references it
+* is already written. So resolve the column through the synthetic name, and keep
+* a param we cannot type rather than dropping it.
+*
+* Dropping was the bug: `parseParams` kept only column-named params, so every
+* `_or` query registered with `$or0`/`$or1` unbound and matched no rows at all,
+* silently (rowCount 0, errorCount 0).
+*/
+function parseQueryParams(tableSchema, params) {
+	const parsedParams = {};
+	for (const [key, value] of Object.entries(params)) {
+		if (value === void 0) continue;
+		const column = tableSchema[key] ?? tableSchema[baseFieldOfParam(key)];
+		parsedParams[key] = column ? parseValue(key, column, value) : value;
+	}
+	return parsedParams;
+}
 function parseValue(name, column, value) {
 	if (column.recordId) {
 		if (value instanceof RecordId$1) return value;
@@ -205,6 +229,7 @@ async function withRetry(logger, operation, retries = 3, delayMs = 100) {
 		return await operation();
 	} catch (err) {
 		lastError = err;
+		if (err?.retryable === false) throw err;
 		if (err?.message?.includes("Can not open transaction") || err?.message?.includes("transaction") || err?.message?.includes("Database is busy")) {
 			const msg = err instanceof Error ? err.message : String(err);
 			logger.warn({
@@ -240,7 +265,7 @@ async function withRetry(logger, operation, retries = 3, delayMs = 100) {
 function withTimeout(promise, timeoutMs, message) {
 	if (!(timeoutMs > 0)) return promise;
 	return new Promise((resolve, reject) => {
-		const timer = setTimeout(() => reject(new Error(message)), timeoutMs);
+		const timer = setTimeout(() => reject(typeof message === "function" ? message() : new Error(message)), timeoutMs);
 		promise.then((value) => {
 			clearTimeout(timer);
 			resolve(value);
@@ -258,12 +283,20 @@ var AbstractDatabaseService = class {
 	logger;
 	events;
 	/**
-	* Per-query deadline in ms; `0` disables. Only the remote service sets this
-	* (see `RemoteDatabaseService`) — a local query can be legitimately slow and
-	* has its own retry ladders, and there is no half-open-socket failure mode
-	* for an in-process engine.
+	* Per-query deadline in ms; `0` disables. The remote service sets it from
+	* `queryTimeoutMs` (see `RemoteDatabaseService`), the local one from
+	* `localOpTimeoutMs` (see `LocalDatabaseService`): a local query can be
+	* legitimately slow, but it must never be endless - every query waits on the
+	* previous link of {@link query}'s chain, and one that never settled wedged
+	* every later local op behind it.
 	*/
 	queryTimeoutMs = 0;
+	/** The error a deadline expiry rejects with; the local service substitutes
+	*  its typed `LocalOpTimeoutError`. "timed out" in the message is
+	*  load-bearing either way: `classifySyncError` keys off it. */
+	timeoutError(_query) {
+		return /* @__PURE__ */ new Error(`Remote query timed out after ${this.queryTimeoutMs}ms`);
+	}
 	constructor(client, logger, events) {
 		this.client = client;
 		this.logger = logger.child({ service: "Database" });
@@ -297,7 +330,7 @@ var AbstractDatabaseService = class {
 						vars,
 						Category: "sp00ky-client::Database::query"
 					}, "Executing query");
-					const result = await withTimeout(this.client.query(query, vars), this.queryTimeoutMs, `Remote query timed out after ${this.queryTimeoutMs}ms`);
+					const result = await withTimeout(this.client.query(query, vars), this.queryTimeoutMs, () => this.timeoutError(query));
 					const duration = performance.now() - startTime;
 					this.events.emit(this.eventType, {
 						query,
@@ -343,6 +376,41 @@ var AbstractDatabaseService = class {
 	}
 };
 
+//#endregion
+//#region src/services/database/errors.ts
+/**
+* A local-store operation that did not answer within its deadline.
+*
+* The local write path (`db.create` / `db.update` / `db.delete`, every local
+* query behind them) used to have no deadline anywhere: the SQLite worker
+* transport parks a call until the worker replies, the surrealdb engine's
+* query chain waits on the previous link, and `withRetry` retries without a
+* clock. One op that never settled (a worker starved behind a long select, a
+* lock verification awaiting `navigator.locks.query()` forever) left the
+* caller's promise pending for the tab's lifetime - a chat composer that never
+* re-enabled, a call that never got past "Connecting".
+*
+* The message says "timed out" on purpose: `classifySyncError` keys off it and
+* treats the failure as transient (re-queue), never as an application error
+* that rolls the mutation back. `retryable: false` keeps `withRetry` from
+* spinning on it: the op is still running in the engine, retrying queues a
+* second copy behind it.
+*/
+var LocalOpTimeoutError = class extends Error {
+	name = "LocalOpTimeoutError";
+	retryable = false;
+	op;
+	timeoutMs;
+	constructor(op, timeoutMs) {
+		super(`Local database operation timed out after ${timeoutMs}ms (${op})`);
+		this.op = op;
+		this.timeoutMs = timeoutMs;
+	}
+};
+/** Default deadline for one local-store operation. Generous: a cold 4k-row
+*  select on a throttled tab is seconds, not tens of seconds. */
+const DEFAULT_LOCAL_OP_TIMEOUT_MS = 3e4;
+
 //#endregion
 //#region src/events/index.ts
 /**
@@ -639,6 +707,10 @@ var LocalDatabaseService = class extends AbstractDatabaseService {
 		const events = createDatabaseEventSystem();
 		super(createBareSurrealClient(), logger, events);
 		this.config = config;
+		this.queryTimeoutMs = Math.max(0, config.localOpTimeoutMs ?? DEFAULT_LOCAL_OP_TIMEOUT_MS);
+	}
+	timeoutError(query) {
+		return new LocalOpTimeoutError(query.slice(0, 80), this.queryTimeoutMs);
 	}
 	getConfig() {
 		return this.config;
@@ -2052,7 +2124,7 @@ var WorkerSqliteTransport = class extends BaseTransport {
 				err: this.makeError(msg),
 				Category: "sp00ky-client::SqliteCacheEngine::worker"
 			}, "Worker error");
-			this.failAll(msg);
+			this.close(msg);
 		};
 		this.worker.onerror = (e) => crash(e.message || "onerror");
 		this.worker.onmessageerror = () => crash("messageerror");
@@ -2205,6 +2277,8 @@ var SqliteCacheEngine = class {
 	workerSelectConfigured;
 	events = createDatabaseEventSystem();
 	bucketId = "anon";
+	/** Deadline for one worker round trip; see `localOpTimeoutMs`. */
+	localOpTimeoutMs;
 	/** Durability of the local store, set on every open. A plain Set of callbacks
 	*  rather than a `DatabaseEventSystem` event: this changes at most once per
 	*  open, and the typed event map is about query traffic. */
@@ -2226,6 +2300,7 @@ var SqliteCacheEngine = class {
 	constructor(config, logger, opts = {}) {
 		this.config = config;
 		this.logger = logger;
+		this.localOpTimeoutMs = Math.max(0, config.localOpTimeoutMs ?? DEFAULT_LOCAL_OP_TIMEOUT_MS);
 		this.useOpfs = opts.useOpfs ?? true;
 		this.workerSelect = opts.workerSelect ?? config.workerSelect ?? true;
 		this.workerSelectConfigured = this.workerSelect;
@@ -2366,7 +2441,8 @@ var SqliteCacheEngine = class {
 			this.inFlightCalls.delete(tracked);
 			settle();
 		};
-		return this.transport.call(type, payload).then((v) => {
+		const timeoutMs = this.localOpTimeoutMs;
+		return withTimeout(this.transport.call(type, payload), timeoutMs, () => new LocalOpTimeoutError(type, timeoutMs)).then((v) => {
 			finish();
 			s.inFlight--;
 			const wt = v?.wt;
@@ -2378,6 +2454,14 @@ var SqliteCacheEngine = class {
 		}, (e) => {
 			finish();
 			s.inFlight--;
+			if (e instanceof LocalOpTimeoutError) {
+				s.timeouts = (s.timeouts ?? 0) + 1;
+				this.logger.error({
+					type,
+					timeoutMs,
+					Category: "sp00ky-client::SqliteCacheEngine::rawCall"
+				}, "Local store op did not answer within its deadline; rejecting the caller");
+			}
 			throw e;
 		});
 	}
@@ -3541,6 +3625,11 @@ var DataModule = class DataModule {
 			await this.processStreamUpdate(update);
 			return;
 		}
+		this.queueStreamUpdate(update);
+	}
+	/** Coalesce `update` onto the query's trailing timer (see onStreamUpdate). */
+	queueStreamUpdate(update) {
+		const { queryHash } = update;
 		if (this.debounceTimers.has(queryHash)) clearTimeout(this.debounceTimers.get(queryHash));
 		this.pendingStreamUpdates.set(queryHash, update);
 		const timer = setTimeout(async () => {
@@ -3551,6 +3640,30 @@ var DataModule = class DataModule {
 		this.debounceTimers.set(queryHash, timer);
 	}
 	/**
+	* Re-materialize + notify a query whose MEMBERSHIP changed without any row
+	* needing to be fetched, i.e. without the SSP stream update that normally
+	* carries the notify. That is every row this client wrote itself: the local
+	* CREATE memoized it at `_00_rv = 1`, the server publishes it at 1, so the
+	* sync engine rightly fetches nothing - and then nobody told the subscribers
+	* that `remoteArray` now holds the id. The row appeared on reload only.
+	*
+	* Routed through the same per-query debounce as a real stream update, so it
+	* cannot race one: a pending real update already materializes against the
+	* current `remoteArray` and wins. The synthetic update re-uses the circuit's
+	* last `localArray` and skips the persist/metrics that describe an ingest.
+	*/
+	scheduleRematerialize(queryHash) {
+		if (this.debounceTimers.has(queryHash)) return;
+		const queryState = this.activeQueries.get(queryHash);
+		if (!queryState) return;
+		this.queueStreamUpdate({
+			queryHash,
+			localArray: queryState.config.localArray ?? [],
+			op: "UPDATE",
+			synthetic: true
+		});
+	}
+	/**
 	* Process a query's pending (debounced) stream update NOW instead of on the
 	* trailing edge. Called by the sync engine before it flips a query back to
 	* `idle`, so the status change never races ahead of the rows it fetched.
@@ -3655,10 +3768,14 @@ var DataModule = class DataModule {
 	pendingIdsAt = 0;
 	pendingIdsInflight = null;
 	static PENDING_IDS_TTL_MS = 250;
+	pendingIdsGen = 0;
+	static PENDING_IDS_MAX_REREADS = 3;
 	/** Drop the cached outbox ids. Cheap; call it on anything that could change
 	*  `_00_pending_mutations`. */
 	invalidatePendingIds() {
 		this.pendingIds = null;
+		this.pendingIdsGen++;
+		this.pendingIdsInflight = null;
 	}
 	/**
 	* Grace period for a settled write. Long enough to cover an SSP round trip
@@ -3744,7 +3861,7 @@ var DataModule = class DataModule {
 		try {
 			const newRecords = await this.materializeRecords(queryState, localArray);
 			if (epoch !== this.local.epoch) return;
-			queryState.config.localArray = localArray;
+			if (!update.synthetic) queryState.config.localArray = localArray;
 			const prevJson = JSON.stringify(queryState.records);
 			const newJson = JSON.stringify(newRecords);
 			queryState.records = newRecords;
@@ -3753,7 +3870,7 @@ var DataModule = class DataModule {
 				queryState.updateCount++;
 				queryState.lastUpdatedAt = Date.now();
 			}
-			await this.local.query(surql.seal(surql.updateSet("id", [
+			if (!update.synthetic) await this.local.query(surql.seal(surql.updateSet("id", [
 				"localArray",
 				"rowCount",
 				"updateCount",
@@ -4089,18 +4206,27 @@ var DataModule = class DataModule {
 			writes: new Set(cached.writes),
 			deletes: new Set(cached.deletes)
 		};
-		if (!this.pendingIdsInflight) this.pendingIdsInflight = this.readPendingRecordIds().finally(() => {
-			this.pendingIdsInflight = null;
-		});
-		const fresh = await this.pendingIdsInflight;
+		let fresh = null;
+		for (let attempt = 0; attempt < DataModule.PENDING_IDS_MAX_REREADS; attempt++) {
+			const gen = this.pendingIdsGen;
+			if (!this.pendingIdsInflight) {
+				const read = this.readPendingRecordIds(gen).finally(() => {
+					if (this.pendingIdsInflight === read) this.pendingIdsInflight = null;
+				});
+				this.pendingIdsInflight = read;
+			}
+			fresh = await this.pendingIdsInflight;
+			if (gen === this.pendingIdsGen) break;
+		}
 		return {
 			writes: new Set(fresh.writes),
 			deletes: new Set(fresh.deletes)
 		};
 	}
 	/** The uncached read. Also the reload path after an invalidation, so the ids
-	*  still survive a reload exactly as before. */
-	async readPendingRecordIds() {
+	*  still survive a reload exactly as before. `gen` is the generation the read
+	*  was issued under; the result is cached only if it is still current. */
+	async readPendingRecordIds(gen) {
 		const writes = /* @__PURE__ */ new Set();
 		const deletes = /* @__PURE__ */ new Set();
 		try {
@@ -4121,11 +4247,13 @@ var DataModule = class DataModule {
 				deletes
 			};
 		}
-		this.pendingIds = {
-			writes,
-			deletes
-		};
-		this.pendingIdsAt = Date.now();
+		if (gen === this.pendingIdsGen) {
+			this.pendingIds = {
+				writes,
+				deletes
+			};
+			this.pendingIdsAt = Date.now();
+		}
 		return {
 			writes,
 			deletes
@@ -4430,13 +4558,22 @@ var DataModule = class DataModule {
 			data: params,
 			...prefixedParams
 		}));
+		this.invalidatePendingIds();
 		const parsedRecord = parseParams(tableSchema.columns, target);
-		await this.cache.save({
-			table: tableName,
-			op: "CREATE",
-			record: parsedRecord,
-			version: 1
-		}, true);
+		try {
+			await this.cache.save({
+				table: tableName,
+				op: "CREATE",
+				record: parsedRecord,
+				version: 1
+			}, true);
+		} catch (err) {
+			this.logger.error({
+				err,
+				id,
+				Category: "sp00ky-client::DataModule::create"
+			}, "SSP create-ingest failed; the row is written and queued, but views only see it once membership arrives");
+		}
 		const mutationEvent = {
 			type: "create",
 			mutation_id: mutationId,
@@ -4445,7 +4582,6 @@ var DataModule = class DataModule {
 			record: target,
 			tableName
 		};
-		this.invalidatePendingIds();
 		for (const callback of this.mutationCallbacks) callback([mutationEvent]);
 		this.logger.debug({
 			id,
@@ -4482,13 +4618,22 @@ var DataModule = class DataModule {
 		for (const key of Object.keys(data)) if (key in target) updatedFields[key] = target[key];
 		if ("_00_rv" in target) updatedFields._00_rv = target._00_rv;
 		this.replaceRecordInQueries(updatedFields);
+		this.invalidatePendingIds();
 		const parsedRecord = parseParams(tableSchema.columns, target);
-		await this.cache.save({
-			table,
-			op: "UPDATE",
-			record: parsedRecord,
-			version: target._00_rv
-		}, true);
+		try {
+			await this.cache.save({
+				table,
+				op: "UPDATE",
+				record: parsedRecord,
+				version: target._00_rv
+			}, true);
+		} catch (err) {
+			this.logger.error({
+				err,
+				id,
+				Category: "sp00ky-client::DataModule::update"
+			}, "SSP update-ingest failed; the row is written and queued");
+		}
 		const pushEventOptions = parseUpdateOptions(id, data, options);
 		const mutationEvent = {
 			type: "update",
@@ -4499,7 +4644,6 @@ var DataModule = class DataModule {
 			beforeRecord: beforeRecord || void 0,
 			options: pushEventOptions
 		};
-		this.invalidatePendingIds();
 		for (const callback of this.mutationCallbacks) callback([mutationEvent]);
 		this.logger.debug({
 			id,
@@ -4522,6 +4666,7 @@ var DataModule = class DataModule {
 			id: rid,
 			mid: mutationId
 		}));
+		this.invalidatePendingIds();
 		try {
 			await this.cache.delete(table, id, true, beforeRecord);
 		} catch (err) {
@@ -4537,7 +4682,6 @@ var DataModule = class DataModule {
 			mutation_id: mutationId,
 			record_id: rid
 		};
-		this.invalidatePendingIds();
 		for (const callback of this.mutationCallbacks) callback([mutationEvent]);
 		this.logger.debug({
 			id,
@@ -4735,7 +4879,7 @@ var DataModule = class DataModule {
 			...configRecord,
 			id: recordId,
 			plan,
-			params: parseParams(tableSchema.columns, configRecord.params),
+			params: parseQueryParams(tableSchema.columns, params ?? configRecord.params),
 			membershipKey
 		};
 		if (membershipKey && !config.remoteArray?.length) {
@@ -6481,6 +6625,7 @@ var Sp00kySync = class Sp00kySync {
 				Category: "sp00ky-client::Sp00kySync::refetchListRefForQuery"
 			}, "syncQuery failed during poll");
 		}
+		if (changed) this.dataModule.scheduleRematerialize(queryHash);
 		await this.syncSubqueryChildren(queryHash).catch((err) => {
 			this.logger.info({
 				err: err?.message ?? err,
@@ -6677,6 +6822,7 @@ var Sp00kySync = class Sp00kySync {
 		}
 		await this.runSyncForQuery(hash, diff);
 		if (diff.removed.length > 0 && diff.added.length === 0 && diff.updated.length === 0) await this.dataModule.notifyQuerySynced(hash);
+		else if (diff.added.length === 0 && diff.updated.length === 0) this.dataModule.scheduleRematerialize(hash);
 	}
 	/**
 	* Handle a LIVE change to a SUBQUERY child edge (a `_00_list_ref` row with
@@ -7414,8 +7560,8 @@ function selfAllowlistedVariant(flag, userId) {
 
 //#endregion
 //#region src/modules/devtools/index.ts
-const CORE_VERSION = "0.0.1-canary.207";
-const WASM_VERSION = "0.0.1-canary.207";
+const CORE_VERSION = "0.0.1-canary.209";
+const WASM_VERSION = "0.0.1-canary.209";
 const SURREAL_VERSION = "3.0.3";
 var DevToolsService = class DevToolsService {
 	eventsHistory = [];
@@ -7426,6 +7572,10 @@ var DevToolsService = class DevToolsService {
 	static NOTIFY_MIN_INTERVAL_MS = 250;
 	notifyTimer = null;
 	lastNotifyAt = 0;
+	/** How many ids a pushed state carries per view; the rest is on demand. */
+	static STATE_IDS_CAP = 200;
+	/** devtools numeric hash -> the query's `_00_query` id, for on-demand rows. */
+	hashToQuery = /* @__PURE__ */ new Map();
 	/** Shared-tabs snapshot for the panel, wired by Sp00kyClient whenever the
 	*  feature was REQUESTED (so an inactive/degraded tab still reports why). */
 	tabsInfoProvider = null;
@@ -7466,6 +7616,7 @@ var DevToolsService = class DevToolsService {
 			const type = e.data?.type;
 			if (type === "SP00KY_DEVTOOLS_CONNECT") {
 				this.enabled = true;
+				this.refreshLocalTables();
 				this.notifyDevTools();
 			} else if (type === "SP00KY_DEVTOOLS_DISCONNECT") this.enabled = false;
 		});
@@ -7501,6 +7652,9 @@ var DevToolsService = class DevToolsService {
 		this.dataManager.getActiveQueries().forEach((q) => {
 			const queryHash = this.hashString(encodeRecordId(q.config.id));
 			const createdAt = q.config.lastActiveAt instanceof Date ? q.config.lastActiveAt.getTime() : new Date(q.config.lastActiveAt || Date.now()).getTime();
+			this.hashToQuery.set(queryHash, q.config.id);
+			const localArray = q.config.localArray ?? [];
+			const remoteArray = q.config.remoteArray ?? [];
 			result.set(queryHash, {
 				queryHash,
 				status: "active",
@@ -7513,9 +7667,11 @@ var DevToolsService = class DevToolsService {
 				query: q.config.surql,
 				variables: q.config.params || {},
 				dataSize: q.records?.length || 0,
-				data: q.records,
-				localArray: q.config.localArray,
-				remoteArray: q.config.remoteArray,
+				localCount: localArray.length,
+				remoteCount: remoteArray.length,
+				localIds: localArray.slice(0, DevToolsService.STATE_IDS_CAP).map(([id]) => id),
+				remoteIds: remoteArray.slice(0, DevToolsService.STATE_IDS_CAP).map(([id]) => id),
+				idsTruncated: localArray.length > DevToolsService.STATE_IDS_CAP || remoteArray.length > DevToolsService.STATE_IDS_CAP,
 				membershipKnown: q.config.membershipKnown === true,
 				remoteSeen: q.config.remoteSeen === true,
 				emptyReads: q.config.emptyReads ?? 0,
@@ -7545,23 +7701,32 @@ var DevToolsService = class DevToolsService {
 		const queryHash = this.hashString(payload.queryId.toString());
 		this.addEvent("QUERY_UPDATED", {
 			queryHash,
-			data: payload.records
+			recordCount: Array.isArray(payload.records) ? payload.records.length : 0
 		});
 		this.notifyDevTools();
 	}
 	onStreamUpdate(update) {
+		if (update.synthetic) return;
 		this.logger.debug({
-			update,
+			queryHash: update.queryHash,
 			Category: "sp00ky-client::DevToolsService::onStreamUpdate"
 		}, "StreamUpdate");
-		this.addEvent("STREAM_UPDATE", { updates: [update] });
+		this.addEvent("STREAM_UPDATE", {
+			queryHash: update.queryHash,
+			op: update.op,
+			localCount: update.localArray?.length ?? 0,
+			materializationTimeMs: update.materializationTimeMs,
+			storeApplyMs: update.storeApplyMs,
+			circuitStepMs: update.circuitStepMs,
+			transformMs: update.transformMs
+		});
 		this.notifyDevTools();
 	}
 	onMutation(payload) {
 		payload.forEach((p) => {
 			this.addEvent("MUTATION_REQUEST_EXECUTION", { mutation: {
-				type: "create",
-				data: "data" in p ? p.data : void 0,
+				type: p.type ?? "create",
+				fields: "data" in p && p.data && typeof p.data === "object" ? Object.keys(p.data) : [],
 				selector: encodeRecordId(p.record_id)
 			} });
 		});
@@ -7606,7 +7771,7 @@ var DevToolsService = class DevToolsService {
 	*/
 	refreshLocalTables() {
 		if (this.localTablesFetching) return;
-		if (Date.now() - this.localTablesAt < 3e3) return;
+		if (Date.now() - this.localTablesAt < 3e4) return;
 		this.localTablesFetching = true;
 		this.databaseService.query("INFO FOR DB").then((res) => {
 			const info = this.unwrapInfo(res);
@@ -7621,8 +7786,8 @@ var DevToolsService = class DevToolsService {
 			this.localTablesFetching = false;
 		});
 	}
-	getState() {
-		this.refreshLocalTables();
+	getState(opts = {}) {
+		if (opts.refreshTables) this.refreshLocalTables();
 		return this.serializeForDevTools({
 			eventsHistory: [...this.eventsHistory],
 			activeQueries: Object.fromEntries(this.getActiveQueries()),
@@ -7736,14 +7901,11 @@ var DevToolsService = class DevToolsService {
 		if (typeof window === "undefined") return;
 		if (this.notifyTimer !== null) return;
 		const waited = Date.now() - this.lastNotifyAt;
-		if (waited >= DevToolsService.NOTIFY_MIN_INTERVAL_MS) {
-			this.flushNotify();
-			return;
-		}
+		const delay = Math.max(0, DevToolsService.NOTIFY_MIN_INTERVAL_MS - waited);
 		this.notifyTimer = setTimeout(() => {
 			this.notifyTimer = null;
 			if (this.enabled) this.flushNotify();
-		}, DevToolsService.NOTIFY_MIN_INTERVAL_MS - waited);
+		}, delay);
 	}
 	flushNotify() {
 		this.lastNotifyAt = Date.now();
@@ -7788,7 +7950,18 @@ var DevToolsService = class DevToolsService {
 		if (typeof window !== "undefined") {
 			window.__00__ = {
 				version: this.version,
-				getState: () => this.getState(),
+				getState: () => this.getState({ refreshTables: true }),
+				getQueryRows: (queryHash) => {
+					const id = this.hashToQuery.get(Number(queryHash));
+					const q = id !== void 0 ? this.dataManager?.getQueryById(id) : void 0;
+					if (!q) return null;
+					return this.serializeForDevTools({
+						queryHash: Number(queryHash),
+						data: q.records,
+						localArray: q.config.localArray,
+						remoteArray: q.config.remoteArray
+					});
+				},
 				getFlags: () => this.flagsAdmin.getFlags(),
 				setFlagEnabled: (key, enabled) => this.flagsAdmin.setFlagEnabled(key, enabled),
 				setFlagUserVariant: (key, variant, remove, userId) => this.flagsAdmin.setFlagUserVariant(key, variant, remove, userId),
@@ -12399,7 +12572,7 @@ var Sp00kyClient = class {
 		return new TabsCoordinator({
 			tabId,
 			fingerprint: computeTabsFingerprint({
-				coreVersion: "0.0.1-canary.207",
+				coreVersion: "0.0.1-canary.209",
 				schemaHash: hash53(this.config.schemaSurql),
 				endpoint: this.config.database.endpoint ?? "",
 				namespace: this.config.database.namespace,
@@ -12836,7 +13009,7 @@ var Sp00kyClient = class {
 	async initQuery(table, q, ttl) {
 		const tableSchema = this.config.schema.tables.find((t) => t.name === table);
 		if (!tableSchema) throw new Error(`Table ${table} not found`);
-		const params = parseParams(tableSchema.columns, q.selectQuery.vars ?? {});
+		const params = parseQueryParams(tableSchema.columns, q.selectQuery.vars ?? {});
 		const hash = await this.dataModule.query(table, q.selectQuery.query, params, ttl, q.selectQuery.plan);
 		if (!this.pendingQueryInits.has(hash)) {
 			const chain = this.finishQueryInit(hash, q, params).finally(() => {
@@ -12908,7 +13081,7 @@ var Sp00kyClient = class {
 		const tableName = q.tableName;
 		const tableSchema = this.config.schema.tables.find((t) => t.name === tableName);
 		if (!tableSchema) throw new Error(`Table ${tableName} not found`);
-		const params = parseParams(tableSchema.columns, q.selectQuery.vars ?? {});
+		const params = parseQueryParams(tableSchema.columns, q.selectQuery.vars ?? {});
 		const hashKey = String(q.hash);
 		const marker = await this.dataModule.getPreloadMarker(hashKey);
 		if (!marker) {
@@ -13085,4 +13258,4 @@ var Sp00kyClient = class {
 };
 
 //#endregion
-export { AppReleaseHandle, AppReleaseModule, AuthEventTypes, AuthService, BLURHASH_IMAGE_EXTENSIONS, BucketHandle, CURSOR_COLORS, CrdtField, CrdtManager, FeatureFlagHandle, FeatureFlagModule, MATERIALIZATION_SAMPLE_WINDOW, Sp00kyClient, blurhashSidecarPath, bucketContentToBlob, createAuthEventSystem, cursorColorFromName, decode as decodeBlurhash, encode as encodeBlurhash, encodeImageToBlurhash, fileToUint8Array, isBlurhashValid, isImagePath, semverGt, textToHtml };
+export { AppReleaseHandle, AppReleaseModule, AuthEventTypes, AuthService, BLURHASH_IMAGE_EXTENSIONS, BucketHandle, CURSOR_COLORS, CrdtField, CrdtManager, DEFAULT_LOCAL_OP_TIMEOUT_MS, FeatureFlagHandle, FeatureFlagModule, LocalOpTimeoutError, MATERIALIZATION_SAMPLE_WINDOW, Sp00kyClient, blurhashSidecarPath, bucketContentToBlob, createAuthEventSystem, cursorColorFromName, decode as decodeBlurhash, encode as encodeBlurhash, encodeImageToBlurhash, fileToUint8Array, isBlurhashValid, isImagePath, semverGt, textToHtml };

package/dist/sqlite-worker.js

@@ -1,6 +1,26 @@
 import { a as renderOrderSql, i as projectedDataSql, l as resolveRelations, n as openDb, o as renderWhereSql, r as project, s as reviveRow, u as stableKey } from "./sqlite-open.js";
 import sqlite3InitModule from "@sqlite.org/sqlite-wasm";
 
+//#region src/services/database/sqlite-lock-verify.ts
+const LOCK_VERIFY_TIMEOUT_MS = 2e3;
+async function verifyLockStillHeld$1(locks, name, fence, timeoutMs = LOCK_VERIFY_TIMEOUT_MS, warn = () => {}) {
+	if (!locks || !name || typeof locks.query !== "function") return;
+	let timer;
+	try {
+		const state = await Promise.race([locks.query(), new Promise((resolve) => {
+			timer = setTimeout(() => resolve(null), timeoutMs);
+		})]);
+		if (state === null) {
+			warn(`lock verification did not answer within ${timeoutMs}ms; trusting the steal callback`);
+			return;
+		}
+		if (!(state.held ?? []).some((l) => l.name === name)) await fence("lock missing after suspected freeze");
+	} catch {} finally {
+		if (timer) clearTimeout(timer);
+	}
+}
+
+//#endregion
 //#region src/services/database/sqlite-select.ts
 function ensureTable(db, table) {
 	if (db.knownTables.has(table)) return;
@@ -230,13 +250,8 @@ function noteTick() {
 	});
 }
 setInterval(noteTick, 1e3);
-async function verifyLockStillHeld() {
-	const locks = workerLocks();
-	const name = currentLock?.name;
-	if (!locks || !name || typeof locks.query !== "function") return;
-	try {
-		if (!((await locks.query()).held ?? []).some((l) => l.name === name)) await fence("lock missing after suspected freeze");
-	} catch {}
+function verifyLockStillHeld() {
+	return verifyLockStillHeld$1(workerLocks(), currentLock?.name, (reason) => fence(reason), void 0, (msg) => console.warn(`[sqlite-worker] ${msg}`));
 }
 async function open(dbName, useOpfs, systemTables = [], workerLockName, openOptions) {
 	if (workerLockName) {

package/dist/types.d.ts

@@ -504,6 +504,16 @@ interface Sp00kyConfig<S extends SchemaStructure> {
      * failure the queue retries. `0` disables. Defaults to `60_000`.
      */
     queryTimeoutMs?: number;
+    /**
+     * Deadline (ms) for every LOCAL store operation (a SQLite worker round trip,
+     * or a query on the in-process surrealdb engine). Local ops are serialized
+     * too, and one that never answered - a worker starved behind a long select,
+     * a lock verification with no clock - left every `db.create`/`db.update`
+     * promise pending for the tab's lifetime. On expiry the call rejects with
+     * `LocalOpTimeoutError` (the op itself keeps running in the engine and is
+     * not retried). `0` disables. Defaults to `30_000`.
+     */
+    localOpTimeoutMs?: number;
   };
   /** The schema definition. */
   schema: S;