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

package/dist/pglite.d.ts

@@ -0,0 +1,22 @@
+/**
+ * `@aiao/rxdb-adapter-electron` 的 **PGlite renderer 侧**入口。
+ *
+ * @remarks
+ * 与默认入口分开而不是并进去，理由是依赖：默认入口只要共享层，本入口却要
+ * `@aiao/rxdb-adapter-pglite` 这个可选 peer。合并的话，任何一个只用 SQLite 的应用
+ * 都会在 import 适配器时撞上「找不到 `@aiao/rxdb-adapter-pglite`」——而它压根没打算用 PGlite。
+ *
+ * 本入口**不引用 PostgreSQL 运行时**：WASM 实例活在主进程，renderer 这边只有一层协议
+ * 代理，从 `@electric-sql/pglite` 拿的只有类型和 `/template` 那个约 2 KB 的模板编译子路径，
+ * 因此 bundle 里不会多出几十兆的 PostgreSQL。特权侧请用
+ * `@aiao/rxdb-adapter-electron/pglite-host`。
+ *
+ * @module @aiao/rxdb-adapter-electron/pglite
+ */
+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

@@ -0,0 +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,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

@@ -0,0 +1,493 @@
+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 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
+}), 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;
+	});
+}, G = class extends S {
+	#e;
+	#t;
+	#n = "";
+	#r;
+	#i;
+	#a;
+	#o = !1;
+	#s;
+	#c = Promise.resolve();
+	#l = Promise.resolve();
+	get sessionId() {
+		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 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 v({
+			resolveDbName: () => this.#n,
+			emit: (e) => this.dispatchEvent(e.type, e),
+			batchTimeout: e.batchTimeout ?? g,
+			onParseError: (e) => console.error("Failed to parse desktop NOTIFY payload:", e)
+		});
+	}
+	async init(e, t) {
+		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 = 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.#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.#b(), H(n), this.#v(async () => this.#h(void 0, e, t));
+	}
+	async sql(e, ...t) {
+		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.#b(), H(t), this.#v(async () => this.#_(void 0, e));
+	}
+	async transaction(e) {
+		return this.#b(), this.#v(() => this.#m(e));
+	}
+	async version() {
+		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.#p(!0), await this.#s;
+	}
+	async forceClose() {
+		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 #d(e) {
+		try {
+			return ee(e);
+		} catch (t) {
+			let n = (typeof e == "object" && e ? e : void 0)?.sessionId;
+			throw typeof n == "string" && await this.#e.transport.request({
+				kind: "pg.close",
+				sessionId: n
+			}).catch(() => void 0), t;
+		}
+	}
+	async #f() {
+		try {
+			await this.#e.transport.subscriptionReady?.();
+		} catch (e) {
+			let t = this.#r;
+			throw this.#o = !0, this.#a?.(), await this.#y({
+				kind: "pg.close",
+				sessionId: t
+			}).catch(() => void 0), new s("host_unavailable", `desktop PGlite session ${String(t)} could not subscribe to host notifications`, { cause: 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 && c("pg.close", await this.#e.transport.request({
+			kind: "pg.close",
+			sessionId: t
+		}));
+	}
+	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, c(e, await this.#y({
+				kind: e,
+				sessionId: this.sessionId,
+				transactionId: t
+			}));
+		}, i = () => {
+			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 = C(e, ...n);
+				return this.#h(t, r.query, r.params);
+			},
+			listen: () => {
+				throw te("listen");
+			},
+			get closed() {
+				return n;
+			}
+		};
+		try {
+			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 #h(e, t, n) {
+		let r = {
+			kind: "pg.query",
+			sessionId: this.sessionId,
+			sql: t,
+			params: n ?? [],
+			...e === void 0 ? {} : { transactionId: e }
+		};
+		return P(c("pg.query", await this.#y(r)).result);
+	}
+	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 c("pg.exec", await this.#y(n)).result.map((e) => P(e));
+	}
+	#v(e) {
+		let t = this.#l.then(e);
+		return this.#l = t.then(void 0, () => void 0), t;
+	}
+	#y(e) {
+		let t = this.#c.then(() => this.#e.transport.request(e));
+		return this.#c = t.then(void 0, () => void 0), t;
+	}
+	#b() {
+		if (this.#o || !this.#r) throw new s("session_closed", `desktop PGlite session ${String(this.#r)} is not open`);
+	}
+	#x(e) {
+		if (!this.#o && typeof e == "object" && e && e.kind === "pg.notify" && e.sessionId === this.#r) try {
+			let t = p(e);
+			this.#t.accept(t.channel, t.payload);
+		} catch (e) {
+			W(e);
+		}
+	}
+}, K = class extends y {
+	#e;
+	#t;
+	name = j;
+	get dataDirectoryName() {
+		return this.#e;
+	}
+	constructor(e, t = {}) {
+		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 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 { 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/dist/sqlite-script.d.ts

@@ -0,0 +1,26 @@
+/**
+ * SQL 脚本切分。
+ *
+ * @remarks
+ * wasm 后端能拿到 `sqlite3_prepare_v3` 的 `pzTail`，由 SQLite 自己逐条吐出语句；`node:sqlite`
+ * 没有对应出口——`prepare()` 只编译第一条语句并**静默丢掉**后面所有语句，`exec()` 跑完整个脚本
+ * 却不返回任何结果集。多语句脚本里带 `RETURNING` 的那条因此会人间蒸发（分支切换正是这个形状）。
+ *
+ * 所以切分只能自己做。状态机逐字搬自 SQLite 的 `complete.c`（即 `sqlite3_complete()` 的实现），
+ * 与 SQLite 对「一条语句到哪里结束」的判断同源；自己发明规则迟早会在触发器体或字符串字面量上分叉。
+ *
+ * @module sqlite-script
+ */
+/**
+ * 把一段可能含多条语句的 SQL 脚本切成单条语句。
+ *
+ * @remarks
+ * 切片保留原文（含语句间的空白与注释），因此把结果按顺序拼回去与原串等价，
+ * 报错信息里的 SQL 也仍是调用方写的那一份。只含空白或注释的片段不会成为语句——
+ * 它们 prepare 出来是空语句，`node:sqlite` 会直接抛错。
+ *
+ * @param sql - 一条或多条 SQL 组成的脚本
+ * @returns 按出现顺序排列的语句原文；脚本里没有实质语句时为空数组
+ */
+export declare function splitSqliteScript(sql: string): string[];
+//# sourceMappingURL=sqlite-script.d.ts.map

package/dist/sqlite-script.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sqlite-script.d.ts","sourceRoot":"","sources":["../src/sqlite-script.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AA0FH;;;;;;;;;;GAUG;AACH,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,EAAE,CAoBvD"}

package/package.json

@@ -1,6 +1,97 @@
 {
   "name": "@aiao/rxdb-adapter-electron",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.0.28",
+  "description": "Desktop host adapter for local SQLite files in Electron and Tauri applications.",
+  "homepage": "https://rxdb.aiao.io/docs/adapters",
+  "bugs": {
+    "url": "https://github.com/aiao-io/rxdb/issues"
+  },
+  "keywords": [
+    "aiao",
+    "rxdb",
+    "sqlite",
+    "electron",
+    "tauri",
+    "desktop"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/aiao-io/rxdb.git",
+    "directory": "packages/rxdb-adapter-electron"
+  },
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "sideEffects": false,
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./host": {
+      "@aiao/source": "./src/host.ts",
+      "types": "./dist/host.d.ts",
+      "import": "./dist/host.js",
+      "default": "./dist/host.js"
+    },
+    "./pglite": {
+      "@aiao/source": "./src/pglite.ts",
+      "types": "./dist/pglite.d.ts",
+      "import": "./dist/pglite.js",
+      "default": "./dist/pglite.js"
+    },
+    "./pglite-host": {
+      "@aiao/source": "./src/pglite-host.ts",
+      "types": "./dist/pglite-host.d.ts",
+      "import": "./dist/pglite-host.js",
+      "default": "./dist/pglite-host.js"
+    }
+  },
+  "files": [
+    "dist",
+    "src",
+    "!src/**/*.spec.*",
+    "!src/**/*.test.*",
+    "!src/**/__tests__/**",
+    "!**/*.tsbuildinfo"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "nx": {
+    "name": "rxdb-adapter-electron",
+    "tags": [
+      "js-lib"
+    ]
+  },
+  "dependencies": {
+    "@aiao/rxdb-adapter-sqlite-core": "^0.0.28",
+    "@aiao/utils": "^0.0.28"
+  },
+  "peerDependencies": {
+    "@electric-sql/pglite": "^0.5.8",
+    "@aiao/rxdb": "^0.0.28",
+    "@aiao/rxdb-adapter-pglite": "^0.0.28"
+  },
+  "peerDependenciesMeta": {
+    "@aiao/rxdb-adapter-pglite": {
+      "optional": true
+    },
+    "@electric-sql/pglite": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@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"
+  }
 }