@dialecte/core 0.6.4 → 0.8.0

package/dist/sqlite.js

@@ -0,0 +1,2671 @@
+import { a as e, n as t } from "./running-operations-vnijBvn7.js";
+import { n, t as r } from "./engine-store-CIEqgPUb.js";
+import { A as i, C as a, M as o, P as s, _ as c, b as l, n as u, p as d, r as f, t as p, y as m } from "./project-key-Ch34EtFa.js";
+import { C as h, T as g } from "./engine.constants-DBMjMmV9.js";
+import { G as _, V as v, W as ee } from "./utils-USNkj4sT.js";
+import * as y from "comlink";
+// src/store/engine/client/client.constants.ts
+var te = 1e4, b = 2e3, x = 1e3, S = 3e4, C = 1e4, w = "unanswered", ne = {
+	"host-gone": "The project engine ended with the view that hosted it",
+	"no-heartbeat": "The project engine sent nothing for too long while a call waited",
+	"realm-dropped": "This view was dropped with the page that bound it: bound again, it reaches the engine"
+};
+// src/store/engine/dialecte-refusal.ts
+function T(e) {
+	let { project: t, engine: n, asked: r } = e;
+	if (r.dialecteId !== n.dialecteId) throw v("PROJECT_DIALECTE_MISMATCH", {
+		detail: `"${t}" was asked as ${r.dialecteId} of an engine of ${n.dialecteId}: nothing was opened or removed`,
+		meta: {
+			project: t,
+			projectDialecteId: n.dialecteId,
+			realmDialecteId: r.dialecteId
+		}
+	});
+	if (r.dialecteVersion !== void 0 && r.dialecteVersion !== n.dialecteVersion) throw v("PROJECT_DIALECTE_VERSION_MISMATCH", {
+		detail: `the engine of "${t}" runs ${n.dialecteId} ${n.dialecteVersion}, the view ${r.dialecteVersion}`,
+		meta: {
+			project: t,
+			dialecteId: n.dialecteId,
+			engineVersion: n.dialecteVersion,
+			realmVersion: r.dialecteVersion
+		}
+	});
+}
+// src/store/engine/client/check-engine-wire.ts
+function E(e) {
+	let { found: t } = e;
+	if (t !== 2) throw v("STORE_PROTOCOL_MISMATCH", {
+		detail: `The project engine speaks wire version ${t}, this page 2: another version of the library`,
+		meta: {
+			expected: 2,
+			found: t
+		}
+	});
+}
+// src/store/engine/wire/error-envelope.ts
+function re(e) {
+	return O({
+		thrown: e.thrown,
+		depth: 0
+	});
+}
+function D(e) {
+	let { data: t } = e;
+	switch (t.kind) {
+		case "dialecte": {
+			let { cause: e, ...n } = t.error, r = Error(t.message);
+			t.stack !== void 0 && (r.stack = t.stack);
+			let i = { ...n };
+			return e && (i.cause = A({ value: D({ data: e }) })), r.cause = i, r;
+		}
+		case "error": {
+			let e = Error(t.message);
+			return e.name = t.name, t.stack !== void 0 && (e.stack = t.stack), t.cause && (e.cause = D({ data: t.cause })), e;
+		}
+		case "value": return t.value;
+	}
+}
+function O(e) {
+	let { thrown: t, depth: n } = e, r = _(t);
+	if (r && t instanceof Error) {
+		let { cause: e, meta: i, ref: a, ...o } = r, s = { ...o };
+		return i !== void 0 && (s.meta = k({ value: i })), a !== void 0 && (s.ref = k({ value: a })), e !== void 0 && n < 4 && (s.cause = O({
+			thrown: e,
+			depth: n + 1
+		})), {
+			kind: "dialecte",
+			message: t.message,
+			stack: t.stack,
+			error: s
+		};
+	}
+	if (t instanceof Error) {
+		let e = {
+			kind: "error",
+			name: t.name,
+			message: t.message,
+			stack: t.stack
+		};
+		return t.cause !== void 0 && n < 4 && (e.cause = O({
+			thrown: t.cause,
+			depth: n + 1
+		})), e;
+	}
+	return {
+		kind: "value",
+		value: k({ value: t })
+	};
+}
+function k(e) {
+	let { value: t, ancestors: n = /* @__PURE__ */ new Set() } = e;
+	if (ie({ value: t })) return t;
+	if (typeof t != "object" || !t || n.has(t)) return String(t);
+	let r = Object.getPrototypeOf(t), i = Array.isArray(t);
+	if (r !== (i ? Array.prototype : Object.prototype) && r !== null) return String(t);
+	n.add(t);
+	let a = i ? t.map(function(e) {
+		return k({
+			value: e,
+			ancestors: n
+		});
+	}) : Object.fromEntries(Object.entries(t).map(function([e, t]) {
+		return [e, k({
+			value: t,
+			ancestors: n
+		})];
+	}));
+	return n.delete(t), a;
+}
+function ie(e) {
+	try {
+		return structuredClone(e.value), !0;
+	} catch {
+		return !1;
+	}
+}
+function A(e) {
+	let { value: t } = e;
+	return t instanceof Error ? t : Error(String(t));
+}
+// src/store/engine/wire/wire-values.ts
+function j(e) {
+	let t = [];
+	return {
+		values: e.values.map(function(e, n) {
+			return M({
+				step: {
+					index: n,
+					path: [],
+					ancestors: /* @__PURE__ */ new Map(),
+					standIns: t
+				},
+				read: function() {
+					return e;
+				}
+			});
+		}),
+		standIns: t
+	};
+}
+function M(e) {
+	let { step: t, read: n } = e, r;
+	try {
+		r = n();
+	} catch (e) {
+		return P({
+			step: t,
+			kind: "throwing-read",
+			message: ae({ thrown: e })
+		});
+	}
+	try {
+		return oe({
+			step: t,
+			value: r
+		});
+	} catch (e) {
+		return P({
+			step: t,
+			kind: "throwing-inspection",
+			message: ae({ thrown: e })
+		});
+	}
+}
+function ae(e) {
+	let { thrown: t } = e;
+	return t instanceof Error ? t.message : String(t);
+}
+function oe(e) {
+	let { step: t, value: n } = e;
+	switch (typeof n) {
+		case "function": return P({
+			step: t,
+			kind: "function"
+		});
+		case "symbol": return P({
+			step: t,
+			kind: "symbol",
+			text: n.description
+		});
+		case "object": return n === null ? null : N({
+			step: t,
+			held: n
+		});
+		default: return n;
+	}
+}
+function N(e) {
+	let { step: t, held: n } = e, r = Array.isArray(n), i = Object.getPrototypeOf(n);
+	if (!a({
+		prototype: i,
+		name: r ? "Array" : "Object"
+	})) return se({
+		step: t,
+		held: n
+	});
+	if (i === null && JSON.isRawJSON?.(n)) return P({
+		step: t,
+		kind: "raw-json",
+		text: n.rawJSON
+	});
+	if (typeof n.toJSON == "function") return P({
+		step: t,
+		kind: "to-json"
+	});
+	if (t.ancestors.has(n)) return t.ancestors.get(n);
+	if (t.ancestors.size >= 512) return r ? [] : {};
+	let o = r ? void 0 : Object.keys(n), s = r ? [] : {};
+	t.ancestors.set(n, s);
+	try {
+		r ? le({
+			step: t,
+			held: n,
+			copy: s
+		}) : ue({
+			step: t,
+			held: n,
+			keys: o,
+			copy: s
+		});
+	} finally {
+		t.ancestors.delete(n);
+	}
+	return s;
+}
+function se(e) {
+	let { step: t, held: n } = e;
+	P({
+		step: t,
+		kind: "instance",
+		name: n.constructor?.name ?? ""
+	});
+	let r = {};
+	if (ArrayBuffer.isView(n) || n instanceof ArrayBuffer) return r;
+	try {
+		for (let e of Object.keys(n)) {
+			let t = n[e];
+			ce({ value: t }) && Object.defineProperty(r, e, {
+				value: t,
+				writable: !0,
+				enumerable: !0,
+				configurable: !0
+			});
+		}
+	} catch {}
+	return r;
+}
+function ce(e) {
+	let { value: t } = e, n = typeof t;
+	return t === null || n === "string" || n === "boolean" || n === "number" && Number.isFinite(t);
+}
+function le(e) {
+	let { step: t, held: n, copy: r } = e, { length: i } = n;
+	for (let e = 0; e < i; e += 1) {
+		t.path.push(e);
+		try {
+			r.push(M({
+				step: t,
+				read: function() {
+					return n[e];
+				}
+			}));
+		} finally {
+			t.path.pop();
+		}
+	}
+}
+function ue(e) {
+	let { step: t, held: n, keys: r, copy: i } = e;
+	for (let e of r) {
+		t.path.push(e);
+		let r;
+		try {
+			r = M({
+				step: t,
+				read: function() {
+					return n[e];
+				}
+			});
+		} finally {
+			t.path.pop();
+		}
+		e === "__proto__" ? Object.defineProperty(i, e, {
+			value: r,
+			writable: !0,
+			enumerable: !0,
+			configurable: !0
+		}) : i[e] = r;
+	}
+}
+function P(e) {
+	let { step: t, kind: n, name: r, text: i, message: a } = e;
+	return t.standIns.push({
+		index: t.index,
+		path: [...t.path],
+		kind: n,
+		name: r,
+		text: i,
+		message: a
+	}), null;
+}
+function F(e) {
+	let { args: t, places: n } = e, r = t.map(function(e, t) {
+		let r = n.filter(function(e) {
+			return e.argument === t;
+		});
+		return r.some(pe) ? e : L({
+			value: e,
+			skip: new Set(r.map(me)),
+			copies: /* @__PURE__ */ new Map()
+		});
+	}), i = j({ values: n.map(function(e) {
+		return de({
+			args: t,
+			place: e
+		});
+	}) });
+	return {
+		args: fe({
+			args: r,
+			places: n,
+			values: i.values
+		}),
+		standIns: i.standIns
+	};
+}
+function de(e) {
+	let { args: t, place: n } = e, r = t[n.argument];
+	for (let e of n.path ?? []) {
+		if (r == null) return;
+		r = r[e];
+	}
+	return r;
+}
+function fe(e) {
+	let { args: t, places: n, values: r } = e, i = [...t];
+	return n.forEach(function(e, t) {
+		i[e.argument] = I({
+			holder: i[e.argument],
+			path: e.path ?? [],
+			value: r[t]
+		});
+	}), i;
+}
+function I(e) {
+	let { holder: t, path: n, value: r } = e;
+	if (n.length === 0) return r;
+	if (t == null) return t;
+	let [i, ...a] = n, o = t;
+	return {
+		...o,
+		[i]: I({
+			holder: o[i],
+			path: a,
+			value: r
+		})
+	};
+}
+function L(e) {
+	let { value: t, skip: n, copies: r } = e;
+	if (typeof t != "object" || !t) return t;
+	if (r.has(t)) return r.get(t);
+	let i = Array.isArray(t);
+	if (!a({
+		prototype: Object.getPrototypeOf(t),
+		name: i ? "Array" : "Object"
+	})) return t;
+	if (i) {
+		let e = [];
+		r.set(t, e);
+		for (let n of t) e.push(L({
+			value: n,
+			copies: r
+		}));
+		return e;
+	}
+	let o = {};
+	r.set(t, o);
+	for (let e of Object.keys(t)) {
+		let i = t[e];
+		Object.defineProperty(o, e, {
+			value: n?.has(e) ? i : L({
+				value: i,
+				copies: r
+			}),
+			writable: !0,
+			enumerable: !0,
+			configurable: !0
+		});
+	}
+	return o;
+}
+function pe(e) {
+	return (e.path ?? []).length === 0;
+}
+function me(e) {
+	return e.path[0];
+}
+// src/store/engine/client/heartbeat-watch.ts
+function he(e) {
+	let { source: t, timeoutMs: n, waiting: r, lose: i } = e, a = performance.now(), o = e.busy ?? !1, s;
+	function c(e) {
+		a = performance.now();
+		let t = e.data?.type;
+		t === f.busy && (o = !0), t === f.heartbeat && (o = !1), u({ delayMs: n });
+	}
+	function l() {
+		a = performance.now(), u({ delayMs: n });
+	}
+	function u(e) {
+		s === void 0 && (s = setTimeout(p, e.delayMs));
+	}
+	function p() {
+		if (s = void 0, r() === 0) return;
+		let e = performance.now() - a;
+		o || e < n ? u({ delayMs: o ? n : n - e }) : d().then(m);
+	}
+	function m() {
+		r() !== 0 && s === void 0 && (o || performance.now() - a < n ? u({ delayMs: 0 }) : i());
+	}
+	let h = globalThis.document;
+	return t.addEventListener("message", c), h?.addEventListener("resume", l), globalThis.addEventListener?.("pageshow", l), {
+		restart: l,
+		stop: function() {
+			s !== void 0 && clearTimeout(s), s = void 0, t.removeEventListener("message", c), h?.removeEventListener("resume", l), globalThis.removeEventListener?.("pageshow", l);
+		}
+	};
+}
+// src/store/engine/client/engine-client.ts
+function R(e) {
+	let { port: t, heartbeatTimeoutMs: r = C } = e, i = y.wrap(t), a = /* @__PURE__ */ new Set(), o = ge({ port: t }), s = _e({ port: t }), c = /* @__PURE__ */ new Set(), l = he({
+		source: t,
+		timeoutMs: r,
+		waiting: function() {
+			return a.size;
+		},
+		lose: function() {
+			u({ reason: "no-heartbeat" });
+		}
+	});
+	function u(e) {
+		let { reason: t } = e;
+		for (let e of a) ve({
+			entry: e,
+			reason: t,
+			unanswered: c
+		}), t === "no-heartbeat" && e.exportId !== void 0 && d({ exportId: e.exportId });
+		a.clear(), o.clear();
+	}
+	function d(e) {
+		let t = n.abortExport, r = F({
+			args: [e],
+			places: t.json ?? []
+		});
+		i.call({
+			member: "abortExport",
+			args: r.args,
+			standIns: r.standIns
+		}).catch(function() {});
+	}
+	function f(e) {
+		let { member: t, args: r, connectionId: s } = e, u = n[t], d = u.listener === void 0 ? void 0 : r[u.listener], f = u.listener === void 0 ? r : r.slice(0, u.listener), p = u.identified ? f[0].writeId : void 0, m = u.abortable ? f[0].exportId : void 0;
+		if (t === "getWriteOutcome") {
+			let e = f[0].writeId;
+			if (c.has(e)) return Promise.resolve("running");
+		}
+		let h = F({
+			args: f,
+			places: u.json ?? []
+		});
+		return new Promise(function(e, n) {
+			let r = typeof d == "function" ? o.add({ listener: d }) : void 0, u = {
+				writeId: p,
+				exportId: m,
+				reject: n,
+				lost: !1
+			};
+			a.size === 0 && l.restart(), a.add(u), i.call({
+				member: t,
+				args: h.args,
+				standIns: h.standIns,
+				progressId: r,
+				...s !== void 0 && { connectionId: s }
+			}).then(function(t) {
+				o.remove({ progressId: r }), a.delete(u), p !== void 0 && c.delete(p), u.lost || (t.ok ? e(t.value) : n(D({ data: t.thrown })));
+			}, function(e) {
+				o.remove({ progressId: r }), a.delete(u), u.lost || n(e);
+			});
+		});
+	}
+	function p(e) {
+		let { connectionId: t } = e;
+		return Object.fromEntries(Object.keys(n).map(function(e) {
+			return [e, function(...n) {
+				return f({
+					member: e,
+					args: n,
+					connectionId: t
+				});
+			}];
+		}));
+	}
+	return {
+		api: p({ connectionId: void 0 }),
+		connection: function({ connectionId: e }) {
+			return p({ connectionId: e });
+		},
+		onEvent: function(e) {
+			return s.add({ listener: e });
+		},
+		lose: u,
+		close: function({ storeName: e }) {
+			l.stop(), o.stop(), s.stop();
+			for (let t of a) t.lost = !0, t.reject(v("STORE_CLOSED", {
+				detail: `The connection to project "${e}" was released while a call waited`,
+				meta: { storeName: e }
+			}));
+			a.clear(), t.close();
+		}
+	};
+}
+function ge(e) {
+	let { port: t } = e, n = /* @__PURE__ */ new Map(), r = 0;
+	function i(e) {
+		let t = e.data;
+		if (t?.type !== f.progress) return;
+		let r = n.get(t.progressId);
+		m({
+			listener: r && function(e) {
+				return r.listener(...e);
+			},
+			value: t.progress,
+			of: c.callProgress,
+			call: r
+		});
+	}
+	return t.addEventListener("message", i), {
+		add: function({ listener: e }) {
+			return r += 1, n.set(r, { listener: e }), r;
+		},
+		remove: function({ progressId: e }) {
+			e !== void 0 && n.delete(e);
+		},
+		clear: function() {
+			n.clear();
+		},
+		stop: function() {
+			n.clear(), t.removeEventListener("message", i);
+		}
+	};
+}
+function _e(e) {
+	let { port: t } = e, n = /* @__PURE__ */ new Set();
+	function r(e) {
+		let t = e.data;
+		t?.type === f.event && l({
+			listeners: n,
+			value: t,
+			of: c.engineChanges
+		});
+	}
+	return t.addEventListener("message", r), t.start(), {
+		add: function({ listener: e }) {
+			return n.add(e), function() {
+				n.delete(e);
+			};
+		},
+		stop: function() {
+			n.clear(), t.removeEventListener("message", r);
+		}
+	};
+}
+function ve(e) {
+	let { entry: t, reason: n, unanswered: r } = e;
+	t.lost = !0, t.writeId !== void 0 && n === "no-heartbeat" && r.add(t.writeId), t.reject(v("STORE_ENGINE_LOST", {
+		detail: ne[n],
+		meta: {
+			reason: n,
+			...t.writeId !== void 0 && { writeId: t.writeId }
+		}
+	}));
+}
+// src/store/engine/client/engine-control.ts
+function z(e) {
+	let { worker: t } = e, n = /* @__PURE__ */ new Map(), r = 0, i = !1, a, o = !1;
+	return t.addEventListener("error", function(e) {
+		if (i) return;
+		let t = v("PROJECT_ENGINE_UNAVAILABLE", {
+			detail: `The project engine worker could not start: ${e.message || "its script failed to load"}`,
+			cause: Error(e.message || "worker error")
+		});
+		for (let e of n.values()) e.reject(t);
+		n.clear();
+	}), t.addEventListener("message", function(e) {
+		let t = e.data;
+		if (t?.type === f.busy && (o = !0), t?.type === f.heartbeat && (o = !1), !t || !("requestId" in t)) return;
+		let r = t, i = n.get(r.requestId);
+		i && (n.delete(r.requestId), r.type === "failed" ? i.reject(D({ data: r.thrown })) : r.type === i.expect ? i.resolve(r) : i.reject(v("ASSERTION_FAILED", { detail: `The engine answered "${r.type}" where "${i.expect}" was expected` })));
+	}), {
+		watchSilence: function({ budgetMs: e }) {
+			return ye({
+				worker: t,
+				busy: o,
+				budgetMs: e
+			});
+		},
+		opened: function() {
+			i = !0;
+		},
+		end: function({ error: e }) {
+			a = e;
+			for (let t of n.values()) t.reject(e);
+			n.clear();
+		},
+		request: function({ message: e, expect: i, transfer: o = [] }) {
+			r += 1;
+			let s = r;
+			return new Promise(function(r, c) {
+				a === void 0 ? (n.set(s, {
+					expect: i,
+					resolve: r,
+					reject: c
+				}), t.postMessage({
+					...e,
+					requestId: s
+				}, o)) : c(a);
+			});
+		}
+	};
+}
+function ye(e) {
+	let { worker: t, busy: n, budgetMs: r } = e, i = Se, a = new Promise(function(e) {
+		i = e;
+	}), o = he({
+		source: t,
+		timeoutMs: r,
+		waiting: be,
+		lose: i,
+		busy: n
+	});
+	return o.restart(), {
+		silent: a,
+		stop: o.stop
+	};
+}
+function be() {
+	return 1;
+}
+async function xe(e) {
+	let { control: t, work: n, budgetMs: r } = e, i = t.watchSilence({ budgetMs: r }), a = i.silent.then(function() {
+		return w;
+	});
+	try {
+		return await Promise.race([n, a]);
+	} finally {
+		i.stop();
+	}
+}
+function Se() {}
+// src/store/engine/client/worker-connector.ts
+var B = /* @__PURE__ */ new Map(), V = /* @__PURE__ */ new Map(), H = { next: 0 }, U = t(), W = /* @__PURE__ */ new WeakMap();
+function Ce(e) {
+	return s({
+		project: e.name,
+		dialecteId: e.dialecteId
+	}), {
+		connect: function() {
+			return we(e);
+		},
+		destroy: function(t) {
+			return Ne({
+				connector: e,
+				own: t?.own
+			});
+		}
+	};
+}
+async function we(e) {
+	let t = e.openBudgetMs ?? 1e4, n = {
+		clientId: crypto.randomUUID(),
+		released: !1,
+		listeners: /* @__PURE__ */ new Set(),
+		follow: ke,
+		mayFollow: !0,
+		followedAt: void 0,
+		followRearmMs: x,
+		adoption: void 0,
+		creationId: void 0,
+		refusal: void 0,
+		releasing: void 0
+	}, r = J(e);
+	U.markOpen({
+		name: r,
+		connection: n
+	}), await Te({
+		connector: e,
+		link: n
+	}).catch(function(e) {
+		throw U.markClosed({
+			name: r,
+			connection: n
+		}), e;
+	});
+	async function i() {
+		n.released && o({ storeName: e.name });
+		let r = await Te({
+			connector: e,
+			link: n
+		});
+		if (n.adoption?.generation !== r.generation) {
+			je({
+				adoption: n.adoption,
+				storeName: e.name
+			});
+			let i = n.adoption !== void 0;
+			n.adoption = {
+				generation: r.generation,
+				client: Ae({
+					name: e.name,
+					dialecteId: e.dialecteId,
+					engine: r,
+					state: n,
+					heartbeatTimeoutMs: e.liveness?.heartbeatTimeoutMs,
+					openBudgetMs: t
+				}).then(function(e) {
+					return e.onEvent(function(e) {
+						Oe({
+							state: n,
+							notice: {
+								type: "event",
+								signal: e
+							}
+						});
+					}), i && Oe({
+						state: n,
+						notice: { type: "resync" }
+					}), e;
+				})
+			};
+		}
+		return (await n.adoption.client).api;
+	}
+	let a = {
+		engine: function() {
+			return n.mayFollow = !0, n.followRearmMs = x, i();
+		},
+		connectionId: n.clientId,
+		onNotice: function(e) {
+			return n.released ? ke : (n.listeners.add(e), function() {
+				n.listeners.delete(e);
+			});
+		},
+		close: function() {
+			return n.releasing ??= s(), n.releasing;
+		}
+	};
+	n.follow = function() {
+		let e = n.followedAt !== void 0 && performance.now() - n.followedAt >= n.followRearmMs;
+		!n.released && n.listeners.size !== 0 && (n.mayFollow || e) && (e && (n.followRearmMs = Math.min(n.followRearmMs * 2, S)), n.mayFollow = !1, n.followedAt = void 0, i().then(function() {
+			n.followedAt = performance.now();
+		}, function() {}));
+	};
+	async function s() {
+		n.released = !0, n.listeners.clear(), U.markClosed({
+			name: r,
+			connection: n
+		});
+		let i = B.get(r);
+		Me({
+			engine: i,
+			state: n,
+			storeName: e.name
+		}), i?.links.delete(n) ? i.links.size > 0 || await Be({
+			name: e.name,
+			dialecteId: e.dialecteId,
+			engine: i,
+			openBudgetMs: t
+		}) : await V.get(r);
+	}
+	return W.set(a, n), a;
+}
+async function Te(e) {
+	let { connector: t, link: n } = e, { name: r } = t, i = J(t);
+	if (await V.get(i), n.released && o({ storeName: r }), n.refusal !== void 0) throw n.refusal;
+	let a = B.get(i);
+	a || (a = G({
+		connector: t,
+		expectedCreationId: n.creationId
+	}), B.set(i, a)), a.links.add(n);
+	try {
+		await a.opened;
+	} catch (t) {
+		a.links.delete(n), B.get(i) === a && B.delete(i);
+		let r = _(t)?.key === "PROJECT_DESTROYED_WHILE_AWAY";
+		if (r && n.creationId === void 0) return Te(e);
+		throw r && (n.refusal = t), t;
+	}
+	n.released && o({ storeName: r });
+	try {
+		g({
+			project: r,
+			expectedCreationId: n.creationId,
+			creationId: a.creationId
+		});
+	} catch (e) {
+		throw n.refusal = e, a.links.delete(n) && a.links.size === 0 && !a.ended && Be({
+			name: r,
+			dialecteId: t.dialecteId,
+			engine: a,
+			openBudgetMs: t.openBudgetMs ?? 1e4
+		}), e;
+	}
+	return n.creationId = a.creationId, a;
+}
+function G(e) {
+	let { connector: t, expectedCreationId: n } = e, { name: r, dialecteId: i, dialecteVersion: a, engineUrl: o, perf: s = !1, openBudgetMs: c = te, liveness: l = {}, settings: u } = t, d = Math.max(t.openWindowMs ?? 3e4, c + b), f = new Worker(o, { type: "module" }), p = z({ worker: f });
+	H.next += 1;
+	let m = {
+		worker: f,
+		generation: H.next,
+		opened: Promise.resolve(),
+		control: p,
+		links: /* @__PURE__ */ new Set(),
+		ended: !1,
+		watch: void 0,
+		creationId: void 0
+	};
+	return m.opened = qe({
+		work: p.request({
+			message: {
+				type: "open",
+				project: r,
+				dialecteId: i,
+				dialecteVersion: a,
+				expectedCreationId: n,
+				lock: "if-available",
+				budgetMs: c,
+				perf: s,
+				heartbeatIntervalMs: l.heartbeatIntervalMs,
+				settings: u
+			},
+			expect: "opened"
+		}),
+		budgetMs: d
+	}).then(function(e) {
+		if (e === "unanswered") throw m.ended || q({
+			name: r,
+			dialecteId: i,
+			engine: m,
+			worker: f,
+			ending: Promise.resolve(w),
+			lockBudgetMs: c
+		}), v("PROJECT_ENGINE_UNAVAILABLE", {
+			detail: `The engine of project "${r}" gave no answer to its open within ${d} ms: it was ended`,
+			meta: {
+				project: r,
+				openWindowMs: d
+			}
+		});
+		m.creationId = e.creationId;
+		try {
+			E({ found: e.wireProtocol }), T({
+				project: r,
+				engine: e,
+				asked: {
+					dialecteId: i,
+					dialecteVersion: a
+				}
+			});
+		} catch (t) {
+			throw q({
+				name: r,
+				dialecteId: i,
+				engine: m,
+				worker: f,
+				ending: Promise.resolve(),
+				lockBudgetMs: c,
+				lockDialecteId: e.dialecteId
+			}), t;
+		}
+	}).then(function() {
+		p.opened(), m.ended || Ee({
+			name: r,
+			dialecteId: i,
+			engine: m
+		});
+	}, function(e) {
+		throw m.ended || (m.ended = !0, p.end({ error: e }), f.terminate()), e;
+	}), m;
+}
+function Ee(e) {
+	let { name: t, dialecteId: n, engine: r } = e, i = new AbortController(), a = p({
+		dialecteId: n,
+		project: t
+	});
+	r.watch = {
+		controller: i,
+		settled: navigator.locks.request(a, { signal: i.signal }, function() {
+			K({
+				name: t,
+				dialecteId: n,
+				engine: r
+			});
+		}).then(Y, Y)
+	};
+}
+function K(e) {
+	let { name: t, dialecteId: n, engine: r } = e;
+	if (r.ended) return;
+	r.ended = !0;
+	let i = J({
+		name: t,
+		dialecteId: n
+	});
+	B.get(i) === r && B.delete(i), r.control.end({ error: Ge() }), r.watch && We({
+		key: i,
+		until: r.watch.settled
+	}), De({ engine: r }), r.worker.terminate();
+}
+function De(e) {
+	let { engine: t } = e;
+	for (let e of t.links) e.adoption?.generation === t.generation && e.adoption.client.then(function(t) {
+		t.lose({ reason: "host-gone" }), queueMicrotask(e.follow);
+	}, Je);
+}
+function Oe(e) {
+	l({
+		listeners: e.state.listeners,
+		value: e.notice,
+		of: c.engineChanges
+	});
+}
+function ke() {}
+async function Ae(e) {
+	let { name: t, dialecteId: n, engine: r, state: i, heartbeatTimeoutMs: a = C, openBudgetMs: o } = e, s = new MessageChannel(), c = r.control.request({
+		message: {
+			type: "adopt-client",
+			clientId: i.clientId,
+			port: s.port2
+		},
+		expect: "adopted",
+		transfer: [s.port2]
+	});
+	if (await xe({
+		control: r.control,
+		work: c,
+		budgetMs: a
+	}) === "unanswered") throw s.port1.close(), r.ended || (De({ engine: r }), r.control.end({ error: Ge() }), q({
+		name: t,
+		dialecteId: n,
+		engine: r,
+		worker: r.worker,
+		ending: Promise.resolve(w),
+		lockBudgetMs: o
+	})), v("PROJECT_ENGINE_UNAVAILABLE", {
+		detail: `The engine of project "${t}" gave no answer to a new connection within ${a} ms: it was ended`,
+		meta: {
+			project: t,
+			heartbeatTimeoutMs: a
+		}
+	});
+	return R({
+		port: s.port1,
+		heartbeatTimeoutMs: a
+	});
+}
+function je(e) {
+	let { adoption: t, storeName: n } = e;
+	t?.client.then(function(e) {
+		e.close({ storeName: n });
+	}, Je);
+}
+function Me(e) {
+	let { engine: t, state: n, storeName: r } = e, i = n.adoption;
+	n.adoption = void 0, i && (i.client.then(function(e) {
+		e.close({ storeName: r });
+	}, Je), t?.generation !== i.generation || t.ended || t.control.request({
+		message: {
+			type: "client-gone",
+			clientId: n.clientId
+		},
+		expect: "released"
+	}).catch(Ye));
+}
+async function Ne(e) {
+	let { connector: t, own: n } = e, { name: r, dialecteId: i, engineUrl: a, openBudgetMs: o = te } = t, s = J(t);
+	Fe({
+		name: r,
+		key: s,
+		own: n === void 0 ? void 0 : W.get(n.link)
+	}), n?.letGo();
+	let c = V.get(s), l = Y;
+	We({
+		key: s,
+		until: new Promise(function(e) {
+			l = e;
+		})
+	});
+	let u = Promise.resolve();
+	try {
+		await c, Ie({
+			name: r,
+			key: s
+		});
+		let e = Re({
+			name: r,
+			dialecteId: i,
+			engineUrl: a,
+			budgetMs: o,
+			lock: "if-available"
+		});
+		u = e.released, await e.done;
+	} finally {
+		u.then(l, l);
+	}
+}
+function Pe(e) {
+	return U.others({ name: J(e) }) > 0;
+}
+function Fe(e) {
+	let t = U.others({
+		name: e.key,
+		connection: e.own
+	});
+	t > 0 && i({
+		storeName: e.name,
+		connections: t
+	});
+}
+function Ie(e) {
+	if (B.has(e.key)) throw v("ASSERTION_FAILED", {
+		detail: `Project "${e.name}" has an engine in this realm with no connection open on it`,
+		meta: { project: e.name }
+	});
+}
+async function Le(e) {
+	await Re(e).done;
+}
+function Re(e) {
+	let { name: t, dialecteId: n, engineUrl: r, budgetMs: i, lock: a } = e, o = new Worker(r, { type: "module" }), { ended: s, released: c } = q({
+		name: t,
+		dialecteId: n,
+		engine: void 0,
+		worker: o,
+		lockBudgetMs: i,
+		ending: qe({
+			work: ze({
+				name: t,
+				dialecteId: n,
+				control: z({ worker: o }),
+				budgetMs: i,
+				lock: a
+			}),
+			budgetMs: i + b
+		})
+	});
+	return {
+		done: s.then(function(e) {
+			if (e === "unanswered") throw v("PROJECT_DESTROY_FAILED", {
+				detail: `Project "${t}" was not destroyed: its engine worker gave no answer within ${i + b} ms`,
+				meta: {
+					project: t,
+					budgetMs: i
+				}
+			});
+		}),
+		released: c
+	};
+}
+async function ze(e) {
+	let { name: t, dialecteId: n, control: r, budgetMs: i, lock: a } = e;
+	await r.request({
+		message: {
+			type: "destroy",
+			project: t,
+			dialecteId: n,
+			lock: a,
+			budgetMs: i
+		},
+		expect: "destroyed"
+	});
+}
+function Be(e) {
+	let { name: t, dialecteId: n, engine: r, openBudgetMs: i } = e, a = q({
+		name: t,
+		dialecteId: n,
+		engine: r,
+		worker: r.worker,
+		lockBudgetMs: i,
+		ending: qe({
+			work: r.control.request({
+				message: { type: "close" },
+				expect: "closed"
+			}),
+			budgetMs: b
+		})
+	});
+	return a.ended.catch(Ye), a.released;
+}
+function q(e) {
+	let { name: t, dialecteId: n, engine: r, worker: i, ending: a, lockBudgetMs: o } = e, s = e.lockDialecteId ?? n, c = J({
+		name: t,
+		dialecteId: n
+	});
+	r && (r.ended = !0, B.get(c) === r && B.delete(c), r.watch?.controller.abort());
+	let l = !1, u = a.then(function(e) {
+		return d({ unanswered: e === w }), e;
+	}, function(e) {
+		throw d({ unanswered: !1 }), e;
+	});
+	function d(e) {
+		l = e.unanswered, r?.control.end({ error: Ke({ name: t }) }), i.terminate();
+	}
+	let f = u.then(Y, Y).then(function() {
+		return Ve({
+			name: t,
+			dialecteId: s,
+			budgetMs: l ? o : b
+		});
+	}), p = Promise.all([f, r?.watch?.settled]).then(Y);
+	return We({
+		key: c,
+		until: p
+	}), {
+		ended: u,
+		released: p
+	};
+}
+function Ve(e) {
+	return navigator.locks.request(p({
+		dialecteId: e.dialecteId,
+		project: e.name
+	}), { signal: AbortSignal.timeout(e.budgetMs) }, Y).then(He, Ue);
+}
+function He() {
+	return !0;
+}
+function Ue() {
+	return !1;
+}
+function We(e) {
+	let { key: t, until: n } = e, r = Promise.all([V.get(t), n]).then(Y);
+	V.set(t, r), r.then(function() {
+		V.get(t) === r && V.delete(t);
+	});
+}
+function Ge() {
+	return v("STORE_ENGINE_LOST", {
+		detail: ne["host-gone"],
+		meta: { reason: "host-gone" }
+	});
+}
+function Ke(e) {
+	return v("STORE_CLOSED", {
+		detail: `The engine of project "${e.name}" was ended`,
+		meta: { storeName: e.name }
+	});
+}
+function qe(e) {
+	let { work: t, budgetMs: n } = e, r, i = new Promise(function(e) {
+		r = setTimeout(e, n, w);
+	});
+	return Promise.race([t, i]).finally(function() {
+		clearTimeout(r);
+	});
+}
+function J(e) {
+	return u({
+		dialecteId: e.dialecteId,
+		project: e.name
+	});
+}
+function Y() {}
+function Je() {}
+function Ye() {}
+// src/store/engine/client/hub-connector.ts
+var Xe = /* @__PURE__ */ new WeakMap();
+function Ze(e) {
+	s({
+		project: e.name,
+		dialecteId: e.dialecteId
+	});
+	let { name: t, connection: n, dialecteId: r, dialecteVersion: i, engineUrl: a, destroyBudgetMs: o = te, heartbeatTimeoutMs: c, deletesFiles: l = !0 } = e;
+	return {
+		connect: async function() {
+			let e = n.openProject({
+				project: t,
+				dialecteId: r,
+				dialecteVersion: i,
+				heartbeatTimeoutMs: c
+			});
+			try {
+				await e.engine();
+			} catch (t) {
+				throw e.release(), t;
+			}
+			let a = crypto.randomUUID(), o = /* @__PURE__ */ new WeakMap(), s = {
+				engine: async function() {
+					let t = await e.engine(), n = o.get(t) ?? t.connection({ connectionId: a });
+					return o.set(t, n), n;
+				},
+				connectionId: a,
+				onNotice: e.onNotice,
+				close: e.release
+			};
+			return Xe.set(s, e), s;
+		},
+		destroy: function(e) {
+			let s = e?.own, c = s && Xe.get(s.link);
+			return n.destroyProject({
+				project: t,
+				dialecteId: r,
+				dialecteVersion: i,
+				own: s && c && {
+					link: c,
+					letGo: s.letGo
+				},
+				destroy: l ? function() {
+					return Le({
+						name: t,
+						dialecteId: r,
+						engineUrl: a,
+						budgetMs: o,
+						lock: "wait"
+					});
+				} : void 0
+			});
+		}
+	};
+}
+// src/store/engine/hub/hub.constants.ts
+var Qe = "dialecte:realm:", $e = "dialecte-hub", et = [
+	"PROJECT_DIALECTE_MISMATCH",
+	"PROJECT_DIALECTE_VERSION_MISMATCH",
+	"STORE_PROTOCOL_MISMATCH",
+	"PROJECT_DESTROYED_WHILE_AWAY",
+	"PROJECT_NAME_INVALID"
+], X = Symbol.for("@dialecte/core/hub/v5"), tt = 1e4, nt = 1e3, rt = 3e4;
+// src/store/engine/hub/realm-host.ts
+function it(e) {
+	let { report: t, adoptBudgetMs: n = C } = e, r = new Map(e.spawners.map(function(e) {
+		return [e.dialecteId, { ...e }];
+	})), i = /* @__PURE__ */ new Map();
+	function a(e) {
+		let { engine: t } = e;
+		t.ended = !0, t.watch?.abort(), i.delete(dt(t));
+	}
+	return {
+		spawn: function({ project: e, dialecteId: n, generation: s, openBudgetMs: c, expectedCreationId: l }) {
+			let u = r.get(n), d;
+			try {
+				if (!u) throw v("PROJECT_ENGINE_UNAVAILABLE", {
+					detail: `This view cannot start an engine of ${n}`,
+					meta: {
+						project: e,
+						dialecteId: n
+					}
+				});
+				d = new Worker(u.engineUrl, { type: "module" });
+			} catch (r) {
+				t({
+					type: "engine-open-failed",
+					project: e,
+					dialecteId: n,
+					generation: s,
+					key: void 0,
+					error: re({ thrown: r })
+				});
+				return;
+			}
+			let f = z({ worker: d }), p = {
+				project: e,
+				dialecteId: n,
+				generation: s,
+				worker: d,
+				control: f,
+				ended: !1,
+				watch: void 0
+			};
+			i.set(dt(p), p);
+			let m = u.perf ?? !1;
+			Promise.resolve().then(u.settings).then(function(t) {
+				return f.request({
+					message: {
+						type: "open",
+						project: e,
+						dialecteId: n,
+						dialecteVersion: u.dialecteVersion,
+						...l !== void 0 && { expectedCreationId: l },
+						lock: "wait",
+						budgetMs: c,
+						perf: m,
+						settings: t
+					},
+					expect: "opened"
+				});
+			}).then(function(t) {
+				return E({ found: t.wireProtocol }), T({
+					project: e,
+					engine: t,
+					asked: {
+						dialecteId: n,
+						dialecteVersion: u.dialecteVersion
+					}
+				}), t.creationId;
+			}).then(function(r) {
+				p.ended || (f.opened(), ct({
+					engine: p,
+					onGone: o
+				}), t({
+					type: "engine-opened",
+					project: e,
+					dialecteId: n,
+					generation: s,
+					creationId: r
+				}));
+			}, function(r) {
+				p.ended || (a({ engine: p }), f.end({ error: r }), d.terminate(), t({
+					type: "engine-open-failed",
+					project: e,
+					dialecteId: n,
+					generation: s,
+					key: _(r)?.key,
+					error: re({ thrown: r })
+				}));
+			});
+		},
+		adopt: function({ project: e, generation: r, adoptionId: a, clientId: o, port: s }) {
+			let c = i.get(dt({
+				project: e,
+				generation: r
+			}));
+			if (!c) {
+				s.close(), t({
+					type: "client-adopt-failed",
+					adoptionId: a
+				});
+				return;
+			}
+			let l = c.control.request({
+				message: {
+					type: "adopt-client",
+					clientId: o,
+					port: s
+				},
+				expect: "adopted",
+				transfer: [s]
+			});
+			at({
+				control: c.control,
+				adopting: l,
+				adoptionId: a,
+				budgetMs: n,
+				report: t
+			});
+		},
+		clientGone: async function({ project: e, generation: t, clientId: n }) {
+			await i.get(dt({
+				project: e,
+				generation: t
+			}))?.control.request({
+				message: {
+					type: "client-gone",
+					clientId: n
+				},
+				expect: "released"
+			}).catch(ft);
+		},
+		release: function({ project: e, generation: t }) {
+			let n = i.get(dt({
+				project: e,
+				generation: t
+			}));
+			n && (a({ engine: n }), lt({ engine: n }).then(function() {
+				n.control.end({ error: ut({ project: e }) }), n.worker.terminate();
+			}));
+		},
+		add: function({ spawners: e }) {
+			for (let t of e) {
+				let e = r.get(t.dialecteId);
+				e ? t.perf && (e.perf = !0) : r.set(t.dialecteId, { ...t });
+			}
+		},
+		endAll: function() {
+			for (let e of i.values()) a({ engine: e }), e.control.end({ error: ut({ project: e.project }) }), e.worker.terminate();
+		}
+	};
+	function o(e) {
+		let { engine: n } = e;
+		n.ended || (a({ engine: n }), n.control.end({ error: ut({ project: n.project }) }), n.worker.terminate(), t({
+			type: "engine-ended",
+			project: n.project,
+			dialecteId: n.dialecteId,
+			generation: n.generation
+		}));
+	}
+}
+function at(e) {
+	let { control: t, adopting: n, adoptionId: r, budgetMs: i, report: a } = e;
+	xe({
+		control: t,
+		work: n.then(ot, st),
+		budgetMs: i
+	}).then(function(e) {
+		a({
+			type: e === !0 ? "client-adopted" : "client-adopt-failed",
+			adoptionId: r
+		});
+	});
+}
+function ot() {
+	return !0;
+}
+function st() {
+	return !1;
+}
+function ct(e) {
+	let { engine: t, onGone: n } = e, r = new AbortController();
+	t.watch = r, navigator.locks.request(p({
+		dialecteId: t.dialecteId,
+		project: t.project
+	}), { signal: r.signal }, function() {
+		n({ engine: t });
+	}).catch(ft);
+}
+function lt(e) {
+	let { engine: t } = e, n, r = new Promise(function(e) {
+		n = setTimeout(e, b);
+	}), i = t.control.request({
+		message: { type: "close" },
+		expect: "closed"
+	}).then(ft, ft);
+	return Promise.race([i, r]).finally(function() {
+		clearTimeout(n);
+	});
+}
+function ut(e) {
+	return v("STORE_CLOSED", {
+		detail: `The engine of project "${e.project}" was released`,
+		meta: { storeName: e.project }
+	});
+}
+function dt(e) {
+	return `${e.project}#${e.generation}`;
+}
+function ft() {}
+// src/store/engine/hub/hub-client.ts
+function pt(e = {}) {
+	ht({
+		registered: [],
+		asked: (e.spawners ?? []).map(Mt)
+	});
+	let t = e.hostsNoEngine ? [] : e.spawners ?? [], n = globalThis[X];
+	if (!n) return vt({ attempt: function() {
+		return yt({ spawners: t });
+	} });
+	let r = xt({ spawners: t });
+	return r.length === 0 ? n : n.then(function(e) {
+		return e?.addSpawners({ spawners: r }), e;
+	});
+}
+function mt() {
+	return globalThis[X];
+}
+function ht(e) {
+	let { registered: t, asked: n } = e, r = n.filter(function(e) {
+		return [...t, ...n].some(function(t) {
+			return t.dialecteId === e.dialecteId && t.dialecteVersion !== e.dialecteVersion;
+		});
+	});
+	r.length !== 0 && ee("STORE_HUB_SPAWNERS_FIXED", {
+		detail: `This page's hub connection runs ${gt({ spawners: t })}, not ${gt({ spawners: r })}: a page runs one version of each dialecte's engine`,
+		meta: { spawners: r }
+	});
+}
+function gt(e) {
+	let { spawners: t } = e;
+	return t.length === 0 ? "no engine" : t.map(function(e) {
+		return `${e.dialecteId}@${e.dialecteVersion}`;
+	}).join(", ");
+}
+function _t(e) {
+	let t = globalThis[X];
+	return t ? t.then(function(t) {
+		return t?.adoptPort({ port: e.port }) || Ht({ port: e.port }), t;
+	}, function() {
+		return _t(e);
+	}) : vt({ attempt: function() {
+		return St({
+			openPort: function() {
+				return { port: e.port };
+			},
+			topLevel: !1,
+			spawners: [],
+			holdsLock: !1,
+			lifecycle: void 0,
+			bound: !0
+		});
+	} });
+}
+function vt(e) {
+	let t = globalThis, n = t[X];
+	if (n) return n;
+	let r = e.attempt();
+	t[X] = r;
+	function i() {
+		t[X] === r && delete t[X];
+	}
+	return r.then(function(e) {
+		if (!e) return i();
+		e.ended.then(i);
+	}, i), r;
+}
+async function yt(e = {}) {
+	if (typeof SharedWorker > "u") return;
+	let t;
+	try {
+		t = bt();
+	} catch (e) {
+		if (e instanceof DOMException) return;
+		throw e;
+	}
+	let n = !1;
+	try {
+		return await St({
+			openPort: function() {
+				return n ? bt() : (n = !0, t);
+			},
+			topLevel: globalThis.top === globalThis,
+			spawners: xt({ spawners: e.spawners ?? [] }),
+			holdsLock: !0,
+			lifecycle: {
+				page: globalThis.document,
+				window: globalThis
+			}
+		});
+	} catch (e) {
+		if (_(e)?.key === "STORE_CONNECTION_FAILED") return;
+		throw e;
+	}
+}
+function bt() {
+	let e = new SharedWorker(new URL(
+		/* @vite-ignore */
+		new URL("assets/hub.worker-B1HcVDhn.js", import.meta.url).href,
+		"" + import.meta.url
+	), {
+		type: "module",
+		name: $e
+	}), t = new Promise(function(t) {
+		e.addEventListener("error", function(e) {
+			let n = e.message;
+			t(v("STORE_CONNECTION_FAILED", { detail: `The origin's hub could not start${n ? `: ${n}` : ""}` }));
+		}, { once: !0 });
+	});
+	return {
+		port: e.port,
+		failed: t
+	};
+}
+function xt(e) {
+	let { spawners: t, realm: n = globalThis } = e, r = n.document?.baseURI ?? n.location?.href;
+	return t.filter(function(e) {
+		try {
+			return new URL(e.engineUrl, r).origin === n.origin;
+		} catch {
+			return !1;
+		}
+	});
+}
+async function St(e) {
+	let { openPort: t, topLevel: n, spawners: r, holdsLock: a, lifecycle: o, welcomeBudgetMs: s = tt, bound: c = !1 } = e, l = /* @__PURE__ */ new Map();
+	function d(e) {
+		let t = u(e);
+		l.get(t) === e && l.delete(t);
+	}
+	let f = /* @__PURE__ */ new WeakSet(), p = /* @__PURE__ */ new Map(), m = /* @__PURE__ */ new Map(), h = /* @__PURE__ */ new Map(), g = [], ee = new AbortController(), y = crypto.randomUUID(), b = t, x = b(), S = x.port, C = Q, w = "joining", T, E, O, k = /* @__PURE__ */ new Set(), ie = !1, A, j, M, ae = Q, oe = nt, N, se, ce = 0, le = Q, ue = new Promise(function(e) {
+		le = e;
+	}), P, F = Q, de = [...r], fe = de.map(Mt), I = it({
+		spawners: r,
+		report: L
+	});
+	function L(e, t = []) {
+		S.postMessage(e, t);
+	}
+	async function pe(e) {
+		let { key: t, project: n, dialecteId: r, dialecteVersion: i, own: a } = e, o = l.get(t);
+		o && (o.asked = !1), p.set(t, n);
+		try {
+			await new Promise(function(e, a) {
+				m.set(t, {
+					granted: e,
+					refused: a
+				}), R({
+					type: "destroy-elsewhere",
+					project: n,
+					dialecteId: r,
+					dialecteVersion: i
+				});
+			}).finally(function() {
+				m.delete(t), p.delete(t);
+			});
+		} catch (e) {
+			let n = l.get(t);
+			throw n?.current ? n.asked = !0 : me({
+				key: t,
+				own: void 0
+			}), e;
+		}
+		let s = l.get(t);
+		s && (s.creationId = void 0), a?.letGo(), me({
+			key: t,
+			own: a?.link
+		});
+	}
+	function me(e) {
+		let t = l.get(e.key);
+		t && (je({
+			key: e.key,
+			own: e.own
+		}) > 0 || t.waiters.length > 0) && Se(t);
+	}
+	function he(e) {
+		let { project: t, dialecteId: n } = e, r = de.find(function(e) {
+			return e.dialecteId === n;
+		});
+		(r ? Le({
+			name: t,
+			dialecteId: n,
+			engineUrl: r.engineUrl,
+			budgetMs: te,
+			lock: "wait"
+		}) : Promise.reject(v("STORE_UNAVAILABLE", {
+			detail: `Project "${t}" cannot be deleted from this view: it runs no engine of "${n}"`,
+			meta: {
+				project: t,
+				dialecteId: n
+			}
+		}))).then(function() {
+			L({
+				type: "files-deleted",
+				project: t,
+				dialecteId: n
+			});
+		}, function(e) {
+			L({
+				type: "files-deleted",
+				project: t,
+				dialecteId: n,
+				error: re({ thrown: e })
+			});
+		});
+	}
+	function R(e, t = []) {
+		if (w === "joined") return L(e, t);
+		w !== "refused" && g.push({
+			message: e,
+			transfer: t
+		});
+	}
+	function ge(e) {
+		let t = e.data;
+		switch (t?.type) {
+			case "engine-ready": return Dt({
+				entry: l.get(u(t)),
+				message: t,
+				leave: ke,
+				forget: d
+			});
+			case "engine-lost": return kt({ entry: l.get(u(t)) });
+			case "open-refused": return At({
+				entry: l.get(u(t)),
+				error: D({ data: t.error }),
+				forget: d
+			});
+			case "destroy-granted":
+				m.get(u(t))?.granted();
+				return;
+			case "left": return Oe({ key: u(t) });
+			case "destroy-refused":
+				m.get(u(t))?.refused(D({ data: t.error }));
+				return;
+			case "destroyed-elsewhere":
+				m.get(u(t))?.granted();
+				return;
+			case "pong":
+				ae();
+				return;
+			case "delete-files": return he({
+				project: t.project,
+				dialecteId: t.dialecteId
+			});
+			case "dropped": return we({});
+			case "spawn-engine":
+				w !== "suspended" && I.spawn(t);
+				return;
+			case "adopt-client": return I.adopt(t);
+			case "client-gone":
+				I.clientGone(t);
+				return;
+			case "release-engine": return I.release(t);
+			default: return;
+		}
+	}
+	async function _e() {
+		let e = S, t = y, r = x.failed, i = It({ budgetMs: s }), o = !1, c, l = new Promise(function(t, n) {
+			F = function() {
+				o = !0, t();
+			}, e.addEventListener("message", function(e) {
+				e.data?.type === "welcome" && (c = e.data.hubLock, t()), e.data?.type === "hello-refused" && n(D({ data: e.data.error }));
+			});
+		});
+		async function u() {
+			if (a) {
+				let e = await Bt({
+					realmId: t,
+					expired: i.expired
+				});
+				if (o) return e(), !1;
+				C = e;
+			}
+			e.addEventListener("message", ge), e.start();
+			let s = {
+				type: "hello",
+				protocol: 5,
+				realmId: t,
+				topLevel: n,
+				spawners: [...fe]
+			};
+			return e.postMessage(s), await Ft({
+				welcomed: l,
+				failed: r,
+				expired: i.expired
+			}), !o && (F = Q, a && c !== void 0 && ve({
+				hubLock: c,
+				instanceId: t
+			}), !0);
+		}
+		try {
+			return await u();
+		} catch (e) {
+			if (o) return !1;
+			throw e;
+		} finally {
+			i.clear();
+		}
+	}
+	function ve(e) {
+		let { hubLock: t, instanceId: n } = e, r = new AbortController();
+		P = r, navigator.locks.request(t, { signal: r.signal }, function() {
+			if (y !== n || w !== "joined") return;
+			let e = v("STORE_CONNECTION_FAILED", { detail: "The origin's hub ended: this view joins the next one" }), t = N === void 0 ? 0 : performance.now() - N;
+			z(), t < 1e3 ? Ce({ error: e }) : ce >= 3 ? Ce({ error: v("STORE_CONNECTION_FAILED", { detail: "The origin's hub keeps ending: this view's calls are refused until it joins one that lasts" }) }) : (ce += 1, ye({ error: e }));
+		}).catch(Vt);
+	}
+	function z() {
+		let e = performance.now();
+		N !== void 0 && (se === void 0 || N > se) && e - N > 3e4 && (oe = nt, ce = 0), se = e;
+	}
+	function ye(e) {
+		w = "suspended", E = void 0, B({ reason: "host-gone" }), H({ error: e.error }), K();
+	}
+	function be() {
+		clearTimeout(M);
+		let e = y, t = !1;
+		ae = function() {
+			t = !0;
+		}, L({ type: "ping" }), M = setTimeout(function() {
+			if (M = void 0, ae = Q, !t && y === e && w === "joined" && A) {
+				for (let e of l.values()) e.asked && L({
+					type: "leave",
+					project: e.project,
+					dialecteId: e.dialecteId
+				});
+				E = void 0, B({ reason: "host-gone" }), H({ error: v("STORE_CONNECTION_FAILED", { detail: "The origin's hub ended: this view joins the next one" }) }), w = "dropped", O = void 0, G();
+			}
+		}, s);
+	}
+	function xe() {
+		w = "joined", N = performance.now();
+		for (let { message: e, transfer: t } of g.splice(0)) L(e, t);
+		for (let e of l.values()) (e.waiters.length > 0 || e.users > 0) && Se(e);
+		if (ie) for (let e of k) queueMicrotask(function() {
+			k.has(e) && e();
+		});
+		ie = !0;
+	}
+	function Se(e) {
+		e.asked || w !== "joined" || p.has(u(e)) || (e.asked = !0, L({
+			type: "open",
+			project: e.project,
+			dialecteId: e.dialecteId,
+			dialecteVersion: e.dialecteVersion,
+			...e.creationId !== void 0 && { expectedCreationId: e.creationId }
+		}));
+	}
+	function B(e) {
+		F(), P?.abort(), P = void 0, De(), I.endAll();
+		for (let t of l.values()) jt({
+			entry: t,
+			reason: e.reason
+		}), t.asked = !1;
+		C(), C = Q, S.close();
+	}
+	function V(e) {
+		let t = /* @__PURE__ */ new Set();
+		for (let e = g.length - 1; e >= 0; e--) {
+			let { message: n } = g[e];
+			(n.type === "destroy" || n.type === "destroy-elsewhere") && (t.add(u(n)), g.splice(e, 1));
+		}
+		for (let [n, r] of m) {
+			let i = p.get(n);
+			i === void 0 || t.has(n) ? r.refused(e.error) : r.refused(v("STORE_ENGINE_LOST", {
+				detail: `Project "${i}" may be partly deleted: this view lost its hub before the deletion was answered`,
+				meta: {
+					project: i,
+					reason: "host-gone"
+				}
+			}));
+		}
+	}
+	function H(e) {
+		let { error: t } = e;
+		V({ error: t });
+		for (let { message: e } of g.splice(0)) {
+			if (e.type !== "bind-child") continue;
+			let n = {
+				type: "hello-refused",
+				error: re({ thrown: t })
+			};
+			e.port.postMessage(n), e.port.close();
+		}
+	}
+	function U() {
+		w !== "suspended" && w !== "refused" && (w = "suspended", B({ reason: "host-gone" }), V({ error: v("PROJECT_ENGINE_UNAVAILABLE", {
+			detail: "The page was suspended before the hub granted the destroy",
+			meta: { realmId: y }
+		}) }));
+	}
+	function W(e) {
+		let { error: t } = e;
+		w = "refused", T = t, clearTimeout(j), clearTimeout(M), le(t), ee.abort(), B({ reason: "host-gone" }), A && Ht({ port: A }), A = void 0, H({ error: t });
+		for (let e of l.values()) {
+			e.refusal = t;
+			for (let n of e.waiters.splice(0)) Z({
+				waiter: n,
+				error: t
+			});
+		}
+	}
+	function Ce(e) {
+		let { error: t } = e;
+		z(), w = "suspended", E = t, B({ reason: "host-gone" }), H({ error: t });
+		for (let e of l.values()) for (let n of e.waiters.splice(0)) Z({
+			waiter: n,
+			error: t
+		});
+		j = setTimeout(Ee, oe), oe = Math.min(oe * 2, rt);
+	}
+	function we(e) {
+		let { cause: t } = e, n = v("STORE_ENGINE_LOST", {
+			detail: ne["realm-dropped"],
+			meta: { reason: "realm-dropped" },
+			...t instanceof Error && { cause: t }
+		});
+		O = n, w = "dropped", B({ reason: "realm-dropped" }), H({ error: n });
+		for (let e of l.values()) for (let t of e.waiters.splice(0)) Z({
+			waiter: t,
+			error: n
+		});
+		G();
+	}
+	function Te() {
+		F(), w = "dropped", B({ reason: "realm-dropped" }), G();
+	}
+	function G() {
+		let e = A;
+		e && (A = void 0, b = function() {
+			return { port: e };
+		}, K());
+	}
+	function Ee() {
+		j = void 0, K();
+	}
+	async function K() {
+		if (w === "suspended" || w === "dropped") {
+			clearTimeout(j), j = void 0, clearTimeout(M), M = void 0, w = "joining", y = crypto.randomUUID();
+			try {
+				if (x = Pt({ openPort: b }), S = x.port, !await _e()) return;
+				E = void 0, xe();
+			} catch (e) {
+				if (w !== "joining") return;
+				c ? we({ cause: e }) : _(e)?.key === "STORE_CONNECTION_FAILED" ? Ce({ error: e }) : W({ error: e });
+			}
+		}
+	}
+	function De() {
+		for (let e of h.values()) for (let t of e.splice(0)) t();
+		h.clear();
+	}
+	function Oe(e) {
+		let t = h.get(e.key);
+		t?.shift()?.(), t?.length === 0 && h.delete(e.key);
+	}
+	function ke(e) {
+		Ae({
+			entry: e,
+			key: u(e)
+		});
+	}
+	function Ae(e) {
+		let { entry: t, key: n } = e;
+		return new Promise(function(e) {
+			let r = h.get(n) ?? [];
+			r.push(e), h.set(n, r), L({
+				type: "leave",
+				project: t.project,
+				dialecteId: t.dialecteId
+			}), a || setTimeout(e, s);
+		});
+	}
+	function je(e) {
+		return (l.get(e.key)?.users ?? 0) - (e.own !== void 0 && f.has(e.own) ? 1 : 0);
+	}
+	function Me() {
+		if (T !== void 0) return T;
+		if (w === "dropped") return O;
+		if (w === "suspended") return E;
+	}
+	o && Nt({
+		targets: o,
+		signal: ee.signal,
+		suspend: U,
+		resume: K,
+		end: U
+	});
+	try {
+		await _e() && xe();
+	} catch (e) {
+		throw W({ error: e }), e;
+	}
+	return {
+		realmId: function() {
+			return y;
+		},
+		bound: c,
+		addSpawners: function({ spawners: e }) {
+			if (ht({
+				registered: fe,
+				asked: e.map(Mt)
+			}), c) return;
+			let t = [];
+			for (let n of e) [...de, ...t].some(function(e) {
+				return e.dialecteId === n.dialecteId;
+			}) || t.push(n);
+			I.add({ spawners: e }), t.length !== 0 && (de.push(...t), fe.push(...t.map(Mt)), R({
+				type: "spawners",
+				spawners: t.map(Mt)
+			}));
+		},
+		ended: ue,
+		close: function() {
+			if (w !== "refused") {
+				if (w === "joined") for (let e of l.values()) e.asked && L({
+					type: "leave",
+					project: e.project,
+					dialecteId: e.dialecteId
+				});
+				W({ error: v("STORE_CLOSED", {
+					detail: "This view's connection to the hub was closed",
+					meta: { realmId: y }
+				}) });
+			}
+		},
+		openProject: function(e) {
+			let t = u(e), n = l.get(t), r = T === void 0 && n && Ct({
+				entry: n,
+				asked: e
+			});
+			if (r) return wt({
+				error: r,
+				project: e.project
+			});
+			let i = n ?? Et(e);
+			l.set(t, i), i.users += 1;
+			let a = !1, o, s = /* @__PURE__ */ new Set();
+			async function c() {
+				a = !0, f.delete(d);
+				for (let e of s) i.listeners.delete(e);
+				if (s.clear(), --i.users, !(i.users > 0)) {
+					l.get(t) === i && l.delete(t), i.current?.client.close({ storeName: i.project }), i.current = void 0;
+					for (let e of i.waiters.splice(0)) Z({
+						waiter: e,
+						error: zt({ project: i.project })
+					});
+					i.asked && await Ae({
+						entry: i,
+						key: t
+					});
+				}
+			}
+			let d = {
+				engine: function() {
+					if (a) return Promise.reject(zt({ project: i.project }));
+					let e = Me();
+					return e === void 0 ? i.refusal === void 0 ? i.current ? Promise.resolve(i.current.client) : new Promise(function(e, t) {
+						i.waiters.push({
+							resolve: e,
+							reject: t
+						}), Se(i);
+					}) : Promise.reject(i.refusal) : Promise.reject(e);
+				},
+				release: function() {
+					return o ??= c(), o;
+				},
+				onNotice: function(e) {
+					return a ? Tt : (s.add(e), i.listeners.add(e), function() {
+						s.delete(e), i.listeners.delete(e);
+					});
+				}
+			};
+			return f.add(d), d;
+		},
+		destroyProject: async function({ project: e, dialecteId: t, dialecteVersion: n, destroy: r, own: a }) {
+			let o = u({
+				project: e,
+				dialecteId: t
+			}), s = Me();
+			if (s !== void 0) throw s;
+			let c = je({
+				key: o,
+				own: a?.link
+			});
+			if (c > 0 && i({
+				storeName: e,
+				connections: c
+			}), m.has(o)) throw v("PROJECT_OPEN_ELSEWHERE", {
+				detail: `"${e}" is being destroyed from this view already`,
+				meta: { project: e }
+			});
+			if (!r) await pe({
+				key: o,
+				project: e,
+				dialecteId: t,
+				dialecteVersion: n,
+				own: a
+			});
+			else {
+				await new Promise(function(n, r) {
+					m.set(o, {
+						granted: n,
+						refused: r
+					}), R({
+						type: "destroy",
+						project: e,
+						dialecteId: t
+					});
+				}).finally(function() {
+					m.delete(o);
+				});
+				try {
+					let t = je({
+						key: o,
+						own: a?.link
+					});
+					t > 0 && i({
+						storeName: e,
+						connections: t
+					}), a?.letGo(), await r();
+				} finally {
+					L({
+						type: "destroyed",
+						project: e,
+						dialecteId: t
+					});
+				}
+			}
+		},
+		onRejoined: function(e) {
+			return k.add(e), function() {
+				k.delete(e);
+			};
+		},
+		adoptPort: function({ port: e }) {
+			return !c || w === "refused" ? !1 : (A && Ht({ port: A }), A = e, w === "dropped" ? G() : w === "joined" ? (De(), be()) : w === "joining" && Te(), !0);
+		},
+		createHubPort: function() {
+			let e = Me();
+			if (e !== void 0) throw e;
+			let t = new MessageChannel(), n = crypto.randomUUID();
+			return R({
+				type: "bind-child",
+				bindingId: n,
+				port: t.port2
+			}, [t.port2]), {
+				port: t.port1,
+				unbind: function() {
+					R({
+						type: "unbind-child",
+						bindingId: n
+					});
+				}
+			};
+		}
+	};
+}
+function Ct(e) {
+	let { entry: t, asked: n } = e;
+	if (n.dialecteVersion !== t.dialecteVersion) return v("PROJECT_DIALECTE_VERSION_MISMATCH", {
+		detail: `"${t.project}" is open in this view with ${t.dialecteId} ${t.dialecteVersion}, asked with ${n.dialecteVersion}`,
+		meta: {
+			project: t.project,
+			dialecteId: t.dialecteId,
+			engineVersion: t.dialecteVersion,
+			realmVersion: n.dialecteVersion
+		}
+	});
+}
+function wt(e) {
+	let { error: t, project: n } = e, r = !1;
+	return {
+		engine: function() {
+			return Promise.reject(r ? zt({ project: n }) : t);
+		},
+		release: async function() {
+			r = !0;
+		},
+		onNotice: function() {
+			return Tt;
+		}
+	};
+}
+function Tt() {}
+function Et(e) {
+	return {
+		...e,
+		users: 0,
+		listeners: /* @__PURE__ */ new Set(),
+		reached: !1,
+		asked: !1,
+		current: void 0,
+		waiters: [],
+		refusal: void 0,
+		creationId: void 0
+	};
+}
+function Dt(e) {
+	let { entry: t, message: n, leave: r } = e;
+	if (!t) {
+		n.port.close();
+		return;
+	}
+	jt({
+		entry: t,
+		reason: "host-gone"
+	});
+	try {
+		g({
+			project: t.project,
+			expectedCreationId: t.creationId,
+			creationId: n.creationId
+		});
+	} catch (i) {
+		n.port.close(), t.refusal = i, t.asked = !1, r(t);
+		for (let e of t.waiters.splice(0)) Z({
+			waiter: e,
+			error: i
+		});
+		e.forget(t);
+		return;
+	}
+	t.creationId = n.creationId;
+	let i = R({
+		port: n.port,
+		heartbeatTimeoutMs: t.heartbeatTimeoutMs
+	});
+	t.current = {
+		generation: n.generation,
+		client: i
+	}, i.onEvent(function(e) {
+		Ot({
+			entry: t,
+			notice: {
+				type: "event",
+				signal: e
+			}
+		});
+	}), t.reached && Ot({
+		entry: t,
+		notice: { type: "resync" }
+	}), t.reached = !0;
+	for (let e of t.waiters.splice(0)) e.resolve(i);
+}
+function Ot(e) {
+	l({
+		listeners: e.entry.listeners,
+		value: e.notice,
+		of: c.engineChanges
+	});
+}
+function kt(e) {
+	e.entry && jt({
+		entry: e.entry,
+		reason: "host-gone"
+	});
+}
+function At(e) {
+	let { entry: t, error: n } = e;
+	if (!t) return;
+	t.asked = !1;
+	let r = _(n)?.key;
+	et.some(function(e) {
+		return e === r;
+	}) && (t.refusal = n);
+	for (let e of t.waiters.splice(0)) Z({
+		waiter: e,
+		error: n
+	});
+	r === "PROJECT_DESTROYED_WHILE_AWAY" && e.forget(t);
+}
+function Z(e) {
+	e.waiter.reject(e.error);
+}
+function jt(e) {
+	let { entry: t, reason: n } = e, r = t.current;
+	t.current = void 0, r && (r.client.lose({ reason: n }), r.client.close({ storeName: t.project }));
+}
+function Mt(e) {
+	return {
+		dialecteId: e.dialecteId,
+		dialecteVersion: e.dialecteVersion
+	};
+}
+function Nt(e) {
+	let { targets: t, signal: n, suspend: r, resume: i, end: a } = e;
+	t.page.addEventListener("freeze", r, { signal: n }), t.page.addEventListener("resume", function() {
+		i();
+	}, { signal: n }), t.window.addEventListener("pagehide", function(e) {
+		e.persisted ? r() : a();
+	}, { signal: n }), t.window.addEventListener("pageshow", function(e) {
+		e.persisted && i();
+	}, { signal: n });
+}
+function Pt(e) {
+	try {
+		return e.openPort();
+	} catch (e) {
+		throw e instanceof DOMException ? v("STORE_CONNECTION_FAILED", { detail: `The origin's hub could not start: ${e instanceof Error ? e.message : String(e)}` }) : e;
+	}
+}
+async function Ft(e) {
+	let { welcomed: t, failed: n, expired: r } = e, i = n?.then(function(e) {
+		throw e;
+	}) ?? new Promise(Lt);
+	i.catch(Rt), await Promise.race([
+		t,
+		r,
+		i
+	]);
+}
+function It(e) {
+	let { budgetMs: t } = e, n, r = new Promise(function(e, r) {
+		n = setTimeout(function() {
+			r(v("STORE_CONNECTION_FAILED", {
+				detail: `The origin's hub did not welcome this view within ${t} ms (its lock, then the welcome)`,
+				meta: { budgetMs: t }
+			}));
+		}, t);
+	});
+	return r.catch(Rt), {
+		expired: r,
+		clear: function() {
+			clearTimeout(n);
+		}
+	};
+}
+function Lt() {}
+function Rt() {}
+function zt(e) {
+	return v("STORE_CLOSED", {
+		detail: `The link to project "${e.project}" was released: it reaches no engine`,
+		meta: { storeName: e.project }
+	});
+}
+function Bt(e) {
+	let { realmId: t, expired: n } = e;
+	return new Promise(function(e, r) {
+		let i = !1;
+		n.catch(function(e) {
+			i = !0, r(e);
+		}), navigator.locks.request(`${Qe}${t}`, function() {
+			return new Promise(function(t) {
+				i ? t() : e(t);
+			});
+		}).catch(function(e) {
+			r(v("STORE_CONNECTION_FAILED", {
+				detail: "This view could not ask for its lock: it cannot join the hub",
+				cause: e instanceof Error ? e : void 0
+			}));
+		});
+	});
+}
+function Vt() {}
+function Q() {}
+function Ht(e) {
+	e.port.postMessage({ type: "port-unused" }), e.port.close();
+}
+// src/store/sqlite/adapter/realm-storage.ts
+async function Ut() {
+	return typeof Worker < "u" && await Gt();
+}
+function Wt(e) {
+	let t = typeof Worker < "u";
+	ee("STORE_UNAVAILABLE", {
+		detail: `Project "${e.name}" cannot be stored with SQLite here: this ${t ? "browser gives no private file system" : "environment has no worker"}`,
+		meta: { project: e.name }
+	});
+}
+async function Gt() {
+	let e = globalThis.navigator?.storage;
+	if (typeof e?.getDirectory != "function") return !1;
+	try {
+		return await e.getDirectory(), !0;
+	} catch {
+		return !1;
+	}
+}
+// src/store/sqlite/adapter/sqlite-engine-settings.ts
+function Kt(e = {}) {
+	return {
+		...e,
+		wasmUrl: h
+	};
+}
+// src/store/sqlite/adapter/sqlite-hub-spawner.ts
+function qt(e) {
+	let { dialecteId: t, dialecteVersion: n, engineUrl: r, perf: i, options: a, progressBeatOps: o } = e;
+	return {
+		dialecteId: t,
+		dialecteVersion: n,
+		engineUrl: r,
+		perf: i,
+		settings: async function() {
+			return Kt({
+				options: a,
+				progressBeatOps: o
+			});
+		}
+	};
+}
+// src/store/sqlite/adapter/sqlite-worker-connector.ts
+function Jt(e) {
+	let { options: t, progressBeatOps: n, ...r } = e;
+	return Ce({
+		...r,
+		settings: {
+			wasmUrl: h,
+			options: t,
+			progressBeatOps: n
+		}
+	});
+}
+// src/store/sqlite/adapter/sqlite-connector.ts
+function Yt(e) {
+	let { name: t, dialecteId: n, dialecteVersion: r, engineUrl: i, perf: a } = e, o = Jt({
+		name: t,
+		dialecteId: n,
+		dialecteVersion: r,
+		engineUrl: i,
+		perf: a
+	});
+	function s(e) {
+		return Ze({
+			name: t,
+			connection: e.connection,
+			dialecteId: n,
+			dialecteVersion: r,
+			engineUrl: i,
+			deletesFiles: e.deletesFiles
+		});
+	}
+	async function c() {
+		if (!await Ut()) {
+			let e = await Xt();
+			if (e) return s({
+				connection: e,
+				deletesFiles: !1
+			});
+			Wt({ name: t });
+		}
+		if (Pe({
+			name: t,
+			dialecteId: n
+		})) return o;
+		let e = await pt({ spawners: [qt({
+			dialecteId: n,
+			dialecteVersion: r,
+			engineUrl: i,
+			perf: a
+		})] });
+		return e ? s({
+			connection: e,
+			deletesFiles: !0
+		}) : o;
+	}
+	return {
+		connect: async function() {
+			return (await c()).connect();
+		},
+		destroy: async function(e) {
+			return (await c()).destroy(e);
+		}
+	};
+}
+async function Xt() {
+	let e = await mt();
+	return e?.bound ? e : void 0;
+}
+// src/store/sqlite/sqlite-store-of.ts
+function Zt(e) {
+	let { connector: t } = e;
+	return new r({
+		name: t.name,
+		connector: Yt(t)
+	});
+}
+// src/store/hub-public.ts
+async function Qt(e = {}) {
+	let t = await Ut(), n = await pt({
+		spawners: e.spawners?.map($t),
+		hostsNoEngine: !t
+	});
+	return n && nn({ connection: n });
+}
+function $t(e) {
+	let { dialecteId: t, dialecteVersion: n, engineUrl: r } = e;
+	return {
+		dialecteId: t,
+		dialecteVersion: n,
+		engineUrl: r,
+		settings: en
+	};
+}
+async function en() {
+	return Kt();
+}
+async function tn(e) {
+	let t = await _t(e);
+	return t && nn({ connection: t });
+}
+function nn(e) {
+	let { connection: t } = e;
+	return {
+		realmId: t.realmId,
+		createHubPort: t.createHubPort,
+		onRejoined: t.onRejoined
+	};
+}
+// src/store/sqlite/list-projects.constants.ts
+var rn = {
+	magic: "SQLite format 3\0",
+	userVersionOffset: 60,
+	bytes: 100
+}, an = "dialecte-projects", on = "/project.sqlite3", $ = {
+	bytes: 4096,
+	flagsOffset: 512,
+	digestOffset: 516,
+	digestBytes: 8,
+	headBytes: 524
+}, sn = {
+	deleteOnClose: 8,
+	digestV2: 128,
+	persistentTypes: 542976
+}, cn = {
+	seeds: [3735928559, 1103547991],
+	multipliers: [2654435761, 104729]
+};
+// src/store/sqlite/runtime/pool-header.ts
+function ln(e) {
+	let { files: t } = e;
+	return t.some(un) ? "database" : t.every(dn) ? "blank" : "lost";
+}
+function un(e) {
+	return fn({ header: e.header }) === on;
+}
+function dn(e) {
+	return e.size <= $.bytes;
+}
+function fn(e) {
+	let { header: t } = e, n = t.subarray(0, $.digestOffset), r = new DataView(t.buffer, t.byteOffset, t.byteLength).getUint32($.flagsOffset), i = (r & sn.deleteOnClose) !== 0 || (r & sn.persistentTypes) === 0;
+	if (n[0] !== 0 && i) return;
+	let a = new Uint32Array(t.slice($.digestOffset, $.digestOffset + $.digestBytes).buffer), [o, s] = pn({
+		corpus: n,
+		flags: r
+	});
+	if (a[0] !== o || a[1] !== s) return;
+	let c = n.indexOf(0);
+	return new TextDecoder().decode(n.subarray(0, c === -1 ? n.length : c));
+}
+function pn(e) {
+	let { corpus: t, flags: n } = e;
+	if ((n & sn.digestV2) === 0) return [0, 0];
+	let r = cn.seeds[0], i = cn.seeds[1], [a, o] = cn.multipliers;
+	for (let e of t) r = Math.imul(r ^ e, a), i = Math.imul(i ^ e, o);
+	return [r >>> 0, i >>> 0];
+}
+// src/store/sqlite/list-projects.ts
+async function mn(e = {}) {
+	return hn({
+		root: await xn(),
+		dialecteId: e.dialecteId
+	});
+}
+async function hn(e) {
+	let { root: t, dialecteId: n } = e, r = await Sn({
+		parent: t,
+		name: an
+	});
+	if (!r) return [];
+	let i = [];
+	for (let e of await _n({ directory: r }) ?? []) {
+		if (e.kind !== "directory") continue;
+		let t = wn({ part: e.name });
+		if (t !== void 0 && (n === void 0 || t === n)) for (let n of await _n({ directory: e }) ?? []) {
+			if (n.kind !== "directory") continue;
+			let r = wn({ part: n.name });
+			if (r === void 0 || u({
+				dialecteId: t,
+				project: r
+			}) !== Tn({
+				dialecteDirectory: e,
+				projectDirectory: n
+			})) continue;
+			let a = await gn({
+				name: r,
+				dialecteId: t,
+				directory: n
+			});
+			a && i.push(a);
+		}
+	}
+	return i.sort(En);
+}
+async function gn(e) {
+	let { name: t, dialecteId: n } = e, r;
+	try {
+		let t = await _n({ directory: e.directory });
+		if (t === void 0) return;
+		let n = t.find(function(e) {
+			return e.kind === "directory" && e.name === ".opaque";
+		});
+		r = n ? await _n({ directory: n }) : [];
+	} catch {
+		return {
+			name: t,
+			dialecteId: n,
+			state: "unknown",
+			bytes: 0,
+			lastModified: 0
+		};
+	}
+	if (r === void 0) return;
+	let i = [], a = !1;
+	for (let e of r) {
+		if (e.kind !== "file") continue;
+		let t = await bn({ handle: e });
+		t ? i.push(t) : a = !0;
+	}
+	let o = i.reduce(function(e, t) {
+		return e + t.size;
+	}, 0), s = i.reduce(function(e, t) {
+		return Math.max(e, t.lastModified);
+	}, 0);
+	return {
+		name: t,
+		dialecteId: n,
+		state: a ? "unknown" : vn({ files: i }),
+		bytes: o,
+		lastModified: s
+	};
+}
+async function _n(e) {
+	let t = [];
+	try {
+		for await (let n of e.directory.values()) t.push(n);
+	} catch (e) {
+		if (Cn({ thrown: e })) return;
+		throw e;
+	}
+	return t;
+}
+function vn(e) {
+	let { files: t } = e, n = ln({ files: t });
+	if (n === "blank") return "new";
+	if (n === "lost") return "lost";
+	let r = yn({ data: t.findLast(un).data });
+	return r === void 0 ? "new" : r === 4 ? "current" : "outdated";
+}
+function yn(e) {
+	let { data: t } = e;
+	if (!(t.byteLength < rn.bytes) && new TextDecoder().decode(t.subarray(0, rn.magic.length)) === rn.magic) return new DataView(t.buffer, t.byteOffset, t.byteLength).getUint32(rn.userVersionOffset);
+}
+async function bn(e) {
+	for (let t = 1; t <= 3; t++) try {
+		let t = await e.handle.getFile(), n = await t.slice(0, $.bytes + rn.bytes).arrayBuffer(), r = new Uint8Array(n);
+		return {
+			size: t.size,
+			lastModified: t.lastModified,
+			header: r.subarray(0, $.headBytes),
+			data: r.subarray($.bytes)
+		};
+	} catch {
+		if (t === 3) break;
+		await new Promise(function(e) {
+			setTimeout(e, 50);
+		});
+	}
+}
+async function xn() {
+	let e = globalThis.navigator?.storage;
+	try {
+		if (typeof e?.getDirectory == "function") return await e.getDirectory();
+	} catch {}
+	ee("STORE_UNAVAILABLE", { detail: "The projects on SQLite storage cannot be listed here: this browser gives no private file system" });
+}
+async function Sn(e) {
+	try {
+		return await e.parent.getDirectoryHandle(e.name);
+	} catch (e) {
+		if (Cn({ thrown: e })) return;
+		throw e;
+	}
+}
+function Cn(e) {
+	return e.thrown instanceof DOMException && e.thrown.name === "NotFoundError";
+}
+function wn(e) {
+	try {
+		return decodeURIComponent(e.part);
+	} catch {
+		return;
+	}
+}
+function Tn(e) {
+	return `${e.dialecteDirectory.name}/${e.projectDirectory.name}`;
+}
+function En(e, t) {
+	return Dn({
+		first: e.dialecteId,
+		second: t.dialecteId
+	}) || Dn({
+		first: e.name,
+		second: t.name
+	});
+}
+function Dn(e) {
+	let { first: t, second: n } = e;
+	return t < n ? -1 : +(t > n);
+}
+// src/sqlite.ts
+e({ storage: { storeOf: Zt } });
+export { tn as adoptHubPort, Qt as connectHub, mn as listProjects };