@spooky-sync/core 0.0.1-canary.133 → 0.0.1-canary.135

package/dist/index.js

@@ -1,3 +1,4 @@
+import { a as serializeRow, i as reviveRow, n as renderOrderSql, o as resolveRelations, r as renderWhereSql, s as stableKey, t as project } from "./sqlite-plan-sql.js";
 import { DateTime, Duration, RecordId, Surreal, Uuid, applyDiagnostics, createRemoteEngines } from "surrealdb";
 import { createWasmWorkerEngines } from "@surrealdb/wasm";
 import { QueryBuilder, RecordId as RecordId$1, cyrb53 } from "@spooky-sync/query-builder";
@@ -1046,130 +1047,6 @@ var LocalMigrator = class {
 	}
 };
 
-//#endregion
-//#region src/services/database/cache-engine.ts
-/** Thrown when relation decomposition nests past {@link MAX_RELATION_DEPTH} —
-*  a guard against a cyclic schema producing unbounded fan-out. */
-var RelationCycleError = class extends Error {
-	constructor(path) {
-		super(`Relation nesting exceeded safe depth; possible cyclic schema: ${path.join(" -> ")}`);
-		this.name = "RelationCycleError";
-	}
-};
-/** Defensive ceiling on relation nesting depth. A finite plan tree never hits
-*  this in practice; it exists so a malformed/cyclic plan fails loudly instead
-*  of running away. */
-const MAX_RELATION_DEPTH = 12;
-
-//#endregion
-//#region src/services/database/relation-resolver.ts
-/**
-* Resolve the `.related()` tree of a query by **level-ordered, batched
-* fan-out** — the engine-neutral replacement for SurrealQL's nested
-* `(SELECT..) AS alias` projections. One batched fetch per relation per level
-* (never per-row N+1, never a flat join); grouping, per-parent ORDER/LIMIT and
-* attachment happen in JS.
-*
-* Correlation (mirrors `buildSubquery`):
-* - `one`  → parent[`foreignKeyField`] = child.id  → attach `bucket[0] ?? null`
-* - `many` → child[`foreignKeyField`] = parent.id   → attach `bucket`
-*
-* Cross-level dependency is handled by ordering: a child's correlation key is a
-* field on its parent, known only once the parent level has resolved, so each
-* level's batch runs after the previous level's rows exist. `parents` is
-* mutated in place — each resolved alias is appended LAST so key order matches
-* SurrealQL's `SELECT *, <sub> AS alias` (base fields, then alias).
-*
-* @throws {RelationCycleError} if nesting exceeds {@link MAX_RELATION_DEPTH}.
-*/
-async function resolveRelations(parents, relations, fetcher, depth = 0, path = []) {
-	if (!relations || relations.length === 0 || parents.length === 0) return;
-	if (depth >= MAX_RELATION_DEPTH) throw new RelationCycleError([...path, relations.map((r) => r.alias).join("|")]);
-	await Promise.all(relations.map((relation) => resolveOne(parents, relation, fetcher, depth, path)));
-}
-async function resolveOne(parents, relation, fetcher, depth, path) {
-	const isOne = relation.cardinality === "one";
-	const matchField = isOne ? "id" : relation.foreignKeyField;
-	const parentKeyOf = (parent) => isOne ? parent[relation.foreignKeyField] : parent["id"];
-	const keySet = /* @__PURE__ */ new Map();
-	for (const parent of parents) {
-		const key = parentKeyOf(parent);
-		if (key == null) continue;
-		const k = stableKey(key);
-		if (!keySet.has(k)) keySet.set(k, key);
-	}
-	const grouped = /* @__PURE__ */ new Map();
-	if (keySet.size > 0) {
-		const children = await fetcher.fetchRelation({
-			table: relation.table,
-			matchField,
-			keys: [...keySet.values()],
-			where: relation.where,
-			orderBy: relation.orderBy,
-			select: relation.select
-		});
-		await resolveRelations(children, relation.relations, fetcher, depth + 1, [...path, relation.alias]);
-		for (const child of children) {
-			const k = stableKey(child[matchField]);
-			const bucket = grouped.get(k);
-			if (bucket) bucket.push(child);
-			else grouped.set(k, [child]);
-		}
-	}
-	for (const parent of parents) {
-		const key = parentKeyOf(parent);
-		let bucket = key == null ? [] : grouped.get(stableKey(key)) ?? [];
-		if (relation.orderBy && relation.orderBy.length > 0) bucket = sortRows(bucket, relation.orderBy);
-		if (relation.limit !== void 0) bucket = bucket.slice(0, relation.limit);
-		parent[relation.alias] = isOne ? bucket[0] ?? null : bucket;
-	}
-}
-/**
-* Stable grouping key for a correlation value. A `RecordId` (duck-typed to
-* avoid a hard surrealdb dependency here) and its `table:id` string form must
-* collapse to the same key so a parent FK stored either way matches the child.
-*/
-function stableKey(value) {
-	if (value == null) return "\0null";
-	if (typeof value === "string") return value;
-	if (typeof value === "number" || typeof value === "boolean" || typeof value === "bigint") return String(value);
-	if (typeof value === "object") {
-		const rid = value;
-		if (rid.tb !== void 0 && rid.id !== void 0) return `${String(rid.tb)}:${stableKey(rid.id)}`;
-		if (typeof rid.toString === "function") {
-			const s = rid.toString();
-			if (s !== "[object Object]") return s;
-		}
-		return JSON.stringify(value);
-	}
-	return String(value);
-}
-/**
-* Stable, multi-key sort matching SurrealQL `ORDER BY` semantics closely
-* enough for cache display order: ascending null-last, type-aware compare, and
-* a stable tiebreak (original index) so equal rows keep input order.
-*/
-function sortRows(rows, orderBy) {
-	const indexed = rows.map((row, i) => [row, i]);
-	indexed.sort((a, b) => {
-		for (const [field, direction] of orderBy) {
-			const cmp = compareValues(a[0][field], b[0][field]);
-			if (cmp !== 0) return direction === "desc" ? -cmp : cmp;
-		}
-		return a[1] - b[1];
-	});
-	return indexed.map(([row]) => row);
-}
-function compareValues(a, b) {
-	if (a == null && b == null) return 0;
-	if (a == null) return 1;
-	if (b == null) return -1;
-	if (typeof a === "number" && typeof b === "number") return a - b;
-	const as = stableKey(a);
-	const bs = stableKey(b);
-	return as < bs ? -1 : as > bs ? 1 : 0;
-}
-
 //#endregion
 //#region src/services/database/plan-render.ts
 function bind(ctx, value) {
@@ -1178,7 +1055,7 @@ function bind(ctx, value) {
 	return `$${name}`;
 }
 function renderComparisonSurql(c, ctx) {
-	const rawRight = c.paramRef ? `$${c.paramRef}` : bind(ctx, c.value);
+	const rawRight = c.paramRef !== void 0 && (c.value === void 0 || Object.prototype.hasOwnProperty.call(ctx.vars, c.paramRef)) ? `$${c.paramRef}` : bind(ctx, c.value);
 	const right = c.field === "id" ? `type::record(<string> ${rawRight})` : rawRight;
 	return c.swap ? `${right} ${c.op} ${c.field}` : `${c.field} ${c.op} ${right}`;
 }
@@ -1595,6 +1472,10 @@ var SqliteCacheEngine = class {
 	storeEpoch = 0;
 	knownTables = /* @__PURE__ */ new Set();
 	useOpfs;
+	/** Whether `select` runs as one worker round-trip (plan executed in-worker).
+	*  Flipped off at runtime if the worker script predates the `select` op
+	*  (stale cached bundle) — degrade to the legacy multi-hop path, don't break. */
+	workerSelect;
 	events = createDatabaseEventSystem();
 	bucketId = "anon";
 	/** Schemaless — tables are created lazily on first write; no migrator. */
@@ -1603,6 +1484,7 @@ var SqliteCacheEngine = class {
 		this.config = config;
 		this.logger = logger;
 		this.useOpfs = opts.useOpfs ?? true;
+		this.workerSelect = opts.workerSelect ?? config.workerSelect ?? true;
 	}
 	get epoch() {
 		return this.storeEpoch;
@@ -1655,7 +1537,11 @@ var SqliteCacheEngine = class {
 	*  single-flight query queue. */
 	opQueue = Promise.resolve();
 	call(type, payload) {
-		const run = () => this.rawCall(type, payload);
+		const enqueuedAt = performance.now();
+		const run = () => {
+			getStats().queueWaitMs += performance.now() - enqueuedAt;
+			return this.rawCall(type, payload);
+		};
 		const result = this.opQueue.then(run, run);
 		this.opQueue = result.then(() => void 0, () => void 0);
 		return result;
@@ -1675,10 +1561,16 @@ var SqliteCacheEngine = class {
 		const done = () => {
 			s.inFlight--;
 		};
+		const sentAt = performance.now();
 		return new Promise((resolve, reject) => {
 			this.pending.set(id, {
 				resolve: (v) => {
 					done();
+					const wt = v?.wt;
+					if (typeof wt === "number") {
+						s.workerMs += wt;
+						s.rpcOverheadMs += Math.max(0, performance.now() - sentAt - wt);
+					}
 					resolve(v);
 				},
 				reject: (e) => {
@@ -1753,9 +1645,44 @@ var SqliteCacheEngine = class {
 			sql,
 			bind
 		});
-		return (rows ?? []).map((r) => reviveRow(r.data));
+		const s = getStats();
+		const t0 = performance.now();
+		const out = (rows ?? []).map((r) => {
+			s.bytesParsed += r.data.length;
+			return reviveRow(r.data);
+		});
+		s.parseMs += performance.now() - t0;
+		s.rowsParsed += out.length;
+		return out;
 	}
 	async select(plan, params = {}) {
+		if (this.workerSelect) {
+			const normPlan = normalizePlanForClone(plan);
+			const normParams = {};
+			for (const [k, v] of Object.entries(params)) normParams[k] = toCloneSafe(v);
+			try {
+				const res = await this.call("select", {
+					plan: normPlan,
+					params: normParams
+				});
+				getStats().relationFetches += res.relationFetches ?? 0;
+				return res.rows ?? [];
+			} catch (err) {
+				if (err instanceof Error && err.message.includes("unknown message")) {
+					this.workerSelect = false;
+					this.logger.warn({
+						err,
+						Category: "sp00ky-client::SqliteCacheEngine::select"
+					}, "Worker lacks select op (stale script?) — falling back to multi-hop select");
+				} else throw err;
+			}
+		}
+		return this.selectLegacy(plan, params);
+	}
+	/** Pre-worker-select path: one worker round-trip per table/relation level,
+	*  rows parsed on the main thread. Kept as the `workerSelect:false` escape
+	*  hatch and the stale-worker fallback. */
+	async selectLegacy(plan, params = {}) {
 		if (plan.ids) {
 			const result = await this.selectByIds(plan.table, plan.ids, {
 				select: plan.select,
@@ -1777,6 +1704,7 @@ var SqliteCacheEngine = class {
 		return projected;
 	}
 	async fetchRelation(req) {
+		getStats().relationFetches++;
 		await this.ensureTable(req.table);
 		const keys = req.keys.map(stableKey);
 		const placeholders = keys.map(() => "?").join(", ");
@@ -2013,79 +1941,76 @@ var SqliteCacheEngine = class {
 		});
 	}
 };
+const EMPTY_STATS = {
+	roundTrips: 0,
+	batchStatements: 0,
+	maxBatch: 0,
+	inFlight: 0,
+	maxInFlight: 0,
+	byType: {},
+	queueWaitMs: 0,
+	workerMs: 0,
+	rpcOverheadMs: 0,
+	parseMs: 0,
+	rowsParsed: 0,
+	bytesParsed: 0,
+	relationFetches: 0
+};
 /** Live stats, inspectable in the browser console via `__sqliteStats`. Counts
-*  worker round-trips (the sync-down cost driver), batch sizes, and queue depth
-*  (`maxInFlight`) so a churn OOM can be measured rather than guessed. */
+*  worker round-trips (the sync-down cost driver), batch sizes, queue depth
+*  (`maxInFlight`), and the latency split of each round-trip (queue wait vs
+*  worker time vs RPC overhead vs main-thread row parsing) so first-load cost
+*  can be measured rather than guessed. */
 function getStats() {
 	const g = globalThis;
 	if (!g.__sqliteStats) g.__sqliteStats = {
-		roundTrips: 0,
-		batchStatements: 0,
-		maxBatch: 0,
-		inFlight: 0,
-		maxInFlight: 0,
+		...EMPTY_STATS,
 		byType: {}
 	};
+	else for (const [k, v] of Object.entries(EMPTY_STATS)) if (g.__sqliteStats[k] === void 0) g.__sqliteStats[k] = v;
 	return g.__sqliteStats;
 }
-function renderOrderSql(orderBy) {
-	return ` ORDER BY ${orderBy.map(([f, d]) => `json_extract(data, '$.${f}') ${d === "desc" ? "DESC" : "ASC"}`).join(", ")}`;
-}
-function comparisonSql(c, bind, params) {
-	const lhs = c.field === "id" ? "id" : `json_extract(data, '$.${c.field}')`;
-	const value = c.paramRef ? params[c.paramRef] : c.value;
-	bind.push(scalar(value));
-	const op = c.op === "!=" ? "!=" : c.op;
-	return c.swap ? `? ${op} ${lhs}` : `${lhs} ${op} ?`;
-}
-function renderWhereSql(nodes, bind, params) {
-	return nodes.map((node) => {
-		if ("or" in node) return `(${node.or.map((c) => comparisonSql(c, bind, params)).join(" OR ")})`;
-		return comparisonSql(node, bind, params);
-	}).join(" AND ");
-}
-/** A comparable scalar for SQL binding: record links → `table:id`, everything
-*  else passed through (numbers/strings/bools). */
-function scalar(value) {
-	if (value == null) return null;
-	if (typeof value === "object") return stableKey(value);
-	return value;
-}
-function serializeRow(row) {
-	return JSON.stringify(row, (_k, v) => {
-		if (v instanceof Uint8Array) return { __u8: toBase64(v) };
-		if (v && typeof v === "object") {
-			const rid = v;
-			if (rid.tb !== void 0 && rid.id !== void 0) return stableKey(v);
-		}
-		return v;
-	});
+/**
+* Make a bind/param value safe to cross the worker boundary. structuredClone
+* keeps plain data intact but strips a CLASS instance to a bare object — and
+* surrealdb's `RecordId` stores its fields behind getters (zero own
+* properties), so it clones to `{}`. Convert such instances to their
+* `stableKey` string (the exact value `scalar()` would bind on the main
+* thread), leave everything clone-representable untouched.
+*/
+function toCloneSafe(v) {
+	if (v === null || typeof v !== "object") return v;
+	if (Array.isArray(v) || v instanceof Uint8Array || v instanceof Date) return v;
+	const proto = Object.getPrototypeOf(v);
+	if (proto === Object.prototype || proto === null) return v;
+	return stableKey(v);
 }
-function reviveRow(json) {
-	if (json.indexOf("\"__u8\"") === -1) return JSON.parse(json);
-	return JSON.parse(json, (_k, v) => {
-		if (v && typeof v === "object" && typeof v.__u8 === "string") return fromBase64(v.__u8);
-		return v;
+function normalizeWhereForClone(nodes) {
+	if (!nodes) return nodes;
+	return nodes.map((n) => "or" in n ? { or: n.or.map((c) => ({
+		...c,
+		value: toCloneSafe(c.value)
+	})) } : {
+		...n,
+		value: toCloneSafe(n.value)
 	});
 }
-function project(row, fields) {
-	const out = {};
-	for (const f of ["id", ...fields]) if (f in row) out[f] = row[f];
-	return out;
-}
-function toBase64(bytes) {
-	let bin = "";
-	for (let i = 0; i < bytes.length; i++) bin += String.fromCharCode(bytes[i]);
-	return typeof btoa !== "undefined" ? btoa(bin) : Buffer.from(bytes).toString("base64");
+function normalizeRelationForClone(r) {
+	return {
+		...r,
+		where: normalizeWhereForClone(r.where),
+		relations: r.relations?.map(normalizeRelationForClone)
+	};
 }
-function fromBase64(b64) {
-	if (typeof atob !== "undefined") {
-		const bin = atob(b64);
-		const out = new Uint8Array(bin.length);
-		for (let i = 0; i < bin.length; i++) out[i] = bin.charCodeAt(i);
-		return out;
-	}
-	return new Uint8Array(Buffer.from(b64, "base64"));
+/** Normalize every baked value a plan carries (where trees, window ids) for
+*  the postMessage to the worker's `select` op. */
+function normalizePlanForClone(plan) {
+	return {
+		...plan,
+		ids: plan.ids?.map(stableKey),
+		where: normalizeWhereForClone(plan.where),
+		relations: plan.relations?.map(normalizeRelationForClone)
+	};
 }
 
 //#endregion
@@ -5148,8 +5073,8 @@ function parseBackendInfo(raw) {
 
 //#endregion
 //#region src/modules/devtools/index.ts
-const CORE_VERSION = "0.0.1-canary.133";
-const WASM_VERSION = "0.0.1-canary.133";
+const CORE_VERSION = "0.0.1-canary.135";
+const WASM_VERSION = "0.0.1-canary.135";
 const SURREAL_VERSION = "3.0.3";
 var DevToolsService = class {
 	eventsHistory = [];

package/dist/sqlite-plan-sql.js

@@ -0,0 +1,194 @@
+//#region src/services/database/cache-engine.ts
+/** Thrown when relation decomposition nests past {@link MAX_RELATION_DEPTH} —
+*  a guard against a cyclic schema producing unbounded fan-out. */
+var RelationCycleError = class extends Error {
+	constructor(path) {
+		super(`Relation nesting exceeded safe depth; possible cyclic schema: ${path.join(" -> ")}`);
+		this.name = "RelationCycleError";
+	}
+};
+/** Defensive ceiling on relation nesting depth. A finite plan tree never hits
+*  this in practice; it exists so a malformed/cyclic plan fails loudly instead
+*  of running away. */
+const MAX_RELATION_DEPTH = 12;
+
+//#endregion
+//#region src/services/database/relation-resolver.ts
+/**
+* Resolve the `.related()` tree of a query by **level-ordered, batched
+* fan-out** — the engine-neutral replacement for SurrealQL's nested
+* `(SELECT..) AS alias` projections. One batched fetch per relation per level
+* (never per-row N+1, never a flat join); grouping, per-parent ORDER/LIMIT and
+* attachment happen in JS.
+*
+* Correlation (mirrors `buildSubquery`):
+* - `one`  → parent[`foreignKeyField`] = child.id  → attach `bucket[0] ?? null`
+* - `many` → child[`foreignKeyField`] = parent.id   → attach `bucket`
+*
+* Cross-level dependency is handled by ordering: a child's correlation key is a
+* field on its parent, known only once the parent level has resolved, so each
+* level's batch runs after the previous level's rows exist. `parents` is
+* mutated in place — each resolved alias is appended LAST so key order matches
+* SurrealQL's `SELECT *, <sub> AS alias` (base fields, then alias).
+*
+* @throws {RelationCycleError} if nesting exceeds {@link MAX_RELATION_DEPTH}.
+*/
+async function resolveRelations(parents, relations, fetcher, depth = 0, path = []) {
+	if (!relations || relations.length === 0 || parents.length === 0) return;
+	if (depth >= MAX_RELATION_DEPTH) throw new RelationCycleError([...path, relations.map((r) => r.alias).join("|")]);
+	await Promise.all(relations.map((relation) => resolveOne(parents, relation, fetcher, depth, path)));
+}
+async function resolveOne(parents, relation, fetcher, depth, path) {
+	const isOne = relation.cardinality === "one";
+	const matchField = isOne ? "id" : relation.foreignKeyField;
+	const parentKeyOf = (parent) => isOne ? parent[relation.foreignKeyField] : parent["id"];
+	const keySet = /* @__PURE__ */ new Map();
+	for (const parent of parents) {
+		const key = parentKeyOf(parent);
+		if (key == null) continue;
+		const k = stableKey(key);
+		if (!keySet.has(k)) keySet.set(k, key);
+	}
+	const grouped = /* @__PURE__ */ new Map();
+	if (keySet.size > 0) {
+		const children = await fetcher.fetchRelation({
+			table: relation.table,
+			matchField,
+			keys: [...keySet.values()],
+			where: relation.where,
+			orderBy: relation.orderBy,
+			select: relation.select
+		});
+		await resolveRelations(children, relation.relations, fetcher, depth + 1, [...path, relation.alias]);
+		for (const child of children) {
+			const k = stableKey(child[matchField]);
+			const bucket = grouped.get(k);
+			if (bucket) bucket.push(child);
+			else grouped.set(k, [child]);
+		}
+	}
+	for (const parent of parents) {
+		const key = parentKeyOf(parent);
+		let bucket = key == null ? [] : grouped.get(stableKey(key)) ?? [];
+		if (relation.orderBy && relation.orderBy.length > 0) bucket = sortRows(bucket, relation.orderBy);
+		if (relation.limit !== void 0) bucket = bucket.slice(0, relation.limit);
+		parent[relation.alias] = isOne ? bucket[0] ?? null : bucket;
+	}
+}
+/**
+* Stable grouping key for a correlation value. A `RecordId` (duck-typed to
+* avoid a hard surrealdb dependency here) and its `table:id` string form must
+* collapse to the same key so a parent FK stored either way matches the child.
+*/
+function stableKey(value) {
+	if (value == null) return "\0null";
+	if (typeof value === "string") return value;
+	if (typeof value === "number" || typeof value === "boolean" || typeof value === "bigint") return String(value);
+	if (typeof value === "object") {
+		const rid = value;
+		if (rid.tb !== void 0 && rid.id !== void 0) return `${String(rid.tb)}:${stableKey(rid.id)}`;
+		if (typeof rid.toString === "function") {
+			const s = rid.toString();
+			if (s !== "[object Object]") return s;
+		}
+		return JSON.stringify(value);
+	}
+	return String(value);
+}
+/**
+* Stable, multi-key sort matching SurrealQL `ORDER BY` semantics closely
+* enough for cache display order: ascending null-last, type-aware compare, and
+* a stable tiebreak (original index) so equal rows keep input order.
+*/
+function sortRows(rows, orderBy) {
+	const indexed = rows.map((row, i) => [row, i]);
+	indexed.sort((a, b) => {
+		for (const [field, direction] of orderBy) {
+			const cmp = compareValues(a[0][field], b[0][field]);
+			if (cmp !== 0) return direction === "desc" ? -cmp : cmp;
+		}
+		return a[1] - b[1];
+	});
+	return indexed.map(([row]) => row);
+}
+function compareValues(a, b) {
+	if (a == null && b == null) return 0;
+	if (a == null) return 1;
+	if (b == null) return -1;
+	if (typeof a === "number" && typeof b === "number") return a - b;
+	const as = stableKey(a);
+	const bs = stableKey(b);
+	return as < bs ? -1 : as > bs ? 1 : 0;
+}
+
+//#endregion
+//#region src/services/database/sqlite-plan-sql.ts
+/**
+* SQL rendering + value (de)serialization for the SQLite cache backend.
+* Extracted from `sqlite-cache-engine.ts` so BOTH sides of the worker boundary
+* can use it: the engine (main thread) for the legacy/shim paths, and
+* `sqlite-worker.js` for worker-side plan execution (`select`). Pure module —
+* no DOM, no worker, no engine imports — mirroring `plan-render.ts`.
+*/
+function renderOrderSql(orderBy) {
+	return ` ORDER BY ${orderBy.map(([f, d]) => `json_extract(data, '$.${f}') ${d === "desc" ? "DESC" : "ASC"}`).join(", ")}`;
+}
+function comparisonSql(c, bind, params) {
+	const lhs = c.field === "id" ? "id" : `json_extract(data, '$.${c.field}')`;
+	const value = c.paramRef !== void 0 && (c.value === void 0 || Object.prototype.hasOwnProperty.call(params, c.paramRef)) ? params[c.paramRef] : c.value;
+	bind.push(scalar(value));
+	const op = c.op === "!=" ? "!=" : c.op;
+	return c.swap ? `? ${op} ${lhs}` : `${lhs} ${op} ?`;
+}
+function renderWhereSql(nodes, bind, params) {
+	return nodes.map((node) => {
+		if ("or" in node) return `(${node.or.map((c) => comparisonSql(c, bind, params)).join(" OR ")})`;
+		return comparisonSql(node, bind, params);
+	}).join(" AND ");
+}
+/** A comparable scalar for SQL binding: record links → `table:id`, everything
+*  else passed through (numbers/strings/bools). */
+function scalar(value) {
+	if (value == null) return null;
+	if (typeof value === "object") return stableKey(value);
+	return value;
+}
+function serializeRow(row) {
+	return JSON.stringify(row, (_k, v) => {
+		if (v instanceof Uint8Array) return { __u8: toBase64(v) };
+		if (v && typeof v === "object") {
+			const rid = v;
+			if (rid.tb !== void 0 && rid.id !== void 0) return stableKey(v);
+		}
+		return v;
+	});
+}
+function reviveRow(json) {
+	if (json.indexOf("\"__u8\"") === -1) return JSON.parse(json);
+	return JSON.parse(json, (_k, v) => {
+		if (v && typeof v === "object" && typeof v.__u8 === "string") return fromBase64(v.__u8);
+		return v;
+	});
+}
+function project(row, fields) {
+	const out = {};
+	for (const f of ["id", ...fields]) if (f in row) out[f] = row[f];
+	return out;
+}
+function toBase64(bytes) {
+	let bin = "";
+	for (let i = 0; i < bytes.length; i++) bin += String.fromCharCode(bytes[i]);
+	return typeof btoa !== "undefined" ? btoa(bin) : Buffer.from(bytes).toString("base64");
+}
+function fromBase64(b64) {
+	if (typeof atob !== "undefined") {
+		const bin = atob(b64);
+		const out = new Uint8Array(bin.length);
+		for (let i = 0; i < bin.length; i++) out[i] = bin.charCodeAt(i);
+		return out;
+	}
+	return new Uint8Array(Buffer.from(b64, "base64"));
+}
+
+//#endregion
+export { serializeRow as a, reviveRow as i, renderOrderSql as n, resolveRelations as o, renderWhereSql as r, stableKey as s, project as t };