@vireocodedev/sqlite 0.2.0 → 0.2.1

package/dist/index.js

@@ -0,0 +1,1508 @@
+import { i as e, r as t } from "./queueingHeaders-B7TBifLV.js";
+import n from "@sqlite.org/sqlite-wasm";
+//#region src/core/sqliteCrud.ts
+function r(e, t) {
+	e.exec("BEGIN;");
+	try {
+		t(), e.exec("COMMIT;");
+	} catch (t) {
+		throw e.exec("ROLLBACK;"), t;
+	}
+}
+function i(e, t, n) {
+	let r = e.prepare(t), i = [];
+	try {
+		for (; r.step();) i.push(n(r.get([])));
+	} finally {
+		r.finalize();
+	}
+	return i;
+}
+function a(e, t, n, i) {
+	i.length !== 0 && r(e, () => {
+		for (let r of i) {
+			let i = e.prepare(`DELETE FROM ${t} WHERE ${n} = ?;`);
+			try {
+				i.bind([r]), i.step();
+			} finally {
+				i.finalize();
+			}
+		}
+	});
+}
+//#endregion
+//#region src/core/sqliteRequestHandlers.ts
+function o(e) {
+	return e;
+}
+function s(...e) {
+	let t = {};
+	for (let n of e) for (let [e, r] of Object.entries(n)) {
+		if (e in t) throw Error(`SQLite request handler operation "${e}" is registered more than once.`);
+		t[e] = r;
+	}
+	return t;
+}
+async function c(e, t, n) {
+	let r = n[t.type];
+	if (r) return await r(e, t);
+}
+//#endregion
+//#region src/core/sqliteEntityFactory.ts
+function l(e, t) {
+	return t.map((t) => e[t]).filter((e) => e != null).map((e) => String(e).trim()).filter((e) => e.length > 0).join(" ").trim();
+}
+function u(e, t) {
+	if (e.trim().length === 0) throw Error(`${t} must be a non-empty string.`);
+}
+function d(e) {
+	let t = Object.entries(e.fields);
+	u(e.entityNameSingular, "entityNameSingular"), u(e.entityNamePlural, "entityNamePlural"), u(e.tableName, "tableName"), u(e.requestKeys.replace, "requestKeys.replace"), u(e.requestKeys.upsert, "requestKeys.upsert"), u(e.requestKeys.delete, "requestKeys.delete");
+	for (let [e, n] of t) u(n.column, `fields.${e}.column`);
+	let n = t.filter(([, e]) => e.id === !0);
+	if (n.length !== 1) throw Error(`Sqlite entity spec for ${e.entityNameSingular} must define exactly one field with id: true.`);
+	let s = n[0][1].column, c = e.entityNamePlural, d = {
+		replace: `replace${c}`,
+		upsert: `upsert${e.entityNameSingular}`,
+		list: `list${c}`,
+		delete: `delete${c}`
+	}, f = e.requestKeys, p = e.softDelete?.enabled ?? !0, m = e.softDelete?.columnName ?? "deleted", h = "keywords", g = t.map(([, e]) => e.column), _ = t.map(([e]) => e);
+	if (new Set(g).size !== g.length) throw Error(`Sqlite entity spec for ${e.entityNameSingular} maps more than one field to the same column.`);
+	let v = [h, ...p ? [m] : []], y = v.find((e) => g.includes(e));
+	if (y) throw Error(`Sqlite entity spec for ${e.entityNameSingular} maps field column "${y}", which is managed by the entity runtime.`);
+	if (new Set(v).size !== v.length) throw Error(`Sqlite entity spec for ${e.entityNameSingular} configures duplicate generated columns.`);
+	let b = [...g, h];
+	p && b.push(m);
+	let x = e.keywordFields ?? _;
+	function S(e, t, n) {
+		let r = n[e];
+		return t.toDb ? t.toDb(r) : r;
+	}
+	function C(e) {
+		let n = t.map(([t, n]) => S(t, n, e));
+		return n.push(l(e, x)), p && n.push(0), n;
+	}
+	let w = b.map(() => "?").join(", "), T = b.filter((e) => e !== s);
+	function E(t, n) {
+		r(t, () => {
+			t.exec(`DELETE FROM ${e.tableName};`);
+			for (let r of n) {
+				let n = t.prepare(`
+          INSERT INTO ${e.tableName} (${b.join(", ")})
+          VALUES (${w});
+        `);
+				try {
+					n.bind(C(r)), n.step();
+				} finally {
+					n.finalize();
+				}
+			}
+		});
+	}
+	function D(t, n) {
+		let r = t.prepare(`
+      INSERT INTO ${e.tableName} (${b.join(", ")})
+      VALUES (${w})
+      ON CONFLICT(${s}) DO UPDATE SET
+        ${T.map((e) => `${e} = excluded.${e}`).join(", ")};
+    `);
+		try {
+			r.bind(C(n)), r.step();
+		} finally {
+			r.finalize();
+		}
+	}
+	function O(n) {
+		let r = p ? `WHERE ${m} = 0` : "", a = e.orderBy ?? s;
+		return i(n, `
+        SELECT ${g.join(", ")}
+        FROM ${e.tableName}
+        ${r}
+        ORDER BY ${a} ASC;
+      `, (e) => {
+			let n = {};
+			for (let r = 0; r < t.length; r += 1) {
+				let [i, a] = t[r], o = e[r];
+				n[i] = a.fromDb(o);
+			}
+			return n;
+		});
+	}
+	function k(t, n) {
+		a(t, e.tableName, s, n);
+	}
+	let A = o({
+		[d.replace]: (e, t) => (E(e, t[f.replace]), null),
+		[d.upsert]: (e, t) => (D(e, t[f.upsert]), null),
+		[d.list]: (e) => O(e),
+		[d.delete]: (e, t) => (k(e, t[f.delete]), null)
+	});
+	return {
+		__sqliteEntityBundle: !0,
+		tableName: e.tableName,
+		entityNameSingular: e.entityNameSingular,
+		entityNamePlural: e.entityNamePlural,
+		operationNames: d,
+		requestKeys: f,
+		fields: e.fields,
+		hydration: e.hydration,
+		replaceRows: E,
+		upsertRow: D,
+		listRows: O,
+		deleteRows: k,
+		sse: e.sse,
+		requestHandlers: A,
+		operationMap: void 0
+	};
+}
+//#endregion
+//#region src/concurrency/createSqliteOperationCoordinator.ts
+function f(e) {
+	return typeof DOMException > "u" ? Error(e) : new DOMException(e, "AbortError");
+}
+function p(e) {
+	let t = /* @__PURE__ */ new Map(), n = /* @__PURE__ */ new WeakSet(), r = Promise.resolve(), i = null, a = null, o = async (e) => {
+		let t = r.catch(() => void 0).then(e);
+		return r = t.then(() => void 0, () => void 0), await t;
+	}, s = async (t, r) => {
+		if (r != null && n.has(r)) return await t(r);
+		let i = async () => {
+			let e = {};
+			n.add(e);
+			try {
+				return await t(e);
+			} finally {
+				n.delete(e);
+			}
+		}, a = e.getLockManager?.() ?? null;
+		return a ? await a.request(e.lockName, { mode: "exclusive" }, i) : await o(i);
+	}, c = async (e, n) => {
+		let r = (t.get(e) ?? Promise.resolve()).catch(() => void 0).then(n), i = r.then(() => void 0, () => void 0);
+		t.set(e, i);
+		try {
+			return await r;
+		} finally {
+			t.get(e) === i && t.delete(e);
+		}
+	};
+	return {
+		runDatabaseExclusive: s,
+		runEntityExclusive: async (e, t, n) => await s((n) => c(e, () => t(n)), n),
+		runHydrationExclusive: async (e) => {
+			if (i) return await i;
+			a = new AbortController();
+			let t = a;
+			return i = s((n) => (t.signal.throwIfAborted(), e(t.signal, n))).finally(() => {
+				i = null, a === t && (a = null);
+			}), await i;
+		},
+		abortHydration(t = "SQLite hydration was cancelled.") {
+			a?.abort((e.createAbortReason ?? f)(t));
+		},
+		async awaitHydrationIdle() {
+			await i?.catch(() => void 0);
+		}
+	};
+}
+//#endregion
+//#region src/devtools/createSqlConsoleClient.ts
+function m() {
+	return typeof performance < "u" && typeof performance.now == "function" ? performance.now() : Date.now();
+}
+function h(e) {
+	return typeof e != "object" || !e ? JSON.stringify(e) ?? String(e) : Array.isArray(e) ? `[${e.map((e) => h(e)).join(",")}]` : `{${Object.entries(e).sort(([e], [t]) => e.localeCompare(t)).map(([e, t]) => `${JSON.stringify(e)}:${h(t)}`).join(",")}}`;
+}
+function g(e) {
+	let t = /* @__PURE__ */ new Map(), n = e.now ?? m, r = e.requestTypes ?? {
+		executeScript: "executeSqlScript",
+		executePagedQuery: "executePagedQuery"
+	}, i = e.createUnavailableError ?? ((e) => /* @__PURE__ */ Error(`SQLite ${e === "script" ? "SQL console" : "paged query execution"} is unavailable.`));
+	return {
+		async executeScript(t) {
+			if (e.runtime.shouldUseInMemoryFallback()) throw i("script");
+			return await e.transport.sendWorkerRequest({
+				type: r.executeScript,
+				script: t
+			});
+		},
+		async executePagedQuery(a) {
+			if (e.runtime.shouldUseInMemoryFallback()) throw i("paged-query");
+			let o = h(a), s = t.get(o);
+			if (s) return e.log?.("executePagedQuery dedupe hit"), await s;
+			let c = e.transport.sendWorkerRequest({
+				type: r.executePagedQuery,
+				...a,
+				clientSentAtMs: n()
+			});
+			t.set(o, c);
+			try {
+				return await c;
+			} finally {
+				t.delete(o);
+			}
+		}
+	};
+}
+//#endregion
+//#region src/hydration/createHydrationContributorRegistry.ts
+function _() {
+	let e = /* @__PURE__ */ new Map();
+	return {
+		register(t) {
+			for (let n of t) e.set(n.key, n);
+		},
+		list: () => [...e.values()].sort((e, t) => e.key.localeCompare(t.key))
+	};
+}
+//#endregion
+//#region src/hydration/createHydrationController.ts
+function v() {
+	return typeof performance > "u" ? Date.now() : performance.now();
+}
+function y(e, t) {
+	return typeof DOMException > "u" ? Error(e) : new DOMException(e, t);
+}
+function b(e) {
+	let t = e.elapsedNow ?? v, n = e.timestampNow ?? Date.now, r = e.schedule ?? setTimeout, i = e.cancelScheduled ?? clearTimeout, a = e.isCancellationError ?? ((e) => typeof DOMException < "u" && e instanceof DOMException && e.name === "AbortError"), o = null, s = 0, c = null, l = !1, u = () => {
+		c != null && i(c), c = null;
+	}, d = (t) => {
+		if (c != null || l) return;
+		let n = ++s, i = Math.min(e.retryBaseMs * 2 ** Math.min(n - 1, e.retryExponentLimit ?? 6), e.retryMaxMs);
+		e.debug?.(t, {
+			retryNumber: n,
+			retryDelayMs: i
+		}), c = r(() => {
+			c = null, l || e.events.resetGate();
+		}, i);
+	}, f = async (e, t, n, a) => {
+		let o = new AbortController(), s = !1, c = () => o.abort(t.reason);
+		t.addEventListener("abort", c, { once: !0 });
+		let l = r(() => {
+			s = !0, o.abort(y(a, "TimeoutError"));
+		}, n);
+		try {
+			let t = await e(o.signal);
+			return o.signal.throwIfAborted(), t;
+		} catch (e) {
+			throw s ? Error(a) : e;
+		} finally {
+			i(l), t.removeEventListener("abort", c);
+		}
+	}, p = async (r) => {
+		let i = e.getContributors();
+		e.events.registerEntities(i.map((e) => e.key));
+		let o = null;
+		try {
+			await e.runHydrationExclusive(async (a, c) => {
+				let l = e.requests.consume();
+				o = l;
+				let p = t();
+				e.events.markRunning(!0), e.events.startGate(), e.events.setErrorMessage(null), e.debug?.("Hydration started", {
+					entityCount: i.length,
+					heartbeatEnabled: r.heartbeatEnabled ?? !1,
+					heartbeatConnected: r.heartbeatConnected ?? !1
+				});
+				try {
+					let r = i.map((e) => e.key).sort((e, t) => e.localeCompare(t)), o = t(), p = await e.entityStateClient.list();
+					e.debug?.("Loaded local hydration metadata", {
+						elapsedMs: Math.round(t() - o),
+						entityCount: p.length
+					});
+					let m = new Map(p.map((e) => [e.entityKey, e])), h = /* @__PURE__ */ new Map(), g = /* @__PURE__ */ new Set(), _ = !0, v = !0, y = !0, b = t();
+					try {
+						let n = await f((t) => e.fetchRemoteVersions(r, t), a, e.remoteVersionsTimeoutMs, "Fetching hydration versions timed out.");
+						for (let e of n.versions) h.set(e.entity.toLowerCase(), Number(e.revision ?? 0));
+						e.debug?.("Fetched remote entity revisions", {
+							elapsedMs: Math.round(t() - b),
+							entityCount: n.versions.length
+						});
+					} catch (n) {
+						if (a.aborted) throw n;
+						y = !1, v = !1, e.warn?.("Could not fetch remote entity revisions; every entity will be hydrated", {
+							elapsedMs: Math.round(t() - b),
+							error: n
+						});
+					}
+					for (let r of i) {
+						a.throwIfAborted();
+						let i = t();
+						e.events.markEntityRunning(r.key);
+						let o = m.get(r.key), s = h.get(r.key.toLowerCase()) ?? 0, u = y && h.has(r.key.toLowerCase()), d = u && o?.isStale === !0 && o.lastError == null && o.appliedRevision === s;
+						if (!(l.forcedKeys.has(r.key) || !u || o == null || o.isStale && !d || o.appliedRevision !== s)) {
+							d && await e.entityStateClient.upsert({
+								...o,
+								isStale: !1,
+								lastError: null
+							}), e.events.markEntitySuccess(r.key, o.lastRowCount ?? 0), e.debug?.("Entity is current; skipped hydration", {
+								entity: r.key,
+								elapsedMs: Math.round(t() - i),
+								revision: s,
+								rowCount: o.lastRowCount ?? 0
+							});
+							continue;
+						}
+						e.debug?.("Hydrating entity", {
+							entity: r.key,
+							reason: l.forcedKeys.has(r.key) ? "manual-request" : u ? o == null ? "no-local-state" : o.isStale ? "local-state-stale" : "revision-mismatch" : "remote-revision-unavailable",
+							localRevision: o?.appliedRevision ?? null,
+							remoteRevision: u ? s : null
+						}), await e.runEntityExclusive(r.key, async () => {
+							try {
+								let c = e.entityTimeoutMs(r.key), l = await f((e) => r.hydrate(e), a, c, `Hydration timed out after ${c}ms for entity "${r.key}".`);
+								a.throwIfAborted();
+								let d = (await e.entityStateClient.list()).find((e) => e.entityKey === r.key);
+								a.throwIfAborted();
+								let p = u ? Math.max(s, d?.appliedRevision ?? 0) : d?.appliedRevision ?? o?.appliedRevision ?? 0;
+								await e.entityStateClient.upsert({
+									entityKey: r.key,
+									appliedRevision: p,
+									isStale: !u,
+									lastHydratedAt: n(),
+									lastRowCount: l.rowCount,
+									lastError: null
+								}), e.events.markEntitySuccess(r.key, l.rowCount), e.debug?.("Entity hydration completed", {
+									entity: r.key,
+									elapsedMs: Math.round(t() - i),
+									rowCount: l.rowCount
+								});
+							} catch (n) {
+								if (a.aborted) throw n;
+								_ = !1, g.add(r.key);
+								let s = n instanceof Error ? n.message : "Unknown hydration error.";
+								e.events.setErrorMessage(s), await e.entityStateClient.upsert({
+									entityKey: r.key,
+									appliedRevision: o?.appliedRevision ?? 0,
+									isStale: !0,
+									lastHydratedAt: o?.lastHydratedAt ?? null,
+									lastRowCount: o?.lastRowCount ?? null,
+									lastError: s
+								}), e.events.markEntityError(r.key, s), e.error?.("Entity hydration failed", {
+									entity: r.key,
+									elapsedMs: Math.round(t() - i),
+									error: n
+								});
+							}
+						}, c);
+					}
+					_ && v ? (s = 0, u(), e.events.markDataReady()) : d("Hydration retry scheduled"), e.requests.settle(l, g);
+				} finally {
+					e.debug?.("Hydration finished", { elapsedMs: Math.round(t() - p) }), e.events.markRunning(!1), e.requests.hasPending() ? e.events.resetGate() : e.events.finishGate();
+				}
+			});
+		} catch (t) {
+			if (o && e.requests.reject(o, t), a(t)) {
+				e.debug?.("Hydration cancelled", { reason: t instanceof Error ? t.message : "Request cancelled" });
+				return;
+			}
+			let n = t instanceof Error ? t.message : "Unknown SQLite storage error.";
+			e.events.setErrorMessage(n);
+			for (let t of i) e.events.markEntityError(t.key, n);
+			e.error?.("Hydration failed unexpectedly", { error: t }), d("Hydration retry scheduled after an unexpected SQLite failure");
+		}
+	};
+	return {
+		async run(e = {}) {
+			if (l) throw Error("Hydration controller has been disposed.");
+			return o ??= p(e).finally(() => {
+				o = null;
+			}), await o;
+		},
+		requestRetry() {
+			u(), e.events.setErrorMessage(null), e.events.resetGate();
+		},
+		reset(t) {
+			e.requests.rejectPending(t), u(), s = 0, e.events.setErrorMessage(null), e.events.resetGate();
+		},
+		cancelScheduledRetry: u,
+		dispose() {
+			l = !0, u();
+		},
+		isRunning: () => o != null
+	};
+}
+//#endregion
+//#region src/hydration/createHydrationEntityClient.ts
+function x(e) {
+	let t = /* @__PURE__ */ new Map();
+	return {
+		async list() {
+			return e.runtime.shouldUseInMemoryFallback() ? [...t.values()].sort((e, t) => e.entityKey.localeCompare(t.entityKey)) : await e.transport.sendWorkerRequest({ type: "listHydrationEntityStates" });
+		},
+		async upsert(n) {
+			if (e.runtime.shouldUseInMemoryFallback()) {
+				t.set(n.entityKey, n);
+				return;
+			}
+			await e.transport.sendWorkerRequest({
+				type: "upsertHydrationEntityState",
+				state: n
+			});
+		},
+		dispose: e.runtime.registerInMemoryStore(t)
+	};
+}
+//#endregion
+//#region src/hydration/createHydrationGate.ts
+var S = {
+	phase: "idle",
+	startedAt: null,
+	dataReady: !1,
+	errorMessage: null,
+	retryRequestTick: 0
+};
+function C(e = {}) {
+	let t = e.now ?? Date.now, n = /* @__PURE__ */ new Set(), r = S, i = (e) => {
+		if (e.phase !== r.phase || e.startedAt !== r.startedAt || e.dataReady !== r.dataReady || e.errorMessage !== r.errorMessage || e.retryRequestTick !== r.retryRequestTick) {
+			r = e;
+			for (let e of n) e(r);
+		}
+	};
+	return {
+		getSnapshot: () => r,
+		subscribe(e) {
+			return n.add(e), () => n.delete(e);
+		},
+		setErrorMessage(e) {
+			i({
+				...r,
+				errorMessage: e
+			});
+		},
+		requestRetry() {
+			i({
+				...r,
+				retryRequestTick: r.retryRequestTick + 1
+			});
+		},
+		reset() {
+			i({
+				...r,
+				phase: "idle",
+				startedAt: null,
+				dataReady: !1
+			});
+		},
+		start() {
+			i({
+				...r,
+				phase: "running",
+				startedAt: r.startedAt ?? t()
+			});
+		},
+		finish() {
+			i({
+				...r,
+				phase: "finished"
+			});
+		},
+		markDataReady() {
+			i({
+				...r,
+				dataReady: !0
+			});
+		}
+	};
+}
+//#endregion
+//#region src/hydration/createHydrationRequestQueue.ts
+function w(e = {}) {
+	let t = [];
+	return {
+		request(n) {
+			let r = new Set(n.map((e) => e.trim()).filter(Boolean));
+			if (r.size === 0) return Promise.resolve();
+			let i = new Promise((e, n) => {
+				t.push({
+					keys: r,
+					resolve: e,
+					reject: n
+				});
+			});
+			return e.onRequestQueued?.(), i;
+		},
+		consume() {
+			let e = t.splice(0);
+			return {
+				requests: e,
+				forcedKeys: new Set(e.flatMap((e) => [...e.keys]))
+			};
+		},
+		hasPending: () => t.length > 0,
+		rejectPending(e) {
+			let n = Error(e);
+			for (let e of t.splice(0)) e.reject(n);
+		},
+		settle(e, t) {
+			for (let n of e.requests) {
+				let e = [...n.keys].filter((e) => t.has(e));
+				e.length === 0 ? n.resolve() : n.reject(/* @__PURE__ */ Error(`Hydration failed for: ${e.join(", ")}.`));
+			}
+		},
+		reject(t, n) {
+			let r = n instanceof Error ? n : e.createUnexpectedError?.() ?? /* @__PURE__ */ Error("Hydration failed unexpectedly.");
+			for (let e of t.requests) e.reject(r);
+		}
+	};
+}
+//#endregion
+//#region src/hydration/createHydrationStatus.ts
+function T(e) {
+	return {
+		key: e,
+		state: "idle",
+		lastAttemptAt: null,
+		lastSuccessAt: null,
+		rowCount: null,
+		errorMessage: null
+	};
+}
+function E(e = {}) {
+	let t = e.now ?? Date.now, n = /* @__PURE__ */ new Set(), r = {}, i = !1, a = () => ({
+		running: i,
+		entities: Object.values(r).sort((e, t) => e.key.localeCompare(t.key))
+	}), o = () => {
+		let e = a();
+		for (let t of n) t(e);
+	}, s = (e, t) => {
+		r = {
+			...r,
+			[e]: {
+				...r[e] ?? T(e),
+				...t
+			}
+		}, o();
+	};
+	return {
+		getSnapshot: a,
+		subscribe(e) {
+			return n.add(e), () => n.delete(e);
+		},
+		registerEntities(e) {
+			let t = !1, n = r;
+			for (let r of e) n[r] || (t = !0, n = {
+				...n,
+				[r]: T(r)
+			});
+			t && (r = n, o());
+		},
+		markRunning(e) {
+			i !== e && (i = e, o());
+		},
+		markEntityRunning(e) {
+			s(e, {
+				state: "running",
+				lastAttemptAt: t(),
+				errorMessage: null
+			});
+		},
+		markEntitySuccess(e, n) {
+			s(e, {
+				state: "success",
+				lastSuccessAt: t(),
+				rowCount: n,
+				errorMessage: null
+			});
+		},
+		markEntityError(e, t) {
+			s(e, {
+				state: "error",
+				errorMessage: t
+			});
+		},
+		reset() {
+			!i && Object.keys(r).length === 0 || (i = !1, r = {}, o());
+		}
+	};
+}
+//#endregion
+//#region src/hydration/createLocalReflectionQueue.ts
+function D(e) {
+	let t = /* @__PURE__ */ new Set(), n = () => e.onPendingCountChange?.(t.size);
+	return {
+		enqueue(r, i) {
+			let a = e.runEntityExclusive(r, i);
+			t.add(a), n(), a.catch((t) => e.onError?.(r, t)).finally(() => {
+				t.delete(a), n();
+			});
+		},
+		async awaitIdle() {
+			for (; t.size > 0;) await Promise.allSettled([...t]);
+		},
+		getPendingCount: () => t.size
+	};
+}
+//#endregion
+//#region src/lifecycle/createDatabaseOwnerStore.ts
+function O({ key: e, getStorage: t }) {
+	return {
+		read() {
+			let n = t().getItem(e);
+			return n != null && n.length > 0 ? n : null;
+		},
+		persist(n) {
+			t().setItem(e, n);
+		},
+		clear() {
+			t().removeItem(e);
+		}
+	};
+}
+//#endregion
+//#region src/lifecycle/createOfflineDataLifecycle.ts
+function k(e) {
+	let t = null, n = async (t) => {
+		t.onPhase?.("hydration"), e.abortHydration(e.hydrationAbortReason ?? "SQLite hydration was cancelled before purging local data."), await e.awaitHydrationIdle(), await e.awaitLocalReflectionIdle(), t.onPhase?.("queue"), await e.awaitQueueFlushIdle(), e.resetHydrationGate(), e.resetHydrationStatus(), e.resetQueueStatus(), e.resetRuntime(), e.clearInMemoryStores();
+	}, r = async (e = {}) => {
+		await n(e), e.onPhase?.("storage");
+	}, i = async (t = {}) => {
+		let r = e.readOwner(), i = r == null ? void 0 : e.resolveDatabaseFileName(r, r);
+		await n(t), t.onPhase?.("storage"), await e.deleteDatabaseFiles(i);
+	}, a = async (t) => {
+		let n = e.readOwner();
+		return n === t ? (e.resolveDatabaseFileName(t, n), !1) : (n != null && await r(), e.persistOwner(t), e.resolveDatabaseFileName(t, n), n != null);
+	};
+	return {
+		release: r,
+		purge: i,
+		async ensureOwnedBy(e) {
+			return t ??= a(e).finally(() => {
+				t = null;
+			}), await t;
+		}
+	};
+}
+//#endregion
+//#region src/lifecycle/createOpfsDatabaseFiles.ts
+var A = /* @__PURE__ */ new Set([
+	"NoModificationAllowedError",
+	"InvalidStateError",
+	"InvalidModificationError"
+]);
+function ee(e) {
+	return Array.from(new TextEncoder().encode(e), (e) => e.toString(16).padStart(2, "0")).join("");
+}
+function te(e, t) {
+	return e instanceof Error && e.name === t;
+}
+async function ne(e, t) {
+	let n = e;
+	if (typeof n.keys != "function") return [t];
+	let r = [];
+	for await (let e of n.keys()) (e === t || e.startsWith(`${t}-`)) && r.push(e);
+	return r;
+}
+async function re(e, t) {
+	try {
+		await e.removeEntry(t, { recursive: !0 });
+	} catch (e) {
+		if (!te(e, "NotFoundError")) throw e;
+	}
+}
+function ie(e) {
+	let t = e.lockRetryDelayMs ?? 50, n = e.wait ?? ((e) => new Promise((t) => setTimeout(t, e)));
+	return {
+		getFileName(t, n) {
+			let r = ee(t), i = `${e.mappingKeyPrefix}${r}`, a = e.getStorage(), o = a.getItem(i);
+			if (o != null) return o;
+			let s = n === t ? e.legacyFileName : e.createScopedFileName(r);
+			return a.setItem(i, s), s;
+		},
+		async deleteFiles(r = e.legacyFileName) {
+			let i = e.getDirectory();
+			if (!i) return;
+			let a = await i;
+			for (let e of await ne(a, r)) try {
+				await re(a, e);
+			} catch (r) {
+				if (!(r instanceof Error) || !A.has(r.name)) throw r;
+				await n(t), await re(a, e);
+			}
+		}
+	};
+}
+//#endregion
+//#region src/offline-queue/createOfflineQueueCapture.ts
+function ae(n) {
+	return async (r) => {
+		let i = {
+			commandId: n.createCommandId(),
+			method: (r.method ?? "get").toUpperCase(),
+			url: n.resolveUrl(r),
+			body: r.body ?? null,
+			headers: t(e(r.headers)),
+			createdAt: n.now()
+		};
+		return await n.enqueue(i), n.markEnqueued(), await n.refreshStatus(), i;
+	};
+}
+//#endregion
+//#region src/offline-queue/offlineQueueStateSqlite.ts
+var j = "offline_sync_commands", M = "PENDING", N = "PERMANENTLY_FAILED";
+function P(e, t, n) {
+	try {
+		return JSON.parse(e);
+	} catch {
+		throw Error(`Offline command "${t}" contains invalid JSON in ${n}.`);
+	}
+}
+function oe(e, t) {
+	let n = P(e, t, "headers_json");
+	if (typeof n != "object" || !n || Array.isArray(n) || Object.values(n).some((e) => typeof e != "string")) throw Error(`Offline command "${t}" contains invalid headers_json.`);
+	return n;
+}
+function F(e, t) {
+	if (!Number.isInteger(e) || e <= 0) throw Error(`${t} must be a positive integer.`);
+}
+function I(e) {
+	return String(e ?? "PENDING") === "PERMANENTLY_FAILED" ? N : M;
+}
+function L(e, t) {
+	let n = e.prepare(`
+    INSERT OR REPLACE INTO ${j}
+      (command_id, method, url, body_json, headers_json, created_at)
+    VALUES (?, ?, ?, ?, ?, ?);
+  `);
+	try {
+		n.bind([
+			t.commandId,
+			t.method,
+			t.url,
+			JSON.stringify(t.body ?? null),
+			JSON.stringify(t.headers),
+			t.createdAt
+		]), n.step();
+	} finally {
+		n.finalize();
+	}
+}
+function R(e, t) {
+	F(t, "batchSize");
+	let n = e.prepare(`
+    SELECT command_id, method, url, body_json, headers_json, created_at, status, retry_count, last_error
+    FROM ${j}
+    WHERE status = '${M}'
+    ORDER BY created_at ASC
+    LIMIT ?;
+  `), r = [];
+	try {
+		for (n.bind([t]); n.step();) {
+			let e = n.get([]), t = String(e[0] ?? "");
+			r.push({
+				commandId: t,
+				method: String(e[1] ?? ""),
+				url: String(e[2] ?? ""),
+				body: P(String(e[3] ?? "null"), t, "body_json"),
+				headers: oe(String(e[4] ?? "{}"), t),
+				createdAt: Number(e[5] ?? 0),
+				status: I(e[6]),
+				retryCount: Number(e[7] ?? 0),
+				lastError: e[8] == null ? null : String(e[8])
+			});
+		}
+	} finally {
+		n.finalize();
+	}
+	return r;
+}
+function z(e, t) {
+	t.length !== 0 && r(e, () => {
+		for (let n of t) {
+			let t = e.prepare(`DELETE FROM ${j} WHERE command_id = ?;`);
+			try {
+				t.bind([n]), t.step();
+			} finally {
+				t.finalize();
+			}
+		}
+	});
+}
+function B(e) {
+	let t = e.prepare(`SELECT COUNT(1) AS count FROM ${j};`);
+	try {
+		return t.step() ? Number(t.get([])[0] ?? 0) : 0;
+	} finally {
+		t.finalize();
+	}
+}
+function V(e) {
+	let t = e.prepare(`
+    SELECT status, COUNT(1) AS count
+    FROM ${j}
+    GROUP BY status;
+  `), n = {
+		pending: 0,
+		permanentlyFailed: 0
+	};
+	try {
+		for (; t.step();) {
+			let e = t.get([]), r = Number(e[1] ?? 0);
+			I(e[0]) === "PERMANENTLY_FAILED" ? n.permanentlyFailed = r : n.pending = r;
+		}
+	} finally {
+		t.finalize();
+	}
+	return n;
+}
+function H(e, t, n, i) {
+	t.length !== 0 && (F(i, "maxRetryCount"), r(e, () => {
+		for (let r of t) {
+			let t = e.prepare(`
+        UPDATE ${j}
+        SET retry_count = retry_count + 1,
+            last_error = ?,
+            status = CASE
+              WHEN retry_count + 1 >= ? THEN '${N}'
+              ELSE status
+            END
+        WHERE command_id = ?;
+      `);
+			try {
+				t.bind([
+					n,
+					i,
+					r
+				]), t.step();
+			} finally {
+				t.finalize();
+			}
+		}
+	}));
+}
+function U(e, t, n) {
+	t.length !== 0 && r(e, () => {
+		for (let r of t) {
+			let t = e.prepare(`
+        UPDATE ${j}
+        SET status = '${N}', last_error = ?
+        WHERE command_id = ?;
+      `);
+			try {
+				t.bind([n, r]), t.step();
+			} finally {
+				t.finalize();
+			}
+		}
+	});
+}
+var se = o({
+	enqueue: (e, t) => (L(e, t.command), null),
+	getPendingBatch: (e, t) => R(e, t.batchSize),
+	deleteCommands: (e, t) => (z(e, t.commandIds), null),
+	getQueueSize: (e) => B(e),
+	getStatusCounts: (e) => V(e),
+	markCommandsRetryable: (e, t) => {
+		let n = t;
+		return H(e, n.commandIds, n.lastError, n.maxRetryCount), null;
+	},
+	markCommandsPermanentlyFailed: (e, t) => {
+		let n = t;
+		return U(e, n.commandIds, n.lastError), null;
+	}
+});
+//#endregion
+//#region src/offline-queue/createOfflineQueueClient.ts
+function ce(e) {
+	let t = /* @__PURE__ */ new Map();
+	return {
+		async enqueue(n) {
+			if (e.runtime.shouldUseInMemoryFallback()) {
+				t.set(n.commandId, {
+					...n,
+					status: M,
+					retryCount: 0,
+					lastError: null
+				});
+				return;
+			}
+			await e.transport.sendWorkerRequest({
+				type: "enqueue",
+				command: n
+			});
+		},
+		async getBatch(n) {
+			if (!Number.isInteger(n) || n <= 0) throw Error("batchSize must be a positive integer.");
+			return e.runtime.shouldUseInMemoryFallback() ? [...t.values()].filter((e) => e.status === M).sort((e, t) => e.createdAt - t.createdAt).slice(0, n) : await e.transport.sendWorkerRequest({
+				type: "getPendingBatch",
+				batchSize: n
+			});
+		},
+		async delete(n) {
+			if (e.runtime.shouldUseInMemoryFallback()) {
+				for (let e of n) t.delete(e);
+				return;
+			}
+			await e.transport.sendWorkerRequest({
+				type: "deleteCommands",
+				commandIds: n
+			});
+		},
+		async markRetryable(n, r, i) {
+			if (n.length !== 0) {
+				if (!Number.isInteger(i) || i <= 0) throw Error("maxRetryCount must be a positive integer.");
+				if (e.runtime.shouldUseInMemoryFallback()) {
+					for (let e of n) {
+						let n = t.get(e);
+						if (!n) continue;
+						let a = n.retryCount + 1;
+						t.set(e, {
+							...n,
+							retryCount: a,
+							lastError: r,
+							status: a >= i ? N : n.status
+						});
+					}
+					return;
+				}
+				await e.transport.sendWorkerRequest({
+					type: "markCommandsRetryable",
+					commandIds: n,
+					lastError: r,
+					maxRetryCount: i
+				});
+			}
+		},
+		async markPermanentlyFailed(n, r) {
+			if (n.length !== 0) {
+				if (e.runtime.shouldUseInMemoryFallback()) {
+					for (let e of n) {
+						let n = t.get(e);
+						n && t.set(e, {
+							...n,
+							lastError: r,
+							status: N
+						});
+					}
+					return;
+				}
+				await e.transport.sendWorkerRequest({
+					type: "markCommandsPermanentlyFailed",
+					commandIds: n,
+					lastError: r
+				});
+			}
+		},
+		async getSize() {
+			return e.runtime.shouldUseInMemoryFallback() ? t.size : await e.transport.sendWorkerRequest({ type: "getQueueSize" });
+		},
+		async getStatusCounts() {
+			if (!e.runtime.shouldUseInMemoryFallback()) return await e.transport.sendWorkerRequest({ type: "getStatusCounts" });
+			let n = 0, r = 0;
+			for (let e of t.values()) e.status === "PERMANENTLY_FAILED" ? r += 1 : n += 1;
+			return {
+				pending: n,
+				permanentlyFailed: r
+			};
+		},
+		dispose: e.runtime.registerInMemoryStore(t)
+	};
+}
+//#endregion
+//#region src/offline-queue/createOfflineQueueStatus.ts
+var W = {
+	pending: 0,
+	permanentlyFailed: 0
+};
+function le(e) {
+	let t = /* @__PURE__ */ new Set(), n = {
+		...W,
+		enqueueTick: 0
+	}, r = (e) => {
+		if (e.pending !== n.pending || e.permanentlyFailed !== n.permanentlyFailed || e.enqueueTick !== n.enqueueTick) {
+			n = e;
+			for (let e of t) e(n);
+		}
+	};
+	return {
+		getSnapshot: () => n,
+		subscribe(e) {
+			return t.add(e), () => t.delete(e);
+		},
+		markEnqueued() {
+			r({
+				...n,
+				enqueueTick: n.enqueueTick + 1
+			});
+		},
+		async refresh() {
+			try {
+				let t = await e.readStatusCounts();
+				r({
+					...t,
+					enqueueTick: n.enqueueTick
+				});
+			} catch (t) {
+				e.onReadError?.(t);
+			}
+		},
+		resetCounts() {
+			r({
+				...W,
+				enqueueTick: n.enqueueTick
+			});
+		}
+	};
+}
+//#endregion
+//#region src/offline-queue/replayOfflineSyncBatch.ts
+var ue = /* @__PURE__ */ new Set(["REJECTED", "RETRY_LIMIT_EXCEEDED"]);
+function de(e) {
+	return !e.success && e.reason != null && ue.has(e.reason);
+}
+function fe(e) {
+	return {
+		commandId: e.commandId,
+		method: e.method,
+		url: e.url,
+		body: e.body,
+		headers: e.headers
+	};
+}
+async function pe(e) {
+	let { batchSize: t, maxAttempts: n, dependencies: r } = e;
+	if (!Number.isInteger(t) || t <= 0) throw Error("batchSize must be a positive integer.");
+	if (!Number.isInteger(n) || n <= 0) throw Error("maxAttempts must be a positive integer.");
+	let i = await r.getBatch(t);
+	if (i.length === 0) return 0;
+	let a = await r.sendBatch(i.map(fe)), o = new Map(a.results.map((e) => [e.commandId, e])), s = [], c = [], l = [], u = null, d = null;
+	for (let e of i) {
+		let t = o.get(e.commandId);
+		t ? t.success ? s.push(e.commandId) : de(t) ? (c.push(e.commandId), u = t.error ?? u) : (l.push(e.commandId), d = t.error ?? d) : l.push(e.commandId);
+	}
+	let f = new Set(s);
+	return await r.cleanupSuccessfulCommands(i.filter((e) => f.has(e.commandId))), s.length > 0 && await r.deleteSuccessful(s), await r.markPermanentlyFailed(c, u), await r.markRetryable(l, d, n), await r.refreshStatus(), s.length;
+}
+//#endregion
+//#region src/runtime/createManagedSqliteRuntime.ts
+function me() {
+	return typeof performance < "u" && typeof performance.now == "function" ? performance.now() : Date.now();
+}
+function he(e) {
+	let t = e.bootLogPrefix ?? "[SQLITE-BOOT]", n = e.now ?? me, r = /* @__PURE__ */ new Set(), i = /* @__PURE__ */ new Map(), a = null, o = 1, s = !1, c = null, l = 0, u = !1, d = (n, ...r) => {
+		e.debug && console.debug(`${t} ${n}`, ...r);
+	}, f = () => {
+		if (u) throw Error("SQLite runtime has been disposed.");
+	}, p = (e) => {
+		for (let t of i.values()) t.reject(e);
+		i.clear();
+	}, m = (e) => {
+		a?.terminate(), a = null, s = !1, c = null, l += 1, p(e);
+	}, h = () => (f(), a || (a = e.workerFactory(), a.addEventListener("message", (e) => {
+		let t = e.data, n = i.get(t.id);
+		n && (i.delete(t.id), t.ok ? n.resolve(t.result) : n.reject(Error(t.error)));
+	}), a.addEventListener("error", (e) => {
+		let t = e.error instanceof Error ? e.error : Error(e.message);
+		m(t);
+	}), a.addEventListener("messageerror", () => {
+		m(/* @__PURE__ */ Error("SQLite worker returned an unreadable message."));
+	}), a)), g = async (e) => {
+		let t = o++, n = h();
+		return await new Promise((r, a) => {
+			i.set(t, {
+				resolve: (e) => r(e),
+				reject: a
+			});
+			try {
+				n.postMessage({
+					id: t,
+					...e
+				});
+			} catch (e) {
+				i.delete(t), a(e);
+			}
+		});
+	}, _ = async () => {
+		if (f(), s) return;
+		if (c) return await c;
+		let e = n(), t = ++l;
+		d("client init request -> worker");
+		let r = (async () => {
+			try {
+				await g({ type: "init" }), s = !0, d(`client init completed in ${Math.round(n() - e)}ms`);
+			} catch (t) {
+				throw d(`client init failed after ${Math.round(n() - e)}ms`, t), t;
+			} finally {
+				l === t && (c = null);
+			}
+		})();
+		c = r, await r;
+	};
+	return {
+		registerInMemoryStore(e) {
+			return r.add(e), () => r.delete(e);
+		},
+		clearInMemoryStores() {
+			for (let e of r) e.clear();
+		},
+		shouldUseInMemoryFallback: () => e.shouldUseInMemoryFallback?.() ?? !1,
+		send: g,
+		ensureInitialized: _,
+		warmup: _,
+		reset() {
+			f(), m(/* @__PURE__ */ Error("SQLite runtime was reset."));
+		},
+		dispose() {
+			u || (u = !0, m(/* @__PURE__ */ Error("SQLite runtime was disposed.")), r.clear());
+		}
+	};
+}
+//#endregion
+//#region src/runtime/createSqliteEntityClient.ts
+function G(e, t, n) {
+	return {
+		type: e,
+		[t]: n
+	};
+}
+function ge(e) {
+	let t = /* @__PURE__ */ new Map();
+	return e.runtime.registerInMemoryStore(t), {
+		async replace(n) {
+			if (e.runtime.shouldUseInMemoryFallback()) {
+				t.clear();
+				for (let r of n) t.set(e.getKey(r), r);
+				return;
+			}
+			await e.transport.sendWorkerRequest(G(e.requests.replace.type, e.requests.replace.payloadKey, n));
+		},
+		async upsert(n) {
+			if (e.runtime.shouldUseInMemoryFallback()) {
+				t.set(e.getKey(n), n);
+				return;
+			}
+			await e.transport.sendWorkerRequest(G(e.requests.upsert.type, e.requests.upsert.payloadKey, n));
+		},
+		async list() {
+			return e.runtime.shouldUseInMemoryFallback() ? [...t.values()].sort(e.compare) : await e.transport.sendWorkerRequest({ type: e.requests.list.type });
+		},
+		async delete(n) {
+			if (e.runtime.shouldUseInMemoryFallback()) {
+				for (let e of n) t.delete(e);
+				return;
+			}
+			await e.transport.sendWorkerRequest(G(e.requests.delete.type, e.requests.delete.payloadKey, n));
+		}
+	};
+}
+//#endregion
+//#region src/runtime/createSqliteTransport.ts
+function _e({ runtime: e, createUnavailableError: t }) {
+	let n = t ?? ((e) => /* @__PURE__ */ Error(`SQLite request '${e}' is unavailable in this runtime.`));
+	return {
+		async sendRequest(t, r) {
+			if (e.shouldUseInMemoryFallback()) throw n(t);
+			return await e.ensureInitialized(), await e.send({
+				type: t,
+				...r ?? {}
+			});
+		},
+		async sendWorkerRequest(t) {
+			return await e.ensureInitialized(), await e.send(t);
+		}
+	};
+}
+//#endregion
+//#region src/core/sqliteRuntime.ts
+function K() {
+	return typeof performance < "u" && typeof performance.now == "function" ? performance.now() : Date.now();
+}
+function q(e) {
+	return e instanceof Error ? e.message : "Unknown worker error";
+}
+function ve(e) {
+	let t = typeof navigator < "u", n = t && navigator.storage != null;
+	return {
+		crossOriginIsolated: globalThis.crossOriginIsolated === !0,
+		hasSharedArrayBuffer: typeof SharedArrayBuffer < "u",
+		hasNavigator: t,
+		hasNavigatorStorage: n,
+		hasStorageGetDirectory: n && typeof navigator.storage.getDirectory == "function",
+		hasOpfsDbCtor: typeof e.oo1.OpfsDb == "function",
+		hasSqliteOpfsNamespace: e.opfs != null
+	};
+}
+function J(e) {
+	let t = ve(e);
+	return Object.entries(t).map(([e, t]) => `${e}=${String(t)}`).join(", ");
+}
+function ye(e, t) {
+	if (typeof e.oo1.OpfsDb != "function") throw Error(`[offline-sqlite] OPFS database constructor is unavailable. Diagnostics: ${J(e)}.`);
+	try {
+		return new e.oo1.OpfsDb(t);
+	} catch (t) {
+		throw Error(`[offline-sqlite] Failed to open OPFS SQLite database: ${q(t)}. Diagnostics: ${J(e)}.`);
+	}
+}
+function be(e, t) {
+	let n = e.prepare(t);
+	try {
+		if (!n.step()) return 0;
+		let e = n.get([]);
+		return Number(e[0] ?? 0);
+	} finally {
+		n.finalize();
+	}
+}
+function Y(e) {
+	return be(e, "PRAGMA user_version;");
+}
+function xe(e, t) {
+	e.exec(`PRAGMA user_version = ${t};`);
+}
+function Se(e, t) {
+	let n = K();
+	e.exec("BEGIN;");
+	try {
+		let r = Y(e);
+		`${r}${t.length}`;
+		for (let n = r; n < t.length; n += 1) {
+			let r = K();
+			t[n](e), xe(e, n + 1), `${n + 1}${Math.round(K() - r)}`;
+		}
+		if (Y(e) > t.length) throw Error("Database schema version is newer than supported client version.");
+		e.exec("COMMIT;"), `${Math.round(K() - n)}`;
+	} catch (t) {
+		throw e.exec("ROLLBACK;"), `${Math.round(K() - n)}`, t;
+	}
+}
+async function Ce(e, t) {
+	let r = K(), i = K(), a = await n();
+	`${Math.round(K() - i)}`;
+	let o = K(), s = ye(a, e);
+	`${Math.round(K() - o)}`;
+	let c = K();
+	return Se(s, t), `${Math.round(K() - c)}`, `${Math.round(K() - r)}`, s;
+}
+//#endregion
+//#region src/core/sqliteWorkerRuntime.ts
+function X() {
+	return typeof performance < "u" && typeof performance.now == "function" ? performance.now() : Date.now();
+}
+function we(e) {
+	let t = e.bootLogPrefix ?? "[SQLITE-BOOT]", n = null, r = null;
+	function i(n, ...r) {
+		e.debug && console.debug(`${t} ${n}`, ...r);
+	}
+	function a(e, t) {
+		e.postMessage(t);
+	}
+	function o() {
+		if (n == null) throw Error("SQLite database is not initialized.");
+		return n;
+	}
+	async function s() {
+		if (n != null) return;
+		if (r != null) {
+			i("worker init wait for in-flight initialization"), await r;
+			return;
+		}
+		let t = X();
+		i("worker init start"), r = (async () => {
+			try {
+				n = await Ce(e.dbFile, e.migrations), i(`worker init done in ${Math.round(X() - t)}ms`);
+			} finally {
+				r = null;
+			}
+		})(), await r;
+	}
+	async function l(t) {
+		return await c(o(), t, e.requestHandlers);
+	}
+	async function u(e, t) {
+		try {
+			if (await s(), t.type === "init") {
+				a(e, {
+					id: t.id,
+					ok: !0,
+					result: null
+				});
+				return;
+			}
+			let n = await l(t);
+			if (n !== void 0) {
+				a(e, {
+					id: t.id,
+					ok: !0,
+					result: n
+				});
+				return;
+			}
+			throw Error(`Unsupported worker request: ${JSON.stringify(t)}`);
+		} catch (n) {
+			a(e, {
+				id: t.id,
+				ok: !1,
+				error: q(n)
+			});
+		}
+	}
+	function d(e) {
+		e.addEventListener("message", async (t) => {
+			await u(e, t.data);
+		});
+	}
+	return {
+		attach: d,
+		handleRequest: u
+	};
+}
+//#endregion
+//#region src/sqliteWorkerConfig.ts
+function Te(e) {
+	if (e.dbFile.trim().length === 0) throw Error("SQLite worker configuration requires a non-empty dbFile.");
+	return {
+		dbFile: e.dbFile,
+		migrations: e.migrations,
+		debug: e.debug,
+		requestHandlers: s(...e.entityBundles.map((e) => e.requestHandlers), ...e.extraRequestHandlers ?? [])
+	};
+}
+//#endregion
+//#region src/runtime/hydrationEntityStateSqlite.ts
+var Z = "hydration_entity_state";
+function Ee(e) {
+	let t = e.prepare(`
+    SELECT entity_key, applied_revision, is_stale, last_hydrated_at, last_row_count, last_error
+    FROM ${Z}
+    ORDER BY entity_key ASC;
+  `), n = [];
+	try {
+		for (; t.step();) {
+			let e = t.get([]);
+			n.push({
+				entityKey: String(e[0] ?? ""),
+				appliedRevision: Number(e[1] ?? 0),
+				isStale: Number(e[2] ?? 0) === 1,
+				lastHydratedAt: e[3] == null ? null : Number(e[3]),
+				lastRowCount: e[4] == null ? null : Number(e[4]),
+				lastError: e[5] == null ? null : String(e[5])
+			});
+		}
+	} finally {
+		t.finalize();
+	}
+	return n;
+}
+function De(e, t) {
+	let n = e.prepare(`
+    INSERT INTO ${Z}
+      (entity_key, applied_revision, is_stale, last_hydrated_at, last_row_count, last_error)
+    VALUES (?, ?, ?, ?, ?, ?)
+    ON CONFLICT(entity_key) DO UPDATE SET
+      applied_revision = excluded.applied_revision,
+      is_stale = excluded.is_stale,
+      last_hydrated_at = excluded.last_hydrated_at,
+      last_row_count = excluded.last_row_count,
+      last_error = excluded.last_error;
+  `);
+	try {
+		n.bind([
+			t.entityKey,
+			t.appliedRevision,
+			+!!t.isStale,
+			t.lastHydratedAt,
+			t.lastRowCount,
+			t.lastError
+		]), n.step();
+	} finally {
+		n.finalize();
+	}
+}
+var Oe = o({
+	listHydrationEntityStates: (e) => Ee(e),
+	upsertHydrationEntityState: (e, t) => (De(e, t.state), null)
+});
+//#endregion
+//#region src/runtime/sqlConsoleSqlite.ts
+function Q() {
+	return typeof performance < "u" && typeof performance.now == "function" ? performance.now() : Date.now();
+}
+function ke(e, t) {
+	let n = e.prepare(t);
+	try {
+		if (!n.step()) return 0;
+		let e = n.get([]);
+		return Number(e[0] ?? 0);
+	} finally {
+		n.finalize();
+	}
+}
+function Ae(e) {
+	return e.split(";").map((e) => e.trim()).filter((e) => e.length > 0);
+}
+function je(e, t) {
+	let n = Ae(t);
+	if (n.length === 0) return { statements: [] };
+	let r = [];
+	for (let t of n) {
+		let n = e.prepare(t);
+		try {
+			let i = n.getColumnNames?.([]) ?? [], a = [];
+			for (; n.step();) a.push(n.get([]));
+			let o = ke(e, "SELECT changes();");
+			r.push({
+				statement: t,
+				columns: i,
+				rows: a,
+				rowsAffected: o
+			});
+		} finally {
+			n.finalize();
+		}
+	}
+	return { statements: r };
+}
+function $(e, t) {
+	let n = Q(), r = Number.isFinite(t.clientSentAtMs) && t.clientSentAtMs != null ? Math.max(0, Math.round(n - t.clientSentAtMs)) : void 0, i = [];
+	t.limit != null && t.limit > 0 && (i.push(`LIMIT ${t.limit}`), t.offset != null && t.offset > 0 && i.push(`OFFSET ${t.offset}`));
+	let a = `
+    SELECT ${t.selectSql}
+    FROM ${t.fromSql}
+    WHERE ${t.whereSql}
+    ORDER BY ${t.orderBySql}
+    ${i.join(" ")};
+  `, o = e.prepare(a), s = [], c = [];
+	try {
+		for (s = o.getColumnNames?.([]) ?? []; o.step();) c.push(o.get([]));
+	} finally {
+		o.finalize();
+	}
+	if (t.includeTotalCount === !1) return {
+		columns: s,
+		rows: c,
+		totalElements: null,
+		queueWaitMs: r,
+		workerExecMs: Math.round(Q() - n)
+	};
+	let l = `
+    SELECT COUNT(*) AS total_elements
+    FROM ${t.fromSql}
+    WHERE ${t.whereSql};
+  `, u = e.prepare(l);
+	try {
+		if (!u.step()) return {
+			columns: s,
+			rows: c,
+			totalElements: 0,
+			queueWaitMs: r,
+			workerExecMs: Math.round(Q() - n)
+		};
+		let e = u.get([]);
+		return {
+			columns: s,
+			rows: c,
+			totalElements: Number(e[0] ?? 0),
+			queueWaitMs: r,
+			workerExecMs: Math.round(Q() - n)
+		};
+	} finally {
+		u.finalize();
+	}
+}
+var Me = o({
+	executeSqlScript: (e, t) => je(e, t.script),
+	executePagedQuery: (e, t) => $(e, t)
+});
+//#endregion
+export { Oe as HYDRATION_ENTITY_STATE_SQLITE_REQUEST_HANDLERS, M as OFFLINE_QUEUE_PENDING, N as OFFLINE_QUEUE_PERMANENTLY_FAILED, se as OFFLINE_QUEUE_STATE_SQLITE_REQUEST_HANDLERS, Me as SQL_CONSOLE_SQLITE_REQUEST_HANDLERS, O as createDatabaseOwnerStore, _ as createHydrationContributorRegistry, b as createHydrationController, x as createHydrationEntityClient, C as createHydrationGate, w as createHydrationRequestQueue, E as createHydrationStatus, D as createLocalReflectionQueue, he as createManagedSqliteRuntime, k as createOfflineDataLifecycle, ae as createOfflineQueueCapture, ce as createOfflineQueueClient, le as createOfflineQueueStatus, ie as createOpfsDatabaseFiles, g as createSqlConsoleClient, d as createSqliteEntityBundle, ge as createSqliteEntityClient, p as createSqliteOperationCoordinator, o as createSqliteRequestHandlers, _e as createSqliteTransport, we as createSqliteWorkerRuntime, Te as createSqliteWorkerRuntimeConfig, z as deleteOfflineCommands, a as deleteSqliteRowsByKey, c as dispatchSqliteRequest, L as enqueueOfflineCommand, $ as executePagedQuery, je as executeSqlScript, B as getOfflineQueueSize, V as getOfflineQueueStatusCounts, R as getPendingOfflineCommands, Ee as listHydrationEntityStates, i as listSqliteRows, U as markOfflineCommandsPermanentlyFailed, H as markOfflineCommandsRetryable, s as mergeSqliteRequestHandlers, pe as replayOfflineSyncBatch, r as runSqliteTransaction, De as upsertHydrationEntityState };
+
+//# sourceMappingURL=index.js.map