acrylblends 0.8.1 → 0.9.0

package/lib/cordis/router.js

@@ -0,0 +1,7 @@
+import { HTTPException } from "../http-exception.js";
+import { t as Context } from "../context-DDO0cfuP.js";
+import { t as Acryl } from "../app-BM0rTCp7.js";
+import { t as App } from "../deprecated-BP4fPt38.js";
+import { n as getConnInfo, t as connectionOf } from "../connection-C7xgP1hP.js";
+import { i as name, n as Router, r as apply, t as Config } from "../src-CwABFr6r.js";
+export { Acryl, App, Config, Context, HTTPException, Router, apply, connectionOf, getConnInfo, name };

package/lib/cordis/state/react.d.ts

@@ -0,0 +1,6 @@
+import { r as ReadonlyCell } from "../../cell-ChU41DZD.js";
+
+//#region ../../plugins/acryl-state/src/react.d.ts
+declare function useCell<T>(cell: ReadonlyCell<T>): T;
+//#endregion
+export { useCell };

package/lib/cordis/state/react.js

@@ -0,0 +1,11 @@
+import { useSyncExternalStore } from "react";
+//#region ../../plugins/acryl-state/src/react.ts
+/**
+* The React binding: one hook that reads a cell and re-renders when it changes. `useSyncExternalStore` is React's own
+* contract for exactly this, so it is tear-free under concurrent rendering. Import from `acryl-state/react`.
+*/
+function useCell(cell) {
+	return useSyncExternalStore((listener) => cell.subscribe(listener), cell.get, cell.get);
+}
+//#endregion
+export { useCell };

package/lib/cordis/state.d.ts

@@ -0,0 +1,33 @@
+import { t as Context$1 } from "../context-DS3fYyG-.js";
+import { a as createDerived, i as createCell, n as Listener, r as ReadonlyCell, t as Cell } from "../cell-ChU41DZD.js";
+import { Context, Service } from "@deepseek-ai/cordis";
+
+//#region ../../plugins/acryl-state/src/service.d.ts
+declare module '@deepseek-ai/cordis' {
+  interface Context {
+    state: State;
+  }
+}
+/** Stable Cordis plugin name, equal to the package name and the Loader row id. */
+declare const name = "acryl-state";
+declare class State extends Service {
+  private readonly cells;
+  constructor(ctx: Context);
+  private claim;
+  private report;
+  /** Create a writable cell owned by the calling plugin. The key must be new. */
+  cell<T>(key: string, initial: T): Cell<T>;
+  /** Create a read-only cell computed from other cells, owned by the calling plugin. */
+  derive<D extends readonly ReadonlyCell<unknown>[], T>(key: string, inputs: D, compute: (...values: { [K in keyof D]: D[K] extends ReadonlyCell<infer V> ? V : never }) => T): ReadonlyCell<T>;
+  /** A cell by key, if one is live. */
+  find<T = unknown>(key: string): ReadonlyCell<T> | undefined;
+  keys(): string[];
+  /**
+   * The current value of `key` as a server-sent event stream: the value now, then one event per change, until the client cancels or the router
+   * is disposed (both abort the stream). A comment line goes out every 15 seconds so proxies and browsers keep an idle stream open.
+   */
+  stream(key: string, c: Context$1): Response | undefined;
+}
+declare function apply(ctx: Context): void;
+//#endregion
+export { type Cell, type Listener, type ReadonlyCell, State, apply, createCell, createDerived, name };

package/lib/cordis/state.js

@@ -0,0 +1,163 @@
+import { t as Acryl } from "../app-BM0rTCp7.js";
+import { methodNotAllowed } from "../method-not-allowed.js";
+import { r as streamSSE } from "../streaming-DHST3Scg.js";
+import { loopbackOnly } from "../loopback-only.js";
+import "../helpers-CvTauQT5.js";
+import "../src-CwABFr6r.js";
+import "../middleware-CPQ8himN.js";
+import { Service } from "@deepseek-ai/cordis";
+//#region ../../plugins/acryl-state/src/cell.ts
+/** A writable cell. `report` receives anything a listener throws; one failing listener never blocks the others. */
+function createCell(key, initial, report = () => void 0) {
+	let value = initial;
+	const listeners = /* @__PURE__ */ new Set();
+	const set = (next) => {
+		if (Object.is(next, value)) return;
+		const previous = value;
+		value = next;
+		for (const listener of [...listeners]) try {
+			listener(next, previous);
+		} catch (error) {
+			report(error);
+		}
+	};
+	return {
+		key,
+		get: () => value,
+		set,
+		update: (change) => {
+			set(change(value));
+		},
+		subscribe: (listener) => {
+			listeners.add(listener);
+			return () => {
+				listeners.delete(listener);
+			};
+		}
+	};
+}
+/**
+* A read-only cell computed from other cells and recomputed whenever one of them changes. `dispose` detaches it from its
+* inputs; after that it keeps its last value.
+*/
+function createDerived(key, inputs, compute, report = () => void 0) {
+	const read = () => compute(...inputs.map((input) => input.get()));
+	const inner = createCell(key, read(), report);
+	const stops = inputs.map((input) => input.subscribe(() => {
+		inner.set(read());
+	}));
+	return {
+		cell: {
+			key,
+			get: inner.get,
+			subscribe: inner.subscribe
+		},
+		dispose: () => {
+			for (const stop of stops) stop();
+		}
+	};
+}
+//#endregion
+//#region ../../plugins/acryl-state/src/service.ts
+/**
+* The ACRYL state service (`ctx.state`): observable cells owned by plugins. A cell created from a plugin's context is removed
+* when that plugin unloads, so a surface never keeps a value alive for a plugin that is gone. In process the cells are read
+* and subscribed to directly (the terminal UI); with a router present they are also readable as JSON and streamable as
+* server-sent events (Web and Desktop), read-only: only the Host plugin that owns a cell writes it.
+*/
+const KEEP_ALIVE_MS = 15e3;
+/** Stable Cordis plugin name, equal to the package name and the Loader row id. */
+const name = "acryl-state";
+const KEY_PATTERN = /^[a-z][a-z0-9-]*(\.[a-z][a-z0-9-]*)*$/;
+var State = class extends Service {
+	cells = /* @__PURE__ */ new Map();
+	constructor(ctx) {
+		super(ctx, "state");
+	}
+	claim(key) {
+		if (!KEY_PATTERN.test(key)) throw new TypeError(`acryl-state: key "${key}" must be dotted lowercase words, like "market.sources"`);
+		if (this.cells.has(key)) throw new Error(`acryl-state: key "${key}" is already in use`);
+	}
+	report = (error) => {
+		this.ctx.logger.error(`acryl-state: a subscriber failed: ${error instanceof Error ? error.message : String(error)}`);
+	};
+	/** Create a writable cell owned by the calling plugin. The key must be new. */
+	cell(key, initial) {
+		this.claim(key);
+		const cell = createCell(key, initial, this.report);
+		this.cells.set(key, cell);
+		this.ctx.effect(() => () => {
+			this.cells.delete(key);
+		}, `acryl-state: cell ${key}`);
+		return cell;
+	}
+	/** Create a read-only cell computed from other cells, owned by the calling plugin. */
+	derive(key, inputs, compute) {
+		this.claim(key);
+		const derived = createDerived(key, inputs, compute, this.report);
+		this.cells.set(key, derived.cell);
+		this.ctx.effect(() => () => {
+			derived.dispose();
+			this.cells.delete(key);
+		}, `acryl-state: derived ${key}`);
+		return derived.cell;
+	}
+	/** A cell by key, if one is live. */
+	find(key) {
+		return this.cells.get(key);
+	}
+	keys() {
+		return [...this.cells.keys()].sort();
+	}
+	/**
+	* The current value of `key` as a server-sent event stream: the value now, then one event per change, until the client cancels or the router
+	* is disposed (both abort the stream). A comment line goes out every 15 seconds so proxies and browsers keep an idle stream open.
+	*/
+	stream(key, c) {
+		const cell = this.find(key);
+		if (cell === void 0) return void 0;
+		return streamSSE(c, async (stream) => {
+			const ended = new Promise((resolve) => {
+				stream.onAbort(resolve);
+			});
+			let queue = Promise.resolve();
+			const send = (value) => {
+				queue = queue.then(() => stream.writeSSE({
+					event: "value",
+					data: typeof value === "string" ? value : JSON.stringify(value)
+				})).catch(() => {});
+			};
+			send(cell.get());
+			const unsubscribe = cell.subscribe(send);
+			const keepAlive = setInterval(() => {
+				queue = queue.then(() => stream.write(": keepalive\n\n")).catch(() => {});
+			}, KEEP_ALIVE_MS);
+			keepAlive.unref();
+			try {
+				await ended;
+			} finally {
+				clearInterval(keepAlive);
+				unsubscribe();
+			}
+		});
+	}
+};
+function apply(ctx) {
+	const state = new State(ctx);
+	ctx.inject(["router"], (inner) => {
+		const api = new Acryl();
+		api.use(loopbackOnly({ inProcess: "allow" }), methodNotAllowed({ app: api })).get("/", (c) => c.json({ keys: state.keys() })).get("/:key", (c) => {
+			const cell = state.find(c.req.param("key"));
+			return cell === void 0 ? c.json({ error: "no such state" }, 404) : c.json({
+				key: cell.key,
+				value: cell.get()
+			});
+		}).get("/:key/events", (c) => state.stream(c.req.param("key"), c) ?? c.json({ error: "no such state" }, 404));
+		inner.router.route("/api/state", api);
+		inner.inject(["routerHttp"], (http) => {
+			http.routerHttp.mount("/api/state");
+		});
+	});
+}
+//#endregion
+export { State, apply, createCell, createDerived, name };

package/lib/core-CaY8XDZ6.js

@@ -0,0 +1,19 @@
+import "./app-BM0rTCp7.js";
+//#region ../../plugins/acryl-router/src/core/index.ts
+/**
+* @module
+*
+* Acryl - Web Framework built on Web Standards
+*
+* @example
+* ```ts
+* import { Acryl } from 'acrylblends'
+* const app = new Acryl()
+*
+* app.get('/', (c) => c.text('Acryl!'))
+*
+* export default app
+* ```
+*/
+//#endregion
+export {};

package/lib/database-DBHdwefi.d.ts

@@ -0,0 +1,44 @@
+//#region ../../plugins/acryl-db/src/facade/database.d.ts
+/** Values supported by the portable SQL drivers. */
+type SqlValue = null | number | bigint | string | Uint8Array;
+/**
+ * Asynchronous SQL operations shared by a database and its transaction handles.
+ *
+ * `exec` runs SQL text without bindings and may contain several statements. `run`, `get`, and `all`
+ * execute one statement with positional bindings. Adapters may cache prepared statements by SQL text,
+ * so callers pass values as bindings instead of interpolating them. `run` resolves the number of rows
+ * the statement changed.
+ */
+interface DbExecutor {
+  exec(sql: string): Promise<void>;
+  run(sql: string, ...params: SqlValue[]): Promise<{
+    readonly changes: number;
+  }>;
+  get<T extends object>(sql: string, ...params: SqlValue[]): Promise<T | undefined>;
+  all<T extends object>(sql: string, ...params: SqlValue[]): Promise<T[]>;
+}
+/**
+ * Minimal portable SQL database facade.
+ *
+ * All operations are asynchronous so adapters may execute outside the caller's runtime.
+ *
+ * `transaction` passes the callback a transaction handle. All work in the transaction
+ * must use that handle; the handle is invalid after the callback settles. Adapters must
+ * queue unrelated operations and other transactions until the transaction finishes. The
+ * returned promise settles after commit or rollback. Calling the database itself (including
+ * `transaction`) from inside a callback therefore waits for that transaction and
+ * never settles.
+ *
+ * When the callback rejects, the adapter must roll the transaction back before rejecting
+ * with that same error. If rollback fails, it must reject with a different error (for
+ * example an `AggregateError`) so callers cannot mistake the callback error for a
+ * guaranteed rollback.
+ *
+ * Closing is the adapter's: the plugin that opened a database closes it, so the facade an
+ * app receives has no `close`.
+ */
+interface Db extends DbExecutor {
+  transaction<T>(callback: (transaction: DbExecutor) => Promise<T>): Promise<T>;
+}
+//#endregion
+export { DbExecutor as n, SqlValue as r, Db as t };

package/lib/db/conformance.d.ts

@@ -0,0 +1,11 @@
+import { t as Db } from "../database-DBHdwefi.js";
+
+//#region ../../plugins/acryl-db/src/conformance.d.ts
+/** A fresh, empty database from the provider under test, and how to close it. */
+interface DbUnderTest {
+  readonly db: Db;
+  close(): Promise<void>;
+}
+declare function describeDbConformance(provider: string, open: () => Promise<DbUnderTest>): void;
+//#endregion
+export { DbUnderTest, describeDbConformance };

package/lib/db/conformance.js

@@ -0,0 +1,267 @@
+import { i as applyMigrations, n as MIGRATIONS_TABLE, r as readMigrationFiles } from "../src-MWcsMS8i.js";
+import { mkdtemp, rm, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { afterEach, describe, expect, it } from "vitest";
+//#region ../../plugins/acryl-db/src/conformance.ts
+/**
+* The `db` conformance suite: what every provider of the port must do, as Vitest tests. A provider passes it to be accepted
+* (`describeDbConformance('acryl-db-sqlite', open)` in its own tests); the SQL is the portable subset, with `?` bindings, so the same
+* suite runs unchanged on SQLite and Postgres.
+*
+* A `?` inside a string literal, a quoted identifier or a comment is text, not a binding. Foreign keys are enforced (`ON DELETE CASCADE` works) and `INSERT ... RETURNING` answers through `get`, on every provider.
+*
+* The transaction cases are the contract the SQL facade documents (and its SQLite tests check): other calls and transactions wait for
+* an active transaction, a rejected callback rolls back and rejects with its own error, and a handle is dead once its transaction settles.
+*/
+/** A promise and the function that settles it, for holding a transaction open. */
+function gate() {
+	let open;
+	return {
+		promise: new Promise((resolve) => {
+			open = resolve;
+		}),
+		open
+	};
+}
+function describeDbConformance(provider, open) {
+	describe(`db conformance: ${provider}`, () => {
+		const opened = [];
+		const fresh = async () => {
+			const subject = await open();
+			opened.push(subject);
+			return subject.db;
+		};
+		afterEach(async () => {
+			await Promise.all(opened.splice(0).map((subject) => subject.close()));
+		});
+		it("round-trips null, integers, bigints in the safe range, reals, text and bytes", async () => {
+			const db = await fresh();
+			await db.exec("CREATE TABLE value_probe (n INTEGER, i INTEGER, b BIGINT, r DOUBLE PRECISION, t TEXT, x BYTEA)");
+			const bytes = new Uint8Array([
+				0,
+				1,
+				254,
+				255
+			]);
+			await db.run("INSERT INTO value_probe (n, i, b, r, t, x) VALUES (?, ?, ?, ?, ?, ?)", null, 42, 9007199254740991n, 1.5, "café ✓", bytes);
+			const row = await db.get("SELECT n, i, b, r, t, x FROM value_probe");
+			expect(row).toEqual({
+				n: null,
+				i: 42,
+				b: 9007199254740991,
+				r: 1.5,
+				t: "café ✓",
+				x: bytes
+			});
+			expect(row?.x).toBeInstanceOf(Uint8Array);
+		});
+		it("answers get with undefined and all with [] when nothing matches", async () => {
+			const db = await fresh();
+			await db.exec("CREATE TABLE empty_probe (value INTEGER)");
+			expect(await db.get("SELECT value FROM empty_probe WHERE value = ?", 1)).toBeUndefined();
+			expect(await db.all("SELECT value FROM empty_probe")).toEqual([]);
+		});
+		it("reports how many rows run changed", async () => {
+			const db = await fresh();
+			await db.exec("CREATE TABLE change_probe (value INTEGER)");
+			expect(await db.run("INSERT INTO change_probe (value) VALUES (?), (?), (?)", 1, 2, 3)).toEqual({ changes: 3 });
+			expect(await db.run("UPDATE change_probe SET value = value + 10 WHERE value < ?", 3)).toEqual({ changes: 2 });
+			expect(await db.run("DELETE FROM change_probe WHERE value = ?", 99)).toEqual({ changes: 0 });
+		});
+		it("runs several statements in one exec", async () => {
+			const db = await fresh();
+			await db.exec("CREATE TABLE multi_probe (value INTEGER); INSERT INTO multi_probe (value) VALUES (1); INSERT INTO multi_probe (value) VALUES (2);");
+			expect(await db.all("SELECT value FROM multi_probe ORDER BY value")).toEqual([{ value: 1 }, { value: 2 }]);
+		});
+		it("enforces foreign keys: ON DELETE CASCADE removes the children, and an orphan insert is refused", async () => {
+			const db = await fresh();
+			await db.exec("CREATE TABLE fk_parent (id INTEGER PRIMARY KEY); CREATE TABLE fk_child (id INTEGER PRIMARY KEY, parent INTEGER NOT NULL REFERENCES fk_parent (id) ON DELETE CASCADE)");
+			await db.run("INSERT INTO fk_parent (id) VALUES (?), (?)", 1, 2);
+			await db.run("INSERT INTO fk_child (id, parent) VALUES (?, ?), (?, ?), (?, ?)", 10, 1, 11, 1, 20, 2);
+			expect(await db.run("DELETE FROM fk_parent WHERE id = ?", 1)).toEqual({ changes: 1 });
+			expect(await db.all("SELECT id FROM fk_child ORDER BY id")).toEqual([{ id: 20 }]);
+			await expect(db.run("INSERT INTO fk_child (id, parent) VALUES (?, ?)", 30, 99)).rejects.toThrow();
+			expect(await db.all("SELECT id FROM fk_child ORDER BY id")).toEqual([{ id: 20 }]);
+		});
+		it("returns the inserted row through get with INSERT ... RETURNING, inside a transaction too", async () => {
+			const db = await fresh();
+			await db.exec("CREATE TABLE returning_probe (id INTEGER PRIMARY KEY, body TEXT NOT NULL)");
+			expect(await db.get("INSERT INTO returning_probe (id, body) VALUES (?, ?) RETURNING id, body", 1, "first")).toEqual({
+				id: 1,
+				body: "first"
+			});
+			expect(await db.transaction((tx) => tx.get("INSERT INTO returning_probe (id, body) VALUES (?, ?) RETURNING id", 2, "second"))).toEqual({ id: 2 });
+			expect(await db.all("SELECT body FROM returning_probe ORDER BY id")).toEqual([{ body: "first" }, { body: "second" }]);
+		});
+		it("binds only the ? outside string literals, quoted identifiers and comments", async () => {
+			const db = await fresh();
+			expect(await db.get("SELECT '?' AS q, CAST(? AS INTEGER) AS v, 'it''s ?' AS r", 7)).toEqual({
+				q: "?",
+				v: 7,
+				r: "it's ?"
+			});
+			expect(await db.get("SELECT CAST(? AS INTEGER) AS v /* not ? a binding */, CAST(? AS INTEGER) AS w -- nor ?\n", 1, 2)).toEqual({
+				v: 1,
+				w: 2
+			});
+			await db.exec("CREATE TABLE \"odd?name\" (\"col?\" INTEGER, body TEXT)");
+			await db.run("INSERT INTO \"odd?name\" (\"col?\", body) VALUES (?, 'what?')", 3);
+			expect(await db.all("SELECT \"col?\" AS c, body FROM \"odd?name\" WHERE \"col?\" = ?", 3)).toEqual([{
+				c: 3,
+				body: "what?"
+			}]);
+		});
+		it("commits work done through the transaction handle and resolves the callback value", async () => {
+			const db = await fresh();
+			expect(await db.transaction(async (tx) => {
+				await tx.exec("CREATE TABLE commit_probe (value INTEGER)");
+				await tx.run("INSERT INTO commit_probe (value) VALUES (?)", 1);
+				return "committed";
+			})).toBe("committed");
+			expect(await db.all("SELECT value FROM commit_probe")).toEqual([{ value: 1 }]);
+		});
+		it("rolls back when the callback rejects, and rejects with that same error", async () => {
+			const db = await fresh();
+			await db.exec("CREATE TABLE rollback_probe (value INTEGER)");
+			const failure = /* @__PURE__ */ new Error("roll back");
+			await expect(db.transaction(async (tx) => {
+				await tx.run("INSERT INTO rollback_probe (value) VALUES (?)", 1);
+				throw failure;
+			})).rejects.toBe(failure);
+			expect(await db.all("SELECT value FROM rollback_probe")).toEqual([]);
+		});
+		it("makes other calls and transactions wait for an active transaction, then runs them in call order", async () => {
+			const db = await fresh();
+			await db.exec("CREATE TABLE queue_probe (value INTEGER)");
+			const started = gate();
+			const release = gate();
+			const first = db.transaction(async (tx) => {
+				await tx.run("INSERT INTO queue_probe (value) VALUES (?)", 1);
+				started.open();
+				await release.promise;
+			});
+			await started.promise;
+			const settled = [];
+			const write = db.run("INSERT INTO queue_probe (value) VALUES (?)", 2).then(() => {
+				settled.push("write");
+			});
+			const second = db.transaction(async (tx) => {
+				await tx.run("INSERT INTO queue_probe (value) VALUES (?)", 3);
+			}).then(() => {
+				settled.push("second");
+			});
+			const read = db.all("SELECT value FROM queue_probe ORDER BY value").then((rows) => {
+				settled.push("read");
+				return rows;
+			});
+			await new Promise((resolve) => setTimeout(resolve, 20));
+			expect(settled).toEqual([]);
+			release.open();
+			await Promise.all([
+				first,
+				write,
+				second
+			]);
+			expect(await read).toEqual([
+				{ value: 1 },
+				{ value: 2 },
+				{ value: 3 }
+			]);
+			expect(settled).toEqual([
+				"write",
+				"second",
+				"read"
+			]);
+		});
+		it("keeps a rolled-back transaction from leaking into calls made while it ran", async () => {
+			const db = await fresh();
+			await db.exec("CREATE TABLE isolation_probe (value INTEGER)");
+			const transaction = db.transaction(async (tx) => {
+				await tx.run("INSERT INTO isolation_probe (value) VALUES (?)", 1);
+				await Promise.resolve();
+				throw new Error("roll back");
+			});
+			const before = db.all("SELECT value FROM isolation_probe");
+			const write = db.run("INSERT INTO isolation_probe (value) VALUES (?)", 2);
+			const after = db.all("SELECT value FROM isolation_probe");
+			await expect(transaction).rejects.toThrow("roll back");
+			await write;
+			expect(await before).toEqual([]);
+			expect(await after).toEqual([{ value: 2 }]);
+		});
+		it("rejects a transaction handle used after its transaction settles", async () => {
+			const db = await fresh();
+			await db.exec("CREATE TABLE stale_probe (value INTEGER)");
+			let handle;
+			await db.transaction(async (tx) => {
+				handle = tx;
+				await tx.run("INSERT INTO stale_probe (value) VALUES (?)", 1);
+			});
+			await expect(handle.run("INSERT INTO stale_probe (value) VALUES (?)", 2)).rejects.toThrow();
+			await expect(handle.get("SELECT value FROM stale_probe")).rejects.toThrow();
+			expect(await db.all("SELECT value FROM stale_probe")).toEqual([{ value: 1 }]);
+		});
+		it("applies migrations once and in order, and refuses a schema newer than the code", async () => {
+			const db = await fresh();
+			const first = [{
+				version: 1,
+				statements: ["CREATE TABLE notes (body TEXT)", "INSERT INTO notes (body) VALUES ('kept')"]
+			}];
+			await applyMigrations(db, first, { table: MIGRATIONS_TABLE });
+			await applyMigrations(db, first, { table: MIGRATIONS_TABLE });
+			await applyMigrations(db, [...first, {
+				version: 2,
+				statements: ["ALTER TABLE notes ADD COLUMN title TEXT"]
+			}], { table: MIGRATIONS_TABLE });
+			expect(await db.all("SELECT body, title FROM notes")).toEqual([{
+				body: "kept",
+				title: null
+			}]);
+			expect(await db.get(`SELECT version FROM ${MIGRATIONS_TABLE}`)).toEqual({ version: 2 });
+			await expect(applyMigrations(db, first, { table: MIGRATIONS_TABLE })).rejects.toThrow("Schema version 2 is newer than supported version 1");
+		});
+		it("rolls every pending migration back together when one fails", async () => {
+			const db = await fresh();
+			const failing = [{
+				version: 1,
+				statements: ["CREATE TABLE migration_first (value TEXT)", "INSERT INTO migration_first (value) VALUES ('retained')"]
+			}, {
+				version: 2,
+				statements: ["CREATE TABLE migration_second (value TEXT)", "THIS IS NOT SQL"]
+			}];
+			await expect(applyMigrations(db, failing, { table: MIGRATIONS_TABLE })).rejects.toThrow();
+			await expect(db.all("SELECT value FROM migration_first")).rejects.toThrow();
+			const version = await db.get(`SELECT version FROM ${MIGRATIONS_TABLE}`).catch(() => void 0);
+			expect(version === void 0 || Number(version.version) === 0).toBe(true);
+			await applyMigrations(db, [failing[0], {
+				version: 2,
+				statements: ["CREATE TABLE migration_second (value TEXT)"]
+			}], { table: MIGRATIONS_TABLE });
+			expect(await db.get(`SELECT version FROM ${MIGRATIONS_TABLE}`)).toEqual({ version: 2 });
+			expect(await db.all("SELECT value FROM migration_first")).toEqual([{ value: "retained" }]);
+		});
+		it("applies an app's numbered migration files", async () => {
+			const db = await fresh();
+			const folder = await mkdtemp(join(tmpdir(), "acryl-db-migrations-"));
+			try {
+				await writeFile(join(folder, "001-notes.sql"), "CREATE TABLE notes (id INTEGER PRIMARY KEY, body TEXT NOT NULL);\nINSERT INTO notes (id, body) VALUES (1, 'first');\n");
+				await writeFile(join(folder, "002-tags.sql"), "CREATE TABLE tags (note INTEGER NOT NULL, tag TEXT NOT NULL);\n");
+				await applyMigrations(db, await readMigrationFiles(folder), { table: MIGRATIONS_TABLE });
+				await db.run("INSERT INTO tags (note, tag) VALUES (?, ?)", 1, "todo");
+				expect(await db.all("SELECT body, tag FROM notes JOIN tags ON tags.note = notes.id")).toEqual([{
+					body: "first",
+					tag: "todo"
+				}]);
+				expect(await db.get(`SELECT version FROM ${MIGRATIONS_TABLE}`)).toEqual({ version: 2 });
+			} finally {
+				await rm(folder, {
+					recursive: true,
+					force: true
+				});
+			}
+		});
+	});
+}
+//#endregion
+export { describeDbConformance };

package/lib/db/sqlite.d.ts

@@ -1,4 +1,4 @@
-import { c as DbExecutor, l as SqlValue, s as Db } from "../index-D4FAsBZu.js";
+import { n as DbExecutor, r as SqlValue, t as Db } from "../database-DBHdwefi.js";
 
 //#region ../../plugins/acryl-db-sqlite/src/open.d.ts
 interface OpenDbOptions {