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

package/dist/pglite-host.js

@@ -0,0 +1,215 @@
+import { DESKTOP_PGLITE_DEFAULT_BEGIN_TIMEOUT_MS as e, DESKTOP_PGLITE_MAX_BEGIN_TIMEOUT_MS as t, DESKTOP_PGLITE_PROTOCOL_VERSION as n, DESKTOP_PGLITE_PROTOCOL_VERSION as r, RxDBAdapterDesktopError as i, RxDBAdapterDesktopError as a, assertValidDesktopDatabaseName as o, isDesktopPgliteRequestKind as s, parseDesktopPgliteRequest as c, parseDesktopPgliteRequest as l } from "@aiao/rxdb-adapter-sqlite-core/desktop-host";
+import { randomUUID as u } from "node:crypto";
+//#region src/pglite-host/electron-pglite-host.ts
+var d = "desktop-pglite://app-scope", f = Object.freeze([
+	"rxdb_change_notify",
+	"rxdb_branch_notify",
+	"rxdb_migration_notify"
+]), p = Symbol("pg.begin timed out"), m = async (e, t) => {
+	let n;
+	try {
+		return await Promise.race([e, new Promise((e) => {
+			n = setTimeout(() => e(p), t);
+		})]);
+	} finally {
+		clearTimeout(n);
+	}
+}, h = (e) => ({
+	rows: e.rows,
+	fields: e.fields.map((e) => ({
+		name: e.name,
+		dataTypeID: e.dataTypeID
+	})),
+	affectedRows: e.affectedRows
+}), g = (e) => e instanceof a ? {
+	kind: "error",
+	code: e.code,
+	message: e.detail
+} : {
+	kind: "error",
+	code: "host_internal_error",
+	message: e instanceof Error ? e.message : String(e)
+}, _ = async (e) => {
+	try {
+		return await e();
+	} catch (e) {
+		throw e instanceof a ? e : new a("statement_failed", e instanceof Error ? e.message : String(e), { cause: e });
+	}
+};
+function v(e) {
+	let t = /* @__PURE__ */ new Map(), n = /* @__PURE__ */ new Map(), i = /* @__PURE__ */ new Map(), o = (t, n, r) => {
+		try {
+			e.postNotify({
+				kind: "pg.notify",
+				sessionId: t,
+				channel: n,
+				payload: r
+			});
+		} catch (t) {
+			e.onDeliveryError?.(t);
+		}
+	}, s = (t) => {
+		let n = /* @__PURE__ */ new Set();
+		return {
+			sessions: n,
+			ready: (async () => {
+				let r = await e.createRuntime(t);
+				for (let e of f) await r.listen(e, (t) => {
+					for (let r of n) o(r, e, t);
+				});
+				return r;
+			})()
+		};
+	}, c = (e, t) => {
+		let r = n.get(e);
+		if (!r) throw new a("session_closed", `session ${e} is not open on this host`);
+		if (r.owner !== t) throw new a("permission_denied", `session ${e} belongs to another window`);
+		return r;
+	}, v = async (e) => {
+		let n = t.get(e.dataDirectoryName);
+		if (!n) throw new a("host_internal_error", `session references a released instance for ${e.dataDirectoryName}`);
+		return n.ready;
+	}, y = (e, t) => {
+		let n = i.get(e);
+		if (!n || n.sessionId !== t) throw new a("transaction_not_found", `transaction ${e} is unknown, already finished, or not owned by session ${t}`);
+		return n;
+	}, b = async (e, t) => {
+		let n = i.get(e);
+		if (!n) return;
+		i.delete(e), t ? n.settle.reject(t) : n.settle.resolve();
+		let r = await n.finished.then(() => void 0, (e) => e);
+		if (!(t || r === void 0)) return r instanceof a ? r : new a("statement_failed", r instanceof Error ? r.message : String(r), { cause: r });
+	}, x = async (e, i) => {
+		let { dataDirectoryName: o } = e.storage, c = t.get(o) ?? s(o);
+		t.set(o, c);
+		try {
+			await c.ready;
+		} catch (e) {
+			throw c.sessions.size === 0 && t.delete(o), new a("open_failed", `the application could not open a PGlite runtime for ${o}`, { cause: e });
+		}
+		let l = u();
+		return c.sessions.add(l), n.set(l, {
+			dataDirectoryName: o,
+			owner: i
+		}), {
+			kind: "pg.open",
+			result: {
+				sessionId: l,
+				resolvedLocation: `${d}/${o}`,
+				protocolVersion: r
+			}
+		};
+	}, S = 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) && (t.delete(r.dataDirectoryName), await (await i.ready.catch(() => void 0))?.close()));
+	}, C = async (e, t) => {
+		let n = [...i.entries()].filter(([, t]) => t.sessionId === e).map(([e]) => e);
+		for (let e of n) await b(e, new a("transaction_not_found", t));
+		return n.length;
+	}, w = async (e, t) => {
+		let n = await v(c(e.sessionId, t)), r, o = new Promise((e, t) => {
+			r = {
+				resolve: e,
+				reject: t
+			};
+		});
+		o.catch(() => void 0);
+		let s, l = new Promise((e) => {
+			s = e;
+		}), d = n.transaction(async (e) => {
+			s(e), await o;
+		});
+		d.catch(() => void 0);
+		let f = await m(l, e.timeout);
+		if (f === p) throw r.reject(new a("transaction_unavailable", "the begin that opened this transaction timed out")), new a("transaction_unavailable", `waited ${e.timeout}ms for the PGlite connection but another transaction still holds it`);
+		let h = u();
+		return i.set(h, {
+			sessionId: e.sessionId,
+			tx: f,
+			settle: r,
+			finished: d
+		}), {
+			kind: "pg.begin",
+			result: { transactionId: h }
+		};
+	}, T = async (e, t) => {
+		let n = c(e.sessionId, t), r = [...e.params];
+		if (e.transactionId !== void 0) {
+			let t = y(e.transactionId, e.sessionId);
+			return {
+				kind: "pg.query",
+				result: h(await _(() => t.tx.query(e.sql, r)))
+			};
+		}
+		let i = await v(n);
+		return {
+			kind: "pg.query",
+			result: h(await _(() => i.query(e.sql, r)))
+		};
+	}, E = async (e, t) => {
+		let n = c(e.sessionId, t), r = e.transactionId === void 0 ? await v(n) : y(e.transactionId, e.sessionId).tx;
+		return {
+			kind: "pg.exec",
+			result: (await _(() => r.exec(e.sql))).map(h)
+		};
+	}, D = async (e, t) => {
+		c(e.sessionId, t), y(e.transactionId, e.sessionId);
+		let n = e.kind === "pg.rollback" ? new a("write_aborted", "rollback requested") : null, r = await b(e.transactionId, n);
+		if (r) throw r;
+		return { kind: e.kind };
+	}, O = async (e, t) => {
+		let n = await v(c(e.sessionId, t)), r = (await _(() => n.query("SELECT version() AS version"))).rows[0]?.version;
+		if (typeof r != "string") throw new a("host_internal_error", "PostgreSQL did not report a version string");
+		return {
+			kind: "pg.version",
+			result: r
+		};
+	}, k = async (e, t) => (c(e.sessionId, t), await C(e.sessionId, `session ${e.sessionId} was closed`), await S(e.sessionId), { kind: "pg.close" }), A = (e, t) => {
+		switch (e.kind) {
+			case "pg.handshake": return Promise.resolve({
+				kind: "pg.handshake",
+				result: { protocolVersion: r }
+			});
+			case "pg.open": return x(e, t);
+			case "pg.query": return T(e, t);
+			case "pg.exec": return E(e, t);
+			case "pg.begin": return w(e, t);
+			case "pg.commit":
+			case "pg.rollback": return D(e, t);
+			case "pg.version": return O(e, t);
+			case "pg.close": return k(e, t);
+			default: throw new a("protocol_violation", `unsupported pglite request kind: ${String(e.kind)}`);
+		}
+	};
+	return {
+		handle: async (e, t) => {
+			try {
+				return await A(l(e), t);
+			} catch (e) {
+				return g(e);
+			}
+		},
+		get openSessionCount() {
+			return n.size;
+		},
+		get openInstanceCount() {
+			return t.size;
+		},
+		get openTransactionCount() {
+			return i.size;
+		},
+		releaseOwner: async (e) => {
+			let t = [...n.entries()].filter(([, t]) => t.owner === e).map(([e]) => e), r = 0;
+			for (let n of t) r += await C(n, `owner ${e} is gone`), await S(n);
+			return r;
+		},
+		closeAll: async () => {
+			for (let e of [...n.keys()]) await C(e, "the host is shutting down"), await S(e);
+		}
+	};
+}
+//#endregion
+export { e as DESKTOP_PGLITE_DEFAULT_BEGIN_TIMEOUT_MS, t as DESKTOP_PGLITE_MAX_BEGIN_TIMEOUT_MS, n as DESKTOP_PGLITE_PROTOCOL_VERSION, f as DESKTOP_PGLITE_WATCH_CHANNELS, i as RxDBAdapterDesktopError, o as assertValidDesktopDatabaseName, v as createElectronPgliteHost, s as isDesktopPgliteRequestKind, c as parseDesktopPgliteRequest };

package/dist/pglite.d.ts

@@ -0,0 +1,20 @@
+/**
+ * `@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 { 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,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,217 @@
+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";
+//#region src/pglite/pglite-adapter.interface.ts
+var v = "pglite-electron", y = "-pgdata", b = (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) => {
+	queueMicrotask(() => {
+		throw e;
+	});
+}, T = class extends g {
+	#e;
+	#t;
+	#n = "";
+	#r;
+	#i;
+	#a;
+	#o = !1;
+	#s;
+	#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");
+		return this.#r;
+	}
+	get resolvedLocation() {
+		if (!this.#i) throw new a("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({
+			resolveDbName: () => this.#n,
+			emit: (e) => this.dispatchEvent(e.type, e),
+			batchTimeout: e.batchTimeout ?? p,
+			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}`);
+		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({
+			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();
+	}
+	async query(e, t, n) {
+		return this.#v(), x(n), this.#g(async () => this.#m(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));
+	}
+	async exec(e, t) {
+		return this.#v(), x(t), this.#g(async () => this.#h(void 0, e));
+	}
+	async transaction(e) {
+		return this.#v(), this.#g(() => this.#p(e));
+	}
+	async version() {
+		return this.#v(), this.#g(async () => o("pg.version", await this.#_({
+			kind: "pg.version",
+			sessionId: this.sessionId
+		})).result);
+	}
+	async disconnect() {
+		this.#s ??= this.#f(!0), await this.#s;
+	}
+	async forceClose() {
+		this.#s ??= this.#f(!1), await this.#s;
+	}
+	async #u(e) {
+		try {
+			return u(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 #d() {
+		try {
+			await this.#e.transport.subscriptionReady?.();
+		} catch (e) {
+			let t = this.#r;
+			throw this.#o = !0, this.#a?.(), await this.#_({
+				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 });
+		}
+	}
+	async #f(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({
+			kind: "pg.close",
+			sessionId: t
+		}));
+	}
+	async #p(e) {
+		let t = o("pg.begin", await this.#_({
+			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.#_({
+				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)),
+			rollback: async () => {
+				i(), await r("pg.rollback");
+			},
+			sql: async (e, ...n) => {
+				i();
+				let r = _(e, ...n);
+				return this.#m(t, r.query, r.params);
+			},
+			listen: () => {
+				throw C("listen");
+			},
+			get closed() {
+				return n;
+			}
+		};
+		try {
+			let t = await e(s);
+			return n || await r("pg.commit"), t;
+		} catch (e) {
+			throw n || await r("pg.rollback").catch(() => void 0), e;
+		}
+	}
+	async #m(e, t, n) {
+		let r = {
+			kind: "pg.query",
+			sessionId: this.sessionId,
+			sql: t,
+			params: n ?? [],
+			...e === void 0 ? {} : { transactionId: e }
+		};
+		return b(o("pg.query", await this.#_(r)).result);
+	}
+	async #h(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));
+	}
+	#g(e) {
+		let t = this.#l.then(e);
+		return this.#l = t.then(void 0, () => void 0), t;
+	}
+	#_(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`);
+	}
+	#y(e) {
+		if (!this.#o && typeof e == "object" && e && e.kind === "pg.notify" && e.sessionId === this.#r) try {
+			let t = l(e);
+			this.#t.accept(t.channel, t.payload);
+		} catch (e) {
+			w(e);
+		}
+	}
+}, E = class extends h {
+	#e;
+	#t;
+	name = v;
+	get dataDirectoryName() {
+		return this.#e;
+	}
+	constructor(e, t = {}) {
+		super(e, {}), this.#t = t, this.#e = t.dataDirectoryName ?? `${e.config.dbName}-pgdata`, s(this.#e);
+	}
+	createClient() {
+		return new T({
+			transport: this.#t.transport ?? f(),
+			dataDirectoryName: this.#e,
+			...this.#t.beginTimeout === void 0 ? {} : { beginTimeout: this.#t.beginTimeout },
+			...this.#t.batchTimeout === void 0 ? {} : { batchTimeout: this.#t.batchTimeout }
+		});
+	}
+};
+//#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 };

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,94 @@
 {
   "name": "@aiao/rxdb-adapter-electron",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.0.26",
+  "description": "Desktop host adapter for local SQLite files in Electron and Tauri applications.",
+  "homepage": "https://rxdb.netlify.app/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/utils": "0.0.26",
+    "@aiao/rxdb-adapter-sqlite-core": "0.0.26",
+    "@aiao/rxdb": "0.0.26"
+  },
+  "peerDependencies": {
+    "@electric-sql/pglite": "^0.5.8",
+    "@aiao/rxdb-adapter-pglite": "0.0.26"
+  },
+  "peerDependenciesMeta": {
+    "@aiao/rxdb-adapter-pglite": {
+      "optional": true
+    },
+    "@electric-sql/pglite": {
+      "optional": true
+    }
+  },
+  "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"
+  }
 }

package/src/RxDBAdapterElectron.ts

@@ -0,0 +1,66 @@
+/**
+ * Electron 本地 SQLite 适配器。
+ *
+ * @module RxDBAdapterElectron
+ */
+
+import type { RxDB } from '@aiao/rxdb';
+import { RxDBAdapterSqliteBase } from '@aiao/rxdb-adapter-sqlite-core';
+import {
+  DEFAULT_DATABASE_SUFFIX,
+  DesktopSqliteClient,
+  assertValidDesktopDatabaseName,
+  resolveDesktopHostTransport,
+  type DesktopOptions
+} from '@aiao/rxdb-adapter-sqlite-core/desktop-host';
+import { ADAPTER_NAME } from './electron-adapter.interface.js';
+
+/**
+ * 把 RxDB 接到 Electron 应用私有目录里的真实 SQLite 文件上。
+ *
+ * @remarks
+ * 数据落在主进程的 `node:sqlite` 连接里，renderer 只通过一条窄传输层发请求，
+ * 因此它既拿不到文件系统句柄，也拿不到物理路径（AC#3）。
+ *
+ * 适配器本身没有自己的查询实现：它复用 {@link RxDBAdapterSqliteBase} 的全套 SQL、事务
+ * 与分支切换逻辑，只把「客户端从哪来」换成了桌面 host。Tauri 侧是同构的另一个类
+ * （`@aiao/rxdb-adapter-tauri` 的 `RxDBAdapterTauri`），两者共用同一份线协议与 renderer client。
+ */
+export class RxDBAdapterElectron extends RxDBAdapterSqliteBase {
+  readonly #databaseName: string;
+  override readonly name: string = ADAPTER_NAME;
+
+  /** 解析出的逻辑数据库名，与 host 侧的物理文件一一对应。 */
+  get databaseName(): string {
+    return this.#databaseName;
+  }
+
+  /**
+   * @param rxdb - 绑定的 RxDB 实例
+   * @param options - 传输层与逻辑数据库名
+   * @throws {@link RxDBAdapterDesktopError} 逻辑数据库名越出应用作用域时抛 `invalid_database_name`
+   */
+  constructor(
+    rxdb: RxDB,
+    readonly options: DesktopOptions = {}
+  ) {
+    super(rxdb, options);
+    this.#databaseName = options.databaseName ?? `${rxdb.config.dbName}${DEFAULT_DATABASE_SUFFIX}`;
+    // 在构造期就校验：名字非法时根本没有能打开的库，等发出 IPC 才报错只会让原因离现场更远。
+    assertValidDesktopDatabaseName(this.#databaseName);
+  }
+
+  protected override async createClient(): Promise<DesktopSqliteClient> {
+    return DesktopSqliteClient.connect(
+      this.options.transport ?? resolveDesktopHostTransport(),
+      { engine: 'sqlite', databaseName: this.#databaseName },
+      { batchTimeout: this.options.batchTimeout }
+    );
+  }
+}
+
+declare module '@aiao/rxdb' {
+  interface RxDBAdapters {
+    [ADAPTER_NAME]: RxDBAdapterElectron;
+  }
+}

package/src/electron-adapter.interface.ts

@@ -0,0 +1,25 @@
+/**
+ * Electron 适配器在本包内的身份。
+ *
+ * @remarks
+ * 选项形状与逻辑文件名后缀已下沉到 `@aiao/rxdb-adapter-sqlite-core/desktop-host`
+ * （两个桌面运行时共用同一份）；留在这里的只有**注册名**——它是每个运行时包各自的身份，
+ * 共享层不替它们定名。
+ *
+ * 名字按 `<引擎>-<运行时>` 构成（与 `@aiao/rxdb-adapter-miniprogram` 的
+ * `wa-sqlite-miniprogram` 同构）。它不能只叫 `electron`：US-208 会在同一个运行时上
+ * 再立一个 PGlite 适配器（`pglite-electron`），到时两者都要能同时注册。
+ *
+ * @module electron-adapter.interface
+ */
+
+import type { DesktopHostAdapterName } from '@aiao/rxdb-adapter-sqlite-core/desktop-host';
+
+/**
+ * 适配器在 `RxDBAdapters` 注册表中的名字。
+ *
+ * @remarks
+ * `satisfies` 把它钉在共享层的登记表上：这个名字改了而 `DESKTOP_HOST_ADAPTER_NAMES` 没跟上，
+ * 是编译错误而不是某个下游在运行期才发现的 `adapter_mismatch`。
+ */
+export const ADAPTER_NAME = 'sqlite-electron' as const satisfies DesktopHostAdapterName;