@aiao/rxdb-plugin-history 0.0.0-stage → 0.0.28

package/dist/index.js

@@ -0,0 +1,1565 @@
+import { ENTITY_LOCAL_CREATE_EVENT as e, MAIN_BRANCH_ID as t, MergeBranchBeginEvent as n, MergeBranchCommitEvent as r, MergeBranchFailedEvent as i, REPOSITORY_SYNC_COMPLETE_EVENT as a, RxDBBranch as o, RxDBChange as s, RxDBError as c, RxDBPluginBase as l, RxDBSync as u, SKIP_BRANCH_SWITCH_PREPARE as d, SwitchBranchBeginEvent as f, SwitchBranchCommitEvent as p, SwitchBranchRollbackEvent as m, TRANSACTION_BEGIN as h, TRANSACTION_COMMIT as g, TRANSACTION_ROLLBACK as _, TrustedWriteIntent as v, assertUsableBranchId as ee, buildPushableRepositoryRules as te, declareTrustedWrite as y, getCurrentBranch as ne, getEntityMetadata as b, getLocalSystemRepositories as re, getRemoteSystemRepositories as ie, getRxDBChangeKey as x, getRxDBEntityIdentityKey as S, isAdapterShutdownError as C, resolve_current_branch as ae, takeDeclaredWrite as oe } from "@aiao/rxdb";
+import { BehaviorSubject as w, EMPTY as se, NEVER as ce, Observable as le, ReplaySubject as ue, Subject as de, catchError as fe, combineLatest as T, filter as E, firstValueFrom as D, map as O, shareReplay as k, switchMap as A, takeUntil as j } from "rxjs";
+import { isNil as M } from "@aiao/utils";
+//#region src/create-branch.ts
+var pe = async (e, t, n) => {
+	ee(t);
+	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 c(`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 c(`Branch id (${t}) already exists on remote`);
+	}
+	let a = await i.transaction(async (r) => {
+		let i = r.getRepository(o), a = r.getRepository(s);
+		if ((await i.find({
+			where: {
+				combinator: "and",
+				rules: [{
+					field: "id",
+					operator: "=",
+					value: t
+				}]
+			},
+			limit: 1
+		})).length) return `Branch id (${t}) already exists`;
+		let c, l;
+		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`;
+			l = e, c = (await i.find({
+				where: {
+					combinator: "and",
+					rules: [{
+						field: "id",
+						operator: "=",
+						value: e.branchId
+					}]
+				},
+				limit: 1
+			}))[0];
+		} else c = await ae(i, e.rxdb), l = await me(a, c.id);
+		if (!c) return "Source branch not found";
+		let u = e.rxdb.entityManager.instantiate(o);
+		u.id = t, u.activated = !1, u.activeKey = null, u.local = !0, u.remote = !1, u.fromChangeId = l?.id ?? null, u.parentId = c.id, await i.create(u);
+		for (let n of e.rxdb.systemContributions) await n.writeBranchRows(e.rxdb.entityManager, {
+			executor: r,
+			branchId: t
+		});
+		return u;
+	});
+	if (typeof a == "string") throw new c(a);
+	return a;
+}, me = 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], N = (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" || C(e);
+};
+//#endregion
+//#region src/history-item-builder.ts
+function P(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 F(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,
+		S(t.entityId),
+		i.getTime()
+	].join(":"), l = e.some((e) => M(e.revertChangeId) === !1), u = e.some((e) => M(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: P(e),
+		namespace: a,
+		entity: o,
+		reverted: l,
+		redoInvalidated: u
+	};
+}
+function I(e) {
+	let t = [], n = [], r;
+	return e.forEach((e) => {
+		e.transactionId && e.transactionId === r ? n.push(e) : (r = e.transactionId, n.length &&= (t.push(F([...n])), 0), e.transactionId ? n.push(e) : t.push(F([e])));
+	}), n.length && t.push(F([...n])), t;
+}
+//#endregion
+//#region src/history-filters.ts
+var L = (e) => `${e.namespace}:${e.entity}`;
+function R(e, t) {
+	let n = new Map(t);
+	for (let t of e) {
+		if (t.lastPushedChangeId === null) continue;
+		let e = L(t), r = n.get(e);
+		r !== void 0 && r >= t.lastPushedChangeId || n.set(e, t.lastPushedChangeId);
+	}
+	return n;
+}
+function z(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: P(n)
+		};
+	}).filter((e) => e !== null);
+}
+function B(e, t, n = 0, r = null) {
+	return e.filter((e) => !e.reverted && e.changes.every((e) => {
+		let i = e.remoteId == null, a = t.get(L(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}:${S(e.entityId)}`;
+}
+//#endregion
+//#region src/history-scope-api.ts
+function ge(e) {
+	if (!e) return { type: "database" };
+	if (Object.getPrototypeOf(e) === Object.prototype && "type" in e) return e;
+	let t = b(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 le((t) => {
+		o();
+		let n = e.subscribe(t);
+		return () => {
+			n.unsubscribe(), a();
+		};
+	}), c = e.histories$.pipe(O((e) => z(e, n)), k({
+		bufferSize: 1,
+		refCount: !0
+	})), l = s(c), u = s(e.undoHistories$.pipe(O((e) => z(e, n)), k({
+		bufferSize: 1,
+		refCount: !0
+	}))), d = s(e.redoHistories$.pipe(O((e) => z(e, n)), k({
+		bufferSize: 1,
+		refCount: !0
+	}))), f = s(c.pipe(O((e) => e.length), k({
+		bufferSize: 1,
+		refCount: !0
+	}))), p = s(u.pipe(O((e) => e.length), k({
+		bufferSize: 1,
+		refCount: !0
+	}))), m = s(d.pipe(O((e) => e.length), k({
+		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 = B(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 D(e.redoHistories$), i = e.selectWholeTransactions(r, n, t);
+			i.length !== 0 && await e.applyUndoRedoHistories("redo", i);
+		})
+	};
+	return h;
+}
+//#endregion
+//#region src/history-undo-session.types.ts
+var V = {
+	changeId: 0,
+	createdAfter: null
+};
+//#endregion
+//#region src/pullable-count.ts
+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);
+}
+//#endregion
+//#region src/redo-stack.ts
+var be = 1e3, xe = class {
+	#e = new w([]);
+	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([]);
+	}
+};
+//#endregion
+//#region src/scope-selection.ts
+function H(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) => H(e, t));
+}
+function Ce(e, t) {
+	return e.changes.every((e) => H(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) H(e, t) || n.add(t.type === "entity" ? `${e.namespace}:${e.entity}#${String(e.entityId)}` : `${e.namespace}:${e.entity}`);
+	return [...n].join(", ");
+}, U = class e extends c {
+	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);
+	}
+}, W = (e) => e.fromChangeId ?? 0, G = (e, t) => {
+	let n = [e], r = /* @__PURE__ */ new Set([e.id]), i = e;
+	for (; i.parentId;) {
+		if (r.has(i.parentId)) throw new c(`Branch history is corrupt: cycle detected at branch '${i.id}' (parentId '${i.parentId}' already visited)`);
+		let e = t.get(i.parentId);
+		if (!e) throw new c(`Branch history is corrupt: branch '${i.id}' references missing parent '${i.parentId}'`);
+		r.add(e.id), n.push(e), i = e;
+	}
+	return n;
+}, K = (e) => {
+	let { branches: t, currentBranch: n, nextBranch: r } = e, i = e.currentChangeId ?? W(n), a = e.nextChangeId ?? W(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 = G(n, o), c = G(r, o), l = null, u = -1;
+	for (let e = 0; e < s.length; e++) if (c.findIndex((t) => t.id === s[e].id) !== -1) {
+		l = s[e], u = e;
+		break;
+	}
+	let d = [];
+	if (l) {
+		for (let e = 0; e < u; e++) {
+			let t = s[e], n = e === 0 ? i : W(s[e - 1]), r = W(t);
+			n !== r && d.push({
+				branch: t,
+				fromChangeId: n,
+				toChangeId: r
+			});
+		}
+		let e = c.findIndex((e) => e.id === l.id);
+		if (e === 0) {
+			let e = u === 0 ? i : W(s[u - 1]), t = a;
+			e !== t && d.push({
+				branch: l,
+				fromChangeId: e,
+				toChangeId: t
+			});
+		} else if (e > 0) {
+			let t = u === 0 ? i : W(s[u - 1]), n = W(c[e - 1]);
+			t !== n && d.push({
+				branch: l,
+				fromChangeId: t,
+				toChangeId: n
+			});
+		}
+		let t = c.slice(0, e).reverse();
+		for (let e = 0; e < t.length; e++) {
+			let n = t[e], r = W(n), i = e === t.length - 1 ? a : W(t[e + 1]);
+			r !== i && d.push({
+				branch: n,
+				fromChangeId: r,
+				toChangeId: i
+			});
+		}
+	} else {
+		for (let e = 0; e < s.length; e++) {
+			let t = s[e], n = e === 0 ? i : W(s[e - 1]), r = W(t);
+			n !== r && d.push({
+				branch: t,
+				fromChangeId: n,
+				toChangeId: r
+			});
+		}
+		let e = s[s.length - 1], t = W(e);
+		t !== 0 && d.push({
+			branch: e,
+			fromChangeId: t,
+			toChangeId: 0
+		});
+		let n = c[c.length - 1], r = c.length > 1 ? W(c[c.length - 2]) : a;
+		r !== 0 && d.push({
+			branch: n,
+			fromChangeId: 0,
+			toChangeId: r
+		});
+		let o = c.slice(0, c.length - 1).reverse();
+		for (let e = 0; e < o.length; e++) {
+			let t = o[e], n = W(t), r = e === o.length - 1 ? a : W(o[e + 1]);
+			n !== r && d.push({
+				branch: t,
+				fromChangeId: n,
+				toChangeId: r
+			});
+		}
+	}
+	return d;
+}, De = async (e, t) => q(await e.getLocalRepositories(), t), q = async (e, t) => {
+	let { branchRepository: n, changeRepository: r } = e, i = (await n.find({
+		where: {
+			combinator: "and",
+			rules: [{
+				field: "activated",
+				operator: "=",
+				value: !0
+			}]
+		},
+		limit: 1
+	}))[0];
+	if (!i) throw new c("Current branch not found");
+	let a = await n.find({ where: {
+		combinator: "and",
+		rules: []
+	} }), o = a.find((e) => e.id === t);
+	if (!o) throw new c(`Branch (${t}) not found`);
+	if (i.id === o.id) throw new c("Cannot switch to the same branch");
+	let s = await Y(r, i.id), l = await Y(r, o.id), u = K({
+		branches: a,
+		currentBranch: i,
+		currentChangeId: s ? s.id : null,
+		nextBranch: o,
+		nextChangeId: l ? l.id : null
+	}), d = {
+		deletes: /* @__PURE__ */ new Map(),
+		updates: /* @__PURE__ */ new Map(),
+		inserts: /* @__PURE__ */ new Map()
+	};
+	for (let e = 0; e < u.length; e++) {
+		let { branch: t, fromChangeId: n, toChangeId: i } = u[e], a = n < i, o = n > i, s = Math.min(n, i), c = Math.max(n, i), l = { 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 && l.where.rules.push({
+			field: "id",
+			operator: ">",
+			value: t.fromChangeId
+		});
+		let f = await r.find(l);
+		o ? ke(f, d) : a && Oe(f, d);
+	}
+	return d;
+}, Oe = (e, t) => J(e, !0, t), ke = (e, t) => J(e, !1, t), J = (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 = x(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 = x(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;
+}, Y = 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], X = (e) => e.getRepository(u);
+async function Ae(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 = R(await X(await D(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: I(await n.find({
+			where: {
+				combinator: "and",
+				rules: s
+			},
+			orderBy: [{
+				field: "id",
+				sort: "desc"
+			}]
+		})),
+		lastPushedMap: o
+	};
+}
+async function je(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 = J(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;
+		y(s, {
+			file: "undo-redo-apply.ts",
+			symbol: "applyUndoRedoHistories",
+			intent: v.undo_redo
+		}), await s.switchBranch({
+			actions: a,
+			prepare: d
+		}), 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 Me(e) {
+	let t = ++e.pushableGeneration, n = (n) => {
+		t === e.pushableGeneration && e.pushableCount$.next(n);
+	};
+	try {
+		if (!await D(e.rxdb.connected$)) {
+			n(0);
+			return;
+		}
+		let t = X(await D(e.rxdb.localAdapter$)), r = e.rxdb.entityManager.getRepository(s), i = await D(e.rxdb.entityManager.getRepository(o).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
+			}]
+		} }), c = te(e.rxdb.config.entities, e.rxdb.entitySync, a);
+		if (c.length === 0) {
+			n(0);
+			return;
+		}
+		n(await D(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: c
+				}
+			]
+		} })));
+	} catch (t) {
+		!e.destroyed && !C(t) && (console.error("[#updatePushableCount] error", t), e.errors$.next(t instanceof Error ? t : Error(String(t)))), n(0);
+	}
+}
+//#endregion
+//#region src/HistoryManager.ts
+var Z = (e) => e.reduce((e, t) => t < e ? t : e, Infinity), Ne = class {
+	rxdb;
+	#e = [];
+	#t = !1;
+	#n;
+	#r;
+	#i = new ue(1);
+	#a = Promise.resolve();
+	#o = new w(0);
+	#s = 0;
+	#c = new w(0);
+	#l = 0;
+	#u = new w(0);
+	#d = /* @__PURE__ */ new Map();
+	#f = new w(0);
+	#p = 0;
+	#m;
+	#h = null;
+	#g = /* @__PURE__ */ new Date();
+	#_ = /* @__PURE__ */ new Map();
+	#v = null;
+	#y = 0;
+	#b = null;
+	#x = new w({
+		generation: 0,
+		state: "active",
+		boundary: V
+	});
+	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 de();
+	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(o), n = e.entityManager.getRepository(s), r = this.rxdb.connected$.pipe(A((e) => e ? t.findOne({ where: {
+			combinator: "and",
+			rules: [{
+				field: "activated",
+				operator: "=",
+				value: !0
+			}]
+		} }) : ce));
+		this.#e.push(r.pipe(j(this.#i)).subscribe({
+			next: (e) => this.#E(e?.id ?? null),
+			error: (e) => this.#T("undo session 分支跟随的活跃分支流已中断", e)
+		})), this.#m = T({
+			connected: this.rxdb.connected$,
+			branch: r
+		}).pipe(E(({ connected: e, branch: t }) => e && !!t), A(({ 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"
+				}]
+			});
+		}), j(this.#i));
+		let i = this.#m.pipe(O((e) => I(e)), k({
+			bufferSize: 1,
+			refCount: !0
+		}));
+		this.histories$ = T([i, this.#f]).pipe(O(([e]) => this.#O(e)), k({
+			bufferSize: 1,
+			refCount: !0
+		})), this.count$ = this.histories$.pipe(O((e) => e.length), k({
+			bufferSize: 1,
+			refCount: !0
+		})), this.undoHistories$ = T({
+			histories: this.histories$,
+			undoSession: this.#x,
+			trigger: this.#u
+		}).pipe(A(async ({ histories: e, undoSession: t }) => {
+			if (t.state === "cleared") return [];
+			try {
+				let n = await D(this.rxdb.entityManager.getRepository(o).findOne({ where: {
+					combinator: "and",
+					rules: [{
+						field: "activated",
+						operator: "=",
+						value: !0
+					}]
+				} }));
+				return n ? B(e, R(await X(await D(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), [];
+			}
+		}), k({
+			bufferSize: 1,
+			refCount: !0
+		})), this.redoHistories$ = this.redoStack.items$, this.undoCount$ = this.undoHistories$.pipe(O((e) => e.length), k({
+			bufferSize: 1,
+			refCount: !0
+		})), this.redoCount$ = this.redoHistories$.pipe(O((e) => e.length), k({
+			bufferSize: 1,
+			refCount: !0
+		})), this.pushableCount$ = this.#c.asObservable(), this.pullableCount$ = this.#o.asObservable();
+		let c = T({
+			connected: this.rxdb.connected$,
+			branch: r
+		}).pipe(E(({ connected: e, branch: t }) => e && !!t), A(({ branch: e }) => {
+			let t = [
+				{
+					field: "branchId",
+					operator: "=",
+					value: e.id
+				},
+				{
+					field: "revertChangeId",
+					operator: "=",
+					value: null
+				},
+				{
+					field: "remoteId",
+					operator: "=",
+					value: null
+				},
+				{
+					field: "rejectedAt",
+					operator: "=",
+					value: null
+				}
+			];
+			return n.count({ where: {
+				combinator: "and",
+				rules: t
+			} }).pipe(fe((e) => (this.#T("pushableCount 的变更计数查询", e), se)));
+		})).subscribe({
+			next: () => {
+				this.#L();
+			},
+			error: (e) => this.#T("pushableCount 重算的活跃分支流已中断", e)
+		});
+		this.#e.push(c), this.rxdb.addEventListener(a, 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(a, 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: V
+		});
+		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 = Z(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 ? Z(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 (!(e?.length && e.every((e) => e <= this.#p))) {
+				this.isInvalidatingRedo = !0;
+				try {
+					let e = await D(this.redoHistories$);
+					if (e.length === 0) return;
+					let t = e.flatMap((e) => e.changes), n = /* @__PURE__ */ new Date(), r = J([], !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 }
+						});
+					}), y(i, {
+						file: "HistoryManager.ts",
+						symbol: "invalidateRedoStack",
+						intent: v.redo_invalidation
+					}), await i.switchBranch({
+						actions: r,
+						prepare: d
+					}), 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 U(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 || C(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: V
+		} : {
+			...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 Ae(this.#r, e);
+	}
+	#F = () => {
+		this.#L(), this.#u.next(Date.now());
+	};
+	async #I(e, t, n) {
+		return je(this.#r, e, t, n);
+	}
+	async #L() {
+		return Me(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)
+		};
+	}
+}, Pe = async (e, n) => {
+	let { adapter: r } = await e.getLocalRepositories();
+	if (n === t) throw new c("Cannot remove main branch");
+	let i = await r.transaction(async (t) => {
+		let r = t.getRepository(o), i = t.getRepository(s), a = (await r.find({
+			where: {
+				combinator: "and",
+				rules: [{
+					field: "id",
+					operator: "=",
+					value: n
+				}]
+			},
+			limit: 1
+		}))[0];
+		if (!a) return `Branch '${n}' not found`;
+		if (a.activated) return `Cannot remove active branch '${n}'. Switch to another branch first.`;
+		if ((await r.find({
+			where: {
+				combinator: "and",
+				rules: [{
+					field: "parentId",
+					operator: "=",
+					value: n
+				}, {
+					field: "id",
+					operator: "!=",
+					value: n
+				}]
+			},
+			limit: 1
+		}))?.length) return `Cannot remove branch '${n}' because it has child branches`;
+		let c = await i.find({ where: {
+			combinator: "and",
+			rules: [{
+				field: "branchId",
+				operator: "=",
+				value: n
+			}]
+		} });
+		for (let r of e.rxdb.systemContributions) await r.removeBranchRows({
+			executor: t,
+			branchId: n
+		});
+		await t.removeMany([...c, a]);
+	});
+	if (i) throw new c(i);
+}, Fe = async (e, t, n, r) => {
+	let i = r?.strategy ?? "squash", a = r?.deleteSource ?? !1, { branchRepository: o, changeRepository: s, adapter: l } = await e.getLocalRepositories();
+	if (t === n) throw new c(`Cannot merge branch '${t}' into itself`);
+	let u = (await o.find({
+		where: {
+			combinator: "and",
+			rules: [{
+				field: "id",
+				operator: "=",
+				value: t
+			}]
+		},
+		limit: 1
+	}))[0];
+	if (!u) throw new c(`Branch '${t}' not found`);
+	let d = await s.find({
+		where: {
+			combinator: "and",
+			rules: [
+				{
+					field: "branchId",
+					operator: "=",
+					value: t
+				},
+				{
+					field: "revertChangeId",
+					operator: "=",
+					value: null
+				},
+				...u.fromChangeId == null ? [] : [{
+					field: "id",
+					operator: ">",
+					value: u.fromChangeId
+				}]
+			]
+		},
+		orderBy: [{
+			field: "id",
+			sort: "asc"
+		}]
+	}), f = async () => {
+		if (!a) return { deleted: !1 };
+		try {
+			return await Pe(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 l.transaction(async (e) => {
+		for (let t of d) {
+			let n = {
+				deletes: /* @__PURE__ */ new Map(),
+				updates: /* @__PURE__ */ new Map(),
+				inserts: /* @__PURE__ */ new Map()
+			}, r = x(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
+			}), y(e, {
+				file: "merge-branch.ts",
+				symbol: "merge_branch",
+				intent: v.merge_per_change
+			}), await e.mergeChanges(n, void 0, !1);
+		}
+	}), m = d.length;
+	else {
+		let e = J(d, !0), t = new Set(d.filter((e) => e.type === "INSERT").map((e) => x(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 l.transaction(async (t) => {
+			y(t, {
+				file: "merge-branch.ts",
+				symbol: "merge_branch",
+				intent: v.merge_squash
+			}), await t.mergeChanges(e, void 0, !1);
+		}, !1);
+	}
+	return p(m, await f());
+}, Q = 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;
+	}
+};
+//#endregion
+//#region src/restore-entity.ts
+async function Ie(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 c(`RxDBChange not found: ${n.changeId}`);
+	let o = a[0];
+	if (o.type !== "DELETE") throw new c(`Cannot restore from non-DELETE change (type=${o.type})`);
+	if (!o.inversePatch) throw new c(`RxDBChange ${n.changeId} has no inversePatch`);
+	let s = t.constructor, l = b(s), u = await e.getCurrentBranch();
+	if (o.namespace !== l.namespace || o.entity !== l.name) throw new c(`RxDBChange ${n.changeId} belongs to ${o.namespace}:${o.entity}, not ${l.namespace}:${l.name}`);
+	if (o.branchId != null && o.branchId !== u.id) throw new c(`RxDBChange ${n.changeId} belongs to branch '${o.branchId}', current branch is '${u.id}'`);
+	let d = J([o], !1);
+	await i.transaction(async (e) => {
+		y(e, {
+			file: "restore-entity.ts",
+			symbol: "restore_entity",
+			intent: v.restore_entity
+		}), await e.mergeChanges(d, void 0, !1);
+	}, !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 c(`Restore produced no row for ${l.namespace}:${l.name} id=${String(o.entityId)}`);
+	return f[0];
+}
+//#endregion
+//#region src/sync-history-bridge.ts
+var Le = (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)
+}), Re = (e) => typeof e == "number" && Number.isSafeInteger(e) && e > 0 ? e : null, ze = (e) => {
+	let t = Re(e.id);
+	return t === null ? typeof e.patch != "object" || e.patch === null || !("id" in e.patch) ? null : Re(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 Q();
+	syncBridge = Le(() => this.historyManager, this.pushInFlight);
+	get pushableCount$() {
+		return this.historyManager.pushableCount$;
+	}
+	get pullableCount$() {
+		return this.historyManager.pullableCount$;
+	}
+	constructor(e) {
+		this.rxdb = e, this.historyManager = new Ne(this.rxdb);
+	}
+	init() {
+		this.#i &&= (this.historyManager = new Ne(this.rxdb), !1);
+		let t = () => {
+			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(g, e), this.rxdb.addEventListener(_, t), this.#e.push(() => this.rxdb.removeEventListener(g, e), () => this.rxdb.removeEventListener(_, t));
+			}
+			this.#t === 0 && (this.#n = this.historyManager.undoSessionGeneration), this.#t += 1;
+		};
+		this.rxdb.addEventListener(h, t), this.#e.push(() => this.rxdb.removeEventListener(h, t));
+		let n = (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.#l(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(e, n), this.#e.push(() => this.rxdb.removeEventListener(e, n));
+	}
+	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 pe(this, e, t);
+	}
+	async removeBranch(e) {
+		return Pe(this, e);
+	}
+	async switchBranch(e, t) {
+		let n = await this.getCurrentBranch();
+		if (n?.id === e) return;
+		let r = !1, i, a = !1;
+		try {
+			if (this.rxdb.dispatchEvent(new f(e)), await this.#o(n?.id ?? null, e, t)) {
+				r = !0, this.#a(e);
+				return;
+			}
+			let { adapter: o } = await this.getLocalRepositories(), s = await De(this, e);
+			y(o, {
+				file: "VersionManager.ts",
+				symbol: "switchBranch",
+				intent: v.branch_materialization
+			}), i = o;
+			let l = await o.switchBranch({
+				branchId: e,
+				actions: s,
+				prepare: async ({ executor: e, targetBranchId: r }) => {
+					a = !0, await this.#c(e, n?.id ?? null, r, t);
+				}
+			});
+			if (r = !0, this.#a(e), !a) throw new c(`适配器 ${o.constructor.name} 的 switchBranch 没有调用 options.prepare：分支已经切到 ${e}，但这次切换一条前置条件都没校验过。适配器必须在解析出目标分支之后、动第一行之前 await 它（见 rxdb-adapter.ts › SwitchBranchOptions.prepare）。`);
+			return l;
+		} catch (t) {
+			throw i && oe(i), r || (this.rxdb.dispatchEvent(new m(e)), await this.#s(n?.id ?? null, e, t)), t;
+		}
+	}
+	async mergeBranch(e, t) {
+		let a = await this.getCurrentBranch();
+		if (!a) throw new c("No active branch found");
+		let o = a.id;
+		try {
+			this.rxdb.dispatchEvent(new n(e, o));
+			let i = await Fe(this, e, o, t);
+			return i.merged > 0 && this.historyManager.clearUndoHistory(), this.rxdb.dispatchEvent(new r(e, o)), i;
+		} catch (t) {
+			throw this.rxdb.dispatchEvent(new i(e, o)), t;
+		}
+	}
+	history(e) {
+		return this.historyManager.history(e);
+	}
+	async restoreEntity(e, t) {
+		return Ie(this, e, t);
+	}
+	async getLocalRepositories() {
+		return re(this.rxdb);
+	}
+	async getRemoteRepositories() {
+		return ie(this.rxdb);
+	}
+	async getCurrentBranch() {
+		return ne(this.rxdb);
+	}
+	#a(e) {
+		this.historyManager.clearRedoStack(), this.historyManager.setUndoBranch(e), this.rxdb.dispatchEvent(new p(e));
+	}
+	async #o(e, t, n) {
+		for (let r of this.rxdb.systemContributions) if (await r.takeOverBranchSwitch({
+			currentBranchId: e,
+			targetBranchId: t,
+			preconditions: n
+		}) === "switched") return !0;
+		return !1;
+	}
+	async #s(e, t, n) {
+		for (let r of this.rxdb.systemContributions) await r.settleBranchSwitchFailure({
+			currentBranchId: e,
+			targetBranchId: t,
+			error: n
+		});
+	}
+	async #c(e, t, n, r) {
+		for (let i of this.rxdb.systemContributions) await i.prepareBranchSwitch({
+			executor: e,
+			currentBranchId: t,
+			targetBranchId: n,
+			preconditions: r
+		});
+	}
+	#l(e, t) {
+		e.catch((e) => {
+			N(e) || console.error(`[VersionManager] ${t} failed:`, e);
+		});
+	}
+}, $ = class extends l {
+	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");
+	}
+}, He = (e) => new $(e);
+//#endregion
+export { Q as PushInFlightRegistry, U as RxDBCrossScopeTransactionError, $ as RxDBPluginHistory, q as compute_switch_branch_actions, G as find_branch_path_to_root, K as find_switch_branch_step, Y as get_branch_max_change, N as isIgnorableDetachedVersionEventError, He as rxDBPluginHistory };