@aiao/rxdb-adapter-electron 0.0.26 → 0.0.28

package/dist/pglite.d.ts

@@ -16,5 +16,7 @@
 export { DEFAULT_DATA_DIRECTORY_SUFFIX as DESKTOP_DEFAULT_DATA_DIRECTORY_SUFFIX, ADAPTER_NAME as ELECTRON_PGLITE_ADAPTER_NAME, type ElectronPGliteOptions } from './pglite/pglite-adapter.interface.js';
 export { RxDBAdapterElectronPGlite } from './pglite/RxDBAdapterElectronPGlite.js';
 export { DesktopPGliteClient, type DesktopPGliteClientOptions } from './pglite/desktop-pglite-client.js';
+export type { PGliteRestoreOptions, PGliteRestoreStage } from '@aiao/rxdb-adapter-pglite';
+export { cleanupIncompleteElectronPGliteRestore, restoreElectronPGliteDatabase, type ElectronPGliteRestoreTarget } from './pglite/restore-electron-pglite-database.js';
 export { DESKTOP_HOST_TRANSPORT_KEY, DESKTOP_PGLITE_DEFAULT_BEGIN_TIMEOUT_MS, DESKTOP_PGLITE_MAX_BEGIN_TIMEOUT_MS, DESKTOP_PGLITE_PROTOCOL_VERSION, RxDBAdapterDesktopError, resolveDesktopHostTransport, type DesktopHostTransport, type DesktopPgliteNotifyMessage, type DesktopPgliteQueryResult, type DesktopPgliteRequest, type DesktopPgliteResponse, type RxDBAdapterDesktopErrorCode } from '@aiao/rxdb-adapter-sqlite-core/desktop-host';
 //# sourceMappingURL=pglite.d.ts.map

package/dist/pglite.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pglite.d.ts","sourceRoot":"","sources":["../src/pglite.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EACL,6BAA6B,IAAI,qCAAqC,EACtE,YAAY,IAAI,4BAA4B,EAC5C,KAAK,qBAAqB,EAC3B,MAAM,sCAAsC,CAAC;AAE9C,OAAO,EAAE,yBAAyB,EAAE,MAAM,uCAAuC,CAAC;AAElF,OAAO,EAAE,mBAAmB,EAAE,KAAK,0BAA0B,EAAE,MAAM,mCAAmC,CAAC;AAIzG,OAAO,EACL,0BAA0B,EAC1B,uCAAuC,EACvC,mCAAmC,EACnC,+BAA+B,EAC/B,uBAAuB,EACvB,2BAA2B,EAC3B,KAAK,oBAAoB,EACzB,KAAK,0BAA0B,EAC/B,KAAK,wBAAwB,EAC7B,KAAK,oBAAoB,EACzB,KAAK,qBAAqB,EAC1B,KAAK,2BAA2B,EACjC,MAAM,6CAA6C,CAAC"}
+{"version":3,"file":"pglite.d.ts","sourceRoot":"","sources":["../src/pglite.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EACL,6BAA6B,IAAI,qCAAqC,EACtE,YAAY,IAAI,4BAA4B,EAC5C,KAAK,qBAAqB,EAC3B,MAAM,sCAAsC,CAAC;AAE9C,OAAO,EAAE,yBAAyB,EAAE,MAAM,uCAAuC,CAAC;AAElF,OAAO,EAAE,mBAAmB,EAAE,KAAK,0BAA0B,EAAE,MAAM,mCAAmC,CAAC;AAIzG,YAAY,EAAE,oBAAoB,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AAC1F,OAAO,EACL,sCAAsC,EACtC,6BAA6B,EAC7B,KAAK,2BAA2B,EACjC,MAAM,8CAA8C,CAAC;AAItD,OAAO,EACL,0BAA0B,EAC1B,uCAAuC,EACvC,mCAAmC,EACnC,+BAA+B,EAC/B,uBAAuB,EACvB,2BAA2B,EAC3B,KAAK,oBAAoB,EACzB,KAAK,0BAA0B,EAC/B,KAAK,wBAAwB,EAC7B,KAAK,oBAAoB,EACzB,KAAK,qBAAqB,EAC1B,KAAK,2BAA2B,EACjC,MAAM,6CAA6C,CAAC"}

package/dist/pglite.js

@@ -1,24 +1,71 @@
-import { DESKTOP_HOST_TRANSPORT_KEY as e, DESKTOP_PGLITE_DEFAULT_BEGIN_TIMEOUT_MS as t, DESKTOP_PGLITE_MAX_BEGIN_TIMEOUT_MS as n, DESKTOP_PGLITE_PROTOCOL_VERSION as r, RxDBAdapterDesktopError as i, RxDBAdapterDesktopError as a, assertDesktopPgliteResponse as o, assertValidDesktopDatabaseName as s, parseDesktopPgliteHandshakeResult as c, parseDesktopPgliteNotifyMessage as l, parseDesktopPgliteOpenResult as u, resolveDesktopHostTransport as d, resolveDesktopHostTransport as f } from "@aiao/rxdb-adapter-sqlite-core/desktop-host";
-import { DEFAULT_NOTIFY_BATCH_TIMEOUT_MS as p, PGliteNotificationBatcher as m, RxDBAdapterPGlite as h } from "@aiao/rxdb-adapter-pglite";
-import { EventDispatcher as g } from "@aiao/utils";
-import { query as _ } from "@electric-sql/pglite/template";
+import { DESKTOP_HOST_TRANSPORT_KEY as e, DESKTOP_PGLITE_DEFAULT_BEGIN_TIMEOUT_MS as t, DESKTOP_PGLITE_DEFAULT_BEGIN_TIMEOUT_MS as n, DESKTOP_PGLITE_MAX_BEGIN_TIMEOUT_MS as r, DESKTOP_PGLITE_PROTOCOL_VERSION as i, DESKTOP_PGLITE_PROTOCOL_VERSION as a, RxDBAdapterDesktopError as o, RxDBAdapterDesktopError as s, assertDesktopPgliteResponse as c, assertValidDesktopDatabaseName as l, parseDesktopPgliteBackupItem as u, parseDesktopPgliteEngineResult as d, parseDesktopPgliteHandshakeResult as f, parseDesktopPgliteNotifyMessage as p, parseDesktopPgliteOpenResult as ee, resolveDesktopHostTransport as m, resolveDesktopHostTransport as h } from "@aiao/rxdb-adapter-sqlite-core/desktop-host";
+import { DEFAULT_NOTIFY_BATCH_TIMEOUT_MS as g, PGLITE_BACKUP_ENGINE as _, PGliteNotificationBatcher as v, RxDBAdapterPGlite as y, toPGliteEngineInfo as b, verifyPGliteRestored as x } from "@aiao/rxdb-adapter-pglite";
+import { EventDispatcher as S } from "@aiao/utils";
+import { query as C } from "@electric-sql/pglite/template";
+import { RXDB_CHANGE_CODEC_VERSION as w, RXDB_SYSTEM_SCHEMA_VERSION as T, RxDBBackupArchiveReader as E, RxDBBackupError as D, assertRxDBBackupCompatible as O, getRxDBBackupAuthDomain as k, getRxDBBackupSchemaFingerprint as A } from "@aiao/rxdb";
 //#region src/pglite/pglite-adapter.interface.ts
-var v = "pglite-electron", y = "-pgdata", b = (e) => ({
+var j = "pglite-electron", M = "-pgdata", N = (e, t) => t.dataDirectoryName ?? `${e}-pgdata`, P = (e) => ({
 	rows: e.rows,
 	fields: e.fields.map((e) => ({
 		name: e.name,
 		dataTypeID: e.dataTypeID
 	})),
 	affectedRows: e.affectedRows
-}), x = (e) => {
-	if (e !== void 0) throw new a("protocol_violation", "the desktop PGlite protocol carries no QueryOptions; parsers, serializers, onNotice and blob cannot cross the process boundary");
-}, S = (e) => {
-	if (e.store !== void 0 || e.dataDir !== void 0) throw new a("protocol_violation", "the desktop PGlite host owns storage; store and dataDir must not be set on the renderer side");
-}, C = (e) => new a("protocol_violation", `${e}() cannot be proxied to the desktop PGlite host; use query() or exec() instead`), w = (e) => {
+}), F = /* @__PURE__ */ new Map([
+	["database_busy", "target_busy"],
+	["restore_in_progress", "restore_in_progress"],
+	["restore_incomplete", "restore_incomplete"],
+	["target_not_empty", "target_not_empty"],
+	["cleanup_pending", "cleanup_pending"]
+]), I = /* @__PURE__ */ new Set([
+	"unsupported_runtime_engine",
+	"invalid_database_name",
+	"unsupported_operation"
+]), L = (e, t) => {
+	switch (e) {
+		case "target_busy": return `Desktop PGlite data directory "${t}" is open in another connection or being restored`;
+		case "restore_in_progress": return `Desktop PGlite data directory "${t}" is being restored`;
+		case "restore_incomplete": return `A previous restore into "${t}" did not finish; call cleanupIncompleteElectronPGliteRestore()`;
+		case "target_not_empty": return `Desktop PGlite data directory "${t}" already holds a database`;
+		default: return `Failed to clean up the incomplete restore of "${t}"; call cleanupIncompleteElectronPGliteRestore()`;
+	}
+}, R = (e, t) => {
+	if (I.has(e)) return "unsupported_combination";
+	switch (e) {
+		case "disk_full": return "storage_full";
+		case "transaction_unavailable": return "lock_timeout";
+		case "session_closed": return "invalid_state";
+		case "database_corrupted": return t === "restore" ? "corrupt_archive" : "io_error";
+		default: return "io_error";
+	}
+}, z = (e, t, n) => {
+	let r = F.get(e.code);
+	if (r !== void 0) {
+		let n = {
+			field: "dataDirectoryName",
+			actual: t
+		};
+		return new D(r, L(r, t), {
+			details: n,
+			cause: e
+		});
+	}
+	return e.code === "protocol_violation" ? new D("unsupported_combination", "The desktop host does not speak this renderer's protocol", {
+		details: {
+			field: "protocolVersion",
+			expected: a
+		},
+		cause: e
+	}) : new D(R(e.code, n), `Desktop PGlite ${n} failed: ${e.detail}`, { cause: e });
+}, B = (e, t, n) => e instanceof D ? e : e instanceof s ? z(e, t, n) : new D("io_error", `Desktop PGlite ${n} failed`, { cause: e }), V = /* @__PURE__ */ new Set(["restore_in_progress", "restore_incomplete"]), H = (e) => {
+	if (e !== void 0) throw new s("protocol_violation", "the desktop PGlite protocol carries no QueryOptions; parsers, serializers, onNotice and blob cannot cross the process boundary");
+}, U = (e) => {
+	if (e.store !== void 0 || e.dataDir !== void 0) throw new s("protocol_violation", "the desktop PGlite host owns storage; store and dataDir must not be set on the renderer side");
+}, te = (e) => new s("protocol_violation", `${e}() cannot be proxied to the desktop PGlite host; use query() or exec() instead`), W = (e) => {
 	queueMicrotask(() => {
 		throw e;
 	});
-}, T = class extends g {
+}, G = class extends S {
 	#e;
 	#t;
 	#n = "";
@@ -30,67 +77,95 @@ var v = "pglite-electron", y = "-pgdata", b = (e) => ({
 	#c = Promise.resolve();
 	#l = Promise.resolve();
 	get sessionId() {
-		if (!this.#r) throw new a("session_closed", "the desktop PGlite client has not been initialised yet");
+		if (!this.#r) throw new s("session_closed", "the desktop PGlite client has not been initialised yet");
 		return this.#r;
 	}
 	get resolvedLocation() {
-		if (!this.#i) throw new a("session_closed", "the desktop PGlite client has not been initialised yet");
+		if (!this.#i) throw new s("session_closed", "the desktop PGlite client has not been initialised yet");
 		return this.#i;
 	}
 	get pendingNotificationCount() {
 		return this.#t.pendingCount;
 	}
 	constructor(e) {
-		super(), this.#e = e, this.#t = new m({
+		super(), this.#e = e, this.#t = new v({
 			resolveDbName: () => this.#n,
 			emit: (e) => this.dispatchEvent(e.type, e),
-			batchTimeout: e.batchTimeout ?? p,
+			batchTimeout: e.batchTimeout ?? g,
 			onParseError: (e) => console.error("Failed to parse desktop NOTIFY payload:", e)
 		});
 	}
 	async init(e, t) {
-		if (S(t), this.#r) throw new a("protocol_violation", `the desktop PGlite client is already bound to session ${this.#r}`);
+		if (U(t), this.#r) throw new s("protocol_violation", `the desktop PGlite client is already bound to session ${this.#r}`);
 		this.#n = e;
-		let n = o("pg.handshake", await this.#e.transport.request({ kind: "pg.handshake" }));
-		c(n.result);
-		let r = o("pg.open", await this.#e.transport.request({
+		let n = c("pg.handshake", await this.#e.transport.request({ kind: "pg.handshake" }));
+		f(n.result);
+		let r = this.#u(await this.#e.transport.request({
 			kind: "pg.open",
 			storage: {
 				engine: "pglite",
 				dataDirectoryName: this.#e.dataDirectoryName
 			}
-		})), i = await this.#u(r.result);
-		this.#r = i.sessionId, this.#i = i.resolvedLocation, this.#a = this.#e.transport.subscribe((e) => this.#y(e)), await this.#d();
+		})), i = await this.#d(r.result);
+		this.#r = i.sessionId, this.#i = i.resolvedLocation, this.#a = this.#e.transport.subscribe((e) => this.#x(e)), await this.#f();
 	}
 	async query(e, t, n) {
-		return this.#v(), x(n), this.#g(async () => this.#m(void 0, e, t));
+		return this.#b(), H(n), this.#v(async () => this.#h(void 0, e, t));
 	}
 	async sql(e, ...t) {
-		this.#v();
-		let n = _(e, ...t);
-		return this.#g(async () => this.#m(void 0, n.query, n.params));
+		this.#b();
+		let n = C(e, ...t);
+		return this.#v(async () => this.#h(void 0, n.query, n.params));
 	}
 	async exec(e, t) {
-		return this.#v(), x(t), this.#g(async () => this.#h(void 0, e));
+		return this.#b(), H(t), this.#v(async () => this.#_(void 0, e));
 	}
 	async transaction(e) {
-		return this.#v(), this.#g(() => this.#p(e));
+		return this.#b(), this.#v(() => this.#m(e));
 	}
 	async version() {
-		return this.#v(), this.#g(async () => o("pg.version", await this.#_({
+		return this.#b(), this.#v(async () => c("pg.version", await this.#y({
 			kind: "pg.version",
 			sessionId: this.sessionId
 		})).result);
 	}
+	async snapshotDataDir(e) {
+		return this.#b(), this.#v(async () => {
+			let t = c("pg.backup.begin", await this.#y({
+				kind: "pg.backup.begin",
+				sessionId: this.sessionId,
+				timeout: this.#e.beginTimeout ?? n
+			})).result.backupId, r = async () => {
+				c("pg.backup.end", await this.#y({
+					kind: "pg.backup.end",
+					sessionId: this.sessionId,
+					backupId: t
+				}));
+			}, i;
+			try {
+				i = await e(this.#g(t));
+			} catch (e) {
+				throw await r().catch(() => void 0), e;
+			}
+			return await r(), i;
+		});
+	}
 	async disconnect() {
-		this.#s ??= this.#f(!0), await this.#s;
+		this.#s ??= this.#p(!0), await this.#s;
 	}
 	async forceClose() {
-		this.#s ??= this.#f(!1), await this.#s;
+		this.#s ??= this.#p(!1), await this.#s;
+	}
+	#u(e) {
+		try {
+			return c("pg.open", e);
+		} catch (e) {
+			throw e instanceof s && V.has(e.code) ? B(e, this.#e.dataDirectoryName, "restore") : e;
+		}
 	}
-	async #u(e) {
+	async #d(e) {
 		try {
-			return u(e);
+			return ee(e);
 		} catch (t) {
 			let n = (typeof e == "object" && e ? e : void 0)?.sessionId;
 			throw typeof n == "string" && await this.#e.transport.request({
@@ -99,64 +174,64 @@ var v = "pglite-electron", y = "-pgdata", b = (e) => ({
 			}).catch(() => void 0), t;
 		}
 	}
-	async #d() {
+	async #f() {
 		try {
 			await this.#e.transport.subscriptionReady?.();
 		} catch (e) {
 			let t = this.#r;
-			throw this.#o = !0, this.#a?.(), await this.#_({
+			throw this.#o = !0, this.#a?.(), await this.#y({
 				kind: "pg.close",
 				sessionId: t
-			}).catch(() => void 0), new a("host_unavailable", `desktop PGlite session ${String(t)} could not subscribe to host notifications`, { cause: e });
+			}).catch(() => void 0), new s("host_unavailable", `desktop PGlite session ${String(t)} could not subscribe to host notifications`, { cause: e });
 		}
 	}
-	async #f(e) {
+	async #p(e) {
 		e && await this.#l.catch(() => void 0), this.#o = !0, e && await this.#c.catch(() => void 0);
 		let t = this.#r;
-		this.#a?.(), this.#t.clear(), this.removeAllEventListeners(), t && o("pg.close", await this.#e.transport.request({
+		this.#a?.(), this.#t.clear(), this.removeAllEventListeners(), t && c("pg.close", await this.#e.transport.request({
 			kind: "pg.close",
 			sessionId: t
 		}));
 	}
-	async #p(e) {
-		let t = o("pg.begin", await this.#_({
+	async #m(e) {
+		let t = c("pg.begin", await this.#y({
 			kind: "pg.begin",
 			sessionId: this.sessionId,
 			...this.#e.beginTimeout === void 0 ? {} : { timeout: this.#e.beginTimeout }
 		})).result.transactionId, n = !1, r = async (e) => {
-			n = !0, o(e, await this.#_({
+			n = !0, c(e, await this.#y({
 				kind: e,
 				sessionId: this.sessionId,
 				transactionId: t
 			}));
 		}, i = () => {
-			if (n) throw new a("transaction_not_found", `transaction ${t} is already closed`);
-		}, s = {
-			query: async (e, n, r) => (i(), x(r), this.#m(t, e, n)),
-			exec: async (e, n) => (i(), x(n), this.#h(t, e)),
+			if (n) throw new s("transaction_not_found", `transaction ${t} is already closed`);
+		}, a = {
+			query: async (e, n, r) => (i(), H(r), this.#h(t, e, n)),
+			exec: async (e, n) => (i(), H(n), this.#_(t, e)),
 			rollback: async () => {
 				i(), await r("pg.rollback");
 			},
 			sql: async (e, ...n) => {
 				i();
-				let r = _(e, ...n);
-				return this.#m(t, r.query, r.params);
+				let r = C(e, ...n);
+				return this.#h(t, r.query, r.params);
 			},
 			listen: () => {
-				throw C("listen");
+				throw te("listen");
 			},
 			get closed() {
 				return n;
 			}
 		};
 		try {
-			let t = await e(s);
+			let t = await e(a);
 			return n || await r("pg.commit"), t;
 		} catch (e) {
 			throw n || await r("pg.rollback").catch(() => void 0), e;
 		}
 	}
-	async #m(e, t, n) {
+	async #h(e, t, n) {
 		let r = {
 			kind: "pg.query",
 			sessionId: this.sessionId,
@@ -164,54 +239,255 @@ var v = "pglite-electron", y = "-pgdata", b = (e) => ({
 			params: n ?? [],
 			...e === void 0 ? {} : { transactionId: e }
 		};
-		return b(o("pg.query", await this.#_(r)).result);
+		return P(c("pg.query", await this.#y(r)).result);
 	}
-	async #h(e, t) {
+	async *#g(e) {
+		for (;;) {
+			let t = c("pg.backup.next", await this.#y({
+				kind: "pg.backup.next",
+				sessionId: this.sessionId,
+				backupId: e
+			})), n = u(t.result);
+			if (n.type === "end") return;
+			yield n;
+		}
+	}
+	async #_(e, t) {
 		let n = {
 			kind: "pg.exec",
 			sessionId: this.sessionId,
 			sql: t,
 			...e === void 0 ? {} : { transactionId: e }
 		};
-		return o("pg.exec", await this.#_(n)).result.map((e) => b(e));
+		return c("pg.exec", await this.#y(n)).result.map((e) => P(e));
 	}
-	#g(e) {
+	#v(e) {
 		let t = this.#l.then(e);
 		return this.#l = t.then(void 0, () => void 0), t;
 	}
-	#_(e) {
+	#y(e) {
 		let t = this.#c.then(() => this.#e.transport.request(e));
 		return this.#c = t.then(void 0, () => void 0), t;
 	}
-	#v() {
-		if (this.#o || !this.#r) throw new a("session_closed", `desktop PGlite session ${String(this.#r)} is not open`);
+	#b() {
+		if (this.#o || !this.#r) throw new s("session_closed", `desktop PGlite session ${String(this.#r)} is not open`);
 	}
-	#y(e) {
+	#x(e) {
 		if (!this.#o && typeof e == "object" && e && e.kind === "pg.notify" && e.sessionId === this.#r) try {
-			let t = l(e);
+			let t = p(e);
 			this.#t.accept(t.channel, t.payload);
 		} catch (e) {
-			w(e);
+			W(e);
 		}
 	}
-}, E = class extends h {
+}, K = class extends y {
 	#e;
 	#t;
-	name = v;
+	name = j;
 	get dataDirectoryName() {
 		return this.#e;
 	}
 	constructor(e, t = {}) {
-		super(e, {}), this.#t = t, this.#e = t.dataDirectoryName ?? `${e.config.dbName}-pgdata`, s(this.#e);
+		super(e, {}), this.#t = t, this.#e = N(e.config.dbName, t), l(this.#e);
+	}
+	async backup(e, t = {}) {
+		try {
+			return await super.backup(e, t);
+		} catch (e) {
+			throw B(e, this.#e, "backup");
+		}
 	}
 	createClient() {
-		return new T({
-			transport: this.#t.transport ?? f(),
+		return new G({
+			transport: this.#n(),
 			dataDirectoryName: this.#e,
 			...this.#t.beginTimeout === void 0 ? {} : { beginTimeout: this.#t.beginTimeout },
 			...this.#t.batchTimeout === void 0 ? {} : { batchTimeout: this.#t.batchTimeout }
 		});
 	}
+	backupStorage() {
+		return "directory";
+	}
+	async backupExtensions() {
+		let e = c("pg.engine", await this.#n().request({ kind: "pg.engine" }));
+		return d(e.result).extensions;
+	}
+	#n() {
+		return this.#t.transport ?? h();
+	}
+}, q = (e) => new D("aborted", "Desktop PGlite restore was aborted", { cause: e.reason }), J = (e) => {
+	if (e?.aborted) throw q(e);
+}, Y = (e) => {
+	let t = !1;
+	if (e.connected$.subscribe((e) => {
+		t = e;
+	}).unsubscribe(), t) throw new D("target_busy", `RxDB "${e.config.dbName}" is already connected`, { details: {
+		field: "rxdb",
+		actual: e.config.dbName
+	} });
+}, X = async (e) => {
+	let t = c("pg.handshake", await e.request({ kind: "pg.handshake" }));
+	f(t.result);
+}, Z = async (e) => {
+	let t = c("pg.engine", await e.request({ kind: "pg.engine" }));
+	return d(t.result);
+}, Q = (e, t) => (e.init(), {
+	adapterName: j,
+	engine: _,
+	engineCompatibility: b(t.serverVersion).compatibility,
+	extensions: t.extensions,
+	systemSchemaVersion: T,
+	changeCodecVersion: w,
+	schemaFingerprint: A(e),
+	authDomain: k(e)
+}), ne = async (e, t) => {
+	let { restoreId: n } = c("pg.restore.begin", await e.request({
+		kind: "pg.restore.begin",
+		storage: {
+			engine: "pglite",
+			dataDirectoryName: t
+		}
+	})).result;
+	return {
+		step: async (t) => {
+			c(t, await e.request({
+				kind: t,
+				restoreId: n
+			}));
+		},
+		write: async (t) => {
+			c("pg.restore.write", await e.request({
+				kind: "pg.restore.write",
+				restoreId: n,
+				item: t
+			}));
+		},
+		query: async (t, r) => c("pg.restore.query", await e.request({
+			kind: "pg.restore.query",
+			restoreId: n,
+			sql: t,
+			params: r
+		})).result,
+		abort: async () => {
+			c("pg.restore.abort", await e.request({
+				kind: "pg.restore.abort",
+				restoreId: n
+			}));
+		}
+	};
+}, re = (e) => {
+	let t = {
+		type: "entry",
+		header: {
+			path: e.path,
+			kind: e.kind,
+			size: e.size
+		}
+	};
+	try {
+		u(t);
+	} catch (t) {
+		throw new D("corrupt_archive", `Archive entry ${JSON.stringify(e.path)} cannot be restored into a desktop data directory`, {
+			details: {
+				field: "path",
+				actual: e.path
+			},
+			cause: t
+		});
+	}
+	return t;
+}, ie = (e) => e.buffer instanceof ArrayBuffer && e.byteOffset === 0 && e.byteLength === e.buffer.byteLength ? e : e.slice(), ae = async (e, t) => {
+	let n = await e.next();
+	for (; n.type !== "end";) await t.write(n.type === "entry" ? re(n.header) : {
+		type: "data",
+		bytes: ie(n.bytes)
+	}), n = await e.next();
+	return n.trailer;
+}, oe = async (e, t) => {
+	let n = { query: async (t, n = []) => P(await e.query(t, n)) };
+	try {
+		await x(n, t);
+	} catch (e) {
+		throw e instanceof s && e.code === "statement_failed" ? new D("corrupt_archive", "Restored database cannot answer the verification queries", { cause: e }) : e;
+	}
+}, $ = async (e) => {
+	let { host: t, archive: n, options: r } = e;
+	await t.step("pg.restore.prepare"), await r.onStage?.("marker-written"), J(r.signal);
+	let i = await ae(n, t);
+	return await t.step("pg.restore.open"), await r.onStage?.("files-written"), J(r.signal), await oe(t, e.manifest), await r.onStage?.("verified"), J(r.signal), await t.step("pg.restore.persist"), await r.onStage?.("persisted"), await t.step("pg.restore.commit"), i;
+}, se = async (e, t, n, r) => {
+	try {
+		await e.abort();
+	} catch (e) {
+		let i = AggregateError([r, e], "Restore and cleanup both failed");
+		if (!t) {
+			let e = B(r, n, "restore");
+			throw new D(e.code, e.message, {
+				details: e.details,
+				cause: i
+			});
+		}
+		throw new D("cleanup_pending", "Desktop PGlite restore failed and its partial data could not be removed; call cleanupIncompleteElectronPGliteRestore()", {
+			details: {
+				field: "dataDirectoryName",
+				actual: n
+			},
+			cause: i
+		});
+	}
+	throw r;
+}, ce = async (e, t, n, r) => {
+	let i = t.options.transport ?? h();
+	await X(i);
+	let a = Q(t.rxdb, await Z(i));
+	J(r.signal);
+	let o = await ne(i, n), s = !1;
+	try {
+		let t = new E(e, r.signal), n = await t.readManifest();
+		return O(n, a), s = !0, {
+			...await $({
+				host: o,
+				archive: t,
+				manifest: n,
+				options: r
+			}),
+			manifest: n,
+			scope: n.scope
+		};
+	} catch (e) {
+		return se(o, s, n, e);
+	}
+}, le = async (e, t, n = {}) => {
+	let r = e.getReader(), i = N(t.rxdb.config.dbName, t.options);
+	try {
+		J(n.signal), l(i), Y(t.rxdb);
+		let e = await ce(r, t, i, n);
+		return r.releaseLock(), e;
+	} catch (e) {
+		throw await r.cancel(e).catch(() => void 0), B(e, i, "restore");
+	}
+}, ue = async (e) => {
+	let t = N(e.rxdb.config.dbName, e.options);
+	try {
+		l(t);
+		let n = e.options.transport ?? h();
+		return await X(n), c("pg.restore.cleanup", await n.request({
+			kind: "pg.restore.cleanup",
+			storage: {
+				engine: "pglite",
+				dataDirectoryName: t
+			}
+		})).result.cleaned;
+	} catch (e) {
+		let n = B(e, t, "restore");
+		throw n.code === "io_error" ? new D("cleanup_pending", `Failed to clean up the incomplete restore of "${t}"`, {
+			details: {
+				field: "dataDirectoryName",
+				actual: t
+			},
+			cause: e
+		}) : n;
+	}
 };
 //#endregion
-export { y as DESKTOP_DEFAULT_DATA_DIRECTORY_SUFFIX, e as DESKTOP_HOST_TRANSPORT_KEY, t as DESKTOP_PGLITE_DEFAULT_BEGIN_TIMEOUT_MS, n as DESKTOP_PGLITE_MAX_BEGIN_TIMEOUT_MS, r as DESKTOP_PGLITE_PROTOCOL_VERSION, T as DesktopPGliteClient, v as ELECTRON_PGLITE_ADAPTER_NAME, i as RxDBAdapterDesktopError, E as RxDBAdapterElectronPGlite, d as resolveDesktopHostTransport };
+export { M as DESKTOP_DEFAULT_DATA_DIRECTORY_SUFFIX, e as DESKTOP_HOST_TRANSPORT_KEY, t as DESKTOP_PGLITE_DEFAULT_BEGIN_TIMEOUT_MS, r as DESKTOP_PGLITE_MAX_BEGIN_TIMEOUT_MS, i as DESKTOP_PGLITE_PROTOCOL_VERSION, G as DesktopPGliteClient, j as ELECTRON_PGLITE_ADAPTER_NAME, o as RxDBAdapterDesktopError, K as RxDBAdapterElectronPGlite, ue as cleanupIncompleteElectronPGliteRestore, m as resolveDesktopHostTransport, le as restoreElectronPGliteDatabase };

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@aiao/rxdb-adapter-electron",
-  "version": "0.0.26",
+  "version": "0.0.28",
   "description": "Desktop host adapter for local SQLite files in Electron and Tauri applications.",
-  "homepage": "https://rxdb.netlify.app/docs/adapters",
+  "homepage": "https://rxdb.aiao.io/docs/adapters",
   "bugs": {
     "url": "https://github.com/aiao-io/rxdb/issues"
   },
@@ -69,13 +69,13 @@
     ]
   },
   "dependencies": {
-    "@aiao/utils": "0.0.26",
-    "@aiao/rxdb-adapter-sqlite-core": "0.0.26",
-    "@aiao/rxdb": "0.0.26"
+    "@aiao/rxdb-adapter-sqlite-core": "^0.0.28",
+    "@aiao/utils": "^0.0.28"
   },
   "peerDependencies": {
     "@electric-sql/pglite": "^0.5.8",
-    "@aiao/rxdb-adapter-pglite": "0.0.26"
+    "@aiao/rxdb": "^0.0.28",
+    "@aiao/rxdb-adapter-pglite": "^0.0.28"
   },
   "peerDependenciesMeta": {
     "@aiao/rxdb-adapter-pglite": {
@@ -86,9 +86,12 @@
     }
   },
   "devDependencies": {
-    "@electric-sql/pglite": "^0.5.8",
-    "@aiao/rxdb-adapter-pglite": "0.0.26",
-    "@aiao/rxdb-plugin-history": "0.0.26",
-    "@aiao/rxdb-test": "0.0.26"
+    "@electric-sql/pglite": "^0.5.10",
+    "@aiao/rxdb-plugin-querycache": "0.0.28",
+    "@aiao/rxdb-plugin-sync": "0.0.28",
+    "@aiao/rxdb-test": "0.0.28",
+    "@aiao/rxdb-plugin-working-tree": "0.0.28",
+    "@aiao/rxdb-plugin-history": "0.0.28",
+    "@aiao/rxdb-adapter-pglite": "0.0.28"
   }
 }