acrylblends 0.8.1 → 0.9.0

package/lib/audit-BXnYsLge.d.ts

@@ -0,0 +1,58 @@
+import { _ as UiResult, g as UiRequest, n as ChannelToHost, t as AuditEntry } from "./protocol-BizVt4J6.js";
+
+//#region ../../plugins/acryl-door/src/host/channel.d.ts
+/** The slice of a page's stream the channel needs, so tests can supply their own. */
+interface PageStream {
+  send(data: string): void;
+  close(): void;
+}
+declare class UiChannel {
+  private readonly connections;
+  private readonly pending;
+  private nextId;
+  private clock;
+  private closed;
+  /**
+   * Register a page's stream. A stream already open for the same window is closed first, and its calls settle as `disconnected`.
+   * @returns the function to call when this stream ends.
+   */
+  attach(windowId: string, focused: boolean, stream: PageStream): () => void;
+  /** A message a page sent by POST. Only the window that was asked may answer a call, so another page cannot forge a result. */
+  receive(windowId: string, message: ChannelToHost): void;
+  /** True when at least one page is connected. */
+  get connected(): boolean;
+  /** The windows currently connected, most recently active first (for diagnostics and tests). */
+  windows(): readonly {
+    windowId: string;
+    focused: boolean;
+  }[];
+  /**
+   * Ask the current page to do something.
+   * @throws UiControlError `no-window`, `timeout`, `aborted`, `unloaded`, `disconnected`, or whatever the page refused with.
+   */
+  call(request: UiRequest, options?: {
+    signal?: AbortSignal;
+    timeoutMs?: number;
+  }): Promise<UiResult>;
+  /** Close every page's stream and settle every pending call as `unloaded`. */
+  close(): void;
+  private byRecency;
+  /** Forget a connection; its calls in flight settle as `disconnected` at once rather than waiting for their timeout. */
+  private drop;
+  private settle;
+}
+//#endregion
+//#region ../../plugins/acryl-door/src/host/audit.d.ts
+/** The audit log below a folder the caller owns (the app's `.acryl/` here; ACRYL's app home for the DSH face). */
+declare function auditPath(folder: string): string;
+declare class AuditLog {
+  private readonly path;
+  constructor(path: string);
+  /** Append one line; a failing disk never breaks the tool call. */
+  record(entry: AuditEntry): void;
+  /** The most recent entries, oldest first. */
+  recent(limit?: number): AuditEntry[];
+  private rotateIfLarge;
+}
+//#endregion
+export { UiChannel as i, auditPath as n, PageStream as r, AuditLog as t };

package/lib/cell-ChU41DZD.d.ts

@@ -0,0 +1,32 @@
+//#region ../../plugins/acryl-state/src/cell.d.ts
+/**
+ * Observable cells: the reactive core of the state service, with no Cordis and no DOM. A cell holds one value, tells its
+ * subscribers when it changes, and can be derived from other cells. The shape follows VanJS's `state` and `derive`
+ * (spec 046, M5): small enough to read in one sitting, and the same cell serves a React hook, a terminal component and a
+ * server-sent stream.
+ */
+type Listener<T> = (value: T, previous: T) => void;
+interface ReadonlyCell<T> {
+  readonly key: string;
+  get(): T;
+  /** Call `listener` after every change (never for a set to an equal value). Returns the unsubscribe function. */
+  subscribe(listener: Listener<T>): () => void;
+}
+interface Cell<T> extends ReadonlyCell<T> {
+  set(value: T): void;
+  update(change: (current: T) => T): void;
+}
+type ErrorSink = (error: unknown) => void;
+/** A writable cell. `report` receives anything a listener throws; one failing listener never blocks the others. */
+declare function createCell<T>(key: string, initial: T, report?: ErrorSink): Cell<T>;
+type Values<D extends readonly ReadonlyCell<unknown>[]> = { [K in keyof D]: D[K] extends ReadonlyCell<infer V> ? V : never };
+/**
+ * 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.
+ */
+declare function createDerived<D extends readonly ReadonlyCell<unknown>[], T>(key: string, inputs: D, compute: (...values: Values<D>) => T, report?: ErrorSink): {
+  readonly cell: ReadonlyCell<T>;
+  readonly dispose: () => void;
+};
+//#endregion
+export { createDerived as a, createCell as i, Listener as n, ReadonlyCell as r, Cell as t };

package/lib/client-modules-CLvWOjbd.js

@@ -0,0 +1,267 @@
+import { t as Acryl } from "./app-BM0rTCp7.js";
+import "./core-CaY8XDZ6.js";
+import { basePath } from "./route.js";
+import "./helpers-CvTauQT5.js";
+import { n as compileModule, t as MissingTypeScriptError } from "./transpile-QUK9b3eG.js";
+import { dirname, extname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { copyFileSync, mkdirSync, readFileSync, readdirSync, realpathSync, statSync, writeFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+//#region ../../plugins/acryl-node-server/src/client-modules.ts
+/**
+* Client components without a bundler. `clientModules({ root: 'src/client' })` is an app that serves the TypeScript and JSX modules of a
+* folder to the browser as ES modules: a `.tsx`/`.ts`/`.jsx` file compiled with the app's own `typescript` (JSX for `acrylblends/jsx/dom`),
+* a `.js`/`.mjs` file as it is. The framework's own browser imports (`acrylblends/jsx/dom` with its runtimes and `client`,
+* `acrylblends/client` and `acrylblends/read-sse`) are rewritten to three self-contained files the same app serves, at a URL relative to each module, so a page needs
+* one `<script type="module" src="/client/counter.tsx">` and no import map, under whatever path the app is routed at.
+*
+* Production runs without `typescript` (a deploy that leaves out devDependencies): `buildClientModules` writes the same compiled modules
+* and the three browser files into a folder, and with `NODE_ENV=production` and `compiled` set, only that folder is served.
+*/
+/** The folder the three browser files are served from, below the app's mount. A source folder of this name is not served. */
+const RUNTIME_DIR = "@acrylblends";
+/** The framework's browser imports and the browser file that provides each. */
+const BROWSER_IMPORTS = {
+	"acrylblends/jsx/dom": "jsx-dom.js",
+	"acrylblends/jsx/dom/jsx-runtime": "jsx-dom.js",
+	"acrylblends/jsx/dom/jsx-dev-runtime": "jsx-dom.js",
+	"acrylblends/jsx/dom/client": "jsx-dom.js",
+	"acrylblends/client": "client.js",
+	"acrylblends/read-sse": "read-sse.js"
+};
+const RUNTIME_FILES = [
+	"jsx-dom.js",
+	"client.js",
+	"read-sse.js"
+];
+const COMPILED = /* @__PURE__ */ new Set([
+	".ts",
+	".tsx",
+	".jsx",
+	".mts"
+]);
+const SERVED = /* @__PURE__ */ new Set([
+	...COMPILED,
+	".js",
+	".mjs"
+]);
+const JS_TYPE = "text/javascript; charset=utf-8";
+/** The cache bound when `cacheBytes` is not given. */
+const DEFAULT_CACHE_BYTES = 16 * 1024 * 1024;
+/** The framework's three browser files, next to the built module that contains this code. */
+const defaultRuntimeDir = () => fileURLToPath(new URL("./browser/", import.meta.url));
+/** A module path below the root (`widgets/counter.tsx`) with the URL prefix that reaches the browser files from it. */
+const runtimePrefix = (relativePath) => {
+	const depth = relativePath.split("/").length - 1;
+	return depth === 0 ? "./" : "../".repeat(depth);
+};
+/** One client module compiled for the browser: TypeScript and JSX compiled, the framework's imports pointed at its browser files. */
+function compileForBrowser(file, relativePath) {
+	const prefix = runtimePrefix(relativePath);
+	return compileModule(file, readFileSync(file, "utf8"), {
+		importSource: "acrylblends/jsx/dom",
+		defaultImportSource: "acrylblends/jsx/dom",
+		what: "is a client module",
+		rewrite: (specifier) => {
+			const target = BROWSER_IMPORTS[specifier];
+			return target === void 0 ? void 0 : `${prefix}${RUNTIME_DIR}/${target}`;
+		}
+	});
+}
+/**
+* The path below the root a request names, or `undefined` when it must not be served: a `..` or dot segment, a backslash or NUL, an
+* extension outside the served set, or a `.d.ts` file.
+*/
+function servedPath(requestPath) {
+	let decoded;
+	try {
+		decoded = decodeURIComponent(requestPath);
+	} catch {
+		return;
+	}
+	const parts = decoded.split("/").filter((part) => part !== "");
+	if (parts.length === 0 || parts.some((part) => part.startsWith(".") || part.includes("\\") || part.includes("\0"))) return void 0;
+	const path = parts.join("/");
+	if (!SERVED.has(extname(path)) || path.endsWith(".d.ts")) return void 0;
+	return path;
+}
+/** A real file inside `root` (symbolic links followed), or `undefined`. */
+function fileInside(root, path) {
+	try {
+		const file = realpathSync(join(root, ...path.split("/")));
+		return file.startsWith(root + sep) && statSync(file).isFile() ? file : void 0;
+	} catch {
+		return;
+	}
+}
+/** A file's validator: its size and modification time. */
+const etagOf = (stat) => `"${stat.size.toString(36)}-${Math.trunc(stat.mtimeMs).toString(36)}"`;
+/** Compiled modules, least recently served first, bounded by the UTF-8 bytes of their code. Exported for its tests. */
+var CompileCache = class {
+	entries = /* @__PURE__ */ new Map();
+	bytes = 0;
+	limit;
+	constructor(limit) {
+		this.limit = limit;
+	}
+	get(file, mtimeMs, size) {
+		const entry = this.entries.get(file);
+		if (entry === void 0) return void 0;
+		this.entries.delete(file);
+		if (entry.mtimeMs !== mtimeMs || entry.size !== size) {
+			this.bytes -= entry.bytes;
+			return;
+		}
+		this.entries.set(file, entry);
+		return entry;
+	}
+	set(file, stat, code) {
+		const entry = {
+			mtimeMs: stat.mtimeMs,
+			size: stat.size,
+			etag: etagOf(stat),
+			code,
+			bytes: Buffer.byteLength(code)
+		};
+		const previous = this.entries.get(file);
+		if (previous !== void 0) {
+			this.entries.delete(file);
+			this.bytes -= previous.bytes;
+		}
+		if (entry.bytes > this.limit) return entry;
+		this.entries.set(file, entry);
+		this.bytes += entry.bytes;
+		for (const [key, old] of this.entries) {
+			if (this.bytes <= this.limit) break;
+			this.entries.delete(key);
+			this.bytes -= old.bytes;
+		}
+		return entry;
+	}
+	/** The UTF-8 bytes of code held now. */
+	get heldBytes() {
+		return this.bytes;
+	}
+	/** The files held now, least recently served first. */
+	get files() {
+		return [...this.entries.keys()];
+	}
+};
+const absolute = (path) => isAbsolute(path) ? path : resolve(path);
+/** A folder's real path; one that does not exist (a production image that ships only the compiled folder) keeps its absolute path. */
+const realFolder = (path) => {
+	try {
+		return realpathSync(absolute(path));
+	} catch {
+		return absolute(path);
+	}
+};
+/**
+* An app serving a folder of client modules to the browser. Route it where the page's script tags point: `app.route('/client',
+* clientModules({ root: 'src/client' }))` serves `src/client/counter.tsx` at `/client/counter.tsx`. Files are compiled on request and
+* cached until they change (bounded by `cacheBytes`); a response carries an ETag and `Cache-Control: no-cache`, so an edit shows on the
+* next reload. With `NODE_ENV=production` and `compiled` set, only the `compiled` folder is served and nothing is compiled.
+* @param options - the folder, the precompiled folder, and the cache bound.
+* @returns the app.
+*/
+function clientModules(options) {
+	const root = realFolder(options.root);
+	const runtimeDir = absolute(options.runtimeDir ?? defaultRuntimeDir());
+	let compiled;
+	if (process.env.NODE_ENV === "production" && options.compiled !== void 0) try {
+		compiled = realpathSync(absolute(options.compiled));
+	} catch {
+		throw new Error(`acrylblends: the compiled client folder ${absolute(options.compiled)} does not exist; build it with buildClientModules before starting in production`);
+	}
+	const cache = new CompileCache(options.cacheBytes ?? DEFAULT_CACHE_BYTES);
+	const app = new Acryl();
+	app.get("/*", (c) => {
+		const requestPath = c.req.path.slice(basePath(c).length);
+		const runtime = /^\/@acrylblends\/([a-z-]+\.js)$/u.exec(requestPath)?.[1];
+		const send = (code, etag) => {
+			if (c.req.header("if-none-match") === etag) return c.body(null, 304, {
+				etag,
+				"cache-control": "no-cache"
+			});
+			return c.body(code, 200, {
+				"content-type": JS_TYPE,
+				etag,
+				"cache-control": "no-cache"
+			});
+		};
+		const serveFile = (file) => {
+			const stat = statSync(file);
+			return send(readFileSync(file, "utf8"), etagOf(stat));
+		};
+		if (runtime !== void 0) {
+			if (!RUNTIME_FILES.includes(runtime)) return c.notFound();
+			return serveFile(compiled === void 0 ? join(runtimeDir, runtime) : join(compiled, RUNTIME_DIR, runtime));
+		}
+		const path = servedPath(requestPath);
+		if (path === void 0 || path.split("/")[0] === RUNTIME_DIR) return c.notFound();
+		if (compiled !== void 0) {
+			const file = fileInside(compiled, path);
+			if (file !== void 0) return serveFile(file);
+			if (fileInside(root, path) !== void 0) return c.text(`acrylblends: ${path} is not in ${relative(process.cwd(), compiled) || compiled}; build the client modules again (buildClientModules)`, 500);
+			return c.notFound();
+		}
+		const file = fileInside(root, path);
+		if (file === void 0) return c.notFound();
+		if (!COMPILED.has(extname(file))) return serveFile(file);
+		const stat = statSync(file);
+		let entry = cache.get(file, stat.mtimeMs, stat.size);
+		if (entry === void 0) {
+			let code;
+			try {
+				code = compileForBrowser(file, path);
+			} catch (error) {
+				if (error instanceof MissingTypeScriptError) return c.text(error.message, 500);
+				throw error;
+			}
+			entry = cache.set(file, stat, code);
+		}
+		return send(entry.code, entry.etag);
+	});
+	return app;
+}
+/** Every served file below `dir`, as paths below `root` with `/` separators; dot entries, `node_modules` and the runtime folder skipped. */
+function sourceFiles(root, dir = root) {
+	const files = [];
+	for (const entry of readdirSync(dir, { withFileTypes: true })) {
+		if (entry.name.startsWith(".") || entry.name === "node_modules" || dir === root && entry.name === RUNTIME_DIR) continue;
+		const full = join(dir, entry.name);
+		if (entry.isDirectory()) files.push(...sourceFiles(root, full));
+		else if (entry.isFile() && SERVED.has(extname(entry.name)) && !entry.name.endsWith(".d.ts")) files.push(relative(root, full).split(sep).join("/"));
+	}
+	return files.sort();
+}
+/**
+* Compile a folder of client modules once, for a production that has no `typescript`: each module is written to `outDir` at the same
+* relative path and file name (so the page's URLs stay the same), compiled exactly as {@link clientModules} compiles it, and the three
+* browser files are copied to `outDir/@acrylblends/`. Files already in `outDir` that no source produces are left there.
+* @param options - the source folder and the output folder.
+* @returns the paths written, relative to `outDir`.
+* @throws MissingTypeScriptError when the app has no `typescript`; an error when `outDir` lies inside `root`.
+*/
+function buildClientModules(options) {
+	const root = realpathSync(absolute(options.root));
+	const outDir = absolute(options.outDir);
+	const runtimeDir = absolute(options.runtimeDir ?? defaultRuntimeDir());
+	if (outDir === root || outDir.startsWith(root + sep)) throw new Error(`acrylblends: the output folder ${outDir} lies inside the client folder ${root}`);
+	const written = [];
+	for (const path of sourceFiles(root)) {
+		const source = join(root, ...path.split("/"));
+		const target = join(outDir, ...path.split("/"));
+		mkdirSync(dirname(target), { recursive: true });
+		if (COMPILED.has(extname(path))) writeFileSync(target, compileForBrowser(source, path));
+		else copyFileSync(source, target);
+		written.push(path);
+	}
+	mkdirSync(join(outDir, RUNTIME_DIR), { recursive: true });
+	for (const name of RUNTIME_FILES) {
+		copyFileSync(join(runtimeDir, name), join(outDir, RUNTIME_DIR, name));
+		written.push(`${RUNTIME_DIR}/${name}`);
+	}
+	return written;
+}
+//#endregion
+export { clientModules as n, buildClientModules as t };

package/lib/connection-ZLEso7XL.d.ts

@@ -0,0 +1,25 @@
+import { t as Context } from "./context-DS3fYyG-.js";
+import { r as GetConnInfo } from "./types-Dv_nV2cv.js";
+
+//#region ../../plugins/acryl-router/src/connection.d.ts
+/** An in-process caller (the terminal UI, a test) passes nothing, so a handler that needs a trusted peer must refuse an empty one. */
+interface ConnectionInfo {
+  /** The peer address of the socket, when the request came over one (for example `127.0.0.1`). */
+  readonly remoteAddress?: string | undefined;
+  /** The local port the socket is connected to, the real one a `Host` header should be checked against. */
+  readonly localPort?: number | undefined;
+}
+/** What the router puts in `c.env`. */
+interface RouterBindings {
+  readonly connection: ConnectionInfo;
+}
+/** The `Env` of an `Acryl` that wants `c.env.connection` typed: `new Acryl<RouterEnv>()`. */
+interface RouterEnv {
+  Bindings: RouterBindings;
+}
+/** The transport facts of this request; empty for an in-process call or an `Acryl` run outside the router. */
+declare function connectionOf(c: Context): ConnectionInfo;
+/** The peer in the core's conninfo shape, for middleware written against it (for example `ipRestriction`). */
+declare const getConnInfo: GetConnInfo;
+//#endregion
+export { getConnInfo as a, connectionOf as i, RouterBindings as n, RouterEnv as r, ConnectionInfo as t };

package/lib/conninfo.d.ts

@@ -1,25 +1,3 @@
-import { t as Context } from "./context-DS3fYyG-.js";
 import { i as NetAddrInfo, n as ConnInfo, r as GetConnInfo, t as AddressType } from "./types-Dv_nV2cv.js";
-
-//#region ../../plugins/acryl-router/src/connection.d.ts
-/** An in-process caller (the terminal UI, a test) passes nothing, so a handler that needs a trusted peer must refuse an empty one. */
-interface ConnectionInfo {
-  /** The peer address of the socket, when the request came over one (for example `127.0.0.1`). */
-  readonly remoteAddress?: string | undefined;
-  /** The local port the socket is connected to, the real one a `Host` header should be checked against. */
-  readonly localPort?: number | undefined;
-}
-/** What the router puts in `c.env`. */
-interface RouterBindings {
-  readonly connection: ConnectionInfo;
-}
-/** The `Env` of an `Acryl` that wants `c.env.connection` typed: `new Acryl<RouterEnv>()`. */
-interface RouterEnv {
-  Bindings: RouterBindings;
-}
-/** The transport facts of this request; empty for an in-process call or an `Acryl` run outside the router. */
-declare function connectionOf(c: Context): ConnectionInfo;
-/** The peer in the core's conninfo shape, for middleware written against it (for example `ipRestriction`). */
-declare const getConnInfo: GetConnInfo;
-//#endregion
+import { a as getConnInfo, i as connectionOf, n as RouterBindings, r as RouterEnv, t as ConnectionInfo } from "./connection-ZLEso7XL.js";
 export { type AddressType, type ConnInfo, type ConnectionInfo, type GetConnInfo, type NetAddrInfo, type RouterBindings, type RouterEnv, connectionOf, getConnInfo };

package/lib/cordis/db-sqlite.d.ts

@@ -0,0 +1,56 @@
+import { n as DbExecutor, r as SqlValue, t as Db } from "../database-DBHdwefi.js";
+import { OpenDb, OpenDbOptions, openDb } from "../db/sqlite.js";
+import { DatabaseSync, StatementSync } from "node:sqlite";
+import { Context } from "@deepseek-ai/cordis";
+import z from "@deepseek-ai/schemastery";
+
+//#region ../../plugins/acryl-db-sqlite/src/facade/node.d.ts
+/** Node SQLite connection settings for a database file. */
+type NodeSqliteDatabaseOptions = {
+  /** SQLite WAL auto-checkpoint threshold. SQLite and this adapter default to 1,000 pages; 0 disables it. */readonly walAutoCheckpointPages?: number; /** Time SQLite waits for a competing file lock. SQLite defaults to 0; this adapter defaults to 5,000 ms. */
+  readonly busyTimeoutMs?: number;
+};
+/**
+ * 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.
+ */
+declare abstract class NodeSqliteExecutor implements DbExecutor {
+  protected readonly database: DatabaseSync;
+  protected readonly statements: Map<string, StatementSync>;
+  constructor(database: DatabaseSync, statements: Map<string, StatementSync>);
+  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[]>;
+  protected abstract runOperation<T>(operation: () => T): Promise<T>;
+  private statement;
+}
+/** `Db` adapter backed by Node's built-in `node:sqlite`. */
+declare class NodeSqliteDatabase extends NodeSqliteExecutor implements Db {
+  private readonly access;
+  private closed;
+  constructor(database: DatabaseSync);
+  transaction<T>(callback: (transaction: DbExecutor) => Promise<T>): Promise<T>;
+  close(): Promise<void>;
+  protected runOperation<T>(operation: () => T): Promise<T>;
+}
+/** Open and configure a Node-backed SQLite database facade. */
+declare function openNodeSqliteDatabase(path: string, options?: NodeSqliteDatabaseOptions): Promise<NodeSqliteDatabase>;
+//#endregion
+//#region ../../plugins/acryl-db-sqlite/src/index.d.ts
+/** Stable Cordis plugin name, equal to the package name and the Loader row id. */
+declare const name = "acryl-db-sqlite";
+interface Config {
+  path?: string;
+  migrations?: string;
+  busyTimeoutMs?: number;
+  walAutoCheckpointPages?: number;
+}
+declare const Config: z<Config>;
+/** The file name used in the app home when `path` is not configured. */
+declare const DEFAULT_FILE = "data.sqlite";
+declare function apply(ctx: Context, rawConfig?: Config): Promise<void>;
+//#endregion
+export { Config, DEFAULT_FILE, NodeSqliteDatabase, type NodeSqliteDatabaseOptions, type OpenDb, type OpenDbOptions, apply, name, openDb, openNodeSqliteDatabase };

package/lib/cordis/db-sqlite.js

@@ -0,0 +1,58 @@
+import "../src-MWcsMS8i.js";
+import { n as NodeSqliteDatabase, r as openNodeSqliteDatabase, t as openDb } from "../open-CMhnJODn.js";
+import { dirname, isAbsolute, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import z from "@deepseek-ai/schemastery";
+//#region ../../plugins/acryl-db-sqlite/src/index.ts
+/**
+* The SQLite provider of the `db` port (spec 049 slice 1): one `node:sqlite` file, opened with the ported facade's settings (WAL,
+* `synchronous = NORMAL`, a busy timeout), migrated, and provided as `db`. App plugins declare `inject: ['db']` and import types from
+* `acryl-db` only, so replacing this row with another provider does not touch them. The plugin is a thin wrapper over `openDb`
+* (`acryl-db-sqlite/open`), the same opening for code without Cordis.
+*
+* Unloading withdraws `db` first, so consumers stop calling, and then closes the file: the close waits for running operations and
+* transactions, checkpoints the WAL and releases the file.
+*/
+/** Stable Cordis plugin name, equal to the package name and the Loader row id. */
+const name = "acryl-db-sqlite";
+function isAppHome(value) {
+	return typeof value === "object" && value !== null && "home" in value && typeof value.home === "string";
+}
+const Config = z.object({
+	path: z.string().description("The database file, absolute or relative to the app. Defaults to data.sqlite in the ACRYL app home; required where there is none."),
+	migrations: z.string().description("A folder of NNN-name.sql files numbered from 1, absolute or relative to the app, applied in order on start."),
+	busyTimeoutMs: z.natural().description("How long SQLite waits for a competing file lock, in milliseconds. Defaults to 5000."),
+	walAutoCheckpointPages: z.natural().description("The WAL auto-checkpoint threshold in pages; 0 disables it. Defaults to 1000.")
+});
+/** The file name used in the app home when `path` is not configured. */
+const DEFAULT_FILE = "data.sqlite";
+/** A configured path as a file path: absolute as given, relative to the Loader's base URL (the app) otherwise. */
+function resolveFromApp(ctx, path, option) {
+	if (path.startsWith("file:")) return fileURLToPath(path);
+	if (isAbsolute(path)) return path;
+	const base = ctx.baseUrl;
+	if (base === void 0 || !base.startsWith("file:")) throw new Error(`acryl-db-sqlite: ${option} ${JSON.stringify(path)} is relative, but this app has no file base URL to resolve it from; give an absolute path`);
+	return resolve(base.endsWith("/") ? fileURLToPath(base) : dirname(fileURLToPath(base)), path);
+}
+async function apply(ctx, rawConfig = {}) {
+	const config = Config(rawConfig);
+	const appInstance = ctx.get("appInstance");
+	let file;
+	if (config.path !== void 0) file = resolveFromApp(ctx, config.path, "path");
+	else if (isAppHome(appInstance)) file = join(appInstance.home, DEFAULT_FILE);
+	else throw new Error("acryl-db-sqlite: no database path; set `path` in this row's config (there is no ACRYL app home to default to)");
+	const migrations = config.migrations === void 0 ? void 0 : resolveFromApp(ctx, config.migrations, "migrations");
+	const options = {
+		path: file,
+		...migrations === void 0 ? {} : { migrations },
+		...config.busyTimeoutMs === void 0 ? {} : { busyTimeoutMs: config.busyTimeoutMs },
+		...config.walAutoCheckpointPages === void 0 ? {} : { walAutoCheckpointPages: config.walAutoCheckpointPages }
+	};
+	await ctx.effect(async function* () {
+		const opened = await openDb(options);
+		yield () => opened.close();
+		yield ctx.reflect.provide("db", opened.db);
+	}, `acryl-db-sqlite: ${file}`);
+}
+//#endregion
+export { Config, DEFAULT_FILE, NodeSqliteDatabase, apply, name, openDb, openNodeSqliteDatabase };

package/lib/cordis/db.d.ts

@@ -0,0 +1,8 @@
+import { t as Db } from "../database-DBHdwefi.js";
+
+//#region ../../plugins/acryl-db/src/cordis.d.ts
+declare module '@deepseek-ai/cordis' {
+  interface Context {
+    db: Db;
+  }
+}

package/lib/cordis/db.js

@@ -0,0 +1 @@
+export {};