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

package/dist/index.d.ts

@@ -12,12 +12,18 @@ declare abstract class AbstractDatabaseService {
   protected logger: Logger$1;
   protected events: DatabaseEventSystem;
   /**
-   * 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.
    */
   protected queryTimeoutMs: number;
+  /** 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. */
+  protected timeoutError(_query: string): Error;
   protected abstract eventType: typeof DatabaseEventTypes.LocalQuery | typeof DatabaseEventTypes.RemoteQuery;
   constructor(client: Surreal$1, logger: Logger$1, events: DatabaseEventSystem);
   abstract connect(): Promise<void>;
@@ -256,6 +262,14 @@ interface StreamUpdate {
   queryHash: string;
   localArray: RecordVersionArray;
   op?: 'CREATE' | 'UPDATE' | 'DELETE';
+  /**
+   * Client-internal: not from the circuit. A membership-only change that
+   * needed no fetch is re-materialized through this same path so it cannot
+   * race a real update (DataModule.scheduleRematerialize). Carries the last
+   * known `localArray`; consumers that describe an INGEST (persist, metrics,
+   * devtools events) skip it.
+   */
+  synthetic?: boolean;
   /**
    * End-to-end ingest latency for the WASM call that produced this update,
    * in milliseconds. Populated by StreamProcessorService.ingest. Undefined
@@ -734,6 +748,22 @@ declare class DataModule<S extends SchemaStructure> {
    * Handle stream updates from DBSP (via CacheModule)
    */
   onStreamUpdate(update: StreamUpdate): Promise<void>;
+  /** Coalesce `update` onto the query's trailing timer (see onStreamUpdate). */
+  private queueStreamUpdate;
+  /**
+   * 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: string): void;
   /**
    * 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
@@ -794,6 +824,8 @@ declare class DataModule<S extends SchemaStructure> {
   private pendingIdsAt;
   private pendingIdsInflight;
   private static readonly PENDING_IDS_TTL_MS;
+  private pendingIdsGen;
+  private static readonly PENDING_IDS_MAX_REREADS;
   /** Drop the cached outbox ids. Cheap; call it on anything that could change
    *  `_00_pending_mutations`. */
   private invalidatePendingIds;
@@ -957,7 +989,8 @@ declare class DataModule<S extends SchemaStructure> {
     deletes: Set<string>;
   }>;
   /** The uncached read. Also the reload path after an invalidation, so the ids
-   *  still survive a reload exactly as before. */
+   *  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. */
   private readPendingRecordIds;
   /** True while ≥1 live subscriber is watching this query (refcount guard). */
   hasSubscribers(hash: string): boolean;
@@ -2640,6 +2673,36 @@ declare class Sp00kyClient<S extends SchemaStructure> {
 /** True when `a` is a valid version strictly greater than valid version `b`. */
 declare function semverGt(a: unknown, b: unknown): boolean;
 //#endregion
+//#region src/services/database/errors.d.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.
+ */
+declare class LocalOpTimeoutError extends Error {
+  readonly name = "LocalOpTimeoutError";
+  readonly retryable = false;
+  readonly op: string;
+  readonly timeoutMs: number;
+  constructor(op: string, timeoutMs: number);
+}
+/** Default deadline for one local-store operation. Generous: a cold 4k-row
+ *  select on a throttled tab is seconds, not tens of seconds. */
+declare const DEFAULT_LOCAL_OP_TIMEOUT_MS = 30000;
+//#endregion
 //#region src/utils/index.d.ts
 declare function fileToUint8Array(file: File | Blob): Promise<Uint8Array>;
 /**
@@ -2652,4 +2715,4 @@ declare function textToHtml(text: string): string;
  */
 
 //#endregion
-export { AppReleaseHandle, AppReleaseModule, type AppReleaseOptions, type AppReleaseSnapshot, AuthEventSystem, AuthEventTypeMap, AuthEventTypes, AuthService, BLURHASH_IMAGE_EXTENSIONS, type BlobCacheStats, type BlobEntry, type BlobKey, type BlobReadOptions, type BlobUrlLease, type BlurhashEncodeOptions, type BlurhashSetting, BucketHandle, BucketPutOptions, BucketPutResult, CURSOR_COLORS, ConnectionState, CrdtField, CrdtManager, DebounceOptions, EventSubscriptionOptions, FeatureFlagHandle, FeatureFlagModule, type FeatureFlagOptions, type FeatureFlagOverride, type FeatureFlagSnapshot, Level, MATERIALIZATION_SAMPLE_WINDOW, MutationCallback, MutationEvent, MutationEventType, PersistenceClient, PhaseStat, PinoTransmit, PreloadOptions, PreloadRefresh, QueryConfig, QueryConfigRecord, QueryHash, QueryState, QueryStatus, QueryStatusCallback, QueryTimeToLive, QueryTimings, QueryUpdateCallback, ReconnectConfig, RecordVersionArray, RecordVersionDiff, RegistrationTimings, RunOptions, Sp00kyClient, Sp00kyConfig, Sp00kyQueryResult, Sp00kyQueryResultPromise, StorageHealth, StorageHealthStatus, StoreType, SyncHealth, SyncHealthConfig, SyncHealthStatus, TimingPhase, UpdateOptions, blurhashSidecarPath, bucketContentToBlob, createAuthEventSystem, cursorColorFromName, decode as decodeBlurhash, encode as encodeBlurhash, encodeImageToBlurhash, fileToUint8Array, isBlurhashValid, isImagePath, semverGt, textToHtml };
+export { AppReleaseHandle, AppReleaseModule, type AppReleaseOptions, type AppReleaseSnapshot, AuthEventSystem, AuthEventTypeMap, AuthEventTypes, AuthService, BLURHASH_IMAGE_EXTENSIONS, type BlobCacheStats, type BlobEntry, type BlobKey, type BlobReadOptions, type BlobUrlLease, type BlurhashEncodeOptions, type BlurhashSetting, BucketHandle, BucketPutOptions, BucketPutResult, CURSOR_COLORS, ConnectionState, CrdtField, CrdtManager, DEFAULT_LOCAL_OP_TIMEOUT_MS, DebounceOptions, EventSubscriptionOptions, FeatureFlagHandle, FeatureFlagModule, type FeatureFlagOptions, type FeatureFlagOverride, type FeatureFlagSnapshot, Level, LocalOpTimeoutError, MATERIALIZATION_SAMPLE_WINDOW, MutationCallback, MutationEvent, MutationEventType, PersistenceClient, PhaseStat, PinoTransmit, PreloadOptions, PreloadRefresh, QueryConfig, QueryConfigRecord, QueryHash, QueryState, QueryStatus, QueryStatusCallback, QueryTimeToLive, QueryTimings, QueryUpdateCallback, ReconnectConfig, RecordVersionArray, RecordVersionDiff, RegistrationTimings, RunOptions, Sp00kyClient, Sp00kyConfig, Sp00kyQueryResult, Sp00kyQueryResultPromise, StorageHealth, StorageHealthStatus, StoreType, SyncHealth, SyncHealthConfig, SyncHealthStatus, TimingPhase, UpdateOptions, blurhashSidecarPath, bucketContentToBlob, createAuthEventSystem, cursorColorFromName, decode as decodeBlurhash, encode as encodeBlurhash, encodeImageToBlurhash, fileToUint8Array, isBlurhashValid, isImagePath, semverGt, textToHtml };

package/dist/index.js

@@ -229,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({
@@ -264,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);
@@ -282,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" });
@@ -321,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,
@@ -367,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
 /**
@@ -663,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;
@@ -2076,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");
@@ -2229,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. */
@@ -2250,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;
@@ -2390,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;
@@ -2402,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;
 		});
 	}
@@ -3565,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 () => {
@@ -3575,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.
@@ -3679,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
@@ -3768,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;
@@ -3777,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",
@@ -4113,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 {
@@ -4145,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
@@ -4454,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,
@@ -4469,7 +4582,6 @@ var DataModule = class DataModule {
 			record: target,
 			tableName
 		};
-		this.invalidatePendingIds();
 		for (const callback of this.mutationCallbacks) callback([mutationEvent]);
 		this.logger.debug({
 			id,
@@ -4506,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",
@@ -4523,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,
@@ -4546,6 +4666,7 @@ var DataModule = class DataModule {
 			id: rid,
 			mid: mutationId
 		}));
+		this.invalidatePendingIds();
 		try {
 			await this.cache.delete(table, id, true, beforeRecord);
 		} catch (err) {
@@ -4561,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,
@@ -6505,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,
@@ -6701,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
@@ -7438,8 +7560,8 @@ function selfAllowlistedVariant(flag, userId) {
 
 //#endregion
 //#region src/modules/devtools/index.ts
-const CORE_VERSION = "0.0.1-canary.208";
-const WASM_VERSION = "0.0.1-canary.208";
+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 = [];
@@ -7450,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;
@@ -7490,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;
 		});
@@ -7525,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",
@@ -7537,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,
@@ -7569,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)
 			} });
 		});
@@ -7630,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);
@@ -7645,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()),
@@ -7760,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();
@@ -7812,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),
@@ -12423,7 +12572,7 @@ var Sp00kyClient = class {
 		return new TabsCoordinator({
 			tabId,
 			fingerprint: computeTabsFingerprint({
-				coreVersion: "0.0.1-canary.208",
+				coreVersion: "0.0.1-canary.209",
 				schemaHash: hash53(this.config.schemaSurql),
 				endpoint: this.config.database.endpoint ?? "",
 				namespace: this.config.database.namespace,
@@ -13109,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 };