@aiao/rxdb-adapter-sqliteai 0.0.24 → 0.0.26

package/dist/testing.js

@@ -0,0 +1,1537 @@
+import { n as e, t } from "./RxDBAdapterSqliteai-Bebaerj4.js";
+import { ENTITY_LOCAL_CREATE_EVENT as n, MergeBranchBeginEvent as r, MergeBranchCommitEvent as i, MergeBranchFailedEvent as a, REPOSITORY_SYNC_COMPLETE_EVENT as o, RxDB as s, RxDBBranch as c, RxDBChange as l, RxDBError as u, RxDBPluginBase as d, RxDBSync as f, SwitchBranchBeginEvent as p, SwitchBranchCommitEvent as m, SwitchBranchRollbackEvent as h, SyncType as ee, TRANSACTION_BEGIN as g, TRANSACTION_COMMIT as _, TRANSACTION_ROLLBACK as v, buildPushableRepositoryRules as te, getCurrentBranch as ne, getEntityMetadata as y, getLocalSystemRepositories as re, getRemoteSystemRepositories as ie, getRxDBChangeKey as b, getRxDBEntityIdentityKey as x, isAdapterShutdownError as S, resolve_current_branch as ae } from "@aiao/rxdb";
+import { BehaviorSubject as C, EMPTY as oe, Observable as se, ReplaySubject as ce, Subject as le, catchError as ue, combineLatest as w, filter as T, firstValueFrom as E, map as D, shareReplay as O, switchMap as k, takeUntil as A } from "rxjs";
+import { isNil as j } from "@aiao/utils";
+//#region \0rolldown/runtime.js
+var M = Object.defineProperty, de = (e, t) => {
+	let n = {};
+	for (var r in e) M(n, r, {
+		get: e[r],
+		enumerable: !0
+	});
+	return t || M(n, Symbol.toStringTag, { value: "Module" }), n;
+}, fe = async (e, t, n) => {
+	let { branchRepository: r, adapter: i } = await e.getLocalRepositories();
+	if ((await r.find({
+		where: {
+			combinator: "and",
+			rules: [{
+				field: "id",
+				operator: "=",
+				value: t
+			}]
+		},
+		limit: 1
+	})).length) throw new u(`Branch id (${t}) already exists`);
+	if (e.rxdb.config.sync?.remote?.adapter) {
+		let { adapter: n } = await e.getRemoteRepositories();
+		if (n.branchExists && await n.branchExists(t)) throw new u(`Branch id (${t}) already exists on remote`);
+	}
+	let a = await i.transaction(async (r) => {
+		let i = r.getRepository(c), a = r.getRepository(l);
+		if ((await i.find({
+			where: {
+				combinator: "and",
+				rules: [{
+					field: "id",
+					operator: "=",
+					value: t
+				}]
+			},
+			limit: 1
+		})).length) return `Branch id (${t}) already exists`;
+		let o, s;
+		if (n) {
+			let e = (await a.find({
+				where: {
+					combinator: "and",
+					rules: [{
+						field: "id",
+						operator: "=",
+						value: n
+					}]
+				},
+				limit: 1
+			}))[0];
+			if (!e) return `Change ID (${n}) not found`;
+			s = e, o = (await i.find({
+				where: {
+					combinator: "and",
+					rules: [{
+						field: "id",
+						operator: "=",
+						value: e.branchId
+					}]
+				},
+				limit: 1
+			}))[0];
+		} else o = await ae(i, e.rxdb), s = await pe(a, o.id);
+		if (!o) return "Source branch not found";
+		let u = e.rxdb.entityManager.instantiate(c);
+		return u.id = t, u.activated = !1, u.local = !0, u.remote = !1, u.fromChangeId = s?.id ?? null, u.parentId = o.id, await i.create(u), u;
+	});
+	if (typeof a == "string") throw new u(a);
+	return a;
+}, pe = async (e, t) => (await e.find({
+	where: {
+		combinator: "and",
+		rules: [t ? {
+			field: "branchId",
+			operator: "=",
+			value: t
+		} : {
+			field: "branch.activated",
+			operator: "=",
+			value: !0
+		}, {
+			field: "revertChangeId",
+			operator: "=",
+			value: null
+		}]
+	},
+	orderBy: [{
+		field: "id",
+		sort: "desc"
+	}],
+	limit: 1
+}))[0], me = (e) => {
+	if (!e || typeof e != "object") return !1;
+	let t = "name" in e ? String(e.name) : "";
+	return ("errno" in e ? Number(e.errno) : void 0) === 44 || t === "AbortError" || S(e);
+};
+function N(e) {
+	if (e.length === 1) {
+		let t = e[0];
+		return `${t.type === "INSERT" ? "创建" : t.type === "UPDATE" ? "更新" : "删除"} ${t.entity}`;
+	}
+	let t = {};
+	for (let n of e) {
+		let e = n.type.toLowerCase();
+		t[e] = (t[e] ?? 0) + 1;
+	}
+	let n = [];
+	return t.insert && n.push(`创建${t.insert}条`), t.update && n.push(`更新${t.update}条`), t.delete && n.push(`删除${t.delete}条`), `事务: ${n.join(", ")}`;
+}
+function P(e) {
+	let t = e[0], n = e.length, r = t.transactionId ?? null, i = t.createdAt, a = t.namespace, o = t.entity, s = r ? "TRANSACTION" : t.type, c = [
+		s,
+		x(t.entityId),
+		i.getTime()
+	].join(":"), l = e.some((e) => j(e.revertChangeId) === !1), u = e.some((e) => j(e.redoInvalidatedAt) === !1);
+	return {
+		transactionId: r,
+		changeId: e.reduce((e, t) => t.id > e ? t.id : e, e[0].id),
+		fingerprint: c,
+		changes: e,
+		type: s,
+		count: n,
+		createdAt: i,
+		description: N(e),
+		namespace: a,
+		entity: o,
+		reverted: l,
+		redoInvalidated: u
+	};
+}
+function F(e) {
+	let t = [], n = [], r;
+	return e.forEach((e) => {
+		e.transactionId && e.transactionId === r ? n.push(e) : (r = e.transactionId, n.length &&= (t.push(P([...n])), 0), e.transactionId ? n.push(e) : t.push(P([e])));
+	}), n.length && t.push(P([...n])), t;
+}
+var I = (e) => `${e.namespace}:${e.entity}`;
+function L(e, t) {
+	let n = new Map(t);
+	for (let t of e) {
+		if (t.lastPushedChangeId === null) continue;
+		let e = I(t), r = n.get(e);
+		r !== void 0 && r >= t.lastPushedChangeId || n.set(e, t.lastPushedChangeId);
+	}
+	return n;
+}
+function R(e, t) {
+	return t.type === "database" ? e : e.map((e) => {
+		let n = e.changes.filter((e) => t.type === "repository" ? e.namespace === t.namespace && e.entity === t.entity : e.namespace === t.namespace && e.entity === t.entity && e.entityId === t.entityId);
+		return n.length === 0 ? null : {
+			...e,
+			changes: n,
+			count: n.length,
+			description: N(n)
+		};
+	}).filter((e) => e !== null);
+}
+function z(e, t, n = 0, r = null) {
+	return e.filter((e) => !e.reverted && e.changes.every((e) => {
+		let i = e.remoteId == null, a = t.get(I(e)), o = a == null || e.id > a, s = e.id > n, c = r === null || e.createdAt.getTime() > r.getTime();
+		return i && o && s && c;
+	}));
+}
+function he(e) {
+	return e.type === "database" ? "database" : e.type === "repository" ? `${e.namespace}:${e.entity}` : `${e.namespace}:${e.entity}:${x(e.entityId)}`;
+}
+function ge(e) {
+	if (!e) return { type: "database" };
+	if (Object.getPrototypeOf(e) === Object.prototype && "type" in e) return e;
+	let t = y(e), n = "id" in e ? e.id : void 0, r = typeof n == "string" || typeof n == "number" || typeof n == "bigint" ? n : void 0;
+	return r === void 0 ? {
+		type: "repository",
+		namespace: t.namespace,
+		entity: t.name
+	} : {
+		type: "entity",
+		namespace: t.namespace,
+		entity: t.name,
+		entityId: r
+	};
+}
+function _e(e, t) {
+	let n = ge(t), r = he(n), i = e.history_cache.get(r);
+	if (i) return i;
+	let a = () => {
+		let t = (e.history_ref_counts.get(r) || 0) - 1;
+		t <= 0 ? (e.history_cache.delete(r), e.history_ref_counts.delete(r)) : e.history_ref_counts.set(r, t);
+	}, o = () => {
+		let t = (e.history_ref_counts.get(r) || 0) + 1;
+		e.history_ref_counts.set(r, t), e.history_cache.set(r, h);
+	}, s = (e) => new se((t) => {
+		o();
+		let n = e.subscribe(t);
+		return () => {
+			n.unsubscribe(), a();
+		};
+	}), c = e.histories$.pipe(D((e) => R(e, n)), O({
+		bufferSize: 1,
+		refCount: !0
+	})), l = s(c), u = s(e.undoHistories$.pipe(D((e) => R(e, n)), O({
+		bufferSize: 1,
+		refCount: !0
+	}))), d = s(e.redoHistories$.pipe(D((e) => R(e, n)), O({
+		bufferSize: 1,
+		refCount: !0
+	}))), f = s(c.pipe(D((e) => e.length), O({
+		bufferSize: 1,
+		refCount: !0
+	}))), p = s(u.pipe(D((e) => e.length), O({
+		bufferSize: 1,
+		refCount: !0
+	}))), m = s(d.pipe(D((e) => e.length), O({
+		bufferSize: 1,
+		refCount: !0
+	}))), h = {
+		type: n.type,
+		histories$: l,
+		undoHistories$: u,
+		redoHistories$: d,
+		count$: f,
+		undoCount$: p,
+		redoCount$: m,
+		undo: (t = 1) => e.runSerialized(async () => {
+			let r = e.undoSession$.value;
+			if (r.state === "cleared") return;
+			let { histories: i, lastPushedMap: a } = await e.fetchLatestHistories(r.boundary);
+			if (!e.isUndoSessionCurrent(r)) return;
+			let o = z(i, a, r.boundary.changeId, r.boundary.createdAfter), s = e.selectWholeTransactions(o, n, t);
+			s.length !== 0 && await e.applyUndoRedoHistories("undo", s, r);
+		}),
+		redo: (t = 1) => e.runSerialized(async () => {
+			let r = await E(e.redoHistories$), i = e.selectWholeTransactions(r, n, t);
+			i.length !== 0 && await e.applyUndoRedoHistories("redo", i);
+		})
+	};
+	return h;
+}
+var B = {
+	changeId: 0,
+	createdAfter: null
+};
+function ve(e, t) {
+	return e?.repositoryFilter !== void 0 && e.repositoryFilter.length > 0 ? !1 : !t.hasMore && t.failures.length === 0;
+}
+function ye(e, t) {
+	return t.complete && !t.concurrent ? 0 : Math.max(0, e - t.pulled);
+}
+var be = 1e3, xe = class {
+	#e = new C([]);
+	get items$() {
+		return this.#e.asObservable();
+	}
+	get value() {
+		return this.#e.value;
+	}
+	push(e) {
+		let t = [...e, ...this.#e.value], n = t.length > 1e3 ? t.slice(0, be) : t;
+		this.#e.next(n);
+	}
+	remove(e) {
+		let t = new Set(e.map((e) => e.fingerprint)), n = this.#e.value, r = n.filter((e) => t.has(e.fingerprint));
+		return r.length === 0 || this.#e.next(n.filter((e) => !t.has(e.fingerprint))), r;
+	}
+	clear() {
+		this.#e.next([]);
+	}
+};
+function V(e, t) {
+	return t.type === "database" ? !0 : e.namespace !== t.namespace || e.entity !== t.entity ? !1 : t.type === "repository" || e.entityId === t.entityId;
+}
+function Se(e, t) {
+	return e.changes.some((e) => V(e, t));
+}
+function Ce(e, t) {
+	return e.changes.every((e) => V(e, t));
+}
+function we(e, t, n) {
+	let r = e.filter((e) => Se(e, t)).slice(0, Math.max(0, n)), i = [], a = [];
+	for (let e of r) Ce(e, t) ? a.push(e) : i.push(e);
+	return {
+		crossScope: i,
+		selected: a
+	};
+}
+var Te = (e) => e.type === "database" ? "database" : e.type === "repository" ? `${e.namespace}:${e.entity}` : `${e.namespace}:${e.entity}#${String(e.entityId)}`, Ee = (e, t) => {
+	let n = /* @__PURE__ */ new Set();
+	for (let r of e) for (let e of r.changes) V(e, t) || n.add(t.type === "entity" ? `${e.namespace}:${e.entity}#${String(e.entityId)}` : `${e.namespace}:${e.entity}`);
+	return [...n].join(", ");
+}, De = class e extends u {
+	scope;
+	histories;
+	constructor(t, n) {
+		super(`Scoped history operation would split a transaction: scope ${Te(t)} also changes ${Ee(n, t)}. Use the database scope to apply the whole transaction.`), this.scope = t, this.histories = n, this.name = "RxDBCrossScopeTransactionError", Object.setPrototypeOf(this, e.prototype);
+	}
+}, H = (e) => e.fromChangeId ?? 0, Oe = (e) => {
+	let { branches: t, currentBranch: n, nextBranch: r } = e, i = e.currentChangeId ?? H(n), a = e.nextChangeId ?? H(r);
+	if (i === a) return [];
+	if (n.id === r.id) return [{
+		branch: n,
+		fromChangeId: i,
+		toChangeId: a
+	}];
+	let o = /* @__PURE__ */ new Map();
+	for (let e of t) o.set(e.id, e);
+	let s = (e) => {
+		let t = [e], n = /* @__PURE__ */ new Set([e.id]), r = e;
+		for (; r.parentId;) {
+			if (n.has(r.parentId)) throw new u(`Branch history is corrupt: cycle detected at branch '${r.id}' (parentId '${r.parentId}' already visited)`);
+			let e = o.get(r.parentId);
+			if (!e) throw new u(`Branch history is corrupt: branch '${r.id}' references missing parent '${r.parentId}'`);
+			n.add(e.id), t.push(e), r = e;
+		}
+		return t;
+	}, c = s(n), l = s(r), d = null, f = -1;
+	for (let e = 0; e < c.length; e++) if (l.findIndex((t) => t.id === c[e].id) !== -1) {
+		d = c[e], f = e;
+		break;
+	}
+	let p = [];
+	if (d) {
+		for (let e = 0; e < f; e++) {
+			let t = c[e], n = e === 0 ? i : H(c[e - 1]), r = H(t);
+			n !== r && p.push({
+				branch: t,
+				fromChangeId: n,
+				toChangeId: r
+			});
+		}
+		let e = l.findIndex((e) => e.id === d.id);
+		if (e === 0) {
+			let e = f === 0 ? i : H(c[f - 1]), t = a;
+			e !== t && p.push({
+				branch: d,
+				fromChangeId: e,
+				toChangeId: t
+			});
+		} else if (e > 0) {
+			let t = f === 0 ? i : H(c[f - 1]), n = H(l[e - 1]);
+			t !== n && p.push({
+				branch: d,
+				fromChangeId: t,
+				toChangeId: n
+			});
+		}
+		let t = l.slice(0, e).reverse();
+		for (let e = 0; e < t.length; e++) {
+			let n = t[e], r = H(n), i = e === t.length - 1 ? a : H(t[e + 1]);
+			r !== i && p.push({
+				branch: n,
+				fromChangeId: r,
+				toChangeId: i
+			});
+		}
+	} else {
+		for (let e = 0; e < c.length; e++) {
+			let t = c[e], n = e === 0 ? i : H(c[e - 1]), r = H(t);
+			n !== r && p.push({
+				branch: t,
+				fromChangeId: n,
+				toChangeId: r
+			});
+		}
+		let e = c[c.length - 1], t = H(e);
+		t !== 0 && p.push({
+			branch: e,
+			fromChangeId: t,
+			toChangeId: 0
+		});
+		let n = l[l.length - 1], r = l.length > 1 ? H(l[l.length - 2]) : a;
+		r !== 0 && p.push({
+			branch: n,
+			fromChangeId: 0,
+			toChangeId: r
+		});
+		let o = l.slice(0, l.length - 1).reverse();
+		for (let e = 0; e < o.length; e++) {
+			let t = o[e], n = H(t), r = e === o.length - 1 ? a : H(o[e + 1]);
+			n !== r && p.push({
+				branch: t,
+				fromChangeId: n,
+				toChangeId: r
+			});
+		}
+	}
+	return p;
+}, ke = async (e, t) => {
+	let { branchRepository: n, changeRepository: r } = await e.getLocalRepositories(), i = (await n.find({
+		where: {
+			combinator: "and",
+			rules: [{
+				field: "activated",
+				operator: "=",
+				value: !0
+			}]
+		},
+		limit: 1
+	}))[0];
+	if (!i) throw new u("Current branch not found");
+	let a = await n.find({ where: {
+		combinator: "and",
+		rules: []
+	} }), o = a.find((e) => e.id === t);
+	if (!o) throw new u(`Branch (${t}) not found`);
+	if (i.id === o.id) throw new u("Cannot switch to the same branch");
+	let s = await W(r, i.id), c = await W(r, o.id), l = Oe({
+		branches: a,
+		currentBranch: i,
+		currentChangeId: s ? s.id : null,
+		nextBranch: o,
+		nextChangeId: c ? c.id : null
+	}), d = {
+		deletes: /* @__PURE__ */ new Map(),
+		updates: /* @__PURE__ */ new Map(),
+		inserts: /* @__PURE__ */ new Map()
+	};
+	for (let e = 0; e < l.length; e++) {
+		let { branch: t, fromChangeId: n, toChangeId: i } = l[e], a = n < i, o = n > i, s = Math.min(n, i), c = Math.max(n, i), u = { where: {
+			combinator: "and",
+			rules: [
+				{
+					field: "branchId",
+					operator: "=",
+					value: t.id
+				},
+				{
+					field: "id",
+					operator: ">",
+					value: s
+				},
+				{
+					field: "id",
+					operator: "<=",
+					value: c
+				},
+				{
+					field: "revertChangeId",
+					operator: "=",
+					value: null
+				}
+			]
+		} };
+		t.fromChangeId && s < t.fromChangeId && u.where.rules.push({
+			field: "id",
+			operator: ">",
+			value: t.fromChangeId
+		});
+		let f = await r.find(u);
+		o ? je(f, d) : a && Ae(f, d);
+	}
+	return d;
+}, Ae = (e, t) => U(e, !0, t), je = (e, t) => U(e, !1, t), U = (e, t, n = {
+	deletes: /* @__PURE__ */ new Map(),
+	updates: /* @__PURE__ */ new Map(),
+	inserts: /* @__PURE__ */ new Map()
+}) => {
+	if (t) {
+		let t = [...e].sort((e, t) => e.id - t.id);
+		for (let e of t) {
+			let t = b(e);
+			switch (e.type) {
+				case "INSERT":
+					n.inserts.set(t, {
+						patch: { ...e.patch },
+						inversePatch: null
+					});
+					break;
+				case "UPDATE":
+					{
+						let r = n.inserts.get(t) || n.updates.get(t);
+						r ? (r.patch && e.patch && Object.assign(r.patch, e.patch), r.inversePatch === null && e.inversePatch ? r.inversePatch = { ...e.inversePatch } : r.inversePatch && e.inversePatch && Object.assign(r.inversePatch, e.inversePatch)) : n.updates.set(t, {
+							patch: { ...e.patch },
+							inversePatch: { ...e.inversePatch }
+						});
+					}
+					break;
+				case "DELETE": n.deletes.set(t, {
+					patch: null,
+					inversePatch: { ...e.inversePatch }
+				}), n.inserts.delete(t), n.updates.delete(t);
+			}
+		}
+	} else {
+		let t = [...e].sort((e, t) => t.id - e.id);
+		for (let e of t) {
+			let t = b(e);
+			switch (e.type) {
+				case "INSERT":
+					n.deletes.set(t, {
+						patch: null,
+						inversePatch: { ...e.patch }
+					}), n.inserts.delete(t), n.updates.delete(t);
+					break;
+				case "UPDATE":
+					{
+						let r = n.inserts.get(t) || n.updates.get(t);
+						r ? (r.patch && e.inversePatch && Object.assign(r.patch, e.inversePatch), r.inversePatch && e.patch && Object.assign(r.inversePatch, e.patch)) : n.updates.set(t, {
+							patch: { ...e.inversePatch },
+							inversePatch: { ...e.patch }
+						});
+					}
+					break;
+				case "DELETE": n.inserts.set(t, {
+					patch: { ...e.inversePatch },
+					inversePatch: null
+				});
+			}
+		}
+	}
+	return n;
+}, W = async (e, t) => (await e.find({
+	where: {
+		combinator: "and",
+		rules: [{
+			field: "branchId",
+			operator: "=",
+			value: t
+		}, {
+			field: "revertChangeId",
+			operator: "=",
+			value: null
+		}]
+	},
+	orderBy: [{
+		field: "id",
+		sort: "desc"
+	}],
+	limit: 1
+}))[0], G = (e) => e.getRepository(f);
+async function Me(e, t) {
+	let { changeRepository: n, branchRepository: r } = await e.rxdb.versionManager.getLocalRepositories(), i = await r.find({ where: {
+		combinator: "and",
+		rules: [{
+			field: "activated",
+			operator: "=",
+			value: !0
+		}]
+	} });
+	if (i.length === 0) return {
+		histories: [],
+		lastPushedMap: /* @__PURE__ */ new Map()
+	};
+	let a = i[0], o = L(await G(await E(e.rxdb.localAdapter$)).find({ where: {
+		combinator: "and",
+		rules: [{
+			field: "branchId",
+			operator: "=",
+			value: a.id
+		}]
+	} }), e.rxdb.versionManager.pushInFlight.snapshot()), s = [{
+		field: "branchId",
+		operator: "=",
+		value: a.id
+	}, {
+		field: "createdAt",
+		operator: ">=",
+		value: e.getFirstConnectedAt()
+	}];
+	return t.changeId > 0 && s.push({
+		field: "id",
+		operator: ">",
+		value: t.changeId
+	}), {
+		histories: F(await n.find({
+			where: {
+				combinator: "and",
+				rules: s
+			},
+			orderBy: [{
+				field: "id",
+				sort: "desc"
+			}]
+		})),
+		lastPushedMap: o
+	};
+}
+async function Ne(e, t, n, r) {
+	e.isUndoRedoInProgress = !0;
+	try {
+		let i = n.flatMap((e) => e.changes).sort((e, n) => t === "undo" ? n.id - e.id : e.id - n.id), a = U(i, t === "redo"), o = e.getNextRevertStateUpdatedAt(i);
+		if (t === "undo") {
+			let { adapter: t } = await e.rxdb.versionManager.getLocalRepositories(), n = await t.getRxDBChangeSequence(), r = /* @__PURE__ */ new Date();
+			i.forEach((e, t) => {
+				let i = `rxdb:RxDBChange:${e.id}`, s = a.updates.get(i) || {
+					patch: {},
+					inversePatch: null
+				};
+				a.updates.set(i, {
+					patch: {
+						...s.patch,
+						revertChangeId: n + t + 1,
+						revertChangedAt: r,
+						updatedAt: o
+					},
+					inversePatch: s.inversePatch
+				});
+			}), a.updateRxDBChangeSequence = n + i.length, e.redoInvalidationFloor = n + i.length;
+		} else i.forEach((e) => {
+			let t = `rxdb:RxDBChange:${e.id}`, n = a.updates.get(t) || {
+				patch: {},
+				inversePatch: null
+			};
+			a.updates.set(t, {
+				patch: {
+					...n.patch,
+					revertChangeId: null,
+					updatedAt: o
+				},
+				inversePatch: n.inversePatch
+			});
+		});
+		let { adapter: s } = await e.rxdb.versionManager.getLocalRepositories();
+		if (t === "undo" && (r === void 0 || !e.isUndoSessionCurrent(r))) return;
+		await s.switchBranch({ actions: a }), e.pushableCountTrigger$.next(Date.now()), e.setRevertStateWatermarks(i, t === "undo", o), t === "undo" ? e.pushToRedoStack(n) : e.removeFromRedoStack(n);
+	} finally {
+		e.isUndoRedoInProgress = !1;
+	}
+}
+async function Pe(e) {
+	let t = ++e.pushableGeneration, n = (n) => {
+		t === e.pushableGeneration && e.pushableCount$.next(n);
+	};
+	try {
+		if (!await E(e.rxdb.connected$)) {
+			n(0);
+			return;
+		}
+		let t = G(await E(e.rxdb.localAdapter$)), r = e.rxdb.entityManager.getRepository(l), i = await E(e.rxdb.entityManager.getRepository(c).findOne({ where: {
+			combinator: "and",
+			rules: [{
+				field: "activated",
+				operator: "=",
+				value: !0
+			}]
+		} }));
+		if (!i) {
+			n(0);
+			return;
+		}
+		let a = await t.find({ where: {
+			combinator: "and",
+			rules: [{
+				field: "branchId",
+				operator: "=",
+				value: i.id
+			}]
+		} }), o = te(e.rxdb.config.entities, e.rxdb.config.sync, a);
+		if (o.length === 0) {
+			n(0);
+			return;
+		}
+		n(await E(r.count({ where: {
+			combinator: "and",
+			rules: [
+				{
+					field: "branchId",
+					operator: "=",
+					value: i.id
+				},
+				{
+					field: "revertChangeId",
+					operator: "=",
+					value: null
+				},
+				{
+					field: "remoteId",
+					operator: "=",
+					value: null
+				},
+				{
+					combinator: "or",
+					rules: o
+				}
+			]
+		} })));
+	} catch (t) {
+		!e.destroyed && !S(t) && (console.error("[#updatePushableCount] error", t), e.errors$.next(t instanceof Error ? t : Error(String(t)))), n(0);
+	}
+}
+var K = (e) => e.reduce((e, t) => t < e ? t : e, Infinity), q = class {
+	rxdb;
+	#e = [];
+	#t = !1;
+	#n;
+	#r;
+	#i = new ce(1);
+	#a = Promise.resolve();
+	#o = new C(0);
+	#s = 0;
+	#c = new C(0);
+	#l = 0;
+	#u = new C(0);
+	#d = /* @__PURE__ */ new Map();
+	#f = new C(0);
+	#p = 0;
+	#m;
+	#h = null;
+	#g = /* @__PURE__ */ new Date();
+	#_ = /* @__PURE__ */ new Map();
+	#v = null;
+	#y = 0;
+	#b = null;
+	#x = new C({
+		generation: 0,
+		state: "active",
+		boundary: B
+	});
+	isUndoRedoInProgress = !1;
+	isInvalidatingRedo = !1;
+	syncDepth = 0;
+	redoStack = new xe();
+	history_cache = /* @__PURE__ */ new Map();
+	history_ref_counts = /* @__PURE__ */ new Map();
+	histories$;
+	undoHistories$;
+	redoHistories$;
+	undoCount$;
+	redoCount$;
+	errors$ = new le();
+	pushableCount$;
+	pullableCount$;
+	count$;
+	get undoSessionGeneration() {
+		return this.#x.value.generation;
+	}
+	constructor(e) {
+		this.rxdb = e, this.#n = this.#R(), this.#r = this.#z();
+		let t = e.entityManager.getRepository(c), n = e.entityManager.getRepository(l), r = t.findOne({ where: {
+			combinator: "and",
+			rules: [{
+				field: "activated",
+				operator: "=",
+				value: !0
+			}]
+		} });
+		this.#e.push(r.pipe(A(this.#i)).subscribe({
+			next: (e) => this.#E(e?.id ?? null),
+			error: (e) => this.#T("undo session 分支跟随的活跃分支流已中断", e)
+		})), this.#m = w({
+			connected: this.rxdb.connected$,
+			branch: r
+		}).pipe(T(({ connected: e, branch: t }) => e && !!t), k(({ branch: e }) => {
+			let t = this.#M();
+			return n.findAll({
+				where: {
+					combinator: "and",
+					rules: [{
+						field: "branchId",
+						operator: "=",
+						value: e.id
+					}, {
+						field: "createdAt",
+						operator: ">=",
+						value: t
+					}]
+				},
+				orderBy: [{
+					field: "id",
+					sort: "desc"
+				}]
+			});
+		}), A(this.#i));
+		let i = this.#m.pipe(D((e) => F(e)), O({
+			bufferSize: 1,
+			refCount: !0
+		}));
+		this.histories$ = w([i, this.#f]).pipe(D(([e]) => this.#O(e)), O({
+			bufferSize: 1,
+			refCount: !0
+		})), this.count$ = this.histories$.pipe(D((e) => e.length), O({
+			bufferSize: 1,
+			refCount: !0
+		})), this.undoHistories$ = w({
+			histories: this.histories$,
+			undoSession: this.#x,
+			trigger: this.#u
+		}).pipe(k(async ({ histories: e, undoSession: t }) => {
+			if (t.state === "cleared") return [];
+			try {
+				let n = await E(this.rxdb.entityManager.getRepository(c).findOne({ where: {
+					combinator: "and",
+					rules: [{
+						field: "activated",
+						operator: "=",
+						value: !0
+					}]
+				} }));
+				return n ? z(e, L(await G(await E(this.rxdb.localAdapter$)).find({ where: {
+					combinator: "and",
+					rules: [{
+						field: "branchId",
+						operator: "=",
+						value: n.id
+					}]
+				} }), this.rxdb.versionManager.pushInFlight.snapshot()), t.boundary.changeId, t.boundary.createdAfter) : [];
+			} catch (e) {
+				let t = e instanceof Error ? e : Error(String(e));
+				return this.errors$.next(t), [];
+			}
+		}), O({
+			bufferSize: 1,
+			refCount: !0
+		})), this.redoHistories$ = this.redoStack.items$, this.undoCount$ = this.undoHistories$.pipe(D((e) => e.length), O({
+			bufferSize: 1,
+			refCount: !0
+		})), this.redoCount$ = this.redoHistories$.pipe(D((e) => e.length), O({
+			bufferSize: 1,
+			refCount: !0
+		})), this.pushableCount$ = this.#c.asObservable(), this.pullableCount$ = this.#o.asObservable();
+		let a = w({
+			connected: this.rxdb.connected$,
+			branch: r
+		}).pipe(T(({ connected: e, branch: t }) => e && !!t), k(({ branch: e }) => {
+			let t = [
+				{
+					field: "branchId",
+					operator: "=",
+					value: e.id
+				},
+				{
+					field: "revertChangeId",
+					operator: "=",
+					value: null
+				},
+				{
+					field: "remoteId",
+					operator: "=",
+					value: null
+				}
+			];
+			return n.count({ where: {
+				combinator: "and",
+				rules: t
+			} }).pipe(ue((e) => (this.#T("pushableCount 的变更计数查询", e), oe)));
+		})).subscribe({
+			next: () => {
+				this.#L();
+			},
+			error: (e) => this.#T("pushableCount 重算的活跃分支流已中断", e)
+		});
+		this.#e.push(a), this.rxdb.addEventListener(o, this.#F), this.#L();
+	}
+	destroy() {
+		this.#t = !0, this.#i.next(), this.#i.complete();
+		for (let e of this.#e) e.unsubscribe();
+		this.#e.length = 0, this.rxdb.removeEventListener(o, this.#F), this.#d.clear(), this.errors$.complete();
+	}
+	incrementPullableCount(e) {
+		this.#s++;
+		let t = this.#o.value + e;
+		this.#o.next(t);
+	}
+	resetPullableCount() {
+		this.#s++, this.#o.next(0);
+	}
+	beginPullableSettlement() {
+		return this.#s;
+	}
+	reconcilePullableCount(e, t) {
+		let n = e === this.#s ? t : Math.max(this.#o.value, t);
+		this.#o.next(n);
+	}
+	settlePullableCount(e, t) {
+		this.#o.next(ye(this.#o.value, {
+			complete: t.complete,
+			concurrent: e !== this.#s,
+			pulled: t.pulled
+		}));
+	}
+	pushToRedoStack(e) {
+		this.redoStack.push(e);
+	}
+	removeFromRedoStack(e) {
+		return this.redoStack.remove(e);
+	}
+	clearRedoStack() {
+		this.redoStack.clear();
+	}
+	setUndoBranch(e) {
+		this.#E(e);
+	}
+	clearUndoHistory() {
+		this.#w({
+			generation: this.#C(),
+			state: "cleared",
+			boundary: this.#x.value.boundary,
+			clearedAt: /* @__PURE__ */ new Date()
+		}), this.clearRedoStack();
+	}
+	clearAllUndoHistory() {
+		let e = /* @__PURE__ */ new Date(), t = (t) => ({
+			generation: this.#C(),
+			state: "cleared",
+			boundary: t.boundary,
+			clearedAt: e
+		});
+		for (let [e, n] of this.#_) this.#_.set(e, t(n));
+		this.#v = t(this.#v ?? {
+			generation: 0,
+			state: "active",
+			boundary: B
+		});
+		let n = this.#b === null ? void 0 : this.#_.get(this.#b);
+		this.#x.next(n ?? this.#v), this.clearRedoStack();
+	}
+	resetSyncCleared(e = [], t) {
+		let n = this.#x.value;
+		if (n.state === "active") return;
+		let r = e.filter((e) => Number.isSafeInteger(e) && e > 0);
+		if (t === void 0) {
+			if (r.length === 0) return;
+			let e = K(r);
+			this.#w({
+				generation: n.generation,
+				state: "active",
+				boundary: {
+					changeId: Math.max(n.boundary.changeId, e - 1),
+					createdAfter: n.boundary.createdAfter
+				}
+			});
+			return;
+		}
+		if (!(t.generation === null ? t.recordAt !== null && Number.isFinite(t.recordAt.getTime()) && t.recordAt.getTime() > n.clearedAt.getTime() : t.generation === n.generation)) return;
+		let i = r.length > 0 ? K(r) : null, a = i === null && (n.boundary.createdAfter === null || n.boundary.createdAfter.getTime() < n.clearedAt.getTime()) ? n.clearedAt : n.boundary.createdAfter;
+		this.#w({
+			generation: n.generation,
+			state: "active",
+			boundary: {
+				changeId: i === null ? n.boundary.changeId : Math.max(n.boundary.changeId, i - 1),
+				createdAfter: a
+			}
+		});
+	}
+	isExecutingUndoRedo() {
+		return this.isUndoRedoInProgress || this.isInvalidatingRedo || this.syncDepth > 0;
+	}
+	async syncing(e) {
+		this.syncDepth += 1;
+		try {
+			return await e();
+		} finally {
+			--this.syncDepth;
+		}
+	}
+	async invalidateRedoStack(e) {
+		return this.#j(async () => {
+			if (!(this.isUndoRedoInProgress || this.isInvalidatingRedo) && !(e?.length && e.every((e) => e <= this.#p))) {
+				this.isInvalidatingRedo = !0;
+				try {
+					let e = await E(this.redoHistories$);
+					if (e.length === 0) return;
+					let t = e.flatMap((e) => e.changes), n = /* @__PURE__ */ new Date(), r = U([], !1), { adapter: i } = await this.rxdb.versionManager.getLocalRepositories();
+					t.forEach((e) => {
+						let t = `rxdb:RxDBChange:${e.id}`;
+						r.updates.set(t, {
+							patch: { redoInvalidatedAt: n },
+							inversePatch: { redoInvalidatedAt: null }
+						});
+					}), await i.switchBranch({ actions: r }), this.clearRedoStack();
+				} catch (e) {
+					throw console.error("[HistoryManager] Failed to invalidate redo stack:", e), e;
+				} finally {
+					this.isInvalidatingRedo = !1;
+				}
+			}
+		});
+	}
+	history(e) {
+		return _e(this.#n, e);
+	}
+	#S(e, t, n) {
+		let { crossScope: r, selected: i } = we(e, t, n);
+		if (r.length > 0) throw new De(t, r);
+		return i;
+	}
+	#C() {
+		return ++this.#y;
+	}
+	#w(e) {
+		this.#b !== null && this.#_.set(this.#b, e), this.#x.next(e);
+	}
+	#T(e, t) {
+		this.#t || S(t) || (console.error(`[HistoryManager] ${e}:`, t), this.errors$.next(t instanceof Error ? t : Error(String(t))));
+	}
+	#E(e) {
+		if (e === this.#b || (this.#b === null && e !== null && !this.#_.has(e) && this.#_.set(e, this.#x.value), this.#b = e, e === null)) return;
+		let t = this.#_.get(e) ?? this.#D();
+		this.#_.set(e, t), this.#x.next(t);
+	}
+	#D() {
+		let e = this.#C(), t = this.#v;
+		return t === null ? {
+			generation: e,
+			state: "active",
+			boundary: B
+		} : {
+			...t,
+			generation: e
+		};
+	}
+	#O(e) {
+		return e.map((e) => {
+			let t = !1;
+			for (let n of e.changes) {
+				let e = {
+					reverted: n.revertChangeId != null,
+					updatedAt: n.updatedAt.getTime()
+				}, r = this.#d.get(n.id), i = r && r.updatedAt >= e.updatedAt ? r : e;
+				r && e.updatedAt > r.updatedAt && this.#d.set(n.id, e), t ||= i.reverted;
+			}
+			return t === e.reverted ? e : {
+				...e,
+				reverted: t
+			};
+		});
+	}
+	#k(e) {
+		let t = Date.now();
+		for (let n of e) {
+			let e = this.#d.get(n.id)?.updatedAt ?? 0;
+			t = Math.max(t, n.updatedAt.getTime() + 1, e + 1);
+		}
+		return new Date(t);
+	}
+	#A(e, t, n) {
+		for (let r of e) this.#d.set(r.id, {
+			reverted: t,
+			updatedAt: n.getTime()
+		});
+		this.#f.next(this.#f.value + 1);
+	}
+	#j(e) {
+		let t = this.#a.then(e, e);
+		return this.#a = t.catch(() => void 0), t;
+	}
+	#M() {
+		return this.#h ||= this.rxdb.firstConnectedAt ?? this.#g, this.#h;
+	}
+	#N(e) {
+		return this.#x.value === e;
+	}
+	async #P(e) {
+		return Me(this.#r, e);
+	}
+	#F = () => {
+		this.#L(), this.#u.next(Date.now());
+	};
+	async #I(e, t, n) {
+		return Ne(this.#r, e, t, n);
+	}
+	async #L() {
+		return Pe(this.#r);
+	}
+	#R() {
+		let e = this;
+		return {
+			get history_cache() {
+				return e.history_cache;
+			},
+			get history_ref_counts() {
+				return e.history_ref_counts;
+			},
+			get histories$() {
+				return e.histories$;
+			},
+			get undoHistories$() {
+				return e.undoHistories$;
+			},
+			get redoHistories$() {
+				return e.redoHistories$;
+			},
+			get undoSession$() {
+				return e.#x;
+			},
+			runSerialized: (t) => e.#j(t),
+			fetchLatestHistories: (t) => e.#P(t),
+			isUndoSessionCurrent: (t) => e.#N(t),
+			selectWholeTransactions: (t, n, r) => e.#S(t, n, r),
+			applyUndoRedoHistories: (t, n, r) => e.#I(t, n, r)
+		};
+	}
+	#z() {
+		let e = this;
+		return {
+			get rxdb() {
+				return e.rxdb;
+			},
+			get destroyed() {
+				return e.#t;
+			},
+			get isUndoRedoInProgress() {
+				return e.isUndoRedoInProgress;
+			},
+			set isUndoRedoInProgress(t) {
+				e.isUndoRedoInProgress = t;
+			},
+			get redoInvalidationFloor() {
+				return e.#p;
+			},
+			set redoInvalidationFloor(t) {
+				e.#p = t;
+			},
+			get pushableGeneration() {
+				return e.#l;
+			},
+			set pushableGeneration(t) {
+				e.#l = t;
+			},
+			get pushableCount$() {
+				return e.#c;
+			},
+			get pushableCountTrigger$() {
+				return e.#u;
+			},
+			get errors$() {
+				return e.errors$;
+			},
+			getFirstConnectedAt: () => e.#M(),
+			isUndoSessionCurrent: (t) => e.#N(t),
+			getNextRevertStateUpdatedAt: (t) => e.#k(t),
+			setRevertStateWatermarks: (t, n, r) => e.#A(t, n, r),
+			pushToRedoStack: (t) => e.pushToRedoStack(t),
+			removeFromRedoStack: (t) => e.removeFromRedoStack(t)
+		};
+	}
+}, J = async (e, t) => {
+	let { adapter: n } = await e.getLocalRepositories();
+	if (t === "main") throw new u("Cannot remove main branch");
+	let r = await n.transaction(async (e) => {
+		let n = e.getRepository(c), r = e.getRepository(l), i = (await n.find({
+			where: {
+				combinator: "and",
+				rules: [{
+					field: "id",
+					operator: "=",
+					value: t
+				}]
+			},
+			limit: 1
+		}))[0];
+		if (!i) return `Branch '${t}' not found`;
+		if (i.activated) return `Cannot remove active branch '${t}'. Switch to another branch first.`;
+		if ((await n.find({
+			where: {
+				combinator: "and",
+				rules: [{
+					field: "parentId",
+					operator: "=",
+					value: t
+				}, {
+					field: "id",
+					operator: "!=",
+					value: t
+				}]
+			},
+			limit: 1
+		}))?.length) return `Cannot remove branch '${t}' because it has child branches`;
+		let a = await r.find({ where: {
+			combinator: "and",
+			rules: [{
+				field: "branchId",
+				operator: "=",
+				value: t
+			}]
+		} });
+		await e.removeMany([...a, i]);
+	});
+	if (r) throw new u(r);
+}, Fe = async (e, t, n, r) => {
+	let i = r?.strategy ?? "squash", a = r?.deleteSource ?? !1, { branchRepository: o, changeRepository: s, adapter: c } = await e.getLocalRepositories();
+	if (t === n) throw new u(`Cannot merge branch '${t}' into itself`);
+	let l = (await o.find({
+		where: {
+			combinator: "and",
+			rules: [{
+				field: "id",
+				operator: "=",
+				value: t
+			}]
+		},
+		limit: 1
+	}))[0];
+	if (!l) throw new u(`Branch '${t}' not found`);
+	let d = await s.find({
+		where: {
+			combinator: "and",
+			rules: [
+				{
+					field: "branchId",
+					operator: "=",
+					value: t
+				},
+				{
+					field: "revertChangeId",
+					operator: "=",
+					value: null
+				},
+				...l.fromChangeId == null ? [] : [{
+					field: "id",
+					operator: ">",
+					value: l.fromChangeId
+				}]
+			]
+		},
+		orderBy: [{
+			field: "id",
+			sort: "asc"
+		}]
+	}), f = async () => {
+		if (!a) return { deleted: !1 };
+		try {
+			return await J(e, t), { deleted: !0 };
+		} catch (e) {
+			return {
+				deleted: !1,
+				error: e instanceof Error ? e : Error(String(e))
+			};
+		}
+	}, p = (e, t) => ({
+		merged: e,
+		strategy: i,
+		sourceDeleted: t.deleted,
+		...t.error ? { sourceDeleteError: t.error } : {}
+	});
+	if (d.length === 0) return p(0, await f());
+	let m;
+	if (i === "normal") await c.transaction(async (e) => {
+		for (let t of d) {
+			let n = {
+				deletes: /* @__PURE__ */ new Map(),
+				updates: /* @__PURE__ */ new Map(),
+				inserts: /* @__PURE__ */ new Map()
+			}, r = b(t);
+			t.type === "INSERT" ? n.inserts.set(r, {
+				patch: t.patch,
+				inversePatch: null
+			}) : t.type === "UPDATE" ? n.updates.set(r, {
+				patch: t.patch,
+				inversePatch: t.inversePatch
+			}) : t.type === "DELETE" && n.deletes.set(r, {
+				patch: null,
+				inversePatch: t.inversePatch
+			}), await e.mergeChanges(n, void 0, !1);
+		}
+	}), m = d.length;
+	else {
+		let e = U(d, !0), t = new Set(d.filter((e) => e.type === "INSERT").map((e) => b(e)));
+		for (let n of t) e.deletes.has(n) && e.deletes.delete(n);
+		if (m = e.inserts.size + e.updates.size + e.deletes.size, m === 0) return p(0, await f());
+		await c.mergeChanges(e, void 0, !1);
+	}
+	return p(m, await f());
+}, Ie = class {
+	#e = /* @__PURE__ */ new Map();
+	#t = 0;
+	session() {
+		let e = ++this.#t, t = /* @__PURE__ */ new Map();
+		return this.#e.set(e, t), {
+			claim: (e, n) => {
+				let r = t.get(e);
+				r !== void 0 && r >= n || t.set(e, n);
+			},
+			release: () => {
+				this.#e.delete(e);
+			}
+		};
+	}
+	snapshot() {
+		let e = /* @__PURE__ */ new Map();
+		for (let t of this.#e.values()) for (let [n, r] of t) {
+			let t = e.get(n);
+			t !== void 0 && t >= r || e.set(n, r);
+		}
+		return e;
+	}
+};
+async function Le(e, t, n) {
+	let { changeRepository: r, adapter: i } = await e.getLocalRepositories(), a = await r.find({
+		where: {
+			combinator: "and",
+			rules: [{
+				field: "id",
+				operator: "=",
+				value: Number(n.changeId)
+			}]
+		},
+		limit: 1
+	});
+	if (a.length === 0) throw new u(`RxDBChange not found: ${n.changeId}`);
+	let o = a[0];
+	if (o.type !== "DELETE") throw new u(`Cannot restore from non-DELETE change (type=${o.type})`);
+	if (!o.inversePatch) throw new u(`RxDBChange ${n.changeId} has no inversePatch`);
+	let s = t.constructor, c = y(s), l = await e.getCurrentBranch();
+	if (o.namespace !== c.namespace || o.entity !== c.name) throw new u(`RxDBChange ${n.changeId} belongs to ${o.namespace}:${o.entity}, not ${c.namespace}:${c.name}`);
+	if (o.branchId != null && o.branchId !== l.id) throw new u(`RxDBChange ${n.changeId} belongs to branch '${o.branchId}', current branch is '${l.id}'`);
+	let d = U([o], !1);
+	await i.mergeChanges(d, void 0, !1);
+	let f = await i.getRepository(s).find({
+		where: {
+			combinator: "and",
+			rules: [{
+				field: "id",
+				operator: "=",
+				value: o.entityId
+			}]
+		},
+		limit: 1
+	});
+	if (!f[0]) throw new u(`Restore produced no row for ${c.namespace}:${c.name} id=${String(o.entityId)}`);
+	return f[0];
+}
+var Re = (e, t) => ({
+	pushInFlight: t,
+	syncing: (t) => e().syncing(t),
+	clearUndoHistory: () => e().clearUndoHistory(),
+	beginPullableSettlement: () => e().beginPullableSettlement(),
+	settlePull: (t, n, r) => e().settlePullableCount(t, {
+		complete: ve(n, r),
+		pulled: r.pulled
+	}),
+	settleAbortedPull: (t, n) => e().settlePullableCount(t, {
+		complete: !1,
+		pulled: n
+	}),
+	reconcilePullableCount: (t, n) => e().reconcilePullableCount(t, n),
+	incrementPullableCount: (t) => e().incrementPullableCount(t)
+}), Y = (e) => typeof e == "number" && Number.isSafeInteger(e) && e > 0 ? e : null, ze = (e) => {
+	let t = Y(e.id);
+	return t === null ? typeof e.patch != "object" || e.patch === null || !("id" in e.patch) ? null : Y(e.patch.id) : t;
+}, Be = (e) => {
+	let t = null;
+	for (let n of e) n.recordAt instanceof Date && Number.isFinite(n.recordAt.getTime()) && (t === null || n.recordAt.getTime() < t.getTime()) && (t = n.recordAt);
+	return t;
+}, Ve = class {
+	rxdb;
+	#e = [];
+	#t = 0;
+	#n = null;
+	#r = !1;
+	#i = !1;
+	historyManager;
+	pushInFlight = new Ie();
+	syncBridge = Re(() => this.historyManager, this.pushInFlight);
+	get pushableCount$() {
+		return this.historyManager.pushableCount$;
+	}
+	get pullableCount$() {
+		return this.historyManager.pullableCount$;
+	}
+	constructor(e) {
+		this.rxdb = e, this.historyManager = new q(this.rxdb);
+	}
+	init() {
+		this.#i &&= (this.historyManager = new q(this.rxdb), !1);
+		let e = () => {
+			if (!this.#r) {
+				this.#r = !0;
+				let e = () => {
+					if (this.#t > 1) {
+						--this.#t;
+						return;
+					}
+					this.#t = 0, this.#n = null;
+				}, t = () => {
+					this.#t = 0, this.#n = null;
+				};
+				this.rxdb.addEventListener(_, e), this.rxdb.addEventListener(v, t), this.#e.push(() => this.rxdb.removeEventListener(_, e), () => this.rxdb.removeEventListener(v, t));
+			}
+			this.#t === 0 && (this.#n = this.historyManager.undoSessionGeneration), this.#t += 1;
+		};
+		this.rxdb.addEventListener(g, e), this.#e.push(() => this.rxdb.removeEventListener(g, e));
+		let t = (e) => {
+			let t = e.entities?.filter((e) => e.namespace === "rxdb" && e.entity === "RxDBChange") ?? [];
+			if (t.length > 0 && !this.historyManager.isExecutingUndoRedo()) {
+				let e = t.flatMap((e) => {
+					let t = ze(e);
+					return t === null ? [] : [t];
+				});
+				this.#a(this.historyManager.invalidateRedoStack(e), "invalidateRedoStack");
+				let n = Be(t);
+				this.#n !== null || n !== null ? this.historyManager.resetSyncCleared(e, {
+					generation: this.#n,
+					recordAt: n
+				}) : this.historyManager.resetSyncCleared(e);
+			}
+		};
+		this.rxdb.addEventListener(n, t), this.#e.push(() => this.rxdb.removeEventListener(n, t));
+	}
+	destroy() {
+		if (!this.#i) {
+			this.#i = !0, this.historyManager.destroy();
+			for (let e of this.#e) e();
+			this.#e.length = 0, this.#t = 0, this.#n = null, this.#r = !1;
+		}
+	}
+	resetSessionState() {
+		this.historyManager.clearAllUndoHistory(), this.historyManager.resetPullableCount();
+	}
+	async createBranch(e, t) {
+		return fe(this, e, t);
+	}
+	async removeBranch(e) {
+		return J(this, e);
+	}
+	async switchBranch(e) {
+		if ((await this.getCurrentBranch())?.id === e) return;
+		let t = !1;
+		try {
+			this.rxdb.dispatchEvent(new p(e));
+			let { adapter: n } = await this.getLocalRepositories(), r = await ke(this, e), i = await n.switchBranch({
+				branchId: e,
+				actions: r
+			});
+			return t = !0, this.historyManager.clearRedoStack(), this.historyManager.setUndoBranch(e), this.rxdb.dispatchEvent(new m(e)), i;
+		} catch (n) {
+			throw t || this.rxdb.dispatchEvent(new h(e)), n;
+		}
+	}
+	async mergeBranch(e, t) {
+		let n = await this.getCurrentBranch();
+		if (!n) throw new u("No active branch found");
+		let o = n.id;
+		try {
+			this.rxdb.dispatchEvent(new r(e, o));
+			let n = await Fe(this, e, o, t);
+			return n.merged > 0 && this.historyManager.clearUndoHistory(), this.rxdb.dispatchEvent(new i(e, o)), n;
+		} catch (t) {
+			throw this.rxdb.dispatchEvent(new a(e, o)), t;
+		}
+	}
+	history(e) {
+		return this.historyManager.history(e);
+	}
+	async restoreEntity(e, t) {
+		return Le(this, e, t);
+	}
+	async getLocalRepositories() {
+		return re(this.rxdb);
+	}
+	async getRemoteRepositories() {
+		return ie(this.rxdb);
+	}
+	async getCurrentBranch() {
+		return ne(this.rxdb);
+	}
+	#a(e, t) {
+		e.catch((e) => {
+			me(e) || console.error(`[VersionManager] ${t} failed:`, e);
+		});
+	}
+}, He = class extends d {
+	lifecycle = "scoped";
+	name = "history";
+	install(e) {
+		let t = new Ve(this.rxdb);
+		e.acquire(() => (Object.defineProperty(this.rxdb, "versionManager", {
+			value: t,
+			configurable: !0,
+			enumerable: !0
+		}), () => void Reflect.deleteProperty(this.rxdb, "versionManager")), "history:slot"), e.acquire(() => () => t.destroy(), "history:versionManager"), t.init(), e.acquire(() => this.rxdb.syncState.bindPushableCount(t.pushableCount$), "history:pushableCount");
+	}
+}, Ue = (e) => new He(e), We = /* @__PURE__ */ de({
+	sqliteaiEncryptedFactory: () => Je,
+	sqliteaiFactory: () => Ke
+}), Ge = class extends t {
+	queryCount = 0;
+	query(...e) {
+		return this.queryCount++, super.query(...e);
+	}
+}, X = /* @__PURE__ */ new WeakMap(), Z = () => void 0, Q = /* @__PURE__ */ new WeakMap(), $ = (e) => {
+	let t = Q.get(e);
+	t && (Q.delete(e), t.terminate());
+}, Ke = {
+	name: "sqliteai",
+	async createAdapter(e) {
+		return await qe(e);
+	},
+	async createClient(t, n) {
+		return await e(t, {
+			printErr: Z,
+			...n
+		});
+	},
+	cleanupAdapter(e) {
+		$(e.rxdb);
+	}
+};
+async function qe(e) {
+	let { entities: t, persistent: n, ...r } = e ?? {}, i = (t ?? []).slice(), a = `sqliteai-test-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`, o = new s({
+		dbName: a,
+		context: { userId: "userId" },
+		entities: i,
+		sync: {
+			local: { adapter: "sqliteai" },
+			type: ee.None
+		}
+	});
+	try {
+		let e;
+		return o.adapter("sqliteai", async (t) => {
+			$(t);
+			let i = n === !0 ? new Worker(new URL(
+				/* @vite-ignore */
+				"/assets/sqliteai-test.worker-CTOPs2O0.js",
+				"" + import.meta.url
+			), {
+				type: "module",
+				name: `${a}-worker`
+			}) : void 0;
+			return i && Q.set(t, i), e = new Ge(t, {
+				...i ? {
+					opfs: !0,
+					opfsFallback: "throw",
+					worker: !0,
+					workerInstance: i
+				} : { printErr: Z },
+				...r
+			}), e;
+		}), o.use(Ue), await o.getAdapter("sqliteai"), await o.connect("sqliteai"), e;
+	} catch (e) {
+		throw $(o), e;
+	}
+}
+var Je = {
+	name: "sqliteai",
+	getQueryCount: (e) => X.get(e)?.() ?? 0,
+	createAdapter: async (e) => {
+		let t = await qe(e);
+		return X.set(t, () => t.queryCount), t;
+	}
+}, Ye = (/* @__PURE__ */ Object.assign({ "./__tests__/sqliteai-factory.ts": We }))["./__tests__/sqliteai-factory.ts"].sqliteaiFactory;
+//#endregion
+export { Ye as sqliteaiFactory };