acrylblends 0.8.1 → 0.9.0

package/lib/db/sqlite.js

@@ -1,197 +1,2 @@
-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
+import { t as openDb } from "../open-CMhnJODn.js";
 export { openDb };

package/lib/db.d.ts

@@ -1,2 +1,3 @@
-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";
+import { n as DbExecutor, r as SqlValue, t as Db } from "./database-DBHdwefi.js";
+import { a as Migration, i as validateSchemaPrefix, n as MIGRATIONS_TABLE, o as applyMigrations, r as readMigrationFiles, t as DB_SERVICE } from "./index-Dmst2QCQ.js";
 export { DB_SERVICE, type Db, type DbExecutor, MIGRATIONS_TABLE, type Migration, type SqlValue, applyMigrations, readMigrationFiles, validateSchemaPrefix };

package/lib/{src-0hI7M7cN.js → deprecated-BP4fPt38.js}

@@ -1,21 +1,4 @@
 import { t as Acryl } from "./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
 //#region ../../plugins/acryl-router/src/deprecated.ts
 /**
 * The 0.4 names, kept for one release so code written against them keeps working: `App` is now `Acryl` and `AppRequest` is now `AcrylRequest`,

package/lib/door/host.d.ts

@@ -0,0 +1,24 @@
+import { t as Acryl } from "../app-D8riatvv.js";
+import { t as AuditEntry, v as UiSnapshot } from "../protocol-BizVt4J6.js";
+import { i as UiChannel, n as auditPath, r as PageStream, t as AuditLog } from "../audit-BXnYsLge.js";
+
+//#region ../../plugins/acryl-door/src/host/page-routes.d.ts
+/** How often the Host writes a `ping`; the page gives up on a stream that is silent for three of these. */
+declare const HEARTBEAT_MS = 15000;
+interface PageRoutesOptions {
+  /** Where the channel lives, e.g. `/api/acryl-door`. */
+  readonly prefix: string;
+  readonly heartbeatMs?: number;
+  /** The only hostnames the page may be served from (default: every loopback name), e.g. `['127.0.0.1']` for a Host that serves only that. */
+  readonly hostnames?: readonly string[];
+}
+declare function pageChannelRoutes(channel: UiChannel, options: PageRoutesOptions): Acryl;
+//#endregion
+//#region ../../plugins/acryl-door/src/page/snapshot-text.d.ts
+/**
+ * The snapshot as compact text for an agent: one line per element, indented by depth.
+ * @param more - how to ask for the rest when the page was cut, given the cursor to continue from.
+ */
+declare function renderSnapshot(snapshot: UiSnapshot, more?: (cursor: number) => string): string;
+//#endregion
+export { type AuditEntry, AuditLog, HEARTBEAT_MS, type PageRoutesOptions, type PageStream, UiChannel, auditPath, pageChannelRoutes, renderSnapshot };

package/lib/door/host.js

@@ -0,0 +1,2 @@
+import { d as AuditLog, f as auditPath, n as HEARTBEAT_MS, p as UiChannel, r as pageChannelRoutes, t as renderSnapshot } from "../snapshot-text-D3NspDyT.js";
+export { AuditLog, HEARTBEAT_MS, UiChannel, auditPath, pageChannelRoutes, renderSnapshot };

package/lib/door/page.d.ts

@@ -0,0 +1,105 @@
+import { _ as UiResult, g as UiRequest } from "../protocol-BizVt4J6.js";
+
+//#region ../../plugins/acryl-door/src/page/driver/driver.d.ts
+interface DriverActivity {
+  /** True from the moment a call starts until it ends. */
+  readonly busy: boolean;
+  /** What the agent is doing, for the indicator ("click", "type", ...). */
+  readonly doing: string;
+  /** True after the user pressed the kill switch. */
+  readonly killed: boolean;
+}
+interface UiDriverOptions {
+  readonly document: () => Document;
+  /** Milliseconds since the user last used the page (mouse, keyboard); Infinity when never. */
+  readonly msSinceUserInput?: () => number;
+  readonly sleep?: (ms: number, signal: AbortSignal) => Promise<void>;
+}
+declare class UiDriver {
+  private readonly refs;
+  private readonly snapshots;
+  private readonly listeners;
+  private readonly env;
+  private readonly stopAll;
+  private killedFlag;
+  private disposed;
+  private busyCount;
+  private doing;
+  private current;
+  private readonly options;
+  constructor(options: UiDriverOptions);
+  /** The current activity; the same object until something changes, as a store snapshot must be. */
+  get activity(): DriverActivity;
+  subscribe(listener: (activity: DriverActivity) => void): () => void;
+  /** The user pressed the kill switch: pending calls settle as `killed` and new ones are refused. */
+  kill(): void;
+  /** The user allowed the agent to drive again. */
+  resume(): void;
+  /** The driver goes away: pending calls settle as `unloaded`; refs are gone. */
+  dispose(): void;
+  /** @param signal - the Host cancelled the call. @throws UiControlError. */
+  handle(request: UiRequest, signal?: AbortSignal): Promise<UiResult>;
+  private run;
+  private yieldToUser;
+  private emit;
+}
+//#endregion
+//#region ../../plugins/acryl-door/src/page/channel.d.ts
+/** The slice of an `EventSource` the channel uses, so tests can supply their own. */
+interface ChannelSource {
+  addEventListener(type: string, listener: (event: MessageEvent) => void): void;
+  onerror: ((event: Event) => void) | null;
+  close(): void;
+  readonly readyState: number;
+}
+/** The Host's heartbeat is 15 s; three missed beats and the stream counts as dead. */
+declare const SILENCE_MS = 45000;
+interface PageChannelOptions {
+  readonly windowId: string;
+  readonly focused: () => boolean;
+  /** Where the door's routes are, e.g. `/api/acryl-door`. */
+  readonly base: string;
+  readonly createSource?: (url: string) => ChannelSource;
+  readonly post?: (url: string, body: string) => Promise<unknown>;
+  readonly silenceMs?: number;
+  readonly now?: () => number;
+}
+declare class PageChannel {
+  private source;
+  private reconnectTimer;
+  private watchdog;
+  private backoff;
+  private lastHeard;
+  private disposed;
+  private readonly now;
+  private readonly driver;
+  private readonly options;
+  constructor(driver: UiDriver, options: PageChannelOptions);
+  connect(): void;
+  /** Tell the Host whether this window is the one in front. */
+  reportFocus(focused: boolean): void;
+  dispose(): void;
+  /** Drop the stream and open a new one after the backoff. */
+  private restart;
+  private stop;
+  private answer;
+  private send;
+}
+//#endregion
+//#region ../../plugins/acryl-door/src/page/user-input.d.ts
+/** Tracks when the user last used the page, so the agent yields to them. */
+declare class UserInputClock {
+  private last;
+  private readonly now;
+  constructor(now?: () => number);
+  /** Milliseconds since the user last touched the page; Infinity when they have not. */
+  msSince: () => number;
+  /** Start listening. @returns disposer. */
+  attach(target: Document): () => void;
+}
+//#endregion
+//#region ../../plugins/acryl-door/src/page/indicator.d.ts
+/** Show the bar for `driver` in `document`. @returns the disposer, which removes the bar, its style and its listeners. */
+declare function mountIndicator(driver: UiDriver, document: Document): () => void;
+//#endregion
+export { type ChannelSource, type DriverActivity, PageChannel, type PageChannelOptions, SILENCE_MS, UiDriver, type UiDriverOptions, UserInputClock, mountIndicator };