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

package/dist/host.js

@@ -0,0 +1,762 @@
+import { DEFAULT_BATCH_TIMEOUT as e, DEFAULT_CACHE_SIZE_KB as t, MAX_BATCH_WAIT_MS as n, SQLiteChangeType as r, WATCH_TABLES as i, get_init_sql as a, isReadOnlyStatement as o, validateSqliteNumericOption as s } from "@aiao/rxdb-adapter-sqlite-core";
+import { DESKTOP_HOST_MAX_BINDINGS as c, DESKTOP_HOST_MAX_BLOB_BYTES as l, DESKTOP_HOST_MAX_FILE_CHUNK_BYTES as u, DESKTOP_HOST_MAX_PENDING_WRITES_PER_SESSION as ee, DESKTOP_HOST_MAX_QUEUED_LOCKS_PER_NAME as d, DESKTOP_HOST_MAX_SQL_LENGTH as f, DESKTOP_HOST_PROTOCOL_VERSION as p, DESKTOP_HOST_PROTOCOL_VERSION as m, RxDBAdapterDesktopError as h, RxDBAdapterDesktopError as g, assertDesktopSqliteStorage as _, assertValidDesktopDatabaseName as v, isDesktopHostFileRequestKind as y, isDesktopPgliteDirectoryStorage as b, isDesktopSqliteFileStorage as te, parseDesktopHostFileRequest as ne, parseDesktopHostFileRequest as re, parseDesktopHostRequest as x, parseDesktopHostRequest as S } from "@aiao/rxdb-adapter-sqlite-core/desktop-host";
+import { randomUUID as C } from "node:crypto";
+import { DatabaseSync as ie, constants as w } from "node:sqlite";
+import { mkdir as T, open as E, readdir as ae, realpath as D, rename as O, rm as k, stat as oe } from "node:fs/promises";
+import { basename as A, dirname as j, join as M, resolve as N, sep as P } from "node:path";
+//#region src/sqlite-script.ts
+var F = 0, I = 1, L = 2, se = 3, ce = 4, R = 5, le = 6, ue = 7, de = 1, fe = [
+	[
+		1,
+		0,
+		2,
+		3,
+		4,
+		2,
+		2,
+		2
+	],
+	[
+		1,
+		1,
+		2,
+		3,
+		4,
+		2,
+		2,
+		2
+	],
+	[
+		1,
+		2,
+		2,
+		2,
+		2,
+		2,
+		2,
+		2
+	],
+	[
+		1,
+		3,
+		3,
+		2,
+		4,
+		2,
+		2,
+		2
+	],
+	[
+		1,
+		4,
+		2,
+		2,
+		2,
+		4,
+		5,
+		2
+	],
+	[
+		6,
+		5,
+		5,
+		5,
+		5,
+		5,
+		5,
+		5
+	],
+	[
+		6,
+		6,
+		5,
+		5,
+		5,
+		5,
+		5,
+		7
+	],
+	[
+		1,
+		7,
+		5,
+		5,
+		5,
+		5,
+		5,
+		5
+	]
+], pe = /* @__PURE__ */ new Map([
+	["create", ce],
+	["temp", R],
+	["temporary", R],
+	["trigger", le],
+	["end", ue],
+	["explain", se]
+]), me = /* @__PURE__ */ new Set([
+	" ",
+	"	",
+	"\n",
+	"\r",
+	"\f"
+]), z = /[A-Za-z0-9_$\u0080-\uFFFF]/u, he = (e, t) => {
+	let n = e[t];
+	if (n === ";") return {
+		token: F,
+		next: t + 1
+	};
+	if (me.has(n)) return {
+		token: I,
+		next: t + 1
+	};
+	if (n === "/" && e[t + 1] === "*") return {
+		token: I,
+		next: B(e, t + 2, "*/")
+	};
+	if (n === "-" && e[t + 1] === "-") return {
+		token: I,
+		next: B(e, t + 2, "\n")
+	};
+	if (n === "[") return {
+		token: L,
+		next: B(e, t + 1, "]")
+	};
+	if (n === "\"" || n === "'" || n === "`") return {
+		token: L,
+		next: B(e, t + 1, n)
+	};
+	if (!z.test(n)) return {
+		token: L,
+		next: t + 1
+	};
+	let r = ge(e, t + 1);
+	return {
+		token: pe.get(e.slice(t, r).toLowerCase()) ?? L,
+		next: r
+	};
+}, B = (e, t, n) => {
+	let r = e.indexOf(n, t);
+	return r === -1 ? e.length : r + n.length;
+}, ge = (e, t) => {
+	let n = t;
+	for (; n < e.length && z.test(e[n]);) n++;
+	return n;
+};
+function V(e) {
+	let t = [], n = 0, r = 0, i = 0, a = !1;
+	for (; i < e.length;) {
+		let { token: o, next: s } = he(e, i);
+		n = fe[n][o], i = s, o !== I && o !== F && (a = !0), o === F && n === de && (a && t.push(e.slice(r, i)), a = !1, r = i);
+	}
+	return a && t.push(e.slice(r)), t;
+}
+//#endregion
+//#region src/node-sqlite-engine.ts
+var H = "rxdb_desktop_notify", _e = "rxdb_desktop_notify", ve = [
+	{
+		type: r.SQLITE_INSERT,
+		event: "INSERT",
+		row: "NEW"
+	},
+	{
+		type: r.SQLITE_UPDATE,
+		event: "UPDATE",
+		row: "NEW"
+	},
+	{
+		type: r.SQLITE_DELETE,
+		event: "DELETE",
+		row: "OLD"
+	}
+], ye = /* @__PURE__ */ new Map([
+	[3, "permission_denied"],
+	[8, "permission_denied"],
+	[23, "permission_denied"],
+	[11, "database_corrupted"],
+	[26, "database_corrupted"],
+	[14, "open_failed"],
+	[5, "database_busy"],
+	[6, "database_busy"]
+]), be = /* @__PURE__ */ new Set([w.SQLITE_ATTACH, w.SQLITE_DETACH]), xe = /* @__PURE__ */ new Set(["temp_store_directory", "data_store_directory"]), Se = (e, t) => be.has(e) ? !0 : e === w.SQLITE_PRAGMA && t !== null && xe.has(t.toLowerCase()), Ce = (e) => {
+	let t = e.errcode;
+	return typeof t == "number" ? t : void 0;
+}, U = (e, t) => {
+	let n = Ce(e);
+	return n === void 0 ? t : ye.get(n) ?? t;
+}, W = (e) => e instanceof Error ? e.message : String(e), we = (e) => Array.isArray(e) ? Uint8Array.from(e) : e, Te = (e, t, n) => {
+	if (typeof e != "bigint" || typeof t != "string" || typeof n != "bigint") throw new g("host_internal_error", `the notify trigger passed (${typeof e}, ${typeof t}, ${typeof n}) instead of (bigint, string, bigint)`);
+	return [
+		Number(e),
+		t,
+		n
+	];
+}, Ee = BigInt(-(2 ** 53 - 1)), De = BigInt(2 ** 53 - 1), Oe = (e) => typeof e == "bigint" && e >= Ee && e <= De ? Number(e) : e, ke = (e) => e.map(Oe), G = (e) => {
+	let [t] = e.all();
+	return Number(t?.[0] ?? 0);
+}, K = (e) => `"${e.replaceAll("\"", "\"\"")}"`, Ae = (e) => `'${e.replaceAll("'", "''")}'`, q = (e, t) => {
+	let n = setTimeout(e, t);
+	return n.unref?.(), n;
+}, J = class r {
+	#e;
+	#t;
+	#n;
+	#r;
+	#i = /* @__PURE__ */ new Set();
+	#a = /* @__PURE__ */ new Map();
+	#o;
+	#s;
+	#c;
+	#l;
+	#u = !1;
+	constructor(t, n) {
+		this.#e = t, this.#t = n.dbName, this.#n = n.onChange, this.#r = s("batchTimeout", n.batchTimeout, e, { allowZero: !0 });
+	}
+	static open(e) {
+		let n;
+		try {
+			n = new ie(e.filePath);
+		} catch (t) {
+			throw new g(U(t, "open_failed"), `failed to open desktop database ${e.dbName}: ${W(t)}`, { cause: t });
+		}
+		try {
+			let i = new r(n, e);
+			return i.#d(e.cacheSizeKb ?? t), i;
+		} catch (t) {
+			throw n.close(), new g(U(t, "open_failed"), `failed to initialize desktop database ${e.dbName}: ${W(t)}`, { cause: t });
+		}
+	}
+	execute(e, t = []) {
+		this.#f();
+		let n = performance.now(), r = V(e);
+		if (r.length > 1 && t.length > 0) throw new g("protocol_violation", `multi statement scripts cannot carry bindings, got ${t.length} for SQL "${e}"`);
+		this.#T();
+		let { results: i, rowsAffected: a } = this.#m(r, t);
+		return this.#T(), {
+			sql: e,
+			rowsAffected: a,
+			elapsed: performance.now() - n,
+			results: i
+		};
+	}
+	version() {
+		this.#f();
+		let [e] = this.#p("SELECT sqlite_version()", []);
+		return String(e?.rows[0]?.[0]);
+	}
+	close() {
+		if (!this.#u) {
+			this.#u = !0, this.#S();
+			try {
+				this.#O(), this.#e.exec("PRAGMA wal_checkpoint(TRUNCATE)");
+			} finally {
+				this.#c = void 0, this.#l = void 0, this.#e.close();
+			}
+		}
+	}
+	#d(e) {
+		this.#e.setAuthorizer((e, t) => Se(e, t) ? w.SQLITE_DENY : w.SQLITE_OK), this.#e.function(H, {
+			deterministic: !1,
+			directOnly: !1,
+			useBigIntArguments: !0,
+			varargs: !1
+		}, (e, t, n) => (this.#b(...Te(e, t, n)), null)), this.#e.exec(a(e, !0)), this.#T();
+	}
+	#f() {
+		if (this.#u) throw new g("session_closed", `desktop database ${this.#t} is already closed`);
+	}
+	#p(e, t) {
+		try {
+			let n = this.#e.prepare(e);
+			n.setReturnArrays(!0), n.setReadBigInts(!0);
+			let r = n.all(...t.map(we)), i = n.columns().map((e) => e.name);
+			return i.length > 0 ? [{
+				columns: i,
+				rows: r.map(ke)
+			}] : [];
+		} catch (t) {
+			throw this.#g(e, t);
+		}
+	}
+	#m(e, t) {
+		let n = [], r = 0;
+		for (let i of e) {
+			let e = this.#v(), a = this.#p(i, t);
+			r += this.#h(i, e), n.length === 0 && n.push(...a);
+		}
+		return {
+			results: n,
+			rowsAffected: r
+		};
+	}
+	#h(e, t) {
+		return o(e) || this.#v() === t ? 0 : this.#_();
+	}
+	#g(e, t) {
+		return new g(U(t, "statement_failed"), `desktop database ${this.#t} failed for SQL "${e}": ${W(t)}`, { cause: t });
+	}
+	#_() {
+		return this.#c ??= this.#y("SELECT changes()"), G(this.#c);
+	}
+	#v() {
+		return this.#l ??= this.#y("SELECT total_changes()"), G(this.#l);
+	}
+	#y(e) {
+		let t = this.#e.prepare(e);
+		return t.setReturnArrays(!0), t;
+	}
+	#b(e, t, n) {
+		let r = `${e} ${t}`, i = this.#a.get(r);
+		i ? i.rowIds.push(n) : this.#a.set(r, {
+			type: e,
+			tableName: t,
+			rowIds: [n]
+		}), this.#x();
+	}
+	#x() {
+		this.#o && clearTimeout(this.#o), this.#o = q(() => this.#S(), this.#r), this.#s ??= q(() => this.#S(), n);
+	}
+	#S() {
+		this.#C(), this.#w();
+	}
+	#C() {
+		this.#o && clearTimeout(this.#o), this.#s && clearTimeout(this.#s), this.#o = void 0, this.#s = void 0;
+	}
+	#w() {
+		if (this.#a.size === 0) return;
+		let e = [...this.#a.values()];
+		this.#a.clear();
+		let t = /* @__PURE__ */ new Date();
+		for (let { type: n, tableName: r, rowIds: i } of e) try {
+			this.#n({
+				type: n,
+				dbName: "main",
+				tableName: r,
+				rowIds: i,
+				recordAt: t
+			});
+		} catch (e) {
+			console.error(`[NodeSqliteEngine] change event listener failed for ${r}:`, e);
+		}
+	}
+	#T() {
+		if (this.#i.size === i.size) return;
+		let e = [...i], t = e.map(() => "?").join(", "), n = this.#e.prepare(`SELECT name FROM sqlite_master WHERE type = 'table' AND name IN (${t})`);
+		n.setReturnArrays(!0);
+		let r = n.all(...e);
+		for (let [e] of r) this.#i.has(e) || (this.#D(e), this.#E(e));
+	}
+	#E(e) {
+		this.#e.isTransaction || this.#i.add(e);
+	}
+	#D(e) {
+		let t = K(e), n = Ae(e);
+		for (let { type: r, event: i, row: a } of ve) {
+			let o = K(`${_e}$${e}$${i}`);
+			this.#e.exec(`CREATE TEMP TRIGGER IF NOT EXISTS ${o} AFTER ${i} ON ${t} BEGIN SELECT ${H}(${r}, ${n}, ${a}.rowid); END;`);
+		}
+	}
+	#O() {
+		this.#e.isTransaction && this.#e.exec("ROLLBACK");
+	}
+}, je = "desktop-sqlite://app-scope", Y = "BEGIN IMMEDIATE;", Me = "BEGIN EXCLUSIVE;", Ne = 5e3, Pe = 1, Fe = 100, Ie = (e) => new Promise((t) => {
+	setTimeout(t, e);
+}), Le = (e, t) => {
+	if (!(e instanceof g) || e.code !== "database_busy") return !1;
+	let [n] = V(t);
+	return n === Y || n === Me;
+}, Re = (e) => e instanceof g ? {
+	kind: "error",
+	code: e.code,
+	message: e.detail
+} : {
+	kind: "error",
+	code: "host_internal_error",
+	message: e instanceof Error ? e.message : String(e)
+};
+function ze(e) {
+	let t = /* @__PURE__ */ new Map(), n = (t, n) => {
+		try {
+			e.postChange({
+				kind: "change",
+				sessionId: t,
+				event: n
+			});
+		} catch (t) {
+			e.onDeliveryError?.(t);
+		}
+	}, r = (e) => {
+		let n = t.get(e);
+		if (!n) throw new g("session_closed", `session ${e} is not open on this host`);
+		return n;
+	}, i = (t) => {
+		try {
+			return e.resolveDatabasePath(t);
+		} catch (e) {
+			throw new g("open_failed", `the application could not resolve a path for ${t}`, { cause: e });
+		}
+	}, a = (r) => {
+		let { databaseName: a } = r.storage, o = C(), s = J.open({
+			filePath: i(a),
+			dbName: a,
+			onChange: (e) => n(o, e),
+			cacheSizeKb: e.cacheSizeKb,
+			batchTimeout: r.batchTimeout
+		});
+		return t.set(o, s), {
+			kind: "open",
+			result: {
+				sessionId: o,
+				resolvedLocation: `${je}/${a}`,
+				protocolVersion: m,
+				beginTransactionSql: Y,
+				beginSystemMigrationTransactionSql: Me
+			}
+		};
+	}, o = (e) => {
+		let n = r(e);
+		return t.delete(e), n.close(), { kind: "close" };
+	}, s = async (t) => {
+		let n = r(t.sessionId), i, a = Pe;
+		for (;;) try {
+			return {
+				kind: "execute",
+				result: n.execute(t.sql, t.bindings)
+			};
+		} catch (n) {
+			if (!Le(n, t.sql) || (i ??= performance.now() + (e.busyRetryBudgetMs ?? Ne), performance.now() + a > i)) throw n;
+			await Ie(a), a = Math.min(a * 2, Fe);
+		}
+	}, c = (e) => {
+		switch (e.kind) {
+			case "handshake": return {
+				kind: "handshake",
+				result: { protocolVersion: m }
+			};
+			case "open": return a(e);
+			case "close": return o(e.sessionId);
+			case "version": return {
+				kind: "version",
+				result: r(e.sessionId).version()
+			};
+			case "execute": return s(e);
+			default: throw new g("protocol_violation", `unsupported request kind: ${String(e.kind)}`);
+		}
+	};
+	return {
+		handle: async (e) => {
+			try {
+				return await c(S(e));
+			} catch (e) {
+				return Re(e);
+			}
+		},
+		get openSessionCount() {
+			return t.size;
+		},
+		closeAll: () => {
+			for (let e of t.values()) e.close();
+			t.clear();
+		}
+	};
+}
+//#endregion
+//#region src/electron-file-host.ts
+var Be = (e) => e.kind.startsWith("file.write"), Ve = (e) => e.kind.startsWith("file.lock"), He = {
+	ENOENT: "file_not_found",
+	ENOTDIR: "invalid_file_path",
+	EISDIR: "invalid_file_path",
+	ENAMETOOLONG: "invalid_file_path",
+	EEXIST: "invalid_file_path",
+	ELOOP: "invalid_file_path",
+	EACCES: "permission_denied",
+	EPERM: "permission_denied",
+	EROFS: "permission_denied",
+	ENOSPC: "disk_full",
+	EDQUOT: "disk_full"
+}, X = (e) => {
+	if (typeof e != "object" || !e) return;
+	let t = e.code;
+	return typeof t == "string" ? t : void 0;
+}, Z = (e, t) => {
+	if (e instanceof g) return e;
+	let n = X(e), r = n === void 0 ? void 0 : He[n];
+	return new g(r ?? "host_internal_error", `${n ?? "filesystem failure"} on ${t}`, { cause: e });
+}, Ue = (e) => e instanceof g ? {
+	kind: "error",
+	code: e.code,
+	message: e.detail
+} : {
+	kind: "error",
+	code: "host_internal_error",
+	message: e instanceof Error ? e.message : String(e)
+}, We = (e) => new g("invalid_file_path", `path escapes the storage root: ${e}`), Ge = (e, t) => t === e || t.startsWith(e + P), Ke = (e, t) => {
+	let n = t === "" ? e : N(e, t);
+	if (!Ge(e, n)) throw We(t);
+	return n;
+}, qe = async (e) => {
+	let t = [], n = e;
+	for (;;) try {
+		let e = await D(n);
+		return t.length === 0 ? e : M(e, ...t);
+	} catch (e) {
+		if (X(e) !== "ENOENT") throw e;
+		let r = j(n);
+		if (r === n) return M(n, ...t);
+		t.unshift(A(n)), n = r;
+	}
+}, Q = (e) => e ? "directory" : "file", $ = async (e, t, n) => {
+	let r;
+	try {
+		r = (await oe(e)).isDirectory();
+	} catch (e) {
+		if (X(e) === "ENOENT") return;
+		throw Z(e, t);
+	}
+	if (Q(r) !== n) throw new g("invalid_file_path", `path is not a ${n}: ${t}`);
+};
+function Je(e) {
+	let t = /* @__PURE__ */ new Map(), n = /* @__PURE__ */ new Map(), r = (e) => {
+		let n = t.get(e);
+		if (!n) throw new g("session_closed", `file session ${e} is not open on this host`);
+		return n;
+	}, i = (e, t) => {
+		let n = e.writes.get(t);
+		if (!n) throw new g("write_aborted", `write ${t} is no longer pending`);
+		return n;
+	}, a = () => {
+		try {
+			return N(e.resolveStorageRoot());
+		} catch (e) {
+			throw new g("host_internal_error", "the application could not resolve the storage root", { cause: e });
+		}
+	}, o = async (e) => {
+		let t = a(), n = Ke(t, e);
+		try {
+			let [r, i] = await Promise.all([qe(t), qe(n)]);
+			if (!Ge(r, i)) throw We(e);
+			return n;
+		} catch (t) {
+			throw Z(t, e);
+		}
+	}, s = (e) => {
+		let t = n.get(e);
+		if (t) return t;
+		let r = {
+			held: /* @__PURE__ */ new Map(),
+			waiting: []
+		};
+		return n.set(e, r), r;
+	}, c = (e, t) => e.held.size === 0 || t.mode !== "exclusive" && [...e.held.values()].every((e) => e === "shared"), l = (e) => {
+		let t = n.get(e);
+		if (t) {
+			for (; t.waiting.length > 0 && c(t, t.waiting[0]);) {
+				let e = t.waiting.shift();
+				t.held.set(e.lockId, e.mode), e.grant();
+			}
+			t.held.size === 0 && t.waiting.length === 0 && n.delete(e);
+		}
+	}, u = (e, t, n) => {
+		let i = r(e), a = s(t);
+		if (a.waiting.length >= d) throw new g("protocol_violation", `lock ${t} already has ${d} queued waiters`);
+		let o = C();
+		return new Promise((r, s) => {
+			a.waiting.push({
+				lockId: o,
+				sessionId: e,
+				mode: n,
+				grant: () => {
+					i.lockNames.set(o, t), r(o);
+				},
+				deny: s
+			}), l(t);
+		});
+	}, f = (e, t) => {
+		let r = e.lockNames.get(t);
+		if (r === void 0) throw new g("protocol_violation", `lock ${t} is not held by this session`);
+		e.lockNames.delete(t), n.get(r)?.held.delete(t), l(r);
+	}, p = (e) => {
+		for (let [t, r] of n) {
+			let n = r.waiting.filter((t) => t.sessionId === e);
+			r.waiting = r.waiting.filter((t) => t.sessionId !== e);
+			for (let t of n) t.deny(new g("session_closed", `file session ${e} closed while queued`));
+			l(t);
+		}
+	}, h = async (e) => {
+		await e.handle.close().catch(() => void 0), await k(e.temporaryPath, { force: !0 }).catch(() => void 0);
+	}, _ = async (e) => {
+		let r = t.get(e);
+		if (r) {
+			t.delete(e), r.closed = !0, p(e);
+			for (let e of [...r.lockNames.keys()]) {
+				let t = r.lockNames.get(e);
+				r.lockNames.delete(e), n.get(t)?.held.delete(e), l(t);
+			}
+			await Promise.all([...r.writes.values()].map(h)), r.writes.clear();
+		}
+	}, v = async (e) => {
+		let t = await o(e);
+		try {
+			let e = await oe(t);
+			return {
+				kind: Q(e.isDirectory()),
+				size: e.isDirectory() ? 0 : e.size,
+				lastModified: e.mtimeMs
+			};
+		} catch (t) {
+			if (X(t) === "ENOENT") return null;
+			throw Z(t, e);
+		}
+	}, y = async (e) => {
+		let t = await o(e);
+		try {
+			return (await ae(t, { withFileTypes: !0 })).map((e) => ({
+				name: e.name,
+				kind: Q(e.isDirectory())
+			}));
+		} catch (t) {
+			throw Z(t, e);
+		}
+	}, b = async (e, t) => {
+		try {
+			await e();
+		} catch (e) {
+			throw Z(e, t);
+		}
+	}, te = async (e, t) => {
+		let n = await o(e), r = await o(t);
+		await b(() => T(j(r), { recursive: !0 }), t), await b(() => O(n, r), e);
+	}, ne = async (e, t, n) => {
+		let r = await o(e);
+		await $(r, e, "file");
+		let i;
+		try {
+			i = await E(r, "r");
+			let e = (await i.stat()).size, a = new Uint8Array(Math.max(0, Math.min(n, e - t)));
+			return a.byteLength > 0 && await i.read(a, 0, a.byteLength, t), {
+				chunk: a,
+				eof: t + a.byteLength >= e
+			};
+		} catch (t) {
+			throw Z(t, e);
+		} finally {
+			await i?.close().catch(() => void 0);
+		}
+	}, x = async (e, t) => {
+		try {
+			return await E(e, "wx");
+		} catch (e) {
+			throw Z(e, t);
+		}
+	}, S = async (e, t) => {
+		let n = C();
+		if (e.writes.size + e.reservations.size >= ee) throw new g("protocol_violation", `session already has ${ee} pending writes`);
+		e.reservations.add(n);
+		try {
+			let r = await o(t), i = M(j(r), `.${n}.rxdb-tmp`);
+			await b(() => T(j(r), { recursive: !0 }), t);
+			let a = {
+				logicalPath: t,
+				targetPath: r,
+				temporaryPath: i,
+				handle: await x(i, t)
+			};
+			if (e.closed) throw await h(a), new g("session_closed", "file session closed while the write was being opened");
+			return e.writes.set(n, a), n;
+		} finally {
+			e.reservations.delete(n);
+		}
+	}, ie = async (e) => {
+		let t;
+		try {
+			t = await E(e, "r"), await t.sync();
+		} catch (e) {
+			let t = X(e);
+			if (t !== "EISDIR" && t !== "EPERM" && t !== "EACCES") throw e;
+		} finally {
+			await t?.close().catch(() => void 0);
+		}
+	}, w = async (e, t) => {
+		let n = i(e, t);
+		e.writes.delete(t);
+		try {
+			await n.handle.sync(), await n.handle.close(), await O(n.temporaryPath, n.targetPath), await ie(j(n.targetPath));
+		} catch (e) {
+			throw await n.handle.close().catch(() => void 0), await k(n.temporaryPath, { force: !0 }).catch(() => void 0), Z(e, n.logicalPath);
+		}
+	}, D = async (e) => {
+		let t = r(e.sessionId);
+		if (e.kind === "file.writeBegin") return {
+			kind: "file.writeBegin",
+			result: { writeId: await S(t, e.path) }
+		};
+		if (e.kind === "file.writeChunk") {
+			let n = i(t, e.writeId);
+			try {
+				await n.handle.write(e.chunk);
+			} catch (e) {
+				throw Z(e, n.logicalPath);
+			}
+			return { kind: "file.writeChunk" };
+		}
+		if (e.kind === "file.writeCommit") return await w(t, e.writeId), { kind: "file.writeCommit" };
+		let n = i(t, e.writeId);
+		return t.writes.delete(e.writeId), await h(n), { kind: "file.writeAbort" };
+	}, A = async (e) => e.kind === "file.lockAcquire" ? {
+		kind: "file.lockAcquire",
+		result: { lockId: await u(e.sessionId, e.name, e.mode) }
+	} : (f(r(e.sessionId), e.lockId), { kind: "file.lockRelease" }), P = async (e) => {
+		if (r(e.sessionId), e.kind === "file.stat") return {
+			kind: "file.stat",
+			result: await v(e.path)
+		};
+		if (e.kind === "file.list") return {
+			kind: "file.list",
+			result: await y(e.path)
+		};
+		let t = await o(e.path);
+		return e.kind === "file.mkdir" ? (await b(() => T(t, { recursive: !0 }), e.path), { kind: "file.mkdir" }) : e.kind === "file.rmdir" ? (await $(t, e.path, "directory"), await b(() => k(t, {
+			force: !0,
+			recursive: !0
+		}), e.path), { kind: "file.rmdir" }) : (await $(t, e.path, "file"), await b(() => k(t, { force: !0 }), e.path), { kind: "file.remove" });
+	}, F = async (e) => {
+		if (e.kind === "file.open") {
+			let e = C();
+			return t.set(e, {
+				writes: /* @__PURE__ */ new Map(),
+				reservations: /* @__PURE__ */ new Set(),
+				lockNames: /* @__PURE__ */ new Map(),
+				closed: !1
+			}), {
+				kind: "file.open",
+				result: {
+					sessionId: e,
+					protocolVersion: m
+				}
+			};
+		}
+		return e.kind === "file.close" ? (r(e.sessionId), await _(e.sessionId), { kind: "file.close" }) : e.kind === "file.move" ? (r(e.sessionId), await te(e.fromPath, e.toPath), { kind: "file.move" }) : e.kind === "file.read" ? (r(e.sessionId), {
+			kind: "file.read",
+			result: await ne(e.path, e.offset, e.length)
+		}) : Be(e) ? D(e) : Ve(e) ? A(e) : P(e);
+	};
+	return {
+		handle: async (e) => {
+			try {
+				return await F(re(e));
+			} catch (e) {
+				return Ue(e);
+			}
+		},
+		get openSessionCount() {
+			return t.size;
+		},
+		get trackedLockNameCount() {
+			return n.size;
+		},
+		closeAll: async () => {
+			await Promise.all([...t.keys()].map((e) => _(e)));
+		}
+	};
+}
+//#endregion
+export { c as DESKTOP_HOST_MAX_BINDINGS, l as DESKTOP_HOST_MAX_BLOB_BYTES, u as DESKTOP_HOST_MAX_FILE_CHUNK_BYTES, f as DESKTOP_HOST_MAX_SQL_LENGTH, p as DESKTOP_HOST_PROTOCOL_VERSION, J as NodeSqliteEngine, h as RxDBAdapterDesktopError, _ as assertDesktopSqliteStorage, v as assertValidDesktopDatabaseName, Je as createElectronFileHost, ze as createElectronSqliteHost, y as isDesktopHostFileRequestKind, b as isDesktopPgliteDirectoryStorage, te as isDesktopSqliteFileStorage, ne as parseDesktopHostFileRequest, x as parseDesktopHostRequest };