@aiao/rxdb-plugin-sync 0.0.0-stage → 0.0.26

package/dist/index.js

@@ -0,0 +1,3273 @@
+import { ConflictDetectedEvent as e, ConflictPendingEvent as t, ENTITY_REMOTE_CREATE_EVENT as n, ENTITY_REMOTE_REMOVE_EVENT as r, ENTITY_REMOTE_UPDATE_EVENT as i, LWWConflictResolver as a, RelationKind as o, RepositorySyncBeginEvent as s, RepositorySyncCompleteEvent as c, RepositorySyncErrorEvent as l, RxDBBranch as u, RxDBChange as d, RxDBDependencyFailedError as f, RxDBError as p, RxDBPartialSyncError as m, RxDBPluginBase as h, RxDBSync as g, SYNC_DISABLED_REASON as _, SyncBeginEvent as v, SyncCompleteEvent as y, SyncErrorEvent as b, buildOfflineWriteRepositoryRules as x, compactChanges as S, findCurrentSyncRecord as C, getCurrentBranch as w, getEntityMetadata as T, getLocalSystemRepositories as E, getOrCreateSyncRecord as D, getRemoteSystemRepositories as O, getRxDBChangeEntityIdQueryValues as k, getRxDBChangeKey as A, getRxDBEntityIdentityKey as j, getSyncCapability as M, getSyncType as N, isRepositorySyncEnabled as P, isSystemEntity as ee, needsPull as te, needsPush as ne, repositoryKey as F, resolvePullIneligibility as re, resolvePushIneligibility as ie } from "@aiao/rxdb";
+import { combineLatest as ae, firstValueFrom as I, merge as oe } from "rxjs";
+import { isIgnorableDetachedVersionEventError as se } from "@aiao/rxdb-plugin-history";
+//#region src/query-cache-outbox.ts
+var ce = {
+	INSERT: {
+		kind: "replay",
+		verb: "create"
+	},
+	UPDATE: {
+		kind: "discard",
+		repair: "drop"
+	},
+	DELETE: { kind: "noop" }
+}, le = {
+	INSERT: "update",
+	UPDATE: "update",
+	DELETE: "delete"
+}, ue = [/* @__PURE__ */ new Set(["DELETE"]), /* @__PURE__ */ new Set(["INSERT", "UPDATE"])], de = /* @__PURE__ */ new WeakMap();
+function fe(e, t, n, r) {
+	let i = de.get(e) ?? /* @__PURE__ */ new Map();
+	de.set(e, i);
+	let o = `${t}:${n}`, s = i.get(o);
+	if (s) return s;
+	let c = me(e, t, n, r?.conflictResolver ?? new a()).finally(() => {
+		i.delete(o);
+	});
+	return i.set(o, c), c;
+}
+var pe = (e, t) => ({
+	repository: {
+		namespace: e,
+		entity: t
+	},
+	originalCount: 0,
+	compacted: 0,
+	replayed: 0,
+	discarded: 0,
+	noop: 0,
+	watermark: null,
+	conflicts: [],
+	failures: []
+});
+async function me(e, t, n, r) {
+	let i = ve(e, t, n), a = await w(e), { adapter: o } = await E(e), s = o, c = s.getRepository(g), l = await D(c, {
+		namespace: t,
+		entity: n,
+		branchId: a.id,
+		syncType: i
+	}, () => e.entityManager.instantiate(g));
+	if (!P(l)) return {
+		...pe(t, n),
+		skipped: _
+	};
+	let u = await ye(s.getRepository(d), t, n, a.id, l.lastPushedChangeId);
+	if (u.length === 0) return pe(t, n);
+	let f = u.reduce((e, t) => t.id > e ? t.id : e, u[0].id), p = be(u), m = {
+		...pe(t, n),
+		originalCount: u.length
+	};
+	if (p.length === 0) return await c.update(l, {
+		lastPushedChangeId: f,
+		updatedAt: /* @__PURE__ */ new Date()
+	}), {
+		...m,
+		compacted: u.length,
+		watermark: f
+	};
+	let h = await I(e.remoteAdapter$), v = {
+		...m,
+		compacted: u.length - p.length,
+		restoreIds: [],
+		dropIds: [],
+		settled: /* @__PURE__ */ new Set()
+	}, y = await Ce(h, n, p, e, v);
+	if (y && await we(p, y, {
+		rxdb: e,
+		entity: n,
+		remoteAdapter: h,
+		conflictResolver: r,
+		run: v
+	}), await je(s, h, n, v), v.failures.length > 0) {
+		let e = Te(p, v.settled, f);
+		return e <= (l.lastPushedChangeId ?? 0) ? he(v) : (await c.update(l, {
+			lastPushedChangeId: e,
+			updatedAt: /* @__PURE__ */ new Date()
+		}), {
+			...he(v),
+			watermark: e
+		});
+	}
+	return await c.update(l, {
+		lastPushedChangeId: f,
+		lastPushedAt: /* @__PURE__ */ new Date(),
+		updatedAt: /* @__PURE__ */ new Date()
+	}), {
+		...he(v),
+		watermark: f
+	};
+}
+var he = (e) => ({
+	repository: e.repository,
+	originalCount: e.originalCount,
+	compacted: e.compacted,
+	replayed: e.replayed,
+	discarded: e.discarded,
+	noop: e.noop,
+	watermark: e.watermark,
+	conflicts: e.restoreIds,
+	failures: e.failures
+});
+async function ge(e) {
+	let t = await w(e), { adapter: n } = await E(e), r = await n.getRepository(g).find({ where: {
+		combinator: "and",
+		rules: [{
+			field: "branchId",
+			operator: "=",
+			value: t.id
+		}]
+	} }), i = x(e.config.entities, e.config.sync, r);
+	return i.length === 0 ? 0 : I(e.entityManager.getRepository(d).count({ where: {
+		combinator: "and",
+		rules: [
+			{
+				field: "branchId",
+				operator: "=",
+				value: t.id
+			},
+			{
+				field: "revertChangeId",
+				operator: "=",
+				value: null
+			},
+			{
+				field: "remoteId",
+				operator: "=",
+				value: null
+			},
+			{
+				combinator: "or",
+				rules: i
+			}
+		]
+	} }));
+}
+async function _e(e, t, n) {
+	let r = await w(e), { adapter: i } = await E(e), a = i, o = await C(e, t, n), s = await ye(a.getRepository(d), t, n, r.id, o?.lastPushedChangeId ?? null);
+	return new Set(s.map((e) => String(e.entityId)));
+}
+function ve(e, t, n) {
+	let r = e.config.entities.find((e) => {
+		let r = T(e);
+		return r.namespace === t && r.name === n;
+	});
+	if (!r) throw new p(`Entity not found for QueryCache outbox flush: ${t}/${n}`);
+	let i = N(T(r), e.config.sync);
+	if (i !== "querycache") throw new p(`flushQueryCacheOutbox only handles syncType 'querycache'; ${t}/${n} is '${i}'. Repositories with a changelog endpoint push through syncManager.push().`);
+	return i;
+}
+async function ye(e, t, n, r, i) {
+	let a = [
+		{
+			field: "namespace",
+			operator: "=",
+			value: t
+		},
+		{
+			field: "entity",
+			operator: "=",
+			value: n
+		},
+		{
+			field: "branchId",
+			operator: "=",
+			value: r
+		},
+		{
+			field: "remoteId",
+			operator: "=",
+			value: null
+		},
+		{
+			field: "revertChangeId",
+			operator: "=",
+			value: null
+		}
+	];
+	return i !== null && a.push({
+		field: "id",
+		operator: ">",
+		value: i
+	}), e.find({
+		where: {
+			combinator: "and",
+			rules: a
+		},
+		orderBy: [{
+			field: "id",
+			sort: "asc"
+		}]
+	});
+}
+function be(e) {
+	let t = /* @__PURE__ */ new Map();
+	for (let n of e) {
+		let e = A(n), r = t.get(e) ?? [];
+		r.push(n), t.set(e, r);
+	}
+	let n = S(e), r = [], i = (e, n) => {
+		for (let [i, a] of e) {
+			let e = t.get(i);
+			if (!e?.length) throw new p(`Missing source changes for compacted QueryCache action: ${i}`);
+			let o = e[e.length - 1], s = e.reduce((e, t) => t.id < e ? t.id : e, e[0].id);
+			r.push({
+				key: i,
+				entityId: String(o.entityId),
+				kind: n,
+				action: a,
+				lastChange: o,
+				minChangeId: s
+			});
+		}
+	};
+	return i(n.deletes, "DELETE"), i(n.updates, "UPDATE"), i(n.inserts, "INSERT"), r;
+}
+var xe = 100;
+function Se(e, t) {
+	let n = [];
+	for (let r = 0; r < e.length; r += t) n.push(e.slice(r, r + t));
+	return n;
+}
+async function Ce(e, t, n, r, i) {
+	let a = n.map((e) => e.entityId), o = /* @__PURE__ */ new Map();
+	for (let n of Se(a, xe)) try {
+		let r = await I(e.fetchMetadata(t, {
+			combinator: "and",
+			rules: [{
+				field: "id",
+				operator: "in",
+				value: n
+			}]
+		}));
+		for (let e of r) o.set(e.id, e.updatedAt);
+	} catch (e) {
+		return r.reachability.report(e), i.failures.push({
+			entityId: null,
+			error: e instanceof Error ? e : Error(String(e))
+		}), null;
+	}
+	return r.reachability.report(null), o;
+}
+async function we(e, t, n) {
+	for (let r of ue) for (let i of e.filter((e) => r.has(e.kind))) {
+		if (n.run.failures.length > 0) return;
+		let e = n.run.failures.length;
+		await Ee(i, t.get(i.entityId), n), n.run.failures.length === e && n.run.settled.add(i);
+	}
+}
+function Te(e, t, n) {
+	let r;
+	for (let n of e) t.has(n) || (r === void 0 || n.minChangeId < r) && (r = n.minChangeId);
+	return r === void 0 ? n : r - 1;
+}
+async function Ee(e, t, n) {
+	let r = await De(e, t, n.conflictResolver), { run: i } = n;
+	if (r.kind === "noop") {
+		i.noop += 1;
+		return;
+	}
+	if (r.kind === "discard") {
+		i.discarded += 1, (r.repair === "restore" ? i.restoreIds : i.dropIds).push(e.entityId);
+		return;
+	}
+	if (r.kind === "unresolved") {
+		i.failures.push({
+			entityId: e.entityId,
+			error: new p(`Unsupported conflict resolution '${r.resolution}' during QueryCache outbox replay for ${e.key}. Only KEEP_LOCAL and KEEP_REMOTE can be applied over REST verbs.`)
+		});
+		return;
+	}
+	await ke(e, r.verb, n);
+}
+async function De(e, t, n) {
+	if (t === void 0) return ce[e.kind];
+	let r = await n.resolve({
+		entityKey: e.key,
+		local: e.lastChange,
+		remote: Oe(e, t)
+	});
+	return r.type === "KEEP_LOCAL" ? {
+		kind: "replay",
+		verb: le[e.kind]
+	} : r.type === "KEEP_REMOTE" ? {
+		kind: "discard",
+		repair: "restore"
+	} : {
+		kind: "unresolved",
+		resolution: r.type
+	};
+}
+function Oe(e, t) {
+	let n = new Date(t);
+	return {
+		id: 0,
+		namespace: e.lastChange.namespace,
+		entity: e.lastChange.entity,
+		entityId: e.lastChange.entityId,
+		branchId: e.lastChange.branchId,
+		type: e.kind,
+		patch: null,
+		inversePatch: null,
+		createdAt: n,
+		updatedAt: n
+	};
+}
+async function ke(e, t, n) {
+	let { entity: r, remoteAdapter: i, run: a, rxdb: o } = n, s = Ae(i, r, e, t);
+	if (!s) {
+		a.failures.push({
+			entityId: e.entityId,
+			error: new p(`Remote adapter does not support ${t} operation for ${r}`)
+		});
+		return;
+	}
+	try {
+		await I(s), o.reachability.report(null), a.replayed += 1;
+	} catch (t) {
+		o.reachability.report(t), a.failures.push({
+			entityId: e.entityId,
+			error: t instanceof Error ? t : Error(String(t))
+		});
+	}
+}
+function Ae(e, t, n, r) {
+	if (r === "delete") return e.delete ? e.delete(t, [n.entityId]) : null;
+	let i = n.action.patch ?? {};
+	if (r === "create") {
+		let r = {
+			id: n.entityId,
+			...i
+		};
+		return e.create ? e.create(t, r) : null;
+	}
+	return e.update ? e.update(t, n.entityId, i) : null;
+}
+async function je(e, t, n, r) {
+	if (r.restoreIds.length > 0) {
+		let i = await I(t.findByIds(n, r.restoreIds));
+		await I(e.upsertMany(n, i));
+	}
+	r.dropIds.length > 0 && await I(e.deleteByIds(n, r.dropIds));
+}
+//#endregion
+//#region src/branch-utils.ts
+async function L(e, t) {
+	let n = [t];
+	if (t === "main") return n;
+	let { adapter: r } = await e.getLocalRepositories(), i = r.getRepository(u), a = t, o = /* @__PURE__ */ new Set([a]);
+	for (; a;) {
+		let e = (await i.find({
+			where: {
+				combinator: "and",
+				rules: [{
+					field: "id",
+					operator: "=",
+					value: a
+				}]
+			},
+			limit: 1
+		}))[0];
+		if (!e?.parentId || o.has(e.parentId)) break;
+		n.push(e.parentId), o.add(e.parentId), a = e.parentId;
+	}
+	return n;
+}
+//#endregion
+//#region src/cascade-blocking.ts
+function Me(e, t, n, r) {
+	let i = e.get(t);
+	if (i) for (let e of i[r]) {
+		let t = n.get(F(e));
+		if (t) return {
+			dependency: e,
+			cause: t
+		};
+	}
+}
+//#endregion
+//#region src/dependency-graph.ts
+function R(e) {
+	let t = /* @__PURE__ */ new Map();
+	for (let n of e) {
+		let e = `${n.namespace}:${n.name}`, r = {
+			repository: {
+				namespace: n.namespace,
+				entity: n.name
+			},
+			dependsOn: [],
+			requiredBy: []
+		};
+		if (n.relations) {
+			for (let e of n.relations) if (e.kind === o.MANY_TO_ONE || e.kind === o.ONE_TO_ONE) {
+				let t = e.mappedEntity, i = e.mappedNamespace || n.namespace;
+				r.dependsOn.push({
+					namespace: i,
+					entity: t
+				});
+			}
+		}
+		t.set(e, r);
+	}
+	for (let e of t.values()) for (let n of e.dependsOn) {
+		let r = t.get(`${n.namespace}:${n.entity}`);
+		r && r.requiredBy.push(e.repository);
+	}
+	return Ne(t), t;
+}
+function Ne(e) {
+	let t = /* @__PURE__ */ new Set(), n = /* @__PURE__ */ new Set(), r = [];
+	function i(a) {
+		t.add(a), n.add(a), r.push(a);
+		let o = e.get(a);
+		if (!o) return n.delete(a), r.pop(), !1;
+		for (let e of o.dependsOn) {
+			let o = `${e.namespace}:${e.entity}`;
+			if (o !== a) {
+				if (!t.has(o)) {
+					if (i(o)) return !0;
+				} else if (n.has(o)) {
+					let e = r.indexOf(o), t = [...r.slice(e), o];
+					throw new p(`Circular dependency detected: ${t.join(" -> ")}`);
+				}
+			}
+		}
+		return n.delete(a), r.pop(), !1;
+	}
+	for (let n of e.keys()) t.has(n) || i(n);
+}
+//#endregion
+//#region src/pull-ancestor-changes.ts
+async function Pe(e, t, n) {
+	let { namespace: r, entity: i, sinceId: a, limit: o, filter: s } = t, c = [`${r}:${i}`];
+	return (await Promise.all(n.map((t) => e.pullChanges(a, o, c, s, t)))).flat().sort((e, t) => e.id - t.id).slice(0, o);
+}
+//#endregion
+//#region src/pull-conflict-utils.ts
+function z() {
+	return {
+		deletes: /* @__PURE__ */ new Map(),
+		updates: /* @__PURE__ */ new Map(),
+		inserts: /* @__PURE__ */ new Map()
+	};
+}
+function B(e) {
+	return e.inserts.size + e.updates.size + e.deletes.size;
+}
+function Fe(e, t) {
+	if (t.type === "INSERT") {
+		e.inserts.set(t.key, t.change);
+		return;
+	}
+	if (t.type === "UPDATE") {
+		e.updates.set(t.key, t.change);
+		return;
+	}
+	e.deletes.set(t.key, t.change);
+}
+function Ie(e, t) {
+	let n = /* @__PURE__ */ new Map();
+	for (let t of e) {
+		let e = A(t), r = n.get(e);
+		(!r || t.id > r.id) && n.set(e, t);
+	}
+	let r = [], i = (e, t) => {
+		for (let [i, a] of e) {
+			let e = n.get(i);
+			e && r.push({
+				key: i,
+				entityId: e.entityId,
+				type: t,
+				change: a,
+				remote: {
+					...e,
+					type: t,
+					patch: a.patch ?? null,
+					inversePatch: a.inversePatch ?? null
+				}
+			});
+		}
+	};
+	return i(t.inserts, "INSERT"), i(t.updates, "UPDATE"), i(t.deletes, "DELETE"), r;
+}
+async function Le(e, t, n, r, i, a) {
+	if (a.length === 0) return /* @__PURE__ */ new Map();
+	let o = [
+		{
+			field: "namespace",
+			operator: "=",
+			value: t
+		},
+		{
+			field: "entity",
+			operator: "=",
+			value: n
+		},
+		{
+			field: "branchId",
+			operator: "=",
+			value: r
+		},
+		{
+			field: "remoteId",
+			operator: "=",
+			value: null
+		},
+		{
+			field: "revertChangeId",
+			operator: "=",
+			value: null
+		},
+		{
+			field: "entityId",
+			operator: "in",
+			value: k(a)
+		}
+	];
+	i !== null && o.push({
+		field: "id",
+		operator: ">",
+		value: i
+	});
+	let s = await e.find({
+		where: {
+			combinator: "and",
+			rules: o
+		},
+		orderBy: [{
+			field: "id",
+			sort: "asc"
+		}]
+	}), c = /* @__PURE__ */ new Map();
+	for (let e of s) {
+		let t = A(e);
+		c.has(t) || c.set(t, []), c.get(t).push(e);
+	}
+	return c;
+}
+async function Re(e, t, n) {
+	for (let r of t) await e.update(r, {
+		remoteId: n,
+		updatedAt: /* @__PURE__ */ new Date()
+	});
+}
+var ze = (e, t) => t ? Object.assign(Object.create(Object.getPrototypeOf(e)), e, { clientId: t }) : e;
+async function Be(n, r, i) {
+	let a = z(), o = [], s = new Map(n.map((e) => [e.key, e])), c = [];
+	for (let e of n) {
+		let t = r.get(e.key);
+		if (!t || t.length === 0) {
+			Fe(a, e);
+			continue;
+		}
+		o.push({
+			entityKey: e.key,
+			local: ze(t[t.length - 1], i.localClientId),
+			remote: e.remote
+		});
+	}
+	let l = 0;
+	if (o.length > 0) {
+		let { conflictResolver: n, changeRepo: u, dispatchEvent: d, repoLabel: f } = i, m = n.resolveAll ? await n.resolveAll(o) : await Promise.all(o.map((e) => n.resolve(e))), h = [];
+		for (let e = 0; e < o.length; e += 1) {
+			let t = o[e], n = m[e], i = s.get(t.entityKey), u = r.get(t.entityKey) ?? [];
+			if (i) {
+				if (n.type === "KEEP_LOCAL") {
+					l += 1;
+					continue;
+				}
+				if (n.type === "KEEP_REMOTE") {
+					l += 1, c.push({
+						localChanges: u,
+						remoteId: i.remote.id
+					}), Fe(a, i);
+					continue;
+				}
+				h.push(t);
+			}
+		}
+		if (h.length > 0) throw d(new e(o, 0, h.length)), d(new t(h)), new p(`Unsupported conflict resolution returned during pull for ${f}. Only KEEP_LOCAL and KEEP_REMOTE can be applied automatically at runtime.`);
+		if (d(new e(o, o.length, 0)), !i.deferLocalChangeSupersession) for (let e of c) await Re(u, e.localChanges, e.remoteId);
+	}
+	return {
+		applyActions: a,
+		conflictsResolved: l,
+		localChangeSupersessions: c
+	};
+}
+//#endregion
+//#region src/topological-sort.ts
+function Ve(e) {
+	return e === "pull" ? "dependsOn" : "requiredBy";
+}
+function He(e) {
+	return e === "DELETE" ? "push" : "pull";
+}
+function Ue(e) {
+	return Ve(He(e));
+}
+function We(e, t) {
+	let n = [], r = /* @__PURE__ */ new Set(), i = /* @__PURE__ */ new Set();
+	function a(o) {
+		if (r.has(o)) return;
+		if (i.has(o)) throw new p(`Circular dependency detected at ${o}`);
+		i.add(o);
+		let s = e.get(o);
+		if (!s) throw new p(`Repository ${o} not found in dependency graph`);
+		let c = s[Ve(t)];
+		for (let t of c) {
+			let n = `${t.namespace}:${t.entity}`;
+			n !== o && e.has(n) && a(n);
+		}
+		i.delete(o), r.add(o), n.push(s.repository);
+	}
+	for (let t of e.keys()) a(t);
+	return n;
+}
+function Ge(e) {
+	return We(e, "pull");
+}
+function Ke(e, t) {
+	return We(e, He(t));
+}
+//#endregion
+//#region src/pull-repository.ts
+function qe(e) {
+	if (!e || typeof e != "object") return !1;
+	let t = e;
+	return (t.combinator === "and" || t.combinator === "or") && Array.isArray(t.rules);
+}
+function Je() {
+	return {
+		pulled: 0,
+		compacted: 0,
+		applied: 0,
+		hasMore: !1,
+		conflictsResolved: 0,
+		conflictsDeferred: 0,
+		persistedProgress: !1,
+		historyInvalidated: !1,
+		failures: []
+	};
+}
+function Ye(e) {
+	if (!(e instanceof m)) return;
+	let t = e.result;
+	if (!t || typeof t != "object") return;
+	let n = t;
+	return typeof n.applied == "number" && typeof n.persistedProgress == "boolean" ? n : void 0;
+}
+var Xe = {
+	limit: 1e3,
+	fetchAll: !1,
+	includeRelated: !0,
+	filter: void 0,
+	conflictResolver: void 0
+};
+async function Ze(e, t, n, r) {
+	let i = {
+		...Xe,
+		...r
+	}, a = e.rxdb;
+	a.dispatchEvent(new s("pull", t, n, i.includeRelated));
+	try {
+		let r = await Qe(e, t, n, i);
+		return a.dispatchEvent(new c("pull", t, n, {
+			pulled: r.pulled,
+			compacted: r.compacted,
+			conflictsResolved: r.conflictsResolved,
+			conflictsDeferred: r.conflictsDeferred
+		})), r;
+	} catch (e) {
+		throw a.dispatchEvent(new l("pull", t, n, e)), e;
+	}
+}
+async function Qe(e, t, n, r) {
+	let i = e.rxdb.config.entities.find((e) => {
+		let r = T(e);
+		return r.namespace === t && r.name === n;
+	});
+	if (!i) throw new p(`Entity not found: ${t}:${n}`);
+	let a = T(i), o = N(a, e.rxdb.config.sync), s = await re(e.rxdb, t, n, o);
+	if (s) throw new p(`Cannot pull repository ${t}:${n}: ${s}.`);
+	let c = r.filter;
+	if (o === "filter" && !c) {
+		let e = a.sync;
+		if (e?.remote?.filter) {
+			try {
+				c = e.remote.filter();
+			} catch (e) {
+				throw new p(`Filter function failed for ${t}:${n}: ${e instanceof Error ? e.message : String(e)}`);
+			}
+			if (c && !qe(c)) throw new p(`Invalid RuleGroup returned by filter function for ${t}:${n}: RuleGroup must have 'combinator' ('and' | 'or') and 'rules' array properties.`);
+		}
+	}
+	let l = {
+		...r,
+		filter: c
+	};
+	return r.includeRelated ? await $e(e, t, n, l) : await nt(e, t, n, l);
+}
+async function $e(e, t, n, r) {
+	let i = R(e.rxdb.config.entities.map((e) => T(e))), a = new Map(e.rxdb.config.entities.map((e) => {
+		let t = T(e);
+		return [`${t.namespace}:${t.name}`, e];
+	})), o = Ge(i), s = `${t}:${n}`;
+	if (!i.get(s)) throw new p(`Repository ${t}:${n} not found in dependency graph`);
+	let c = /* @__PURE__ */ new Set([s]), l = (e) => {
+		let t = i.get(e);
+		if (t) for (let e of t.dependsOn) {
+			let t = `${e.namespace}:${e.entity}`;
+			c.has(t) || (c.add(t), l(t));
+		}
+	};
+	l(s);
+	let u = o.filter((e) => {
+		let t = `${e.namespace}:${e.entity}`;
+		return c.has(t);
+	}), d = [], f = [], h = /* @__PURE__ */ new Map();
+	for (let t of u) {
+		let n = await et(e, i, a, t, r, h);
+		d.push(n), n.error && (h.set(F(t), n.error), f.push({
+			repository: t,
+			error: n.error
+		}));
+	}
+	let g = d.find((e) => e.repository.namespace === t && e.repository.entity === n);
+	if (!g) throw new p("Internal error: target repository result not found");
+	g.relatedResults = d.filter((e) => e !== g), g.failures = f;
+	for (let e of g.relatedResults) g.persistedProgress ||= e.persistedProgress, g.historyInvalidated ||= e.historyInvalidated;
+	let [_] = f;
+	if (!g.success && _) throw !g.persistedProgress && f.length === 1 ? _.error : new m(g, _.error);
+	return g;
+}
+async function et(e, t, n, r, i, a) {
+	let o = F(r), s = Me(t, o, a, "dependsOn");
+	if (s) return {
+		...Je(),
+		repository: r,
+		success: !1,
+		skipped: `dependency ${F(s.dependency)} failed`,
+		error: new f(r, s.dependency, s.cause)
+	};
+	let c = n.get(o);
+	if (!c) throw new p(`Internal error: entity not found for cascade node ${o}`);
+	let l = T(c), u = N(l, e.rxdb.config.sync), d = await re(e.rxdb, r.namespace, r.entity, u);
+	if (d) return {
+		...Je(),
+		repository: r,
+		success: !0,
+		skipped: d
+	};
+	try {
+		let t = await nt(e, r.namespace, r.entity, {
+			...i,
+			filter: tt(o, l, u, i.filter),
+			includeRelated: !1
+		});
+		return t.success = !0, t;
+	} catch (e) {
+		let t = e instanceof Error ? e : Error(String(e)), n = t instanceof m ? t.cause : t;
+		return {
+			...Ye(t) ?? Je(),
+			repository: r,
+			success: !1,
+			error: n,
+			failures: [{
+				repository: r,
+				error: n
+			}]
+		};
+	}
+}
+function tt(e, t, n, r) {
+	if (n === "full") return;
+	if (n !== "filter") return r;
+	let i = t.sync?.remote?.filter;
+	if (!i) return r;
+	let a;
+	try {
+		a = i();
+	} catch (t) {
+		throw new p(`Filter function failed for ${e}: ${t instanceof Error ? t.message : String(t)}`);
+	}
+	if (!qe(a)) throw new p(`Invalid RuleGroup returned by filter function for ${e}: RuleGroup must have 'combinator' ('and' | 'or') and 'rules' array properties.`);
+	return a;
+}
+async function nt(e, t, n, r) {
+	let i = e.rxdb;
+	if (!i.config.sync?.remote?.adapter) throw new p("Remote adapter not configured.");
+	let { adapter: o } = await e.getRemoteRepositories(), { adapter: s } = await e.getLocalRepositories(), c = await e.getCurrentBranch(), l = await L(e, c.id), u = s.getRepository(g), f = e.rxdb.config.entities.find((e) => {
+		let r = T(e);
+		return r.namespace === t && r.name === n;
+	}), h = T(f), _ = N(h, e.rxdb.config.sync), v = await D(u, {
+		namespace: t,
+		entity: n,
+		branchId: c.id,
+		syncType: _
+	}, () => i.entityManager.instantiate(g)), y = v.lastPullRemoteChangeId, b = 0, x = 0, C = 0, w = 0, E = !1, O, k, A = r.conflictResolver ?? new a(), j = y ?? 0, M = z();
+	try {
+		do {
+			let e = await Pe(o, {
+				namespace: t,
+				entity: n,
+				sinceId: j,
+				limit: r.limit,
+				filter: r.filter
+			}, l);
+			if (b += e.length, O = e.length >= r.limit, e.length === 0) {
+				await u.update(v, {
+					lastPulledAt: /* @__PURE__ */ new Date(),
+					updatedAt: /* @__PURE__ */ new Date()
+				});
+				break;
+			}
+			k = e[e.length - 1], j = k.id;
+			let a = i.context.clientId, f = [], p = [];
+			for (let t of e) t.clientId != null && t.clientId === a ? f.push(t) : p.push(t);
+			let m = 0;
+			await s.transaction(async (e) => {
+				let r = e.getRepository(d), a = e.getRepository(g), o = f.filter((e) => e.localId != null);
+				if (o.length > 0) {
+					let e = o.map((e) => e.localId), t = await r.find({ where: {
+						combinator: "and",
+						rules: [{
+							field: "id",
+							operator: "in",
+							value: e
+						}]
+					} }), n = new Map(t.map((e) => [e.id, e]));
+					for (let e of o) {
+						let t = n.get(e.localId);
+						t && t.remoteId == null && await r.update(t, { remoteId: e.id });
+					}
+				}
+				if (p.length > 0) {
+					S(p, M);
+					let a = B(M);
+					x += p.length - a;
+					let o = Ie(p, M), { applyActions: s, conflictsResolved: l, localChangeSupersessions: u } = await Be(o, await Le(r, t, n, c.id, v.lastPushedChangeId, [...new Set(o.map((e) => e.entityId))]), {
+						changeRepo: r,
+						conflictResolver: A,
+						dispatchEvent: (e) => i.dispatchEvent(e),
+						repoLabel: `${t}:${n}`,
+						deferLocalChangeSupersession: !0,
+						localClientId: i.context.clientId
+					});
+					w += l;
+					let d = B(s);
+					if (d > 0) {
+						await e.mergeChanges(s, void 0, !0);
+						for (let e of u) await Re(r, e.localChanges, e.remoteId);
+						m = d;
+					}
+					M = z();
+				}
+				let s = k.id;
+				v = await a.update(v, {
+					lastPullRemoteChangeId: s,
+					lastPulledAt: /* @__PURE__ */ new Date(),
+					updatedAt: /* @__PURE__ */ new Date()
+				});
+			}), E = !0, C += m;
+		} while (O && r.fetchAll);
+	} catch (e) {
+		throw E ? new m({
+			repository: {
+				namespace: t,
+				entity: n
+			},
+			pulled: b,
+			compacted: x,
+			applied: C,
+			hasMore: !0,
+			conflictsResolved: w,
+			conflictsDeferred: 0,
+			persistedProgress: !0,
+			historyInvalidated: C > 0,
+			failures: [{
+				repository: {
+					namespace: t,
+					entity: n
+				},
+				error: e instanceof Error ? e : Error(String(e))
+			}]
+		}, e instanceof Error ? e : Error(String(e))) : e;
+	}
+	return {
+		repository: {
+			namespace: t,
+			entity: n
+		},
+		pulled: b,
+		compacted: x,
+		applied: C,
+		hasMore: O,
+		conflictsResolved: w,
+		conflictsDeferred: 0,
+		persistedProgress: E,
+		historyInvalidated: C > 0,
+		failures: []
+	};
+}
+//#endregion
+//#region src/push-repository.ts
+var rt = {
+	batchSize: 1e3,
+	includeRelated: !0
+};
+function it(e) {
+	if (!Number.isSafeInteger(e) || e <= 0) throw RangeError("batchSize must be a positive safe integer");
+}
+function at(e) {
+	if (!(e instanceof m)) return;
+	let t = e.result;
+	if (!t || typeof t != "object") return;
+	let n = t;
+	return typeof n.pushed == "number" && typeof n.originalCount == "number" ? n : void 0;
+}
+function ot(e) {
+	let { error: t } = e;
+	throw t ? e.pushed === 0 ? t : new m(e, t) : new p(`Internal error: repository ${F(e.repository)} failed without an error`);
+}
+async function st(e, t, n, r) {
+	let i = {
+		batchSize: r?.batchSize === void 0 ? rt.batchSize : r.batchSize,
+		includeRelated: r?.includeRelated === void 0 ? rt.includeRelated : r.includeRelated
+	}, a = e.rxdb;
+	a.dispatchEvent(new s("push", t, n, i.includeRelated));
+	let o = e.pushInFlight.session();
+	try {
+		it(i.batchSize);
+		let r = await ct(e, t, n, i, o);
+		return a.dispatchEvent(new c("push", t, n, {
+			pushed: r.pushed,
+			compacted: r.compacted,
+			failed: r.failed
+		})), r;
+	} catch (e) {
+		throw a.dispatchEvent(new l("push", t, n, e)), e;
+	} finally {
+		o.release();
+	}
+}
+async function ct(e, t, n, r, i) {
+	let a = e.rxdb.config.entities.find((e) => {
+		let r = T(e);
+		return r.namespace === t && r.name === n;
+	});
+	if (!a) throw new p(`Entity not found: ${t}:${n}`);
+	let o = T(a), s = await ie(e.rxdb, t, n, N(o, e.rxdb.config.sync));
+	if (s) throw new p(`Cannot push repository ${t}:${n}: ${s}.`);
+	return r.includeRelated ? await lt(e, t, n, r, i) : await Ct(e, t, n, r, i);
+}
+async function lt(e, t, n, r, i) {
+	let a = R(e.rxdb.config.entities.map((e) => T(e))), o = `${t}:${n}`;
+	if (!a.get(o)) throw new p(`Repository ${t}:${n} not found in dependency graph`);
+	let s = /* @__PURE__ */ new Set([o]), c = (e) => {
+		let t = a.get(e);
+		if (t) for (let e of t.requiredBy) {
+			let t = `${e.namespace}:${e.entity}`;
+			s.has(t) || (s.add(t), c(t));
+		}
+	};
+	c(o);
+	let l = (e) => Ke(a, e).filter((e) => s.has(F(e))), u = /* @__PURE__ */ new Map(), d = /* @__PURE__ */ new Map();
+	for (let t of pt) for (let n of l(t.action)) await ut(e, a, n, t, r, u, d, i);
+	let f = [], m = [];
+	for (let e of l("INSERT")) {
+		let t = u.get(F(e));
+		if (!t) throw new p(`Internal error: cascade node missing for ${F(e)}`);
+		let n = t.result ?? await St(t.plan);
+		f.push(n), n.error && m.push({
+			repository: e,
+			error: n.error
+		});
+	}
+	let h = f.find((e) => e.repository.namespace === t && e.repository.entity === n);
+	if (!h) throw new p("Internal error: target repository result not found");
+	return h.relatedResults = f.filter((e) => e !== h), h.failures = m, h.success || ot(h), h;
+}
+async function ut(e, t, n, r, i, a, o, s) {
+	let c = F(n), l = a.get(c);
+	if (l || (l = { repo: n }, a.set(c, l)), l.result) return;
+	let u = Me(t, c, o, Ue(r.action));
+	if (u) {
+		let e = new f(n, u.dependency, u.cause);
+		l.result = {
+			...ft(l.plan),
+			repository: n,
+			success: !1,
+			skipped: `dependency ${F(u.dependency)} failed`,
+			error: e
+		}, o.set(c, e);
+		return;
+	}
+	if (!l.plan) {
+		let t = await dt(e, n);
+		if (t) {
+			l.result = {
+				...V(),
+				repository: n,
+				success: !0,
+				skipped: t
+			};
+			return;
+		}
+		try {
+			let t = await bt(e, n.namespace, n.entity, s);
+			if ("emptyResult" in t) {
+				l.result = {
+					...t.emptyResult,
+					success: t.emptyResult.success ?? !0
+				};
+				return;
+			}
+			l.plan = t;
+		} catch (e) {
+			let t = e instanceof Error ? e : Error(String(e));
+			l.result = {
+				...V(),
+				repository: n,
+				success: !1,
+				error: t,
+				failures: [{
+					repository: n,
+					error: t
+				}]
+			}, o.set(c, t);
+			return;
+		}
+	}
+	await xt(l.plan, r.kinds, i.batchSize), l.plan.error && (l.result = await St(l.plan), o.set(c, l.plan.error));
+}
+async function dt(e, t) {
+	let n = e.rxdb.config.entities.find((e) => {
+		let n = T(e);
+		return n.namespace === t.namespace && n.name === t.entity;
+	});
+	if (!n) throw new p(`Internal error: entity not found for cascade node ${F(t)}`);
+	return ie(e.rxdb, t.namespace, t.entity, N(T(n), e.rxdb.config.sync));
+}
+function V() {
+	return {
+		pushed: 0,
+		failed: 0,
+		compacted: 0,
+		originalCount: 0,
+		failures: []
+	};
+}
+function ft(e) {
+	return e ? {
+		pushed: e.pushed,
+		failed: e.effectiveCount - e.pushed,
+		compacted: e.compacted,
+		originalCount: e.originalCount,
+		failures: []
+	} : V();
+}
+var pt = [{
+	action: "DELETE",
+	kinds: /* @__PURE__ */ new Set(["deletes"])
+}, {
+	action: "INSERT",
+	kinds: /* @__PURE__ */ new Set(["updates", "inserts"])
+}], mt = /* @__PURE__ */ new Set([
+	"deletes",
+	"updates",
+	"inserts"
+]);
+function ht(e, t) {
+	let n = /* @__PURE__ */ new Map();
+	for (let t of e) {
+		let e = A(t), r = n.get(e) ?? [];
+		r.push(t), n.set(e, r);
+	}
+	let r = [], i = (e, t) => {
+		for (let [i, a] of t) {
+			let t = n.get(i);
+			if (!t?.length) throw new p(`Missing source changes for compacted action: ${i}`);
+			r.push({
+				actionKind: e,
+				key: i,
+				action: a,
+				sourceChanges: t
+			});
+		}
+	};
+	return i("deletes", t.deletes), i("updates", t.updates), i("inserts", t.inserts), r;
+}
+function gt(e) {
+	let t = {
+		deletes: /* @__PURE__ */ new Map(),
+		updates: /* @__PURE__ */ new Map(),
+		inserts: /* @__PURE__ */ new Map()
+	}, n = [], r = /* @__PURE__ */ new Map();
+	for (let i of e) {
+		t[i.actionKind].set(i.key, i.action);
+		for (let e of i.sourceChanges) n.push(e), r.set(e.id, [e]);
+	}
+	return n.sort((e, t) => e.id - t.id), {
+		actions: t,
+		sourceChanges: n,
+		sourceChangesByLocalId: r
+	};
+}
+function _t(e) {
+	return typeof e != "object" || !e ? [] : e.changeIdMapping ?? [];
+}
+function vt(e, t) {
+	let n = e.map(({ localId: e, remoteId: n }) => {
+		let r = t.get(e);
+		if (!r) throw new p(`Remote change mapping references unknown local change: ${e}`);
+		return {
+			remoteId: n,
+			sourceChanges: r
+		};
+	}), r = /* @__PURE__ */ new Map();
+	for (let { remoteId: e, sourceChanges: t } of n) for (let n of t) r.set(n, e);
+	return [...r].map(([e, t]) => ({
+		change: e,
+		remoteId: t
+	}));
+}
+async function yt(e, t, n) {
+	return vt(_t(await e.mergeChanges(n.actions, t, n.sourceChanges)), n.sourceChangesByLocalId);
+}
+async function bt(e, t, n, r) {
+	let i = e.rxdb;
+	if (!i.config.sync?.remote?.adapter) throw new p("Remote adapter not configured.");
+	await e.getRemoteRepositories();
+	let { adapter: a } = await e.getLocalRepositories(), o = await e.getCurrentBranch(), s = a.getRepository(g), c = e.rxdb.config.entities.find((e) => {
+		let r = T(e);
+		return r.namespace === t && r.name === n;
+	}), l = T(c), u = N(l, e.rxdb.config.sync), f = await D(s, {
+		namespace: t,
+		entity: n,
+		branchId: o.id,
+		syncType: u
+	}, () => i.entityManager.instantiate(g)), m = f.lastPushedChangeId, h = await L(e, o.id), _ = a.getRepository(d), v;
+	if (h.length === 1) v = await wt(_, h, m, t, [n]);
+	else {
+		let e = m;
+		for (let r of h.slice(1)) {
+			let i = `${t}:${n}:${r}`, a = (await s.find({
+				where: {
+					combinator: "and",
+					rules: [{
+						field: "id",
+						operator: "=",
+						value: i
+					}]
+				},
+				limit: 1
+			}))[0]?.lastPushedChangeId ?? null;
+			if (a === null) {
+				e = null;
+				break;
+			}
+			(e === null || a < e) && (e = a);
+		}
+		v = await wt(_, h, e, t, [n]);
+	}
+	let y = v.length;
+	if (y === 0) return { emptyResult: {
+		...V(),
+		repository: {
+			namespace: t,
+			entity: n
+		}
+	} };
+	let b = {
+		deletes: /* @__PURE__ */ new Map(),
+		updates: /* @__PURE__ */ new Map(),
+		inserts: /* @__PURE__ */ new Map()
+	};
+	S(v.map((e) => ({
+		id: e.id,
+		namespace: e.namespace,
+		entity: e.entity,
+		entityId: e.entityId,
+		type: e.type,
+		branchId: e.branchId,
+		patch: e.patch,
+		inversePatch: e.inversePatch,
+		createdAt: e.createdAt,
+		updatedAt: e.updatedAt
+	})), b);
+	let x = b.inserts.size + b.updates.size + b.deletes.size, C = y - x;
+	if (x === 0) {
+		let e = v.reduce((e, t) => t.id > e ? t.id : e, v[0].id);
+		return await s.update(f, {
+			lastPushedChangeId: e,
+			updatedAt: /* @__PURE__ */ new Date()
+		}), { emptyResult: {
+			...V(),
+			repository: {
+				namespace: t,
+				entity: n
+			},
+			compacted: y,
+			originalCount: y
+		} };
+	}
+	let { adapter: w } = await e.getRemoteRepositories();
+	return r.claim(`${t}:${n}`, v.reduce((e, t) => t.id > e ? t.id : e, v[0].id)), {
+		repository: {
+			namespace: t,
+			entity: n
+		},
+		entries: ht(v, b),
+		localChanges: v,
+		repoSync: f,
+		localAdapter: a,
+		remoteAdapter: w,
+		branchId: o.id,
+		originalCount: y,
+		effectiveCount: x,
+		compacted: C,
+		pushed: 0,
+		remoteIdsByChange: /* @__PURE__ */ new Map()
+	};
+}
+async function xt(e, t, n) {
+	if (e.error) return;
+	let r = e.entries.filter((e) => t.has(e.actionKind));
+	if (r.length === 0) return;
+	let { namespace: i, entity: a } = e.repository;
+	for (let t = 0; t < r.length; t += n) {
+		let o = r.slice(t, t + n), s = gt(o);
+		try {
+			let t = await yt(e.remoteAdapter, e.branchId, s);
+			for (let { change: n, remoteId: r } of t) e.remoteIdsByChange.set(n, r);
+			e.pushed += o.length;
+		} catch (t) {
+			console.error(`Error pushing changes to remote for repository [${i}/${a}]:`, t), e.error = t instanceof Error ? t : Error(String(t));
+			return;
+		}
+	}
+}
+async function St(e) {
+	let { repository: t, localChanges: n, repoSync: r, localAdapter: i, remoteIdsByChange: a, effectiveCount: o } = e, { namespace: s, entity: c } = t, l = e.pushed, u = e.error, d = o - l;
+	if (d === 0) {
+		let e = n.reduce((e, t) => t.id > e ? t.id : e, n[0].id), t = new Map([...a].map(([e]) => [e, e.remoteId])), f = {
+			lastPushedChangeId: r.lastPushedChangeId,
+			lastPushedAt: r.lastPushedAt,
+			updatedAt: r.updatedAt
+		}, p = /* @__PURE__ */ new Date();
+		try {
+			await i.transaction(async (t) => {
+				let n = [...a].map(([e, t]) => (e.remoteId = t, e));
+				n.length > 0 && await t.saveMany(n), await t.getRepository(g).update(r, {
+					lastPushedChangeId: e,
+					lastPushedAt: p,
+					updatedAt: p
+				});
+			});
+		} catch (e) {
+			for (let [e, n] of t) e.remoteId = n;
+			Object.assign(r, f), console.error(`Error saving push state for repository [${s}/${c}]:`, e), u = e instanceof Error ? e : Error(String(e)), l = 0, d = o;
+		}
+	}
+	return {
+		repository: t,
+		success: d === 0,
+		error: u,
+		pushed: l,
+		failed: d,
+		compacted: e.compacted,
+		originalCount: e.originalCount,
+		failures: u ? [{
+			repository: t,
+			error: u
+		}] : []
+	};
+}
+async function Ct(e, t, n, r, i) {
+	let a = await bt(e, t, n, i);
+	if ("emptyResult" in a) return a.emptyResult;
+	await xt(a, mt, r.batchSize);
+	let o = await St(a);
+	return o.success || ot(o), o;
+}
+async function wt(e, t, n, r, i) {
+	let a = [
+		{
+			field: "revertChangeId",
+			operator: "=",
+			value: null
+		},
+		{
+			field: "remoteId",
+			operator: "=",
+			value: null
+		},
+		{
+			field: "namespace",
+			operator: "=",
+			value: r
+		}
+	];
+	return t.length === 1 ? a.push({
+		field: "branchId",
+		operator: "=",
+		value: t[0]
+	}) : a.push({
+		field: "branchId",
+		operator: "in",
+		value: t
+	}), i && i.length > 0 && a.push({
+		field: "entity",
+		operator: "in",
+		value: i
+	}), n !== null && a.push({
+		field: "id",
+		operator: ">",
+		value: n
+	}), await e.find({
+		where: {
+			combinator: "and",
+			rules: a
+		},
+		orderBy: [{
+			field: "id",
+			sort: "asc"
+		}]
+	});
+}
+//#endregion
+//#region src/sync-repository.ts
+function Tt(e, t) {
+	return {
+		repository: {
+			namespace: e,
+			entity: t
+		},
+		pulled: 0,
+		compacted: 0,
+		applied: 0,
+		hasMore: !1,
+		conflictsResolved: 0,
+		conflictsDeferred: 0,
+		persistedProgress: !1,
+		historyInvalidated: !1,
+		failures: []
+	};
+}
+function Et(e, t) {
+	return {
+		repository: {
+			namespace: e,
+			entity: t
+		},
+		pushed: 0,
+		failed: 0,
+		compacted: 0,
+		originalCount: 0,
+		failures: []
+	};
+}
+function Dt(e, t, n) {
+	if (!(e instanceof m)) return e;
+	let r = Ye(e);
+	if (!r) return e;
+	let i = {
+		pullResult: r,
+		pushResult: Et(t, n),
+		persistedProgress: r.persistedProgress,
+		historyInvalidated: r.historyInvalidated
+	};
+	return new m(i, e.cause);
+}
+function Ot(e, t, n, r) {
+	let i = e instanceof Error ? e : Error(String(e)), a = at(i), o = a === void 0 ? Et(n, r) : a, s = t.persistedProgress || o.pushed > 0;
+	if (!s) return i;
+	let c = {
+		pullResult: t,
+		pushResult: o,
+		persistedProgress: s,
+		historyInvalidated: t.historyInvalidated
+	};
+	return new m(c, i instanceof m ? i.cause : i);
+}
+async function kt(e, t, n, r) {
+	let i = e.rxdb, a = r?.pull?.includeRelated ?? r?.push?.includeRelated ?? !0;
+	i.dispatchEvent(new s("sync", t, n, a));
+	try {
+		let a = await At(e, t, n, r), { pullResult: o, pushResult: s } = a, l = {
+			pulled: o.pulled,
+			pushed: s.pushed,
+			compacted: o.compacted + s.compacted,
+			failed: s.failed,
+			conflictsResolved: o.conflictsResolved,
+			conflictsDeferred: o.conflictsDeferred
+		};
+		return i.dispatchEvent(new c("sync", t, n, l)), a;
+	} catch (e) {
+		throw i.dispatchEvent(new l("sync", t, n, e)), e;
+	}
+}
+async function At(e, t, n, r) {
+	let i = e.rxdb.config.entities.find((e) => {
+		let r = T(e);
+		return r.namespace === t && r.name === n;
+	});
+	if (!i) throw new p(`Entity not found: ${t}:${n}`);
+	let a = T(i), o = N(a, e.rxdb.config.sync);
+	if (o === "none") throw new p(`Cannot sync repository ${t}:${n}: syncType is 'none'. This entity is not configured for remote synchronization.`);
+	let s;
+	if ((r?.direction === "pull" || r?.direction === "sync" || !r?.direction) && M(o).pull) try {
+		s = await Ze(e, t, n, r?.pull);
+	} catch (e) {
+		throw Dt(e, t, n);
+	}
+	else s = Tt(t, n);
+	let c;
+	if ((r?.direction === "push" || r?.direction === "sync" || !r?.direction) && M(o).push) try {
+		c = await st(e, t, n, r?.push);
+	} catch (e) {
+		throw Ot(e, s, t, n);
+	}
+	else c = Et(t, n);
+	return {
+		pullResult: s,
+		pushResult: c,
+		persistedProgress: s.persistedProgress || c.pushed > 0,
+		historyInvalidated: s.historyInvalidated
+	};
+}
+//#endregion
+//#region src/bulk-sync.ts
+async function jt(e, t) {
+	if (t.repositories && t.repositories.length > 0) return t.repositories;
+	let n = [];
+	for (let t of e.config.entities) {
+		let r = T(t), i = M(N(r, e.config.sync));
+		if (!i.pull && !i.push) continue;
+		let a = await C(e, r.namespace, r.name);
+		P(a) && n.push({
+			namespace: r.namespace,
+			entity: r.name
+		});
+	}
+	return n;
+}
+async function Mt(e, t, n) {
+	try {
+		return {
+			repository: t,
+			success: !0,
+			result: await kt(e, t.namespace, t.entity, n)
+		};
+	} catch (e) {
+		let n = e instanceof Error ? e : Error(String(e));
+		return {
+			repository: t,
+			success: !1,
+			result: n instanceof m ? n.result : void 0,
+			error: n
+		};
+	}
+}
+async function Nt(e, t, n) {
+	let r = [];
+	for (let i of t) {
+		let t = await Mt(e, i, n);
+		r.push(t);
+	}
+	return r;
+}
+async function Pt(e, t, n, r) {
+	let i = [];
+	for (let a = 0; a < t.length; a += r) {
+		let o = t.slice(a, a + r).map((t) => Mt(e, t, n)), s = await Promise.all(o);
+		i.push(...s);
+	}
+	return i;
+}
+async function Ft(e, t = {}) {
+	let n = Date.now(), r = e.syncManager, i = await jt(e, t), a = {
+		direction: t.operation,
+		pull: t.pull,
+		push: t.push
+	}, o = t.concurrent ?? !1, s = t.concurrency ?? 3;
+	if (o && (!Number.isSafeInteger(s) || s < 1)) throw new p(`bulkSync: concurrency 必须是不小于 1 的安全整数，收到 ${String(s)}`);
+	let c;
+	c = o ? await Pt(r, i, a, s) : await Nt(r, i, a);
+	let l = c.filter((e) => e.success).length, u = c.filter((e) => !e.success).length, d = Date.now() - n;
+	return {
+		succeeded: l,
+		failed: u,
+		results: c,
+		durationMs: d
+	};
+}
+//#endregion
+//#region src/check-repository-updates.ts
+async function It(e, t, n) {
+	let r = {
+		namespace: t,
+		entity: n
+	}, i = e.config.entities.find((e) => {
+		let r = T(e);
+		return r.namespace === t && r.name === n;
+	});
+	if (!i) throw Error(`Entity not found: ${t}.${n}`);
+	let a = T(i);
+	if (!te(a, e.config.sync)) return {
+		repository: r,
+		remoteLatestChangeId: 0,
+		localLastPullRemoteChangeId: null,
+		pendingCount: 0,
+		hasUpdates: !1
+	};
+	let o = e.syncManager, s = (await o.getCurrentBranch()).id, { adapter: c } = await o.getLocalRepositories(), l = c.getRepository(g), u = `${t}:${n}:${s}`, d = (await l.find({
+		where: {
+			combinator: "and",
+			rules: [{
+				field: "id",
+				operator: "=",
+				value: u
+			}]
+		},
+		limit: 1
+	}))[0]?.lastPullRemoteChangeId ?? null, { adapter: f } = await o.getRemoteRepositories();
+	if (!f) throw Error("Remote adapter not configured");
+	let p = d ?? 0, m = await L(o, s), h = await Promise.all(m.map((e) => f.getChangeCount(p, [`${t}:${a.name}`], e))), _ = h.reduce((e, t) => e + t.count, 0);
+	return {
+		repository: r,
+		remoteLatestChangeId: h.reduce((e, t) => t.latestChangeId > e ? t.latestChangeId : e, 0),
+		localLastPullRemoteChangeId: d,
+		pendingCount: _,
+		hasUpdates: _ > 0
+	};
+}
+//#endregion
+//#region src/cleanup-expired.ts
+async function Lt(e, t, n, r) {
+	let i = e.rxdb, { adapter: a } = await e.getLocalRepositories(), o = i.config.entities.find((e) => {
+		let r = T(e);
+		return r.namespace === t && r.name === n;
+	});
+	if (!o) throw new p(`Entity not found: ${t}:${n}`);
+	let s = T(o), c = N(s, i.config.sync), l = r?.filter;
+	if (!l && c === "filter") {
+		let e = s.sync;
+		if (e?.remote?.filter) try {
+			l = e.remote.filter();
+		} catch (e) {
+			throw new p(`Filter function failed for ${t}:${n}: ${e instanceof Error ? e.message : String(e)}`);
+		}
+	}
+	if (!l) throw new p(`No filter provided and entity ${t}:${n} does not have a Filter sync configuration.`);
+	let u = Rt(l), f = async (e, r) => {
+		if (e.length === 0) return e;
+		let i = await r.getRepository(d).find({ where: {
+			combinator: "and",
+			rules: [
+				{
+					field: "namespace",
+					operator: "=",
+					value: t
+				},
+				{
+					field: "entity",
+					operator: "=",
+					value: n
+				},
+				{
+					field: "remoteId",
+					operator: "=",
+					value: null
+				},
+				{
+					field: "revertChangeId",
+					operator: "=",
+					value: null
+				},
+				{
+					field: "entityId",
+					operator: "in",
+					value: k(e.map((e) => e.id))
+				}
+			]
+		} }), a = new Set(i.map((e) => j(e.entityId)));
+		return a.size === 0 ? e : e.filter((e) => !a.has(j(e.id)));
+	};
+	if (r?.dryRun) {
+		let e = await f(await a.getRepository(o).find({ where: u }), a);
+		return {
+			removed: e.length,
+			removedIds: e.map((e) => e.id)
+		};
+	}
+	return a.transaction(async (e) => {
+		let r = e.getRepository(o), i = await f(await r.find({ where: u }), e), a = i.map((e) => e.id);
+		if (a.length > 0) {
+			let r = /* @__PURE__ */ new Map();
+			for (let e of i) r.set(`${t}:${n}:${j(e.id)}`, {
+				patch: null,
+				inversePatch: null
+			});
+			let a = {
+				deletes: r,
+				updates: /* @__PURE__ */ new Map(),
+				inserts: /* @__PURE__ */ new Map()
+			};
+			await e.mergeChanges(a, void 0, !0);
+		}
+		return {
+			removed: a.length,
+			removedIds: a
+		};
+	});
+}
+function Rt(e) {
+	return {
+		combinator: e.combinator === "and" ? "or" : "and",
+		rules: e.rules.map((e) => "combinator" in e ? Rt(e) : zt(e))
+	};
+}
+function zt(e) {
+	let t = {
+		"=": "!=",
+		"!=": "=",
+		"<": ">=",
+		"<=": ">",
+		">": "<=",
+		">=": "<",
+		in: "notIn",
+		notIn: "in",
+		contains: "notContains",
+		notContains: "contains",
+		startsWith: "notStartsWith",
+		notStartsWith: "startsWith",
+		endsWith: "notEndsWith",
+		notEndsWith: "endsWith",
+		between: "notBetween",
+		notBetween: "between",
+		null: "notNull",
+		notNull: "null",
+		exists: "notExists",
+		notExists: "exists"
+	}[e.operator];
+	if (!t) throw new p(`Cannot invert operator: ${e.operator}`);
+	return {
+		...e,
+		operator: t
+	};
+}
+//#endregion
+//#region src/get-repository-sync-status.ts
+async function Bt(e, t, n, r, i) {
+	let { adapter: a } = await e.getLocalRepositories(), o = a.getRepository(d), s = [
+		{
+			field: "namespace",
+			operator: "=",
+			value: t
+		},
+		{
+			field: "entity",
+			operator: "=",
+			value: n
+		},
+		{
+			field: "branchId",
+			operator: "=",
+			value: r
+		},
+		{
+			field: "remoteId",
+			operator: "=",
+			value: null
+		},
+		{
+			field: "revertChangeId",
+			operator: "=",
+			value: null
+		}
+	];
+	return i !== null && s.push({
+		field: "id",
+		operator: ">",
+		value: i
+	}), (await o.find({ where: {
+		combinator: "and",
+		rules: s
+	} })).length;
+}
+async function Vt(e, t, n) {
+	return (await It(e, t, n)).pendingCount;
+}
+async function Ht(e, t, n) {
+	let r = e.config.entities.find((e) => {
+		let r = T(e);
+		return r.namespace === t && r.name === n;
+	});
+	if (!r) throw Error(`Entity not found: ${t}.${n}`);
+	let i = T(r), a = N(i, e.config.sync), o = M(a), s = e.syncManager, c = (await s.getCurrentBranch()).id, { adapter: l } = await s.getLocalRepositories(), u = l.getRepository(g), d = {
+		combinator: "and",
+		rules: [{
+			field: "id",
+			operator: "=",
+			value: `${t}:${n}:${c}`
+		}]
+	}, f = await u.find({
+		where: d,
+		limit: 1
+	}), p = f.length > 0 ? f[0] : null, m = 0, h = 0;
+	return ne(i, e.config.sync) && (m = await Bt(s, t, n, c, p?.lastPushedChangeId ?? null)), te(i, e.config.sync) && (h = await Vt(e, t, n)), {
+		repository: {
+			namespace: t,
+			entity: n
+		},
+		branchId: c,
+		syncType: a,
+		enabled: o.pull || o.push ? P(p) : !1,
+		lastPushedChangeId: p?.lastPushedChangeId ?? null,
+		lastPushedAt: p?.lastPushedAt ?? null,
+		lastPulledAt: p?.lastPulledAt ?? null,
+		lastPullRemoteChangeId: p?.lastPullRemoteChangeId ?? null,
+		pushableCount: m,
+		pullableCount: h
+	};
+}
+//#endregion
+//#region src/get-all-repository-sync-status.ts
+async function Ut(e, t) {
+	let n = e.config.entities, r = [];
+	for (let t of n) {
+		let n = T(t), i = n.namespace, a = n.name, o = await Ht(e, i, a);
+		r.push(o);
+	}
+	let i = r;
+	return t?.syncType && t.syncType.length > 0 && (i = i.filter((e) => t.syncType.includes(e.syncType))), t?.enabled !== void 0 && (i = i.filter((e) => e.enabled === t.enabled)), t?.hasPendingChanges !== void 0 && (i = t.hasPendingChanges ? i.filter((e) => e.pushableCount > 0 || e.pullableCount > 0) : i.filter((e) => e.pushableCount === 0 && e.pullableCount === 0)), i;
+}
+//#endregion
+//#region src/pull-batch.ts
+var Wt = 1e3;
+async function Gt(e, t) {
+	if (t?.fetchAll !== !0) return await Jt(e, t?.limit, t?.conflictResolver);
+	let n = {
+		pulled: 0,
+		compacted: 0,
+		applied: 0,
+		hasMore: !1,
+		conflictsResolved: 0,
+		conflictsDeferred: 0,
+		persistedProgress: !1,
+		historyInvalidated: !1,
+		failures: []
+	}, r = (e) => {
+		n.pulled += e.pulled, n.compacted += e.compacted, n.applied += e.applied, n.conflictsResolved += e.conflictsResolved, n.conflictsDeferred += e.conflictsDeferred, n.hasMore = e.hasMore, n.persistedProgress ||= e.persistedProgress, n.historyInvalidated ||= e.historyInvalidated, n.failures.push(...e.failures);
+	};
+	for (let i = 0; i < Wt; i++) {
+		let i;
+		try {
+			i = await Jt(e, t.limit, t.conflictResolver);
+		} catch (e) {
+			throw qt(e, n);
+		}
+		if (r(i), !i.hasMore || i.pulled === 0) break;
+	}
+	return n;
+}
+var Kt = (e) => !e.persistedProgress;
+function qt(e, t) {
+	let n = e instanceof Error ? e : Error(String(e));
+	return Kt(t) ? n : new m(t, n);
+}
+async function Jt(e, t, n) {
+	let r = e.rxdb, i = t ?? 1e3;
+	if (!r.config.sync?.remote?.adapter) throw new p("Remote adapter not configured.");
+	let { adapter: o } = await e.getRemoteRepositories(), { adapter: s } = await e.getLocalRepositories(), c = (await e.getCurrentBranch()).id, l = await L(e, c), u = s.getRepository(g), f = [];
+	for (let e of r.config.entities) {
+		let t = T(e), n = N(t, r.config.sync);
+		if (!M(n).pull || n === "filter") continue;
+		let i = await D(u, {
+			namespace: t.namespace,
+			entity: t.name,
+			branchId: c,
+			syncType: n
+		}, () => r.entityManager.instantiate(g));
+		P(i) && f.push({
+			namespace: t.namespace,
+			entity: t.name,
+			syncId: i.id,
+			repoSync: i,
+			lastPullRemoteChangeId: i.lastPullRemoteChangeId ?? 0,
+			syncType: n
+		});
+	}
+	if (f.length === 0) return {
+		pulled: 0,
+		compacted: 0,
+		applied: 0,
+		hasMore: !1,
+		conflictsResolved: 0,
+		conflictsDeferred: 0,
+		persistedProgress: !1,
+		historyInvalidated: !1,
+		failures: []
+	};
+	let m = Ge(R(r.config.entities.map((e) => T(e)))), h = new Map(f.map((e) => [`${e.namespace}:${e.entity}`, e])), _ = m.map((e) => h.get(`${e.namespace}:${e.entity}`)).filter((e) => e != null), v = i * _.length, y, b = _.map((e) => ({
+		namespace: e.namespace,
+		entity: e.entity,
+		sinceId: e.lastPullRemoteChangeId
+	}));
+	y = o.pullChangesBatch ? await o.pullChangesBatch(b, v, l) : (await Promise.all(_.map((e) => Pe(o, {
+		namespace: e.namespace,
+		entity: e.entity,
+		sinceId: e.lastPullRemoteChangeId,
+		limit: i
+	}, l)))).flat();
+	let x = /* @__PURE__ */ new Map();
+	for (let e of y) {
+		let t = `${e.namespace}:${e.entity}`;
+		x.has(t) || x.set(t, []), x.get(t).push(e);
+	}
+	let C = 0, w = 0, E = 0, O = 0, k = !1, A = r.context.clientId, j = n === void 0 ? new a() : n;
+	return await s.transaction(async (e) => {
+		let t = e.getRepository(d), n = e.getRepository(g);
+		for (let a of _) {
+			let o = (x.get(`${a.namespace}:${a.entity}`) ?? []).filter((e) => e.id > a.lastPullRemoteChangeId);
+			if (o.length === 0) continue;
+			C += o.length;
+			let s = [], l = [];
+			for (let e of o) e.clientId != null && e.clientId === A ? s.push(e) : l.push(e);
+			let u = s.filter((e) => e.localId != null);
+			if (u.length > 0) {
+				let e = u.map((e) => e.localId), n = await t.find({ where: {
+					combinator: "and",
+					rules: [{
+						field: "id",
+						operator: "in",
+						value: e
+					}, {
+						field: "remoteId",
+						operator: "=",
+						value: null
+					}]
+				} });
+				if (n.length > 0) {
+					let e = new Map(u.map((e) => [e.localId, e.id]));
+					for (let r of n) {
+						let n = e.get(r.id);
+						n != null && await t.update(r, { remoteId: n });
+					}
+				}
+			}
+			if (l.length > 0) {
+				let n = z();
+				S(l, n);
+				let i = B(n);
+				w += l.length - i;
+				let o = Ie(l, n), { applyActions: s, conflictsResolved: u } = await Be(o, await Le(t, a.namespace, a.entity, c, a.repoSync.lastPushedChangeId ?? null, [...new Set(o.map((e) => e.entityId))]), {
+					changeRepo: t,
+					conflictResolver: j,
+					dispatchEvent: (e) => r.dispatchEvent(e),
+					repoLabel: `${a.namespace}:${a.entity}`,
+					localClientId: r.context.clientId
+				});
+				O += u;
+				let d = B(s);
+				d > 0 && (await e.mergeChanges(s, void 0, !0), E += d);
+			}
+			let d = o.reduce((e, t) => t.id > e ? t.id : e, o[0].id);
+			a.repoSync = await n.update(a.repoSync, {
+				lastPullRemoteChangeId: d,
+				lastPulledAt: /* @__PURE__ */ new Date(),
+				updatedAt: /* @__PURE__ */ new Date()
+			}), o.length >= i && (k = !0);
+		}
+	}), {
+		pulled: C,
+		compacted: w,
+		applied: E,
+		hasMore: k,
+		conflictsResolved: O,
+		conflictsDeferred: 0,
+		persistedProgress: C > 0,
+		historyInvalidated: E > 0,
+		failures: []
+	};
+}
+//#endregion
+//#region src/pull.ts
+async function Yt(e, t) {
+	let n = e.rxdb;
+	if (!n.config.sync?.remote?.adapter) throw new p("Remote adapter not configured.");
+	n.dispatchEvent(new v("pull"));
+	try {
+		let r;
+		return t?.repositoryFilter?.length ? r = await Qt(e, t) : (r = await Gt(e, {
+			limit: t?.limit,
+			fetchAll: t?.fetchAll,
+			conflictResolver: t?.conflictResolver
+		}), await Xt(e, t, r)), n.dispatchEvent(new y("pull", r)), r;
+	} catch (e) {
+		throw n.dispatchEvent(new b("pull", e)), e;
+	}
+}
+async function Xt(e, t, n) {
+	let r = e.rxdb;
+	for (let i of r.config.entities) {
+		let a = T(i), o = N(a, r.config.sync);
+		if (o !== "filter" || !M(o).pull) continue;
+		let s = await C(e.rxdb, a.namespace, a.name);
+		if (!P(s)) continue;
+		let c;
+		try {
+			c = await Ze(e, a.namespace, a.name, {
+				limit: t?.limit,
+				fetchAll: t?.fetchAll,
+				conflictResolver: t?.conflictResolver,
+				includeRelated: !1
+			});
+		} catch (e) {
+			let t = e instanceof Error ? e : Error(String(e));
+			t instanceof m && Zt(n, t.result), n.failures.push({
+				repository: {
+					namespace: a.namespace,
+					entity: a.name
+				},
+				error: t instanceof m ? t.cause : t
+			});
+			continue;
+		}
+		Zt(n, c), n.failures.push(...c.failures);
+	}
+}
+function Zt(e, t) {
+	e.pulled += t.pulled, e.compacted += t.compacted, e.applied += t.applied, e.conflictsResolved += t.conflictsResolved, e.conflictsDeferred += t.conflictsDeferred, e.hasMore ||= t.hasMore, e.persistedProgress ||= t.persistedProgress, e.historyInvalidated ||= t.historyInvalidated;
+}
+async function Qt(e, t) {
+	let n = {
+		operation: "pull",
+		repositories: t.repositoryFilter?.map((e) => typeof e == "string" ? {
+			namespace: "public",
+			entity: e
+		} : e),
+		pull: {
+			limit: t.limit,
+			fetchAll: t.fetchAll,
+			conflictResolver: t.conflictResolver
+		}
+	}, r = await e.bulkSync(n), i = {
+		pulled: 0,
+		compacted: 0,
+		applied: 0,
+		hasMore: !1,
+		conflictsResolved: 0,
+		conflictsDeferred: 0,
+		persistedProgress: !1,
+		historyInvalidated: !1,
+		failures: []
+	};
+	for (let e of r.results) {
+		let t = e.result?.pullResult;
+		if (t && (i.pulled += t.pulled, i.compacted += t.compacted, i.applied += t.applied, i.conflictsResolved += t.conflictsResolved, i.conflictsDeferred += t.conflictsDeferred, i.hasMore ||= t.hasMore, i.persistedProgress ||= t.persistedProgress, i.historyInvalidated ||= t.historyInvalidated), e.success) continue;
+		let n = e.error ?? new p(`Repository pull failed: ${e.repository.namespace}:${e.repository.entity}`);
+		i.failures.push({
+			repository: e.repository,
+			error: n instanceof m ? n.cause : n
+		});
+	}
+	let [a] = i.failures;
+	if (a) throw !i.persistedProgress && i.failures.length === 1 ? a.error : new m(i, a.error);
+	return i;
+}
+//#endregion
+//#region src/branch-change-id.ts
+var $t = async (e, t, n) => (await e.find({
+	where: {
+		combinator: "and",
+		rules: [{
+			field: t,
+			operator: "=",
+			value: n
+		}]
+	},
+	limit: 1
+}))[0], en = async (e, t) => {
+	let n = await $t(e, "id", t);
+	if (!n) throw new p(`分支分叉点翻译失败：本地不存在 RxDBChange id=${t}，分支表与变更表已不一致`);
+	return n.remoteId ?? null;
+}, tn = async (e, t) => (await $t(e, "remoteId", t))?.id ?? null;
+//#endregion
+//#region src/push-branch.ts
+async function nn(e) {
+	let t = await e.getCurrentBranch();
+	if (!t || t.id === "main") return {
+		synced: 0,
+		skipped: t ? ["main"] : [],
+		forkPointPending: !1
+	};
+	let { adapter: n } = await e.getRemoteRepositories();
+	if (!n.pushBranches) return {
+		synced: 0,
+		skipped: [],
+		forkPointPending: !1
+	};
+	let { branchRepository: r, changeRepository: i } = await e.getLocalRepositories(), a = t.fromChangeId ?? null, o = a === null ? null : await en(i, a), s = a !== null && o === null, c = {
+		id: t.id,
+		fromChangeId: o,
+		local: t.local,
+		remote: !0,
+		parentId: t.parentId
+	}, l = await n.pushBranches([c]);
+	return l.synced > 0 && !t.remote && await r.update(t, {
+		remote: !0,
+		updatedAt: /* @__PURE__ */ new Date()
+	}), {
+		...l,
+		forkPointPending: s
+	};
+}
+//#endregion
+//#region src/push.ts
+async function rn(e, t) {
+	let n = e.rxdb;
+	if (!n.config.sync?.remote?.adapter) throw new p("Remote adapter not configured.");
+	n.dispatchEvent(new v("push"));
+	try {
+		let r = await nn(e), i = {
+			operation: "push",
+			repositories: t?.repositoryFilter?.map((e) => typeof e == "string" ? {
+				namespace: "public",
+				entity: e
+			} : e),
+			...t?.batchSize === void 0 ? {} : { push: { batchSize: t.batchSize } }
+		}, a = await e.bulkSync(i), o = {
+			pushed: 0,
+			failed: 0,
+			compacted: 0,
+			originalCount: 0,
+			failures: []
+		};
+		for (let e of a.results) {
+			let t = e.result?.pushResult;
+			if (t && (o.pushed += t.pushed, o.failed += t.failed, o.compacted += t.compacted, o.originalCount += t.originalCount), e.success) continue;
+			let n = e.error ?? new p(`Repository push failed: ${e.repository.namespace}:${e.repository.entity}`);
+			o.failures.push({
+				repository: e.repository,
+				error: n instanceof m ? n.cause : n
+			});
+		}
+		return r.forkPointPending && o.pushed > 0 && await nn(e), n.dispatchEvent(new y("push", o)), o;
+	} catch (e) {
+		throw n.dispatchEvent(new b("push", e)), e;
+	}
+}
+//#endregion
+//#region src/sync-branches.ts
+function an(e, t) {
+	let n = new Set(t), r = new Set(e.map((e) => e.id)), i = [], a = e;
+	for (; a.length > 0;) {
+		let e = a.filter((e) => {
+			let t = e.parentId ?? null;
+			return t === null || n.has(t);
+		});
+		if (e.length === 0) break;
+		for (let t of e) i.push(t), n.add(t.id);
+		a = a.filter((e) => !n.has(e.id));
+	}
+	if (a.length > 0) {
+		let e = a.map((e) => {
+			let t = e.parentId ?? null, n = t !== null && r.has(t) ? "cycle" : "missing parent";
+			return `'${e.id}' -> '${String(t)}' (${n})`;
+		}).join(", ");
+		throw new p(`syncBranches: 远端分支拓扑无法解析，整批放弃：${e}`);
+	}
+	return i;
+}
+async function on(e) {
+	let { adapter: t } = await e.getRemoteRepositories();
+	if (!t.pullBranches) return {
+		created: 0,
+		updated: 0,
+		total: 0,
+		skipped: []
+	};
+	let n = await t.pullBranches();
+	if (n.length === 0) return {
+		created: 0,
+		updated: 0,
+		total: 0,
+		skipped: []
+	};
+	let { adapter: r } = await e.getLocalRepositories();
+	return r.transaction(async (e) => {
+		let t = e.getRepository(u), r = e.getRepository(d), i = await t.find({ where: {
+			combinator: "and",
+			rules: []
+		} }), a = new Map(i.map((e) => [e.id, e])), o = 0, s = 0, c = [];
+		for (let e of an(n, new Set(a.keys()))) {
+			let n = a.get(e.id);
+			if (n) {
+				n.remote || (await t.update(n, {
+					remote: !0,
+					updatedAt: /* @__PURE__ */ new Date()
+				}), s++);
+				continue;
+			}
+			let i = e.fromChangeId ?? null, l = i === null ? null : await tn(r, i);
+			if (i !== null && l === null) {
+				c.push(e.id);
+				continue;
+			}
+			await t.create({
+				id: e.id,
+				activated: !1,
+				local: !1,
+				remote: !0,
+				fromChangeId: l,
+				parentId: e.parentId ?? null
+			}), o++;
+		}
+		return {
+			created: o,
+			updated: s,
+			total: n.length,
+			skipped: c
+		};
+	});
+}
+//#endregion
+//#region ../../node_modules/.pnpm/rxjs@7.8.2/node_modules/rxjs/dist/esm5/internal/util/isFunction.js
+function H(e) {
+	return typeof e == "function";
+}
+//#endregion
+//#region ../../node_modules/.pnpm/rxjs@7.8.2/node_modules/rxjs/dist/esm5/internal/util/lift.js
+function sn(e) {
+	return H(e?.lift);
+}
+function U(e) {
+	return function(t) {
+		if (sn(t)) return t.lift(function(t) {
+			try {
+				return e(t, this);
+			} catch (e) {
+				this.error(e);
+			}
+		});
+		throw TypeError("Unable to lift unknown Observable type");
+	};
+}
+//#endregion
+//#region ../../node_modules/.pnpm/tslib@2.8.1/node_modules/tslib/tslib.es6.mjs
+var cn = function(e, t) {
+	return cn = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(e, t) {
+		e.__proto__ = t;
+	} || function(e, t) {
+		for (var n in t) Object.prototype.hasOwnProperty.call(t, n) && (e[n] = t[n]);
+	}, cn(e, t);
+};
+function ln(e, t) {
+	if (typeof t != "function" && t !== null) throw TypeError("Class extends value " + String(t) + " is not a constructor or null");
+	cn(e, t);
+	function n() {
+		this.constructor = e;
+	}
+	e.prototype = t === null ? Object.create(t) : (n.prototype = t.prototype, new n());
+}
+function un(e, t, n, r) {
+	function i(e) {
+		return e instanceof n ? e : new n(function(t) {
+			t(e);
+		});
+	}
+	return new (n ||= Promise)(function(n, a) {
+		function o(e) {
+			try {
+				c(r.next(e));
+			} catch (e) {
+				a(e);
+			}
+		}
+		function s(e) {
+			try {
+				c(r.throw(e));
+			} catch (e) {
+				a(e);
+			}
+		}
+		function c(e) {
+			e.done ? n(e.value) : i(e.value).then(o, s);
+		}
+		c((r = r.apply(e, t || [])).next());
+	});
+}
+function dn(e, t) {
+	var n = {
+		label: 0,
+		sent: function() {
+			if (a[0] & 1) throw a[1];
+			return a[1];
+		},
+		trys: [],
+		ops: []
+	}, r, i, a, o = Object.create((typeof Iterator == "function" ? Iterator : Object).prototype);
+	return o.next = s(0), o.throw = s(1), o.return = s(2), typeof Symbol == "function" && (o[Symbol.iterator] = function() {
+		return this;
+	}), o;
+	function s(e) {
+		return function(t) {
+			return c([e, t]);
+		};
+	}
+	function c(s) {
+		if (r) throw TypeError("Generator is already executing.");
+		for (; o && (o = 0, s[0] && (n = 0)), n;) try {
+			if (r = 1, i && (a = s[0] & 2 ? i.return : s[0] ? i.throw || ((a = i.return) && a.call(i), 0) : i.next) && !(a = a.call(i, s[1])).done) return a;
+			switch (i = 0, a && (s = [s[0] & 2, a.value]), s[0]) {
+				case 0:
+				case 1:
+					a = s;
+					break;
+				case 4: return n.label++, {
+					value: s[1],
+					done: !1
+				};
+				case 5:
+					n.label++, i = s[1], s = [0];
+					continue;
+				case 7:
+					s = n.ops.pop(), n.trys.pop();
+					continue;
+				default:
+					if (a = n.trys, !(a = a.length > 0 && a[a.length - 1]) && (s[0] === 6 || s[0] === 2)) {
+						n = 0;
+						continue;
+					}
+					if (s[0] === 3 && (!a || s[1] > a[0] && s[1] < a[3])) {
+						n.label = s[1];
+						break;
+					}
+					if (s[0] === 6 && n.label < a[1]) {
+						n.label = a[1], a = s;
+						break;
+					}
+					if (a && n.label < a[2]) {
+						n.label = a[2], n.ops.push(s);
+						break;
+					}
+					a[2] && n.ops.pop(), n.trys.pop();
+					continue;
+			}
+			s = t.call(e, n);
+		} catch (e) {
+			s = [6, e], i = 0;
+		} finally {
+			r = a = 0;
+		}
+		if (s[0] & 5) throw s[1];
+		return {
+			value: s[0] ? s[1] : void 0,
+			done: !0
+		};
+	}
+}
+function W(e) {
+	var t = typeof Symbol == "function" && Symbol.iterator, n = t && e[t], r = 0;
+	if (n) return n.call(e);
+	if (e && typeof e.length == "number") return { next: function() {
+		return e && r >= e.length && (e = void 0), {
+			value: e && e[r++],
+			done: !e
+		};
+	} };
+	throw TypeError(t ? "Object is not iterable." : "Symbol.iterator is not defined.");
+}
+function G(e, t) {
+	var n = typeof Symbol == "function" && e[Symbol.iterator];
+	if (!n) return e;
+	var r = n.call(e), i, a = [], o;
+	try {
+		for (; (t === void 0 || t-- > 0) && !(i = r.next()).done;) a.push(i.value);
+	} catch (e) {
+		o = { error: e };
+	} finally {
+		try {
+			i && !i.done && (n = r.return) && n.call(r);
+		} finally {
+			if (o) throw o.error;
+		}
+	}
+	return a;
+}
+function K(e, t, n) {
+	if (n || arguments.length === 2) for (var r = 0, i = t.length, a; r < i; r++) (a || !(r in t)) && (a ||= Array.prototype.slice.call(t, 0, r), a[r] = t[r]);
+	return e.concat(a || Array.prototype.slice.call(t));
+}
+function q(e) {
+	return this instanceof q ? (this.v = e, this) : new q(e);
+}
+function fn(e, t, n) {
+	if (!Symbol.asyncIterator) throw TypeError("Symbol.asyncIterator is not defined.");
+	var r = n.apply(e, t || []), i, a = [];
+	return i = Object.create((typeof AsyncIterator == "function" ? AsyncIterator : Object).prototype), s("next"), s("throw"), s("return", o), i[Symbol.asyncIterator] = function() {
+		return this;
+	}, i;
+	function o(e) {
+		return function(t) {
+			return Promise.resolve(t).then(e, d);
+		};
+	}
+	function s(e, t) {
+		r[e] && (i[e] = function(t) {
+			return new Promise(function(n, r) {
+				a.push([
+					e,
+					t,
+					n,
+					r
+				]) > 1 || c(e, t);
+			});
+		}, t && (i[e] = t(i[e])));
+	}
+	function c(e, t) {
+		try {
+			l(r[e](t));
+		} catch (e) {
+			f(a[0][3], e);
+		}
+	}
+	function l(e) {
+		e.value instanceof q ? Promise.resolve(e.value.v).then(u, d) : f(a[0][2], e);
+	}
+	function u(e) {
+		c("next", e);
+	}
+	function d(e) {
+		c("throw", e);
+	}
+	function f(e, t) {
+		e(t), a.shift(), a.length && c(a[0][0], a[0][1]);
+	}
+}
+function pn(e) {
+	if (!Symbol.asyncIterator) throw TypeError("Symbol.asyncIterator is not defined.");
+	var t = e[Symbol.asyncIterator], n;
+	return t ? t.call(e) : (e = typeof W == "function" ? W(e) : e[Symbol.iterator](), n = {}, r("next"), r("throw"), r("return"), n[Symbol.asyncIterator] = function() {
+		return this;
+	}, n);
+	function r(t) {
+		n[t] = e[t] && function(n) {
+			return new Promise(function(r, a) {
+				n = e[t](n), i(r, a, n.done, n.value);
+			});
+		};
+	}
+	function i(e, t, n, r) {
+		Promise.resolve(r).then(function(t) {
+			e({
+				value: t,
+				done: n
+			});
+		}, t);
+	}
+}
+//#endregion
+//#region ../../node_modules/.pnpm/rxjs@7.8.2/node_modules/rxjs/dist/esm5/internal/util/isArrayLike.js
+var mn = (function(e) {
+	return e && typeof e.length == "number" && typeof e != "function";
+});
+//#endregion
+//#region ../../node_modules/.pnpm/rxjs@7.8.2/node_modules/rxjs/dist/esm5/internal/util/isPromise.js
+function hn(e) {
+	return H(e?.then);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/rxjs@7.8.2/node_modules/rxjs/dist/esm5/internal/util/createErrorClass.js
+function gn(e) {
+	var t = e(function(e) {
+		Error.call(e), e.stack = (/* @__PURE__ */ Error()).stack;
+	});
+	return t.prototype = Object.create(Error.prototype), t.prototype.constructor = t, t;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/rxjs@7.8.2/node_modules/rxjs/dist/esm5/internal/util/UnsubscriptionError.js
+var _n = gn(function(e) {
+	return function(t) {
+		e(this), this.message = t ? t.length + " errors occurred during unsubscription:\n" + t.map(function(e, t) {
+			return t + 1 + ") " + e.toString();
+		}).join("\n  ") : "", this.name = "UnsubscriptionError", this.errors = t;
+	};
+});
+//#endregion
+//#region ../../node_modules/.pnpm/rxjs@7.8.2/node_modules/rxjs/dist/esm5/internal/util/arrRemove.js
+function vn(e, t) {
+	if (e) {
+		var n = e.indexOf(t);
+		0 <= n && e.splice(n, 1);
+	}
+}
+//#endregion
+//#region ../../node_modules/.pnpm/rxjs@7.8.2/node_modules/rxjs/dist/esm5/internal/Subscription.js
+var yn = function() {
+	function e(e) {
+		this.initialTeardown = e, this.closed = !1, this._parentage = null, this._finalizers = null;
+	}
+	return e.prototype.unsubscribe = function() {
+		var e, t, n, r, i;
+		if (!this.closed) {
+			this.closed = !0;
+			var a = this._parentage;
+			if (a) {
+				if (this._parentage = null, Array.isArray(a)) try {
+					for (var o = W(a), s = o.next(); !s.done; s = o.next()) s.value.remove(this);
+				} catch (t) {
+					e = { error: t };
+				} finally {
+					try {
+						s && !s.done && (t = o.return) && t.call(o);
+					} finally {
+						if (e) throw e.error;
+					}
+				}
+				else a.remove(this);
+			}
+			var c = this.initialTeardown;
+			if (H(c)) try {
+				c();
+			} catch (e) {
+				i = e instanceof _n ? e.errors : [e];
+			}
+			var l = this._finalizers;
+			if (l) {
+				this._finalizers = null;
+				try {
+					for (var u = W(l), d = u.next(); !d.done; d = u.next()) {
+						var f = d.value;
+						try {
+							xn(f);
+						} catch (e) {
+							i ??= [], e instanceof _n ? i = K(K([], G(i)), G(e.errors)) : i.push(e);
+						}
+					}
+				} catch (e) {
+					n = { error: e };
+				} finally {
+					try {
+						d && !d.done && (r = u.return) && r.call(u);
+					} finally {
+						if (n) throw n.error;
+					}
+				}
+			}
+			if (i) throw new _n(i);
+		}
+	}, e.prototype.add = function(t) {
+		if (t && t !== this) {
+			if (this.closed) xn(t);
+			else {
+				if (t instanceof e) {
+					if (t.closed || t._hasParent(this)) return;
+					t._addParent(this);
+				}
+				(this._finalizers = this._finalizers ?? []).push(t);
+			}
+		}
+	}, e.prototype._hasParent = function(e) {
+		var t = this._parentage;
+		return t === e || Array.isArray(t) && t.includes(e);
+	}, e.prototype._addParent = function(e) {
+		var t = this._parentage;
+		this._parentage = Array.isArray(t) ? (t.push(e), t) : t ? [t, e] : e;
+	}, e.prototype._removeParent = function(e) {
+		var t = this._parentage;
+		t === e ? this._parentage = null : Array.isArray(t) && vn(t, e);
+	}, e.prototype.remove = function(t) {
+		var n = this._finalizers;
+		n && vn(n, t), t instanceof e && t._removeParent(this);
+	}, e.EMPTY = (function() {
+		var t = new e();
+		return t.closed = !0, t;
+	})(), e;
+}();
+yn.EMPTY;
+function bn(e) {
+	return e instanceof yn || e && "closed" in e && H(e.remove) && H(e.add) && H(e.unsubscribe);
+}
+function xn(e) {
+	H(e) ? e() : e.unsubscribe();
+}
+//#endregion
+//#region ../../node_modules/.pnpm/rxjs@7.8.2/node_modules/rxjs/dist/esm5/internal/config.js
+var J = {
+	onUnhandledError: null,
+	onStoppedNotification: null,
+	Promise: void 0,
+	useDeprecatedSynchronousErrorHandling: !1,
+	useDeprecatedNextContext: !1
+}, Y = {
+	setTimeout: function(e, t) {
+		var n = [...arguments].slice(2), r = Y.delegate;
+		return r?.setTimeout ? r.setTimeout.apply(r, K([e, t], G(n))) : setTimeout.apply(void 0, K([e, t], G(n)));
+	},
+	clearTimeout: function(e) {
+		return (Y.delegate?.clearTimeout || clearTimeout)(e);
+	},
+	delegate: void 0
+};
+//#endregion
+//#region ../../node_modules/.pnpm/rxjs@7.8.2/node_modules/rxjs/dist/esm5/internal/util/reportUnhandledError.js
+function Sn(e) {
+	Y.setTimeout(function() {
+		var t = J.onUnhandledError;
+		if (t) t(e);
+		else throw e;
+	});
+}
+//#endregion
+//#region ../../node_modules/.pnpm/rxjs@7.8.2/node_modules/rxjs/dist/esm5/internal/util/noop.js
+function Cn() {}
+//#endregion
+//#region ../../node_modules/.pnpm/rxjs@7.8.2/node_modules/rxjs/dist/esm5/internal/NotificationFactories.js
+var wn = (function() {
+	return Dn("C", void 0, void 0);
+})();
+function Tn(e) {
+	return Dn("E", void 0, e);
+}
+function En(e) {
+	return Dn("N", e, void 0);
+}
+function Dn(e, t, n) {
+	return {
+		kind: e,
+		value: t,
+		error: n
+	};
+}
+//#endregion
+//#region ../../node_modules/.pnpm/rxjs@7.8.2/node_modules/rxjs/dist/esm5/internal/util/errorContext.js
+var X = null;
+function On(e) {
+	if (J.useDeprecatedSynchronousErrorHandling) {
+		var t = !X;
+		if (t && (X = {
+			errorThrown: !1,
+			error: null
+		}), e(), t) {
+			var n = X, r = n.errorThrown, i = n.error;
+			if (X = null, r) throw i;
+		}
+	} else e();
+}
+function kn(e) {
+	J.useDeprecatedSynchronousErrorHandling && X && (X.errorThrown = !0, X.error = e);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/rxjs@7.8.2/node_modules/rxjs/dist/esm5/internal/Subscriber.js
+var An = function(e) {
+	ln(t, e);
+	function t(t) {
+		var n = e.call(this) || this;
+		return n.isStopped = !1, t ? (n.destination = t, bn(t) && t.add(n)) : n.destination = Ln, n;
+	}
+	return t.create = function(e, t, n) {
+		return new Pn(e, t, n);
+	}, t.prototype.next = function(e) {
+		this.isStopped ? In(En(e), this) : this._next(e);
+	}, t.prototype.error = function(e) {
+		this.isStopped ? In(Tn(e), this) : (this.isStopped = !0, this._error(e));
+	}, t.prototype.complete = function() {
+		this.isStopped ? In(wn, this) : (this.isStopped = !0, this._complete());
+	}, t.prototype.unsubscribe = function() {
+		this.closed || (this.isStopped = !0, e.prototype.unsubscribe.call(this), this.destination = null);
+	}, t.prototype._next = function(e) {
+		this.destination.next(e);
+	}, t.prototype._error = function(e) {
+		try {
+			this.destination.error(e);
+		} finally {
+			this.unsubscribe();
+		}
+	}, t.prototype._complete = function() {
+		try {
+			this.destination.complete();
+		} finally {
+			this.unsubscribe();
+		}
+	}, t;
+}(yn), jn = Function.prototype.bind;
+function Mn(e, t) {
+	return jn.call(e, t);
+}
+var Nn = function() {
+	function e(e) {
+		this.partialObserver = e;
+	}
+	return e.prototype.next = function(e) {
+		var t = this.partialObserver;
+		if (t.next) try {
+			t.next(e);
+		} catch (e) {
+			Z(e);
+		}
+	}, e.prototype.error = function(e) {
+		var t = this.partialObserver;
+		if (t.error) try {
+			t.error(e);
+		} catch (e) {
+			Z(e);
+		}
+		else Z(e);
+	}, e.prototype.complete = function() {
+		var e = this.partialObserver;
+		if (e.complete) try {
+			e.complete();
+		} catch (e) {
+			Z(e);
+		}
+	}, e;
+}(), Pn = function(e) {
+	ln(t, e);
+	function t(t, n, r) {
+		var i = e.call(this) || this, a;
+		if (H(t) || !t) a = {
+			next: t ?? void 0,
+			error: n ?? void 0,
+			complete: r ?? void 0
+		};
+		else {
+			var o;
+			i && J.useDeprecatedNextContext ? (o = Object.create(t), o.unsubscribe = function() {
+				return i.unsubscribe();
+			}, a = {
+				next: t.next && Mn(t.next, o),
+				error: t.error && Mn(t.error, o),
+				complete: t.complete && Mn(t.complete, o)
+			}) : a = t;
+		}
+		return i.destination = new Nn(a), i;
+	}
+	return t;
+}(An);
+function Z(e) {
+	J.useDeprecatedSynchronousErrorHandling ? kn(e) : Sn(e);
+}
+function Fn(e) {
+	throw e;
+}
+function In(e, t) {
+	var n = J.onStoppedNotification;
+	n && Y.setTimeout(function() {
+		return n(e, t);
+	});
+}
+var Ln = {
+	closed: !0,
+	next: Cn,
+	error: Fn,
+	complete: Cn
+}, Rn = (function() {
+	return typeof Symbol == "function" && Symbol.observable || "@@observable";
+})();
+//#endregion
+//#region ../../node_modules/.pnpm/rxjs@7.8.2/node_modules/rxjs/dist/esm5/internal/util/identity.js
+function zn(e) {
+	return e;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/rxjs@7.8.2/node_modules/rxjs/dist/esm5/internal/util/pipe.js
+function Bn(e) {
+	return e.length === 0 ? zn : e.length === 1 ? e[0] : function(t) {
+		return e.reduce(function(e, t) {
+			return t(e);
+		}, t);
+	};
+}
+//#endregion
+//#region ../../node_modules/.pnpm/rxjs@7.8.2/node_modules/rxjs/dist/esm5/internal/Observable.js
+var Q = function() {
+	function e(e) {
+		e && (this._subscribe = e);
+	}
+	return e.prototype.lift = function(t) {
+		var n = new e();
+		return n.source = this, n.operator = t, n;
+	}, e.prototype.subscribe = function(e, t, n) {
+		var r = this, i = Un(e) ? e : new Pn(e, t, n);
+		return On(function() {
+			var e = r, t = e.operator, n = e.source;
+			i.add(t ? t.call(i, n) : n ? r._subscribe(i) : r._trySubscribe(i));
+		}), i;
+	}, e.prototype._trySubscribe = function(e) {
+		try {
+			return this._subscribe(e);
+		} catch (t) {
+			e.error(t);
+		}
+	}, e.prototype.forEach = function(e, t) {
+		var n = this;
+		return t = Vn(t), new t(function(t, r) {
+			var i = new Pn({
+				next: function(t) {
+					try {
+						e(t);
+					} catch (e) {
+						r(e), i.unsubscribe();
+					}
+				},
+				error: r,
+				complete: t
+			});
+			n.subscribe(i);
+		});
+	}, e.prototype._subscribe = function(e) {
+		return this.source?.subscribe(e);
+	}, e.prototype[Rn] = function() {
+		return this;
+	}, e.prototype.pipe = function() {
+		return Bn([...arguments])(this);
+	}, e.prototype.toPromise = function(e) {
+		var t = this;
+		return e = Vn(e), new e(function(e, n) {
+			var r;
+			t.subscribe(function(e) {
+				return r = e;
+			}, function(e) {
+				return n(e);
+			}, function() {
+				return e(r);
+			});
+		});
+	}, e.create = function(t) {
+		return new e(t);
+	}, e;
+}();
+function Vn(e) {
+	return e ?? J.Promise ?? Promise;
+}
+function Hn(e) {
+	return e && H(e.next) && H(e.error) && H(e.complete);
+}
+function Un(e) {
+	return e && e instanceof An || Hn(e) && bn(e);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/rxjs@7.8.2/node_modules/rxjs/dist/esm5/internal/util/isInteropObservable.js
+function Wn(e) {
+	return H(e[Rn]);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/rxjs@7.8.2/node_modules/rxjs/dist/esm5/internal/util/isAsyncIterable.js
+function Gn(e) {
+	return Symbol.asyncIterator && H(e?.[Symbol.asyncIterator]);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/rxjs@7.8.2/node_modules/rxjs/dist/esm5/internal/util/throwUnobservableError.js
+function Kn(e) {
+	return /* @__PURE__ */ TypeError("You provided " + (typeof e == "object" && e ? "an invalid object" : "'" + e + "'") + " where a stream was expected. You can provide an Observable, Promise, ReadableStream, Array, AsyncIterable, or Iterable.");
+}
+//#endregion
+//#region ../../node_modules/.pnpm/rxjs@7.8.2/node_modules/rxjs/dist/esm5/internal/symbol/iterator.js
+function qn() {
+	return typeof Symbol != "function" || !Symbol.iterator ? "@@iterator" : Symbol.iterator;
+}
+var Jn = qn();
+//#endregion
+//#region ../../node_modules/.pnpm/rxjs@7.8.2/node_modules/rxjs/dist/esm5/internal/util/isIterable.js
+function Yn(e) {
+	return H(e?.[Jn]);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/rxjs@7.8.2/node_modules/rxjs/dist/esm5/internal/util/isReadableStreamLike.js
+function Xn(e) {
+	return fn(this, arguments, function() {
+		var t, n, r, i;
+		return dn(this, function(a) {
+			switch (a.label) {
+				case 0: t = e.getReader(), a.label = 1;
+				case 1: a.trys.push([
+					1,
+					,
+					9,
+					10
+				]), a.label = 2;
+				case 2: return [4, q(t.read())];
+				case 3: return n = a.sent(), r = n.value, i = n.done, i ? [4, q(void 0)] : [3, 5];
+				case 4: return [2, a.sent()];
+				case 5: return [4, q(r)];
+				case 6: return [4, a.sent()];
+				case 7: return a.sent(), [3, 2];
+				case 8: return [3, 10];
+				case 9: return t.releaseLock(), [7];
+				case 10: return [2];
+			}
+		});
+	});
+}
+function Zn(e) {
+	return H(e?.getReader);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/rxjs@7.8.2/node_modules/rxjs/dist/esm5/internal/observable/innerFrom.js
+function Qn(e) {
+	if (e instanceof Q) return e;
+	if (e != null) {
+		if (Wn(e)) return $n(e);
+		if (mn(e)) return er(e);
+		if (hn(e)) return tr(e);
+		if (Gn(e)) return rr(e);
+		if (Yn(e)) return nr(e);
+		if (Zn(e)) return ir(e);
+	}
+	throw Kn(e);
+}
+function $n(e) {
+	return new Q(function(t) {
+		var n = e[Rn]();
+		if (H(n.subscribe)) return n.subscribe(t);
+		throw TypeError("Provided object does not correctly implement Symbol.observable");
+	});
+}
+function er(e) {
+	return new Q(function(t) {
+		for (var n = 0; n < e.length && !t.closed; n++) t.next(e[n]);
+		t.complete();
+	});
+}
+function tr(e) {
+	return new Q(function(t) {
+		e.then(function(e) {
+			t.closed || (t.next(e), t.complete());
+		}, function(e) {
+			return t.error(e);
+		}).then(null, Sn);
+	});
+}
+function nr(e) {
+	return new Q(function(t) {
+		var n, r;
+		try {
+			for (var i = W(e), a = i.next(); !a.done; a = i.next()) {
+				var o = a.value;
+				if (t.next(o), t.closed) return;
+			}
+		} catch (e) {
+			n = { error: e };
+		} finally {
+			try {
+				a && !a.done && (r = i.return) && r.call(i);
+			} finally {
+				if (n) throw n.error;
+			}
+		}
+		t.complete();
+	});
+}
+function rr(e) {
+	return new Q(function(t) {
+		ar(e, t).catch(function(e) {
+			return t.error(e);
+		});
+	});
+}
+function ir(e) {
+	return rr(Xn(e));
+}
+function ar(e, t) {
+	var n, r, i, a;
+	return un(this, void 0, void 0, function() {
+		var o, s;
+		return dn(this, function(c) {
+			switch (c.label) {
+				case 0: c.trys.push([
+					0,
+					5,
+					6,
+					11
+				]), n = pn(e), c.label = 1;
+				case 1: return [4, n.next()];
+				case 2:
+					if (r = c.sent(), r.done) return [3, 4];
+					if (o = r.value, t.next(o), t.closed) return [2];
+					c.label = 3;
+				case 3: return [3, 1];
+				case 4: return [3, 11];
+				case 5: return s = c.sent(), i = { error: s }, [3, 11];
+				case 6: return c.trys.push([
+					6,
+					,
+					9,
+					10
+				]), r && !r.done && (a = n.return) ? [4, a.call(n)] : [3, 8];
+				case 7: c.sent(), c.label = 8;
+				case 8: return [3, 10];
+				case 9:
+					if (i) throw i.error;
+					return [7];
+				case 10: return [7];
+				case 11: return t.complete(), [2];
+			}
+		});
+	});
+}
+//#endregion
+//#region ../../node_modules/.pnpm/rxjs@7.8.2/node_modules/rxjs/dist/esm5/internal/operators/OperatorSubscriber.js
+function $(e, t, n, r, i) {
+	return new or(e, t, n, r, i);
+}
+var or = function(e) {
+	ln(t, e);
+	function t(t, n, r, i, a, o) {
+		var s = e.call(this, t) || this;
+		return s.onFinalize = a, s.shouldUnsubscribe = o, s._next = n ? function(e) {
+			try {
+				n(e);
+			} catch (e) {
+				t.error(e);
+			}
+		} : e.prototype._next, s._error = i ? function(e) {
+			try {
+				i(e);
+			} catch (e) {
+				t.error(e);
+			} finally {
+				this.unsubscribe();
+			}
+		} : e.prototype._error, s._complete = r ? function() {
+			try {
+				r();
+			} catch (e) {
+				t.error(e);
+			} finally {
+				this.unsubscribe();
+			}
+		} : e.prototype._complete, s;
+	}
+	return t.prototype.unsubscribe = function() {
+		var t;
+		if (!this.shouldUnsubscribe || this.shouldUnsubscribe()) {
+			var n = this.closed;
+			e.prototype.unsubscribe.call(this), !n && ((t = this.onFinalize) == null || t.call(this));
+		}
+	}, t;
+}(An);
+//#endregion
+//#region ../../node_modules/.pnpm/rxjs@7.8.2/node_modules/rxjs/dist/esm5/internal/util/args.js
+function sr(e) {
+	return e[e.length - 1];
+}
+function cr(e) {
+	return H(sr(e)) ? e.pop() : void 0;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/rxjs@7.8.2/node_modules/rxjs/dist/esm5/internal/operators/map.js
+function lr(e, t) {
+	return U(function(n, r) {
+		var i = 0;
+		n.subscribe($(r, function(n) {
+			r.next(e.call(t, n, i++));
+		}));
+	});
+}
+//#endregion
+//#region ../../node_modules/.pnpm/rxjs@7.8.2/node_modules/rxjs/dist/esm5/internal/operators/distinctUntilChanged.js
+function ur(e, t) {
+	return t === void 0 && (t = zn), e ??= dr, U(function(n, r) {
+		var i, a = !0;
+		n.subscribe($(r, function(n) {
+			var o = t(n);
+			(a || !e(i, o)) && (a = !1, i = o, r.next(n));
+		}));
+	});
+}
+function dr(e, t) {
+	return e === t;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/rxjs@7.8.2/node_modules/rxjs/dist/esm5/internal/operators/filter.js
+function fr(e, t) {
+	return U(function(n, r) {
+		var i = 0;
+		n.subscribe($(r, function(n) {
+			return e.call(t, n, i++) && r.next(n);
+		}));
+	});
+}
+//#endregion
+//#region ../../node_modules/.pnpm/rxjs@7.8.2/node_modules/rxjs/dist/esm5/internal/operators/exhaustMap.js
+function pr(e, t) {
+	return t ? function(n) {
+		return n.pipe(pr(function(n, r) {
+			return Qn(e(n, r)).pipe(lr(function(e, i) {
+				return t(n, e, r, i);
+			}));
+		}));
+	} : U(function(t, n) {
+		var r = 0, i = null, a = !1;
+		t.subscribe($(n, function(t) {
+			i || (i = $(n, void 0, function() {
+				i = null, a && n.complete();
+			}), Qn(e(t, r++)).subscribe(i));
+		}, function() {
+			a = !0, !i && n.complete();
+		}));
+	});
+}
+//#endregion
+//#region ../../node_modules/.pnpm/rxjs@7.8.2/node_modules/rxjs/dist/esm5/internal/operators/withLatestFrom.js
+function mr() {
+	var e = [...arguments], t = cr(e);
+	return U(function(n, r) {
+		for (var i = e.length, a = Array(i), o = e.map(function() {
+			return !1;
+		}), s = !1, c = function(t) {
+			Qn(e[t]).subscribe($(r, function(e) {
+				a[t] = e, !s && !o[t] && (o[t] = !0, (s = o.every(zn)) && (o = null));
+			}, Cn));
+		}, l = 0; l < i; l++) c(l);
+		n.subscribe($(r, function(e) {
+			if (s) {
+				var n = K([e], G(a));
+				r.next(t ? t.apply(void 0, K([], G(n))) : n);
+			}
+		}));
+	});
+}
+//#endregion
+//#region src/sync-listeners.ts
+async function hr(e, t) {
+	try {
+		return await t(), !0;
+	} catch (t) {
+		return e.reportError(t), !1;
+	}
+}
+function gr(e) {
+	return e.rxdb.config.entities.filter((e) => !ee(e));
+}
+function _r(e) {
+	let t = [];
+	for (let n of gr(e)) {
+		let r = T(n), i = M(N(r, e.rxdb.config.sync));
+		i.offlineWrite && !i.push && t.push({
+			namespace: r.namespace,
+			entity: r.name
+		});
+	}
+	return t;
+}
+async function vr(e, t, n) {
+	let { syncState: r } = e.rxdb, i = await fe(e.rxdb, t, n);
+	for (let e of i.conflicts) r.reportConflict({
+		namespace: t,
+		entity: n,
+		entityId: e,
+		winner: "remote"
+	});
+}
+async function yr(e, t) {
+	let { syncState: n } = e.rxdb, r = !0;
+	for (let { namespace: i, entity: a } of t) r = await hr(n, () => vr(e, i, a)) && r;
+	return r;
+}
+async function br(e) {
+	try {
+		e.rxdb.syncState.reportOutboxCount(await ge(e.rxdb));
+	} catch {}
+}
+async function xr(e) {
+	let t = _r(e);
+	if (t.length === 0) return;
+	let { syncState: n } = e.rxdb;
+	n.beginRound();
+	try {
+		await yr(e, t) && n.reportSuccess(), await br(e);
+	} finally {
+		n.endRound();
+	}
+}
+function Sr(e) {
+	let t = e.rxdb.connected$, n = ae([t, e.rxdb.reachability.online$]).pipe(lr(([e, t]) => e && t), ur());
+	return oe(n.pipe(fr((e) => e)), e.rxdb.reachability.wakeup$.pipe(mr(t), fr(([, e]) => e)));
+}
+function Cr(e) {
+	let t = [], a = [];
+	if (e.rxdb.config.sync?.remote?.adapter) {
+		let n = Sr(e).pipe(pr(() => xr(e).catch((t) => {
+			e.rxdb.syncState.reportError(t);
+		}))).subscribe();
+		t.push(n);
+	}
+	let o = async (t) => {
+		let n = await e.getCurrentBranch();
+		return t.filter((e) => !e.branchId || e.branchId === n.id).length;
+	}, s = (t) => (n) => {
+		(async () => {
+			try {
+				let t = await o(n.entities);
+				t > 0 && e.history.incrementPullableCount(t);
+			} catch (e) {
+				se(e) || console.error(`[SyncManager] ${t} failed:`, e);
+			}
+		})();
+	}, c = [
+		{
+			type: n,
+			handler: s("onRemoteCreate")
+		},
+		{
+			type: i,
+			handler: s("onRemoteUpdate")
+		},
+		{
+			type: r,
+			handler: s("onRemoteRemove")
+		}
+	];
+	for (let { type: t, handler: n } of c) e.rxdb.addEventListener(t, n), a.push(() => e.rxdb.removeEventListener(t, n));
+	return {
+		subscriptions: t,
+		removers: a
+	};
+}
+//#endregion
+//#region src/sync-manager.utils.ts
+var wr = (e) => e?.historyInvalidated === !0 || (e?.pushResult?.pushed ?? 0) > 0, Tr = (e) => e instanceof m && wr(e.result), Er = (e) => e instanceof m ? e.result : void 0, Dr = class {
+	rxdb;
+	history;
+	#e = [];
+	#t = [];
+	get pushInFlight() {
+		return this.history.pushInFlight;
+	}
+	constructor(e, t) {
+		this.rxdb = e, this.history = t;
+	}
+	init() {
+		let { subscriptions: e, removers: t } = Cr(this);
+		this.#t.push(...e), this.#e.push(...t);
+	}
+	destroy() {
+		for (let e of this.#e) e();
+		this.#e.length = 0;
+		for (let e of this.#t) e.unsubscribe();
+		this.#t.length = 0;
+	}
+	async getLocalRepositories() {
+		return E(this.rxdb);
+	}
+	async getRemoteRepositories() {
+		return O(this.rxdb);
+	}
+	async getCurrentBranch() {
+		return w(this.rxdb);
+	}
+	async syncBranches() {
+		return on(this);
+	}
+	async pull(e) {
+		let t;
+		try {
+			t = await this.history.syncing(() => this.#n(e));
+		} catch (e) {
+			throw Tr(e) && this.history.clearUndoHistory(), e;
+		}
+		return t.historyInvalidated && this.history.clearUndoHistory(), t;
+	}
+	async push(e) {
+		let t = await this.history.syncing(() => rn(this, e));
+		return t.pushed > 0 && this.history.clearUndoHistory(), t;
+	}
+	async sync(e) {
+		let t, n;
+		try {
+			n = await this.history.syncing(async () => {
+				t = await this.#n(e?.pull);
+				let n = await rn(this, e?.push);
+				return {
+					pullResult: t,
+					pushResult: n
+				};
+			});
+		} catch (e) {
+			throw (t?.historyInvalidated === !0 || Tr(e)) && this.history.clearUndoHistory(), e;
+		}
+		return (n.pullResult.historyInvalidated || n.pushResult.pushed > 0) && this.history.clearUndoHistory(), n;
+	}
+	async pullRepository(e, t, n) {
+		let r;
+		try {
+			r = await this.history.syncing(() => Ze(this, e, t, n));
+		} catch (e) {
+			throw Tr(e) && this.history.clearUndoHistory(), e;
+		}
+		return r.historyInvalidated && this.history.clearUndoHistory(), r;
+	}
+	async pushRepository(e, t, n) {
+		let r = await this.history.syncing(() => st(this, e, t, n));
+		return r.pushed > 0 && this.history.clearUndoHistory(), r;
+	}
+	async syncRepository(e, t, n) {
+		let r;
+		try {
+			r = await this.history.syncing(() => kt(this, e, t, n));
+		} catch (e) {
+			throw Tr(e) && this.history.clearUndoHistory(), e;
+		}
+		return (r.pullResult.historyInvalidated || r.pushResult.pushed > 0) && this.history.clearUndoHistory(), r;
+	}
+	async cleanupExpired(e, t, n) {
+		return Lt(this, e, t, n);
+	}
+	async checkRepositoryUpdates(e, t) {
+		return It(this.rxdb, e, t);
+	}
+	async getRepositorySyncStatus(e, t) {
+		return Ht(this.rxdb, e, t);
+	}
+	async getAllRepositorySyncStatus(e) {
+		return Ut(this.rxdb, e);
+	}
+	async refreshPullableCount() {
+		let e = this.history.beginPullableSettlement(), t = (await Ut(this.rxdb)).reduce((e, t) => e + (t.enabled ? t.pullableCount : 0), 0);
+		return this.history.reconcilePullableCount(e, t), t;
+	}
+	async bulkSync(e) {
+		let t = await this.history.syncing(() => Ft(this.rxdb, e));
+		return t.results.some((e) => wr(e.result) || wr(Er(e.error))) && this.history.clearUndoHistory(), t;
+	}
+	getRepositoryDependencyGraph() {
+		return R(this.rxdb.config.entities.map((e) => T(e)));
+	}
+	getRepositorySyncOrder(e) {
+		return We(this.getRepositoryDependencyGraph(), e);
+	}
+	async #n(e) {
+		let t = this.history.beginPullableSettlement(), n;
+		try {
+			n = await Yt(this, e);
+		} catch (e) {
+			let n = e instanceof m ? e.result : void 0;
+			throw this.history.settleAbortedPull(t, n ? n.pulled : 0), e;
+		}
+		return this.history.settlePull(t, e, n), n;
+	}
+}, Or = class extends h {
+	lifecycle = "scoped";
+	inject = ["plugin:history"];
+	name = "sync";
+	install(e) {
+		let t = new Dr(this.rxdb, this.rxdb.versionManager.syncBridge);
+		e.acquire(() => () => t.destroy(), "sync:syncManager"), e.acquire(() => (Object.defineProperty(this.rxdb, "syncManager", {
+			value: t,
+			configurable: !0,
+			enumerable: !0
+		}), () => void Reflect.deleteProperty(this.rxdb, "syncManager")), "sync:slot"), this.rxdb.queryCacheOutbox({ pendingWriteIds: (e, t) => _e(this.rxdb, e, t) }, e), e.acquire(() => this.rxdb.reachability.watch(), "sync:reachability"), t.init(), e.acquire(() => this.rxdb.syncState.bindPullableRefresh(() => {
+			t.refreshPullableCount().catch((e) => {
+				let t = e instanceof Error ? e.message : String(e);
+				console.warn(`[RxDB Sync] 重算待拉数失败：${t}。`);
+			});
+		}), "sync:pullableRefresh");
+	}
+}, kr = (e) => new Or(e);
+//#endregion
+export { Or as RxDBPluginSync, Lt as cleanupExpired, ge as countQueryCacheOutbox, fe as flushQueryCacheOutbox, _e as pendingQueryCacheWriteIds, kr as rxDBPluginSync, on as syncBranches };