@spooky-sync/core 0.0.1-canary.32 → 0.0.1-canary.320

package/dist/live.js

@@ -0,0 +1,709 @@
+import { B as queryHashInput, C as heartbeatRowGone, M as registerVars, N as singleSnapshotSelect, S as heartbeatBatch, a as metaFromRow, b as bodySelect, c as parseDuration, d as parseQueryParams, f as ANON_USER_ID, h as listRefTableFor, j as registerSelect, l as parseRecordIdString, n as rowOfEdge, p as DEFAULT_REF_MODE, s as encodeRecordId, t as hashOfEdge, u as withTimeout, z as sha256Hex } from "./worker-edges.js";
+import { n as decodeTokenClaims } from "./worker-impersonation.js";
+import { RecordId, Surreal } from "surrealdb";
+
+//#region src/live/index.ts
+/**
+* `@spooky-sync/core/live`: a wasm-free live subscriber.
+*
+* Speaks the exact server contract the full client uses, over the pure-JS
+* `surrealdb` SDK and one WebSocket, with no local store, no circuit, no
+* logger and no `window`: it runs in a service worker, a dedicated worker and
+* Node.
+*
+* Per query:
+* - `fn::query::register($config)` plus the membership read-back in one
+*   request (`registerSelect` / `registerVars`, the same builders the full
+*   client's `registerRemote` uses; `$config = { id: _00_query:<key>, surql,
+*   params, ttl }`, key = sha256(JSON.stringify({ surql, params, sessionId })));
+* - bodies with `SELECT * FROM $ids`;
+* - one `LIVE SELECT * FROM <the user's _00_list_ref table> FETCH out` per
+*   feed, so a changed row usually arrives inline with its edge; an edge whose
+*   `out` is a bare id (a server that ignores FETCH) costs a body read, one
+*   whose `out` is null (unreadable or deleted row) a membership re-read;
+* - `fn::query::heartbeat` at half the ttl, re-registering a reclaimed view;
+* - `fn::query::unsubscribe` for every view on `unsubscribe()` / `close()`.
+*
+* Rows are the SDK's decoded values (`id` is a `RecordId`), unordered: apply
+* the query's order yourself if it matters. Related children (`.related()`)
+* are not joined in; subscribe to them separately when you need them.
+*/
+var LiveFeedError = class extends Error {
+	constructor(code, message, cause) {
+		super(message);
+		this.code = code;
+		this.cause = cause;
+		this.name = "LiveFeedError";
+	}
+};
+function createLiveFeed(options) {
+	return new Feed(options);
+}
+const MATERIALIZE_RETRIES = 20;
+const MATERIALIZE_RETRY_MS = 150;
+const FLUSH_MS = 10;
+const FETCH_BATCH_MS = 15;
+const REREAD_MS = 50;
+const RELEASE_TIMEOUT_MS = 2e3;
+function deferred() {
+	let resolve;
+	let reject;
+	const promise = new Promise((res, rej) => {
+		resolve = res;
+		reject = rej;
+	});
+	promise.catch(() => void 0);
+	return {
+		promise,
+		resolve,
+		reject
+	};
+}
+var SubState = class {
+	rid;
+	payload;
+	rows = /* @__PURE__ */ new Map();
+	listeners = /* @__PURE__ */ new Set();
+	ready = deferred();
+	loaded = false;
+	failed = false;
+	registered = false;
+	/** A LIVE event hit this view before its first set landed. */
+	dirtyDuringLoad = false;
+	pending = {
+		added: /* @__PURE__ */ new Map(),
+		updated: /* @__PURE__ */ new Map(),
+		removed: /* @__PURE__ */ new Map()
+	};
+	flushTimer = null;
+	rereadTimer = null;
+	constructor(key, surql, params, ttl) {
+		this.key = key;
+		this.rid = new RecordId("_00_query", key);
+		this.payload = {
+			id: this.rid,
+			surql,
+			params,
+			ttl
+		};
+	}
+	list() {
+		return [...this.rows.values()].map((h) => h.row);
+	}
+};
+function isBuilt(query) {
+	const q = query;
+	return !!(q && (q.innerQuery?.selectQuery || q.selectQuery));
+}
+/** The register input the full client derives from the same query. */
+function liveQueryInput(query, schema) {
+	if (isBuilt(query)) {
+		const inner = "innerQuery" in query ? query.innerQuery : query;
+		const info = inner.selectQuery;
+		const table = inner.tableName;
+		const columns = (schema ?? inner.schema ?? query.schema)?.tables?.find((t) => t.name === table)?.columns;
+		const vars = info.vars ?? {};
+		return {
+			table,
+			surql: info.query,
+			params: columns ? parseQueryParams(columns, vars) : { ...vars }
+		};
+	}
+	const raw = query;
+	if (typeof raw?.surql !== "string") throw new TypeError("live feed: expected a built query or { surql, params }");
+	return {
+		table: raw.table ?? /\bFROM\s+([A-Za-z0-9_]+)/i.exec(raw.surql)?.[1] ?? "",
+		surql: raw.surql,
+		params: { ...raw.params }
+	};
+}
+/** `http(s)://` becomes `ws(s)://`; a bare host gets `/rpc`. */
+function liveEndpoint(endpoint) {
+	try {
+		const url = new URL(endpoint);
+		if (url.protocol === "http:") url.protocol = "ws:";
+		else if (url.protocol === "https:") url.protocol = "wss:";
+		if (url.pathname === "" || url.pathname === "/") url.pathname = "/rpc";
+		return url.toString();
+	} catch {
+		return endpoint;
+	}
+}
+function asRecordId(value) {
+	if (value instanceof RecordId) return value;
+	if (typeof value === "string" && value.includes(":")) return parseRecordIdString(value);
+	return null;
+}
+function keyOf(rid) {
+	return encodeRecordId(rid);
+}
+/** `SELECT out, version ...` rows into edges, one per id at its highest version. */
+function parseEdges(result) {
+	if (!Array.isArray(result)) return null;
+	const out = /* @__PURE__ */ new Map();
+	for (const row of result) {
+		const rid = asRecordId(row?.out);
+		if (!rid) continue;
+		const version = typeof row.version === "number" ? row.version : 0;
+		const key = keyOf(rid);
+		const held = out.get(key);
+		if (!held || held.version < version) out.set(key, {
+			rid,
+			version
+		});
+	}
+	return out;
+}
+/** The three membership statements starting at `offset`: edges, meta, children. */
+function snapshotAt(results, offset) {
+	if (!Array.isArray(results)) return null;
+	const edges = parseEdges(results[offset]);
+	if (!edges) return null;
+	return {
+		edges,
+		state: metaFromRow(results[offset + 1]).state
+	};
+}
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+function randomId() {
+	const c = globalThis.crypto;
+	if (c?.randomUUID) return c.randomUUID();
+	return `s${Date.now().toString(36)}${Math.random().toString(36).slice(2, 12)}`;
+}
+async function resolveToken(source) {
+	if (!source) return null;
+	const value = typeof source === "function" ? await source() : source;
+	return typeof value === "string" && value.length > 0 ? value : null;
+}
+var Feed = class {
+	db = null;
+	connecting = null;
+	uid = null;
+	table = null;
+	live = null;
+	liveStarting = null;
+	subs = /* @__PURE__ */ new Map();
+	sessionId;
+	ttl;
+	timeoutMs;
+	isClosed = false;
+	lastActivity = Date.now();
+	busy = 0;
+	starting = 0;
+	heartbeatTimer = null;
+	fetchTimer = null;
+	fetchQueue = /* @__PURE__ */ new Map();
+	offs = [];
+	dropped = false;
+	constructor(options) {
+		this.options = options;
+		this.sessionId = options.sessionId ?? randomId();
+		this.ttl = options.ttl ?? "10m";
+		this.timeoutMs = options.timeoutMs ?? 15e3;
+	}
+	get userId() {
+		return this.uid;
+	}
+	get listRefTable() {
+		return this.table;
+	}
+	get closed() {
+		return this.isClosed;
+	}
+	connect() {
+		if (this.isClosed) return Promise.reject(new LiveFeedError("closed", "live feed is closed"));
+		if (this.db) return Promise.resolve();
+		if (!this.connecting) this.connecting = this.open().catch((error) => {
+			this.connecting = null;
+			throw error;
+		});
+		return this.connecting;
+	}
+	makeSurreal() {
+		const given = this.options.surreal;
+		if (typeof given === "function") return given();
+		if (given) return given;
+		return new Surreal();
+	}
+	async open() {
+		const token = await resolveToken(this.options.token);
+		this.uid = token ? decodeTokenClaims(token).userId : null;
+		this.table = listRefTableFor(this.options.refMode ?? DEFAULT_REF_MODE, this.uid ?? ANON_USER_ID);
+		const db = this.makeSurreal();
+		try {
+			await db.connect(liveEndpoint(this.options.endpoint), { reconnect: {
+				enabled: true,
+				attempts: 5,
+				retryDelay: 500,
+				retryDelayMax: 5e3,
+				retryDelayMultiplier: 2,
+				retryDelayJitter: .1
+			} });
+			await db.use({
+				namespace: this.options.namespace,
+				database: this.options.database
+			});
+		} catch (error) {
+			await db.close().catch(() => void 0);
+			throw new LiveFeedError("connect", `live feed: could not connect to ${this.options.endpoint}`, error);
+		}
+		if (token) try {
+			await db.authenticate(token);
+		} catch (error) {
+			await db.close().catch(() => void 0);
+			try {
+				await this.options.onUnauthorized?.(error);
+			} catch {}
+			throw new LiveFeedError("unauthorized", "live feed: the server refused the token", error);
+		}
+		if (this.isClosed) {
+			await db.close().catch(() => void 0);
+			throw new LiveFeedError("closed", "live feed is closed");
+		}
+		if (db.subscribe) {
+			const drop = () => {
+				this.dropped = true;
+				this.live?.off();
+				this.live = null;
+			};
+			this.offs.push(db.subscribe("disconnected", drop), db.subscribe("reconnecting", drop), db.subscribe("connected", () => {
+				if (!this.dropped || this.isClosed) return;
+				this.dropped = false;
+				this.recover();
+			}));
+		}
+		this.db = db;
+	}
+	/** After a reconnect: LIVE again, then re-read every view (events in the gap are lost). */
+	async recover() {
+		try {
+			await this.ensureLive();
+			for (const sub of this.subs.values()) if (sub.loaded) this.scheduleReread(sub);
+		} catch (error) {
+			this.report(error);
+		}
+	}
+	async q(sql, vars) {
+		await this.connect();
+		const db = this.db;
+		const result = await withTimeout(Promise.resolve(db.query(sql, vars)), this.timeoutMs, "live feed statement timed out");
+		return Array.isArray(result) ? result : [result];
+	}
+	async query(surql, vars) {
+		try {
+			return await this.q(surql, vars);
+		} catch (error) {
+			if (error instanceof LiveFeedError) throw error;
+			throw new LiveFeedError("query", error instanceof Error ? error.message : String(error), error);
+		}
+	}
+	report(error) {
+		try {
+			this.options.onError?.(error);
+		} catch {}
+	}
+	touch() {
+		this.lastActivity = Date.now();
+	}
+	/** Start the feed's one LIVE query. `true` when this call started it. */
+	async ensureLive() {
+		if (this.live || this.isClosed) return false;
+		if (!this.liveStarting) this.liveStarting = (async () => {
+			try {
+				let id;
+				try {
+					[id] = await this.q(`LIVE SELECT * FROM ${this.table} FETCH out`);
+				} catch (error) {
+					this.report(error);
+					[id] = await this.q(`LIVE SELECT * FROM ${this.table}`);
+				}
+				const stream = await this.db.liveOf(id);
+				const off = stream.subscribe((message) => this.onLive(message));
+				if (this.isClosed) {
+					off();
+					await (stream.kill?.() ?? Promise.resolve()).catch(() => void 0);
+					return false;
+				}
+				this.live = {
+					id,
+					stream,
+					off
+				};
+				return true;
+			} catch (error) {
+				this.report(error);
+				return false;
+			} finally {
+				this.liveStarting = null;
+			}
+		})();
+		return this.liveStarting;
+	}
+	onLive(message) {
+		if (message.action === "KILLED" || this.isClosed) return;
+		const edge = message.value;
+		const hash = hashOfEdge(edge);
+		const sub = hash ? this.subs.get(hash) : void 0;
+		if (!sub || !edge) return;
+		if (edge.parent !== void 0 && edge.parent !== null) return;
+		this.touch();
+		if (!sub.loaded) {
+			sub.dirtyDuringLoad = true;
+			return;
+		}
+		const out = edge.out;
+		if (message.action === "DELETE") {
+			const rid = asRecordId(out) ?? asRecordId(out?.id);
+			if (rid) this.remove(sub, keyOf(rid));
+			else this.scheduleReread(sub);
+			return;
+		}
+		const inline = rowOfEdge(edge);
+		if (inline) {
+			this.upsert(sub, inline.id, inline.version, inline.record);
+			return;
+		}
+		const rid = asRecordId(out);
+		if (rid) {
+			this.enqueueFetch(sub, rid, typeof edge.version === "number" ? edge.version : 0);
+			return;
+		}
+		this.scheduleReread(sub);
+	}
+	upsert(sub, key, version, row) {
+		const held = sub.rows.get(key);
+		if (held && held.version >= version) return;
+		sub.rows.set(key, {
+			version,
+			row
+		});
+		if (sub.pending.removed.has(key)) {
+			sub.pending.removed.delete(key);
+			sub.pending.updated.set(key, row);
+		} else if (held || sub.pending.updated.has(key)) if (sub.pending.added.has(key)) sub.pending.added.set(key, row);
+		else sub.pending.updated.set(key, row);
+		else sub.pending.added.set(key, row);
+		this.scheduleFlush(sub);
+	}
+	remove(sub, key) {
+		const held = sub.rows.get(key);
+		if (!held) return;
+		sub.rows.delete(key);
+		if (sub.pending.added.has(key)) sub.pending.added.delete(key);
+		else {
+			sub.pending.updated.delete(key);
+			sub.pending.removed.set(key, held.row);
+		}
+		this.scheduleFlush(sub);
+	}
+	scheduleFlush(sub) {
+		this.touch();
+		if (sub.flushTimer) return;
+		sub.flushTimer = setTimeout(() => {
+			sub.flushTimer = null;
+			this.flush(sub);
+		}, FLUSH_MS);
+	}
+	flush(sub) {
+		const { added, updated, removed } = sub.pending;
+		if (added.size + updated.size + removed.size === 0) return;
+		sub.pending = {
+			added: /* @__PURE__ */ new Map(),
+			updated: /* @__PURE__ */ new Map(),
+			removed: /* @__PURE__ */ new Map()
+		};
+		const change = {
+			added: [...added.values()],
+			updated: [...updated.values()],
+			removed: [...removed.values()]
+		};
+		const rows = sub.list();
+		this.touch();
+		for (const l of [...sub.listeners]) try {
+			l.handlers.onChange?.(change);
+			l.handlers.onSet(rows);
+		} catch (error) {
+			this.report(error);
+		}
+	}
+	enqueueFetch(sub, rid, version) {
+		const key = keyOf(rid);
+		const entry = this.fetchQueue.get(key) ?? {
+			rid,
+			waiters: []
+		};
+		entry.waiters.push({
+			sub,
+			version
+		});
+		this.fetchQueue.set(key, entry);
+		if (this.fetchTimer) return;
+		this.busy++;
+		this.fetchTimer = setTimeout(() => {
+			this.fetchTimer = null;
+			this.drainFetches().finally(() => {
+				this.busy--;
+				this.touch();
+			});
+		}, FETCH_BATCH_MS);
+	}
+	async drainFetches() {
+		const batch = [...this.fetchQueue.values()];
+		this.fetchQueue.clear();
+		if (batch.length === 0 || this.isClosed) return;
+		try {
+			const bodies = await this.fetchBodies(batch.map((e) => e.rid));
+			for (const entry of batch) {
+				const key = keyOf(entry.rid);
+				const body = bodies.get(key);
+				for (const w of entry.waiters) {
+					if (!this.subs.has(w.sub.key)) continue;
+					if (body) this.upsert(w.sub, key, w.version, body);
+					else this.scheduleReread(w.sub);
+				}
+			}
+		} catch (error) {
+			this.report(error);
+			for (const entry of batch) for (const w of entry.waiters) this.scheduleReread(w.sub);
+		}
+	}
+	async fetchBodies(rids) {
+		const out = /* @__PURE__ */ new Map();
+		if (rids.length === 0) return out;
+		const [rows] = await this.q(bodySelect(), { ids: rids });
+		for (const row of Array.isArray(rows) ? rows : []) {
+			const rid = asRecordId(row?.id);
+			if (rid) out.set(keyOf(rid), row);
+		}
+		return out;
+	}
+	async readSnapshot(sub) {
+		return snapshotAt(await this.q(singleSnapshotSelect(this.table), { in: sub.rid }), 0);
+	}
+	/** Make `sub.rows` equal the snapshot: fetch what is new or newer, drop what left. */
+	async applySnapshot(sub, snap) {
+		const need = [...snap.edges.entries()].filter(([key, e]) => (sub.rows.get(key)?.version ?? -1) < e.version);
+		const bodies = await this.fetchBodies(need.map(([, e]) => e.rid));
+		if (!this.subs.has(sub.key)) return;
+		for (const [key, e] of need) {
+			const body = bodies.get(key);
+			if (body) this.upsert(sub, key, e.version, body);
+		}
+		for (const key of [...sub.rows.keys()]) if (!snap.edges.has(key)) this.remove(sub, key);
+	}
+	scheduleReread(sub) {
+		if (sub.rereadTimer || this.isClosed) return;
+		this.busy++;
+		sub.rereadTimer = setTimeout(() => {
+			sub.rereadTimer = null;
+			this.reread(sub).finally(() => {
+				this.busy--;
+				this.touch();
+			});
+		}, REREAD_MS);
+	}
+	async reread(sub) {
+		if (!this.subs.has(sub.key) || this.isClosed) return;
+		try {
+			const snap = await this.readSnapshot(sub);
+			if (!snap) throw new LiveFeedError("query", "membership re-read did not answer");
+			await this.applySnapshot(sub, snap);
+		} catch (error) {
+			this.report(error);
+			for (const l of sub.listeners) l.handlers.onError?.(error);
+		}
+	}
+	/** Register (or re-register) a view and read its membership back, in one request. */
+	async register(sub) {
+		let snap = snapshotAt(await this.q(registerSelect(this.table), registerVars(sub.payload)), 1);
+		for (let i = 0; snap && snap.state === "materializing" && i < MATERIALIZE_RETRIES; i++) {
+			await sleep(MATERIALIZE_RETRY_MS);
+			snap = await this.readSnapshot(sub);
+		}
+		if (!snap) throw new LiveFeedError("register", "registration read-back did not answer");
+		sub.registered = true;
+		this.ensureHeartbeat();
+		return snap;
+	}
+	async load(sub) {
+		this.busy++;
+		try {
+			await this.connect();
+			let snap = await this.register(sub);
+			if (await this.ensureLive()) snap = await this.readSnapshot(sub) ?? snap;
+			if (!this.subs.has(sub.key)) return;
+			const bodies = await this.fetchBodies([...snap.edges.values()].map((e) => e.rid));
+			for (const [key, e] of snap.edges) {
+				const body = bodies.get(key);
+				if (body) sub.rows.set(key, {
+					version: e.version,
+					row: body
+				});
+			}
+			sub.loaded = true;
+			const rows = sub.list();
+			sub.ready.resolve(rows);
+			this.touch();
+			for (const l of [...sub.listeners]) this.deliverInitial(l, rows);
+			if (sub.dirtyDuringLoad) {
+				sub.dirtyDuringLoad = false;
+				this.scheduleReread(sub);
+			}
+		} catch (error) {
+			sub.failed = true;
+			const err = error instanceof LiveFeedError ? error : new LiveFeedError("register", error instanceof Error ? error.message : String(error), error);
+			sub.ready.reject(err);
+			for (const l of [...sub.listeners]) l.handlers.onError?.(err);
+			this.subs.delete(sub.key);
+		} finally {
+			this.busy--;
+			this.touch();
+		}
+	}
+	deliverInitial(listener, rows) {
+		try {
+			listener.handlers.onSet(rows);
+		} catch (error) {
+			this.report(error);
+		}
+	}
+	ensureHeartbeat() {
+		if (this.heartbeatTimer || this.isClosed) return;
+		const every = Math.max(5e3, Math.floor(parseDuration(this.ttl) / 2));
+		this.heartbeatTimer = setInterval(() => void this.heartbeat(), every);
+		this.heartbeatTimer.unref?.();
+	}
+	async heartbeat() {
+		const subs = [...this.subs.values()].filter((s) => s.registered);
+		if (subs.length === 0 || this.isClosed) return;
+		try {
+			const beat = heartbeatBatch(subs.map((s) => s.rid));
+			const results = await this.q(beat.sql, beat.vars);
+			for (let i = 0; i < subs.length; i++) {
+				if (!heartbeatRowGone(results[i])) continue;
+				const sub = subs[i];
+				try {
+					const snap = await this.register(sub);
+					await this.applySnapshot(sub, snap);
+				} catch (error) {
+					this.report(error);
+				}
+			}
+		} catch (error) {
+			this.report(error);
+		}
+	}
+	subscribe(query, handlers) {
+		const listener = { handlers };
+		let key = null;
+		let state = null;
+		let gone = false;
+		this.starting++;
+		const attached = (async () => {
+			try {
+				if (this.isClosed) throw new LiveFeedError("closed", "live feed is closed");
+				const input = liveQueryInput(query, this.options.schema);
+				key = await sha256Hex(queryHashInput({
+					surql: input.surql,
+					params: input.params
+				}, this.sessionId));
+				if (gone) throw new LiveFeedError("closed", "unsubscribed before the view was registered");
+				let sub = this.subs.get(key);
+				const fresh = !sub;
+				if (!sub) {
+					sub = new SubState(key, input.surql, input.params, this.ttl);
+					this.subs.set(key, sub);
+				}
+				state = sub;
+				sub.listeners.add(listener);
+				if (fresh) this.load(sub);
+				else if (sub.loaded) this.deliverInitial(listener, sub.list());
+				return sub;
+			} finally {
+				this.starting--;
+			}
+		})();
+		const ready = attached.then((sub) => sub.ready.promise);
+		ready.catch((error) => {
+			if (!state) handlers.onError?.(error);
+		});
+		return {
+			ready,
+			rows: () => state ? state.list() : [],
+			get key() {
+				return key;
+			},
+			unsubscribe: async () => {
+				if (gone) return;
+				gone = true;
+				const sub = await attached.catch(() => null);
+				if (!sub) return;
+				sub.listeners.delete(listener);
+				if (sub.listeners.size > 0 || this.subs.get(sub.key) !== sub) return;
+				this.subs.delete(sub.key);
+				if (sub.flushTimer) clearTimeout(sub.flushTimer);
+				if (sub.rereadTimer) {
+					clearTimeout(sub.rereadTimer);
+					this.busy--;
+				}
+				if (sub.registered && !this.isClosed) await this.q("fn::query::unsubscribe($id)", { id: sub.rid }).catch((error) => this.report(error));
+			}
+		};
+	}
+	idle(options = {}) {
+		const timeoutMs = options.timeoutMs ?? 1e4;
+		const quietMs = options.quietMs ?? 300;
+		const deadline = Date.now() + timeoutMs;
+		return new Promise((resolve) => {
+			const check = () => {
+				if (this.isClosed) return resolve(false);
+				const loading = this.starting > 0 || [...this.subs.values()].some((s) => !s.loaded && !s.failed);
+				const flushing = [...this.subs.values()].some((s) => s.flushTimer !== null);
+				const quietFor = Date.now() - this.lastActivity;
+				if (!loading && !flushing && this.busy === 0 && quietFor >= quietMs) return resolve(true);
+				const left = deadline - Date.now();
+				if (left <= 0) return resolve(false);
+				setTimeout(check, Math.max(10, Math.min(50, left, quietMs - quietFor > 0 ? quietMs - quietFor : 50)));
+			};
+			check();
+		});
+	}
+	async close() {
+		if (this.isClosed) return;
+		const db = this.db;
+		const views = [...this.subs.values()].filter((s) => s.registered).map((s) => s.rid);
+		const live = this.live;
+		if (db) {
+			if (live) {
+				live.off();
+				await withTimeout(Promise.resolve(live.stream.kill ? live.stream.kill() : db.query("KILL $u", { u: live.id })), RELEASE_TIMEOUT_MS, "kill timed out").catch(() => void 0);
+			}
+			if (views.length > 0) {
+				const vars = {};
+				const sql = views.map((id, i) => {
+					vars[`id${i}`] = id;
+					return `fn::query::unsubscribe($id${i})`;
+				}).join(";\n");
+				await withTimeout(Promise.resolve(db.query(sql, vars)), RELEASE_TIMEOUT_MS, "release timed out").catch(() => void 0);
+			}
+		}
+		this.isClosed = true;
+		this.live = null;
+		if (this.heartbeatTimer) clearInterval(this.heartbeatTimer);
+		this.heartbeatTimer = null;
+		if (this.fetchTimer) clearTimeout(this.fetchTimer);
+		this.fetchTimer = null;
+		for (const sub of this.subs.values()) {
+			if (sub.flushTimer) clearTimeout(sub.flushTimer);
+			if (sub.rereadTimer) clearTimeout(sub.rereadTimer);
+			if (!sub.loaded) sub.ready.reject(new LiveFeedError("closed", "live feed is closed"));
+		}
+		this.subs.clear();
+		for (const off of this.offs.splice(0)) off();
+		if (db) await db.close().catch(() => void 0);
+		this.db = null;
+	}
+};
+
+//#endregion
+export { LiveFeedError, createLiveFeed, liveEndpoint, liveQueryInput };

package/dist/otel/index.d.ts

@@ -1,4 +1,4 @@
-import { c as PinoTransmit } from "../types.js";
+import { p as PinoTransmit } from "../types.js";
 import { Level } from "pino";
 
 //#region src/otel/index.d.ts