@aiao/rxdb-adapter-electron 0.0.0-stage → 0.0.28

package/dist/pglite-host.js

@@ -0,0 +1,738 @@
+import { DESKTOP_PGLITE_DEFAULT_BEGIN_TIMEOUT_MS as e, DESKTOP_PGLITE_EXCLUDED_FILES as t, DESKTOP_PGLITE_EXCLUDED_FILES as n, DESKTOP_PGLITE_MAX_BEGIN_TIMEOUT_MS as r, DESKTOP_PGLITE_MAX_DATA_CHUNK_BYTES as i, DESKTOP_PGLITE_MAX_DATA_CHUNK_BYTES as a, DESKTOP_PGLITE_PROTOCOL_VERSION as o, DESKTOP_PGLITE_PROTOCOL_VERSION as s, RxDBAdapterDesktopError as c, RxDBAdapterDesktopError as l, assertValidDesktopDatabaseName as u, isDesktopPgliteRequestKind as d, parseDesktopPgliteRequest as f, parseDesktopPgliteRequest as p } from "@aiao/rxdb-adapter-sqlite-core/desktop-host";
+import { randomUUID as m } from "node:crypto";
+import { DatabaseSync as h } from "node:sqlite";
+import { lstat as g, mkdir as _, open as v, readdir as y, rm as b } from "node:fs/promises";
+import { basename as x, dirname as S, join as C } from "node:path";
+import { mkdirSync as w } from "node:fs";
+//#region src/pglite-host/pglite-host-data-dir.ts
+var T = /* @__PURE__ */ new Map([
+	["ENOSPC", "disk_full"],
+	["EDQUOT", "disk_full"],
+	["EACCES", "permission_denied"],
+	["EPERM", "permission_denied"],
+	["EROFS", "permission_denied"],
+	["ENOENT", "file_not_found"]
+]), E = (e) => {
+	let t = e?.code;
+	return typeof t == "string" ? t : void 0;
+}, D = (e, t) => {
+	if (e instanceof l) return e;
+	let n = T.get(E(e) ?? "") ?? "host_internal_error";
+	return new l(n, t, { cause: e });
+}, O = async (e) => (await y(e)).filter((e) => !n.has(e)).sort();
+async function* k(e, t, n) {
+	let r = await v(e, "r");
+	try {
+		let e = 0;
+		for (; e < t;) {
+			let i = new Uint8Array(Math.min(a, t - e)), { bytesRead: o } = await r.read(i, 0, i.length, e);
+			if (o <= 0) throw new l("host_internal_error", `data file shrank while being read: ${n}`);
+			yield {
+				type: "data",
+				bytes: o === i.length ? i : i.slice(0, o)
+			}, e += o;
+		}
+	} finally {
+		await r.close();
+	}
+}
+async function* A(e, t) {
+	for (let n of await O(e)) {
+		let r = C(e, n), i = t === "" ? n : `${t}/${n}`, a = await g(r);
+		if (a.isDirectory()) {
+			yield {
+				type: "entry",
+				header: {
+					path: i,
+					kind: "directory",
+					size: 0
+				}
+			}, yield* A(r, i);
+			continue;
+		}
+		if (!a.isFile()) throw new l("host_internal_error", `unsupported file type in the data directory: ${i}`);
+		yield {
+			type: "entry",
+			header: {
+				path: i,
+				kind: "file",
+				size: a.size
+			}
+		}, yield* k(r, a.size, i);
+	}
+}
+async function* ee(e) {
+	try {
+		yield* A(e, "");
+	} catch (e) {
+		throw D(e, "failed to read the PGlite data directory");
+	}
+}
+var j = async (e) => {
+	try {
+		return (await y(e)).length === 0;
+	} catch (e) {
+		let t = E(e);
+		if (t === "ENOENT") return !0;
+		if (t === "ENOTDIR") return !1;
+		throw D(e, "failed to inspect the restore target");
+	}
+}, M = async (e) => {
+	try {
+		return (await g(C(e, "PG_VERSION"))).isFile();
+	} catch (e) {
+		if (E(e) === "ENOENT") return !1;
+		throw D(e, "failed to inspect the PGlite data directory");
+	}
+}, N = async (e, t) => {
+	let n = await v(e, t);
+	try {
+		await n.sync();
+	} finally {
+		await n.close();
+	}
+}, P = async (e) => {
+	process.platform !== "win32" && await N(e, "r");
+}, F = async (e) => {
+	for (let t of await y(e)) {
+		let n = C(e, t);
+		(await g(n)).isDirectory() ? await F(n) : await N(n, "r+");
+	}
+	await P(e);
+}, I = async (e) => {
+	try {
+		await F(e), await P(S(e));
+	} catch (e) {
+		throw D(e, "failed to persist the restored PGlite data directory");
+	}
+}, L = async (e) => {
+	try {
+		await b(e, {
+			recursive: !0,
+			force: !0,
+			maxRetries: 3
+		});
+	} catch (e) {
+		throw D(e, "failed to remove the PGlite data directory");
+	}
+}, R = (e) => C(S(e), `.${x(e)}.rxdb-lock`), z = "\n  PRAGMA busy_timeout = 0;\n  PRAGMA locking_mode = EXCLUSIVE;\n  PRAGMA journal_mode = DELETE;\n  PRAGMA synchronous = FULL;\n  BEGIN EXCLUSIVE;\n  CREATE TABLE IF NOT EXISTS holder (id INTEGER PRIMARY KEY, pid INTEGER NOT NULL);\n  CREATE TABLE IF NOT EXISTS restore_marker (id INTEGER PRIMARY KEY, created_at TEXT NOT NULL);\n", B = /* @__PURE__ */ new Map([
+	[3, "permission_denied"],
+	[5, "database_busy"],
+	[6, "database_busy"],
+	[8, "permission_denied"],
+	[13, "disk_full"],
+	[23, "permission_denied"]
+]), V = (e, t, n) => {
+	let r = e?.errcode, i = typeof r == "number" ? B.get(r & 255) : void 0;
+	return new l(i ?? t, n, { cause: e });
+}, H = (e, t) => {
+	try {
+		w(S(e), {
+			recursive: !0,
+			mode: 448
+		});
+	} catch (e) {
+		throw D(e, "failed to create the parent of the PGlite data directory");
+	}
+	try {
+		return new h(e);
+	} catch (e) {
+		throw V(e, "open_failed", `failed to open the lock of PGlite data directory "${x(t)}"`);
+	}
+}, U = (e) => {
+	let t = H(R(e), e);
+	try {
+		t.exec(z), t.prepare("INSERT OR REPLACE INTO holder (id, pid) VALUES (1, ?)").run(process.pid), t.exec("COMMIT");
+	} catch (n) {
+		throw t.close(), V(n, "open_failed", `failed to lock PGlite data directory "${x(e)}"`);
+	}
+	let n = !1, r = (e, t) => {
+		try {
+			return e();
+		} catch (e) {
+			throw V(e, "host_internal_error", t);
+		}
+	};
+	return {
+		hasMarker: () => r(() => t.prepare("SELECT 1 FROM restore_marker LIMIT 1").get() !== void 0, "failed to read the restore marker"),
+		markRestoring: () => r(() => {
+			t.prepare("INSERT OR REPLACE INTO restore_marker (id, created_at) VALUES (1, ?)").run((/* @__PURE__ */ new Date()).toISOString());
+		}, "failed to persist the restore marker"),
+		clearRestoring: () => r(() => {
+			t.exec("DELETE FROM restore_marker");
+		}, "failed to remove the restore marker"),
+		release: () => {
+			n || (n = !0, t.close());
+		}
+	};
+}, W = (e) => ({
+	rows: e.rows,
+	fields: e.fields.map((e) => ({
+		name: e.name,
+		dataTypeID: e.dataTypeID
+	})),
+	affectedRows: e.affectedRows
+}), G = async (e) => {
+	try {
+		return await e();
+	} catch (e) {
+		throw e instanceof l ? e : new l("statement_failed", e instanceof Error ? e.message : String(e), { cause: e });
+	}
+}, K = Symbol("transaction begin timed out"), q = async (e, t) => {
+	let n;
+	try {
+		return await Promise.race([e, new Promise((e) => {
+			n = setTimeout(() => e(K), t);
+		})]);
+	} finally {
+		clearTimeout(n);
+	}
+}, J = async (e, t) => {
+	let n, r = new Promise((e, t) => {
+		n = {
+			resolve: e,
+			reject: t
+		};
+	});
+	r.catch(() => void 0);
+	let i, a = new Promise((e) => {
+		i = e;
+	}), o = e.transaction(async (e) => {
+		i(e), await r;
+	});
+	o.catch(() => void 0);
+	let s = await q(a, t);
+	if (s === K) throw n.reject(new l("transaction_unavailable", "the begin that opened this transaction timed out")), new l("transaction_unavailable", `waited ${t}ms for the PGlite connection but another transaction still holds it`);
+	return {
+		tx: s,
+		settle: n,
+		finished: o
+	};
+}, Y = /* @__PURE__ */ new Set([
+	"EEXIST",
+	"ENOENT",
+	"ENOTDIR"
+]), X = (e, t) => new l("database_corrupted", e, t), te = (e) => e instanceof l ? e : Y.has(E(e) ?? "") ? X("the archive does not describe a valid directory tree", { cause: e }) : D(e, "failed to write the restored PGlite data directory"), Z = (e, t) => new l("protocol_violation", `${t} is not allowed while the restore is ${e.stage}`), Q = (e, t, n) => {
+	if (e.stage !== t) throw Z(e, n);
+}, ne = async (e, t) => {
+	let n = e.file;
+	if (n === void 0) throw X("a data chunk arrived without a file entry");
+	if (n.written + t.byteLength > n.size) throw X(`the data of "${n.path}" exceeds its declared size`);
+	await n.handle.writeFile(t), n.written += t.byteLength, !(n.written < n.size) && (e.file = void 0, await n.handle.close());
+}, re = async (e, t) => {
+	if (e.file !== void 0) throw X(`the data of "${e.file.path}" is incomplete`);
+	let n = C(e.directory, ...t.path.split("/"));
+	if (t.kind === "directory") {
+		await _(n, { mode: 448 });
+		return;
+	}
+	let r = await v(n, "wx", 384);
+	if (t.size === 0) {
+		await r.close();
+		return;
+	}
+	e.file = {
+		handle: r,
+		path: t.path,
+		size: t.size,
+		written: 0
+	};
+}, ie = (e) => {
+	let t = /* @__PURE__ */ new Set(), n = /* @__PURE__ */ new Map(), r = async (n, r) => {
+		if (await e.isInUse(n) || t.has(n)) throw new l("database_busy", `"${n}" is open or being restored in this host`);
+		t.add(n);
+		try {
+			return U(r);
+		} catch (e) {
+			throw t.delete(n), e;
+		}
+	}, i = (e, n) => {
+		t.delete(e), n.release();
+	}, a = async (e, t, n) => {
+		try {
+			await L(t), n.clearRestoring();
+		} catch (t) {
+			throw new l("cleanup_pending", `the incomplete restore of "${e}" could not be removed; run pg.restore.cleanup to retry`, { cause: t });
+		}
+	}, o = async (t, a) => {
+		let o = t.storage.dataDirectoryName, s = e.resolveDataDirectory(o), c = await r(o, s);
+		try {
+			if (c.hasMarker()) throw new l("restore_incomplete", `a restore of "${o}" did not finish; run pg.restore.cleanup first`);
+			if (!await j(s)) throw new l("target_not_empty", `"${o}" already holds data`);
+		} catch (e) {
+			throw i(o, c), e;
+		}
+		let u = m();
+		return n.set(u, {
+			id: u,
+			owner: a,
+			dataDirectoryName: o,
+			directory: s,
+			lock: c,
+			stage: "begun",
+			marked: !1,
+			file: void 0,
+			runtime: void 0,
+			tail: Promise.resolve(),
+			finished: !1
+		}), {
+			kind: "pg.restore.begin",
+			result: { restoreId: u }
+		};
+	}, s = async (t) => {
+		let n = t.storage.dataDirectoryName, o = e.resolveDataDirectory(n), s = await r(n, o);
+		try {
+			return s.hasMarker() ? (await a(n, o, s), {
+				kind: "pg.restore.cleanup",
+				result: { cleaned: !0 }
+			}) : {
+				kind: "pg.restore.cleanup",
+				result: { cleaned: !1 }
+			};
+		} finally {
+			i(n, s);
+		}
+	}, c = (e, t) => {
+		let r = n.get(e);
+		if (r === void 0) throw new l("transaction_not_found", `restore ${e} is unknown or already finished`);
+		if (r.owner !== t) throw new l("permission_denied", `restore ${e} belongs to another window`);
+		return r;
+	}, u = (e, t) => {
+		let n = e.tail.then(() => {
+			if (e.finished) throw new l("transaction_not_found", `restore ${e.id} is already finished`);
+			return t();
+		});
+		return e.tail = n.then(() => void 0, () => void 0), n;
+	}, d = async (e) => {
+		let { file: t, runtime: n } = e;
+		e.file = void 0, e.runtime = void 0, await t?.handle.close().catch(() => void 0), await n?.close().catch(() => void 0);
+	}, f = async (e, t) => {
+		try {
+			await t();
+		} catch (t) {
+			throw t instanceof l && t.code === "protocol_violation" || (e.stage = "failed", await d(e)), t;
+		}
+	}, p = (e) => {
+		e.finished = !0, n.delete(e.id), i(e.dataDirectoryName, e.lock);
+	}, h = async (e) => {
+		Q(e, "begun", "pg.restore.prepare"), e.lock.markRestoring(), e.marked = !0;
+		try {
+			await _(e.directory, {
+				recursive: !0,
+				mode: 448
+			});
+		} catch (e) {
+			throw D(e, "failed to create the restore target");
+		}
+		e.stage = "prepared";
+	}, g = async (e, t) => {
+		Q(e, "prepared", "pg.restore.write");
+		try {
+			await (t.type === "data" ? ne(e, t.bytes) : re(e, t.header));
+		} catch (e) {
+			throw te(e);
+		}
+	}, v = async (t) => {
+		let n;
+		try {
+			return n = await e.createRuntime(t), await n.query("SELECT 1"), n;
+		} catch (e) {
+			throw await n?.close().catch(() => void 0), X("the restored data directory cannot be opened", { cause: e });
+		}
+	}, y = async (e) => {
+		if (Q(e, "prepared", "pg.restore.open"), e.file !== void 0) throw X(`the data of "${e.file.path}" is incomplete`);
+		if (!await M(e.directory)) throw X("the archive has no PG_VERSION");
+		e.runtime = await v(e.dataDirectoryName), e.stage = "opened";
+	}, b = (e, t) => {
+		let n = e.runtime;
+		if (n === void 0) throw Z(e, t);
+		return n;
+	}, x = async (e, t) => {
+		let n = b(e, t.kind);
+		return W(await G(() => n.query(t.sql, [...t.params])));
+	}, S = async (e) => {
+		let t = b(e, "pg.restore.persist");
+		e.runtime = void 0;
+		try {
+			await t.close();
+		} catch (e) {
+			throw D(e, "failed to close the restored PGlite instance");
+		}
+		await I(e.directory), e.stage = "persisted";
+	}, C = (e) => {
+		Q(e, "persisted", "pg.restore.commit"), e.lock.clearRestoring(), p(e);
+	}, w = async (e) => {
+		try {
+			await d(e), e.marked && await a(e.dataDirectoryName, e.directory, e.lock);
+		} finally {
+			p(e);
+		}
+	}, T = (e) => u(e, async () => {
+		await d(e), p(e);
+	}).catch(() => void 0), E = async (e, t) => {
+		switch (t.kind) {
+			case "pg.restore.prepare": return await f(e, () => h(e)), { kind: "pg.restore.prepare" };
+			case "pg.restore.write": return await f(e, () => g(e, t.item)), { kind: "pg.restore.write" };
+			case "pg.restore.open": return await f(e, () => y(e)), { kind: "pg.restore.open" };
+			case "pg.restore.query": return {
+				kind: "pg.restore.query",
+				result: await x(e, t)
+			};
+			case "pg.restore.persist": return await f(e, () => S(e)), { kind: "pg.restore.persist" };
+			case "pg.restore.commit": return await f(e, async () => C(e)), { kind: "pg.restore.commit" };
+			case "pg.restore.abort": return await w(e), { kind: "pg.restore.abort" };
+			default: throw new l("protocol_violation", `unsupported restore request kind: ${String(t.kind)}`);
+		}
+	}, O = async (e, t) => {
+		let n = c(e.restoreId, t);
+		return u(n, () => E(n, e));
+	};
+	return {
+		get openCount() {
+			return n.size;
+		},
+		isReserved: (e) => t.has(e),
+		handle: async (e, t) => {
+			switch (e.kind) {
+				case "pg.restore.begin": return o(e, t);
+				case "pg.restore.cleanup": return s(e);
+				default: return O(e, t);
+			}
+		},
+		releaseOwner: async (e) => {
+			await Promise.all([...n.values()].filter((t) => t.owner === e).map(T));
+		},
+		closeAll: async () => {
+			await Promise.all([...n.values()].map(T));
+		}
+	};
+}, ae = "desktop-pglite://app-scope", $ = Object.freeze([
+	"rxdb_change_notify",
+	"rxdb_branch_notify",
+	"rxdb_migration_notify"
+]), oe = (e) => e instanceof l ? {
+	kind: "error",
+	code: e.code,
+	message: e.detail
+} : {
+	kind: "error",
+	code: "host_internal_error",
+	message: e instanceof Error ? e.message : String(e)
+}, se = (e, t) => new l("open_failed", `the application could not open a PGlite runtime for ${e}`, { cause: t });
+function ce(e) {
+	let t = /* @__PURE__ */ new Map(), n = /* @__PURE__ */ new Map(), r = /* @__PURE__ */ new Map(), i = /* @__PURE__ */ new Map(), a = /* @__PURE__ */ new Map(), o, c = async (e) => {
+		for (; a.has(e);) await a.get(e);
+		return t.has(e);
+	}, u = e.backup, d = u === void 0 ? void 0 : {
+		options: u,
+		extensions: [...new Set(u.extensions)].sort(),
+		restores: ie({
+			createRuntime: (t) => e.createRuntime(t),
+			resolveDataDirectory: (e) => u.resolveDataDirectory(e),
+			isInUse: c
+		})
+	}, f = (t, n, r) => {
+		try {
+			e.postNotify({
+				kind: "pg.notify",
+				sessionId: t,
+				channel: n,
+				payload: r
+			});
+		} catch (t) {
+			e.onDeliveryError?.(t);
+		}
+	}, h = (e) => {
+		if (d === void 0) return;
+		let t = U(d.options.resolveDataDirectory(e)), n;
+		try {
+			n = t.hasMarker();
+		} catch (e) {
+			throw t.release(), e;
+		}
+		if (!n) return t;
+		throw t.release(), new l("restore_incomplete", `a restore of "${e}" did not finish; run pg.restore.cleanup before connecting`);
+	}, g = async (e, t) => {
+		for (let n of $) await e.listen(n, (e) => {
+			for (let r of t) f(r, n, e);
+		});
+	}, _ = async (t, n) => {
+		let r;
+		try {
+			r = await e.createRuntime(t);
+		} catch (e) {
+			throw se(t, e);
+		}
+		try {
+			await g(r, n);
+		} catch (e) {
+			throw await r.close().catch(() => void 0), se(t, e);
+		}
+		return r;
+	}, v = async (e, t) => {
+		let n = h(e);
+		try {
+			return {
+				runtime: await _(e, t),
+				lock: n
+			};
+		} catch (e) {
+			throw n?.release(), e;
+		}
+	}, y = (e) => {
+		let t = /* @__PURE__ */ new Set();
+		return {
+			sessions: t,
+			pending: 0,
+			ready: v(e, t)
+		};
+	}, b = async (e) => {
+		let { runtime: t, lock: n } = await e.ready;
+		try {
+			await t.close();
+		} finally {
+			n?.release();
+		}
+	}, x = async (e, n) => {
+		t.delete(e);
+		let r = b(n), i = r.then(() => void 0, () => void 0);
+		a.set(e, i);
+		try {
+			await r;
+		} finally {
+			a.get(e) === i && a.delete(e);
+		}
+	}, S = (e, t) => {
+		let r = n.get(e);
+		if (!r) throw new l("session_closed", `session ${e} is not open on this host`);
+		if (r.owner !== t) throw new l("permission_denied", `session ${e} belongs to another window`);
+		return r;
+	}, C = async (e) => {
+		let n = t.get(e.dataDirectoryName);
+		if (!n) throw new l("host_internal_error", `session references a released instance for ${e.dataDirectoryName}`);
+		return (await n.ready).runtime;
+	}, w = (e, t) => {
+		let n = r.get(e);
+		if (!n || n.sessionId !== t) throw new l("transaction_not_found", `transaction ${e} is unknown, already finished, or not owned by session ${t}`);
+		return n;
+	}, T = async (e, t) => {
+		let n = r.get(e);
+		if (!n) return;
+		r.delete(e), t ? n.settle.reject(t) : n.settle.resolve();
+		let i = await n.finished.then(() => void 0, (e) => e);
+		if (!(t || i === void 0)) return i instanceof l ? i : new l("statement_failed", i instanceof Error ? i.message : String(i), { cause: i });
+	}, E = async (e, r) => {
+		let { dataDirectoryName: i } = e.storage;
+		for (; a.has(i);) await a.get(i);
+		if (d?.restores.isReserved(i)) throw new l("restore_in_progress", `"${i}" is being restored`);
+		let o = t.get(i) ?? y(i);
+		t.set(i, o), o.pending += 1;
+		try {
+			await o.ready;
+		} catch (e) {
+			throw t.get(i) === o && t.delete(i), e;
+		} finally {
+			--o.pending;
+		}
+		let c = m();
+		return o.sessions.add(c), n.set(c, {
+			dataDirectoryName: i,
+			owner: r
+		}), {
+			kind: "pg.open",
+			result: {
+				sessionId: c,
+				resolvedLocation: `${ae}/${i}`,
+				protocolVersion: s
+			}
+		};
+	}, D = async (e) => {
+		let r = n.get(e);
+		if (!r) return;
+		n.delete(e);
+		let i = t.get(r.dataDirectoryName);
+		i && (i.sessions.delete(e), !(i.sessions.size > 0 || i.pending > 0) && await x(r.dataDirectoryName, i));
+	}, O = async (e, t) => {
+		let n = [...r.entries()].filter(([, t]) => t.sessionId === e).map(([e]) => e);
+		for (let e of n) await T(e, new l("transaction_not_found", t));
+		return n.length;
+	}, k = async (e, t) => {
+		let n = await J(await C(S(e.sessionId, t)), e.timeout), i = m();
+		return r.set(i, {
+			...n,
+			sessionId: e.sessionId
+		}), {
+			kind: "pg.begin",
+			result: { transactionId: i }
+		};
+	}, A = async (e, t) => {
+		let n = S(e.sessionId, t), r = [...e.params];
+		if (e.transactionId !== void 0) {
+			let t = w(e.transactionId, e.sessionId);
+			return {
+				kind: "pg.query",
+				result: W(await G(() => t.tx.query(e.sql, r)))
+			};
+		}
+		let i = await C(n);
+		return {
+			kind: "pg.query",
+			result: W(await G(() => i.query(e.sql, r)))
+		};
+	}, j = async (e, t) => {
+		let n = S(e.sessionId, t), r = e.transactionId === void 0 ? await C(n) : w(e.transactionId, e.sessionId).tx;
+		return {
+			kind: "pg.exec",
+			result: (await G(() => r.exec(e.sql))).map(W)
+		};
+	}, N = async (e, t) => {
+		S(e.sessionId, t), w(e.transactionId, e.sessionId);
+		let n = e.kind === "pg.rollback" ? new l("write_aborted", "rollback requested") : null, r = await T(e.transactionId, n);
+		if (r) throw r;
+		return { kind: e.kind };
+	}, P = async (e, t) => {
+		let n = await C(S(e.sessionId, t)), r = (await G(() => n.query("SELECT version() AS version"))).rows[0]?.version;
+		if (typeof r != "string") throw new l("host_internal_error", "PostgreSQL did not report a version string");
+		return {
+			kind: "pg.version",
+			result: r
+		};
+	}, F = () => {
+		if (d === void 0) throw new l("unsupported_operation", "this host was created without backup support");
+		return d;
+	}, I = async (e) => {
+		let t;
+		try {
+			t = await e.options.createProbeRuntime();
+		} catch (e) {
+			throw new l("open_failed", "the application could not start the PGlite probe runtime", { cause: e });
+		}
+		try {
+			let n = (await G(() => t.query("SHOW server_version"))).rows[0]?.server_version;
+			if (typeof n != "string" || n === "") throw new l("host_internal_error", "PostgreSQL did not report server_version");
+			return {
+				serverVersion: n,
+				extensions: e.extensions
+			};
+		} finally {
+			await t.close().catch(() => void 0);
+		}
+	}, L = async (e) => {
+		let t = o ??= I(e);
+		try {
+			return {
+				kind: "pg.engine",
+				result: await t
+			};
+		} catch (e) {
+			throw o === t && (o = void 0), e;
+		}
+	}, R = async (e, t, n) => {
+		let r = S(t.sessionId, n), a = e.options.resolveDataDirectory(r.dataDirectoryName), o = await J(await C(r), t.timeout);
+		try {
+			if (await G(() => o.tx.query("CHECKPOINT")), !await M(a)) throw new l("host_internal_error", `resolveDataDirectory does not point at the data directory of "${r.dataDirectoryName}"`);
+		} catch (e) {
+			throw o.settle.reject(new l("write_aborted", "the snapshot was aborted")), await o.finished.catch(() => void 0), e;
+		}
+		let s = m();
+		return i.set(s, {
+			sessionId: t.sessionId,
+			iterator: ee(a),
+			held: o
+		}), {
+			kind: "pg.backup.begin",
+			result: { backupId: s }
+		};
+	}, z = (e, t) => {
+		let n = i.get(e);
+		if (!n || n.sessionId !== t) throw new l("transaction_not_found", `backup ${e} is unknown, already finished, or not owned by session ${t}`);
+		return n;
+	}, B = async (e) => {
+		let t = i.get(e);
+		if (t) {
+			i.delete(e);
+			try {
+				await t.iterator.return(void 0);
+			} finally {
+				t.held.settle.resolve(), await t.held.finished.catch(() => void 0);
+			}
+		}
+	}, V = async (e, t) => {
+		S(e.sessionId, t);
+		let n = z(e.backupId, e.sessionId), r;
+		try {
+			r = await n.iterator.next();
+		} catch (t) {
+			throw await B(e.backupId), t;
+		}
+		return {
+			kind: "pg.backup.next",
+			result: r.done ? { type: "end" } : r.value
+		};
+	}, H = async (e, t) => (S(e.sessionId, t), z(e.backupId, e.sessionId), await B(e.backupId), { kind: "pg.backup.end" }), K = async (e, t) => {
+		let n = F();
+		switch (e.kind) {
+			case "pg.engine": return L(n);
+			case "pg.backup.begin": return R(n, e, t);
+			case "pg.backup.next": return V(e, t);
+			case "pg.backup.end": return H(e, t);
+			default: return n.restores.handle(e, t);
+		}
+	}, q = async (e, t) => {
+		let n = [...i.entries()].filter(([, t]) => t.sessionId === e).map(([e]) => e);
+		for (let e of n) await B(e).catch(() => void 0);
+		let r = await O(e, t);
+		return await D(e), r;
+	}, Y = async (e, t) => (S(e.sessionId, t), await q(e.sessionId, `session ${e.sessionId} was closed`), { kind: "pg.close" }), X = (e, t) => {
+		switch (e.kind) {
+			case "pg.handshake": return Promise.resolve({
+				kind: "pg.handshake",
+				result: { protocolVersion: s }
+			});
+			case "pg.open": return E(e, t);
+			case "pg.query": return A(e, t);
+			case "pg.exec": return j(e, t);
+			case "pg.begin": return k(e, t);
+			case "pg.commit":
+			case "pg.rollback": return N(e, t);
+			case "pg.version": return P(e, t);
+			case "pg.close": return Y(e, t);
+			default: return K(e, t);
+		}
+	};
+	return {
+		handle: async (e, t) => {
+			try {
+				return await X(p(e), t);
+			} catch (e) {
+				return oe(e);
+			}
+		},
+		get openSessionCount() {
+			return n.size;
+		},
+		get openInstanceCount() {
+			return t.size;
+		},
+		get openTransactionCount() {
+			return r.size;
+		},
+		get openBackupCount() {
+			return i.size;
+		},
+		get openRestoreCount() {
+			return d === void 0 ? 0 : d.restores.openCount;
+		},
+		releaseOwner: async (e) => {
+			let t = [...n.entries()].filter(([, t]) => t.owner === e).map(([e]) => e), r = 0;
+			for (let n of t) r += await q(n, `owner ${e} is gone`);
+			return await d?.restores.releaseOwner(e), r;
+		},
+		closeAll: async () => {
+			for (let e of [...n.keys()]) await q(e, "the host is shutting down");
+			await d?.restores.closeAll();
+		}
+	};
+}
+//#endregion
+export { e as DESKTOP_PGLITE_DEFAULT_BEGIN_TIMEOUT_MS, t as DESKTOP_PGLITE_EXCLUDED_FILES, r as DESKTOP_PGLITE_MAX_BEGIN_TIMEOUT_MS, i as DESKTOP_PGLITE_MAX_DATA_CHUNK_BYTES, o as DESKTOP_PGLITE_PROTOCOL_VERSION, $ as DESKTOP_PGLITE_WATCH_CHANNELS, c as RxDBAdapterDesktopError, u as assertValidDesktopDatabaseName, ce as createElectronPgliteHost, d as isDesktopPgliteRequestKind, f as parseDesktopPgliteRequest };