@vercel/board 0.0.0-stage → 0.15.0

package/dist/sql-DbiEnqM0.mjs

@@ -0,0 +1,571 @@
+import { n as setOwn } from "./own-OwgPWdmh.mjs";
+import { r as externalMessageKey } from "./reducers-mUPFuFJV.mjs";
+import { i as syncReads, n as project, r as projectSync, t as concernedMessageId } from "./project-CFiArraX.mjs";
+//#region src/store/sql.ts
+/** The projection's name in `board_positions`, and the A2 consumer that runs it. */
+const TABLES_CONSUMER = "board-tables";
+/** The tables, as statements for one dialect. Postgres users apply them from `schema.sql`. */
+function ddl(dialect) {
+	const big = dialect === "postgres" ? "bigint" : "integer";
+	const bool = dialect === "postgres" ? "boolean" : "integer";
+	return [
+		`create table if not exists board_positions (
+  consumer text primary key,
+  log_index ${big} not null
+)`,
+		`create table if not exists board_messages (
+  id ${big} primary key,
+  event_id text not null unique,
+  channel text not null,
+  re ${big},
+  by_actor text not null,
+  by_principal text not null,
+  by_profile text,
+  from_key text,
+  no_sync ${bool} not null,
+  text_lower text not null,
+  deleted ${bool} not null,
+  created_at ${big} not null,
+  replies integer not null default 0,
+  at ${big},
+  data text not null
+)`,
+		"create index if not exists board_messages_channel on board_messages (channel, id)",
+		"create index if not exists board_messages_re on board_messages (re, id)",
+		"create index if not exists board_messages_by_actor on board_messages (by_actor, id)",
+		"create index if not exists board_messages_by_principal on board_messages (by_principal, id)",
+		"create index if not exists board_threads_at on board_messages (at) where re is null",
+		"create index if not exists board_threads_channel on board_messages (channel, at) where re is null",
+		`create table if not exists board_versions (
+  log_index ${big} primary key,
+  message_id ${big} not null,
+  data text not null
+)`,
+		"create index if not exists board_versions_message on board_versions (message_id, log_index)",
+		`create table if not exists board_terms (
+  message_id ${big} not null,
+  term text not null,
+  value text not null,
+  primary key (message_id, term, value)
+)`,
+		"create index if not exists board_terms_term on board_terms (term, value, message_id)",
+		"create table if not exists board_sync_threads (\n  thread text primary key,\n  data text not null\n)",
+		"create table if not exists board_external_threads (\n  external text primary key,\n  thread text not null\n)",
+		`create table if not exists board_copies (
+  message_id ${big} not null,
+  target text not null,
+  data text not null,
+  primary key (message_id, target)
+)`,
+		`create table if not exists board_external_messages (
+  key text primary key,
+  message_id ${big} not null
+)`,
+		"create index if not exists board_messages_recent on board_messages (by_principal, created_at) where re is null",
+		...dialect === "postgres" ? ["drop function if exists board_apply(text, bigint, boolean, jsonb, jsonb, jsonb)", APPLY_FUNCTION] : []
+	];
+}
+/**
+* Postgres applies an event's change in one call, one round trip: claim the
+* position, then write the message, its version, its terms, and its root's
+* summary. `apply_next` claims only the very next index. SQLite runs the same
+* writes as statements, in process.
+*/
+const APPLY_FUNCTION = `create or replace function board_apply(
+  apply_consumer text,
+  apply_index bigint,
+  apply_next boolean,
+  apply_message jsonb,
+  apply_terms jsonb,
+  apply_summary jsonb,
+  apply_sync jsonb
+) returns boolean language plpgsql as $$
+begin
+  if apply_next then
+    update board_positions set log_index = apply_index
+      where consumer = apply_consumer and log_index = apply_index - 1;
+  else
+    insert into board_positions (consumer, log_index) values (apply_consumer, apply_index)
+      on conflict (consumer) do update set log_index = excluded.log_index
+      where board_positions.log_index < excluded.log_index;
+  end if;
+  if not found then
+    return false;
+  end if;
+  if apply_message is not null then
+    if (apply_message->>'created')::boolean then
+      insert into board_messages
+        (id, event_id, channel, re, by_actor, by_principal, by_profile, from_key, no_sync, text_lower, deleted, created_at, data)
+        values (
+          (apply_message->>'id')::bigint, apply_message->>'event_id', apply_message->>'channel', (apply_message->>'re')::bigint,
+          apply_message->>'by_actor', apply_message->>'by_principal', apply_message->>'by_profile', apply_message->>'from_key',
+          (apply_message->>'no_sync')::boolean, apply_message->>'text_lower', (apply_message->>'deleted')::boolean,
+          (apply_message->>'created_at')::bigint, apply_message->>'data');
+    else
+      update board_messages
+        set text_lower = apply_message->>'text_lower', deleted = (apply_message->>'deleted')::boolean, data = apply_message->>'data'
+        where id = (apply_message->>'id')::bigint;
+    end if;
+    insert into board_versions (log_index, message_id, data)
+      values (apply_index, (apply_message->>'id')::bigint, apply_message->>'data');
+    if apply_terms is not null then
+      delete from board_terms where message_id = (apply_message->>'id')::bigint;
+      insert into board_terms (message_id, term, value)
+        select (apply_message->>'id')::bigint, term->>0, term->>1 from jsonb_array_elements(apply_terms) as term;
+    end if;
+  end if;
+  if apply_summary is not null then
+    update board_messages set replies = (apply_summary->>'replies')::int, at = (apply_summary->>'at')::bigint
+      where id = (apply_summary->>'root')::bigint;
+  end if;
+  if apply_sync is not null then
+    if jsonb_typeof(apply_sync->'thread') = 'object' then
+      insert into board_sync_threads (thread, data) values (apply_sync->'thread'->>'key', apply_sync->'thread'->>'data')
+        on conflict (thread) do update set data = excluded.data;
+    end if;
+    insert into board_external_threads (external, thread)
+      select entry->>0, entry->>1 from jsonb_array_elements(apply_sync->'external_threads') as entry
+      on conflict (external) do update set thread = excluded.thread;
+    insert into board_copies (message_id, target, data)
+      select (entry->>0)::bigint, entry->>1, entry->>2 from jsonb_array_elements(apply_sync->'copies') as entry
+      on conflict (message_id, target) do update set data = excluded.data;
+    insert into board_external_messages (key, message_id)
+      select entry->>0, (entry->>1)::bigint from jsonb_array_elements(apply_sync->'external_messages') as entry
+      on conflict (key) do update set message_id = excluded.message_id;
+  end if;
+  return true;
+end
+$$`;
+/**
+* Postgres refuses NUL in text, and a lone surrogate in JSON: the board refuses
+* both, and a log from before that may hold them. Nothing a reader filters on
+* needs either, so keys and columns go without NUL and with U+FFFD for a lone
+* surrogate, and the lookups that find them do the same.
+*/
+const clean = (value) => value.replaceAll("\0", "").toWellFormed();
+/** A mention's term. Label keys start with a letter or digit, so it's never a label's. */
+const MENTION = "@";
+/** An attachment's term, the same way. */
+const ATTACHMENT = "^";
+/** Terms one insert takes, three parameters each. */
+const TERMS_PER_INSERT = 300;
+var Params = class {
+	values = [];
+	add(value) {
+		this.values.push(value);
+		return `$${this.values.length}`;
+	}
+	list(values) {
+		return values.map((value) => this.add(value)).join(", ");
+	}
+};
+const likeEscape = (text) => text.replace(/[\\%_]/g, (c) => `\\${c}`);
+/** A channel, or a channel and everything under it, on the messages table aliased `alias`. */
+function channelClause(alias, channel, p) {
+	const path = p.add(channel.path);
+	if (!channel.subtree) return `${alias}.channel = ${path}`;
+	const prefix = `cast(${p.add(`${channel.path}/`)} as text)`;
+	return `(${alias}.channel = ${path} or substr(${alias}.channel, 1, length(${prefix})) = ${prefix})`;
+}
+/** The filter as `where` clauses on the messages table aliased `m`. */
+function clauses(filter, p) {
+	const out = [];
+	if (filter.channel) out.push(channelClause("m", filter.channel, p));
+	if (filter.channels) out.push(filter.channels.length ? `m.channel in (${p.list(filter.channels)})` : "1 = 0");
+	if (filter.re !== void 0) {
+		const re = p.add(filter.re);
+		out.push(`(m.id = ${re} or m.re = ${re})`);
+	}
+	if (filter.by) {
+		const { actors, principals } = filter.by;
+		const either = [...actors.length ? [`m.by_actor in (${p.list(actors)})`] : [], ...principals.length ? [`m.by_principal in (${p.list(principals)})`] : []];
+		out.push(either.length ? `(${either.join(" or ")})` : "1 = 0");
+	}
+	if (filter.mentions) out.push(filter.mentions.length ? `exists (select 1 from board_terms t where t.message_id = m.id and t.term = '${MENTION}' and t.value in (${p.list(filter.mentions)}))` : "1 = 0");
+	if (filter.from !== void 0) out.push(`coalesce(m.from_key, 'board') = ${p.add(filter.from)}`);
+	if (filter.text !== void 0) out.push(`m.text_lower like ${p.add(`%${likeEscape(filter.text)}%`)} escape '\\'`);
+	for (const label of filter.labels ?? []) {
+		const values = label.values === null ? "" : ` and t.value in (${p.list(label.values)})`;
+		out.push(`exists (select 1 from board_terms t where t.message_id in (m.id, m.re) and t.term = ${p.add(label.key)}${values})`);
+	}
+	return out;
+}
+const parse = (row) => row === void 0 || row.data === null || row.data === void 0 ? null : JSON.parse(String(row.data));
+/** The tables on a SQL database. */
+function sqlTables(db) {
+	const positionSql = {
+		text: "select log_index from board_positions where consumer = $1",
+		values: [TABLES_CONSUMER]
+	};
+	const position = (rows) => rows[0] ? Number(rows[0].log_index) : 0;
+	const claim = (index) => ({
+		text: `insert into board_positions (consumer, log_index) values ($1, $2)
+  on conflict (consumer) do update set log_index = excluded.log_index
+  where board_positions.log_index < excluded.log_index
+  returning 1 as claimed`,
+		values: [TABLES_CONSUMER, index]
+	});
+	/** Only the event right after the position: never ahead of events the tables haven't applied. */
+	const claimNext = (index) => ({
+		text: "update board_positions set log_index = $2 where consumer = $1 and log_index = $3 returning 1 as claimed",
+		values: [
+			TABLES_CONSUMER,
+			index,
+			index - 1
+		]
+	});
+	async function row(id) {
+		const [found] = await db.all({
+			text: "select data, replies, at from board_messages where id = $1",
+			values: [id]
+		});
+		return found;
+	}
+	async function before(event, id) {
+		const found = event.type === "message.posted" ? void 0 : await row(id);
+		const message = parse(found) ?? void 0;
+		const rootId = event.type === "message.posted" ? event.payload.re : message?.re ?? null;
+		if (rootId === null) return {
+			message,
+			root: void 0
+		};
+		const rootRow = await row(rootId);
+		const root = rootRow ? {
+			replies: Number(rootRow.replies),
+			at: Number(rootRow.at)
+		} : void 0;
+		if (event.type === "message.deleted" && message && !message.deleted && root?.at === id) {
+			const [newest] = await db.all({
+				text: "select max(id) as id from board_messages where re = $1 and not deleted and id <> $2",
+				values: [rootId, id]
+			});
+			return {
+				message,
+				root,
+				previousLast: newest?.id === null || newest?.id === void 0 ? null : Number(newest.id)
+			};
+		}
+		return {
+			message,
+			root
+		};
+	}
+	async function syncBefore(event) {
+		const reads = syncReads(event);
+		const [thread] = reads.thread === null ? [] : await db.all({
+			text: "select data from board_sync_threads where thread = $1",
+			values: [clean(reads.thread)]
+		});
+		const [copy] = reads.copy === null ? [] : await db.all({
+			text: "select data from board_copies where message_id = $1 and target = $2",
+			values: [reads.copy[0], clean(reads.copy[1])]
+		});
+		return {
+			thread: thread ? JSON.parse(String(thread.data)) : void 0,
+			copy: copy ? JSON.parse(String(copy.data)) : void 0
+		};
+	}
+	/** The sync rows an event writes, as values; null when it writes none. */
+	function syncPayload(change) {
+		if (!change.thread && !change.externalThreads.length && !change.copies.length && !change.externalMessages.length) return null;
+		return {
+			thread: change.thread ? {
+				key: clean(change.thread.key),
+				data: JSON.stringify(change.thread.data)
+			} : null,
+			external_threads: change.externalThreads.map(([external, thread]) => [clean(external), clean(thread)]),
+			copies: change.copies.map(([message, target, copy]) => [
+				message,
+				clean(target),
+				JSON.stringify(copy)
+			]),
+			external_messages: change.externalMessages.map(([key, message]) => [clean(key), message])
+		};
+	}
+	/** What an event writes, as column values: the one place they're derived. */
+	function payload(event, change, sync) {
+		const m = change.message?.after;
+		return {
+			message: m && {
+				id: m.id,
+				created: change.message.created,
+				event_id: clean(event.id),
+				channel: m.channel,
+				re: m.re,
+				by_actor: clean(m.by.actor),
+				by_principal: clean(m.by.principal),
+				by_profile: m.by.profile === null ? null : clean(m.by.profile),
+				from_key: m.from,
+				no_sync: m.noSync,
+				text_lower: clean(m.text.toLowerCase()),
+				deleted: m.deleted,
+				created_at: Date.parse(m.createdAt),
+				data: JSON.stringify(m)
+			},
+			terms: m && change.message.terms ? [
+				...Object.entries(m.labels).map(([key, value]) => [key, clean(value)]),
+				...[...new Set(m.mentions)].map((actor) => [MENTION, clean(actor)]),
+				...[...new Set(m.attachments.map((file) => file.id))].map((id) => [ATTACHMENT, clean(id)])
+			] : null,
+			summary: change.summary ?? null,
+			sync: syncPayload(sync)
+		};
+	}
+	/** The writes as statements, for SQLite. Postgres's `board_apply` does the same. */
+	function statements(index, { message: m, terms, summary, sync }) {
+		const out = [];
+		if (m) {
+			if (m.created) out.push({
+				text: `insert into board_messages
+  (id, event_id, channel, re, by_actor, by_principal, by_profile, from_key, no_sync, text_lower, deleted, created_at, data)
+  values ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13)`,
+				values: [
+					m.id,
+					m.event_id,
+					m.channel,
+					m.re,
+					m.by_actor,
+					m.by_principal,
+					m.by_profile,
+					m.from_key,
+					m.no_sync,
+					m.text_lower,
+					m.deleted,
+					m.created_at,
+					m.data
+				]
+			});
+			else out.push({
+				text: "update board_messages set text_lower = $1, deleted = $2, data = $3 where id = $4",
+				values: [
+					m.text_lower,
+					m.deleted,
+					m.data,
+					m.id
+				]
+			});
+			out.push({
+				text: "insert into board_versions (log_index, message_id, data) values ($1, $2, $3)",
+				values: [
+					index,
+					m.id,
+					m.data
+				]
+			});
+			if (terms) {
+				if (!m.created) out.push({
+					text: "delete from board_terms where message_id = $1",
+					values: [m.id]
+				});
+				for (let first = 0; first < terms.length; first += TERMS_PER_INSERT) {
+					const p = new Params();
+					const tuples = terms.slice(first, first + TERMS_PER_INSERT).map(([term, value]) => `(${p.add(m.id)}, ${p.add(term)}, ${p.add(value)})`);
+					out.push({
+						text: `insert into board_terms (message_id, term, value) values ${tuples.join(", ")}`,
+						values: p.values
+					});
+				}
+			}
+		}
+		if (summary) out.push({
+			text: "update board_messages set replies = $1, at = $2 where id = $3",
+			values: [
+				summary.replies,
+				summary.at,
+				summary.root
+			]
+		});
+		if (sync) {
+			if (sync.thread) out.push({
+				text: "insert into board_sync_threads (thread, data) values ($1, $2) on conflict (thread) do update set data = excluded.data",
+				values: [sync.thread.key, sync.thread.data]
+			});
+			for (const [external, thread] of sync.external_threads) out.push({
+				text: "insert into board_external_threads (external, thread) values ($1, $2) on conflict (external) do update set thread = excluded.thread",
+				values: [external, thread]
+			});
+			for (const [message, target, data] of sync.copies) out.push({
+				text: "insert into board_copies (message_id, target, data) values ($1, $2, $3) on conflict (message_id, target) do update set data = excluded.data",
+				values: [
+					message,
+					target,
+					data
+				]
+			});
+			for (const [key, message] of sync.external_messages) out.push({
+				text: "insert into board_external_messages (key, message_id) values ($1, $2) on conflict (key) do update set message_id = excluded.message_id",
+				values: [key, message]
+			});
+		}
+		return out;
+	}
+	/** Claims `event` (only if it's the next one, with `next`) and writes what it changes, atomically. */
+	async function commit(event, next) {
+		if (next && position(await db.all(positionSql)) !== event.index - 1) return false;
+		const id = concernedMessageId(event);
+		const [change, sync] = await Promise.all([id === null ? {} : before(event, id).then((read) => project(read, event)), syncBefore(event).then((read) => projectSync(read, event))]);
+		const written = payload(event, change, sync);
+		if (db.dialect === "postgres") {
+			const json = (value) => value === null || value === void 0 ? null : JSON.stringify(value);
+			const [row] = await db.all({
+				text: "select board_apply($1, $2, $3, $4::jsonb, $5::jsonb, $6::jsonb, $7::jsonb) as applied",
+				values: [
+					TABLES_CONSUMER,
+					event.index,
+					next,
+					json(written.message),
+					json(written.terms),
+					json(written.summary),
+					json(written.sync)
+				]
+			});
+			return row?.applied === true;
+		}
+		return db.commit(next ? claimNext(event.index) : claim(event.index), statements(event.index, written));
+	}
+	function threadsQuery(filter, page) {
+		const p = new Params();
+		const where = ["r.re is null"];
+		const { channel, channels, ...rest } = filter;
+		if (channel) where.push(channelClause("r", channel, p));
+		if (channels) where.push(channels.length ? `r.channel in (${p.list(channels)})` : "1 = 0");
+		const matching = clauses(rest, p);
+		if (matching.length > 0) where.push(`r.id in (select coalesce(m.re, m.id) from board_messages m where ${matching.join(" and ")})`);
+		if (page.after !== void 0) where.push(`r.at > ${p.add(page.after)}`);
+		const order = page.after !== void 0 ? "asc" : "desc";
+		return {
+			text: `select r.data as data, r.replies as replies, l.data as last
+from board_messages r left join board_messages l on l.id = r.at and r.at <> r.id
+where ${where.join(" and ")}
+order by r.at ${order} limit ${p.add(page.limit)}`,
+			values: p.values
+		};
+	}
+	return {
+		async position() {
+			return position(await db.all(positionSql));
+		},
+		async apply(event) {
+			if (position(await db.all(positionSql)) >= event.index) return;
+			await commit(event, false);
+		},
+		applyNext: (event) => commit(event, true),
+		async message(id) {
+			return parse(await row(id));
+		},
+		async byEventId(eventId) {
+			const [found] = await db.all({
+				text: "select data from board_messages where event_id = $1",
+				values: [clean(eventId)]
+			});
+			return parse(found);
+		},
+		async messagesAt(ids, index) {
+			const out = /* @__PURE__ */ new Map();
+			if (ids.length === 0) return out;
+			const p = new Params();
+			const rows = await db.all({
+				text: `select v.message_id as id, v.data as data from board_versions v
+where v.message_id in (${p.list([...new Set(ids)])})
+  and v.log_index = (select max(w.log_index) from board_versions w where w.message_id = v.message_id and w.log_index <= ${p.add(index)})`,
+				values: p.values
+			});
+			for (const found of rows) out.set(Number(found.id), parse(found));
+			return out;
+		},
+		async thread(root) {
+			return (await db.all({
+				text: "select data from board_messages where id = $1 or re = $1 order by id",
+				values: [root]
+			})).map((found) => parse(found));
+		},
+		async messages(filter, page) {
+			const p = new Params();
+			const where = clauses(filter, p);
+			if (page.before !== void 0) where.push(`m.id < ${p.add(page.before)}`);
+			if (page.after !== void 0) where.push(`m.id > ${p.add(page.after)}`);
+			const order = page.after !== void 0 ? "asc" : "desc";
+			const query = {
+				text: `select m.data as data from board_messages m${where.length ? ` where ${where.join(" and ")}` : ""} order by m.id ${order} limit ${p.add(page.limit)}`,
+				values: p.values
+			};
+			const [positions, rows] = await db.read([positionSql, query]);
+			const messages = rows.map((found) => parse(found));
+			return {
+				messages: page.after !== void 0 ? messages : messages.reverse(),
+				position: position(positions)
+			};
+		},
+		async threads(filter, page) {
+			const [positions, rows] = await db.read([positionSql, threadsQuery(filter, page)]);
+			const threads = rows.map((found) => ({
+				root: parse(found),
+				replies: Number(found.replies),
+				last: found.last === null || found.last === void 0 ? null : JSON.parse(String(found.last))
+			}));
+			return {
+				threads: page.after !== void 0 ? threads : threads.reverse(),
+				position: position(positions)
+			};
+		},
+		async syncOf(thread) {
+			const [found] = await db.all({
+				text: "select data from board_sync_threads where thread = $1",
+				values: [clean(thread)]
+			});
+			return found ? JSON.parse(String(found.data)) : null;
+		},
+		async threadOf(external) {
+			const [found] = await db.all({
+				text: "select thread from board_external_threads where external = $1",
+				values: [clean(external)]
+			});
+			return found ? String(found.thread) : null;
+		},
+		async copiesOf(ids) {
+			const out = /* @__PURE__ */ new Map();
+			if (ids.length === 0) return out;
+			const p = new Params();
+			const rows = await db.all({
+				text: `select message_id, target, data from board_copies where message_id in (${p.list([...new Set(ids)])})`,
+				values: p.values
+			});
+			for (const found of rows) {
+				const copies = out.get(Number(found.message_id)) ?? {};
+				setOwn(copies, String(found.target), JSON.parse(String(found.data)));
+				out.set(Number(found.message_id), copies);
+			}
+			return out;
+		},
+		async messageOf(externalThread, platformMessage) {
+			const [found] = await db.all({
+				text: "select message_id from board_external_messages where key = $1",
+				values: [clean(externalMessageKey(externalThread, platformMessage))]
+			});
+			return found ? Number(found.message_id) : null;
+		},
+		async externalThreads() {
+			return (await db.all({
+				text: "select external from board_external_threads",
+				values: []
+			})).map((found) => String(found.external));
+		},
+		async withAttachment(attachment) {
+			return (await db.all({
+				text: `select m.data as data from board_messages m
+where exists (select 1 from board_terms t where t.message_id = m.id and t.term = '${ATTACHMENT}' and t.value = $1)
+order by m.id`,
+				values: [clean(attachment)]
+			})).map((found) => parse(found));
+		},
+		async recentRoots(principal, since) {
+			return (await db.all({
+				text: "select data from board_messages where by_principal = $1 and re is null and created_at >= $2 order by id",
+				values: [principal, since]
+			})).map((found) => parse(found));
+		},
+		close: () => db.close()
+	};
+}
+//#endregion
+export { ddl as n, sqlTables as r, TABLES_CONSUMER as t };

package/dist/sqlite-db-Cbj03vmp.mjs

@@ -0,0 +1,70 @@
+import { n as ddl } from "./sql-DbiEnqM0.mjs";
+import { mkdirSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+//#region src/store/sqlite-db.ts
+/** `$1` → `?1`: SQLite's numbered parameters, bound in order. */
+const numbered = (text) => text.replace(/\$(\d+)/g, "?$1");
+/** SQLite has no booleans. */
+const bind = (value) => typeof value === "boolean" ? value ? 1 : 0 : value ?? null;
+/**
+* The tables on `node:sqlite`, at `path` (`:memory:` works). Every transaction
+* runs synchronously, from `begin` to `commit`: A2's SQLite store, on another
+* handle to the same file, blocks the thread while it waits for the lock, so
+* a transaction of ours that yielded in between would wait on itself.
+*/
+function sqliteDb(path) {
+	const { DatabaseSync: Database } = process.getBuiltinModule("node:sqlite");
+	if (path !== ":memory:") mkdirSync(dirname(resolve(
+		/* turbopackIgnore: true */
+		path
+	)), { recursive: true });
+	const db = new Database(path);
+	db.exec("pragma busy_timeout = 5000");
+	for (const statement of ddl("sqlite")) db.exec(statement);
+	const statements = /* @__PURE__ */ new Map();
+	const run = (query) => {
+		let statement = statements.get(query.text);
+		if (!statement) statements.set(query.text, statement = db.prepare(numbered(query.text)));
+		return statement.all(...query.values.map(bind));
+	};
+	const rollback = () => {
+		try {
+			db.exec("rollback");
+		} catch {}
+	};
+	return {
+		dialect: "sqlite",
+		all: async (query) => run(query),
+		async read(queries) {
+			db.exec("begin");
+			try {
+				const rows = queries.map(run);
+				db.exec("commit");
+				return rows;
+			} catch (error) {
+				rollback();
+				throw error;
+			}
+		},
+		async commit(claim, writes) {
+			db.exec("begin immediate");
+			try {
+				if (run(claim).length === 0) {
+					db.exec("rollback");
+					return false;
+				}
+				for (const write of writes) run(write);
+				db.exec("commit");
+				return true;
+			} catch (error) {
+				rollback();
+				throw error;
+			}
+		},
+		async close() {
+			db.close();
+		}
+	};
+}
+//#endregion
+export { sqliteDb as t };