acrylblends 0.7.3 → 0.7.5

package/lib/bun.d.ts

@@ -0,0 +1,75 @@
+import { L as MiddlewareHandler, t as Context, v as Env } from "./context-DS3fYyG-.js";
+import { r as GetConnInfo } from "./types-Dv_nV2cv.js";
+import { f as FileSystemModule, m as ToSSGAdaptorInterface } from "./index-DaJtL7ci.js";
+import { a as WSEvents, n as UpgradeWebSocket } from "./index-BvFh1Gfx.js";
+import { t as ServeStaticOptions } from "./index-CseujaYI.js";
+
+//#region ../../plugins/acryl-router/src/core/adapter/bun/serve-static.d.ts
+declare const serveStatic: <E extends Env = Env>(options?: ServeStaticOptions<E>) => MiddlewareHandler;
+//#endregion
+//#region ../../plugins/acryl-router/src/core/adapter/bun/ssg.d.ts
+/**
+ * @experimental
+ * `bunFileSystemModule` is an experimental feature.
+ * The API might be changed.
+ */
+declare const bunFileSystemModule: FileSystemModule;
+/**
+ * @experimental
+ * `toSSG` is an experimental feature.
+ * The API might be changed.
+ */
+declare const toSSG: ToSSGAdaptorInterface;
+//#endregion
+//#region ../../plugins/acryl-router/src/core/adapter/bun/websocket.d.ts
+/**
+ * @internal
+ */
+interface BunServerWebSocket<T> {
+  send(data: string | ArrayBuffer | Uint8Array, compress?: boolean): void;
+  close(code?: number, reason?: string): void;
+  data: T;
+  readyState: 0 | 1 | 2 | 3;
+}
+interface BunWebSocketHandler<T> {
+  open(ws: BunServerWebSocket<T>): void;
+  close(ws: BunServerWebSocket<T>, code?: number, reason?: string): void;
+  message(ws: BunServerWebSocket<T>, message: string | {
+    buffer: ArrayBufferLike;
+  }): void;
+}
+interface CreateWebSocket<T> {
+  upgradeWebSocket: UpgradeWebSocket<T>;
+  websocket: BunWebSocketHandler<BunWebSocketData>;
+}
+interface BunWebSocketData {
+  events: WSEvents;
+  url: URL;
+  protocol: string;
+}
+declare const upgradeWebSocket: UpgradeWebSocket<any>;
+declare const websocket: BunWebSocketHandler<BunWebSocketData>;
+/**
+ * @deprecated Import `upgradeWebSocket` and `websocket` directly from `acryl-router/bun` instead.
+ * @returns A function to create a Bun WebSocket handler.
+ */
+declare const createBunWebSocket: <T>() => CreateWebSocket<T>;
+//#endregion
+//#region ../../plugins/acryl-router/src/core/adapter/bun/conninfo.d.ts
+/**
+ * Get ConnInfo with Bun
+ * @param c Context
+ * @returns ConnInfo
+ */
+declare const getConnInfo: GetConnInfo;
+//#endregion
+//#region ../../plugins/acryl-router/src/core/adapter/bun/server.d.ts
+/**
+ * Get Bun Server Object from Context
+ * @template T - The type of Bun Server
+ * @param c Context
+ * @returns Bun Server
+ */
+declare const getBunServer: <T>(c: Context) => T | undefined;
+//#endregion
+export { type BunWebSocketData, type BunWebSocketHandler, bunFileSystemModule, createBunWebSocket, getBunServer, getConnInfo, serveStatic, toSSG, upgradeWebSocket, websocket };

package/lib/bun.js

@@ -0,0 +1,134 @@
+import { t as serveStatic$1 } from "./serve-static-Cp5adzGo.js";
+import { c as toSSG$1 } from "./ssg-BwjcA-Ge.js";
+import { WSContext, createWSMessageEvent, defineWebSocketHelper } from "./ws.js";
+import { stat } from "node:fs/promises";
+import { join } from "node:path";
+//#region ../../plugins/acryl-router/src/core/adapter/bun/serve-static.ts
+const serveStatic = (options = {}) => {
+	return async function serveStatic(c, next) {
+		const getContent = async (path) => {
+			const file = Bun.file(path);
+			return await file.exists() ? file : null;
+		};
+		const isDir = async (path) => {
+			let isDir;
+			try {
+				isDir = (await stat(path)).isDirectory();
+			} catch {}
+			return isDir;
+		};
+		return serveStatic$1({
+			...options,
+			getContent,
+			join,
+			isDir
+		})(c, next);
+	};
+};
+//#endregion
+//#region ../../plugins/acryl-router/src/core/adapter/bun/ssg.ts
+/**
+* @experimental
+* `bunFileSystemModule` is an experimental feature.
+* The API might be changed.
+*/
+const bunFileSystemModule = {
+	writeFile: async (path, data) => {
+		await Bun.write(path, data);
+	},
+	mkdir: async () => {}
+};
+/**
+* @experimental
+* `toSSG` is an experimental feature.
+* The API might be changed.
+*/
+const toSSG = async (app, options) => {
+	return toSSG$1(app, bunFileSystemModule, options);
+};
+//#endregion
+//#region ../../plugins/acryl-router/src/core/adapter/bun/server.ts
+/**
+* Get Bun Server Object from Context
+* @template T - The type of Bun Server
+* @param c Context
+* @returns Bun Server
+*/
+const getBunServer = (c) => "server" in c.env ? c.env.server : c.env;
+//#endregion
+//#region ../../plugins/acryl-router/src/core/adapter/bun/websocket.ts
+/**
+* @internal
+*/
+const createWSContext = (ws) => {
+	return new WSContext({
+		send: (source, options) => {
+			ws.send(source, options?.compress);
+		},
+		raw: ws,
+		readyState: ws.readyState,
+		url: ws.data.url,
+		protocol: ws.data.protocol,
+		close(code, reason) {
+			ws.close(code, reason);
+		}
+	});
+};
+const upgradeWebSocket = defineWebSocketHelper((c, events) => {
+	const server = getBunServer(c);
+	if (!server) throw new TypeError("env has to include the 2nd argument of fetch.");
+	if (server.upgrade(c.req.raw, { data: {
+		events,
+		url: new URL(c.req.url),
+		protocol: c.req.header("sec-websocket-protocol")?.split(",")[0]?.trim() ?? ""
+	} })) return new Response(null);
+});
+const websocket = {
+	open(ws) {
+		const websocketListeners = ws.data.events;
+		if (websocketListeners.onOpen) websocketListeners.onOpen(new Event("open"), createWSContext(ws));
+	},
+	close(ws, code, reason) {
+		const websocketListeners = ws.data.events;
+		if (websocketListeners.onClose) websocketListeners.onClose(new CloseEvent("close", {
+			code,
+			reason
+		}), createWSContext(ws));
+	},
+	message(ws, message) {
+		const websocketListeners = ws.data.events;
+		if (websocketListeners.onMessage) {
+			const normalizedReceiveData = typeof message === "string" ? message : message.buffer;
+			websocketListeners.onMessage(createWSMessageEvent(normalizedReceiveData), createWSContext(ws));
+		}
+	}
+};
+/**
+* @deprecated Import `upgradeWebSocket` and `websocket` directly from `acryl-router/bun` instead.
+* @returns A function to create a Bun WebSocket handler.
+*/
+const createBunWebSocket = () => ({
+	upgradeWebSocket,
+	websocket
+});
+//#endregion
+//#region ../../plugins/acryl-router/src/core/adapter/bun/conninfo.ts
+/**
+* Get ConnInfo with Bun
+* @param c Context
+* @returns ConnInfo
+*/
+const getConnInfo = (c) => {
+	const server = getBunServer(c);
+	if (!server) throw new TypeError("env has to include the 2nd argument of fetch.");
+	if (typeof server.requestIP !== "function") throw new TypeError("server.requestIP is not a function.");
+	const info = server.requestIP(c.req.raw);
+	if (!info) return { remote: {} };
+	return { remote: {
+		address: info.address,
+		addressType: info.family === "IPv6" || info.family === "IPv4" ? info.family : void 0,
+		port: info.port
+	} };
+};
+//#endregion
+export { bunFileSystemModule, createBunWebSocket, getBunServer, getConnInfo, serveStatic, toSSG, upgradeWebSocket, websocket };

package/lib/cloudflare-pages.d.ts

@@ -0,0 +1,58 @@
+import { L as MiddlewareHandler, Y as Schema, g as BlankSchema, j as Input, v as Env } from "./context-DS3fYyG-.js";
+import { r as GetConnInfo } from "./types-Dv_nV2cv.js";
+import { t as Acryl } from "./app-D8riatvv.js";
+
+//#region ../../plugins/acryl-router/src/core/adapter/cloudflare-pages/handler.d.ts
+type Params<P extends string = any> = Record<P, string | string[]>;
+type EventContext<Env = {}, P extends string = any, Data = Record<string, unknown>> = {
+  request: Request;
+  functionPath: string;
+  waitUntil: (promise: Promise<unknown>) => void;
+  passThroughOnException: () => void;
+  props: any;
+  next: (input?: Request | string, init?: RequestInit) => Promise<Response>;
+  env: Env & {
+    ASSETS: {
+      fetch: typeof fetch;
+    };
+  };
+  params: Params<P>;
+  data: Data;
+};
+declare type PagesFunction<Env = unknown, Params extends string = any, Data extends Record<string, unknown> = Record<string, unknown>> = (context: EventContext<Env, Params, Data>) => Response | Promise<Response>;
+declare const handle: <E extends Env = Env, S extends Schema = BlankSchema, BasePath extends string = "/">(app: Acryl<E, S, BasePath>) => PagesFunction<E["Bindings"]>;
+declare function handleMiddleware<E extends Env = {}, P extends string = any, I extends Input = {}>(middleware: MiddlewareHandler<E & {
+  Bindings: {
+    eventContext: EventContext;
+  };
+}, P, I>): PagesFunction<E['Bindings']>;
+/**
+ *
+ * @description `serveStatic()` is for advanced mode:
+ * https://developers.cloudflare.com/pages/platform/functions/advanced-mode/#set-up-a-function
+ */
+declare const serveStatic: () => MiddlewareHandler;
+//#endregion
+//#region ../../plugins/acryl-router/src/core/adapter/cloudflare-pages/conninfo.d.ts
+/**
+ * Get connection information from Cloudflare Pages
+ * @param c - Context
+ * @returns Connection information including remote address
+ * @example
+ * ```ts
+ * import { Acryl } from 'acrylblends'
+ * import { handle, getConnInfo } from 'acrylblends/cloudflare-pages'
+ *
+ * const app = new Acryl()
+ *
+ * app.get('/', (c) => {
+ *   const info = getConnInfo(c)
+ *   return c.text(`Your IP: ${info.remote.address}`)
+ * })
+ *
+ * export const onRequest = handle(app)
+ * ```
+ */
+declare const getConnInfo: GetConnInfo;
+//#endregion
+export { type EventContext, getConnInfo, handle, handleMiddleware, serveStatic };

package/lib/cloudflare-pages.js

@@ -0,0 +1,78 @@
+import { HTTPException } from "./http-exception.js";
+import { t as Context } from "./context-DDO0cfuP.js";
+//#region ../../plugins/acryl-router/src/core/adapter/cloudflare-pages/handler.ts
+const handle = (app) => (eventContext) => {
+	return app.fetch(eventContext.request, {
+		...eventContext.env,
+		eventContext
+	}, {
+		waitUntil: eventContext.waitUntil,
+		passThroughOnException: eventContext.passThroughOnException,
+		props: {}
+	});
+};
+function handleMiddleware(middleware) {
+	return async (executionCtx) => {
+		const context = new Context(executionCtx.request, {
+			env: {
+				...executionCtx.env,
+				eventContext: executionCtx
+			},
+			executionCtx
+		});
+		let response = void 0;
+		try {
+			response = await middleware(context, async () => {
+				try {
+					context.res = await executionCtx.next();
+				} catch (error) {
+					if (error instanceof Error) context.error = error;
+					else throw error;
+				}
+			});
+		} catch (error) {
+			if (error instanceof Error) context.error = error;
+			else throw error;
+		}
+		if (response) return response;
+		if (context.error instanceof HTTPException) return context.error.getResponse();
+		if (context.error) throw context.error;
+		return context.res;
+	};
+}
+/**
+*
+* @description `serveStatic()` is for advanced mode:
+* https://developers.cloudflare.com/pages/platform/functions/advanced-mode/#set-up-a-function
+*/
+const serveStatic = () => {
+	return async (c) => {
+		const res = await c.env.ASSETS.fetch(c.req.raw);
+		if (res.status === 404) return c.notFound();
+		return res;
+	};
+};
+//#endregion
+//#region ../../plugins/acryl-router/src/core/adapter/cloudflare-pages/conninfo.ts
+/**
+* Get connection information from Cloudflare Pages
+* @param c - Context
+* @returns Connection information including remote address
+* @example
+* ```ts
+* import { Acryl } from 'acrylblends'
+* import { handle, getConnInfo } from 'acrylblends/cloudflare-pages'
+*
+* const app = new Acryl()
+*
+* app.get('/', (c) => {
+*   const info = getConnInfo(c)
+*   return c.text(`Your IP: ${info.remote.address}`)
+* })
+*
+* export const onRequest = handle(app)
+* ```
+*/
+const getConnInfo = (c) => ({ remote: { address: c.req.header("cf-connecting-ip") } });
+//#endregion
+export { getConnInfo, handle, handleMiddleware, serveStatic };

package/lib/cloudflare-workers.d.ts

@@ -0,0 +1,21 @@
+import { L as MiddlewareHandler, v as Env } from "./context-DS3fYyG-.js";
+import { r as GetConnInfo } from "./types-Dv_nV2cv.js";
+import { a as WSEvents, n as UpgradeWebSocket } from "./index-BvFh1Gfx.js";
+import { t as ServeStaticOptions$1 } from "./index-CseujaYI.js";
+
+//#region ../../plugins/acryl-router/src/core/adapter/cloudflare-workers/serve-static.d.ts
+type ServeStaticOptions<E extends Env = Env> = ServeStaticOptions$1<E> & {
+  namespace?: unknown;
+  manifest?: object | string;
+};
+//#endregion
+//#region ../../plugins/acryl-router/src/core/adapter/cloudflare-workers/serve-static-module.d.ts
+declare const module: <E extends Env = Env>(options: Omit<ServeStaticOptions<E>, "namespace">) => MiddlewareHandler;
+//#endregion
+//#region ../../plugins/acryl-router/src/core/adapter/cloudflare-workers/websocket.d.ts
+declare const upgradeWebSocket: UpgradeWebSocket<WebSocket, any, Omit<WSEvents<WebSocket>, 'onOpen'>>;
+//#endregion
+//#region ../../plugins/acryl-router/src/core/adapter/cloudflare-workers/conninfo.d.ts
+declare const getConnInfo: GetConnInfo;
+//#endregion
+export { getConnInfo, module as serveStatic, upgradeWebSocket };

package/lib/cloudflare-workers.js

@@ -0,0 +1,80 @@
+import { t as serveStatic$1 } from "./serve-static-Cp5adzGo.js";
+import { WSContext, defineWebSocketHelper } from "./ws.js";
+//#region ../../plugins/acryl-router/src/core/adapter/cloudflare-workers/utils.ts
+const getContentFromKVAsset = async (path, options) => {
+	let ASSET_MANIFEST;
+	if (options && options.manifest) if (typeof options.manifest === "string") ASSET_MANIFEST = JSON.parse(options.manifest);
+	else ASSET_MANIFEST = options.manifest;
+	else if (typeof __STATIC_CONTENT_MANIFEST === "string") ASSET_MANIFEST = JSON.parse(__STATIC_CONTENT_MANIFEST);
+	else ASSET_MANIFEST = __STATIC_CONTENT_MANIFEST;
+	let ASSET_NAMESPACE;
+	if (options && options.namespace) ASSET_NAMESPACE = options.namespace;
+	else ASSET_NAMESPACE = __STATIC_CONTENT;
+	const key = ASSET_MANIFEST[path];
+	if (!key) return null;
+	const content = await ASSET_NAMESPACE.get(key, { type: "stream" });
+	if (!content) return null;
+	return content;
+};
+//#endregion
+//#region ../../plugins/acryl-router/src/core/adapter/cloudflare-workers/serve-static.ts
+/**
+* @deprecated
+* `serveStatic` in the Cloudflare Workers adapter is deprecated.
+* You can serve static files directly using Cloudflare Static Assets.
+* @see https://developers.cloudflare.com/workers/static-assets/
+* Cloudflare Static Assets is currently in open beta. If this doesn't work for you,
+* please consider using Cloudflare Pages.
+*/
+const serveStatic = (options = {}) => {
+	return async function serveStatic(c, next) {
+		const getContent = async (path) => {
+			return getContentFromKVAsset(path, {
+				manifest: options.manifest,
+				namespace: options.namespace ? options.namespace : c.env ? c.env.__STATIC_CONTENT : void 0
+			});
+		};
+		return serveStatic$1({
+			...options,
+			getContent
+		})(c, next);
+	};
+};
+//#endregion
+//#region ../../plugins/acryl-router/src/core/adapter/cloudflare-workers/serve-static-module.ts
+const module = (options) => {
+	return serveStatic(options);
+};
+//#endregion
+//#region ../../plugins/acryl-router/src/core/adapter/cloudflare-workers/websocket.ts
+const upgradeWebSocket = defineWebSocketHelper(async (c, events) => {
+	if (c.req.header("Upgrade") !== "websocket") return;
+	const webSocketPair = new WebSocketPair();
+	const client = webSocketPair[0];
+	const server = webSocketPair[1];
+	const wsContext = new WSContext({
+		close: (code, reason) => server.close(code, reason),
+		get protocol() {
+			return server.protocol;
+		},
+		raw: server,
+		get readyState() {
+			return server.readyState;
+		},
+		url: server.url ? new URL(server.url) : null,
+		send: (source) => server.send(source)
+	});
+	if (events.onClose) server.addEventListener("close", (evt) => events.onClose?.(evt, wsContext));
+	if (events.onMessage) server.addEventListener("message", (evt) => events.onMessage?.(evt, wsContext));
+	if (events.onError) server.addEventListener("error", (evt) => events.onError?.(evt, wsContext));
+	server.accept?.();
+	return new Response(null, {
+		status: 101,
+		webSocket: client
+	});
+});
+//#endregion
+//#region ../../plugins/acryl-router/src/core/adapter/cloudflare-workers/conninfo.ts
+const getConnInfo = (c) => ({ remote: { address: c.req.header("cf-connecting-ip") } });
+//#endregion
+export { getConnInfo, module as serveStatic, upgradeWebSocket };

package/lib/db/sqlite.d.ts

@@ -0,0 +1,27 @@
+import { c as DbExecutor, l as SqlValue, s as Db } from "../index-D4FAsBZu.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 { type Db, type DbExecutor, OpenDb, OpenDbOptions, type SqlValue, openDb };

package/lib/db/sqlite.js

@@ -0,0 +1,197 @@
+import { i as applyMigrations, n as MIGRATIONS_TABLE, r as readMigrationFiles } from "../src-MWcsMS8i.js";
+import { mkdir } from "node:fs/promises";
+import { dirname } from "node:path";
+import { DatabaseSync } from "node:sqlite";
+//#region ../../plugins/acryl-db-sqlite/src/facade/node.ts
+const DEFAULT_WAL_AUTO_CHECKPOINT_PAGES = 1e3;
+const DEFAULT_BUSY_TIMEOUT_MS = 5e3;
+const ignore = () => {};
+/**
+* Runs operations in call order. An operation starts immediately when nothing is running or waiting;
+* otherwise it waits for everything before it. An asynchronous operation holds the queue until it settles.
+*/
+var SerialOperationQueue = class {
+	tail = Promise.resolve();
+	pending = 0;
+	run(operation) {
+		if (this.pending > 0) return this.enqueue(operation);
+		try {
+			return Promise.resolve(operation());
+		} catch (error) {
+			return Promise.reject(error);
+		}
+	}
+	runAsync(operation) {
+		if (this.pending > 0) return this.enqueue(operation);
+		this.pending++;
+		const { promise: barrier, resolve: releaseBarrier } = Promise.withResolvers();
+		this.tail = barrier;
+		let started;
+		try {
+			started = operation();
+		} catch (error) {
+			started = Promise.reject(error);
+		}
+		return started.finally(() => {
+			this.pending--;
+			releaseBarrier();
+		});
+	}
+	enqueue(operation) {
+		this.pending++;
+		return this.release(this.tail.then(operation));
+	}
+	release(operation) {
+		const settled = operation.finally(() => {
+			this.pending--;
+		});
+		this.tail = settled.then(ignore, ignore);
+		return settled;
+	}
+};
+/**
+* Executes SQL on one connection. Prepared statements are cached per connection by SQL text, so the
+* database and its transaction handles share them across transactions.
+*/
+var NodeSqliteExecutor = class {
+	database;
+	statements;
+	constructor(database, statements) {
+		this.database = database;
+		this.statements = statements;
+	}
+	exec(sql) {
+		return this.runOperation(() => {
+			this.database.exec(sql);
+		});
+	}
+	run(sql, ...params) {
+		return this.runOperation(() => ({ changes: Number(this.statement(sql).run(...params).changes) }));
+	}
+	get(sql, ...params) {
+		return this.runOperation(() => this.statement(sql).get(...params));
+	}
+	all(sql, ...params) {
+		return this.runOperation(() => this.statement(sql).all(...params));
+	}
+	statement(sql) {
+		let statement = this.statements.get(sql);
+		if (statement === void 0) {
+			statement = this.database.prepare(sql);
+			this.statements.set(sql, statement);
+		}
+		return statement;
+	}
+};
+var NodeSqliteTransaction = class extends NodeSqliteExecutor {
+	scope;
+	constructor(database, statements, scope) {
+		super(database, statements);
+		this.scope = scope;
+	}
+	async runOperation(operation) {
+		if (!this.scope.active) throw new Error("SQLite transaction handle is no longer active");
+		return operation();
+	}
+};
+/** `Db` adapter backed by Node's built-in `node:sqlite`. */
+var NodeSqliteDatabase = class extends NodeSqliteExecutor {
+	access = new SerialOperationQueue();
+	closed = false;
+	constructor(database) {
+		super(database, /* @__PURE__ */ new Map());
+	}
+	transaction(callback) {
+		return this.access.runAsync(async () => {
+			this.database.exec("BEGIN IMMEDIATE");
+			const scope = { active: true };
+			try {
+				const result = await callback(new NodeSqliteTransaction(this.database, this.statements, scope));
+				scope.active = false;
+				this.database.exec("COMMIT");
+				return result;
+			} catch (error) {
+				scope.active = false;
+				try {
+					this.database.exec("ROLLBACK");
+				} catch (rollbackError) {
+					throw new AggregateError([error, rollbackError], "SQLite transaction failed and rollback failed");
+				}
+				throw error;
+			}
+		});
+	}
+	close() {
+		return this.access.run(() => {
+			if (this.closed) return;
+			this.closed = true;
+			this.statements.clear();
+			try {
+				this.database.exec("PRAGMA wal_checkpoint(TRUNCATE)");
+			} finally {
+				this.database.close();
+			}
+		});
+	}
+	runOperation(operation) {
+		return this.access.run(operation);
+	}
+};
+/** Open and configure a Node-backed SQLite database facade. */
+async function openNodeSqliteDatabase(path, options = {}) {
+	const checkpointPages = options.walAutoCheckpointPages ?? DEFAULT_WAL_AUTO_CHECKPOINT_PAGES;
+	const timeout = options.busyTimeoutMs ?? DEFAULT_BUSY_TIMEOUT_MS;
+	if (path !== ":memory:") await mkdir(dirname(path), { recursive: true });
+	const adapter = new NodeSqliteDatabase(new DatabaseSync(path, { timeout }));
+	try {
+		await adapter.exec("PRAGMA journal_mode = WAL");
+		await adapter.exec("PRAGMA synchronous = NORMAL");
+		await adapter.exec(`PRAGMA wal_autocheckpoint = ${checkpointPages}`);
+		return adapter;
+	} catch (error) {
+		try {
+			await adapter.close();
+		} catch {}
+		throw error;
+	}
+}
+//#endregion
+//#region ../../plugins/acryl-db-sqlite/src/open.ts
+/**
+* The plain way to open the SQLite provider, for code without Cordis (an acrylblends app): `openDb({ path, migrations })` opens one
+* `node:sqlite` file with the ported facade's settings (WAL, `synchronous = NORMAL`, a busy timeout) and foreign keys enforced, applies the
+* numbered migrations, and resolves the `db` 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.
+*/
+/**
+* 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.
+*/
+async function openDb(options) {
+	const migrations = options.migrations === void 0 ? [] : await readMigrationFiles(options.migrations);
+	const database = await openNodeSqliteDatabase(options.path, {
+		...options.busyTimeoutMs === void 0 ? {} : { busyTimeoutMs: options.busyTimeoutMs },
+		...options.walAutoCheckpointPages === void 0 ? {} : { walAutoCheckpointPages: options.walAutoCheckpointPages }
+	});
+	try {
+		await database.exec("PRAGMA foreign_keys = ON");
+		await applyMigrations(database, migrations, { table: MIGRATIONS_TABLE });
+	} catch (error) {
+		await database.close();
+		throw error;
+	}
+	return {
+		db: {
+			exec: (sql) => database.exec(sql),
+			run: (sql, ...params) => database.run(sql, ...params),
+			get: (sql, ...params) => database.get(sql, ...params),
+			all: (sql, ...params) => database.all(sql, ...params),
+			transaction: (work) => database.transaction(work)
+		},
+		close: () => database.close()
+	};
+}
+//#endregion
+export { openDb };

package/lib/db.d.ts

@@ -0,0 +1,2 @@
+import { a as Migration, c as DbExecutor, i as validateSchemaPrefix, l as SqlValue, n as MIGRATIONS_TABLE, o as applyMigrations, r as readMigrationFiles, s as Db, t as DB_SERVICE } from "./index-D4FAsBZu.js";
+export { DB_SERVICE, type Db, type DbExecutor, MIGRATIONS_TABLE, type Migration, type SqlValue, applyMigrations, readMigrationFiles, validateSchemaPrefix };

package/lib/db.js

@@ -0,0 +1,2 @@
+import { a as validateSchemaPrefix, i as applyMigrations, n as MIGRATIONS_TABLE, r as readMigrationFiles, t as DB_SERVICE } from "./src-MWcsMS8i.js";
+export { DB_SERVICE, MIGRATIONS_TABLE, applyMigrations, readMigrationFiles, validateSchemaPrefix };