@spooky-sync/core 0.0.1-canary.290 → 0.0.1-canary.292

package/dist/index.js

@@ -1290,350 +1290,705 @@ var WebPushModule = class {
 };
 
 //#endregion
-//#region src/events/index.ts
+//#region src/mutation/rows.ts
+const PENDING_TABLE = "_00_pending_mutations";
+const FAILED_TABLE = "_00_failed_mutations";
+/** Debounced patches still inside their delay (see `DebounceOptions.flushOnHide`). */
+const PENDING_WRITES_TABLE = "_00_pending_writes";
+const PENDING_ROW_VERSION = 2;
 /**
-* A type-safe event system that handles subscription, emission (including debouncing), and buffering of events.
-* @template E The EventTypeMap defining all supported events.
+* Parse a record id READ BACK FROM THE STORE, stripping SurrealDB's `⟨⟩`
+* escaping (outbox ids contain `_`, so they come back escaped).
 */
-var EventSystem = class {
-	subscriberId = 0;
-	isProcessing = false;
-	buffer;
-	subscribers;
-	subscribersTypeMap;
-	lastEvents;
-	debouncedEvents;
-	constructor(_eventTypes) {
-		this._eventTypes = _eventTypes;
-		this.buffer = [];
-		this.subscribers = this._eventTypes.reduce((acc, key) => {
-			return Object.assign(acc, { [key]: /* @__PURE__ */ new Map() });
-		}, {});
-		this.lastEvents = {};
-		this.subscribersTypeMap = /* @__PURE__ */ new Map();
-		this.debouncedEvents = /* @__PURE__ */ new Map();
-	}
-	get eventTypes() {
-		return this._eventTypes;
-	}
-	/**
-	* Subscribes a handler to a specific event type.
-	* @param type The event type to subscribe to.
-	* @param handler The function to call when the event occurs.
-	* @param options Subscription options (once, immediately).
-	* @returns A subscription ID that can be used to unsubscribe.
-	*/
-	subscribe(type, handler, options) {
-		const id = this.subscriberId++;
-		this.subscribers[type].set(id, {
-			id,
-			handler,
-			once: options?.once ?? false
-		});
-		this.subscribersTypeMap.set(id, type);
-		if (options?.immediately) {
-			const lastEvent = this.lastEvents[type];
-			if (lastEvent) handler(lastEvent);
-		}
-		return id;
-	}
-	/**
-	* Subscribes a handler to multiple event types.
-	* @param types An array of event types to subscribe to.
-	* @param handler The function to call when any of the events occur.
-	* @param options Subscription options.
-	* @returns An array of subscription IDs.
-	*/
-	subscribeMany(types, handler, options) {
-		return types.map((type) => this.subscribe(type, handler, options));
-	}
-	/**
-	* Unsubscribes a specific subscription by ID.
-	* @param id The subscription ID returned by subscribe().
-	* @returns True if the subscription was found and removed, false otherwise.
-	*/
-	unsubscribe(id) {
-		const type = this.subscribersTypeMap.get(id);
-		if (type) {
-			this.subscribers[type].delete(id);
-			this.subscribersTypeMap.delete(id);
-			return true;
-		}
-		return false;
-	}
-	/**
-	* Emits an event with the given type and payload.
-	* @param type The type of event to emit.
-	* @param payload The data associated with the event.
-	*/
-	emit(type, payload) {
-		const event = {
-			type,
-			payload
-		};
-		this.addEvent(event);
-	}
-	/**
-	* Adds a fully constructed event object to the system.
-	* Similar to emit, but takes the full event object directly.
-	* Supports debouncing if options are provided.
-	* @param event The event object.
-	* @param options Options for the event push (e.g., debouncing).
-	*/
-	addEvent(event, options) {
-		if (options?.debounced) {
-			this.handleDebouncedEvent(event, options.debounced.key, options.debounced.delay);
-			return;
-		}
-		this.buffer.push(event);
-		this.scheduleProcessing();
-	}
-	handleDebouncedEvent(event, key, delay) {
-		if (this.debouncedEvents.has(key)) clearTimeout(this.debouncedEvents.get(key)?.timer);
-		const timer = setTimeout(() => {
-			this.debouncedEvents.delete(key);
-			this.buffer.push(event);
-			this.scheduleProcessing();
-		}, delay);
-		this.debouncedEvents.set(key, {
-			timer,
-			resolve: () => {}
-		});
-	}
-	scheduleProcessing() {
-		if (!this.isProcessing) queueMicrotask(() => this.processEvents());
-	}
-	async processEvents() {
-		if (this.isProcessing) return;
-		this.isProcessing = true;
-		try {
-			while (this.dequeue());
-		} finally {
-			this.isProcessing = false;
-		}
-	}
-	dequeue() {
-		const event = this.buffer.shift();
-		if (!event) return false;
-		this.setLastEvent(event.type, event);
-		this.broadcastEvent(event.type, event);
-		return true;
-	}
-	setLastEvent(type, event) {
-		this.lastEvents[type] = event;
-	}
-	broadcastEvent(type, event) {
-		const subscribers = this.subscribers[type].values();
-		for (const subscriber of subscribers) {
-			subscriber.handler(event);
-			if (subscriber.once) this.unsubscribe(subscriber.id);
-		}
-	}
-};
-function createEventSystem(eventTypes) {
-	return new EventSystem(eventTypes);
+function parseStoredRecordId(id) {
+	const [table, ...rest] = id.split(":");
+	let raw = rest.join(":");
+	if (raw.startsWith("⟨") && raw.endsWith("⟩")) raw = raw.slice(1, -1);
+	return new RecordId$1(table, raw);
 }
-
-//#endregion
-//#region src/modules/auth/events/index.ts
-const AuthEventTypes = {
-	AuthStateChanged: "AUTH_STATE_CHANGED",
-	ImpersonationChanged: "IMPERSONATION_CHANGED"
+/** Stable `table:id` string for an id read from the store, escaping removed. */
+const storedIdString = (id) => {
+	if (id instanceof RecordId$1) return `${id.table}:${String(id.id)}`;
+	const rid = parseStoredRecordId(String(id));
+	return `${rid.table}:${rid.id}`;
 };
-function createAuthEventSystem() {
-	return createEventSystem([AuthEventTypes.AuthStateChanged, AuthEventTypes.ImpersonationChanged]);
-}
-
-//#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 [];
+/** Timestamp prefix of a v1/v2 mutation id, or `null` for a legacy numeric id. */
+function createdAtFromId(id) {
+	const raw = id.includes(":") ? id.slice(id.indexOf(":") + 1) : id;
+	const m = /^⟨?(\d{13})/.exec(raw);
+	return m ? Number(m[1]) : null;
 }
 /**
-* 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'`.
+* Read any row shape this table ever had. Legacy rows (`v` missing) lack
+* `tableName`, `createdAt` and `beforeRecord`. A create without `data` is not
+* replayable and returns `null`.
 */
-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));
-	}
+function parsePendingRow(row) {
+	if (!row || typeof row !== "object") return null;
+	const r = row;
+	const type = r.mutationType;
+	if (type !== "create" && type !== "update" && type !== "delete") return null;
+	if (typeof r.recordId !== "string" && !(r.recordId instanceof RecordId$1)) return null;
+	const id = storedIdString(r.id);
+	const recordId = typeof r.recordId === "string" ? r.recordId : storedIdString(r.recordId);
+	const data = r.data && typeof r.data === "object" ? r.data : void 0;
+	if (type === "create" && !data) return null;
 	return {
-		versions,
-		entities
+		id,
+		mutationType: type,
+		recordId,
+		tableName: typeof r.tableName === "string" ? r.tableName : extractTablePart(recordId),
+		data,
+		beforeRecord: r.beforeRecord && typeof r.beforeRecord === "object" ? r.beforeRecord : void 0,
+		createdAt: typeof r.createdAt === "number" ? r.createdAt : createdAtFromId(id) ?? 0,
+		v: typeof r.v === "number" ? r.v : 1
 	};
 }
-
-//#endregion
-//#region src/modules/devtools/storage-info.ts
 /**
-* Recursively list the origin's OPFS. Sizes come from `handle.getFile()`,
-* which throws for a file another context holds an exclusive sync access
-* handle on — SAHPool does exactly that for its whole pool, so a locked file
-* (size omitted) is a live "who has the pool" signal, not a failure.
+* Re-type a stored row's payload from the schema before it is pushed. The
+* store keeps JSON, so a `record<user>` field comes back as `'user:x'` and a
+* datetime as a string; the server coerces neither. Unknown keys stay as they
+* are, and a payload the schema rejects is sent raw so the server's answer,
+* not a local throw, decides its fate.
 */
-async function walkOpfs(maxEntries = 2e3, maxDepth = 8) {
-	const nav = typeof navigator !== "undefined" ? navigator : void 0;
-	if (!nav?.storage?.getDirectory) return {
-		supported: false,
-		entries: [],
-		totalBytes: 0,
-		truncated: false
-	};
-	const entries = [];
-	let totalBytes = 0;
-	let truncated = false;
+function hydrateRowData(row, columns) {
+	if (!row.data || !columns) return row;
 	try {
-		const root = await nav.storage.getDirectory();
-		const walk = async (dir, prefix, depth) => {
-			if (depth > maxDepth) return;
-			for await (const [name, handle] of dir.entries()) {
-				if (entries.length >= maxEntries) {
-					truncated = true;
-					return;
-				}
-				const path = prefix ? `${prefix}/${name}` : name;
-				if (handle.kind === "directory") {
-					entries.push({
-						path,
-						kind: "directory"
-					});
-					await walk(handle, path, depth + 1);
-				} else {
-					let size;
-					try {
-						size = (await handle.getFile()).size;
-						totalBytes += size;
-					} catch {}
-					const entry = {
-						path,
-						kind: "file"
-					};
-					if (size !== void 0) entry.size = size;
-					entries.push(entry);
-				}
-			}
-		};
-		await walk(root, "", 0);
-		entries.sort((a, b) => a.path.localeCompare(b.path));
-		return {
-			supported: true,
-			entries,
-			totalBytes,
-			truncated
-		};
-	} catch (e) {
 		return {
-			supported: true,
-			entries,
-			totalBytes,
-			truncated,
-			error: e instanceof Error ? e.message : String(e)
+			...row,
+			data: parseQueryParams(columns, row.data)
 		};
+	} catch {
+		return row;
 	}
 }
-
-//#endregion
-//#region src/modules/devtools/flags.ts
-/**
-* SurrealDB's SDK returns one entry per statement; each entry is the rows for
-* that statement, but older/local shapes wrap them as `{ status, result }`.
-* `getTableData` in `index.ts` unwraps the same three shapes inline — this is
-* that logic, reusable.
-*/
-function statementRows(result, index = 0) {
-	if (!Array.isArray(result)) return [];
-	const entry = result[index];
-	if (Array.isArray(entry)) return entry;
-	if (entry && typeof entry === "object" && "result" in entry) {
-		const inner = entry.result;
-		return Array.isArray(inner) ? inner : inner === void 0 || inner === null ? [] : [inner];
-	}
-	return entry === void 0 || entry === null ? [] : [entry];
-}
-function message(err) {
-	return err instanceof Error ? err.message : String(err);
+const toOutboxItem = (row) => ({
+	id: row.id,
+	type: row.mutationType,
+	recordId: row.recordId,
+	table: row.tableName,
+	status: "pending",
+	ackedAt: null,
+	attempts: 0
+});
+/** The `_00_pending_writes` id for a minted mutation id (same suffix). */
+const pendingWriteId = (mutationId) => `${PENDING_WRITES_TABLE}:${mutationId.includes(":") ? mutationId.slice(mutationId.indexOf(":") + 1) : mutationId}`;
+function parsePendingWriteRow(row) {
+	if (!row || typeof row !== "object") return null;
+	const r = row;
+	if (typeof r.recordId !== "string" && !(r.recordId instanceof RecordId$1)) return null;
+	if (!r.data || typeof r.data !== "object") return null;
+	const recordId = typeof r.recordId === "string" ? r.recordId : storedIdString(r.recordId);
+	return {
+		id: storedIdString(r.id),
+		recordId,
+		tableName: typeof r.tableName === "string" ? r.tableName : extractTablePart(recordId),
+		data: r.data,
+		beforeRecord: r.beforeRecord && typeof r.beforeRecord === "object" ? r.beforeRecord : null,
+		flushBy: typeof r.flushBy === "number" ? r.flushBy : 0
+	};
 }
-/** Row shape guards. `key` is the only field the panel truly can't do without. */
-function hasStringKey(row) {
-	return !!row && typeof row === "object" && typeof row.key === "string";
+const loadPendingRows = () => `SELECT * FROM ${PENDING_TABLE} ORDER BY id ASC`;
+const loadPendingWriteRows = () => `SELECT * FROM ${PENDING_WRITES_TABLE}`;
+const loadFailedRows = () => `SELECT * FROM ${FAILED_TABLE} ORDER BY failedAt ASC`;
+const pendingInsert = (type, withData, withBefore) => {
+	const fields = [
+		`mutationType = '${type}'`,
+		"recordId = $id",
+		"tableName = $table",
+		"createdAt = $createdAt",
+		`v = ${PENDING_ROW_VERSION}`
+	];
+	if (withData) fields.push("data = $data");
+	if (withBefore) fields.push("beforeRecord = $before");
+	return `CREATE ONLY $mid SET ${fields.join(", ")}`;
+};
+/** `CREATE` the row and its outbox entry in one transaction; result index 0 is the row. */
+function planCreateTx(input) {
+	const data = input.data ?? {};
+	const keys = Object.keys(data).map((key) => ({
+		key,
+		variable: `data_${key}`
+	}));
+	const vars = {
+		id: input.recordId,
+		mid: input.mutationId,
+		table: input.table,
+		createdAt: input.now,
+		data
+	};
+	for (const { key, variable } of keys) vars[variable] = data[key];
+	return {
+		query: surql.seal(surql.tx([surql.createSet("id", keys), pendingInsert("create", true, false)]), { resultIndex: 0 }),
+		vars
+	};
 }
-function isAssignment(row) {
-	return hasStringKey(row);
+/** Bump `_00_rv`, MERGE the patch, write the outbox row (with `beforeRecord`); returns `{ target }`. */
+function planUpdateTx(input) {
+	return {
+		query: surql.seal(surql.tx([
+			surql.updateSet("id", [{ statement: "_00_rv += 1" }]),
+			surql.let("updated", surql.updateMerge("id", "data")),
+			pendingInsert("update", true, true),
+			surql.returnObject([{
+				key: "target",
+				variable: "updated"
+			}])
+		])),
+		vars: {
+			id: input.recordId,
+			mid: input.mutationId,
+			table: input.table,
+			createdAt: input.now,
+			data: input.data ?? {},
+			before: input.before ?? null
+		}
+	};
 }
-function isFlagRow(row) {
-	return hasStringKey(row);
+/** DELETE the row and write the outbox entry (with `beforeRecord`). */
+function planDeleteTx(input) {
+	return {
+		query: surql.seal(surql.tx([surql.delete("id"), pendingInsert("delete", false, true)])),
+		vars: {
+			id: input.recordId,
+			mid: input.mutationId,
+			table: input.table,
+			createdAt: input.now,
+			before: input.before ?? null
+		}
+	};
 }
-var FlagsAdminService = class {
-	constructor(deps) {
-		this.deps = deps;
-	}
-	/**
-	* Everything the Access tab renders, in one round trip per source.
-	*
-	* Each section fails independently: a remote read that throws downgrades to
-	* `isAdmin: false` plus an `error`, while local assignments and overrides
-	* still render. Signing out must not blank the whole tab.
-	*/
-	async getFlags() {
-		const userId = this.deps.currentUserId();
-		const snapshot = {
-			at: Date.now(),
-			userId,
-			isAdmin: false,
-			flags: [],
-			assignments: [],
-			overrides: this.deps.overrides()?.getLocalOverrides() ?? {}
-		};
-		try {
-			snapshot.assignments = statementRows(await this.deps.local.query("SELECT key, variant, payload FROM _00_user_feature")).filter(isAssignment).map((r) => ({
-				key: r.key,
-				variant: r.variant,
-				payload: r.payload
-			}));
-		} catch (err) {
-			this.deps.logger.debug({
-				err,
-				Category: "sp00ky-client::FlagsAdminService::getFlags"
-			}, "Local feature assignments unavailable");
+/**
+* Debounced update: bump `_00_rv` and MERGE now; the outbox row comes later.
+* With a `mirror`, the merged patch so far is written to `_00_pending_writes`
+* in the same transaction, so the row never changes without a durable copy of
+* what still has to reach the server.
+*/
+function planLocalOnlyUpdateTx(input) {
+	const statements = [surql.updateSet("id", [{ statement: "_00_rv += 1" }]), surql.let("updated", surql.updateMerge("id", "data"))];
+	if (input.mirror) statements.push(surql.upsert("wid", "wrow"));
+	statements.push(surql.returnObject([{
+		key: "target",
+		variable: "updated"
+	}]));
+	return {
+		query: surql.seal(surql.tx(statements)),
+		vars: input.mirror ? {
+			id: input.recordId,
+			data: input.data,
+			wid: input.mirror.id,
+			wrow: input.mirror.row
+		} : {
+			id: input.recordId,
+			data: input.data
 		}
-		if (!userId) return snapshot;
-		try {
-			snapshot.isAdmin = statementRows(await this.deps.remote.query("SELECT VALUE id FROM _00_admin WHERE user = $auth.id LIMIT 1")).length > 0;
-		} catch (err) {
-			snapshot.error = `Could not check admin status: ${message(err)}. If this deployment predates the Access tab, run \`spky migrate\` (or redeploy) to apply the internal schema.`;
-			return snapshot;
+	};
+}
+/**
+* The outbox row of a flushed debounced update. With `mirrorId` the
+* `_00_pending_writes` row goes in the same transaction: the patch moves
+* from one table to the other, it is never in both or in neither.
+*/
+function planDeferredOutboxRowTx(input) {
+	const statements = [pendingInsert("update", true, true)];
+	if (input.mirrorId) statements.push(surql.delete("wid"));
+	return {
+		query: surql.seal(surql.tx(statements)),
+		vars: {
+			id: input.recordId,
+			mid: input.mutationId,
+			table: input.table,
+			createdAt: input.now,
+			data: input.data ?? {},
+			before: input.before ?? null,
+			...input.mirrorId ? { wid: input.mirrorId } : {}
+		}
+	};
+}
+/**
+* Many outbox rows as ONE multi-statement request. Statement i answers row i.
+* Each statement is its own transaction on the server, as before.
+*/
+function remoteBatch(rows) {
+	const vars = {};
+	return {
+		sql: rows.map((row, i) => {
+			const rid = parseRecordIdString(row.recordId);
+			vars[`id${i}`] = rid;
+			switch (row.mutationType) {
+				case "create": {
+					const data = row.data ?? {};
+					return `CREATE ONLY $id${i} SET ${Object.keys(data).map((key) => {
+						vars[`d${i}_${key}`] = data[key];
+						return `${key} = $d${i}_${key}`;
+					}).join(", ")}`;
+				}
+				case "update":
+					vars[`data${i}`] = row.data ?? {};
+					return `UPDATE $id${i} MERGE $data${i}`;
+				case "delete": return `DELETE $id${i}`;
+			}
+		}).join(";\n"),
+		vars
+	};
+}
+/**
+* How to undo a rejected mutation locally. A create is deleted; an update or
+* delete is restored from `beforeRecord` (REPLACE, so the pre-bump `_00_rv`
+* comes back). Without a `beforeRecord` nothing can be restored.
+*/
+function planRevert(row, before) {
+	const rid = parseRecordIdString(row.recordId);
+	if (row.mutationType === "create") return {
+		tx: {
+			query: surql.seal(surql.tx([surql.delete("id")])),
+			vars: { id: rid }
+		},
+		circuit: {
+			table: row.tableName,
+			op: "DELETE",
+			id: row.recordId,
+			record: row.data ?? {}
+		},
+		revert: "full"
+	};
+	if (!before) return {
+		tx: null,
+		circuit: {
+			table: row.tableName,
+			op: "UPDATE",
+			id: row.recordId,
+			record: {}
+		},
+		revert: "partial"
+	};
+	const { id: _id, ...content } = before;
+	return {
+		tx: {
+			query: surql.seal(surql.tx([surql.upsert("id", "content")])),
+			vars: {
+				id: rid,
+				content
+			}
+		},
+		circuit: {
+			table: row.tableName,
+			op: row.mutationType === "delete" ? "CREATE" : "UPDATE",
+			id: row.recordId,
+			record: {
+				...before,
+				id: rid
+			}
+		},
+		revert: "full"
+	};
+}
+const failedRecordId = (mutationId) => new RecordId$1(FAILED_TABLE, mutationId.slice(mutationId.indexOf(":") + 1));
+function buildFailedRow(row, error, before, attempts, now, revert) {
+	return {
+		id: row.id,
+		mutationType: row.mutationType,
+		recordId: row.recordId,
+		tableName: row.tableName,
+		data: row.data,
+		beforeRecord: before,
+		error,
+		attempts,
+		createdAt: row.createdAt,
+		failedAt: now,
+		revert
+	};
+}
+/** ONE transaction: write the tray row, delete the pending row. */
+function moveToFailedTx(failed) {
+	const { id: _id, ...content } = failed;
+	return {
+		query: surql.seal(surql.tx([surql.create("fid", "failed"), surql.delete("mid")])),
+		vars: {
+			fid: failedRecordId(failed.id),
+			failed: content,
+			mid: parseStoredRecordId(failed.id)
+		}
+	};
+}
+const deletePendingRow = (mutationId) => ({
+	sql: "DELETE $mid",
+	vars: { mid: parseStoredRecordId(mutationId) }
+});
+const deleteFailedRow = (mutationId) => ({
+	sql: "DELETE $fid",
+	vars: { fid: failedRecordId(mutationId) }
+});
+function parseFailedRow(row) {
+	if (!row || typeof row !== "object") return null;
+	const r = row;
+	const type = r.mutationType;
+	if (type !== "create" && type !== "update" && type !== "delete") return null;
+	if (typeof r.recordId !== "string") return null;
+	const err = r.error ?? {};
+	return {
+		id: storedIdString(r.id).replace(`${FAILED_TABLE}:`, `${PENDING_TABLE}:`),
+		mutationType: type,
+		recordId: r.recordId,
+		tableName: typeof r.tableName === "string" ? r.tableName : extractTablePart(r.recordId),
+		data: r.data && typeof r.data === "object" ? r.data : void 0,
+		beforeRecord: r.beforeRecord && typeof r.beforeRecord === "object" ? r.beforeRecord : null,
+		error: {
+			message: typeof err.message === "string" ? err.message : "unknown",
+			kind: err.kind === "unreplayable" ? "unreplayable" : "application"
+		},
+		attempts: typeof r.attempts === "number" ? r.attempts : 0,
+		createdAt: typeof r.createdAt === "number" ? r.createdAt : 0,
+		failedAt: typeof r.failedAt === "number" ? r.failedAt : 0,
+		revert: r.revert === "partial" || r.revert === "none" ? r.revert : "full"
+	};
+}
+
+//#endregion
+//#region src/events/index.ts
+/**
+* A type-safe event system that handles subscription, emission (including debouncing), and buffering of events.
+* @template E The EventTypeMap defining all supported events.
+*/
+var EventSystem = class {
+	subscriberId = 0;
+	isProcessing = false;
+	buffer;
+	subscribers;
+	subscribersTypeMap;
+	lastEvents;
+	debouncedEvents;
+	constructor(_eventTypes) {
+		this._eventTypes = _eventTypes;
+		this.buffer = [];
+		this.subscribers = this._eventTypes.reduce((acc, key) => {
+			return Object.assign(acc, { [key]: /* @__PURE__ */ new Map() });
+		}, {});
+		this.lastEvents = {};
+		this.subscribersTypeMap = /* @__PURE__ */ new Map();
+		this.debouncedEvents = /* @__PURE__ */ new Map();
+	}
+	get eventTypes() {
+		return this._eventTypes;
+	}
+	/**
+	* Subscribes a handler to a specific event type.
+	* @param type The event type to subscribe to.
+	* @param handler The function to call when the event occurs.
+	* @param options Subscription options (once, immediately).
+	* @returns A subscription ID that can be used to unsubscribe.
+	*/
+	subscribe(type, handler, options) {
+		const id = this.subscriberId++;
+		this.subscribers[type].set(id, {
+			id,
+			handler,
+			once: options?.once ?? false
+		});
+		this.subscribersTypeMap.set(id, type);
+		if (options?.immediately) {
+			const lastEvent = this.lastEvents[type];
+			if (lastEvent) handler(lastEvent);
+		}
+		return id;
+	}
+	/**
+	* Subscribes a handler to multiple event types.
+	* @param types An array of event types to subscribe to.
+	* @param handler The function to call when any of the events occur.
+	* @param options Subscription options.
+	* @returns An array of subscription IDs.
+	*/
+	subscribeMany(types, handler, options) {
+		return types.map((type) => this.subscribe(type, handler, options));
+	}
+	/**
+	* Unsubscribes a specific subscription by ID.
+	* @param id The subscription ID returned by subscribe().
+	* @returns True if the subscription was found and removed, false otherwise.
+	*/
+	unsubscribe(id) {
+		const type = this.subscribersTypeMap.get(id);
+		if (type) {
+			this.subscribers[type].delete(id);
+			this.subscribersTypeMap.delete(id);
+			return true;
+		}
+		return false;
+	}
+	/**
+	* Emits an event with the given type and payload.
+	* @param type The type of event to emit.
+	* @param payload The data associated with the event.
+	*/
+	emit(type, payload) {
+		const event = {
+			type,
+			payload
+		};
+		this.addEvent(event);
+	}
+	/**
+	* Adds a fully constructed event object to the system.
+	* Similar to emit, but takes the full event object directly.
+	* Supports debouncing if options are provided.
+	* @param event The event object.
+	* @param options Options for the event push (e.g., debouncing).
+	*/
+	addEvent(event, options) {
+		if (options?.debounced) {
+			this.handleDebouncedEvent(event, options.debounced.key, options.debounced.delay);
+			return;
+		}
+		this.buffer.push(event);
+		this.scheduleProcessing();
+	}
+	handleDebouncedEvent(event, key, delay) {
+		if (this.debouncedEvents.has(key)) clearTimeout(this.debouncedEvents.get(key)?.timer);
+		const timer = setTimeout(() => {
+			this.debouncedEvents.delete(key);
+			this.buffer.push(event);
+			this.scheduleProcessing();
+		}, delay);
+		this.debouncedEvents.set(key, {
+			timer,
+			resolve: () => {}
+		});
+	}
+	scheduleProcessing() {
+		if (!this.isProcessing) queueMicrotask(() => this.processEvents());
+	}
+	async processEvents() {
+		if (this.isProcessing) return;
+		this.isProcessing = true;
+		try {
+			while (this.dequeue());
+		} finally {
+			this.isProcessing = false;
+		}
+	}
+	dequeue() {
+		const event = this.buffer.shift();
+		if (!event) return false;
+		this.setLastEvent(event.type, event);
+		this.broadcastEvent(event.type, event);
+		return true;
+	}
+	setLastEvent(type, event) {
+		this.lastEvents[type] = event;
+	}
+	broadcastEvent(type, event) {
+		const subscribers = this.subscribers[type].values();
+		for (const subscriber of subscribers) {
+			subscriber.handler(event);
+			if (subscriber.once) this.unsubscribe(subscriber.id);
+		}
+	}
+};
+function createEventSystem(eventTypes) {
+	return new EventSystem(eventTypes);
+}
+
+//#endregion
+//#region src/modules/auth/events/index.ts
+const AuthEventTypes = {
+	AuthStateChanged: "AUTH_STATE_CHANGED",
+	ImpersonationChanged: "IMPERSONATION_CHANGED"
+};
+function createAuthEventSystem() {
+	return createEventSystem([AuthEventTypes.AuthStateChanged, AuthEventTypes.ImpersonationChanged]);
+}
+
+//#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/storage-info.ts
+/**
+* Recursively list the origin's OPFS. Sizes come from `handle.getFile()`,
+* which throws for a file another context holds an exclusive sync access
+* handle on — SAHPool does exactly that for its whole pool, so a locked file
+* (size omitted) is a live "who has the pool" signal, not a failure.
+*/
+async function walkOpfs(maxEntries = 2e3, maxDepth = 8) {
+	const nav = typeof navigator !== "undefined" ? navigator : void 0;
+	if (!nav?.storage?.getDirectory) return {
+		supported: false,
+		entries: [],
+		totalBytes: 0,
+		truncated: false
+	};
+	const entries = [];
+	let totalBytes = 0;
+	let truncated = false;
+	try {
+		const root = await nav.storage.getDirectory();
+		const walk = async (dir, prefix, depth) => {
+			if (depth > maxDepth) return;
+			for await (const [name, handle] of dir.entries()) {
+				if (entries.length >= maxEntries) {
+					truncated = true;
+					return;
+				}
+				const path = prefix ? `${prefix}/${name}` : name;
+				if (handle.kind === "directory") {
+					entries.push({
+						path,
+						kind: "directory"
+					});
+					await walk(handle, path, depth + 1);
+				} else {
+					let size;
+					try {
+						size = (await handle.getFile()).size;
+						totalBytes += size;
+					} catch {}
+					const entry = {
+						path,
+						kind: "file"
+					};
+					if (size !== void 0) entry.size = size;
+					entries.push(entry);
+				}
+			}
+		};
+		await walk(root, "", 0);
+		entries.sort((a, b) => a.path.localeCompare(b.path));
+		return {
+			supported: true,
+			entries,
+			totalBytes,
+			truncated
+		};
+	} catch (e) {
+		return {
+			supported: true,
+			entries,
+			totalBytes,
+			truncated,
+			error: e instanceof Error ? e.message : String(e)
+		};
+	}
+}
+
+//#endregion
+//#region src/modules/devtools/flags.ts
+/**
+* SurrealDB's SDK returns one entry per statement; each entry is the rows for
+* that statement, but older/local shapes wrap them as `{ status, result }`.
+* `getTableData` in `index.ts` unwraps the same three shapes inline — this is
+* that logic, reusable.
+*/
+function statementRows(result, index = 0) {
+	if (!Array.isArray(result)) return [];
+	const entry = result[index];
+	if (Array.isArray(entry)) return entry;
+	if (entry && typeof entry === "object" && "result" in entry) {
+		const inner = entry.result;
+		return Array.isArray(inner) ? inner : inner === void 0 || inner === null ? [] : [inner];
+	}
+	return entry === void 0 || entry === null ? [] : [entry];
+}
+function message(err) {
+	return err instanceof Error ? err.message : String(err);
+}
+/** Row shape guards. `key` is the only field the panel truly can't do without. */
+function hasStringKey(row) {
+	return !!row && typeof row === "object" && typeof row.key === "string";
+}
+function isAssignment(row) {
+	return hasStringKey(row);
+}
+function isFlagRow(row) {
+	return hasStringKey(row);
+}
+var FlagsAdminService = class {
+	constructor(deps) {
+		this.deps = deps;
+	}
+	/**
+	* Everything the Access tab renders, in one round trip per source.
+	*
+	* Each section fails independently: a remote read that throws downgrades to
+	* `isAdmin: false` plus an `error`, while local assignments and overrides
+	* still render. Signing out must not blank the whole tab.
+	*/
+	async getFlags() {
+		const userId = this.deps.currentUserId();
+		const snapshot = {
+			at: Date.now(),
+			userId,
+			isAdmin: false,
+			flags: [],
+			assignments: [],
+			overrides: this.deps.overrides()?.getLocalOverrides() ?? {}
+		};
+		try {
+			snapshot.assignments = statementRows(await this.deps.local.query("SELECT key, variant, payload FROM _00_user_feature")).filter(isAssignment).map((r) => ({
+				key: r.key,
+				variant: r.variant,
+				payload: r.payload
+			}));
+		} catch (err) {
+			this.deps.logger.debug({
+				err,
+				Category: "sp00ky-client::FlagsAdminService::getFlags"
+			}, "Local feature assignments unavailable");
+		}
+		if (!userId) return snapshot;
+		try {
+			snapshot.isAdmin = statementRows(await this.deps.remote.query("SELECT VALUE id FROM _00_admin WHERE user = $auth.id LIMIT 1")).length > 0;
+		} catch (err) {
+			snapshot.error = `Could not check admin status: ${message(err)}. If this deployment predates the Access tab, run \`spky migrate\` (or redeploy) to apply the internal schema.`;
+			return snapshot;
 		}
 		if (!snapshot.isAdmin) return snapshot;
 		try {
@@ -1750,14 +2105,83 @@ function selfAllowlistedVariant(flag, userId) {
 	return (Array.isArray(flag.rules) ? flag.rules : []).find((rule) => rule?.kind === "allowlist" && Array.isArray(rule.users) && rule.users.some((u) => String(u) === userId))?.variant;
 }
 
+//#endregion
+//#region src/modules/devtools/mutations.ts
+/** When a mutation was queued, from the timestamp its id starts with (0 for a legacy id). */
+const queuedAtOf = (id) => createdAtFromId(id) ?? 0;
+/** The tab's mutation picture: the live outbox over what DevTools saw leave it. */
+function buildMutationsState(input) {
+	const byId = /* @__PURE__ */ new Map();
+	for (const h of input.history) byId.set(h.id, {
+		id: h.id,
+		op: h.op,
+		recordId: h.recordId,
+		table: h.table,
+		fields: h.fields,
+		status: h.outcome ? h.outcome.status : "dropped",
+		attempts: 0,
+		queuedAt: h.queuedAt,
+		settledAt: h.outcome?.at,
+		error: h.outcome?.error
+	});
+	for (const item of input.outbox) {
+		const seen = byId.get(item.id);
+		const status = item.status === "acked" ? "synced" : item.attempts > 0 ? "retrying" : "pending";
+		byId.set(item.id, {
+			id: item.id,
+			op: item.type,
+			recordId: item.recordId,
+			table: item.table,
+			fields: seen?.fields,
+			status,
+			attempts: item.attempts,
+			queuedAt: seen?.queuedAt || queuedAtOf(item.id),
+			settledAt: item.ackedAt ?? seen?.settledAt
+		});
+	}
+	const all = [...byId.values()].toSorted((a, b) => b.queuedAt - a.queuedAt || (a.id < b.id ? 1 : -1));
+	const count = (s) => all.filter((m) => m.status === s).length;
+	const debounced = [...input.pendingWrites].map((w) => ({
+		key: w.key,
+		recordId: w.recordId,
+		table: w.table,
+		fields: Object.keys(w.data),
+		since: w.firstAt,
+		durable: w.mirrorId !== null
+	}));
+	return {
+		role: input.tabRole,
+		connection: input.health.connection,
+		health: input.health.status,
+		consecutiveFailures: input.health.consecutiveFailures,
+		lastError: input.health.error,
+		counts: {
+			pending: count("pending"),
+			retrying: count("retrying"),
+			debounced: debounced.length,
+			failed: input.failedCount,
+			synced: count("synced"),
+			rolledBack: count("rolled-back")
+		},
+		entries: all.slice(0, input.cap),
+		total: all.length,
+		debounced
+	};
+}
+/** Keep the newest `cap` entries of an insertion-ordered history map. */
+function trimHistory(history, cap) {
+	for (const id of history.keys()) {
+		if (history.size <= cap) return;
+		history.delete(id);
+	}
+}
+
 //#endregion
 //#region src/modules/devtools/index.ts
-const CORE_VERSION = "0.0.1-canary.290";
-const WASM_VERSION = "0.0.1-canary.290";
+const CORE_VERSION = "0.0.1-canary.292";
+const WASM_VERSION = "0.0.1-canary.292";
 const SURREAL_VERSION = "3.0.3";
 var DevToolsService = class DevToolsService {
-	eventsHistory = [];
-	eventIdCounter = 0;
 	version = CORE_VERSION;
 	backendInfo = emptyBackendInfo();
 	enabled = false;
@@ -1776,6 +2200,34 @@ var DevToolsService = class DevToolsService {
 	}
 	/** Blob cache counters for the panel, wired by Sp00kyClient. */
 	blobInfoProvider = null;
+	/** Outbox, debounced writes and the failed tray, wired by Sp00kyClient. */
+	mutationSource = null;
+	/**
+	* Mutations seen since a consumer attached, by id, oldest first. The outbox
+	* only knows what is still queued; this is what lets the panel show a write
+	* as synced or rolled back after it left.
+	*/
+	mutationHistory = /* @__PURE__ */ new Map();
+	static MUTATIONS_CAP = 200;
+	setMutationSource(source) {
+		this.mutationSource = source;
+	}
+	/**
+	* The page's log buffer. It records whether or not anybody is watching (so
+	* a panel opened late still sees the boot); while a consumer is attached,
+	* new lines go out as small `SP00KY_LOGS` deltas, never inside the state
+	* push, which would re-serialize the whole buffer every time.
+	*/
+	logTap = null;
+	/** `seq` of the newest line already pushed. */
+	logCursor = 0;
+	logTimer = null;
+	lastLogPushAt = 0;
+	setLogTap(tap) {
+		this.logTap = tap;
+		this.logCursor = tap.head;
+		tap.subscribe(() => this.scheduleLogPush());
+	}
 	setBlobInfoProvider(provider) {
 		this.blobInfoProvider = provider;
 	}
@@ -1808,6 +2260,7 @@ var DevToolsService = class DevToolsService {
 			const type = e.data?.type;
 			if (type === "SP00KY_DEVTOOLS_CONNECT") {
 				this.enabled = true;
+				this.logCursor = this.logTap?.head ?? 0;
 				this.refreshLocalTables();
 				this.notifyDevTools();
 			} else if (type === "SP00KY_DEVTOOLS_DISCONNECT") this.enabled = false;
@@ -1873,57 +2326,193 @@ var DevToolsService = class DevToolsService {
 		});
 		return result;
 	}
-	onQueryInitialized(payload) {
+	onStreamUpdate(update) {
+		if (update.synthetic) return;
 		this.logger.debug({
-			payload,
-			Category: "sp00ky-client::DevToolsService::onQueryInitialized"
-		}, "QueryInitialized");
-		const queryHash = this.hashString(payload.queryId.toString());
-		this.addEvent("QUERY_REQUEST_INIT", {
-			queryHash,
-			query: payload.sql,
-			variables: {}
+			queryHash: update.queryHash,
+			op: update.op,
+			localCount: update.localArray?.length ?? 0,
+			materializationTimeMs: update.materializationTimeMs,
+			storeApplyMs: update.storeApplyMs,
+			circuitStepMs: update.circuitStepMs,
+			transformMs: update.transformMs,
+			Category: "sp00ky-client::DevToolsService::onStreamUpdate"
+		}, "StreamUpdate");
+		this.notifyDevTools();
+	}
+	onMutation(payload) {
+		for (const p of payload) this.recordQueued(p);
+		this.notifyDevTools();
+	}
+	/** A write entered the outbox. */
+	recordQueued(p) {
+		if (!this.enabled || !p?.mutation_id) return;
+		const id = storedIdString(p.mutation_id);
+		const recordId = p.record_id ? encodeRecordId(p.record_id) : "";
+		this.mutationHistory.set(id, {
+			id,
+			op: p.type ?? "create",
+			recordId,
+			table: typeof p.tableName === "string" ? p.tableName : recordId.split(":")[0],
+			fields: p.data && typeof p.data === "object" ? Object.keys(p.data) : [],
+			queuedAt: queuedAtOf(id) || Date.now()
+		});
+		trimHistory(this.mutationHistory, DevToolsService.MUTATIONS_CAP);
+	}
+	/** The server answered a write: accepted (`synced`) or rejected (`rolled-back`). */
+	onMutationOutcome(e) {
+		if (!this.enabled) return;
+		const prev = this.mutationHistory.get(e.mutationId);
+		this.mutationHistory.set(e.mutationId, {
+			...prev ?? {
+				id: e.mutationId,
+				op: e.eventType,
+				recordId: e.recordId,
+				table: e.recordId.split(":")[0],
+				queuedAt: queuedAtOf(e.mutationId)
+			},
+			outcome: {
+				status: e.status,
+				at: Date.now(),
+				error: e.error
+			}
 		});
+		trimHistory(this.mutationHistory, DevToolsService.MUTATIONS_CAP);
+		this.notifyDevTools();
+	}
+	/** Something the panel shows moved (a query's status, the outbox, sync health): re-push. */
+	onStateChanged() {
 		this.notifyDevTools();
 	}
-	onQueryUpdated(payload) {
-		this.logger.debug({
-			id: payload.queryId?.toString(),
-			Category: "sp00ky-client::DevToolsService::onQueryUpdated"
-		}, "QueryUpdated");
-		const queryHash = this.hashString(payload.queryId.toString());
-		this.addEvent("QUERY_UPDATED", {
-			queryHash,
-			recordCount: Array.isArray(payload.records) ? payload.records.length : 0
-		});
-		this.notifyDevTools();
+	mutationsState() {
+		const source = this.mutationSource;
+		if (!source) return null;
+		const s = source.state();
+		return buildMutationsState({
+			outbox: s.outbox,
+			pendingWrites: s.pendingWrites.values(),
+			failedCount: s.failedCount,
+			tabRole: s.tabRole,
+			health: s.sync.health,
+			history: this.mutationHistory.values(),
+			cap: DevToolsService.MUTATIONS_CAP
+		});
+	}
+	/**
+	* The Mutations tab's on-demand half: the failed tray (a local read), one
+	* queued row's payload, and the tray's retry / discard.
+	*/
+	async mutationOp(op, args) {
+		const source = this.mutationSource;
+		if (!source) return {
+			success: false,
+			error: "this client does not expose its mutations"
+		};
+		const id = String(args.id ?? "");
+		try {
+			switch (op) {
+				case "listFailed": return this.serializeForDevTools({
+					success: true,
+					failed: await source.listFailed()
+				});
+				case "get": {
+					const res = await this.databaseService.query("SELECT * FROM $ids", { ids: [parseStoredRecordId(id)] });
+					const raw = Array.isArray(res?.[0]) ? res[0][0] : void 0;
+					return this.serializeForDevTools({
+						success: true,
+						row: raw ? parsePendingRow(raw) : null
+					});
+				}
+				case "retry": return await source.retryFailed(id) ? { success: true } : {
+					success: false,
+					error: `${id} is not in the failed tray`
+				};
+				case "discard": return await source.discardFailed(id) ? { success: true } : {
+					success: false,
+					error: `${id} is not in the failed tray`
+				};
+				case "clearHistory":
+					this.mutationHistory.clear();
+					this.notifyDevTools();
+					return { success: true };
+				default: return {
+					success: false,
+					error: `Unknown mutation op: ${String(op)}`
+				};
+			}
+		} catch (e) {
+			return {
+				success: false,
+				error: e instanceof Error ? e.message : String(e)
+			};
+		}
+	}
+	/** The Logs tab: read the buffer, change what it records, empty it. */
+	logOp(op, args) {
+		const tap = this.logTap;
+		if (!tap) return {
+			success: false,
+			error: "this client does not capture its logs"
+		};
+		try {
+			switch (op) {
+				case "read": {
+					const limit = typeof args.limit === "number" ? args.limit : void 0;
+					return {
+						success: true,
+						...tap.read(Number(args.after ?? 0), limit)
+					};
+				}
+				case "setCaptureLevel":
+					tap.setCaptureLevel(String(args.level));
+					this.notifyDevTools();
+					return {
+						success: true,
+						captureLevel: tap.captureLevel,
+						consoleLevel: tap.consoleLevel
+					};
+				case "clear":
+					tap.clear();
+					return {
+						success: true,
+						head: tap.head
+					};
+				default: return {
+					success: false,
+					error: `Unknown log op: ${String(op)}`
+				};
+			}
+		} catch (e) {
+			return {
+				success: false,
+				error: e instanceof Error ? e.message : String(e)
+			};
+		}
 	}
-	onStreamUpdate(update) {
-		if (update.synthetic) return;
-		this.logger.debug({
-			queryHash: update.queryHash,
-			Category: "sp00ky-client::DevToolsService::onStreamUpdate"
-		}, "StreamUpdate");
-		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();
+	/** Same coalescing as {@link notifyDevTools}, for the log delta channel. */
+	scheduleLogPush() {
+		if (!this.enabled || typeof window === "undefined" || this.logTimer !== null) return;
+		const waited = Date.now() - this.lastLogPushAt;
+		const delay = Math.max(0, DevToolsService.NOTIFY_MIN_INTERVAL_MS - waited);
+		this.logTimer = setTimeout(() => {
+			this.logTimer = null;
+			if (this.enabled) this.flushLogs();
+		}, delay);
 	}
-	onMutation(payload) {
-		payload.forEach((p) => {
-			this.addEvent("MUTATION_REQUEST_EXECUTION", { mutation: {
-				type: p.type ?? "create",
-				fields: "data" in p && p.data && typeof p.data === "object" ? Object.keys(p.data) : [],
-				selector: encodeRecordId(p.record_id)
-			} });
-		});
-		this.notifyDevTools();
+	flushLogs() {
+		const tap = this.logTap;
+		if (!tap) return;
+		this.lastLogPushAt = Date.now();
+		const delta = tap.read(this.logCursor);
+		this.logCursor = delta.head;
+		if (delta.entries.length === 0) return;
+		window.postMessage({
+			type: "SP00KY_LOGS",
+			source: "sp00ky-devtools-page",
+			entries: delta.entries,
+			head: delta.head,
+			dropped: delta.dropped
+		}, "*");
 	}
 	hashString(str) {
 		let hash = 0;
@@ -1935,20 +2524,6 @@ var DevToolsService = class DevToolsService {
 		}
 		return hash;
 	}
-	logEvent(eventType, payload) {
-		this.addEvent(eventType, payload);
-		this.notifyDevTools();
-	}
-	addEvent(eventType, payload) {
-		if (!this.enabled) return;
-		this.eventsHistory.push({
-			id: this.eventIdCounter++,
-			timestamp: Date.now(),
-			eventType,
-			payload: this.serializeForDevTools(payload)
-		});
-		if (this.eventsHistory.length > 100) this.eventsHistory.shift();
-	}
 	/** Unwrap a SurrealDB `INFO FOR DB` result to its `{ tables, ... }` object. */
 	unwrapInfo(res) {
 		if (!Array.isArray(res) || !res[0]) return null;
@@ -1982,7 +2557,7 @@ var DevToolsService = class DevToolsService {
 	getState(opts = {}) {
 		if (opts.refreshTables) this.refreshLocalTables();
 		return this.serializeForDevTools({
-			eventsHistory: [...this.eventsHistory],
+			eventsHistory: [],
 			activeQueries: Object.fromEntries(this.getActiveQueries()),
 			auth: {
 				authenticated: this.authService.isAuthenticated,
@@ -2008,7 +2583,13 @@ var DevToolsService = class DevToolsService {
 					fallback: false
 				},
 				tabs: this.tabsInfoProvider?.() ?? null
-			}
+			},
+			mutations: this.mutationsState(),
+			logs: this.logTap ? {
+				head: this.logTap.head,
+				consoleLevel: this.logTap.consoleLevel,
+				captureLevel: this.logTap.captureLevel
+			} : null
 		});
 	}
 	/**
@@ -2208,14 +2789,12 @@ var DevToolsService = class DevToolsService {
 				},
 				getFlags: () => this.flagsAdmin.getFlags(),
 				impersonationOp: (op, args) => this.impersonationOp(op, args ?? {}),
+				mutationOp: (op, args) => this.mutationOp(op, args ?? {}),
+				logOp: (op, args) => this.logOp(op, args ?? {}),
 				setFlagEnabled: (key, enabled) => this.flagsAdmin.setFlagEnabled(key, enabled),
 				setFlagUserVariant: (key, variant, remove, userId) => this.flagsAdmin.setFlagUserVariant(key, variant, remove, userId),
 				setLocalFlagOverride: (key, variant, payload) => this.flagsAdmin.setLocalFlagOverride(key, variant, payload),
 				clearLocalFlagOverrides: () => this.flagsAdmin.clearLocalFlagOverrides(),
-				clearHistory: () => {
-					this.eventsHistory = [];
-					this.notifyDevTools();
-				},
 				refreshVersions: () => this.refreshBackendVersions(),
 				getStorageInfo: (opts) => this.getStorageInfo(opts),
 				requestPersistentStorage: () => this.requestPersistentStorage(),
@@ -4139,674 +4718,319 @@ function* ensureRegistered(env, opts = {}) {
 				});
 				return;
 			}
-			yield fx.timer.set("ensure-registered", AUTH_READY_RETRY_MS, {
-				type: "EnsureRegistered",
-				requireAuth: true,
-				attempt
-			});
-			return;
-		}
-	}
-	for (const hash of hashes) yield fx.dispatch({
-		type: "RegisterRemote",
-		hash
-	});
-}
-const stmt = (results, i) => results[i];
-/**
-* The SSP answers a registration whose shape is not on the query allowlist
-* with HTTP 403 `{"error":"not_allowlisted"}`. It reaches the client as the
-* `fn::query::register` statement error carrying SurrealDB's http error text
-* (status reason and/or body), and no retry can change the answer.
-*/
-const isNotAllowlisted = (error) => /not_allowlisted|\b403\b|forbidden/i.test(String(error?.message ?? error));
-/**
-* One remote registration: `fn::query::register` plus the edge/meta/children
-* read in ONE request, then membership application. Concurrent with every
-* other registration; retried on its own backoff; stops when the entry is
-* gone.
-*/
-function* registerRemote(env, hash, retry = false) {
-	const state = yield fx.state.read((s) => s);
-	const entry = state.queries.get(hash);
-	if (!entry) return;
-	const { remote } = entry.lifecycle;
-	if (remote === "registered" || remote === "failed" || remote === "registering" && !retry) return;
-	yield fx.state.update(compose(applyLifecycle(hash, { type: "remote-registering" }), applyLifecycle(hash, { type: "fetch-begin" })));
-	try {
-		const table = listRefTable(env, state);
-		const results = yield fx.remote.query(registerSelect(table), registerVars({
-			id: entry.def.id,
-			surql: entry.def.surql,
-			params: { ...entry.def.params },
-			ttl: entry.def.ttl
-		}), env.remoteTimeoutMs);
-		if (!(yield fx.state.read((s) => s.queries.has(hash)))) return;
-		const register = stmt(results, 0);
-		if (!register || register.status === "ERR") throw new Error(register?.status === "ERR" ? register.error : "register returned nothing");
-		const answer = (r) => r?.status === "OK" ? r.result : FAILED;
-		const snap = snapshotFromSingle(answer(stmt(results, 1)), answer(stmt(results, 2)), answer(stmt(results, 3)));
-		if (!snap) {
-			yield fx.state.update(compose(applyLifecycle(hash, { type: "remote-registered" }), resetRegisterAttempts(hash)));
-			yield fx.emit({
-				type: "log",
-				level: "debug",
-				message: "registration read-back did not answer; re-reading membership",
-				data: { hash }
-			});
-			yield* markMembershipDirty([hash]);
-			yield fx.dispatch({
-				type: "SyncOutcome",
-				ok: false,
-				error: "registration read-back failed"
-			});
-			return;
-		}
-		if ((yield* applyMembership(hash, snap.primary, snap.meta)) === "ignored" && snap.meta.present && snap.meta.state === "materializing") {
-			yield fx.state.update(compose(markMembershipDirty$1([hash]), setMembershipReread(hash, 1)));
-			yield fx.timer.set("membership", 150, { type: "ReadDirtyMembership" });
-		}
-		yield* applySubqueryChildren(hash, snap.subquery);
-		yield fx.state.update(compose(applyLifecycle(hash, { type: "remote-registered" }), resetRegisterAttempts(hash)));
-		yield fx.dispatch({
-			type: "SyncOutcome",
-			ok: true
-		});
-	} catch (error) {
-		const current = yield fx.state.read((s) => s.queries.get(hash));
-		if (!current) return;
-		if (isNotAllowlisted(error)) {
-			yield fx.state.update(applyLifecycle(hash, { type: "remote-failed" }));
-			yield fx.emit({
-				type: "log",
-				level: "error",
-				message: "query refused: not allowlisted",
-				data: {
-					hash,
-					table: entry.def.tableName,
-					surql: entry.def.surql,
-					params: Object.keys(entry.def.params),
-					hint: "Add or regenerate the query allowlist: spky generate, then spky deploy (or restart spky dev)."
-				}
-			});
-			yield fx.dispatch({
-				type: "SyncOutcome",
-				ok: false,
-				error
-			});
-			return;
-		}
-		const attempts = current.registerAttempts + 1;
-		yield fx.state.update(bumpRegisterAttempts(hash));
-		yield fx.emit({
-			type: "log",
-			level: "warn",
-			message: "remote registration failed",
-			data: {
-				hash,
-				attempts,
-				error
-			}
-		});
-		yield fx.dispatch({
-			type: "SyncOutcome",
-			ok: false,
-			error
-		});
-		if (attempts >= REGISTER_MAX_RETRIES) yield fx.state.update(applyLifecycle(hash, { type: "remote-failed" }));
-		else yield fx.timer.set(`register:${hash}`, backoffMs(attempts), {
-			type: "RegisterRemote",
-			hash,
-			retry: true
-		});
-	} finally {
-		if (yield fx.state.read((s) => s.queries.has(hash))) yield fx.state.update(applyLifecycle(hash, { type: "fetch-end" }));
-	}
-}
-
-//#endregion
-//#region src/query/lifecycle.saga.ts
-/**
-* One tick for every query in state: evict the ones nobody has watched for a
-* ttl, heartbeat the rest in one request, notice reclaimed rows. Reschedules
-* itself at half the shortest ttl.
-*/
-function* lifecycleTick(env) {
-	const now = yield fx.now();
-	const state = yield fx.state.read((s) => s);
-	for (const hash of evictable(state, now)) yield* evictQuery(hash);
-	const remaining = yield fx.state.read((s) => [...s.queries.values()].filter((e) => e.lifecycle.remote === "registered"));
-	if (remaining.length > 0) {
-		const beat = heartbeatBatch(remaining.map((e) => e.def.id));
-		try {
-			const results = yield fx.remote.query(beat.sql, beat.vars, env.remoteTimeoutMs);
-			let reclaimed = 0;
-			for (let i = 0; i < remaining.length; i++) {
-				const r = results[i];
-				if (r?.status === "OK" && heartbeatRowGone(r.result)) {
-					reclaimed++;
-					yield fx.state.update(applyLifecycle(remaining[i].def.hash, { type: "remote-dropped" }));
-				}
-			}
-			yield fx.state.update(stampHeartbeat(remaining.map((e) => e.def.hash), now));
-			if (reclaimed > 0) {
-				yield fx.emit({
-					type: "log",
-					level: "warn",
-					message: "query rows reclaimed by the server; re-registering",
-					data: { reclaimed }
-				});
-				yield fx.dispatch({ type: "EnsureRegistered" });
-			}
-			yield fx.dispatch({
-				type: "SyncOutcome",
-				ok: true
-			});
-		} catch (error) {
-			yield fx.dispatch({
-				type: "SyncOutcome",
-				ok: false,
-				error
-			});
-		}
-	}
-	const ttl = yield fx.state.read((s) => shortestTtlMs(s));
-	yield fx.timer.set("lifecycle", Math.floor((ttl ?? env.defaultTtlMs) * TTL_HEARTBEAT_FRACTION), { type: "LifecycleTick" });
-}
-/** Free a query's local view and forget it. The server row expires by TTL. */
-function* evictQuery(hash) {
-	if (!(yield fx.state.read((s) => s.queries.has(hash)))) return;
-	try {
-		yield fx.ssp.unregister(hash);
-	} catch (error) {
-		yield fx.emit({
-			type: "log",
-			level: "debug",
-			message: "unregister failed",
-			data: {
-				hash,
-				error
-			}
-		});
+			yield fx.timer.set("ensure-registered", AUTH_READY_RETRY_MS, {
+				type: "EnsureRegistered",
+				requireAuth: true,
+				attempt
+			});
+			return;
+		}
 	}
-	yield fx.state.update(removeQuery(hash));
-	yield fx.emit({
-		type: "query:evicted",
+	for (const hash of hashes) yield fx.dispatch({
+		type: "RegisterRemote",
 		hash
 	});
 }
-/** Drop acked outbox items membership never named within the grace window. */
-function* ackPrune() {
-	const now = yield fx.now();
-	yield fx.state.update(outboxPruneAcked(now, ACK_GRACE_MS));
-	if (yield fx.state.read((s) => s.outbox.some((i) => i.status === "acked"))) yield fx.timer.set("ack-prune", ACK_GRACE_MS, { type: "AckPrune" });
-}
-/** Every `_00_view` row, parsed. Throws when the read fails. */
-function* readViews() {
-	const res = yield fx.local.query(readViewRows());
-	return parseViewIndex(Array.isArray(res) ? res[0] : void 0);
-}
-const indexOf = (rows) => new Map(rows.map((r) => [r.key, r.ids]));
+const stmt = (results, i) => results[i];
 /**
-* Load the durable view index (boot, bucket switch). A failed read leaves it
-* empty, which fails closed: cold scans paint nothing until the server answers.
+* The SSP answers a registration whose shape is not on the query allowlist
+* with HTTP 403 `{"error":"not_allowlisted"}`. It reaches the client as the
+* `fn::query::register` statement error carrying SurrealDB's http error text
+* (status reason and/or body), and no retry can change the answer.
 */
-function* loadViews() {
-	try {
-		yield fx.state.update(reloadViews(indexOf(yield* readViews())));
-	} catch (error) {
-		yield fx.emit({
-			type: "log",
-			level: "warn",
-			message: "view index read failed",
-			data: { error }
-		});
-	}
-}
-const tableOf$1 = (id) => id.slice(0, id.indexOf(":"));
+const isNotAllowlisted = (error) => /not_allowlisted|\b403\b|forbidden/i.test(String(error?.message ?? error));
 /**
-* Orphan collection, `GC_BOOT_DELAY_MS` after boot and then every
-* `GC_INTERVAL_MS`. Re-reads every `_00_view` row into the index, retires the
-* rows no query has resolved for `VIEW_RETENTION_MS`, then deletes the bodies
-* nothing retains (see `retained`) from the store and the circuit, a chunk at
-* a time. Only a leader or solo tab deletes, and a leader relays the deletes
-* so followers drop the rows too; a follower only refreshes its index.
+* One remote registration: `fn::query::register` plus the edge/meta/children
+* read in ONE request, then membership application. Concurrent with every
+* other registration; retried on its own backoff; stops when the entry is
+* gone.
 */
-function* gcTick() {
-	yield fx.state.wait((s) => s.primed);
+function* registerRemote(env, hash, retry = false) {
+	const state = yield fx.state.read((s) => s);
+	const entry = state.queries.get(hash);
+	if (!entry) return;
+	const { remote } = entry.lifecycle;
+	if (remote === "registered" || remote === "failed" || remote === "registering" && !retry) return;
+	yield fx.state.update(compose(applyLifecycle(hash, { type: "remote-registering" }), applyLifecycle(hash, { type: "fetch-begin" })));
 	try {
-		const rows = yield* readViews();
-		const [role, bucket, held] = yield fx.state.read((s) => [
-			s.tabRole,
-			s.bucketId,
-			new Set([...s.queries.values()].map((e) => e.def.viewKey))
-		]);
-		const now = yield fx.now();
-		const expired = role === "follower" ? [] : rows.filter((r) => !held.has(r.key) && now - r.updatedAt >= VIEW_RETENTION_MS);
-		const retired = /* @__PURE__ */ new Set();
-		for (let i = 0; i < expired.length; i += GC_CHUNK) {
-			const chunk = expired.slice(i, i + GC_CHUNK);
-			const settled = yield fx.all(chunk.map((r) => fx.local.delete(VIEW_TABLE, viewRecordId(r.key))));
-			chunk.forEach((r, j) => settled[j].ok && retired.add(r.key));
+		const table = listRefTable(env, state);
+		const results = yield fx.remote.query(registerSelect(table), registerVars({
+			id: entry.def.id,
+			surql: entry.def.surql,
+			params: { ...entry.def.params },
+			ttl: entry.def.ttl
+		}), env.remoteTimeoutMs);
+		if (!(yield fx.state.read((s) => s.queries.has(hash)))) return;
+		const register = stmt(results, 0);
+		if (!register || register.status === "ERR") throw new Error(register?.status === "ERR" ? register.error : "register returned nothing");
+		const answer = (r) => r?.status === "OK" ? r.result : FAILED;
+		const snap = snapshotFromSingle(answer(stmt(results, 1)), answer(stmt(results, 2)), answer(stmt(results, 3)));
+		if (!snap) {
+			yield fx.state.update(compose(applyLifecycle(hash, { type: "remote-registered" }), resetRegisterAttempts(hash)));
+			yield fx.emit({
+				type: "log",
+				level: "debug",
+				message: "registration read-back did not answer; re-reading membership",
+				data: { hash }
+			});
+			yield* markMembershipDirty([hash]);
+			yield fx.dispatch({
+				type: "SyncOutcome",
+				ok: false,
+				error: "registration read-back failed"
+			});
+			return;
 		}
-		yield fx.state.update(reloadViews(indexOf(rows.filter((r) => !retired.has(r.key)))));
-		if (role === "follower") return;
-		const removed = yield* collectOrphans(bucket, role === "leader");
-		yield fx.emit({
-			type: "log",
-			level: "info",
-			message: "orphan gc done",
-			data: {
-				removed,
-				retiredViews: retired.size
-			}
+		if ((yield* applyMembership(hash, snap.primary, snap.meta)) === "ignored" && snap.meta.present && snap.meta.state === "materializing") {
+			yield fx.state.update(compose(markMembershipDirty$1([hash]), setMembershipReread(hash, 1)));
+			yield fx.timer.set("membership", 150, { type: "ReadDirtyMembership" });
+		}
+		yield* applySubqueryChildren(hash, snap.subquery);
+		yield fx.state.update(compose(applyLifecycle(hash, { type: "remote-registered" }), resetRegisterAttempts(hash)));
+		yield fx.dispatch({
+			type: "SyncOutcome",
+			ok: true
 		});
 	} catch (error) {
+		const current = yield fx.state.read((s) => s.queries.get(hash));
+		if (!current) return;
+		if (isNotAllowlisted(error)) {
+			yield fx.state.update(applyLifecycle(hash, { type: "remote-failed" }));
+			yield fx.emit({
+				type: "log",
+				level: "error",
+				message: "query refused: not allowlisted",
+				data: {
+					hash,
+					table: entry.def.tableName,
+					surql: entry.def.surql,
+					params: Object.keys(entry.def.params),
+					hint: "Add or regenerate the query allowlist: spky generate, then spky deploy (or restart spky dev)."
+				}
+			});
+			yield fx.dispatch({
+				type: "SyncOutcome",
+				ok: false,
+				error
+			});
+			return;
+		}
+		const attempts = current.registerAttempts + 1;
+		yield fx.state.update(bumpRegisterAttempts(hash));
 		yield fx.emit({
 			type: "log",
 			level: "warn",
-			message: "orphan gc failed",
-			data: { error }
-		});
-	} finally {
-		yield fx.timer.set("gc", GC_INTERVAL_MS, { type: "GcTick" });
-	}
-}
-/**
-* Delete every body nothing retains, `GC_CHUNK` at a time. Each chunk is
-* re-checked against fresh state (a membership committed meanwhile may name
-* an id again) and the sweep stops if the bucket moved under it.
-*/
-function* collectOrphans(bucket, relay) {
-	const candidates = yield fx.state.read((s) => {
-		const keep = retained(s);
-		return [...s.versions.keys()].filter((id) => !keep(id));
-	});
-	let removed = 0;
-	for (let i = 0; i < candidates.length; i += GC_CHUNK) {
-		const chunk = yield fx.state.read((s) => {
-			if (!s.primed || s.bucketId !== bucket) return null;
-			const keep = retained(s);
-			return candidates.slice(i, i + GC_CHUNK).filter((id) => s.versions.has(id) && !keep(id));
-		});
-		if (chunk === null) break;
-		const settled = yield fx.all(chunk.map((id) => fx.local.delete(tableOf$1(id), id)));
-		const done = chunk.filter((_, j) => settled[j].ok);
-		if (done.length === 0) continue;
-		const records = done.map((id) => ({
-			table: tableOf$1(id),
-			op: "DELETE",
-			id,
-			record: {}
-		}));
-		yield fx.state.update(deleteVersions(done));
-		yield fx.ssp.ingest(records);
-		if (relay) yield fx.emit({
-			type: "tabs:broadcast",
-			message: {
-				type: "ingest",
-				records
-			}
-		});
-		removed += done.length;
-	}
-	if (removed > 0) yield fx.dispatch({ type: "FetchRows" });
-	return removed;
-}
-
-//#endregion
-//#region src/mutation/rows.ts
-const PENDING_TABLE = "_00_pending_mutations";
-const FAILED_TABLE = "_00_failed_mutations";
-/** Debounced patches still inside their delay (see `DebounceOptions.flushOnHide`). */
-const PENDING_WRITES_TABLE = "_00_pending_writes";
-const PENDING_ROW_VERSION = 2;
-/**
-* Parse a record id READ BACK FROM THE STORE, stripping SurrealDB's `⟨⟩`
-* escaping (outbox ids contain `_`, so they come back escaped).
-*/
-function parseStoredRecordId(id) {
-	const [table, ...rest] = id.split(":");
-	let raw = rest.join(":");
-	if (raw.startsWith("⟨") && raw.endsWith("⟩")) raw = raw.slice(1, -1);
-	return new RecordId$1(table, raw);
-}
-/** Stable `table:id` string for an id read from the store, escaping removed. */
-const storedIdString = (id) => {
-	if (id instanceof RecordId$1) return `${id.table}:${String(id.id)}`;
-	const rid = parseStoredRecordId(String(id));
-	return `${rid.table}:${rid.id}`;
-};
-/** Timestamp prefix of a v1/v2 mutation id, or `null` for a legacy numeric id. */
-function createdAtFromId(id) {
-	const raw = id.includes(":") ? id.slice(id.indexOf(":") + 1) : id;
-	const m = /^⟨?(\d{13})/.exec(raw);
-	return m ? Number(m[1]) : null;
-}
-/**
-* Read any row shape this table ever had. Legacy rows (`v` missing) lack
-* `tableName`, `createdAt` and `beforeRecord`. A create without `data` is not
-* replayable and returns `null`.
-*/
-function parsePendingRow(row) {
-	if (!row || typeof row !== "object") return null;
-	const r = row;
-	const type = r.mutationType;
-	if (type !== "create" && type !== "update" && type !== "delete") return null;
-	if (typeof r.recordId !== "string" && !(r.recordId instanceof RecordId$1)) return null;
-	const id = storedIdString(r.id);
-	const recordId = typeof r.recordId === "string" ? r.recordId : storedIdString(r.recordId);
-	const data = r.data && typeof r.data === "object" ? r.data : void 0;
-	if (type === "create" && !data) return null;
-	return {
-		id,
-		mutationType: type,
-		recordId,
-		tableName: typeof r.tableName === "string" ? r.tableName : extractTablePart(recordId),
-		data,
-		beforeRecord: r.beforeRecord && typeof r.beforeRecord === "object" ? r.beforeRecord : void 0,
-		createdAt: typeof r.createdAt === "number" ? r.createdAt : createdAtFromId(id) ?? 0,
-		v: typeof r.v === "number" ? r.v : 1
-	};
+			message: "remote registration failed",
+			data: {
+				hash,
+				attempts,
+				error
+			}
+		});
+		yield fx.dispatch({
+			type: "SyncOutcome",
+			ok: false,
+			error
+		});
+		if (attempts >= REGISTER_MAX_RETRIES) yield fx.state.update(applyLifecycle(hash, { type: "remote-failed" }));
+		else yield fx.timer.set(`register:${hash}`, backoffMs(attempts), {
+			type: "RegisterRemote",
+			hash,
+			retry: true
+		});
+	} finally {
+		if (yield fx.state.read((s) => s.queries.has(hash))) yield fx.state.update(applyLifecycle(hash, { type: "fetch-end" }));
+	}
 }
+
+//#endregion
+//#region src/query/lifecycle.saga.ts
 /**
-* Re-type a stored row's payload from the schema before it is pushed. The
-* store keeps JSON, so a `record<user>` field comes back as `'user:x'` and a
-* datetime as a string; the server coerces neither. Unknown keys stay as they
-* are, and a payload the schema rejects is sent raw so the server's answer,
-* not a local throw, decides its fate.
+* One tick for every query in state: evict the ones nobody has watched for a
+* ttl, heartbeat the rest in one request, notice reclaimed rows. Reschedules
+* itself at half the shortest ttl.
 */
-function hydrateRowData(row, columns) {
-	if (!row.data || !columns) return row;
-	try {
-		return {
-			...row,
-			data: parseQueryParams(columns, row.data)
-		};
-	} catch {
-		return row;
+function* lifecycleTick(env) {
+	const now = yield fx.now();
+	const state = yield fx.state.read((s) => s);
+	for (const hash of evictable(state, now)) yield* evictQuery(hash);
+	const remaining = yield fx.state.read((s) => [...s.queries.values()].filter((e) => e.lifecycle.remote === "registered"));
+	if (remaining.length > 0) {
+		const beat = heartbeatBatch(remaining.map((e) => e.def.id));
+		try {
+			const results = yield fx.remote.query(beat.sql, beat.vars, env.remoteTimeoutMs);
+			let reclaimed = 0;
+			for (let i = 0; i < remaining.length; i++) {
+				const r = results[i];
+				if (r?.status === "OK" && heartbeatRowGone(r.result)) {
+					reclaimed++;
+					yield fx.state.update(applyLifecycle(remaining[i].def.hash, { type: "remote-dropped" }));
+				}
+			}
+			yield fx.state.update(stampHeartbeat(remaining.map((e) => e.def.hash), now));
+			if (reclaimed > 0) {
+				yield fx.emit({
+					type: "log",
+					level: "warn",
+					message: "query rows reclaimed by the server; re-registering",
+					data: { reclaimed }
+				});
+				yield fx.dispatch({ type: "EnsureRegistered" });
+			}
+			yield fx.dispatch({
+				type: "SyncOutcome",
+				ok: true
+			});
+		} catch (error) {
+			yield fx.dispatch({
+				type: "SyncOutcome",
+				ok: false,
+				error
+			});
+		}
 	}
+	const ttl = yield fx.state.read((s) => shortestTtlMs(s));
+	yield fx.timer.set("lifecycle", Math.floor((ttl ?? env.defaultTtlMs) * TTL_HEARTBEAT_FRACTION), { type: "LifecycleTick" });
 }
-const toOutboxItem = (row) => ({
-	id: row.id,
-	type: row.mutationType,
-	recordId: row.recordId,
-	table: row.tableName,
-	status: "pending",
-	ackedAt: null,
-	attempts: 0
-});
-/** The `_00_pending_writes` id for a minted mutation id (same suffix). */
-const pendingWriteId = (mutationId) => `${PENDING_WRITES_TABLE}:${mutationId.includes(":") ? mutationId.slice(mutationId.indexOf(":") + 1) : mutationId}`;
-function parsePendingWriteRow(row) {
-	if (!row || typeof row !== "object") return null;
-	const r = row;
-	if (typeof r.recordId !== "string" && !(r.recordId instanceof RecordId$1)) return null;
-	if (!r.data || typeof r.data !== "object") return null;
-	const recordId = typeof r.recordId === "string" ? r.recordId : storedIdString(r.recordId);
-	return {
-		id: storedIdString(r.id),
-		recordId,
-		tableName: typeof r.tableName === "string" ? r.tableName : extractTablePart(recordId),
-		data: r.data,
-		beforeRecord: r.beforeRecord && typeof r.beforeRecord === "object" ? r.beforeRecord : null,
-		flushBy: typeof r.flushBy === "number" ? r.flushBy : 0
-	};
-}
-const loadPendingRows = () => `SELECT * FROM ${PENDING_TABLE} ORDER BY id ASC`;
-const loadPendingWriteRows = () => `SELECT * FROM ${PENDING_WRITES_TABLE}`;
-const loadFailedRows = () => `SELECT * FROM ${FAILED_TABLE} ORDER BY failedAt ASC`;
-const pendingInsert = (type, withData, withBefore) => {
-	const fields = [
-		`mutationType = '${type}'`,
-		"recordId = $id",
-		"tableName = $table",
-		"createdAt = $createdAt",
-		`v = ${PENDING_ROW_VERSION}`
-	];
-	if (withData) fields.push("data = $data");
-	if (withBefore) fields.push("beforeRecord = $before");
-	return `CREATE ONLY $mid SET ${fields.join(", ")}`;
-};
-/** `CREATE` the row and its outbox entry in one transaction; result index 0 is the row. */
-function planCreateTx(input) {
-	const data = input.data ?? {};
-	const keys = Object.keys(data).map((key) => ({
-		key,
-		variable: `data_${key}`
-	}));
-	const vars = {
-		id: input.recordId,
-		mid: input.mutationId,
-		table: input.table,
-		createdAt: input.now,
-		data
-	};
-	for (const { key, variable } of keys) vars[variable] = data[key];
-	return {
-		query: surql.seal(surql.tx([surql.createSet("id", keys), pendingInsert("create", true, false)]), { resultIndex: 0 }),
-		vars
-	};
-}
-/** Bump `_00_rv`, MERGE the patch, write the outbox row (with `beforeRecord`); returns `{ target }`. */
-function planUpdateTx(input) {
-	return {
-		query: surql.seal(surql.tx([
-			surql.updateSet("id", [{ statement: "_00_rv += 1" }]),
-			surql.let("updated", surql.updateMerge("id", "data")),
-			pendingInsert("update", true, true),
-			surql.returnObject([{
-				key: "target",
-				variable: "updated"
-			}])
-		])),
-		vars: {
-			id: input.recordId,
-			mid: input.mutationId,
-			table: input.table,
-			createdAt: input.now,
-			data: input.data ?? {},
-			before: input.before ?? null
-		}
-	};
+/** Free a query's local view and forget it. The server row expires by TTL. */
+function* evictQuery(hash) {
+	if (!(yield fx.state.read((s) => s.queries.has(hash)))) return;
+	try {
+		yield fx.ssp.unregister(hash);
+	} catch (error) {
+		yield fx.emit({
+			type: "log",
+			level: "debug",
+			message: "unregister failed",
+			data: {
+				hash,
+				error
+			}
+		});
+	}
+	yield fx.state.update(removeQuery(hash));
+	yield fx.emit({
+		type: "query:evicted",
+		hash
+	});
 }
-/** DELETE the row and write the outbox entry (with `beforeRecord`). */
-function planDeleteTx(input) {
-	return {
-		query: surql.seal(surql.tx([surql.delete("id"), pendingInsert("delete", false, true)])),
-		vars: {
-			id: input.recordId,
-			mid: input.mutationId,
-			table: input.table,
-			createdAt: input.now,
-			before: input.before ?? null
-		}
-	};
+/** Drop acked outbox items membership never named within the grace window. */
+function* ackPrune() {
+	const now = yield fx.now();
+	yield fx.state.update(outboxPruneAcked(now, ACK_GRACE_MS));
+	if (yield fx.state.read((s) => s.outbox.some((i) => i.status === "acked"))) yield fx.timer.set("ack-prune", ACK_GRACE_MS, { type: "AckPrune" });
 }
-/**
-* Debounced update: bump `_00_rv` and MERGE now; the outbox row comes later.
-* With a `mirror`, the merged patch so far is written to `_00_pending_writes`
-* in the same transaction, so the row never changes without a durable copy of
-* what still has to reach the server.
-*/
-function planLocalOnlyUpdateTx(input) {
-	const statements = [surql.updateSet("id", [{ statement: "_00_rv += 1" }]), surql.let("updated", surql.updateMerge("id", "data"))];
-	if (input.mirror) statements.push(surql.upsert("wid", "wrow"));
-	statements.push(surql.returnObject([{
-		key: "target",
-		variable: "updated"
-	}]));
-	return {
-		query: surql.seal(surql.tx(statements)),
-		vars: input.mirror ? {
-			id: input.recordId,
-			data: input.data,
-			wid: input.mirror.id,
-			wrow: input.mirror.row
-		} : {
-			id: input.recordId,
-			data: input.data
-		}
-	};
+/** Every `_00_view` row, parsed. Throws when the read fails. */
+function* readViews() {
+	const res = yield fx.local.query(readViewRows());
+	return parseViewIndex(Array.isArray(res) ? res[0] : void 0);
 }
+const indexOf = (rows) => new Map(rows.map((r) => [r.key, r.ids]));
 /**
-* The outbox row of a flushed debounced update. With `mirrorId` the
-* `_00_pending_writes` row goes in the same transaction: the patch moves
-* from one table to the other, it is never in both or in neither.
+* Load the durable view index (boot, bucket switch). A failed read leaves it
+* empty, which fails closed: cold scans paint nothing until the server answers.
 */
-function planDeferredOutboxRowTx(input) {
-	const statements = [pendingInsert("update", true, true)];
-	if (input.mirrorId) statements.push(surql.delete("wid"));
-	return {
-		query: surql.seal(surql.tx(statements)),
-		vars: {
-			id: input.recordId,
-			mid: input.mutationId,
-			table: input.table,
-			createdAt: input.now,
-			data: input.data ?? {},
-			before: input.before ?? null,
-			...input.mirrorId ? { wid: input.mirrorId } : {}
-		}
-	};
+function* loadViews() {
+	try {
+		yield fx.state.update(reloadViews(indexOf(yield* readViews())));
+	} catch (error) {
+		yield fx.emit({
+			type: "log",
+			level: "warn",
+			message: "view index read failed",
+			data: { error }
+		});
+	}
 }
+const tableOf$1 = (id) => id.slice(0, id.indexOf(":"));
 /**
-* Many outbox rows as ONE multi-statement request. Statement i answers row i.
-* Each statement is its own transaction on the server, as before.
+* Orphan collection, `GC_BOOT_DELAY_MS` after boot and then every
+* `GC_INTERVAL_MS`. Re-reads every `_00_view` row into the index, retires the
+* rows no query has resolved for `VIEW_RETENTION_MS`, then deletes the bodies
+* nothing retains (see `retained`) from the store and the circuit, a chunk at
+* a time. Only a leader or solo tab deletes, and a leader relays the deletes
+* so followers drop the rows too; a follower only refreshes its index.
 */
-function remoteBatch(rows) {
-	const vars = {};
-	return {
-		sql: rows.map((row, i) => {
-			const rid = parseRecordIdString(row.recordId);
-			vars[`id${i}`] = rid;
-			switch (row.mutationType) {
-				case "create": {
-					const data = row.data ?? {};
-					return `CREATE ONLY $id${i} SET ${Object.keys(data).map((key) => {
-						vars[`d${i}_${key}`] = data[key];
-						return `${key} = $d${i}_${key}`;
-					}).join(", ")}`;
-				}
-				case "update":
-					vars[`data${i}`] = row.data ?? {};
-					return `UPDATE $id${i} MERGE $data${i}`;
-				case "delete": return `DELETE $id${i}`;
+function* gcTick() {
+	yield fx.state.wait((s) => s.primed);
+	try {
+		const rows = yield* readViews();
+		const [role, bucket, held] = yield fx.state.read((s) => [
+			s.tabRole,
+			s.bucketId,
+			new Set([...s.queries.values()].map((e) => e.def.viewKey))
+		]);
+		const now = yield fx.now();
+		const expired = role === "follower" ? [] : rows.filter((r) => !held.has(r.key) && now - r.updatedAt >= VIEW_RETENTION_MS);
+		const retired = /* @__PURE__ */ new Set();
+		for (let i = 0; i < expired.length; i += GC_CHUNK) {
+			const chunk = expired.slice(i, i + GC_CHUNK);
+			const settled = yield fx.all(chunk.map((r) => fx.local.delete(VIEW_TABLE, viewRecordId(r.key))));
+			chunk.forEach((r, j) => settled[j].ok && retired.add(r.key));
+		}
+		yield fx.state.update(reloadViews(indexOf(rows.filter((r) => !retired.has(r.key)))));
+		if (role === "follower") return;
+		const removed = yield* collectOrphans(bucket, role === "leader");
+		yield fx.emit({
+			type: "log",
+			level: "info",
+			message: "orphan gc done",
+			data: {
+				removed,
+				retiredViews: retired.size
 			}
-		}).join(";\n"),
-		vars
-	};
+		});
+	} catch (error) {
+		yield fx.emit({
+			type: "log",
+			level: "warn",
+			message: "orphan gc failed",
+			data: { error }
+		});
+	} finally {
+		yield fx.timer.set("gc", GC_INTERVAL_MS, { type: "GcTick" });
+	}
 }
 /**
-* How to undo a rejected mutation locally. A create is deleted; an update or
-* delete is restored from `beforeRecord` (REPLACE, so the pre-bump `_00_rv`
-* comes back). Without a `beforeRecord` nothing can be restored.
+* Delete every body nothing retains, `GC_CHUNK` at a time. Each chunk is
+* re-checked against fresh state (a membership committed meanwhile may name
+* an id again) and the sweep stops if the bucket moved under it.
 */
-function planRevert(row, before) {
-	const rid = parseRecordIdString(row.recordId);
-	if (row.mutationType === "create") return {
-		tx: {
-			query: surql.seal(surql.tx([surql.delete("id")])),
-			vars: { id: rid }
-		},
-		circuit: {
-			table: row.tableName,
+function* collectOrphans(bucket, relay) {
+	const candidates = yield fx.state.read((s) => {
+		const keep = retained(s);
+		return [...s.versions.keys()].filter((id) => !keep(id));
+	});
+	let removed = 0;
+	for (let i = 0; i < candidates.length; i += GC_CHUNK) {
+		const chunk = yield fx.state.read((s) => {
+			if (!s.primed || s.bucketId !== bucket) return null;
+			const keep = retained(s);
+			return candidates.slice(i, i + GC_CHUNK).filter((id) => s.versions.has(id) && !keep(id));
+		});
+		if (chunk === null) break;
+		const settled = yield fx.all(chunk.map((id) => fx.local.delete(tableOf$1(id), id)));
+		const done = chunk.filter((_, j) => settled[j].ok);
+		if (done.length === 0) continue;
+		const records = done.map((id) => ({
+			table: tableOf$1(id),
 			op: "DELETE",
-			id: row.recordId,
-			record: row.data ?? {}
-		},
-		revert: "full"
-	};
-	if (!before) return {
-		tx: null,
-		circuit: {
-			table: row.tableName,
-			op: "UPDATE",
-			id: row.recordId,
+			id,
 			record: {}
-		},
-		revert: "partial"
-	};
-	const { id: _id, ...content } = before;
-	return {
-		tx: {
-			query: surql.seal(surql.tx([surql.upsert("id", "content")])),
-			vars: {
-				id: rid,
-				content
-			}
-		},
-		circuit: {
-			table: row.tableName,
-			op: row.mutationType === "delete" ? "CREATE" : "UPDATE",
-			id: row.recordId,
-			record: {
-				...before,
-				id: rid
+		}));
+		yield fx.state.update(deleteVersions(done));
+		yield fx.ssp.ingest(records);
+		if (relay) yield fx.emit({
+			type: "tabs:broadcast",
+			message: {
+				type: "ingest",
+				records
 			}
-		},
-		revert: "full"
-	};
-}
-const failedRecordId = (mutationId) => new RecordId$1(FAILED_TABLE, mutationId.slice(mutationId.indexOf(":") + 1));
-function buildFailedRow(row, error, before, attempts, now, revert) {
-	return {
-		id: row.id,
-		mutationType: row.mutationType,
-		recordId: row.recordId,
-		tableName: row.tableName,
-		data: row.data,
-		beforeRecord: before,
-		error,
-		attempts,
-		createdAt: row.createdAt,
-		failedAt: now,
-		revert
-	};
-}
-/** ONE transaction: write the tray row, delete the pending row. */
-function moveToFailedTx(failed) {
-	const { id: _id, ...content } = failed;
-	return {
-		query: surql.seal(surql.tx([surql.create("fid", "failed"), surql.delete("mid")])),
-		vars: {
-			fid: failedRecordId(failed.id),
-			failed: content,
-			mid: parseStoredRecordId(failed.id)
-		}
-	};
-}
-const deletePendingRow = (mutationId) => ({
-	sql: "DELETE $mid",
-	vars: { mid: parseStoredRecordId(mutationId) }
-});
-const deleteFailedRow = (mutationId) => ({
-	sql: "DELETE $fid",
-	vars: { fid: failedRecordId(mutationId) }
-});
-function parseFailedRow(row) {
-	if (!row || typeof row !== "object") return null;
-	const r = row;
-	const type = r.mutationType;
-	if (type !== "create" && type !== "update" && type !== "delete") return null;
-	if (typeof r.recordId !== "string") return null;
-	const err = r.error ?? {};
-	return {
-		id: storedIdString(r.id).replace(`${FAILED_TABLE}:`, `${PENDING_TABLE}:`),
-		mutationType: type,
-		recordId: r.recordId,
-		tableName: typeof r.tableName === "string" ? r.tableName : extractTablePart(r.recordId),
-		data: r.data && typeof r.data === "object" ? r.data : void 0,
-		beforeRecord: r.beforeRecord && typeof r.beforeRecord === "object" ? r.beforeRecord : null,
-		error: {
-			message: typeof err.message === "string" ? err.message : "unknown",
-			kind: err.kind === "unreplayable" ? "unreplayable" : "application"
-		},
-		attempts: typeof r.attempts === "number" ? r.attempts : 0,
-		createdAt: typeof r.createdAt === "number" ? r.createdAt : 0,
-		failedAt: typeof r.failedAt === "number" ? r.failedAt : 0,
-		revert: r.revert === "partial" || r.revert === "none" ? r.revert : "full"
-	};
+		});
+		removed += done.length;
+	}
+	if (removed > 0) yield fx.dispatch({ type: "FetchRows" });
+	return removed;
 }
 
 //#endregion
@@ -7189,18 +7413,155 @@ var Runtime = class {
 
 //#endregion
 //#region src/services/logger/index.ts
-function createLogger(level = "info", transmit) {
+const LEVELS = pino.levels.values;
+const CAPTURE_KEY = "sp00ky:devtools:logCapture";
+function isLevel(value) {
+	return typeof value === "string" && value in LEVELS;
+}
+/**
+* JSON for a log object that can never throw into the call site: Errors keep
+* their message and stack (plain `JSON.stringify` prints `{}`), bigints become
+* strings, and a cycle prints `[Circular]` instead of throwing.
+*/
+function stringifyLog(o) {
+	const ancestors = [];
+	try {
+		return JSON.stringify(o, function(_key, value) {
+			if (typeof value === "bigint") return value.toString();
+			if (value instanceof Error) return {
+				type: value.name,
+				message: value.message,
+				stack: value.stack
+			};
+			if (typeof value !== "object" || value === null) return value;
+			while (ancestors.length > 0 && ancestors.at(-1) !== this) ancestors.pop();
+			if (ancestors.includes(value)) return "[Circular]";
+			ancestors.push(value);
+			return value;
+		});
+	} catch {
+		const msg = o?.msg;
+		return JSON.stringify({ msg: typeof msg === "string" ? msg : "[unserializable log object]" });
+	}
+}
+/**
+* The page-side log buffer behind the DevTools Logs tab. Always on and
+* bounded: a line costs the JSON the console write produces anyway, and a
+* panel opened after boot still sees the boot.
+*
+* It also owns the logger's level. The console prints at the configured level
+* only; `setCaptureLevel` changes what is RECORDED (debug without flooding the
+* console), live on every child logger, and keeps it for this tab's session so
+* a reload captures its boot at that level too.
+*/
+var LogTap = class LogTap {
+	static CAPACITY = 500;
+	static LINE_MAX = 4e3;
+	ring = [];
+	seq = 0;
+	/** `seq` at the last `clear()`: lines up to here are gone on purpose, not dropped. */
+	clearedThrough = 0;
+	listeners = /* @__PURE__ */ new Set();
+	loggers = [];
+	captureLevelValue;
+	constructor(consoleLevel) {
+		this.consoleLevel = consoleLevel;
+		this.captureLevelValue = consoleLevel;
+		try {
+			const saved = typeof sessionStorage !== "undefined" ? sessionStorage.getItem(CAPTURE_KEY) : null;
+			if (isLevel(saved)) this.captureLevelValue = saved;
+		} catch {}
+	}
+	/** `seq` of the newest captured line. */
+	get head() {
+		return this.seq;
+	}
+	get captureLevel() {
+		return this.captureLevelValue;
+	}
+	/** What pino has to produce for both the console and the buffer. */
+	get effectiveLevel() {
+		return LEVELS[this.captureLevelValue] < LEVELS[this.consoleLevel] ? this.captureLevelValue : this.consoleLevel;
+	}
+	/** Whether the console prints a line at this numeric level. */
+	printsToConsole(level) {
+		return level >= LEVELS[this.consoleLevel];
+	}
+	/** Remember a logger (the root and every child) so a level change reaches it. */
+	track(logger) {
+		this.loggers.push(new WeakRef(logger));
+	}
+	setCaptureLevel(level) {
+		if (!isLevel(level)) throw new Error(`unknown log level: ${String(level)}`);
+		this.captureLevelValue = level;
+		try {
+			if (typeof sessionStorage !== "undefined") if (level === this.consoleLevel) sessionStorage.removeItem(CAPTURE_KEY);
+			else sessionStorage.setItem(CAPTURE_KEY, level);
+		} catch {}
+		const effective = this.effectiveLevel;
+		for (let i = this.loggers.length - 1; i >= 0; i--) {
+			const logger = this.loggers[i].deref();
+			if (logger) logger.level = effective;
+			else this.loggers.splice(i, 1);
+		}
+	}
+	record(o, line) {
+		const level = typeof o.level === "number" ? o.level : LEVELS.info;
+		if (level < LEVELS[this.captureLevelValue]) return;
+		this.ring.push({
+			seq: ++this.seq,
+			time: typeof o.time === "number" ? o.time : Date.now(),
+			level,
+			msg: typeof o.msg === "string" ? o.msg : "",
+			line: line.length > LogTap.LINE_MAX ? `${line.slice(0, LogTap.LINE_MAX)}…` : line
+		});
+		if (this.ring.length > LogTap.CAPACITY) this.ring.shift();
+		for (const cb of this.listeners) try {
+			cb();
+		} catch {}
+	}
+	/** Lines after `after` (0 = everything still buffered), oldest first. */
+	read(after = 0, limit = LogTap.CAPACITY) {
+		const first = this.ring[0]?.seq ?? this.seq + 1;
+		const fresh = this.ring.filter((e) => e.seq > after);
+		return {
+			entries: fresh.slice(Math.max(0, fresh.length - limit)),
+			head: this.seq,
+			dropped: Math.max(0, first - Math.max(after, this.clearedThrough) - 1),
+			consoleLevel: this.consoleLevel,
+			captureLevel: this.captureLevelValue
+		};
+	}
+	clear() {
+		this.ring.length = 0;
+		this.clearedThrough = this.seq;
+	}
+	/** Called synchronously inside the log call: keep it cheap, never log from it. */
+	subscribe(cb) {
+		this.listeners.add(cb);
+		return () => void this.listeners.delete(cb);
+	}
+};
+function createLogger(level = "info", transmit, tap) {
 	const browserConfig = {
 		asObject: true,
 		write: (o) => {
-			console.log(JSON.stringify(o));
+			const line = stringifyLog(o);
+			if (!tap || tap.printsToConsole(o?.level)) console.log(line);
+			tap?.record(o, line);
 		}
 	};
-	if (transmit) browserConfig.transmit = transmit;
-	return pino({
-		level,
-		browser: browserConfig
+	if (transmit) browserConfig.transmit = {
+		...transmit,
+		level: transmit.level ?? level
+	};
+	const logger = pino({
+		level: tap ? tap.effectiveLevel : level,
+		browser: browserConfig,
+		onChild: (child) => tap?.track(child)
 	});
+	tap?.track(logger);
+	return logger;
 }
 
 //#endregion
@@ -7313,7 +7674,7 @@ var AbstractDatabaseService = class {
 			await this.beforeQuery();
 			const startTime = performance.now();
 			try {
-				this.logger.debug({
+				this.logger.trace({
 					query,
 					vars,
 					Category: "sp00ky-client::Database::query"
@@ -14172,7 +14533,8 @@ function mintSalt() {
 	return `s${Date.now().toString(36)}${Math.random().toString(36).slice(2, 12)}`;
 }
 function createServices(config) {
-	const logger = createLogger(config.logLevel ?? "info", config.otelTransmit);
+	const logTap = new LogTap(config.logLevel ?? "info");
+	const logger = createLogger(config.logLevel ?? "info", config.otelTransmit, logTap);
 	if (config.crdt) preloadLoro();
 	const tabsSupport = detectSharedTabsSupport(config);
 	const local = createLocalEngine(config.localEngine, config.database, logger, { shared: tabsSupport.supported });
@@ -14205,6 +14567,7 @@ function createServices(config) {
 	const tabId = typeof crypto !== "undefined" && crypto.randomUUID ? crypto.randomUUID() : `tab_${Math.random().toString(36).slice(2)}`;
 	return {
 		logger,
+		logTap,
 		local,
 		remote,
 		connectionSupervisor,
@@ -14225,7 +14588,7 @@ function createTabsCoordinator(config, s, host) {
 	return new TabsCoordinator({
 		tabId: s.tabId,
 		fingerprint: computeTabsFingerprint({
-			coreVersion: "0.0.1-canary.290",
+			coreVersion: "0.0.1-canary.292",
 			schemaHash: hash53(config.schemaSurql),
 			endpoint: config.database.endpoint ?? "",
 			namespace: config.database.namespace,
@@ -14811,6 +15174,8 @@ const UNKNOWN_STORAGE_HEALTH = Object.freeze({
 	status: "unknown",
 	fallback: false
 });
+/** Longest SurrealQL a statement log line shows as its message. */
+const STATEMENT_MSG_MAX = 160;
 /**
 * The public client. Every method is a thin translation into a saga run, a
 * state read, or a subscription on the runtime; the engine's behaviour lives
@@ -14915,6 +15280,13 @@ var Sp00kyClient = class {
 		this.devTools.setFeatureFlagOverrides(this.featureFlags);
 		s.streamProcessor.addReceiver(this.devTools);
 		this.devTools.setBlobInfoProvider(() => s.blobs.stats());
+		this.devTools.setMutationSource({
+			state: () => this.runtime.state,
+			listFailed: () => this.listFailedMutations(),
+			retryFailed: (id) => this.retryFailedMutation(id),
+			discardFailed: (id) => this.discardFailedMutation(id)
+		});
+		if (s.logTap) this.devTools.setLogTap(s.logTap);
 		if (config.sharedTabs) this.devTools.setTabsInfoProvider(() => {
 			const c = s.tabs;
 			if (!this.sharedActive || !c) return {
@@ -14967,31 +15339,75 @@ var Sp00kyClient = class {
 			if (e.type === "tabs:sendTo" && this.hub) this.hub.sendTo(e.tabId, e.message);
 		});
 		this.runtime.on("*", (e) => this.forwardToDevTools(e));
-		s.local.getEvents().subscribe("DATABASE_LOCAL_QUERY", (event) => this.devTools.logEvent("LOCAL_QUERY", event.payload));
-		s.remote.getEvents().subscribe("DATABASE_REMOTE_QUERY", (event) => this.devTools.logEvent("REMOTE_QUERY", event.payload));
+		const logStatement = (store) => (event) => {
+			if (!s.logger.isLevelEnabled("debug")) return;
+			const q = event.payload ?? {};
+			const sql = String(q.query ?? "").replace(/\s+/g, " ").trim();
+			const cut = sql.length > STATEMENT_MSG_MAX;
+			s.logger.debug({
+				store,
+				...cut ? { query: q.query } : {},
+				vars: q.vars,
+				ms: Math.round((q.duration ?? 0) * 10) / 10,
+				ok: q.success !== false,
+				error: q.error,
+				Category: `sp00ky-client::${store}`
+			}, cut ? `${sql.slice(0, STATEMENT_MSG_MAX)}…` : sql);
+		};
+		s.local.getEvents().subscribe("DATABASE_LOCAL_QUERY", logStatement("local"));
+		s.remote.getEvents().subscribe("DATABASE_REMOTE_QUERY", logStatement("remote"));
 	}
+	/** Runtime events the DevTools panel follows; query transitions also go to the log. */
 	forwardToDevTools(e) {
+		const log = this.services.logger;
 		switch (e.type) {
 			case "query:status":
-				this.devTools.logEvent("QUERY_STATUS_CHANGED", {
-					queryHash: e.hash,
-					status: e.status
-				});
+				log.debug({
+					hash: e.hash,
+					status: e.status,
+					Category: "sp00ky-client::query"
+				}, "Query status");
+				this.devTools.onStateChanged();
 				break;
 			case "query:authority":
-				this.devTools.logEvent("QUERY_AUTHORITY_CHANGED", {
-					queryHash: e.hash,
-					known: e.known
-				});
+				log.debug({
+					hash: e.hash,
+					known: e.known,
+					Category: "sp00ky-client::query"
+				}, e.known ? "Query membership known" : "Query membership unknown");
+				this.devTools.onStateChanged();
 				break;
 			case "query:view-lost":
-				this.devTools.logEvent("QUERY_VIEW_LOST", { queryHash: e.hash });
+				log.info({
+					hash: e.hash,
+					Category: "sp00ky-client::query"
+				}, "Query view lost on the server; re-registering");
+				this.devTools.onStateChanged();
 				break;
 			case "mutation:event":
 				this.devTools.onMutation([e.event]);
 				break;
-			case "devtools":
-				this.devTools.logEvent(e.name, e.data);
+			case "mutation:settled":
+				this.devTools.onMutationOutcome({
+					mutationId: e.mutationId,
+					recordId: e.recordId,
+					eventType: e.eventType,
+					status: "synced"
+				});
+				break;
+			case "mutation:rolled-back":
+				this.devTools.onMutationOutcome({
+					mutationId: e.mutationId,
+					recordId: e.recordId,
+					eventType: e.eventType,
+					status: "rolled-back",
+					error: e.error
+				});
+				break;
+			case "tray:changed":
+			case "health:changed":
+			case "activity:changed":
+				this.devTools.onStateChanged();
 				break;
 			default: break;
 		}