acrylblends 1.0.3 → 1.0.5

package/lib/mount-QkK_3NtJ.js

@@ -0,0 +1,67 @@
+import { i as routePath } from "./route-D8m-a2I1.js";
+//#region ../../plugins/acryl-router/src/core/middleware/mount/index.ts
+const defaultReplaceRequest = (c) => {
+	const pathPrefix = routePath(c).replace(/\/\*$/, "");
+	const url = new URL(c.req.raw.url);
+	url.pathname = c.req.path.slice(pathPrefix.length) || "/";
+	return new Request(url, c.req.raw);
+};
+const defaultGetOptions = (c) => {
+	let executionContext = void 0;
+	try {
+		executionContext = c.executionCtx;
+	} catch {}
+	return [c.env, executionContext];
+};
+/**
+* `mount()` allows you to mount applications built with other frameworks into your Acryl application.
+*
+*
+* @param {Function} applicationHandler - other Request Handler
+* @param {MountOptions} [options] - options of `mount()`
+* @returns {MiddlewareHandler} handler to register with `app.all()`
+*
+* @example
+* ```ts
+* import { Router as IttyRouter } from 'itty-router'
+* import { Acryl } from 'acrylblends'
+* import { mount } from 'acrylblends/mount'
+* // Create itty-router application
+* const ittyRouter = IttyRouter()
+* // GET /itty-router/hello
+* ittyRouter.get('/hello', () => new Response('Hello from itty-router'))
+*
+* const app = new Acryl()
+* app.all('/itty-router/*', mount(ittyRouter.handle))
+* ```
+*
+* @example
+* ```ts
+* const app = new Acryl()
+* // Send the request to another application without modification.
+* app.all('/app/*', mount(anotherApp, {
+*   replaceRequest: (req) => req,
+* }))
+* ```
+*/
+const mount = (applicationHandler, options) => {
+	let replaceRequest;
+	let optionHandler;
+	if (options) if (typeof options === "function") optionHandler = options;
+	else {
+		optionHandler = options.optionHandler;
+		if (options.replaceRequest === false) replaceRequest = (request) => request;
+		else replaceRequest = options.replaceRequest;
+	}
+	const getOptions = optionHandler ? (c) => {
+		const options = optionHandler(c);
+		return Array.isArray(options) ? options : [options];
+	} : defaultGetOptions;
+	return async (c, next) => {
+		const res = await applicationHandler(replaceRequest ? replaceRequest(c.req.raw) : defaultReplaceRequest(c), ...getOptions(c));
+		if (res) return res;
+		await next();
+	};
+};
+//#endregion
+export { mount as t };

package/lib/mount.js

@@ -1,67 +1,2 @@
-import { routePath } from "./route.js";
-//#region ../../plugins/acryl-router/src/core/middleware/mount/index.ts
-const defaultReplaceRequest = (c) => {
-	const pathPrefix = routePath(c).replace(/\/\*$/, "");
-	const url = new URL(c.req.raw.url);
-	url.pathname = c.req.path.slice(pathPrefix.length) || "/";
-	return new Request(url, c.req.raw);
-};
-const defaultGetOptions = (c) => {
-	let executionContext = void 0;
-	try {
-		executionContext = c.executionCtx;
-	} catch {}
-	return [c.env, executionContext];
-};
-/**
-* `mount()` allows you to mount applications built with other frameworks into your Acryl application.
-*
-*
-* @param {Function} applicationHandler - other Request Handler
-* @param {MountOptions} [options] - options of `mount()`
-* @returns {MiddlewareHandler} handler to register with `app.all()`
-*
-* @example
-* ```ts
-* import { Router as IttyRouter } from 'itty-router'
-* import { Acryl } from 'acrylblends'
-* import { mount } from 'acrylblends/mount'
-* // Create itty-router application
-* const ittyRouter = IttyRouter()
-* // GET /itty-router/hello
-* ittyRouter.get('/hello', () => new Response('Hello from itty-router'))
-*
-* const app = new Acryl()
-* app.all('/itty-router/*', mount(ittyRouter.handle))
-* ```
-*
-* @example
-* ```ts
-* const app = new Acryl()
-* // Send the request to another application without modification.
-* app.all('/app/*', mount(anotherApp, {
-*   replaceRequest: (req) => req,
-* }))
-* ```
-*/
-const mount = (applicationHandler, options) => {
-	let replaceRequest;
-	let optionHandler;
-	if (options) if (typeof options === "function") optionHandler = options;
-	else {
-		optionHandler = options.optionHandler;
-		if (options.replaceRequest === false) replaceRequest = (request) => request;
-		else replaceRequest = options.replaceRequest;
-	}
-	const getOptions = optionHandler ? (c) => {
-		const options = optionHandler(c);
-		return Array.isArray(options) ? options : [options];
-	} : defaultGetOptions;
-	return async (c, next) => {
-		const res = await applicationHandler(replaceRequest ? replaceRequest(c.req.raw) : defaultReplaceRequest(c), ...getOptions(c));
-		if (res) return res;
-		await next();
-	};
-};
-//#endregion
+import { t as mount } from "./mount-QkK_3NtJ.js";
 export { mount };

package/lib/node-server/conninfo.d.ts

@@ -1,11 +1,2 @@
-import { r as GetConnInfo } from "../types-Dv_nV2cv.js";
-
-//#region ../../plugins/acryl-node-server/src/adapter/conninfo.d.ts
-/**
- * ConnInfo Helper for Node.js
- * @param c Context
- * @returns ConnInfo
- */
-declare const getConnInfo: GetConnInfo;
-//#endregion
+import { t as getConnInfo } from "../conninfo-BCROmdnf.js";
 export { getConnInfo };

package/lib/node-server/conninfo.js

@@ -1,19 +1,2 @@
-//#region ../../plugins/acryl-node-server/src/adapter/conninfo.ts
-/**
-* ConnInfo Helper for Node.js
-* @param c Context
-* @returns ConnInfo
-*/
-const getConnInfo = (c) => {
-	const bindings = c.env.server ? c.env.server : c.env;
-	const address = bindings.incoming.socket.remoteAddress;
-	const port = bindings.incoming.socket.remotePort;
-	const family = bindings.incoming.socket.remoteFamily;
-	return { remote: {
-		address,
-		port,
-		addressType: family === "IPv4" ? "IPv4" : family === "IPv6" ? "IPv6" : void 0
-	} };
-};
-//#endregion
+import { t as getConnInfo } from "../conninfo-CWJwieh4.js";
 export { getConnInfo };

package/lib/node-server/register.js

@@ -1,7 +1,7 @@
 import { n as compileModule } from "../transpile-QUK9b3eG.js";
 import { registerHooks } from "node:module";
-import { readFileSync } from "node:fs";
-import { fileURLToPath } from "node:url";
+import { existsSync, readFileSync } from "node:fs";
+import { fileURLToPath, pathToFileURL } from "node:url";
 //#region ../../plugins/acryl-node-server/src/register.ts
 /**
 * JSX files on Node: `node --import acrylblends/node-server/register src/index.ts`. Node strips TypeScript's types but does not compile JSX, so a
@@ -27,5 +27,28 @@ registerHooks({ load(url, context, nextLoad) {
 		shortCircuit: true
 	};
 } });
+/**
+* The framework's names for a file of the app: in an app the framework plugins are source under `plugins/`, not packages, so `acrylblends`, `acrylblends/body-limit` or `acryl-router`
+* have nowhere to resolve from. A plugin installed while the app runs gets them from the extensions plugin; a plugin that is a ROW of `blend.yaml` is imported by `src/app.ts` before
+* any of that exists, so the same names are resolved here, in the preload every `dev`, `start` and `test` script runs. Only a name that Node cannot resolve itself, only for the
+* app's own files (never for something in `node_modules`), and only in an app that has the framework as vendored source: the published package resolves its own names.
+*/
+const plugins = new URL("../../", import.meta.url);
+const appRoot = new URL("../", plugins).href;
+const resolver = new URL("extensions/resolve.ts", plugins);
+if (existsSync(fileURLToPath(new URL("acryl-router/src/index.ts", plugins))) && existsSync(fileURLToPath(resolver))) {
+	const { routerAliases } = await import(resolver.href);
+	const aliases = routerAliases();
+	registerHooks({ resolve(specifier, context, nextResolve) {
+		try {
+			return nextResolve(specifier, context);
+		} catch (error) {
+			const alias = aliases[specifier];
+			const parent = context.parentURL;
+			if (alias !== void 0 && parent?.startsWith(appRoot) && !parent.includes("/node_modules/")) return nextResolve(pathToFileURL(alias).href, context);
+			throw error;
+		}
+	} });
+}
 //#endregion
 export {};

package/lib/node-server/serve-static.d.ts

@@ -1,18 +1,2 @@
-import { L as MiddlewareHandler, t as Context, v as Env } from "../context-DS3fYyG-.js";
-//#region ../../plugins/acryl-node-server/src/adapter/serve-static.d.ts
-type ServeStaticOptions<E extends Env = Env> = {
-  /**
-   * Root path. Relative path is based on current working directory from which the app was started.
-   */
-  root?: string;
-  path?: string;
-  index?: string;
-  precompressed?: boolean; /** Allow percent signs in the routed request path. Defaults to false. */
-  allowPercentInPath?: boolean;
-  rewriteRequestPath?: (path: string, c: Context<E>) => string;
-  onFound?: (path: string, c: Context<E>) => void | Promise<void>;
-  onNotFound?: (path: string, c: Context<E>) => void | Promise<void>;
-};
-declare const serveStatic: <E extends Env = any>(options?: ServeStaticOptions<E>) => MiddlewareHandler<E>;
-//#endregion
+import { n as serveStatic, t as ServeStaticOptions } from "../serve-static-B7sqnftW.js";
 export { ServeStaticOptions, serveStatic };

package/lib/node-server/serve-static.js

@@ -1,2 +1,2 @@
-import { t as serveStatic } from "../serve-static-3uo_9rjF.js";
+import { t as serveStatic } from "../serve-static-C1Nkj_xB.js";
 export { serveStatic };

package/lib/node-server.d.ts

@@ -1,7 +1,7 @@
 import { t as Acryl } from "./app-D8riatvv.js";
 import { a as Owner, c as UpgradeHubOptions, d as upgradeWebSocket, f as WebSocketData, i as testWebSocket, l as UpgradeRouter, m as WebSocketServerLike, n as TestWebSocketOptions, o as UpgradeEmitter, p as WebSocketLike, r as TestWebSocketResult, s as UpgradeHub, t as TestSocket, u as RequestError } from "./test-websocket-DyeS50Tr.js";
-import { ServeStaticOptions, serveStatic } from "./node-server/serve-static.js";
-import { getConnInfo } from "./node-server/conninfo.js";
+import { n as serveStatic, t as ServeStaticOptions } from "./serve-static-B7sqnftW.js";
+import { t as getConnInfo } from "./conninfo-BCROmdnf.js";
 import { AddressInfo } from "node:net";
 import { IncomingMessage, Server, ServerOptions, ServerResponse, createServer } from "node:http";
 import { Http2SecureServer, Http2Server, Http2ServerRequest, Http2ServerResponse, SecureServerOptions, ServerOptions as ServerOptions$1, createSecureServer, createServer as createServer$1 } from "node:http2";

package/lib/node-server.js

@@ -1,5 +1,5 @@
-import { a as serve, i as createAdaptorServer, l as RequestError, n as UpgradeEmitter, o as upgradeWebSocket, r as UpgradeHub, s as getRequestListener, t as testWebSocket } from "./test-websocket-D8WWqE5G.js";
-import { t as serveStatic } from "./serve-static-3uo_9rjF.js";
-import { getConnInfo } from "./node-server/conninfo.js";
-import { n as clientModules, t as buildClientModules } from "./client-modules-CLvWOjbd.js";
+import { a as serve, i as createAdaptorServer, l as RequestError, n as UpgradeEmitter, o as upgradeWebSocket, r as UpgradeHub, s as getRequestListener, t as testWebSocket } from "./test-websocket-BLeEvybj.js";
+import { t as serveStatic } from "./serve-static-C1Nkj_xB.js";
+import { t as getConnInfo } from "./conninfo-CWJwieh4.js";
+import { n as clientModules, t as buildClientModules } from "./client-modules-drj4mjhj.js";
 export { RequestError, UpgradeEmitter, UpgradeHub, buildClientModules, clientModules, createAdaptorServer, getConnInfo, getRequestListener, serve, serveStatic, testWebSocket, upgradeWebSocket };

package/lib/open-BqK4D2Wn.d.ts

@@ -0,0 +1,11 @@
+import { r as KvOpened } from "./kv-9f-AlRKN.js";
+
+//#region ../../plugins/acryl-kv-json/src/open.d.ts
+interface OpenKvOptions {
+  /** The JSON file; its folder is created if missing. */
+  readonly path: string;
+}
+/** Open (and create, when missing) a JSON-file store. @throws when the file exists and is not a readable kv file. */
+declare function openKv(options: OpenKvOptions): Promise<KvOpened>;
+//#endregion
+export { openKv as n, OpenKvOptions as t };

package/lib/open-But9E2rL.js

@@ -0,0 +1,57 @@
+import { a as compareKeys, c as runChange, i as codePoints, o as decodeValue, r as checkKey, s as encodeValue } from "./src-DRFVEQQb.js";
+//#region ../../plugins/acryl-kv-db/src/open.ts
+const IDENTIFIER = /^[a-z_][a-z0-9_]*$/u;
+/** The `kv` port over a `db`. It does not own the database: whoever opened it closes it, and calls after that reject. */
+function kvOnDb(db, options = {}) {
+	const table = options.table ?? "kv";
+	if (!IDENTIFIER.test(table)) throw new TypeError(`acryl-kv-db: the table name must be a plain lower case SQL identifier, got ${JSON.stringify(table)}`);
+	let ready;
+	const ensure = () => {
+		ready ??= db.exec(`CREATE TABLE IF NOT EXISTS ${table} (key TEXT PRIMARY KEY, value TEXT NOT NULL)`).catch((error) => {
+			ready = void 0;
+			throw error;
+		});
+		return ready;
+	};
+	/**
+	* Run a statement after the table exists. The table's statement and this one are both handed to the database at once (its queue keeps
+	* their order), so a `close()` called right after a write cannot slip between them and leave the write on a closed database.
+	*/
+	const after = async (work) => {
+		const created = ensure();
+		const result = work();
+		const [, value] = await Promise.all([created, result]);
+		return value;
+	};
+	const upsert = `INSERT INTO ${table} (key, value) VALUES (?, ?) ON CONFLICT (key) DO UPDATE SET value = excluded.value`;
+	return {
+		async get(key) {
+			checkKey(key);
+			const row = await after(() => db.get(`SELECT value FROM ${table} WHERE key = ?`, key));
+			return row === void 0 ? void 0 : decodeValue(row.value);
+		},
+		async set(key, value) {
+			checkKey(key);
+			const text = encodeValue(value);
+			await after(() => db.run(upsert, key, text));
+		},
+		async update(key, change) {
+			checkKey(key);
+			return after(() => db.transaction(async (tx) => {
+				const row = await tx.get(`SELECT value FROM ${table} WHERE key = ?`, key);
+				const text = encodeValue(runChange(change, row === void 0 ? void 0 : decodeValue(row.value)));
+				await tx.run(upsert, key, text);
+				return decodeValue(text);
+			}));
+		},
+		async delete(key) {
+			checkKey(key);
+			await after(() => db.run(`DELETE FROM ${table} WHERE key = ?`, key));
+		},
+		async list(prefix = "") {
+			return (await after(() => prefix === "" ? db.all(`SELECT key FROM ${table}`) : db.all(`SELECT key FROM ${table} WHERE substr(key, 1, ?) = ?`, codePoints(prefix), prefix))).map((row) => row.key).sort(compareKeys);
+		}
+	};
+}
+//#endregion
+export { kvOnDb as t };

package/lib/open-CULVJgOc.d.ts

@@ -0,0 +1,12 @@
+import { t as Db } from "./database-DBHdwefi.js";
+import { n as Kv } from "./kv-9f-AlRKN.js";
+
+//#region ../../plugins/acryl-kv-db/src/open.d.ts
+interface KvOnDbOptions {
+  /** The table that holds the documents. Defaults to `kv`; a plain SQL identifier. */
+  readonly table?: string;
+}
+/** The `kv` port over a `db`. It does not own the database: whoever opened it closes it, and calls after that reject. */
+declare function kvOnDb(db: Db, options?: KvOnDbOptions): Kv;
+//#endregion
+export { kvOnDb as n, KvOnDbOptions as t };

package/lib/open-Dp4sxspc.js

@@ -0,0 +1,224 @@
+import { a as compareKeys, c as runChange, o as decodeValue, r as checkKey, s as encodeValue } from "./src-DRFVEQQb.js";
+import { mkdir, open, readFile, readdir, rename, rm } from "node:fs/promises";
+import { basename, dirname, join, resolve } from "node:path";
+//#region ../../plugins/acryl-kv-json/src/open.ts
+/**
+* The plain way to open the JSON-file provider, for code without Cordis (an acrylblends app): `openKv({ path })` reads one JSON file into
+* memory and resolves the `kv` port with the function that closes it. The Cordis plugin is a thin wrapper over this, so both run one code
+* path. This entry imports nothing from Cordis.
+*
+* Every write persists the whole map: serialize to a temporary file in the same folder, flush it, rename it over the file, and flush the
+* folder where the platform allows. The call resolves after the rename, so a crash leaves the old file or the new one, never half of one.
+* Writes are grouped: the calls made in one turn of the event loop, and those that queue while a file write is in flight, are applied in
+* call order and persisted together by one write, so a burst of calls costs one flush and one rename, not one each (on Windows each costs
+* tens of milliseconds). One process owns the
+* file: two writers would overwrite each other.
+*/
+/** The file's own format version, for a later change of layout. */
+const FORMAT = 1;
+/** Stray temporary files from a crash end in `.tmp` and start with the file's name. */
+const tempPrefix = (file) => `${basename(file)}.`;
+/** The file content for a map of key to JSON text, keys in code point order, so the same data is the same bytes. */
+function serialize(entries) {
+	const body = [...entries.keys()].sort(compareKeys).map((key) => `${JSON.stringify(key)}:${entries.get(key)}`).join(",");
+	return `{"version":${FORMAT},"entries":{${body}}}\n`;
+}
+function unreadable(file, reason) {
+	return /* @__PURE__ */ new Error(`acryl-kv-json: ${file} is not a readable kv file (${reason}); it was not changed`);
+}
+/** The entries of a file, or none when it does not exist. A file that exists and does not parse is an error: it is never started over. */
+async function load(file) {
+	let text;
+	try {
+		text = await readFile(file, "utf8");
+	} catch (error) {
+		if (error.code === "ENOENT") return /* @__PURE__ */ new Map();
+		throw error;
+	}
+	let parsed;
+	try {
+		parsed = JSON.parse(text);
+	} catch (error) {
+		throw unreadable(file, error.message);
+	}
+	if (typeof parsed !== "object" || parsed === null || parsed.version !== FORMAT) throw unreadable(file, "not a version 1 kv file");
+	const entries = parsed.entries;
+	if (typeof entries !== "object" || entries === null || Array.isArray(entries)) throw unreadable(file, "no entries object");
+	return new Map(Object.entries(entries).map(([key, value]) => [key, JSON.stringify(value)]));
+}
+/** Remove the temporary files an earlier crash left beside the file. */
+async function removeStrays(file) {
+	const prefix = tempPrefix(file);
+	for (const name of await readdir(dirname(file))) if (name.startsWith(prefix) && name.endsWith(".tmp")) await rm(join(dirname(file), name), { force: true });
+}
+const RENAME_RETRIES = 8;
+/** Rename over the target. Windows refuses while a scanner or an indexer holds the target for a moment, so it is retried briefly. */
+async function replace(from, to) {
+	for (let attempt = 0;; attempt += 1) try {
+		await rename(from, to);
+		return;
+	} catch (error) {
+		const code = error.code;
+		if (attempt >= RENAME_RETRIES || code !== "EPERM" && code !== "EBUSY" && code !== "EACCES") throw error;
+		await new Promise((resolveWait) => setTimeout(resolveWait, 10 * (attempt + 1)));
+	}
+}
+/** Flush the folder entry of a renamed file (POSIX); Windows cannot open a folder, and a filesystem that refuses is no worse than before. */
+async function flushFolder(folder) {
+	if (process.platform === "win32") return;
+	try {
+		const handle = await open(folder, "r");
+		try {
+			await handle.sync();
+		} finally {
+			await handle.close();
+		}
+	} catch {}
+}
+/** Open (and create, when missing) a JSON-file store. @throws when the file exists and is not a readable kv file. */
+async function openKv(options) {
+	const file = resolve(options.path);
+	await mkdir(dirname(file), { recursive: true });
+	await removeStrays(file);
+	let state = await load(file);
+	let closed = false;
+	let sequence = 0;
+	/** Calls waiting for the next file write, in call order. */
+	let queue = [];
+	/** Whether the loop that writes the queue runs; cleared by the loop itself, so a call queued after it ends starts a new one. */
+	let draining = false;
+	/** The latest loop, for `close` to wait on. */
+	let drained = Promise.resolve();
+	const guard = () => {
+		if (closed) throw new Error(`acryl-kv-json: ${file} is closed`);
+	};
+	/** Persist a map: the file is the old one or this one, never between. */
+	const persist = async (next) => {
+		sequence += 1;
+		const temp = join(dirname(file), `${tempPrefix(file)}${process.pid}.${sequence}.tmp`);
+		try {
+			const handle = await open(temp, "w");
+			try {
+				await handle.writeFile(serialize(next), "utf8");
+				await handle.sync();
+			} finally {
+				await handle.close();
+			}
+			await replace(temp, file);
+		} catch (error) {
+			await rm(temp, { force: true });
+			throw error;
+		}
+		await flushFolder(dirname(file));
+	};
+	/**
+	* Write the queue until it is empty. Each round takes every call queued so far and applies them in order to one copy of the state. A call
+	* whose change throws rejects with its error and changes nothing, and the others in the round still apply. The copy becomes the state
+	* only once it is on disk. A failed file write rejects every call in its round and leaves the state as it was.
+	*/
+	const drain = async () => {
+		try {
+			await Promise.resolve();
+			await rounds();
+		} finally {
+			draining = false;
+		}
+	};
+	const rounds = async () => {
+		while (queue.length > 0) {
+			const round = queue;
+			queue = [];
+			const draft = new Map(state);
+			const applied = [];
+			for (const call of round) {
+				let change;
+				try {
+					change = call.change((key) => draft.get(key));
+				} catch (error) {
+					call.reject(error);
+					continue;
+				}
+				if (change.text === void 0) draft.delete(change.key);
+				else draft.set(change.key, change.text);
+				applied.push({
+					call,
+					result: change.result
+				});
+			}
+			if (applied.length === 0) continue;
+			try {
+				await persist(draft);
+			} catch (error) {
+				for (const { call } of applied) call.reject(error);
+				continue;
+			}
+			state = draft;
+			for (const { call, result } of applied) call.resolve(result);
+		}
+	};
+	/** Queue one change behind every earlier call; it resolves once a file write that contains it is on disk. */
+	const write = (change) => {
+		guard();
+		const done = new Promise((resolveCall, rejectCall) => {
+			queue.push({
+				change,
+				resolve: resolveCall,
+				reject: rejectCall
+			});
+		});
+		if (!draining) {
+			draining = true;
+			drained = drain();
+		}
+		return done;
+	};
+	return {
+		kv: {
+			async get(key) {
+				guard();
+				checkKey(key);
+				const text = state.get(key);
+				return text === void 0 ? void 0 : decodeValue(text);
+			},
+			async set(key, value) {
+				checkKey(key);
+				const text = encodeValue(value);
+				await write(() => ({
+					key,
+					text,
+					result: void 0
+				}));
+			},
+			async update(key, change) {
+				checkKey(key);
+				return write((read) => {
+					const text = read(key);
+					const encoded = encodeValue(runChange(change, text === void 0 ? void 0 : decodeValue(text)));
+					return {
+						key,
+						text: encoded,
+						result: decodeValue(encoded)
+					};
+				});
+			},
+			async delete(key) {
+				checkKey(key);
+				await write(() => ({
+					key,
+					text: void 0,
+					result: void 0
+				}));
+			},
+			async list(prefix = "") {
+				guard();
+				return [...state.keys()].filter((key) => key.startsWith(prefix)).sort(compareKeys);
+			}
+		},
+		close: async () => {
+			closed = true;
+			await drained;
+		}
+	};
+}
+//#endregion
+export { openKv as t };

package/lib/open-T7kgbO2O.d.ts

@@ -0,0 +1,27 @@
+import { t as Db } from "./database-DBHdwefi.js";
+
+//#region ../../plugins/acryl-db-sqlite/src/open.d.ts
+interface OpenDbOptions {
+  /** The database file, its folder created if missing; `:memory:` for a database that lives until `close`. */
+  readonly path: string;
+  /** A folder of `NNN-name.sql` files numbered from 1, as a path or a file URL, applied in order before `openDb` resolves. */
+  readonly migrations?: string | URL;
+  /** How long SQLite waits for a competing file lock, in milliseconds. Defaults to 5000. */
+  readonly busyTimeoutMs?: number;
+  /** The WAL auto-checkpoint threshold in pages; 0 disables it. Defaults to 1000. */
+  readonly walAutoCheckpointPages?: number;
+}
+/** An open database: the port, and the one function that closes it. */
+interface OpenDb {
+  readonly db: Db;
+  /** Waits for running operations and transactions, checkpoints the WAL and releases the file. Calling it again does nothing. */
+  close(): Promise<void>;
+}
+/**
+ * Open, configure and migrate a SQLite database.
+ * @throws when the migration files are misnamed or misnumbered, or a migration fails (the file is closed, and unchanged), or the
+ *   database's schema is newer than the migrations.
+ */
+declare function openDb(options: OpenDbOptions): Promise<OpenDb>;
+//#endregion
+export { OpenDbOptions as n, openDb as r, OpenDb as t };

package/lib/{pattern-router-HZxjDGEQ.js → pattern-router-CJBecJBd.js}

@@ -1,4 +1,4 @@
-import { UnsupportedPathError } from "./router.js";
+import { a as UnsupportedPathError } from "./router-Be_o6nFu.js";
 //#region ../../plugins/acryl-router/src/core/router/pattern-router/router.ts
 const emptyParams = Object.create(null);
 var PatternRouter = class {

package/lib/powered-by-CXQNjNIX.js

@@ -0,0 +1,24 @@
+//#region ../../plugins/acryl-router/src/core/middleware/powered-by/index.ts
+/**
+* Powered By Middleware for Acryl.
+*
+* @param options - The options for the Powered By Middleware.
+* @returns {MiddlewareHandler} The middleware handler function.
+*
+* @example
+* ```ts
+* import { poweredBy } from 'acrylblends/powered-by'
+*
+* const app = new Acryl()
+*
+* app.use(poweredBy()) // With options: poweredBy({ serverName: "My Server" })
+* ```
+*/
+const poweredBy = (options) => {
+	return async function poweredBy(c, next) {
+		await next();
+		c.res.headers.set("X-Powered-By", options?.serverName ?? "Acryl");
+	};
+};
+//#endregion
+export { poweredBy as t };

package/lib/powered-by.js

@@ -1,24 +1,2 @@
-//#region ../../plugins/acryl-router/src/core/middleware/powered-by/index.ts
-/**
-* Powered By Middleware for Acryl.
-*
-* @param options - The options for the Powered By Middleware.
-* @returns {MiddlewareHandler} The middleware handler function.
-*
-* @example
-* ```ts
-* import { poweredBy } from 'acrylblends/powered-by'
-*
-* const app = new Acryl()
-*
-* app.use(poweredBy()) // With options: poweredBy({ serverName: "My Server" })
-* ```
-*/
-const poweredBy = (options) => {
-	return async function poweredBy(c, next) {
-		await next();
-		c.res.headers.set("X-Powered-By", options?.serverName ?? "Acryl");
-	};
-};
-//#endregion
+import { t as poweredBy } from "./powered-by-CXQNjNIX.js";
 export { poweredBy };