acrylblends 1.0.4 → 1.0.5

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 };

package/lib/pretty-json-CeC1yvYt.js

@@ -0,0 +1,39 @@
+//#region ../../plugins/acryl-router/src/core/middleware/pretty-json/index.ts
+const jsonContentTypeRegex = /^application\/(?:[a-z0-9._-]+\+)?json(?=$|[;\s])/i;
+/**
+* Pretty JSON Middleware for Acryl.
+*
+*
+* @param options - The options for the pretty JSON middleware.
+* @returns {MiddlewareHandler} The middleware handler function.
+*
+* @example
+* ```ts
+* const app = new Acryl()
+*
+* app.use(prettyJSON()) // With options: prettyJSON({ space: 4 })
+* app.get('/', (c) => {
+*   return c.json({ message: 'Acryl!' })
+* })
+* ```
+*/
+const prettyJSON = (options) => {
+	const targetQuery = options?.query ?? "pretty";
+	return async function prettyJSON(c, next) {
+		const pretty = options?.force || c.req.query(targetQuery) || c.req.query(targetQuery) === "";
+		await next();
+		const contentType = c.res.headers.get("Content-Type");
+		if (pretty && contentType && jsonContentTypeRegex.test(contentType)) {
+			let obj;
+			try {
+				obj = await c.res.clone().json();
+			} catch {
+				return;
+			}
+			c.res = new Response(JSON.stringify(obj, null, options?.space ?? 2), c.res);
+			c.res.headers.delete("Content-Length");
+		}
+	};
+};
+//#endregion
+export { prettyJSON as t };

package/lib/pretty-json.js

@@ -1,39 +1,2 @@
-//#region ../../plugins/acryl-router/src/core/middleware/pretty-json/index.ts
-const jsonContentTypeRegex = /^application\/(?:[a-z0-9._-]+\+)?json(?=$|[;\s])/i;
-/**
-* Pretty JSON Middleware for Acryl.
-*
-*
-* @param options - The options for the pretty JSON middleware.
-* @returns {MiddlewareHandler} The middleware handler function.
-*
-* @example
-* ```ts
-* const app = new Acryl()
-*
-* app.use(prettyJSON()) // With options: prettyJSON({ space: 4 })
-* app.get('/', (c) => {
-*   return c.json({ message: 'Acryl!' })
-* })
-* ```
-*/
-const prettyJSON = (options) => {
-	const targetQuery = options?.query ?? "pretty";
-	return async function prettyJSON(c, next) {
-		const pretty = options?.force || c.req.query(targetQuery) || c.req.query(targetQuery) === "";
-		await next();
-		const contentType = c.res.headers.get("Content-Type");
-		if (pretty && contentType && jsonContentTypeRegex.test(contentType)) {
-			let obj;
-			try {
-				obj = await c.res.clone().json();
-			} catch {
-				return;
-			}
-			c.res = new Response(JSON.stringify(obj, null, options?.space ?? 2), c.res);
-			c.res.headers.delete("Content-Length");
-		}
-	};
-};
-//#endregion
+import { t as prettyJSON } from "./pretty-json-CeC1yvYt.js";
 export { prettyJSON };

package/lib/protocol-Dt0AZBOz.js

@@ -0,0 +1,213 @@
+//#region ../../plugins/acryl-door/src/page/protocol.ts
+/**
+* The one shape of a door call, shared by the Host and the in-page driver (moved from `acryl-agent-control`, spec 041).
+*
+* The Host turns a verb's arguments into a {@link UiRequest}, sends it to the page over the channel, and gets a {@link UiResult} back.
+* Everything crossing the channel is validated here once, so neither side trusts the other's JSON. The page imports this file too, so it
+* lives with the page code and has no Node imports.
+*/
+/** The operations the driver performs on the page. */
+const UI_OPS = [
+	"snapshot",
+	"click",
+	"type",
+	"select",
+	"press",
+	"scroll",
+	"wait",
+	"reload",
+	"navigate"
+];
+/** Operations that change the page, so each call needs approval. `snapshot`, `scroll` and `wait` only look. */
+const MUTATING_OPS = [
+	"click",
+	"type",
+	"select",
+	"press",
+	"reload",
+	"navigate"
+];
+/** A place in the app to go to: a path on the page's own origin (`/demo`, `/notes?q=a#top`), never another site and never a `//host` address. */
+const APP_PATH = /^\/(?![/\\])[^\0\\]{0,2000}$/u;
+const MAX_TEXT_LENGTH = 1e4;
+const MAX_WAIT_MS = 1e4;
+const MAX_SNAPSHOT_NODES = 1e3;
+const DEFAULT_SNAPSHOT_NODES = 300;
+var UiControlError = class extends Error {
+	code;
+	constructor(code, message) {
+		super(message);
+		this.code = code;
+		this.name = "UiControlError";
+	}
+};
+const KEYS = /^(?:[A-Za-z0-9]|Enter|Escape|Tab|Backspace|Delete|Space|Arrow(?:Up|Down|Left|Right)|Home|End|PageUp|PageDown)$/;
+const REF = /^\d{1,9}\.\d{1,6}$/;
+const isRecord = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+const invalid = (message) => {
+	throw new UiControlError("invalid", message);
+};
+function ref(value) {
+	if (typeof value !== "string" || !REF.test(value)) return invalid("ref must look like 3.17, from the latest snapshot");
+	return value;
+}
+function text(value, max = MAX_TEXT_LENGTH) {
+	if (typeof value !== "string" || value.length > max || value.includes("\0")) return invalid(`text must be a string of at most ${String(max)} characters`);
+	return value;
+}
+/** @param value - untrusted JSON. @throws UiControlError `invalid`. */
+function parseUiRequest(value) {
+	if (!isRecord(value) || typeof value.op !== "string") return invalid("a call needs an op");
+	const op = value.op;
+	const only = (allowed) => {
+		const extra = Object.keys(value).find((key) => key !== "op" && !allowed.includes(key));
+		if (extra !== void 0) invalid(`unknown field ${extra}`);
+	};
+	switch (op) {
+		case "snapshot": {
+			only(["cursor", "maxNodes"]);
+			const cursor = value.cursor === void 0 ? void 0 : Number(value.cursor);
+			const maxNodes = value.maxNodes === void 0 ? void 0 : Number(value.maxNodes);
+			if (cursor !== void 0 && (!Number.isInteger(cursor) || cursor < 0) || maxNodes !== void 0 && (!Number.isInteger(maxNodes) || maxNodes < 1 || maxNodes > 1e3)) return invalid("cursor and maxNodes must be small positive integers");
+			return {
+				op,
+				...cursor === void 0 ? {} : { cursor },
+				...maxNodes === void 0 ? {} : { maxNodes }
+			};
+		}
+		case "click":
+			only(["ref"]);
+			return {
+				op,
+				ref: ref(value.ref)
+			};
+		case "type":
+			only([
+				"ref",
+				"text",
+				"submit",
+				"clear"
+			]);
+			if (value.submit !== void 0 && typeof value.submit !== "boolean" || value.clear !== void 0 && typeof value.clear !== "boolean") return invalid("submit and clear must be true or false");
+			return {
+				op,
+				ref: ref(value.ref),
+				text: text(value.text),
+				...value.submit === void 0 ? {} : { submit: value.submit },
+				...value.clear === void 0 ? {} : { clear: value.clear }
+			};
+		case "select":
+			only(["ref", "option"]);
+			return {
+				op,
+				ref: ref(value.ref),
+				option: text(value.option, 500)
+			};
+		case "press":
+			only(["key", "ref"]);
+			if (typeof value.key !== "string" || !KEYS.test(value.key)) return invalid("key must be a single character or a name such as Enter, Escape, Tab or ArrowDown");
+			return {
+				op,
+				key: value.key,
+				...value.ref === void 0 ? {} : { ref: ref(value.ref) }
+			};
+		case "scroll": {
+			only([
+				"direction",
+				"ref",
+				"amount"
+			]);
+			if (value.direction !== "up" && value.direction !== "down" && value.direction !== "left" && value.direction !== "right") return invalid("direction must be up, down, left or right");
+			const amount = value.amount === void 0 ? void 0 : Number(value.amount);
+			if (amount !== void 0 && (!Number.isFinite(amount) || amount <= 0 || amount > 1e4)) return invalid("amount must be between 1 and 10000 pixels");
+			return {
+				op,
+				direction: value.direction,
+				...value.ref === void 0 ? {} : { ref: ref(value.ref) },
+				...amount === void 0 ? {} : { amount }
+			};
+		}
+		case "wait": {
+			only([
+				"text",
+				"role",
+				"name",
+				"gone",
+				"timeoutMs"
+			]);
+			const timeoutMs = value.timeoutMs === void 0 ? void 0 : Number(value.timeoutMs);
+			if (timeoutMs !== void 0 && (!Number.isFinite(timeoutMs) || timeoutMs < 0 || timeoutMs > 1e4)) return invalid(`timeoutMs must be between 0 and ${String(MAX_WAIT_MS)}`);
+			if (value.gone !== void 0 && typeof value.gone !== "boolean") return invalid("gone must be true or false");
+			if (value.text === void 0 && value.role === void 0 && value.name === void 0) return invalid("wait needs text, or a role and name");
+			return {
+				op,
+				...value.text === void 0 ? {} : { text: text(value.text, 500) },
+				...value.role === void 0 ? {} : { role: text(value.role, 60) },
+				...value.name === void 0 ? {} : { name: text(value.name, 500) },
+				...value.gone === void 0 ? {} : { gone: value.gone },
+				...timeoutMs === void 0 ? {} : { timeoutMs }
+			};
+		}
+		case "reload":
+			only([]);
+			return { op };
+		case "navigate":
+			only(["path"]);
+			if (typeof value.path !== "string" || !APP_PATH.test(value.path)) return invalid("path must be a path of this app, such as /demo (it starts with one /, and names no other site)");
+			return {
+				op,
+				path: value.path
+			};
+		default: return invalid(`unknown op ${String(op)}`);
+	}
+}
+/** @param text - one `call` event's data from the Host. @throws when it is not a well-formed call. */
+function parseChannelToPage(text) {
+	const value = JSON.parse(text);
+	if (isRecord(value) && value.t === "call" && typeof value.id === "number" && Number.isSafeInteger(value.id)) return {
+		t: "call",
+		id: value.id,
+		request: parseUiRequest(value.request)
+	};
+	throw new UiControlError("invalid", "not a channel call");
+}
+/** Every code a {@link UiControlError} can carry, so a code read off the wire is validated, not cast. */
+const UI_ERROR_CODES = [
+	"no-window",
+	"stale-ref",
+	"unknown-ref",
+	"sensitive",
+	"protected",
+	"not-actionable",
+	"not-found",
+	"killed",
+	"timeout",
+	"aborted",
+	"unloaded",
+	"disconnected",
+	"invalid"
+];
+/** A window id the page chose: short, printable, so it can travel in a query string and a log line. */
+const WINDOW_ID = /^[A-Za-z0-9-]{1,80}$/u;
+/** @param value - one parsed message from the page; null when it is not a well-formed message. */
+function parseChannelToHost(value) {
+	if (!isRecord(value)) return null;
+	if (value.t === "focus" && typeof value.focused === "boolean") return {
+		t: "focus",
+		focused: value.focused
+	};
+	if (value.t === "result" && typeof value.id === "number" && isRecord(value.value)) return {
+		t: "result",
+		id: value.id,
+		value: value.value
+	};
+	if (value.t === "error" && typeof value.id === "number" && typeof value.message === "string" && UI_ERROR_CODES.includes(value.code)) return {
+		t: "error",
+		id: value.id,
+		code: value.code,
+		message: value.message.slice(0, 500)
+	};
+	return null;
+}
+//#endregion
+export { MAX_WAIT_MS as a, UI_OPS as c, parseChannelToHost as d, parseChannelToPage as f, MAX_TEXT_LENGTH as i, UiControlError as l, DEFAULT_SNAPSHOT_NODES as n, MUTATING_OPS as o, parseUiRequest as p, MAX_SNAPSHOT_NODES as r, UI_ERROR_CODES as s, APP_PATH as t, WINDOW_ID as u };