@dialecte/core 0.7.0 → 0.8.0

package/dist/in-process-link-DBeAOZRp.js

@@ -0,0 +1,2791 @@
+import { S as e, T as t, _ as n, a as r, b as i, c as a, d as o, f as s, g as c, h as l, i as u, l as d, m as f, n as p, o as m, p as h, r as ee, s as g, t as _, u as v, v as y, w as b, x, y as S } from "./engine.constants-DBMjMmV9.js";
+import { A as C, E as w, G as T, K as E, M as D, P as te, S as ne, T as re, U as O, V as k, W as A, _ as j, a as ie, b as ae, h as oe, i as se, j as ce, k as le, n as ue, p as de, r as fe, w as M, x as N, y as P } from "./project-key-Ch34EtFa.js";
+import { G as pe, V as F, W as I, f as me } from "./utils-USNkj4sT.js";
+import { T as he, d as ge, i as _e, m as L, n as R, o as z, p as ve, r as ye, t as be, u as xe } from "./same-json-value-C6kUaoyt.js";
+import Se from "@sqlite.org/sqlite-wasm";
+// src/store/engine/host/store-events.ts
+var Ce = {
+	registerDocument: function({ args: e }) {
+		return {
+			type: "init-empty-document",
+			documentId: e[0].id
+		};
+	},
+	updateDocument: function({ args: e, value: t }) {
+		return B({ value: t }) ? {
+			type: "document-updated",
+			documentId: e[0]
+		} : void 0;
+	},
+	removeDocument: function({ args: e, value: t }) {
+		return B({ value: t }) ? {
+			type: "document-removed",
+			documentId: e[0]
+		} : void 0;
+	},
+	bulkWrite: function({ args: e, value: t }) {
+		return B({ value: t }) ? {
+			type: "commit",
+			documentId: e[0]
+		} : void 0;
+	},
+	commit: function({ args: e }) {
+		return {
+			type: "commit",
+			documentId: e[0].documentId
+		};
+	},
+	undo: function({ args: e, value: t }) {
+		return B({ value: t }) ? {
+			type: "commit",
+			documentId: e[0]
+		} : void 0;
+	},
+	redo: function({ args: e, value: t }) {
+		return B({ value: t }) ? {
+			type: "commit",
+			documentId: e[0]
+		} : void 0;
+	},
+	importFile: function({ value: e }) {
+		return {
+			type: "document-imported",
+			documentId: e.record.id
+		};
+	},
+	addBlob: function({ args: e }) {
+		let t = e[0];
+		return {
+			type: "blob-added",
+			blobId: t.id,
+			documentId: t.documentId
+		};
+	},
+	attachBlob: function({ args: e, value: t }) {
+		if (B({ value: t })) return {
+			type: "blob-attached",
+			blobId: e[0],
+			ref: e[1]
+		};
+	},
+	detachBlob: function({ args: e, value: t }) {
+		if (B({ value: t })) return {
+			type: "blob-detached",
+			blobId: e[0],
+			ref: e[1]
+		};
+	},
+	removeBlob: function({ args: e, value: t }) {
+		return B({ value: t }) ? {
+			type: "blob-removed",
+			blobId: e[0]
+		} : void 0;
+	}
+};
+function B(e) {
+	return e.value !== !1;
+}
+function we(e) {
+	let { member: t, args: n, value: r, connectionId: i } = e, a = Ce[t]?.({
+		args: n,
+		value: r
+	});
+	if (!a) return;
+	let o = Te({ args: n });
+	return {
+		type: fe.event,
+		message: {
+			...a,
+			timestamp: Date.now()
+		},
+		connectionId: i,
+		...o !== void 0 && { writeId: o }
+	};
+}
+function Te(e) {
+	let [t] = e.args;
+	if (typeof t != "object" || !t || !("writeId" in t)) return;
+	let { writeId: n } = t;
+	return typeof n == "string" ? n : void 0;
+}
+// src/store/sqlite/sqlite.constants.ts
+var Ee = {
+	opfs: !0,
+	"opfs-vfs": !0,
+	"opfs-wl": !0
+}, De = Object.keys({
+	typedArrayToString: !0,
+	typedArrayPart: !0,
+	allocCString: !0,
+	alloc: !0,
+	heap8u: !0
+}), Oe = Symbol.for("dialecte.sqlite.losslessText");
+// src/store/sqlite/sqlite-text.ts
+function ke(e) {
+	let { sqlite3: t } = e;
+	if (Ae({ sqlite3: t })) return;
+	let n = Me({ sqlite3: t }), r = new TextDecoder("utf-8", { ignoreBOM: !0 }), i = n.allocCString;
+	Object.assign(t.wasm, {
+		typedArrayToString: function(e, t, i) {
+			return r.decode(n.typedArrayPart(e, t, i));
+		},
+		allocCString: function(e, t) {
+			return typeof e != "string" || e.isWellFormed() ? i(e, t) : Ne({
+				wasm: n,
+				bytes: je({ text: e }),
+				returnWithLength: t
+			});
+		}
+	}), Object.defineProperty(t.wasm, Oe, { value: !0 });
+}
+function Ae(e) {
+	return e.sqlite3.wasm[Oe] === !0;
+}
+function je(e) {
+	let { text: t } = e, n = [];
+	for (let e = 0; e < t.length; e++) {
+		let r = t.codePointAt(e);
+		r < 128 ? n.push(r) : r < 2048 ? n.push(192 | r >> 6, 128 | r & 63) : r < 65536 ? n.push(224 | r >> 12, 128 | r >> 6 & 63, 128 | r & 63) : (n.push(240 | r >> 18, 128 | r >> 12 & 63, 128 | r >> 6 & 63, 128 | r & 63), e++);
+	}
+	return Uint8Array.from(n);
+}
+function Me(e) {
+	let { sqlite3: t } = e, n = t.wasm, r = De.filter(function(e) {
+		return typeof n[e] != "function";
+	});
+	if (r.length > 0) throw F("ASSERTION_FAILED", { detail: `sqlite-wasm's wasm utilities lack ${r.join(", ")} (SQLite ${t.version?.libVersion ?? "unknown"}): not the sqlite-wasm build core pins, its text codec cannot be made lossless` });
+	return n;
+}
+function Ne(e) {
+	let { wasm: t, bytes: n, returnWithLength: r } = e, i = t.alloc(n.length + 1), a = t.heap8u();
+	return a.set(n, i), a[i + n.length] = 0, r ? [i, n.length] : i;
+}
+// src/store/sqlite/engine/blobs.ts
+function Pe(e) {
+	let { db: t, entry: n, type: r, bytes: i } = e;
+	t.exec({
+		sql: `INSERT OR REPLACE INTO ${k} (id, documentId, entry) VALUES (?, ?, ?)`,
+		bind: [
+			n.id,
+			n.documentId,
+			JSON.stringify(n)
+		]
+	}), t.exec({
+		sql: `INSERT OR REPLACE INTO ${x} (id, type, bytes) VALUES (?, ?, ?)`,
+		bind: [
+			n.id,
+			r,
+			i
+		]
+	});
+}
+function Fe(e) {
+	let { db: t, blobId: n } = e, [r] = t.selectArrays(`SELECT b.entry, d.type, d.bytes FROM ${k} b JOIN ${x} d ON d.id = b.id WHERE b.id = ?`, [n]);
+	if (!r) return;
+	let [i, a, o] = r;
+	return {
+		entry: JSON.parse(String(i)),
+		type: String(a),
+		bytes: o instanceof Uint8Array ? o : /* @__PURE__ */ new Uint8Array()
+	};
+}
+function Ie(e) {
+	let { db: t, blobId: n } = e, r = t.selectValue(`SELECT entry FROM ${k} WHERE id = ?`, [n]);
+	return r === void 0 ? void 0 : JSON.parse(String(r));
+}
+function Le(e) {
+	let { db: t, entry: n } = e;
+	t.exec({
+		sql: `UPDATE ${k} SET entry = ? WHERE id = ?`,
+		bind: [JSON.stringify(n), n.id]
+	});
+}
+function Re(e) {
+	let { db: t, filter: n } = e;
+	return (n === "standalone" ? t.selectValues(`SELECT entry FROM ${k} WHERE json_array_length(entry, '$.attachedTo') = 0`) : t.selectValues(`SELECT entry FROM ${k} b WHERE EXISTS (SELECT 1 FROM json_each(b.entry, '$.attachedTo') a WHERE a.value->>'documentId' = ? AND (? IS NULL OR a.value->>'recordRef' = ?))`, [
+		n.documentId,
+		n.recordRef ?? null,
+		n.recordRef ?? null
+	])).map((e) => JSON.parse(String(e))).sort(R);
+}
+function ze(e) {
+	let { db: t, blobId: n } = e;
+	t.exec({
+		sql: `DELETE FROM ${x} WHERE id = ?`,
+		bind: [n]
+	}), t.exec({
+		sql: `DELETE FROM ${k} WHERE id = ?`,
+		bind: [n]
+	});
+}
+function Be(e) {
+	let { db: t, documentId: n } = e;
+	t.exec({
+		sql: `DELETE FROM ${x} WHERE id IN (SELECT id FROM ${k} WHERE documentId = ?)`,
+		bind: [n]
+	}), t.exec({
+		sql: `DELETE FROM ${k} WHERE documentId = ?`,
+		bind: [n]
+	});
+}
+// src/store/sqlite/engine/bulk-insert.ts
+function Ve(e) {
+	return N({ value: e.records }), He({ records: e.records });
+}
+function He(e) {
+	let { records: t } = e, n = [];
+	for (let e = 0; e < t.length; e += y) {
+		let r = t.slice(e, e + y).map((e) => Ge({ record: e }));
+		n.push(JSON.stringify(r));
+	}
+	return { payloads: n };
+}
+function Ue(e) {
+	let { db: t, table: n, rows: r, lead: a } = e;
+	if (r.payloads.length === 0) return;
+	let o = t.prepare(a ? `INSERT INTO ${n} (${[...a.columns, f].join(", ")}) SELECT ${[...a.columns.map(() => "?"), ...i].join(", ")} FROM json_each(?) e ORDER BY e.key` : `INSERT INTO ${n} (${f}) SELECT ${i.join(", ")} FROM json_each(?) e`);
+	try {
+		for (let e of r.payloads) o.bind([...a?.values ?? [], e]).stepReset();
+	} finally {
+		o.finalize();
+	}
+}
+function We(e) {
+	let { db: t, table: n, records: r, perf: i } = e;
+	Ue({
+		db: t,
+		table: n,
+		rows: i.time("import::encode", function() {
+			return He({ records: r });
+		})
+	});
+}
+function Ge(e) {
+	let { record: t } = e;
+	return [
+		t.id,
+		t.tagName,
+		t.namespace.prefix,
+		t.namespace.uri,
+		t.value,
+		t.parent?.id ?? null,
+		t.parent?.tagName ?? null,
+		t.attributes,
+		t.children
+	];
+}
+// src/store/sqlite/engine/engine-errors.ts
+function V(e) {
+	let { key: t, detail: n, work: r } = e;
+	try {
+		return r();
+	} catch (e) {
+		throw Ke({
+			key: t,
+			detail: n,
+			thrown: e
+		});
+	}
+}
+function Ke(e) {
+	let { key: t, detail: n, thrown: r } = e;
+	if (pe(r)) return r;
+	let i = r instanceof Error ? r : Error(String(r));
+	return F(t, {
+		detail: `${n}: ${i.message}`,
+		cause: i
+	});
+}
+function H(e) {
+	let { detail: t, work: n } = e;
+	return V({
+		key: "STORE_READ_FAILED",
+		detail: `${t} could not be read`,
+		work: n
+	});
+}
+function qe(e) {
+	let t = e.thrown;
+	for (let e = 0; typeof t == "object" && t && e < 8; e += 1) {
+		let e = t.resultCode;
+		if (typeof e == "number") return e & 255;
+		t = t.cause;
+	}
+}
+// src/store/sqlite/engine/records.ts
+function Je(e) {
+	let { db: t, table: n, id: r } = e, [i] = t.selectArrays(`SELECT ${f} FROM ${n} WHERE id = ?`, [r]);
+	return i ? U({ row: i }) : void 0;
+}
+function Ye(e) {
+	let { db: t, table: n } = e;
+	return t.selectArrays(`SELECT ${f} FROM ${n}`).map((e) => U({ row: e })).sort(R);
+}
+function Xe(e) {
+	let { db: t, table: n, tagName: r } = e;
+	return t.selectArrays(`SELECT ${f} FROM ${n} WHERE tagName = ?`, [r]).map((e) => U({ row: e })).sort(R);
+}
+function Ze(e) {
+	let { db: t, table: n, ids: r } = e, i = t.selectArrays(`SELECT ${f} FROM ${n} WHERE id IN (SELECT value FROM json_each(?))`, [JSON.stringify(r)]);
+	return new Map(i.map((e) => [String(e[0]), U({ row: e })]));
+}
+function Qe(e) {
+	let { db: t, table: n } = e, r = t.prepare(`SELECT ${f} FROM ${n} WHERE id IN (SELECT value FROM json_each(?))`);
+	return {
+		read: function(e) {
+			let t = /* @__PURE__ */ new Map();
+			try {
+				for (r.bind([JSON.stringify(e)]); r.step();) {
+					let e = U({ row: r.get([]) });
+					t.set(e.id, e);
+				}
+			} finally {
+				r.reset(!0);
+			}
+			return t;
+		},
+		finalize: function() {
+			r.finalize();
+		}
+	};
+}
+function $e(e) {
+	let { db: t, table: n, ids: r } = e;
+	return new Set(t.selectValues(`SELECT id FROM ${n} WHERE id IN (SELECT value FROM json_each(?))`, [JSON.stringify(r)]).map(String));
+}
+function et(e) {
+	return Number(e.db.selectValue(`SELECT count(*) FROM ${e.table}`));
+}
+function tt(e) {
+	let { db: t, table: n, documentId: r, creates: i } = e;
+	if (i.length === 0) return;
+	let a = i.map((e) => e.id);
+	nt({
+		documentId: r,
+		ids: a,
+		heldIds: $e({
+			db: t,
+			table: n,
+			ids: a
+		})
+	});
+}
+function nt(e) {
+	let { documentId: t, ids: n, heldIds: r } = e, i = /* @__PURE__ */ new Set(), a = [], o = [];
+	for (let e of n) r.has(e) && a.push(e), i.has(e) && o.push(e), i.add(e);
+	return (a.length > 0 || o.length > 0) && le({
+		documentId: t,
+		held: a,
+		repeated: o
+	}), i;
+}
+function rt(e) {
+	let { sqlite3: t, db: n, table: r, documentId: i, thrown: a } = e;
+	if (a?.resultCode !== t.capi.SQLITE_CONSTRAINT_UNIQUE) return;
+	let o = n.selectValues(`SELECT id FROM ${r} GROUP BY id HAVING count(*) > 1 LIMIT ?`, [100]).map(String);
+	le({
+		documentId: i,
+		held: [],
+		repeated: o,
+		cause: a instanceof Error ? a : void 0
+	});
+}
+function it(e) {
+	let { db: t, table: n, patches: r } = e;
+	if (r.length === 0) return;
+	let i = /* @__PURE__ */ new Set();
+	for (let e = 0; e < r.length; e += y) {
+		let a = r.slice(e, e + y).map((e) => e.recordId);
+		for (let e of $e({
+			db: t,
+			table: n,
+			ids: a
+		})) i.add(e);
+	}
+	at({
+		patches: r,
+		held: i
+	});
+}
+function at(e) {
+	let { patches: t, held: n } = e, r = t.filter((e) => n.has(e.recordId));
+	return N({ value: r }), r;
+}
+function ot(e) {
+	let { db: t, table: r, patches: i } = e;
+	if (i.length === 0) return;
+	let a = t.prepare(`UPDATE ${r} SET ${n} FROM (SELECT ${S} FROM json_each(?) e) AS u WHERE ${r}.id = u.c0`);
+	try {
+		for (let e = 0; e < i.length; e += y) {
+			let n = i.slice(e, e + y), o = Ze({
+				db: t,
+				table: r,
+				ids: n.map((e) => e.recordId)
+			}), s = /* @__PURE__ */ new Map();
+			for (let e of n) {
+				let t = s.get(e.recordId) ?? o.get(e.recordId);
+				t && s.set(e.recordId, ge({
+					record: t,
+					patch: e
+				}));
+			}
+			let c = He({ records: [...s.values()] });
+			for (let e of c.payloads) a.bind([e]).stepReset();
+		}
+	} finally {
+		a.finalize();
+	}
+}
+function st(e) {
+	let { db: t, table: n, ids: r } = e;
+	return r.length === 0 ? 0 : (t.exec({
+		sql: `DELETE FROM ${n} WHERE id IN (SELECT value FROM json_each(?))`,
+		bind: [JSON.stringify(r)]
+	}), t.changes());
+}
+function U(e) {
+	let [t, n, r, i, a, o, s, c, l] = e.row;
+	return {
+		id: String(t),
+		tagName: String(n),
+		namespace: {
+			prefix: String(r ?? ""),
+			uri: String(i ?? "")
+		},
+		attributes: JSON.parse(String(c)),
+		value: String(a ?? ""),
+		parent: o === null ? null : {
+			id: String(o),
+			tagName: String(s)
+		},
+		children: JSON.parse(String(l))
+	};
+}
+// src/store/sqlite/engine/history.ts
+function ct(e) {
+	let { db: t, documentId: n, table: r, writeId: i } = e;
+	t.exec({
+		sql: `DELETE FROM ${r} WHERE entry IN (SELECT id FROM ${O} WHERE documentId = ? AND state = ?)`,
+		bind: [n, d.undone]
+	}), t.exec({
+		sql: `UPDATE ${O} SET state = ?, sequenceNumber = NULL WHERE documentId = ? AND state = ?`,
+		bind: [
+			d.discarded,
+			n,
+			d.undone
+		]
+	});
+	let a = Number(t.selectValue(`SELECT coalesce(max(sequenceNumber), 0) FROM ${O} WHERE documentId = ?`, [n]));
+	return t.exec({
+		sql: `INSERT INTO ${O} (documentId, sequenceNumber, timestamp, writeId, state) VALUES (?, ?, ?, ?, ?)`,
+		bind: [
+			n,
+			a + 1,
+			Date.now(),
+			i,
+			d.applied
+		]
+	}), { id: Number(t.selectValue("SELECT last_insert_rowid()")) };
+}
+function lt(e) {
+	let { db: t, records: n, table: r, entry: i, part: a, ids: o } = e;
+	o.length !== 0 && t.exec({
+		sql: `INSERT INTO ${r} (entry, part, ${f}) SELECT ?, ?, ${l.map((e) => `t.${e}`).join(", ")} FROM json_each(?) j JOIN ${n} t ON t.id = j.value ORDER BY j.key`,
+		bind: [
+			i.id,
+			v[a],
+			JSON.stringify(o)
+		]
+	});
+}
+function ut(e) {
+	let { db: t, table: n, entry: r, part: i, rows: a } = e;
+	Ue({
+		db: t,
+		table: n,
+		rows: a,
+		lead: {
+			columns: ["entry", "part"],
+			values: [r.id, v[i]]
+		}
+	});
+}
+function dt(e) {
+	let { direction: t, ...n } = e;
+	return t === "forward" ? W({
+		...n,
+		part: "create"
+	}) + W({
+		...n,
+		part: "after"
+	}) - ft({
+		...n,
+		part: "delete"
+	}) : W({
+		...n,
+		part: "delete"
+	}) + W({
+		...n,
+		part: "before"
+	}) - ft({
+		...n,
+		part: "create"
+	});
+}
+function W(e) {
+	let { db: t, records: n, table: r, entry: i, part: a } = e, o = [i.id, v[a]], s = Number(t.selectValue(`SELECT count(DISTINCT h.id) FROM ${r} h WHERE h.entry = ? AND h.part = ? AND NOT EXISTS (SELECT 1 FROM ${n} t WHERE t.id = h.id)`, o));
+	return t.exec({
+		sql: `INSERT OR REPLACE INTO ${n} (${f}) SELECT ${f} FROM ${r} WHERE entry = ? AND part = ? ORDER BY rowNo`,
+		bind: o
+	}), s;
+}
+function ft(e) {
+	let { db: t, records: n, table: r, entry: i, part: a } = e;
+	return t.exec({
+		sql: `DELETE FROM ${n} WHERE id IN (SELECT id FROM ${r} WHERE entry = ? AND part = ?)`,
+		bind: [i.id, v[a]]
+	}), t.changes();
+}
+function pt(e) {
+	let { db: t, documentId: n } = e, r = t.selectValue(`SELECT id FROM ${O} WHERE documentId = ? AND state = ? ORDER BY sequenceNumber DESC LIMIT 1`, [n, d.applied]);
+	return r === void 0 ? void 0 : { id: Number(r) };
+}
+function mt(e) {
+	let { db: t, documentId: n } = e, r = t.selectValue(`SELECT id FROM ${O} WHERE documentId = ? AND state = ? ORDER BY sequenceNumber LIMIT 1`, [n, d.undone]);
+	return r === void 0 ? void 0 : { id: Number(r) };
+}
+function ht(e) {
+	let { db: t, entry: n, state: r } = e;
+	t.exec({
+		sql: `UPDATE ${O} SET state = ? WHERE id = ?`,
+		bind: [d[r], n.id]
+	});
+}
+function gt(e) {
+	let { db: t, documentId: n } = e, r = `EXISTS (SELECT 1 FROM ${O} WHERE documentId = ? AND state = ?)`, [i] = t.selectArrays(`SELECT ${r}, ${r}`, [
+		n,
+		d.applied,
+		n,
+		d.undone
+	]);
+	return {
+		canUndo: Number(i?.[0]) === 1,
+		canRedo: Number(i?.[1]) === 1
+	};
+}
+function _t(e) {
+	let { db: t, documentId: n, table: r } = e, i = /* @__PURE__ */ new Map(), a = /* @__PURE__ */ new Map(), o = /* @__PURE__ */ new Map();
+	for (let [e, r, s, c] of t.selectArrays(`SELECT id, sequenceNumber, timestamp, writeId FROM ${O} WHERE documentId = ? AND state != ? ORDER BY sequenceNumber`, [n, d.discarded])) i.set(Number(e), {
+		id: Number(e),
+		documentId: n,
+		sequenceNumber: Number(r),
+		timestamp: Number(s),
+		writeId: String(c),
+		operations: {
+			creates: [],
+			updates: [],
+			deletes: []
+		}
+	}), a.set(Number(e), []), o.set(Number(e), []);
+	if (i.size === 0) return [];
+	for (let [e, n, ...s] of t.selectArrays(`SELECT entry, part, ${f} FROM ${r} ORDER BY rowNo`)) {
+		let t = i.get(Number(e));
+		if (!t) continue;
+		let r = U({ row: s });
+		n === v.create && t.operations.creates.push(r), n === v.before && a.get(t.id).push(r), n === v.after && o.get(t.id).push(r), n === v.delete && t.operations.deletes.push(r);
+	}
+	for (let e of i.values()) {
+		let t = o.get(e.id);
+		e.operations.updates = a.get(e.id).map((e, n) => ({
+			before: e,
+			after: t[n]
+		}));
+	}
+	return [...i.values()];
+}
+function vt(e) {
+	let { db: t, writeId: n } = e;
+	return t.selectValue(`SELECT 1 FROM ${O} WHERE writeId = ? LIMIT 1`, [n]) !== void 0;
+}
+function yt(e) {
+	let { db: t, documentId: n, table: r } = e;
+	t.exec(`DROP TABLE ${r}`), t.exec({
+		sql: `DELETE FROM ${O} WHERE documentId = ?`,
+		bind: [n]
+	});
+}
+// src/store/sqlite/engine/transaction.ts
+function G(e) {
+	let { sqlite3: t, db: n, work: r } = e;
+	n.exec("BEGIN IMMEDIATE");
+	try {
+		let e = r();
+		return n.exec("COMMIT"), e;
+	} catch (e) {
+		throw t.capi.sqlite3_get_autocommit(n) === 0 && n.exec("ROLLBACK"), e;
+	}
+}
+// src/store/sqlite/engine/schema.ts
+function bt(e) {
+	let { db: t, steadyCacheMiB: n } = e;
+	t.exec(`PRAGMA locking_mode=EXCLUSIVE; PRAGMA temp_store=MEMORY; PRAGMA journal_mode=TRUNCATE; PRAGMA synchronous=FULL; PRAGMA cache_size=${-n * 1024};`);
+}
+function xt(e) {
+	let { sqlite3: t, db: n, dialecteId: r } = e, i = crypto.randomUUID();
+	return n.exec("PRAGMA auto_vacuum=INCREMENTAL"), G({
+		sqlite3: t,
+		db: n,
+		work: a
+	}), i;
+	function a() {
+		n.exec(`CREATE TABLE ${T} (key TEXT PRIMARY KEY, value TEXT NOT NULL);CREATE TABLE ${A} (seq INTEGER PRIMARY KEY, ${K({ columns: m })});CREATE TABLE ${O} (${K({ columns: u })});CREATE UNIQUE INDEX ${O}_sequence ON ${O}(documentId, sequenceNumber);CREATE INDEX ${O}_state ON ${O}(documentId, state, sequenceNumber);CREATE INDEX ${O}_writeId ON ${O}(writeId);CREATE TABLE ${k} (${K({ columns: p })});CREATE INDEX ${k}_documentId ON ${k}(documentId);CREATE TABLE ${x} (${K({ columns: ee })});`), n.exec({
+			sql: `INSERT INTO ${T} (key, value) VALUES (?, ?), (?, ?), (?, ?)`,
+			bind: [
+				s.dialecteId,
+				r,
+				s.layoutVersion,
+				"4",
+				s.creationId,
+				i
+			]
+		}), n.exec(`PRAGMA application_id=${St({ dialecteId: r })}`), n.exec("PRAGMA user_version=4");
+	}
+}
+function St(e) {
+	let { offsetBasis: t, prime: n } = _, r = t;
+	for (let t of new TextEncoder().encode(e.dialecteId)) r = Math.imul(r ^ t, n);
+	return r | 0;
+}
+function Ct(e) {
+	let { sqlite3: n, db: r, project: i, dialecteId: a, expectedCreationId: o, steadyCacheMiB: s } = e, c = Number(r.selectValue("PRAGMA user_version")), l = Number(r.selectValue("SELECT count(*) FROM sqlite_schema"));
+	if (c === 0 && l === 0) return t({
+		project: i,
+		expectedCreationId: o,
+		creationId: void 0
+	}), bt({
+		db: r,
+		steadyCacheMiB: s
+	}), { creationId: xt({
+		sqlite3: n,
+		db: r,
+		dialecteId: a
+	}) };
+	if (c === 4) {
+		let e = wt({ db: r });
+		return Et({
+			project: i,
+			dialecteId: a,
+			fileDialecteId: e.dialecteId
+		}), t({
+			project: i,
+			expectedCreationId: o,
+			creationId: e.creationId
+		}), bt({
+			db: r,
+			steadyCacheMiB: s
+		}), { creationId: e.creationId };
+	}
+	I("PROJECT_LAYOUT_OUTDATED", {
+		detail: `The project file is at layout ${c}, this library reads layout 4: delete the project and import its files again`,
+		meta: {
+			layoutVersion: c,
+			expectedLayoutVersion: 4
+		}
+	});
+}
+function wt(e) {
+	let t = e.db.selectObjects(`SELECT key, value FROM ${T}`), n = new Map(t.map(Tt));
+	return {
+		dialecteId: n.get(s.dialecteId) ?? "",
+		creationId: n.get(s.creationId) ?? ""
+	};
+}
+function Tt(e) {
+	return [e.key, e.value];
+}
+function Et(e) {
+	let { project: t, dialecteId: n, fileDialecteId: r } = e;
+	r !== n && I("PROJECT_DIALECTE_MISMATCH", {
+		detail: `The file of "${t}" was stored by ${r || "no dialecte"}, this engine runs ${n}: nothing of it was written`,
+		meta: {
+			project: t,
+			projectDialecteId: r,
+			realmDialecteId: n
+		}
+	});
+}
+function Dt(e) {
+	let { db: t, table: n } = e;
+	t.exec(`CREATE TABLE ${n} (${K({ columns: h })})`);
+}
+function Ot(e) {
+	let { db: t, table: n } = e;
+	t.exec(`CREATE TABLE ${n} (rowNo INTEGER PRIMARY KEY, entry INTEGER NOT NULL, part INTEGER NOT NULL, ${K({ columns: h })});CREATE INDEX ${n}_entry ON ${n}(entry, part);`);
+}
+function kt(e) {
+	let { db: t, table: n, index: r } = e, { column: i, unique: a } = c[r];
+	t.exec(`CREATE ${a ? "UNIQUE " : ""}INDEX ${n}_${r} ON ${n}(${i})`);
+}
+function At(e) {
+	for (let t of Object.keys(c)) kt({
+		...e,
+		index: t
+	});
+}
+function K(e) {
+	return Object.entries(e.columns).map(([e, t]) => `${e} ${t}`).join(", ");
+}
+// src/store/sqlite/engine/registry.ts
+function jt(e) {
+	let { db: t } = e;
+	Ht({
+		db: t,
+		documentId: e.document.id
+	}) !== void 0 && re({ documentId: e.document.id });
+	let n = M({ value: e.document });
+	n.path !== void 0 && L({
+		document: n,
+		documents: Vt({ db: t })
+	});
+	let r = Object.keys(m).map(() => "?").join(", ");
+	t.exec({
+		sql: `INSERT INTO ${A} (${g}) VALUES (${r})`,
+		bind: Gt({ document: n })
+	});
+	let i = Number(t.selectValue("SELECT last_insert_rowid()")), a = Ut({ seq: i });
+	return Dt({
+		db: t,
+		table: a
+	}), Ot({
+		db: t,
+		table: Wt({ seq: i })
+	}), {
+		seq: i,
+		table: a
+	};
+}
+function Mt(e) {
+	let { db: t, documentId: n } = e, [r] = t.selectArrays(`SELECT seq, status, writeId, createdAt FROM ${A} WHERE id = ?`, [n]);
+	if (!r) return;
+	let [i, a, o, s] = r;
+	return {
+		seq: Number(i),
+		status: Jt({ value: a }),
+		writeId: o === null ? void 0 : String(o),
+		createdAt: Number(s)
+	};
+}
+function Nt(e) {
+	let { db: t, documentId: n } = e;
+	return t.exec({
+		sql: `UPDATE ${A} SET status = ? WHERE id = ? AND status = ?`,
+		bind: [
+			"ready",
+			n,
+			"importing"
+		]
+	}), t.changes() === 1;
+}
+function Pt(e) {
+	let { db: t, documentId: n } = e, [r] = t.selectArrays(`SELECT ${g} FROM ${A} WHERE id = ?`, [n]);
+	return r ? qt({ row: r }) : void 0;
+}
+function Ft(e) {
+	return e.db.selectArrays(`SELECT ${g} FROM ${A}`).map((e) => qt({ row: e })).sort(R);
+}
+function It(e) {
+	let { db: t, documentId: n } = e, r = M({ value: e.updates }), i = Pt({
+		db: t,
+		documentId: n
+	});
+	if (!i) return !1;
+	let a = ve({
+		document: i,
+		updates: r
+	});
+	return a.path !== i.path && L({
+		document: a,
+		documents: Vt({ db: t })
+	}), Lt({
+		held: i,
+		updated: a
+	}) ? (t.exec({
+		sql: `UPDATE ${A} SET name = ?, metadata = ?, path = ? WHERE id = ?`,
+		bind: [
+			a.name,
+			Kt({ document: a }),
+			a.path ?? null,
+			n
+		]
+	}), !0) : !1;
+}
+function Lt(e) {
+	let { held: t, updated: n } = e;
+	return t.name !== n.name || t.path !== n.path || !be({
+		first: t.metadata,
+		second: n.metadata
+	});
+}
+function Rt(e) {
+	let { db: t, documentId: n } = e, r = Ht({
+		db: t,
+		documentId: n
+	});
+	return r !== void 0 && (Bt({
+		db: t,
+		documentId: n,
+		seq: r
+	}), !0);
+}
+function q(e) {
+	let t = Ht(e);
+	return t === void 0 ? void 0 : Ut({ seq: t });
+}
+function zt(e) {
+	let t = Mt(e);
+	if (!t) return;
+	let { seq: n, status: r } = t;
+	return {
+		seq: n,
+		status: r,
+		records: Ut({ seq: n }),
+		history: Wt({ seq: n })
+	};
+}
+function Bt(e) {
+	let { db: t, documentId: n, seq: r } = e;
+	t.exec(`DROP TABLE ${Ut({ seq: r })}`), yt({
+		db: t,
+		documentId: n,
+		table: Wt({ seq: r })
+	}), Be({
+		db: t,
+		documentId: n
+	}), t.exec({
+		sql: `DELETE FROM ${A} WHERE seq = ?`,
+		bind: [r]
+	});
+}
+function Vt(e) {
+	return e.db.selectArrays(`SELECT id, path FROM ${A} WHERE path IS NOT NULL`).map(([e, t]) => ({
+		id: String(e),
+		path: String(t)
+	}));
+}
+function Ht(e) {
+	let { db: t, documentId: n } = e, r = t.selectValue(`SELECT seq FROM ${A} WHERE id = ?`, [n]);
+	return r === void 0 ? void 0 : Number(r);
+}
+function Ut(e) {
+	return `${E}${e.seq}`;
+}
+function Wt(t) {
+	return `${e}${t.seq}`;
+}
+function Gt(e) {
+	let { document: t } = e;
+	return [
+		t.id,
+		t.name,
+		t.extension,
+		t.configKey,
+		t.createdAt,
+		Kt({ document: t }),
+		t.status,
+		t.writeId ?? null,
+		t.path ?? null
+	];
+}
+function Kt(e) {
+	let { metadata: t } = e.document;
+	return t === void 0 ? null : JSON.stringify(t);
+}
+function qt(e) {
+	let [t, n, r, i, a, o, s, c, l] = e.row, u = {
+		id: String(t),
+		name: String(n),
+		extension: String(r),
+		configKey: String(i),
+		createdAt: Number(a),
+		status: Jt({ value: s })
+	};
+	return o !== null && (u.metadata = JSON.parse(String(o))), c !== null && (u.writeId = String(c)), l !== null && (u.path = String(l)), u;
+}
+function Jt(e) {
+	return e.value === "importing" ? "importing" : "ready";
+}
+function Yt(e) {
+	let { db: t } = e, n = t.selectArrays(`SELECT seq, id FROM ${A} WHERE status = ?`, ["importing"]);
+	for (let [e, r] of n) Bt({
+		db: t,
+		documentId: String(r),
+		seq: Number(e)
+	});
+}
+function Xt(e) {
+	let { db: t, writeId: n } = e;
+	return t.selectArrays(`SELECT ${g} FROM ${A} WHERE writeId = ?`, [n]).map((e) => qt({ row: e }));
+}
+// src/store/sqlite/engine/commit.ts
+function Zt(e) {
+	let { sqlite3: t, db: n, documentId: r, writeId: i, creates: a, updates: o, deletes: s, settle: c } = e, l = H({
+		detail: `Document "${r}"`,
+		work: function() {
+			return zt({
+				db: n,
+				documentId: r
+			});
+		}
+	});
+	l || w({
+		documentId: r,
+		what: "records"
+	}), l.status === "importing" && w({
+		documentId: r,
+		what: "a commit"
+	}), ne({ writeId: i }), H({
+		detail: `The records to update in document "${r}"`,
+		work: function() {
+			$t({
+				db: n,
+				table: l.records,
+				documentId: r,
+				ids: o.map(en)
+			});
+		}
+	});
+	let u = Ve({ records: a });
+	H({
+		detail: `The ids of document "${r}"`,
+		work: function() {
+			tt({
+				db: n,
+				table: l.records,
+				documentId: r,
+				creates: a
+			});
+		}
+	});
+	let d = Ve({ records: o });
+	return V({
+		key: "STORE_COMMIT_FAILED",
+		detail: `The commit on document "${r}" could not be written`,
+		work: function() {
+			return c(), G({
+				sqlite3: t,
+				db: n,
+				work: function() {
+					let e = ct({
+						db: n,
+						documentId: r,
+						table: l.history,
+						writeId: i
+					}), t = {
+						db: n,
+						records: l.records,
+						table: l.history,
+						entry: e
+					};
+					lt({
+						...t,
+						part: "before",
+						ids: o.map(en)
+					}), ut({
+						db: n,
+						table: l.history,
+						entry: e,
+						part: "create",
+						rows: u
+					}), ut({
+						db: n,
+						table: l.history,
+						entry: e,
+						part: "after",
+						rows: d
+					});
+					let a = W({
+						...t,
+						part: "create"
+					}) + W({
+						...t,
+						part: "after"
+					});
+					return lt({
+						...t,
+						part: "delete",
+						ids: s
+					}), a - ft({
+						...t,
+						part: "delete"
+					});
+				}
+			});
+		}
+	});
+}
+function Qt(e) {
+	let { sqlite3: t, db: n, documentId: r, direction: i, settle: a } = e, o = H({
+		detail: `The history of document "${r}"`,
+		work: function() {
+			let e = zt({
+				db: n,
+				documentId: r
+			});
+			if (!e) return;
+			let t = i === "back" ? pt({
+				db: n,
+				documentId: r
+			}) : mt({
+				db: n,
+				documentId: r
+			});
+			return t && {
+				tables: e,
+				entry: t
+			};
+		}
+	});
+	if (!o) return;
+	let { tables: s, entry: c } = o;
+	return V({
+		key: "STORE_COMMIT_FAILED",
+		detail: `The ${i === "back" ? "undo" : "redo"} on document "${r}" could not be written`,
+		work: function() {
+			return a(), G({
+				sqlite3: t,
+				db: n,
+				work: function() {
+					let e = dt({
+						db: n,
+						records: s.records,
+						table: s.history,
+						entry: c,
+						direction: i
+					});
+					return ht({
+						db: n,
+						entry: c,
+						state: i === "forward" ? "applied" : "undone"
+					}), e;
+				}
+			});
+		}
+	});
+}
+function $t(e) {
+	let { db: t, table: n, documentId: r, ids: i } = e;
+	for (let e = 0; e < i.length; e += y) {
+		let a = i.slice(e, e + y), o = $e({
+			db: t,
+			table: n,
+			ids: a
+		}), s = a.find((e) => !o.has(e));
+		s !== void 0 && ce({
+			documentId: r,
+			recordId: s
+		});
+	}
+}
+function en(e) {
+	return e.id;
+}
+// src/store/sqlite/engine/device-cache.ts
+function tn(e) {
+	let { deviceMemoryGiB: t = 4, rule: n = r.cacheRule } = e, { mibPerGiB: i, floorMiB: a, ceilingMiB: o } = n;
+	return Math.min(o, Math.max(a, Math.round(t * i)));
+}
+function nn() {
+	return globalThis.navigator?.deviceMemory;
+}
+// src/store/sqlite/engine/import-queue.ts
+function rn() {
+	let e = [];
+	return {
+		run: function(t) {
+			return an({
+				entries: e,
+				...t
+			});
+		},
+		abort: function({ writeId: t }) {
+			on({
+				entries: e,
+				matches: (e) => e.writeId === t
+			});
+		},
+		abortOwnedBy: function({ clientId: t }) {
+			on({
+				entries: e,
+				matches: (e) => e.clientId === t
+			});
+		},
+		abortAll: function() {
+			on({
+				entries: e,
+				matches: () => !0
+			});
+		},
+		awaitsRow: function({ writeId: t }) {
+			return e.some((e) => e.writeId === t && !e.registered);
+		},
+		markRegistered: function({ writeId: t }) {
+			for (let n of e) n.writeId === t && (n.registered = !0);
+		},
+		runs: function({ writeId: t }) {
+			return e.some((e) => e.writeId === t);
+		}
+	};
+}
+async function an(e) {
+	let { entries: t, writeId: n, clientId: r, work: i } = e, a = Promise.withResolvers(), o = {
+		writeId: n,
+		clientId: r,
+		controller: new AbortController(),
+		hasTurn: !1,
+		registered: !1,
+		start: a.resolve
+	};
+	t.push(o), t.length === 1 && sn({ entry: o });
+	try {
+		return await a.promise, await i(o.controller.signal);
+	} finally {
+		cn({
+			entries: t,
+			entry: o
+		});
+	}
+}
+function on(e) {
+	let { entries: t, matches: n } = e;
+	for (let e of t.filter(n)) e.controller.abort(), e.hasTurn || (t.splice(t.indexOf(e), 1), sn({ entry: e }));
+}
+function sn(e) {
+	let { entry: t } = e;
+	t.hasTurn = !0, t.start();
+}
+function cn(e) {
+	let { entries: t, entry: n } = e, r = t.indexOf(n);
+	if (r === -1) return;
+	t.splice(r, 1);
+	let i = t[0];
+	i && !i.hasTurn && sn({ entry: i });
+}
+// src/store/sqlite/engine/import-window.ts
+function ln(e) {
+	let t = {
+		openedAt: void 0,
+		synchronousOff: !1,
+		cacheRaised: !1,
+		lost: void 0
+	};
+	return {
+		write: function(n) {
+			return un({
+				params: e,
+				state: t
+			}), n();
+		},
+		commitIfDue: function() {
+			return t.openedAt === void 0 || performance.now() - t.openedAt < e.windowMs ? !1 : (J({
+				params: e,
+				state: t
+			}), !0);
+		},
+		alone: function(n) {
+			J({
+				params: e,
+				state: t
+			}), un({
+				params: e,
+				state: t
+			});
+			let r = n();
+			return J({
+				params: e,
+				state: t
+			}), r;
+		},
+		settle: function() {
+			let { sqlite3: n, db: r } = e;
+			try {
+				J({
+					params: e,
+					state: t
+				});
+			} catch (e) {
+				throw n.capi.sqlite3_get_autocommit(r) === 0 && r.exec("ROLLBACK"), t.openedAt = void 0, t.lost = e instanceof Error ? e : Error(String(e)), e;
+			}
+			fn({
+				params: e,
+				state: t
+			});
+		},
+		finish: function() {
+			dn({ state: t }), J({
+				params: e,
+				state: t
+			}), fn({
+				params: e,
+				state: t
+			}), pn({
+				params: e,
+				state: t
+			});
+		},
+		end: function() {
+			if (!e.db.isOpen()) return;
+			let { sqlite3: n, db: r } = e;
+			try {
+				t.openedAt !== void 0 && n.capi.sqlite3_get_autocommit(r) === 0 && r.exec("ROLLBACK");
+			} finally {
+				try {
+					n.capi.sqlite3_get_autocommit(r) === 0 && r.exec("COMMIT");
+				} finally {
+					pn({
+						params: e,
+						state: t
+					}), n.capi.sqlite3_get_autocommit(r) !== 0 && (t.openedAt = void 0, fn({
+						params: e,
+						state: t
+					}));
+				}
+			}
+		}
+	};
+}
+function un(e) {
+	let { state: t } = e, { db: n, importCacheMiB: r } = e.params;
+	dn({ state: t }), t.openedAt === void 0 && (t.cacheRaised ||= (n.exec(`PRAGMA cache_size=${-r * 1024}`), !0), t.synchronousOff ||= (n.exec("PRAGMA synchronous=OFF"), !0), n.exec("BEGIN IMMEDIATE"), t.openedAt = performance.now());
+}
+function J(e) {
+	let { state: t } = e, { db: n, perf: r } = e.params;
+	t.openedAt !== void 0 && (r.time("import::commit", function() {
+		n.exec("COMMIT");
+	}), t.openedAt = void 0);
+}
+function dn(e) {
+	let { lost: t } = e.state;
+	t && I("STORE_COMMIT_FAILED", {
+		detail: `The import's records could not be committed: ${t.message}`,
+		cause: t
+	});
+}
+function fn(e) {
+	let { state: t } = e;
+	t.synchronousOff &&= (e.params.db.exec("PRAGMA synchronous=FULL"), !1);
+}
+function pn(e) {
+	let { state: t } = e, { db: n, steadyCacheMiB: r } = e.params;
+	t.cacheRaised &&= (n.exec(`PRAGMA cache_size=${-r * 1024}`), !1);
+}
+function mn(e) {
+	try {
+		e.window.end();
+	} catch {}
+}
+// src/store/sqlite/engine/import-target.ts
+function hn(e) {
+	let { sqlite3: t, db: n, signal: r, file: i, counts: a, removeDocument: o } = e, s = {
+		registered: void 0,
+		built: /* @__PURE__ */ new Set(),
+		givenIds: e.customIds ? /* @__PURE__ */ new Set() : void 0
+	};
+	return {
+		registerDocument: async function(o) {
+			z({
+				signal: r,
+				file: i
+			});
+			let c = V({
+				key: "STORE_COMMIT_FAILED",
+				detail: `Document "${o.id}" could not be registered`,
+				work: function() {
+					return G({
+						sqlite3: t,
+						db: n,
+						work: function() {
+							return jt({
+								db: n,
+								document: o
+							});
+						}
+					});
+				}
+			});
+			s.registered = {
+				...c,
+				documentId: o.id,
+				writeId: o.writeId,
+				createdAt: o.createdAt
+			}, e.onRegistered(), a.set(o.id, 0);
+		},
+		getDocument: async function(e) {
+			return z({
+				signal: r,
+				file: i
+			}), H({
+				detail: `Document "${e}"`,
+				work: function() {
+					return Pt({
+						db: n,
+						documentId: e
+					});
+				}
+			});
+		},
+		bulkWrite: async function(t, n) {
+			await gn({
+				params: e,
+				state: s,
+				documentId: t,
+				ops: n
+			});
+		},
+		writeSession: async function(t, n) {
+			s.built.has("id") || await Cn({
+				params: e,
+				state: s,
+				documentId: t,
+				index: "id"
+			}), await gn({
+				params: e,
+				state: s,
+				documentId: t,
+				ops: n
+			});
+		},
+		markReady: async function(t) {
+			for (let n of Object.keys(c)) s.built.has(n) || await Cn({
+				params: e,
+				state: s,
+				documentId: t,
+				index: n
+			});
+			wn({
+				params: e,
+				state: s,
+				documentId: t
+			});
+		},
+		removeDocument: async function(t) {
+			let { registered: r } = s;
+			r?.documentId === t && n.isOpen() && (mn({ window: e.window }), _n({
+				row: Dn({
+					db: n,
+					documentId: t
+				}),
+				registered: r,
+				documentId: t
+			}) && await o({ documentId: t }));
+		}
+	};
+}
+async function gn(e) {
+	let { state: t, documentId: n, ops: r } = e, { creates: i = [], updates: a = [], deletes: o = [] } = r;
+	i.length > 0 && await vn({
+		params: e.params,
+		state: t,
+		documentId: n,
+		creates: i
+	}), (a.length !== 0 || o.length !== 0) && (t.built.has("id") || await Cn({
+		params: e.params,
+		state: t,
+		documentId: n,
+		index: "id"
+	}), await yn({
+		params: e.params,
+		state: t,
+		documentId: n,
+		updates: a,
+		deletes: o
+	}));
+}
+function Y(e) {
+	let { state: t, documentId: n } = e, { db: r, signal: i, file: a } = e.params;
+	z({
+		signal: i,
+		file: a
+	});
+	let { registered: o } = t, s = Dn({
+		db: r,
+		documentId: n
+	});
+	return o && _n({
+		row: s,
+		registered: o,
+		documentId: n
+	}) || w({
+		documentId: n,
+		what: "records"
+	}), o.table;
+}
+function _n(e) {
+	let { row: t, registered: n, documentId: r } = e;
+	return !t || !n || n.documentId !== r ? !1 : t.status === "importing" && t.seq === n.seq && t.writeId === n.writeId && t.createdAt === n.createdAt;
+}
+async function vn(e) {
+	let { state: t, documentId: n, creates: r } = e, { db: i, perf: a, counts: o, window: s } = e.params, c = `Records of document "${n}" could not be written`, l = Y(e);
+	a.time("import::encode", function() {
+		N({ value: r });
+	}), V({
+		key: "STORE_BULK_ADD_FAILED",
+		detail: c,
+		work: function() {
+			En({
+				db: i,
+				table: l,
+				state: t,
+				documentId: n,
+				creates: r
+			});
+		}
+	});
+	for (let t = 0; t < r.length; t += y) {
+		let u = r.slice(t, t + y), d = t === 0 ? l : Y(e);
+		V({
+			key: "STORE_BULK_ADD_FAILED",
+			detail: c,
+			work: function() {
+				s.write(function() {
+					We({
+						db: i,
+						table: d,
+						records: u,
+						perf: a
+					});
+				});
+			}
+		}), o.set(n, (o.get(n) ?? 0) + u.length), await xn({
+			params: e.params,
+			documentId: n
+		});
+	}
+}
+async function yn(e) {
+	let { documentId: t, updates: n, deletes: r } = e, { db: i, counts: a, window: o } = e.params, s = `Records of document "${t}" could not be written`, c = await bn({
+		params: e.params,
+		state: e.state,
+		documentId: t,
+		updates: n
+	});
+	for (let n = 0; n < c.length; n += y) {
+		let r = Y(e), a = c.slice(n, n + y);
+		V({
+			key: "STORE_BULK_UPDATE_FAILED",
+			detail: s,
+			work: function() {
+				o.write(function() {
+					ot({
+						db: i,
+						table: r,
+						patches: a
+					});
+				});
+			}
+		}), await xn({
+			params: e.params,
+			documentId: t
+		});
+	}
+	for (let n = 0; n < r.length; n += y) {
+		let c = Y(e), l = r.slice(n, n + y), u = V({
+			key: "STORE_DELETE_FAILED",
+			detail: s,
+			work: function() {
+				return o.write(function() {
+					return st({
+						db: i,
+						table: c,
+						ids: l
+					});
+				});
+			}
+		});
+		a.set(t, (a.get(t) ?? 0) - u), await xn({
+			params: e.params,
+			documentId: t
+		});
+	}
+}
+async function bn(e) {
+	let { documentId: t, updates: n } = e, { db: r, windowMs: i } = e.params, a = /* @__PURE__ */ new Set(), o = performance.now();
+	for (let s = 0; s < n.length; s += y) {
+		let c = Y(e), l = n.slice(s, s + y).map((e) => e.recordId);
+		for (let e of H({
+			detail: `The records to patch in document "${t}"`,
+			work: function() {
+				return $e({
+					db: r,
+					table: c,
+					ids: l
+				});
+			}
+		})) a.add(e);
+		performance.now() - o >= i && (await Sn(), o = performance.now());
+	}
+	return at({
+		patches: n,
+		held: a
+	});
+}
+async function xn(e) {
+	let { documentId: t } = e, { window: n } = e.params;
+	V({
+		key: "STORE_COMMIT_FAILED",
+		detail: `Records of document "${t}" could not be committed`,
+		work: n.commitIfDue
+	}) && await Sn();
+}
+function Sn() {
+	return new Promise((e) => setTimeout(e, 0));
+}
+async function Cn(e) {
+	let { state: t, documentId: n, index: r } = e, { sqlite3: i, db: a, perf: o, window: s, tellPhase: c, onLongStatement: l } = e.params, u = Y(e);
+	c({ phase: "indexing" }), o.start("import::index");
+	try {
+		V({
+			key: "STORE_COMMIT_FAILED",
+			detail: `The ${r} index of document "${n}" could not be built`,
+			work: function() {
+				l({ work: function() {
+					s.alone(function() {
+						try {
+							kt({
+								db: a,
+								table: u,
+								index: r
+							});
+						} catch (e) {
+							throw rt({
+								sqlite3: i,
+								db: a,
+								table: u,
+								documentId: n,
+								thrown: e
+							}), e;
+						}
+					});
+				} });
+			}
+		});
+	} finally {
+		o.stop("import::index");
+	}
+	t.built.add(r), r === "id" && (t.givenIds = void 0), c({ phase: "storing" }), await Sn();
+}
+function wn(e) {
+	let { documentId: t } = e, { sqlite3: n, db: r, window: i } = e.params;
+	Y(e), V({
+		key: "STORE_COMMIT_FAILED",
+		detail: `Records of document "${t}" could not be committed`,
+		work: i.finish
+	}), V({
+		key: "STORE_COMMIT_FAILED",
+		detail: `Document "${t}" could not be marked ready`,
+		work: function() {
+			return G({
+				sqlite3: n,
+				db: r,
+				work: function() {
+					return Nt({
+						db: r,
+						documentId: t
+					});
+				}
+			});
+		}
+	}) || w({
+		documentId: t,
+		what: "its ready state"
+	});
+}
+function Tn(e) {
+	let { file: t, listener: n } = e, r = {
+		phase: "storing",
+		bytesRead: 0,
+		totalBytes: t.size
+	};
+	return {
+		onProgress: function(e) {
+			Object.assign(r, e), P({
+				listener: n,
+				value: e,
+				of: j.importProgress,
+				call: r
+			});
+		},
+		tellPhase: function({ phase: e }) {
+			P({
+				listener: n,
+				value: {
+					...r,
+					phase: e
+				},
+				of: j.importProgress,
+				call: r
+			});
+		}
+	};
+}
+function En(e) {
+	let { db: t, table: n, state: r, documentId: i, creates: a } = e;
+	if (r.built.has("id")) {
+		tt({
+			db: t,
+			table: n,
+			documentId: i,
+			creates: a
+		});
+		return;
+	}
+	let { givenIds: o } = r;
+	if (!o) return;
+	let s = nt({
+		documentId: i,
+		ids: a.map((e) => e.id),
+		heldIds: o
+	});
+	for (let e of s) o.add(e);
+}
+function Dn(e) {
+	let { db: t, documentId: n } = e;
+	return H({
+		detail: `Document "${n}"`,
+		work: function() {
+			return Mt({
+				db: t,
+				documentId: n
+			});
+		}
+	});
+}
+// src/store/sqlite/engine/reclaim.ts
+async function On(e) {
+	let { db: t, settle: n, isClosed: r, pagesPerStatement: i, sliceMs: a, onStep: o, giveWayTo: s } = e, c = performance.now();
+	for (; !r() && kn({ db: t }) > 0;) {
+		let e = s?.();
+		e ? (await e, c = performance.now()) : (n(), An({
+			db: t,
+			pages: i
+		}), o?.(), performance.now() - c < a || (await de(), c = performance.now()));
+	}
+}
+function kn(e) {
+	return Number(e.db.selectValue("PRAGMA freelist_count"));
+}
+function An(e) {
+	let t = e.db.prepare(`PRAGMA incremental_vacuum(${e.pages})`);
+	try {
+		for (; t.step(););
+	} finally {
+		t.finalize();
+	}
+}
+// src/store/sqlite/engine/sqlite-engine.ts
+function jn(e) {
+	let { sqlite3: t, db: n, dialecteId: i, expectedCreationId: o, name: s, runtime: c, ensureImportSpace: l, onWork: u, onBroken: d } = e;
+	try {
+		Pn({
+			sqlite3: t,
+			name: s
+		});
+	} catch (e) {
+		throw n.close(), e;
+	}
+	let f = e.onLongStatement ?? Rn, { explainIoFailure: p } = e, m = {
+		...r,
+		...e.options
+	}, h = tn({
+		deviceMemoryGiB: nn(),
+		rule: m.cacheRule
+	}), ee = m.steadyCacheMiB ?? h, g = Math.max(h, ee), _ = "";
+	try {
+		V({
+			key: "STORE_CONNECTION_FAILED",
+			detail: "The project file could not be opened",
+			work: function() {
+				_ = Ct({
+					sqlite3: t,
+					db: n,
+					project: s,
+					dialecteId: i,
+					expectedCreationId: o,
+					steadyCacheMiB: ee
+				}).creationId, G({
+					sqlite3: t,
+					db: n,
+					work: function() {
+						Yt({ db: n });
+					}
+				});
+			}
+		});
+	} catch (e) {
+		throw n.close(), e;
+	}
+	let v = /* @__PURE__ */ new Map(), y = /* @__PURE__ */ new Map(), b = /* @__PURE__ */ new Map(), x = { count: 0 }, S = rn(), C = {
+		window: void 0,
+		ended: void 0
+	}, T = {
+		closed: !1,
+		broken: !1
+	}, E = {
+		addBlob: async function(e, t) {
+			Z({
+				state: T,
+				name: s
+			});
+			let r = new Uint8Array(await t.arrayBuffer());
+			Z({
+				state: T,
+				name: s
+			}), H({
+				detail: `Document "${e.documentId}"`,
+				work: function() {
+					return Pt({
+						db: n,
+						documentId: e.documentId
+					});
+				}
+			}) || w({
+				documentId: e.documentId,
+				what: "a blob"
+			}), N({ value: e }), O({
+				detail: `Blob "${e.id}" could not be added`,
+				work: function() {
+					Pe({
+						db: n,
+						entry: e,
+						type: t.type,
+						bytes: r
+					});
+				}
+			});
+		},
+		getBlob: async function(e) {
+			Z({
+				state: T,
+				name: s
+			});
+			let t = H({
+				detail: `Blob "${e}"`,
+				work: function() {
+					return Fe({
+						db: n,
+						blobId: e
+					});
+				}
+			});
+			if (t) return {
+				entry: t.entry,
+				data: new Blob([t.bytes.slice()], { type: t.type })
+			};
+		},
+		getBlobsByDocument: async function(e) {
+			return Z({
+				state: T,
+				name: s
+			}), te({ filter: { documentId: e } });
+		},
+		getBlobsByRecord: async function(e, t) {
+			return Z({
+				state: T,
+				name: s
+			}), te({ filter: {
+				documentId: e,
+				recordRef: t
+			} });
+		},
+		getStandaloneBlobs: async function() {
+			return Z({
+				state: T,
+				name: s
+			}), te({ filter: "standalone" });
+		},
+		attachBlob: async function(e, t) {
+			Z({
+				state: T,
+				name: s
+			});
+			let r = D({ blobId: e });
+			return N({ value: t }), !r.attachedTo.some((e) => e.documentId === t.documentId && e.recordRef === t.recordRef && e.attribute === t.attribute) && (O({
+				detail: `Blob "${e}" could not be attached`,
+				work: function() {
+					Le({
+						db: n,
+						entry: {
+							...r,
+							attachedTo: [...r.attachedTo, t]
+						}
+					});
+				}
+			}), !0);
+		},
+		detachBlob: async function(e, t) {
+			Z({
+				state: T,
+				name: s
+			});
+			let r = D({ blobId: e }), i = r.attachedTo.filter((e) => e.documentId !== t.documentId || e.recordRef !== t.recordRef);
+			return i.length !== r.attachedTo.length && (O({
+				detail: `Blob "${e}" could not be detached`,
+				work: function() {
+					Le({
+						db: n,
+						entry: {
+							...r,
+							attachedTo: i
+						}
+					});
+				}
+			}), !0);
+		},
+		removeBlob: async function(e) {
+			return Z({
+				state: T,
+				name: s
+			}), H({
+				detail: `Blob "${e}"`,
+				work: function() {
+					return Ie({
+						db: n,
+						blobId: e
+					});
+				}
+			}) ? (O({
+				detail: `Blob "${e}" could not be removed`,
+				work: function() {
+					ze({
+						db: n,
+						blobId: e
+					});
+				}
+			}), !0) : !1;
+		},
+		registerDocument: async function(e) {
+			Z({
+				state: T,
+				name: s
+			}), V({
+				key: "STORE_COMMIT_FAILED",
+				detail: `Document "${e.id}" could not be registered`,
+				work: function() {
+					X({ importing: C }), G({
+						sqlite3: t,
+						db: n,
+						work: function() {
+							let { table: t } = jt({
+								db: n,
+								document: e
+							});
+							At({
+								db: n,
+								table: t
+							});
+						}
+					});
+				}
+			}), v.set(e.id, 0);
+		},
+		getDocument: async function(e) {
+			return Z({
+				state: T,
+				name: s
+			}), H({
+				detail: `Document "${e}"`,
+				work: function() {
+					return Pt({
+						db: n,
+						documentId: e
+					});
+				}
+			});
+		},
+		getDocuments: async function() {
+			return Z({
+				state: T,
+				name: s
+			}), H({
+				detail: "The documents",
+				work: function() {
+					return Ft({ db: n });
+				}
+			});
+		},
+		updateDocument: async function(e, r) {
+			return Z({
+				state: T,
+				name: s
+			}), V({
+				key: "STORE_COMMIT_FAILED",
+				detail: `Document "${e}" could not be updated`,
+				work: function() {
+					return X({ importing: C }), G({
+						sqlite3: t,
+						db: n,
+						work: function() {
+							return It({
+								db: n,
+								documentId: e,
+								updates: r
+							});
+						}
+					});
+				}
+			});
+		},
+		removeDocument: async function(e) {
+			return Z({
+				state: T,
+				name: s
+			}), ne({ documentId: e });
+		},
+		get: async function(e, t) {
+			return Z({
+				state: T,
+				name: s
+			}), H({
+				detail: `Record "${e}" of document "${t}"`,
+				work: function() {
+					let r = q({
+						db: n,
+						documentId: t
+					});
+					return r ? Je({
+						db: n,
+						table: r,
+						id: e
+					}) : void 0;
+				}
+			});
+		},
+		getByDocumentId: async function(e) {
+			return Z({
+				state: T,
+				name: s
+			}), H({
+				detail: `The records of document "${e}"`,
+				work: function() {
+					let t = q({
+						db: n,
+						documentId: e
+					});
+					return t ? Ye({
+						db: n,
+						table: t
+					}) : [];
+				}
+			});
+		},
+		count: async function(e) {
+			Z({
+				state: T,
+				name: s
+			});
+			let t = v.get(e);
+			return t === void 0 ? H({
+				detail: `The record count of document "${e}"`,
+				work: function() {
+					let t = q({
+						db: n,
+						documentId: e
+					});
+					if (!t) return 0;
+					let r = et({
+						db: n,
+						table: t
+					});
+					return v.set(e, r), r;
+				}
+			}) : t;
+		},
+		getByTagNameInDocument: async function(e, t) {
+			return Z({
+				state: T,
+				name: s
+			}), H({
+				detail: `The ${e} records of document "${t}"`,
+				work: function() {
+					let r = q({
+						db: n,
+						documentId: t
+					});
+					return r ? Xe({
+						db: n,
+						table: r,
+						tagName: e
+					}) : [];
+				}
+			});
+		},
+		getMany: async function(e, t) {
+			return Z({
+				state: T,
+				name: s
+			}), H({
+				detail: `Records of document "${t}"`,
+				work: function() {
+					let r = q({
+						db: n,
+						documentId: t
+					});
+					if (!r) return e.map(() => void 0);
+					let i = Ze({
+						db: n,
+						table: r,
+						ids: e
+					});
+					return e.map((e) => i.get(e));
+				}
+			});
+		},
+		getWriteOutcome: async function({ writeId: e }) {
+			return Z({
+				state: T,
+				name: s
+			}), H({
+				detail: `The outcome of write "${e}"`,
+				work: function() {
+					if (S.awaitsRow({ writeId: e })) return "running";
+					let t = Xt({
+						db: n,
+						writeId: e
+					});
+					return he({
+						documents: t,
+						writeId: e,
+						committed: vt({
+							db: n,
+							writeId: e
+						}),
+						isRunning: S.runs
+					});
+				}
+			});
+		},
+		bulkWrite: async function(e, r) {
+			Z({
+				state: T,
+				name: s
+			});
+			let { creates: i = [], updates: a = [], deletes: o = [] } = r, c = In({
+				sqlite3: t,
+				db: n,
+				documentId: e,
+				creates: i,
+				updates: a,
+				deletes: o,
+				importing: C
+			});
+			return k({
+				documentId: e,
+				gained: i.length - c
+			}), i.length > 0 || a.length > 0 || c > 0;
+		},
+		commit: async function(e, r) {
+			Z({
+				state: T,
+				name: s
+			});
+			let { documentId: i, creates: a, updates: o, deletes: c } = e;
+			k({
+				documentId: i,
+				gained: Zt({
+					...e,
+					sqlite3: t,
+					db: n,
+					settle: function() {
+						X({ importing: C });
+					}
+				})
+			}), xe({
+				onProgress: r,
+				parts: [
+					a.length,
+					o.length,
+					c.length
+				]
+			});
+		},
+		undo: async function(e) {
+			return Z({
+				state: T,
+				name: s
+			}), j({
+				documentId: e,
+				direction: "back"
+			});
+		},
+		redo: async function(e) {
+			return Z({
+				state: T,
+				name: s
+			}), j({
+				documentId: e,
+				direction: "forward"
+			});
+		},
+		getHistoryStatus: async function(e) {
+			return Z({
+				state: T,
+				name: s
+			}), H({
+				detail: `The history of document "${e}"`,
+				work: function() {
+					return gt({
+						db: n,
+						documentId: e
+					});
+				}
+			});
+		},
+		getChangeLog: async function(e) {
+			return Z({
+				state: T,
+				name: s
+			}), H({
+				detail: `The changelog of document "${e}"`,
+				work: function() {
+					let t = zt({
+						db: n,
+						documentId: e
+					});
+					return t ? _t({
+						db: n,
+						documentId: e,
+						table: t.history
+					}) : [];
+				}
+			});
+		}
+	};
+	function D(e) {
+		let { blobId: t } = e, r = H({
+			detail: `Blob "${t}"`,
+			work: function() {
+				return Ie({
+					db: n,
+					blobId: t
+				});
+			}
+		});
+		return r || I("STORE_BLOB_NOT_FOUND", { detail: `Blob "${t}" not found` }), r;
+	}
+	function te(e) {
+		return H({
+			detail: "The blobs",
+			work: function() {
+				return Re({
+					db: n,
+					filter: e.filter
+				});
+			}
+		});
+	}
+	async function ne(e) {
+		let { documentId: r } = e, i = `Document "${r}" could not be removed`, a = !1;
+		try {
+			V({
+				key: "STORE_DELETE_FAILED",
+				detail: i,
+				work: function() {
+					X({ importing: C }), f({ work: function() {
+						G({
+							sqlite3: t,
+							db: n,
+							work: function() {
+								a = Rt({
+									db: n,
+									documentId: r
+								});
+							}
+						});
+					} }), v.delete(r);
+				}
+			});
+		} finally {
+			x.count += 1, y.set(r, (y.get(r) ?? 0) + 1);
+		}
+		try {
+			await re({ background: !1 });
+		} catch (e) {
+			throw Ke({
+				key: "STORE_DELETE_FAILED",
+				detail: i,
+				thrown: e
+			});
+		}
+		return a;
+	}
+	function re(e) {
+		return On({
+			giveWayTo: e.background ? le : void 0,
+			db: n,
+			settle: function() {
+				X({ importing: C });
+			},
+			isClosed: function() {
+				return T.closed;
+			},
+			pagesPerStatement: m.reclaimPagesPerStatement,
+			sliceMs: m.reclaimSliceMs,
+			onStep: u
+		});
+	}
+	function O(e) {
+		let { detail: r, work: i } = e;
+		V({
+			key: "STORE_COMMIT_FAILED",
+			detail: r,
+			work: function() {
+				X({ importing: C }), G({
+					sqlite3: t,
+					db: n,
+					work: i
+				});
+			}
+		});
+	}
+	function k(e) {
+		let { documentId: t, gained: n } = e, r = v.get(t);
+		r !== void 0 && v.set(t, r + n), y.set(t, (y.get(t) ?? 0) + 1);
+	}
+	function A(e) {
+		let { signal: t, documentId: r, reads: i } = e;
+		function a() {
+			ie({
+				signal: t,
+				documentId: r
+			});
+		}
+		return {
+			getDocument: async function(e) {
+				return a(), E.getDocument(e);
+			},
+			count: async function(e) {
+				return a(), E.count(e);
+			},
+			getMany: async function(e, t) {
+				return a(), Z({
+					state: T,
+					name: s
+				}), H({
+					detail: `Records of document "${t}"`,
+					work: function() {
+						let n = ge({
+							reads: i,
+							documentId: t
+						})?.read(e);
+						return e.map((e) => n?.get(e));
+					}
+				});
+			},
+			getByTagNameInDocument: async function(e, t) {
+				return a(), E.getByTagNameInDocument(e, t);
+			},
+			getExportVersion: async function({ documentId: e }) {
+				if (a(), Z({
+					state: T,
+					name: s
+				}), H({
+					detail: `Document "${e}"`,
+					work: function() {
+						return Mt({
+							db: n,
+							documentId: e
+						});
+					}
+				})?.status === "ready") return y.get(e) ?? 0;
+			}
+		};
+	}
+	function j(e) {
+		let { documentId: r, direction: i } = e, a = Qt({
+			sqlite3: t,
+			db: n,
+			documentId: r,
+			direction: i,
+			settle: function() {
+				X({ importing: C });
+			}
+		});
+		return a !== void 0 && (k({
+			documentId: r,
+			gained: a
+		}), !0);
+	}
+	async function ae(e) {
+		let { thrown: n } = e;
+		if (pe(n)?.key === "STORE_READ_FAILED") return n;
+		let r = qe({ thrown: n });
+		return r === t.capi.SQLITE_FULL ? F("STORE_QUOTA_EXCEEDED", {
+			detail: `The file of project "${s}" can grow no more`,
+			meta: { project: s },
+			cause: n instanceof Error ? n : void 0
+		}) : r === t.capi.SQLITE_IOERR && p ? await p({ thrown: n }) ?? n : n;
+	}
+	async function ce(e, r) {
+		Z({
+			state: T,
+			name: s
+		});
+		let i = ye({
+			runtime: c,
+			storeName: s,
+			operation: "import"
+		}), { file: a, options: o, writeId: d, clientId: p } = e;
+		return S.run({
+			writeId: d,
+			clientId: p,
+			work: async function(e) {
+				z({
+					signal: e,
+					file: a
+				}), l && (await l({ bytes: Nn({
+					db: n,
+					file: a
+				}) }), z({
+					signal: e,
+					file: a
+				}));
+				let s = oe({
+					enabled: i.perf ?? !1,
+					timeline: !1
+				}), c = ln({
+					sqlite3: t,
+					db: n,
+					perf: s,
+					windowMs: m.importWindowMs,
+					importCacheMiB: g,
+					steadyCacheMiB: ee
+				}), p = Tn({
+					file: a,
+					listener: function(e) {
+						return u?.(), r?.(e);
+					}
+				}), h = hn({
+					sqlite3: t,
+					db: n,
+					perf: s,
+					signal: e,
+					file: a,
+					counts: v,
+					removeDocument: async function({ documentId: e }) {
+						await ne({ documentId: e });
+					},
+					window: c,
+					windowMs: m.importWindowMs,
+					tellPhase: p.tellPhase,
+					onLongStatement: f,
+					onRegistered: function() {
+						S.markRegistered({ writeId: d });
+					},
+					customIds: o?.useCustomRecordsIds ?? !1
+				}), _ = Promise.withResolvers();
+				C.window = c, C.ended = _.promise;
+				try {
+					let t = await _e({
+						store: h,
+						runtime: i,
+						file: a,
+						options: o,
+						writeId: d,
+						perf: s
+					}, {
+						onProgress: p.onProgress,
+						signal: e
+					});
+					return V({
+						key: "STORE_COMMIT_FAILED",
+						detail: `The import of "${a.name}" could not end`,
+						work: c.end
+					}), t;
+				} catch (e) {
+					throw mn({ window: c }), await ae({ thrown: e });
+				} finally {
+					C.window = void 0, C.ended = void 0, _.resolve(), ue();
+				}
+			}
+		});
+	}
+	function le() {
+		return C.ended;
+	}
+	function ue() {
+		if (n.isOpen() && t.capi.sqlite3_get_autocommit(n) === 0) {
+			T.broken = !0;
+			try {
+				fe();
+			} catch {} finally {
+				d?.();
+			}
+		}
+	}
+	function fe() {
+		T.closed = !0;
+		try {
+			S.abortAll();
+			for (let { controller: e, reads: t } of b.values()) e.abort(), Fn({ reads: t });
+		} finally {
+			n.close();
+		}
+	}
+	async function M(e) {
+		S.abort(e);
+	}
+	async function P(e, t) {
+		Z({
+			state: T,
+			name: s
+		});
+		let r = ye({
+			runtime: c,
+			storeName: s,
+			operation: "export"
+		}), { documentId: i, options: a, exportId: o, clientId: l } = e;
+		me(!b.has(o), { detail: `An export of id "${o}" runs already: give each export an id of its own` });
+		let d = new AbortController(), f = { current: void 0 };
+		b.set(o, {
+			clientId: l,
+			controller: d,
+			reads: f
+		});
+		try {
+			return await de(), await se({
+				source: A({
+					signal: d.signal,
+					documentId: i,
+					reads: f
+				}),
+				runtime: r,
+				documentId: i,
+				options: a
+			}, {
+				onProgress: function(e) {
+					return u?.(), t?.(e);
+				},
+				signal: d.signal
+			});
+		} finally {
+			b.delete(o), n.isOpen() && Fn({ reads: f });
+		}
+	}
+	function ge(e) {
+		let { reads: t, documentId: r } = e, i = t.current;
+		if (i && i.documentId === r && i.removals === x.count) return i.statement;
+		i?.statement.finalize(), t.current = void 0;
+		let a = q({
+			db: n,
+			documentId: r
+		});
+		if (a) return t.current = {
+			documentId: r,
+			removals: x.count,
+			statement: Qe({
+				db: n,
+				table: a
+			})
+		}, t.current.statement;
+	}
+	async function L(e) {
+		b.get(e.exportId)?.controller.abort();
+	}
+	let R = { ...E };
+	for (let e of a) {
+		let t = E[e];
+		Object.assign(R, { [e]: async function(...e) {
+			try {
+				return await t(...e);
+			} catch (e) {
+				throw await ae({ thrown: e });
+			}
+		} });
+	}
+	return re({ background: !0 }).catch(Mn), {
+		...R,
+		creationId: _,
+		importFile: ce,
+		abortImport: M,
+		exportFile: P,
+		abortExport: L,
+		abortExportsOf: function({ clientId: e }) {
+			for (let t of b.values()) t.clientId === e && t.controller.abort();
+		},
+		abortImportsOf: function(e) {
+			S.abortOwnedBy(e);
+		},
+		clientView: function({ clientId: e }) {
+			return {
+				...R,
+				importFile: function(t, n) {
+					return ce({
+						...t,
+						clientId: e
+					}, n);
+				},
+				abortImport: M,
+				exportFile: function(t, n) {
+					return P({
+						...t,
+						clientId: e
+					}, n);
+				},
+				abortExport: L
+			};
+		},
+		close: fe
+	};
+}
+function Mn() {}
+function Nn(e) {
+	let { db: t, file: n } = e, r = Number(t.selectValue("PRAGMA freelist_count")) * Number(t.selectValue("PRAGMA page_size")), i = Math.max(o, 8 * n.size);
+	return Math.max(0, i - r);
+}
+function X(e) {
+	e.importing.window?.settle();
+}
+function Pn(e) {
+	let { sqlite3: t, name: n } = e;
+	Ae({ sqlite3: t }) || I("ASSERTION_FAILED", { detail: `The engine of "${n}" runs on a SQLite whose text codec is not installed: load SQLite with loadSqlite` });
+}
+function Fn(e) {
+	let { reads: t } = e;
+	t.current?.statement.finalize(), t.current = void 0;
+}
+function Z(e) {
+	let { state: t, name: n } = e;
+	t.broken && I("STORE_ENGINE_LOST", {
+		detail: `The project engine of "${n}" broke (an import left its connection inside a transaction): the next call starts the next one`,
+		meta: { reason: "host-gone" }
+	}), t.closed && D({ storeName: n });
+}
+function In(e) {
+	let { sqlite3: t, db: n, documentId: r, creates: i, updates: a, deletes: o, importing: s } = e, c = `Records of document "${r}" could not be written`, l = H({
+		detail: `Document "${r}"`,
+		work: function() {
+			return q({
+				db: n,
+				documentId: r
+			});
+		}
+	});
+	l || w({
+		documentId: r,
+		what: "records"
+	});
+	let u = Ve({ records: i });
+	return H({
+		detail: `The ids of document "${r}"`,
+		work: function() {
+			tt({
+				db: n,
+				table: l,
+				documentId: r,
+				creates: i
+			});
+		}
+	}), V({
+		key: "STORE_COMMIT_FAILED",
+		detail: c,
+		work: function() {
+			return X({ importing: s }), G({
+				sqlite3: t,
+				db: n,
+				work: function() {
+					return Ln({
+						db: n,
+						table: l,
+						rows: u,
+						updates: a,
+						deletes: o,
+						detail: c
+					});
+				}
+			});
+		}
+	});
+}
+function Ln(e) {
+	let { db: t, table: n, rows: r, updates: i, deletes: a, detail: o } = e;
+	return V({
+		key: "STORE_BULK_ADD_FAILED",
+		detail: o,
+		work: function() {
+			Ue({
+				db: t,
+				table: n,
+				rows: r
+			});
+		}
+	}), V({
+		key: "STORE_BULK_UPDATE_FAILED",
+		detail: o,
+		work: function() {
+			it({
+				db: t,
+				table: n,
+				patches: i
+			}), ot({
+				db: t,
+				table: n,
+				patches: i
+			});
+		}
+	}), V({
+		key: "STORE_DELETE_FAILED",
+		detail: o,
+		work: function() {
+			return st({
+				db: t,
+				table: n,
+				ids: a
+			});
+		}
+	});
+}
+function Rn(e) {
+	return e.work();
+}
+// src/store/sqlite/load-sqlite.ts
+var zn = Se, Bn, Vn;
+function Hn(e = {}) {
+	let { wasmUrl: t } = e, n = globalThis;
+	if (n.sqlite3ApiConfig = {
+		...n.sqlite3ApiConfig,
+		disable: { vfs: Ee }
+	}, t !== void 0 && Vn !== void 0 && t !== Vn) throw F("ASSERTION_FAILED", { detail: `SQLite is loaded in this realm from "${Vn}", not from "${t}": one wasm file per realm` });
+	return Bn || (Vn = t), Bn ??= (t ? zn({ locateFile: function() {
+		return t;
+	} }) : zn()).then(function(e) {
+		return ke({ sqlite3: e }), e;
+	}), Bn;
+}
+// src/store/sqlite/adapter/in-process-link.ts
+var Q = /* @__PURE__ */ new Map(), $ = /* @__PURE__ */ new Map(), Un = /* @__PURE__ */ new WeakMap();
+function Wn(e) {
+	return te({
+		project: e.name,
+		dialecteId: e.dialecteId
+	}), {
+		connect: function() {
+			return Gn(e);
+		},
+		destroy: async function(t) {
+			let n = t?.own, r = Qn(e), i = $.get(r), a = (i?.size ?? 0) - (n !== void 0 && i?.has(n.link) ? 1 : 0);
+			a > 0 && C({
+				storeName: e.name,
+				connections: a
+			}), n?.letGo(), Xn({ key: r });
+		}
+	};
+}
+async function Gn(e) {
+	let { name: n } = e, r = Qn(e), i = $.get(r) ?? /* @__PURE__ */ new Set();
+	$.set(r, i);
+	let a = crypto.randomUUID(), o = !1, s, c, l = /* @__PURE__ */ new Set(), u = {
+		engine: async function() {
+			o && D({ storeName: n });
+			let i = await Yn({
+				...e,
+				expectedCreationId: s
+			});
+			return t({
+				project: n,
+				expectedCreationId: s,
+				creationId: i.creationId
+			}), s = i.creationId, c !== void 0 && c !== i && qn({
+				link: u,
+				notice: { type: "resync" }
+			}), c = i, Kn({
+				view: i.clientView({ clientId: a }),
+				announce: function(e) {
+					let t = we({
+						...e,
+						connectionId: a
+					});
+					if (t) for (let e of $.get(r) ?? []) qn({
+						link: e,
+						notice: {
+							type: "event",
+							signal: t
+						}
+					});
+				}
+			});
+		},
+		connectionId: a,
+		onNotice: function(e) {
+			return o ? Jn : (l.add(e), function() {
+				l.delete(e);
+			});
+		},
+		close: async function() {
+			if (o = !0, l.clear(), !i.delete(u) || i.size > 0) return;
+			$.delete(r);
+			let e = Q.get(r);
+			e?.engine?.close(), e && (e.engine = void 0);
+		}
+	};
+	return Un.set(u, l), i.add(u), u;
+}
+function Kn(e) {
+	let { view: t, announce: n } = e;
+	return Object.fromEntries(Object.keys(t).map(function(e) {
+		let r = t[e];
+		return [e, async function(...t) {
+			let i = await r(...t);
+			return n({
+				member: e,
+				args: t,
+				value: i
+			}), i;
+		}];
+	}));
+}
+function qn(e) {
+	ae({
+		listeners: Un.get(e.link) ?? [],
+		value: e.notice,
+		of: j.engineChanges
+	});
+}
+function Jn() {}
+async function Yn(e) {
+	let { name: n, dialecteId: r, runtime: i, options: a, expectedCreationId: o } = e, s = Qn(e), c = await Hn({ wasmUrl: b() }), l = Q.get(s);
+	l || t({
+		project: n,
+		expectedCreationId: o,
+		creationId: void 0
+	});
+	let u = l ?? { keeper: new c.oo1.DB(Zn({ key: s }), "c") };
+	if (Q.set(s, u), !u.engine) {
+		let e = jn({
+			sqlite3: c,
+			db: new c.oo1.DB(Zn({ key: s }), "c"),
+			dialecteId: r,
+			expectedCreationId: o,
+			name: n,
+			runtime: i,
+			options: a,
+			onBroken: function() {
+				u.engine === e && (u.engine = void 0);
+			}
+		});
+		u.engine = e;
+	}
+	return u.engine;
+}
+function Xn(e) {
+	let t = Q.get(e.key);
+	t && (t.engine?.close(), t.keeper.close(), Q.delete(e.key));
+}
+function Zn(e) {
+	return `file:/${encodeURIComponent(e.key)}?vfs=memdb`;
+}
+function Qn(e) {
+	return ue({
+		dialecteId: e.dialecteId,
+		project: e.name
+	});
+}
+export { Wn as createInProcessConnector };