@botharness/core 1.4.0 → 1.4.1

package/cli/index.mjs

@@ -3,7 +3,7 @@ import { createHash, randomBytes, randomUUID } from "node:crypto";
 import { execFile, execFileSync, spawnSync } from "node:child_process";
 import { chmodSync, closeSync, constants, copyFileSync, cpSync, createReadStream, createWriteStream, existsSync, fstatSync, fsyncSync, lstatSync, mkdirSync, mkdtempSync, openSync, readFileSync, readSync, readdirSync, readlinkSync, realpathSync, renameSync, rmSync, stat, statSync, unlinkSync, unwatchFile, watch, watchFile, writeFileSync } from "node:fs";
 import * as sp from "node:path";
-import { basename, delimiter, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { basename, delimiter, dirname, isAbsolute, join, posix, relative, resolve, sep } from "node:path";
 import { isDeepStrictEqual, parseArgs, promisify } from "node:util";
 import { EventEmitter } from "node:events";
 import { lstat, mkdir, open, opendir, readFile, readdir, realpath, rename, rm, stat as stat$1, writeFile } from "node:fs/promises";
@@ -11,6 +11,7 @@ import { Readable } from "node:stream";
 import { homedir, hostname, tmpdir, type } from "node:os";
 import { setTimeout as setTimeout$1 } from "node:timers/promises";
 import { DatabaseSync } from "node:sqlite";
+import { parse, walk } from "css-tree";
 import { deflateRawSync, deflateSync, inflateRawSync } from "node:zlib";
 import { Resvg } from "@resvg/resvg-js";
 import { pipeline } from "node:stream/promises";
@@ -15790,7 +15791,7 @@ const initializer = (inst, issues) => {
 const ZodRealError = /*@__PURE__*/ $constructor("ZodError", initializer, { Parent: Error });
 //#endregion
 //#region node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/classic/parse.js
-const parse$1 = /* @__PURE__ */ _parse(ZodRealError);
+const parse$2 = /* @__PURE__ */ _parse(ZodRealError);
 const parseAsync = /* @__PURE__ */ _parseAsync(ZodRealError);
 const safeParse = /* @__PURE__ */ _safeParse(ZodRealError);
 const safeParseAsync = /* @__PURE__ */ _safeParseAsync(ZodRealError);
@@ -15850,7 +15851,7 @@ const ZodType = /*@__PURE__*/ $constructor("ZodType", (inst, def) => {
 	inst.def = def;
 	inst.type = def.type;
 	Object.defineProperty(inst, "_def", { value: def });
-	inst.parse = (data, params) => parse$1(inst, data, params, { callee: inst.parse });
+	inst.parse = (data, params) => parse$2(inst, data, params, { callee: inst.parse });
 	inst.safeParse = (data, params) => safeParse(inst, data, params);
 	inst.parseAsync = async (data, params) => parseAsync(inst, data, params, { callee: inst.parseAsync });
 	inst.safeParseAsync = async (data, params) => safeParseAsync(inst, data, params);
@@ -16778,6 +16779,7 @@ function isChannelMessage(value) {
 	const switchTarget = message["memorySwitchTarget"];
 	if (switchTarget !== void 0 && (typeof switchTarget !== "string" || switchTarget.length === 0 || switchTarget.length > 255 || message["author"]?.kind !== "human")) return false;
 	if (message["grantRequest"] !== void 0 && (message["grantRequest"] !== true || !isChannelMessageAuthor(message["author"]) || message["author"].kind !== "bot")) return false;
+	if (message["grantRequestOwner"] !== void 0 && (message["grantRequest"] !== true || typeof message["grantRequestOwner"] !== "string" || !message["grantRequestOwner"])) return false;
 	const grantResolution = message["grantRequestResolution"];
 	const assignmentReply = message["assignmentReply"];
 	if (assignmentReply !== void 0) {
@@ -16817,7 +16819,7 @@ function isChannelMessage(value) {
 		if (typeof toolDecision !== "object" || toolDecision === null || message["author"]?.kind !== "human") return false;
 		const decision = toolDecision;
 		if (decision["actor"] !== void 0 && !parseToolApprovalActor(decision["actor"])) return false;
-		if (typeof decision["requestMessageId"] !== "string" || decision["outcome"] !== "allowed-once" && decision["outcome"] !== "allowed-always-exact" && decision["outcome"] !== "allowed-always-all" && decision["outcome"] !== "rejected" || message["replyTo"] !== decision["requestMessageId"]) return false;
+		if (typeof decision["requestMessageId"] !== "string" || decision["outcome"] !== "allowed-once" && decision["outcome"] !== "allowed-always-tool" && decision["outcome"] !== "allowed-always-exact" && decision["outcome"] !== "allowed-always-all" && decision["outcome"] !== "rejected" || message["replyTo"] !== decision["requestMessageId"]) return false;
 	}
 	const mentions = message["mentions"];
 	if (mentions !== void 0 && (!Array.isArray(mentions) || mentions.some((item) => typeof item !== "object" || item === null || typeof item.botSlug !== "string" || typeof item.label !== "string" || typeof item.start !== "number" || typeof item.end !== "number" || !Number.isSafeInteger(item.start) || !Number.isSafeInteger(item.end) || item.start < 0 || item.end <= item.start))) return false;
@@ -19631,6 +19633,15 @@ function createSqliteChannelStore(options) {
 			if (channel === void 0) throw new Error("Group Channel not found");
 			return allBotPreview(channel, isBotActive, options.botDisplayName ?? (() => void 0));
 		},
+		grantRequestResolution(channelId, requestMessageId) {
+			const row = database.read((db) => db.prepare(`SELECT e.payload_json, e.source_event_id
+        FROM source_events e JOIN channel_placements p ON p.source_event_id = e.source_event_id
+        WHERE p.channel_id = ? AND json_extract(e.payload_json, '$.grantRequestResolution.requestMessageId') = ?
+        LIMIT 1`).get(channelId, requestMessageId));
+			if (!row) return void 0;
+			const payload = JSON.parse(row.payload_json);
+			return allMessages(channelId).find((message) => message.id === payload.id);
+		},
 		async appendMessageOnce(id, message, preview, origin, canCommit) {
 			return append(id, message, true, preview, origin, canCommit) ?? { status: "missing" };
 		},
@@ -40207,6 +40218,45 @@ function createWorkspaceGrantStore(options) {
 				return current;
 			}, ["workspace-grants"]));
 		},
+		async prepareWrite(botSlug, workspaceId, validate) {
+			validate();
+			const existing = this.list(botSlug).find((grant) => grant.workspaceId === workspaceId && grant.revokedAt === void 0);
+			const revokedCount = () => this.list(botSlug).filter((grant) => grant.workspaceId === workspaceId && grant.revokedAt !== void 0).length;
+			const generation = revokedCount();
+			const workspace = lookup().get(workspaceId);
+			if (!workspace || await workspace.status() !== "ok" || !isCurrentDirectory(workspace.path)) throw new WorkspaceGrantError("unavailable-workspace", "Workspace is unavailable");
+			const grant = {
+				id: existing?.id ?? createId(),
+				botSlug,
+				workspaceId,
+				workspacePath: workspace.path,
+				workspaceTitle: workspace.title,
+				createdAt: existing?.createdAt ?? now().toISOString(),
+				orchestratorWrite: true,
+				writeRevision: (existing?.writeRevision ?? 0) + (existing?.orchestratorWrite ? 0 : 1)
+			};
+			return {
+				grant,
+				commit(connection) {
+					if (!connection || !connection.isTransaction || database.read((db) => db !== connection)) throw new WorkspaceGrantError("invalid-grant", "Authorization requires the owning Channel transaction");
+					validate();
+					const current = read(botSlug, grant.id);
+					if (revokedCount() !== generation || existing && (!current || current.revokedAt || current.writeRevision !== existing.writeRevision) || lookup().get(workspaceId)?.path !== workspace.path || !isCurrentDirectory(workspace.path)) throw new WorkspaceGrantError("invalid-grant", "Workspace authority changed while authorization was pending");
+					if (existing) {
+						if (current?.workspacePath !== workspace.path) throw new WorkspaceGrantError("invalid-grant", "Workspace directory changed");
+						connection.prepare(`UPDATE workspace_grants SET orchestrator_write = 1,
+              write_revision = write_revision + CASE WHEN orchestrator_write = 0 THEN 1 ELSE 0 END
+              WHERE bot_slug = ? AND id = ? AND revoked_at IS NULL`).run(botSlug, grant.id);
+					} else {
+						if (connection.prepare("SELECT id FROM workspace_grants WHERE bot_slug = ? AND workspace_id = ? AND revoked_at IS NULL").get(botSlug, workspaceId)) throw new WorkspaceGrantError("invalid-grant", "Workspace was authorized concurrently; read back and retry");
+						connection.prepare(`INSERT INTO workspace_grants
+              (id, bot_slug, workspace_id, workspace_path, workspace_title, created_at, orchestrator_write, write_revision)
+              VALUES (?, ?, ?, ?, ?, ?, 1, 1)`).run(grant.id, botSlug, workspaceId, workspace.path, workspace.title, grant.createdAt);
+					}
+					return true;
+				}
+			};
+		},
 		availableWorkspaces() {
 			return lookup().list().map(({ id, path, title }) => ({
 				id,
@@ -42585,6 +42635,58 @@ const BOT_HARNESS_SCHEMA_PLAN = defineSchemaPlan([
         session_id TEXT NOT NULL, recorded_at TEXT NOT NULL,
         PRIMARY KEY (operation_key, kind)
       );
+    `);
+		}
+	},
+	{
+		generation: 103,
+		module: "usage",
+		description: "Record idle Orchestrator Session compactions for Bot activity",
+		migrate(database) {
+			database.exec(`
+      CREATE TABLE usage_idle_compactions (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        bot_slug TEXT NOT NULL,
+        at TEXT NOT NULL,
+        provider TEXT NOT NULL,
+        model TEXT NOT NULL,
+        idle_gap_ms INTEGER NOT NULL,
+        cache_lifetime_ms INTEGER NOT NULL,
+        cache_lifetime_source TEXT NOT NULL,
+        tokens_before INTEGER NOT NULL,
+        tokens_after INTEGER,
+        outcome TEXT NOT NULL CHECK (outcome IN ('compacted', 'nothing', 'failed')),
+        error TEXT,
+        input_tokens INTEGER,
+        cache_read_tokens INTEGER,
+        output_tokens INTEGER
+      );
+      CREATE INDEX usage_idle_compactions_bot_at ON usage_idle_compactions (bot_slug, at);
+    `);
+		}
+	},
+	{
+		generation: 104,
+		module: "tool-approval-rules",
+		description: "Remember one tool per authority scope and retain native ask for Full Access",
+		migrate(database) {
+			database.exec(`
+      CREATE TABLE tool_approval_rules_next (
+        id TEXT PRIMARY KEY, bot_slug TEXT NOT NULL,
+        role TEXT NOT NULL CHECK (role IN ('orchestrator', 'assignment')),
+        scope_key TEXT NOT NULL,
+        kind TEXT NOT NULL CHECK (kind IN ('exact', 'tool', 'all-opaque', 'secret-cli')),
+        tool_name TEXT NOT NULL, input TEXT NOT NULL, created_at TEXT NOT NULL,
+        active INTEGER NOT NULL CHECK (active IN (0, 1)), revoked_at TEXT, external_creator TEXT
+      );
+      INSERT INTO tool_approval_rules_next
+        SELECT * FROM tool_approval_rules;
+      DROP TABLE tool_approval_rules;
+      ALTER TABLE tool_approval_rules_next RENAME TO tool_approval_rules;
+      CREATE INDEX tool_approval_rules_lookup
+        ON tool_approval_rules (bot_slug, role, scope_key, active, revoked_at);
+      UPDATE assignments SET approval_policy = 'ask'
+        WHERE permission_mode = 'danger-full-access' AND approval_policy = 'never';
     `);
 		}
 	}
@@ -43063,6 +43165,2367 @@ function inspectMemoryRepository(options) {
 	}
 }
 //#endregion
+//#region node_modules/.pnpm/xmlchars@2.2.0/node_modules/xmlchars/xml/1.0/ed5.js
+var require_ed5 = /* @__PURE__ */ __commonJSMin(((exports) => {
+	/**
+	* Character classes and associated utilities for the 5th edition of XML 1.0.
+	*
+	* @author Louis-Dominique Dubeau
+	* @license MIT
+	* @copyright Louis-Dominique Dubeau
+	*/
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.CHAR = "	\n\r -퟿-�𐀀-􏿿";
+	exports.S = " 	\r\n";
+	exports.NAME_START_CHAR = ":A-Z_a-zÀ-ÖØ-öø-˿Ͱ-ͽͿ-῿‌‍⁰-↏Ⰰ-⿯、-퟿豈-﷏ﷰ-�𐀀-󯿿";
+	exports.NAME_CHAR = "-" + exports.NAME_START_CHAR + ".0-9·̀-ͯ‿-⁀";
+	exports.CHAR_RE = new RegExp("^[" + exports.CHAR + "]$", "u");
+	exports.S_RE = new RegExp("^[" + exports.S + "]+$", "u");
+	exports.NAME_START_CHAR_RE = new RegExp("^[" + exports.NAME_START_CHAR + "]$", "u");
+	exports.NAME_CHAR_RE = new RegExp("^[" + exports.NAME_CHAR + "]$", "u");
+	exports.NAME_RE = new RegExp("^[" + exports.NAME_START_CHAR + "][" + exports.NAME_CHAR + "]*$", "u");
+	exports.NMTOKEN_RE = new RegExp("^[" + exports.NAME_CHAR + "]+$", "u");
+	var TAB = 9;
+	var NL = 10;
+	var CR = 13;
+	var SPACE = 32;
+	/** All characters in the ``S`` production. */
+	exports.S_LIST = [
+		SPACE,
+		NL,
+		CR,
+		TAB
+	];
+	/**
+	* Determines whether a codepoint matches the ``CHAR`` production.
+	*
+	* @param c The code point.
+	*
+	* @returns ``true`` if the codepoint matches ``CHAR``.
+	*/
+	function isChar(c) {
+		return c >= SPACE && c <= 55295 || c === NL || c === CR || c === TAB || c >= 57344 && c <= 65533 || c >= 65536 && c <= 1114111;
+	}
+	exports.isChar = isChar;
+	/**
+	* Determines whether a codepoint matches the ``S`` (space) production.
+	*
+	* @param c The code point.
+	*
+	* @returns ``true`` if the codepoint matches ``S``.
+	*/
+	function isS(c) {
+		return c === SPACE || c === NL || c === CR || c === TAB;
+	}
+	exports.isS = isS;
+	/**
+	* Determines whether a codepoint matches the ``NAME_START_CHAR`` production.
+	*
+	* @param c The code point.
+	*
+	* @returns ``true`` if the codepoint matches ``NAME_START_CHAR``.
+	*/
+	function isNameStartChar(c) {
+		return c >= 65 && c <= 90 || c >= 97 && c <= 122 || c === 58 || c === 95 || c === 8204 || c === 8205 || c >= 192 && c <= 214 || c >= 216 && c <= 246 || c >= 248 && c <= 767 || c >= 880 && c <= 893 || c >= 895 && c <= 8191 || c >= 8304 && c <= 8591 || c >= 11264 && c <= 12271 || c >= 12289 && c <= 55295 || c >= 63744 && c <= 64975 || c >= 65008 && c <= 65533 || c >= 65536 && c <= 983039;
+	}
+	exports.isNameStartChar = isNameStartChar;
+	/**
+	* Determines whether a codepoint matches the ``NAME_CHAR`` production.
+	*
+	* @param c The code point.
+	*
+	* @returns ``true`` if the codepoint matches ``NAME_CHAR``.
+	*/
+	function isNameChar(c) {
+		return isNameStartChar(c) || c >= 48 && c <= 57 || c === 45 || c === 46 || c === 183 || c >= 768 && c <= 879 || c >= 8255 && c <= 8256;
+	}
+	exports.isNameChar = isNameChar;
+}));
+//#endregion
+//#region node_modules/.pnpm/xmlchars@2.2.0/node_modules/xmlchars/xml/1.1/ed2.js
+var require_ed2 = /* @__PURE__ */ __commonJSMin(((exports) => {
+	/**
+	* Character classes and associated utilities for the 2nd edition of XML 1.1.
+	*
+	* @author Louis-Dominique Dubeau
+	* @license MIT
+	* @copyright Louis-Dominique Dubeau
+	*/
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.CHAR = "
-퟿-�𐀀-􏿿";
+	exports.RESTRICTED_CHAR = "
-\b\v\f--„†-Ÿ";
+	exports.S = " 	\r\n";
+	exports.NAME_START_CHAR = ":A-Z_a-zÀ-ÖØ-öø-˿Ͱ-ͽͿ-῿‌‍⁰-↏Ⰰ-⿯、-퟿豈-﷏ﷰ-�𐀀-󯿿";
+	exports.NAME_CHAR = "-" + exports.NAME_START_CHAR + ".0-9·̀-ͯ‿-⁀";
+	exports.CHAR_RE = new RegExp("^[" + exports.CHAR + "]$", "u");
+	exports.RESTRICTED_CHAR_RE = new RegExp("^[" + exports.RESTRICTED_CHAR + "]$", "u");
+	exports.S_RE = new RegExp("^[" + exports.S + "]+$", "u");
+	exports.NAME_START_CHAR_RE = new RegExp("^[" + exports.NAME_START_CHAR + "]$", "u");
+	exports.NAME_CHAR_RE = new RegExp("^[" + exports.NAME_CHAR + "]$", "u");
+	exports.NAME_RE = new RegExp("^[" + exports.NAME_START_CHAR + "][" + exports.NAME_CHAR + "]*$", "u");
+	exports.NMTOKEN_RE = new RegExp("^[" + exports.NAME_CHAR + "]+$", "u");
+	var TAB = 9;
+	var NL = 10;
+	var CR = 13;
+	var SPACE = 32;
+	/** All characters in the ``S`` production. */
+	exports.S_LIST = [
+		SPACE,
+		NL,
+		CR,
+		TAB
+	];
+	/**
+	* Determines whether a codepoint matches the ``CHAR`` production.
+	*
+	* @param c The code point.
+	*
+	* @returns ``true`` if the codepoint matches ``CHAR``.
+	*/
+	function isChar(c) {
+		return c >= 1 && c <= 55295 || c >= 57344 && c <= 65533 || c >= 65536 && c <= 1114111;
+	}
+	exports.isChar = isChar;
+	/**
+	* Determines whether a codepoint matches the ``RESTRICTED_CHAR`` production.
+	*
+	* @param c The code point.
+	*
+	* @returns ``true`` if the codepoint matches ``RESTRICTED_CHAR``.
+	*/
+	function isRestrictedChar(c) {
+		return c >= 1 && c <= 8 || c === 11 || c === 12 || c >= 14 && c <= 31 || c >= 127 && c <= 132 || c >= 134 && c <= 159;
+	}
+	exports.isRestrictedChar = isRestrictedChar;
+	/**
+	* Determines whether a codepoint matches the ``CHAR`` production and does not
+	* match the ``RESTRICTED_CHAR`` production. ``isCharAndNotRestricted(x)`` is
+	* equivalent to ``isChar(x) && !isRestrictedChar(x)``. This function is faster
+	* than running the two-call equivalent.
+	*
+	* @param c The code point.
+	*
+	* @returns ``true`` if the codepoint matches ``CHAR`` and does not match
+	* ``RESTRICTED_CHAR``.
+	*/
+	function isCharAndNotRestricted(c) {
+		return c === 9 || c === 10 || c === 13 || c > 31 && c < 127 || c === 133 || c > 159 && c <= 55295 || c >= 57344 && c <= 65533 || c >= 65536 && c <= 1114111;
+	}
+	exports.isCharAndNotRestricted = isCharAndNotRestricted;
+	/**
+	* Determines whether a codepoint matches the ``S`` (space) production.
+	*
+	* @param c The code point.
+	*
+	* @returns ``true`` if the codepoint matches ``S``.
+	*/
+	function isS(c) {
+		return c === SPACE || c === NL || c === CR || c === TAB;
+	}
+	exports.isS = isS;
+	/**
+	* Determines whether a codepoint matches the ``NAME_START_CHAR`` production.
+	*
+	* @param c The code point.
+	*
+	* @returns ``true`` if the codepoint matches ``NAME_START_CHAR``.
+	*/
+	function isNameStartChar(c) {
+		return c >= 65 && c <= 90 || c >= 97 && c <= 122 || c === 58 || c === 95 || c === 8204 || c === 8205 || c >= 192 && c <= 214 || c >= 216 && c <= 246 || c >= 248 && c <= 767 || c >= 880 && c <= 893 || c >= 895 && c <= 8191 || c >= 8304 && c <= 8591 || c >= 11264 && c <= 12271 || c >= 12289 && c <= 55295 || c >= 63744 && c <= 64975 || c >= 65008 && c <= 65533 || c >= 65536 && c <= 983039;
+	}
+	exports.isNameStartChar = isNameStartChar;
+	/**
+	* Determines whether a codepoint matches the ``NAME_CHAR`` production.
+	*
+	* @param c The code point.
+	*
+	* @returns ``true`` if the codepoint matches ``NAME_CHAR``.
+	*/
+	function isNameChar(c) {
+		return isNameStartChar(c) || c >= 48 && c <= 57 || c === 45 || c === 46 || c === 183 || c >= 768 && c <= 879 || c >= 8255 && c <= 8256;
+	}
+	exports.isNameChar = isNameChar;
+}));
+//#endregion
+//#region node_modules/.pnpm/xmlchars@2.2.0/node_modules/xmlchars/xmlns/1.0/ed3.js
+var require_ed3 = /* @__PURE__ */ __commonJSMin(((exports) => {
+	/**
+	* Character class utilities for XML NS 1.0 edition 3.
+	*
+	* @author Louis-Dominique Dubeau
+	* @license MIT
+	* @copyright Louis-Dominique Dubeau
+	*/
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.NC_NAME_START_CHAR = "A-Z_a-zÀ-ÖØ-öø-˿Ͱ-ͽͿ-῿‌-‍⁰-↏Ⰰ-⿯、-퟿豈-﷏ﷰ-�𐀀-󯿿";
+	exports.NC_NAME_CHAR = "-" + exports.NC_NAME_START_CHAR + ".0-9·̀-ͯ‿-⁀";
+	exports.NC_NAME_START_CHAR_RE = new RegExp("^[" + exports.NC_NAME_START_CHAR + "]$", "u");
+	exports.NC_NAME_CHAR_RE = new RegExp("^[" + exports.NC_NAME_CHAR + "]$", "u");
+	exports.NC_NAME_RE = new RegExp("^[" + exports.NC_NAME_START_CHAR + "][" + exports.NC_NAME_CHAR + "]*$", "u");
+	/**
+	* Determines whether a codepoint matches [[NC_NAME_START_CHAR]].
+	*
+	* @param c The code point.
+	*
+	* @returns ``true`` if the codepoint matches.
+	*/
+	function isNCNameStartChar(c) {
+		return c >= 65 && c <= 90 || c === 95 || c >= 97 && c <= 122 || c >= 192 && c <= 214 || c >= 216 && c <= 246 || c >= 248 && c <= 767 || c >= 880 && c <= 893 || c >= 895 && c <= 8191 || c >= 8204 && c <= 8205 || c >= 8304 && c <= 8591 || c >= 11264 && c <= 12271 || c >= 12289 && c <= 55295 || c >= 63744 && c <= 64975 || c >= 65008 && c <= 65533 || c >= 65536 && c <= 983039;
+	}
+	exports.isNCNameStartChar = isNCNameStartChar;
+	/**
+	* Determines whether a codepoint matches [[NC_NAME_CHAR]].
+	*
+	* @param c The code point.
+	*
+	* @returns ``true`` if the codepoint matches.
+	*/
+	function isNCNameChar(c) {
+		return isNCNameStartChar(c) || c === 45 || c === 46 || c >= 48 && c <= 57 || c === 183 || c >= 768 && c <= 879 || c >= 8255 && c <= 8256;
+	}
+	exports.isNCNameChar = isNCNameChar;
+}));
+//#endregion
+//#region packages/core/src/media/image-format.ts
+var import_saxes = (/* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.SaxesParser = exports.EVENTS = void 0;
+	const ed5 = require_ed5();
+	const ed2 = require_ed2();
+	const NSed3 = require_ed3();
+	var isS = ed5.isS;
+	var isChar10 = ed5.isChar;
+	var isNameStartChar = ed5.isNameStartChar;
+	var isNameChar = ed5.isNameChar;
+	var S_LIST = ed5.S_LIST;
+	var NAME_RE = ed5.NAME_RE;
+	var isChar11 = ed2.isChar;
+	var isNCNameStartChar = NSed3.isNCNameStartChar;
+	var isNCNameChar = NSed3.isNCNameChar;
+	var NC_NAME_RE = NSed3.NC_NAME_RE;
+	const XML_NAMESPACE = "http://www.w3.org/XML/1998/namespace";
+	const XMLNS_NAMESPACE = "http://www.w3.org/2000/xmlns/";
+	const rootNS = {
+		__proto__: null,
+		xml: XML_NAMESPACE,
+		xmlns: XMLNS_NAMESPACE
+	};
+	const XML_ENTITIES = {
+		__proto__: null,
+		amp: "&",
+		gt: ">",
+		lt: "<",
+		quot: "\"",
+		apos: "'"
+	};
+	const EOC = -1;
+	const NL_LIKE = -2;
+	const S_BEGIN = 0;
+	const S_BEGIN_WHITESPACE = 1;
+	const S_DOCTYPE = 2;
+	const S_DOCTYPE_QUOTE = 3;
+	const S_DTD = 4;
+	const S_DTD_QUOTED = 5;
+	const S_DTD_OPEN_WAKA = 6;
+	const S_DTD_OPEN_WAKA_BANG = 7;
+	const S_DTD_COMMENT = 8;
+	const S_DTD_COMMENT_ENDING = 9;
+	const S_DTD_COMMENT_ENDED = 10;
+	const S_DTD_PI = 11;
+	const S_DTD_PI_ENDING = 12;
+	const S_TEXT = 13;
+	const S_ENTITY = 14;
+	const S_OPEN_WAKA = 15;
+	const S_OPEN_WAKA_BANG = 16;
+	const S_COMMENT = 17;
+	const S_COMMENT_ENDING = 18;
+	const S_COMMENT_ENDED = 19;
+	const S_CDATA = 20;
+	const S_CDATA_ENDING = 21;
+	const S_CDATA_ENDING_2 = 22;
+	const S_PI_FIRST_CHAR = 23;
+	const S_PI_REST = 24;
+	const S_PI_BODY = 25;
+	const S_PI_ENDING = 26;
+	const S_XML_DECL_NAME_START = 27;
+	const S_XML_DECL_NAME = 28;
+	const S_XML_DECL_EQ = 29;
+	const S_XML_DECL_VALUE_START = 30;
+	const S_XML_DECL_VALUE = 31;
+	const S_XML_DECL_SEPARATOR = 32;
+	const S_XML_DECL_ENDING = 33;
+	const S_OPEN_TAG = 34;
+	const S_OPEN_TAG_SLASH = 35;
+	const S_ATTRIB = 36;
+	const S_ATTRIB_NAME = 37;
+	const S_ATTRIB_NAME_SAW_WHITE = 38;
+	const S_ATTRIB_VALUE = 39;
+	const S_ATTRIB_VALUE_QUOTED = 40;
+	const S_ATTRIB_VALUE_CLOSED = 41;
+	const S_ATTRIB_VALUE_UNQUOTED = 42;
+	const S_CLOSE_TAG = 43;
+	const S_CLOSE_TAG_SAW_WHITE = 44;
+	const TAB = 9;
+	const NL = 10;
+	const CR = 13;
+	const SPACE = 32;
+	const BANG = 33;
+	const DQUOTE = 34;
+	const AMP = 38;
+	const SQUOTE = 39;
+	const MINUS = 45;
+	const FORWARD_SLASH = 47;
+	const SEMICOLON = 59;
+	const LESS = 60;
+	const EQUAL = 61;
+	const GREATER = 62;
+	const QUESTION = 63;
+	const OPEN_BRACKET = 91;
+	const CLOSE_BRACKET = 93;
+	const NEL = 133;
+	const LS = 8232;
+	const isQuote = (c) => c === DQUOTE || c === SQUOTE;
+	const QUOTES = [DQUOTE, SQUOTE];
+	const DOCTYPE_TERMINATOR = [
+		...QUOTES,
+		OPEN_BRACKET,
+		GREATER
+	];
+	const DTD_TERMINATOR = [
+		...QUOTES,
+		LESS,
+		CLOSE_BRACKET
+	];
+	const XML_DECL_NAME_TERMINATOR = [
+		EQUAL,
+		QUESTION,
+		...S_LIST
+	];
+	const ATTRIB_VALUE_UNQUOTED_TERMINATOR = [
+		...S_LIST,
+		GREATER,
+		AMP,
+		LESS
+	];
+	function nsPairCheck(parser, prefix, uri) {
+		switch (prefix) {
+			case "xml":
+				if (uri !== XML_NAMESPACE) parser.fail(`xml prefix must be bound to ${XML_NAMESPACE}.`);
+				break;
+			case "xmlns": if (uri !== XMLNS_NAMESPACE) parser.fail(`xmlns prefix must be bound to ${XMLNS_NAMESPACE}.`);
+		}
+		switch (uri) {
+			case XMLNS_NAMESPACE:
+				parser.fail(prefix === "" ? `the default namespace may not be set to ${uri}.` : `may not assign a prefix (even "xmlns") to the URI \
+${XMLNS_NAMESPACE}.`);
+				break;
+			case XML_NAMESPACE: switch (prefix) {
+				case "xml": break;
+				case "":
+					parser.fail(`the default namespace may not be set to ${uri}.`);
+					break;
+				default: parser.fail("may not assign the xml namespace to another prefix.");
+			}
+		}
+	}
+	function nsMappingCheck(parser, mapping) {
+		for (const local of Object.keys(mapping)) nsPairCheck(parser, local, mapping[local]);
+	}
+	const isNCName = (name) => NC_NAME_RE.test(name);
+	const isName = (name) => NAME_RE.test(name);
+	const FORBIDDEN_START = 0;
+	const FORBIDDEN_BRACKET = 1;
+	const FORBIDDEN_BRACKET_BRACKET = 2;
+	/**
+	* The list of supported events.
+	*/
+	exports.EVENTS = [
+		"xmldecl",
+		"text",
+		"processinginstruction",
+		"doctype",
+		"comment",
+		"opentagstart",
+		"attribute",
+		"opentag",
+		"closetag",
+		"cdata",
+		"error",
+		"end",
+		"ready"
+	];
+	const EVENT_NAME_TO_HANDLER_NAME = {
+		xmldecl: "xmldeclHandler",
+		text: "textHandler",
+		processinginstruction: "piHandler",
+		doctype: "doctypeHandler",
+		comment: "commentHandler",
+		opentagstart: "openTagStartHandler",
+		attribute: "attributeHandler",
+		opentag: "openTagHandler",
+		closetag: "closeTagHandler",
+		cdata: "cdataHandler",
+		error: "errorHandler",
+		end: "endHandler",
+		ready: "readyHandler"
+	};
+	var SaxesParser = class {
+		/**
+		* @param opt The parser options.
+		*/
+		constructor(opt) {
+			this.opt = opt !== null && opt !== void 0 ? opt : {};
+			this.fragmentOpt = !!this.opt.fragment;
+			const xmlnsOpt = this.xmlnsOpt = !!this.opt.xmlns;
+			this.trackPosition = this.opt.position !== false;
+			this.fileName = this.opt.fileName;
+			if (xmlnsOpt) {
+				this.nameStartCheck = isNCNameStartChar;
+				this.nameCheck = isNCNameChar;
+				this.isName = isNCName;
+				this.processAttribs = this.processAttribsNS;
+				this.pushAttrib = this.pushAttribNS;
+				this.ns = Object.assign({ __proto__: null }, rootNS);
+				const additional = this.opt.additionalNamespaces;
+				if (additional != null) {
+					nsMappingCheck(this, additional);
+					Object.assign(this.ns, additional);
+				}
+			} else {
+				this.nameStartCheck = isNameStartChar;
+				this.nameCheck = isNameChar;
+				this.isName = isName;
+				this.processAttribs = this.processAttribsPlain;
+				this.pushAttrib = this.pushAttribPlain;
+			}
+			this.stateTable = [
+				this.sBegin,
+				this.sBeginWhitespace,
+				this.sDoctype,
+				this.sDoctypeQuote,
+				this.sDTD,
+				this.sDTDQuoted,
+				this.sDTDOpenWaka,
+				this.sDTDOpenWakaBang,
+				this.sDTDComment,
+				this.sDTDCommentEnding,
+				this.sDTDCommentEnded,
+				this.sDTDPI,
+				this.sDTDPIEnding,
+				this.sText,
+				this.sEntity,
+				this.sOpenWaka,
+				this.sOpenWakaBang,
+				this.sComment,
+				this.sCommentEnding,
+				this.sCommentEnded,
+				this.sCData,
+				this.sCDataEnding,
+				this.sCDataEnding2,
+				this.sPIFirstChar,
+				this.sPIRest,
+				this.sPIBody,
+				this.sPIEnding,
+				this.sXMLDeclNameStart,
+				this.sXMLDeclName,
+				this.sXMLDeclEq,
+				this.sXMLDeclValueStart,
+				this.sXMLDeclValue,
+				this.sXMLDeclSeparator,
+				this.sXMLDeclEnding,
+				this.sOpenTag,
+				this.sOpenTagSlash,
+				this.sAttrib,
+				this.sAttribName,
+				this.sAttribNameSawWhite,
+				this.sAttribValue,
+				this.sAttribValueQuoted,
+				this.sAttribValueClosed,
+				this.sAttribValueUnquoted,
+				this.sCloseTag,
+				this.sCloseTagSawWhite
+			];
+			this._init();
+		}
+		/**
+		* Indicates whether or not the parser is closed. If ``true``, wait for
+		* the ``ready`` event to write again.
+		*/
+		get closed() {
+			return this._closed;
+		}
+		_init() {
+			var _a;
+			this.openWakaBang = "";
+			this.text = "";
+			this.name = "";
+			this.piTarget = "";
+			this.entity = "";
+			this.q = null;
+			this.tags = [];
+			this.tag = null;
+			this.topNS = null;
+			this.chunk = "";
+			this.chunkPosition = 0;
+			this.i = 0;
+			this.prevI = 0;
+			this.carriedFromPrevious = void 0;
+			this.forbiddenState = FORBIDDEN_START;
+			this.attribList = [];
+			const { fragmentOpt } = this;
+			this.state = fragmentOpt ? S_TEXT : S_BEGIN;
+			this.reportedTextBeforeRoot = this.reportedTextAfterRoot = this.closedRoot = this.sawRoot = fragmentOpt;
+			this.xmlDeclPossible = !fragmentOpt;
+			this.xmlDeclExpects = ["version"];
+			this.entityReturnState = void 0;
+			let { defaultXMLVersion } = this.opt;
+			if (defaultXMLVersion === void 0) {
+				if (this.opt.forceXMLVersion === true) throw new Error("forceXMLVersion set but defaultXMLVersion is not set");
+				defaultXMLVersion = "1.0";
+			}
+			this.setXMLVersion(defaultXMLVersion);
+			this.positionAtNewLine = 0;
+			this.doctype = false;
+			this._closed = false;
+			this.xmlDecl = {
+				version: void 0,
+				encoding: void 0,
+				standalone: void 0
+			};
+			this.line = 1;
+			this.column = 0;
+			this.ENTITIES = Object.create(XML_ENTITIES);
+			(_a = this.readyHandler) === null || _a === void 0 || _a.call(this);
+		}
+		/**
+		* The stream position the parser is currently looking at. This field is
+		* zero-based.
+		*
+		* This field is not based on counting Unicode characters but is to be
+		* interpreted as a plain index into a JavaScript string.
+		*/
+		get position() {
+			return this.chunkPosition + this.i;
+		}
+		/**
+		* The column number of the next character to be read by the parser.  *
+		* This field is zero-based. (The first column in a line is 0.)
+		*
+		* This field reports the index at which the next character would be in the
+		* line if the line were represented as a JavaScript string.  Note that this
+		* *can* be different to a count based on the number of *Unicode characters*
+		* due to how JavaScript handles astral plane characters.
+		*
+		* See [[column]] for a number that corresponds to a count of Unicode
+		* characters.
+		*/
+		get columnIndex() {
+			return this.position - this.positionAtNewLine;
+		}
+		/**
+		* Set an event listener on an event. The parser supports one handler per
+		* event type. If you try to set an event handler over an existing handler,
+		* the old handler is silently overwritten.
+		*
+		* @param name The event to listen to.
+		*
+		* @param handler The handler to set.
+		*/
+		on(name, handler) {
+			this[EVENT_NAME_TO_HANDLER_NAME[name]] = handler;
+		}
+		/**
+		* Unset an event handler.
+		*
+		* @parma name The event to stop listening to.
+		*/
+		off(name) {
+			this[EVENT_NAME_TO_HANDLER_NAME[name]] = void 0;
+		}
+		/**
+		* Make an error object. The error object will have a message that contains
+		* the ``fileName`` option passed at the creation of the parser. If position
+		* tracking was turned on, it will also have line and column number
+		* information.
+		*
+		* @param message The message describing the error to report.
+		*
+		* @returns An error object with a properly formatted message.
+		*/
+		makeError(message) {
+			var _a;
+			let msg = (_a = this.fileName) !== null && _a !== void 0 ? _a : "";
+			if (this.trackPosition) {
+				if (msg.length > 0) msg += ":";
+				msg += `${this.line}:${this.column}`;
+			}
+			if (msg.length > 0) msg += ": ";
+			return new Error(msg + message);
+		}
+		/**
+		* Report a parsing error. This method is made public so that client code may
+		* check for issues that are outside the scope of this project and can report
+		* errors.
+		*
+		* @param message The error to report.
+		*
+		* @returns this
+		*/
+		fail(message) {
+			const err = this.makeError(message);
+			const handler = this.errorHandler;
+			if (handler === void 0) throw err;
+			else handler(err);
+			return this;
+		}
+		/**
+		* Write a XML data to the parser.
+		*
+		* @param chunk The XML data to write.
+		*
+		* @returns this
+		*/
+		write(chunk) {
+			if (this.closed) return this.fail("cannot write after close; assign an onready handler.");
+			let end = false;
+			if (chunk === null) {
+				end = true;
+				chunk = "";
+			} else if (typeof chunk === "object") chunk = chunk.toString();
+			if (this.carriedFromPrevious !== void 0) {
+				chunk = `${this.carriedFromPrevious}${chunk}`;
+				this.carriedFromPrevious = void 0;
+			}
+			let limit = chunk.length;
+			const lastCode = chunk.charCodeAt(limit - 1);
+			if (!end && (lastCode === CR || lastCode >= 55296 && lastCode <= 56319)) {
+				this.carriedFromPrevious = chunk[limit - 1];
+				limit--;
+				chunk = chunk.slice(0, limit);
+			}
+			const { stateTable } = this;
+			this.chunk = chunk;
+			this.i = 0;
+			while (this.i < limit) stateTable[this.state].call(this);
+			this.chunkPosition += limit;
+			return end ? this.end() : this;
+		}
+		/**
+		* Close the current stream. Perform final well-formedness checks and reset
+		* the parser tstate.
+		*
+		* @returns this
+		*/
+		close() {
+			return this.write(null);
+		}
+		/**
+		* Get a single code point out of the current chunk. This updates the current
+		* position if we do position tracking.
+		*
+		* This is the algorithm to use for XML 1.0.
+		*
+		* @returns The character read.
+		*/
+		getCode10() {
+			const { chunk, i } = this;
+			this.prevI = i;
+			this.i = i + 1;
+			if (i >= chunk.length) return EOC;
+			const code = chunk.charCodeAt(i);
+			this.column++;
+			if (code < 55296) {
+				if (code >= SPACE || code === TAB) return code;
+				switch (code) {
+					case NL:
+						this.line++;
+						this.column = 0;
+						this.positionAtNewLine = this.position;
+						return NL;
+					case CR:
+						if (chunk.charCodeAt(i + 1) === NL) this.i = i + 2;
+						this.line++;
+						this.column = 0;
+						this.positionAtNewLine = this.position;
+						return NL_LIKE;
+					default:
+						this.fail("disallowed character.");
+						return code;
+				}
+			}
+			if (code > 56319) {
+				if (!(code >= 57344 && code <= 65533)) this.fail("disallowed character.");
+				return code;
+			}
+			const final = 65536 + (code - 55296) * 1024 + (chunk.charCodeAt(i + 1) - 56320);
+			this.i = i + 2;
+			if (final > 1114111) this.fail("disallowed character.");
+			return final;
+		}
+		/**
+		* Get a single code point out of the current chunk. This updates the current
+		* position if we do position tracking.
+		*
+		* This is the algorithm to use for XML 1.1.
+		*
+		* @returns {number} The character read.
+		*/
+		getCode11() {
+			const { chunk, i } = this;
+			this.prevI = i;
+			this.i = i + 1;
+			if (i >= chunk.length) return EOC;
+			const code = chunk.charCodeAt(i);
+			this.column++;
+			if (code < 55296) {
+				if (code > 31 && code < 127 || code > 159 && code !== LS || code === TAB) return code;
+				switch (code) {
+					case NL:
+						this.line++;
+						this.column = 0;
+						this.positionAtNewLine = this.position;
+						return NL;
+					case CR: {
+						const next = chunk.charCodeAt(i + 1);
+						if (next === NL || next === NEL) this.i = i + 2;
+					}
+					case NEL:
+					case LS:
+						this.line++;
+						this.column = 0;
+						this.positionAtNewLine = this.position;
+						return NL_LIKE;
+					default:
+						this.fail("disallowed character.");
+						return code;
+				}
+			}
+			if (code > 56319) {
+				if (!(code >= 57344 && code <= 65533)) this.fail("disallowed character.");
+				return code;
+			}
+			const final = 65536 + (code - 55296) * 1024 + (chunk.charCodeAt(i + 1) - 56320);
+			this.i = i + 2;
+			if (final > 1114111) this.fail("disallowed character.");
+			return final;
+		}
+		/**
+		* Like ``getCode`` but with the return value normalized so that ``NL`` is
+		* returned for ``NL_LIKE``.
+		*/
+		getCodeNorm() {
+			const c = this.getCode();
+			return c === NL_LIKE ? NL : c;
+		}
+		unget() {
+			this.i = this.prevI;
+			this.column--;
+		}
+		/**
+		* Capture characters into a buffer until encountering one of a set of
+		* characters.
+		*
+		* @param chars An array of codepoints. Encountering a character in the array
+		* ends the capture. (``chars`` may safely contain ``NL``.)
+		*
+		* @return The character code that made the capture end, or ``EOC`` if we hit
+		* the end of the chunk. The return value cannot be NL_LIKE: NL is returned
+		* instead.
+		*/
+		captureTo(chars) {
+			let { i: start } = this;
+			const { chunk } = this;
+			while (true) {
+				const c = this.getCode();
+				const isNLLike = c === NL_LIKE;
+				const final = isNLLike ? NL : c;
+				if (final === EOC || chars.includes(final)) {
+					this.text += chunk.slice(start, this.prevI);
+					return final;
+				}
+				if (isNLLike) {
+					this.text += `${chunk.slice(start, this.prevI)}\n`;
+					start = this.i;
+				}
+			}
+		}
+		/**
+		* Capture characters into a buffer until encountering a character.
+		*
+		* @param char The codepoint that ends the capture. **NOTE ``char`` MAY NOT
+		* CONTAIN ``NL``.** Passing ``NL`` will result in buggy behavior.
+		*
+		* @return ``true`` if we ran into the character. Otherwise, we ran into the
+		* end of the current chunk.
+		*/
+		captureToChar(char) {
+			let { i: start } = this;
+			const { chunk } = this;
+			while (true) {
+				let c = this.getCode();
+				switch (c) {
+					case NL_LIKE:
+						this.text += `${chunk.slice(start, this.prevI)}\n`;
+						start = this.i;
+						c = NL;
+						break;
+					case EOC:
+						this.text += chunk.slice(start);
+						return false;
+				}
+				if (c === char) {
+					this.text += chunk.slice(start, this.prevI);
+					return true;
+				}
+			}
+		}
+		/**
+		* Capture characters that satisfy ``isNameChar`` into the ``name`` field of
+		* this parser.
+		*
+		* @return The character code that made the test fail, or ``EOC`` if we hit
+		* the end of the chunk. The return value cannot be NL_LIKE: NL is returned
+		* instead.
+		*/
+		captureNameChars() {
+			const { chunk, i: start } = this;
+			while (true) {
+				const c = this.getCode();
+				if (c === EOC) {
+					this.name += chunk.slice(start);
+					return EOC;
+				}
+				if (!isNameChar(c)) {
+					this.name += chunk.slice(start, this.prevI);
+					return c === NL_LIKE ? NL : c;
+				}
+			}
+		}
+		/**
+		* Skip white spaces.
+		*
+		* @return The character that ended the skip, or ``EOC`` if we hit
+		* the end of the chunk. The return value cannot be NL_LIKE: NL is returned
+		* instead.
+		*/
+		skipSpaces() {
+			while (true) {
+				const c = this.getCodeNorm();
+				if (c === EOC || !isS(c)) return c;
+			}
+		}
+		setXMLVersion(version) {
+			this.currentXMLVersion = version;
+			if (version === "1.0") {
+				this.isChar = isChar10;
+				this.getCode = this.getCode10;
+			} else {
+				this.isChar = isChar11;
+				this.getCode = this.getCode11;
+			}
+		}
+		sBegin() {
+			if (this.chunk.charCodeAt(0) === 65279) {
+				this.i++;
+				this.column++;
+			}
+			this.state = S_BEGIN_WHITESPACE;
+		}
+		sBeginWhitespace() {
+			const iBefore = this.i;
+			const c = this.skipSpaces();
+			if (this.prevI !== iBefore) this.xmlDeclPossible = false;
+			switch (c) {
+				case LESS:
+					this.state = S_OPEN_WAKA;
+					if (this.text.length !== 0) throw new Error("no-empty text at start");
+					break;
+				case EOC: break;
+				default:
+					this.unget();
+					this.state = S_TEXT;
+					this.xmlDeclPossible = false;
+			}
+		}
+		sDoctype() {
+			var _a;
+			const c = this.captureTo(DOCTYPE_TERMINATOR);
+			switch (c) {
+				case GREATER:
+					(_a = this.doctypeHandler) === null || _a === void 0 || _a.call(this, this.text);
+					this.text = "";
+					this.state = S_TEXT;
+					this.doctype = true;
+					break;
+				case EOC: break;
+				default:
+					this.text += String.fromCodePoint(c);
+					if (c === OPEN_BRACKET) this.state = S_DTD;
+					else if (isQuote(c)) {
+						this.state = S_DOCTYPE_QUOTE;
+						this.q = c;
+					}
+			}
+		}
+		sDoctypeQuote() {
+			const q = this.q;
+			if (this.captureToChar(q)) {
+				this.text += String.fromCodePoint(q);
+				this.q = null;
+				this.state = S_DOCTYPE;
+			}
+		}
+		sDTD() {
+			const c = this.captureTo(DTD_TERMINATOR);
+			if (c === EOC) return;
+			this.text += String.fromCodePoint(c);
+			if (c === CLOSE_BRACKET) this.state = S_DOCTYPE;
+			else if (c === LESS) this.state = S_DTD_OPEN_WAKA;
+			else if (isQuote(c)) {
+				this.state = S_DTD_QUOTED;
+				this.q = c;
+			}
+		}
+		sDTDQuoted() {
+			const q = this.q;
+			if (this.captureToChar(q)) {
+				this.text += String.fromCodePoint(q);
+				this.state = S_DTD;
+				this.q = null;
+			}
+		}
+		sDTDOpenWaka() {
+			const c = this.getCodeNorm();
+			this.text += String.fromCodePoint(c);
+			switch (c) {
+				case BANG:
+					this.state = S_DTD_OPEN_WAKA_BANG;
+					this.openWakaBang = "";
+					break;
+				case QUESTION:
+					this.state = S_DTD_PI;
+					break;
+				default: this.state = S_DTD;
+			}
+		}
+		sDTDOpenWakaBang() {
+			const char = String.fromCodePoint(this.getCodeNorm());
+			const owb = this.openWakaBang += char;
+			this.text += char;
+			if (owb !== "-") {
+				this.state = owb === "--" ? S_DTD_COMMENT : S_DTD;
+				this.openWakaBang = "";
+			}
+		}
+		sDTDComment() {
+			if (this.captureToChar(MINUS)) {
+				this.text += "-";
+				this.state = S_DTD_COMMENT_ENDING;
+			}
+		}
+		sDTDCommentEnding() {
+			const c = this.getCodeNorm();
+			this.text += String.fromCodePoint(c);
+			this.state = c === MINUS ? S_DTD_COMMENT_ENDED : S_DTD_COMMENT;
+		}
+		sDTDCommentEnded() {
+			const c = this.getCodeNorm();
+			this.text += String.fromCodePoint(c);
+			if (c === GREATER) this.state = S_DTD;
+			else {
+				this.fail("malformed comment.");
+				this.state = S_DTD_COMMENT;
+			}
+		}
+		sDTDPI() {
+			if (this.captureToChar(QUESTION)) {
+				this.text += "?";
+				this.state = S_DTD_PI_ENDING;
+			}
+		}
+		sDTDPIEnding() {
+			const c = this.getCodeNorm();
+			this.text += String.fromCodePoint(c);
+			if (c === GREATER) this.state = S_DTD;
+		}
+		sText() {
+			if (this.tags.length !== 0) this.handleTextInRoot();
+			else this.handleTextOutsideRoot();
+		}
+		sEntity() {
+			let { i: start } = this;
+			const { chunk } = this;
+			loop: while (true) switch (this.getCode()) {
+				case NL_LIKE:
+					this.entity += `${chunk.slice(start, this.prevI)}\n`;
+					start = this.i;
+					break;
+				case SEMICOLON: {
+					const { entityReturnState } = this;
+					const entity = this.entity + chunk.slice(start, this.prevI);
+					this.state = entityReturnState;
+					let parsed;
+					if (entity === "") {
+						this.fail("empty entity name.");
+						parsed = "&;";
+					} else {
+						parsed = this.parseEntity(entity);
+						this.entity = "";
+					}
+					if (entityReturnState !== S_TEXT || this.textHandler !== void 0) this.text += parsed;
+					break loop;
+				}
+				case EOC:
+					this.entity += chunk.slice(start);
+					break loop;
+			}
+		}
+		sOpenWaka() {
+			const c = this.getCode();
+			if (isNameStartChar(c)) {
+				this.state = S_OPEN_TAG;
+				this.unget();
+				this.xmlDeclPossible = false;
+			} else switch (c) {
+				case FORWARD_SLASH:
+					this.state = S_CLOSE_TAG;
+					this.xmlDeclPossible = false;
+					break;
+				case BANG:
+					this.state = S_OPEN_WAKA_BANG;
+					this.openWakaBang = "";
+					this.xmlDeclPossible = false;
+					break;
+				case QUESTION:
+					this.state = S_PI_FIRST_CHAR;
+					break;
+				default:
+					this.fail("disallowed character in tag name");
+					this.state = S_TEXT;
+					this.xmlDeclPossible = false;
+			}
+		}
+		sOpenWakaBang() {
+			this.openWakaBang += String.fromCodePoint(this.getCodeNorm());
+			switch (this.openWakaBang) {
+				case "[CDATA[":
+					if (!this.sawRoot && !this.reportedTextBeforeRoot) {
+						this.fail("text data outside of root node.");
+						this.reportedTextBeforeRoot = true;
+					}
+					if (this.closedRoot && !this.reportedTextAfterRoot) {
+						this.fail("text data outside of root node.");
+						this.reportedTextAfterRoot = true;
+					}
+					this.state = S_CDATA;
+					this.openWakaBang = "";
+					break;
+				case "--":
+					this.state = S_COMMENT;
+					this.openWakaBang = "";
+					break;
+				case "DOCTYPE":
+					this.state = S_DOCTYPE;
+					if (this.doctype || this.sawRoot) this.fail("inappropriately located doctype declaration.");
+					this.openWakaBang = "";
+					break;
+				default: if (this.openWakaBang.length >= 7) this.fail("incorrect syntax.");
+			}
+		}
+		sComment() {
+			if (this.captureToChar(MINUS)) this.state = S_COMMENT_ENDING;
+		}
+		sCommentEnding() {
+			var _a;
+			const c = this.getCodeNorm();
+			if (c === MINUS) {
+				this.state = S_COMMENT_ENDED;
+				(_a = this.commentHandler) === null || _a === void 0 || _a.call(this, this.text);
+				this.text = "";
+			} else {
+				this.text += `-${String.fromCodePoint(c)}`;
+				this.state = S_COMMENT;
+			}
+		}
+		sCommentEnded() {
+			const c = this.getCodeNorm();
+			if (c !== GREATER) {
+				this.fail("malformed comment.");
+				this.text += `--${String.fromCodePoint(c)}`;
+				this.state = S_COMMENT;
+			} else this.state = S_TEXT;
+		}
+		sCData() {
+			if (this.captureToChar(CLOSE_BRACKET)) this.state = S_CDATA_ENDING;
+		}
+		sCDataEnding() {
+			const c = this.getCodeNorm();
+			if (c === CLOSE_BRACKET) this.state = S_CDATA_ENDING_2;
+			else {
+				this.text += `]${String.fromCodePoint(c)}`;
+				this.state = S_CDATA;
+			}
+		}
+		sCDataEnding2() {
+			var _a;
+			const c = this.getCodeNorm();
+			switch (c) {
+				case GREATER:
+					(_a = this.cdataHandler) === null || _a === void 0 || _a.call(this, this.text);
+					this.text = "";
+					this.state = S_TEXT;
+					break;
+				case CLOSE_BRACKET:
+					this.text += "]";
+					break;
+				default:
+					this.text += `]]${String.fromCodePoint(c)}`;
+					this.state = S_CDATA;
+			}
+		}
+		sPIFirstChar() {
+			const c = this.getCodeNorm();
+			if (this.nameStartCheck(c)) {
+				this.piTarget += String.fromCodePoint(c);
+				this.state = S_PI_REST;
+			} else if (c === QUESTION || isS(c)) {
+				this.fail("processing instruction without a target.");
+				this.state = c === QUESTION ? S_PI_ENDING : S_PI_BODY;
+			} else {
+				this.fail("disallowed character in processing instruction name.");
+				this.piTarget += String.fromCodePoint(c);
+				this.state = S_PI_REST;
+			}
+		}
+		sPIRest() {
+			const { chunk, i: start } = this;
+			while (true) {
+				const c = this.getCodeNorm();
+				if (c === EOC) {
+					this.piTarget += chunk.slice(start);
+					return;
+				}
+				if (!this.nameCheck(c)) {
+					this.piTarget += chunk.slice(start, this.prevI);
+					const isQuestion = c === QUESTION;
+					if (isQuestion || isS(c)) {
+						if (this.piTarget === "xml") {
+							if (!this.xmlDeclPossible) this.fail("an XML declaration must be at the start of the document.");
+							this.state = isQuestion ? S_XML_DECL_ENDING : S_XML_DECL_NAME_START;
+						} else this.state = isQuestion ? S_PI_ENDING : S_PI_BODY;
+					} else {
+						this.fail("disallowed character in processing instruction name.");
+						this.piTarget += String.fromCodePoint(c);
+					}
+					break;
+				}
+			}
+		}
+		sPIBody() {
+			if (this.text.length === 0) {
+				const c = this.getCodeNorm();
+				if (c === QUESTION) this.state = S_PI_ENDING;
+				else if (!isS(c)) this.text = String.fromCodePoint(c);
+			} else if (this.captureToChar(QUESTION)) this.state = S_PI_ENDING;
+		}
+		sPIEnding() {
+			var _a;
+			const c = this.getCodeNorm();
+			if (c === GREATER) {
+				const { piTarget } = this;
+				if (piTarget.toLowerCase() === "xml") this.fail("the XML declaration must appear at the start of the document.");
+				(_a = this.piHandler) === null || _a === void 0 || _a.call(this, {
+					target: piTarget,
+					body: this.text
+				});
+				this.piTarget = this.text = "";
+				this.state = S_TEXT;
+			} else if (c === QUESTION) this.text += "?";
+			else {
+				this.text += `?${String.fromCodePoint(c)}`;
+				this.state = S_PI_BODY;
+			}
+			this.xmlDeclPossible = false;
+		}
+		sXMLDeclNameStart() {
+			const c = this.skipSpaces();
+			if (c === QUESTION) {
+				this.state = S_XML_DECL_ENDING;
+				return;
+			}
+			if (c !== EOC) {
+				this.state = S_XML_DECL_NAME;
+				this.name = String.fromCodePoint(c);
+			}
+		}
+		sXMLDeclName() {
+			const c = this.captureTo(XML_DECL_NAME_TERMINATOR);
+			if (c === QUESTION) {
+				this.state = S_XML_DECL_ENDING;
+				this.name += this.text;
+				this.text = "";
+				this.fail("XML declaration is incomplete.");
+				return;
+			}
+			if (!(isS(c) || c === EQUAL)) return;
+			this.name += this.text;
+			this.text = "";
+			if (!this.xmlDeclExpects.includes(this.name)) switch (this.name.length) {
+				case 0:
+					this.fail("did not expect any more name/value pairs.");
+					break;
+				case 1:
+					this.fail(`expected the name ${this.xmlDeclExpects[0]}.`);
+					break;
+				default: this.fail(`expected one of ${this.xmlDeclExpects.join(", ")}`);
+			}
+			this.state = c === EQUAL ? S_XML_DECL_VALUE_START : S_XML_DECL_EQ;
+		}
+		sXMLDeclEq() {
+			const c = this.getCodeNorm();
+			if (c === QUESTION) {
+				this.state = S_XML_DECL_ENDING;
+				this.fail("XML declaration is incomplete.");
+				return;
+			}
+			if (isS(c)) return;
+			if (c !== EQUAL) this.fail("value required.");
+			this.state = S_XML_DECL_VALUE_START;
+		}
+		sXMLDeclValueStart() {
+			const c = this.getCodeNorm();
+			if (c === QUESTION) {
+				this.state = S_XML_DECL_ENDING;
+				this.fail("XML declaration is incomplete.");
+				return;
+			}
+			if (isS(c)) return;
+			if (!isQuote(c)) {
+				this.fail("value must be quoted.");
+				this.q = SPACE;
+			} else this.q = c;
+			this.state = S_XML_DECL_VALUE;
+		}
+		sXMLDeclValue() {
+			const c = this.captureTo([this.q, QUESTION]);
+			if (c === QUESTION) {
+				this.state = S_XML_DECL_ENDING;
+				this.text = "";
+				this.fail("XML declaration is incomplete.");
+				return;
+			}
+			if (c === EOC) return;
+			const value = this.text;
+			this.text = "";
+			switch (this.name) {
+				case "version": {
+					this.xmlDeclExpects = ["encoding", "standalone"];
+					const version = value;
+					this.xmlDecl.version = version;
+					if (!/^1\.[0-9]+$/.test(version)) this.fail("version number must match /^1\\.[0-9]+$/.");
+					else if (!this.opt.forceXMLVersion) this.setXMLVersion(version);
+					break;
+				}
+				case "encoding":
+					if (!/^[A-Za-z][A-Za-z0-9._-]*$/.test(value)) this.fail("encoding value must match /^[A-Za-z0-9][A-Za-z0-9._-]*$/.");
+					this.xmlDeclExpects = ["standalone"];
+					this.xmlDecl.encoding = value;
+					break;
+				case "standalone":
+					if (value !== "yes" && value !== "no") this.fail("standalone value must match \"yes\" or \"no\".");
+					this.xmlDeclExpects = [];
+					this.xmlDecl.standalone = value;
+			}
+			this.name = "";
+			this.state = S_XML_DECL_SEPARATOR;
+		}
+		sXMLDeclSeparator() {
+			const c = this.getCodeNorm();
+			if (c === QUESTION) {
+				this.state = S_XML_DECL_ENDING;
+				return;
+			}
+			if (!isS(c)) {
+				this.fail("whitespace required.");
+				this.unget();
+			}
+			this.state = S_XML_DECL_NAME_START;
+		}
+		sXMLDeclEnding() {
+			var _a;
+			if (this.getCodeNorm() === GREATER) {
+				if (this.piTarget !== "xml") this.fail("processing instructions are not allowed before root.");
+				else if (this.name !== "version" && this.xmlDeclExpects.includes("version")) this.fail("XML declaration must contain a version.");
+				(_a = this.xmldeclHandler) === null || _a === void 0 || _a.call(this, this.xmlDecl);
+				this.name = "";
+				this.piTarget = this.text = "";
+				this.state = S_TEXT;
+			} else this.fail("The character ? is disallowed anywhere in XML declarations.");
+			this.xmlDeclPossible = false;
+		}
+		sOpenTag() {
+			var _a;
+			const c = this.captureNameChars();
+			if (c === EOC) return;
+			const tag = this.tag = {
+				name: this.name,
+				attributes: Object.create(null)
+			};
+			this.name = "";
+			if (this.xmlnsOpt) this.topNS = tag.ns = Object.create(null);
+			(_a = this.openTagStartHandler) === null || _a === void 0 || _a.call(this, tag);
+			this.sawRoot = true;
+			if (!this.fragmentOpt && this.closedRoot) this.fail("documents may contain only one root.");
+			switch (c) {
+				case GREATER:
+					this.openTag();
+					break;
+				case FORWARD_SLASH:
+					this.state = S_OPEN_TAG_SLASH;
+					break;
+				default:
+					if (!isS(c)) this.fail("disallowed character in tag name.");
+					this.state = S_ATTRIB;
+			}
+		}
+		sOpenTagSlash() {
+			if (this.getCode() === GREATER) this.openSelfClosingTag();
+			else {
+				this.fail("forward-slash in opening tag not followed by >.");
+				this.state = S_ATTRIB;
+			}
+		}
+		sAttrib() {
+			const c = this.skipSpaces();
+			if (c === EOC) return;
+			if (isNameStartChar(c)) {
+				this.unget();
+				this.state = S_ATTRIB_NAME;
+			} else if (c === GREATER) this.openTag();
+			else if (c === FORWARD_SLASH) this.state = S_OPEN_TAG_SLASH;
+			else this.fail("disallowed character in attribute name.");
+		}
+		sAttribName() {
+			const c = this.captureNameChars();
+			if (c === EQUAL) this.state = S_ATTRIB_VALUE;
+			else if (isS(c)) this.state = S_ATTRIB_NAME_SAW_WHITE;
+			else if (c === GREATER) {
+				this.fail("attribute without value.");
+				this.pushAttrib(this.name, this.name);
+				this.name = this.text = "";
+				this.openTag();
+			} else if (c !== EOC) this.fail("disallowed character in attribute name.");
+		}
+		sAttribNameSawWhite() {
+			const c = this.skipSpaces();
+			switch (c) {
+				case EOC: return;
+				case EQUAL:
+					this.state = S_ATTRIB_VALUE;
+					break;
+				default:
+					this.fail("attribute without value.");
+					this.text = "";
+					this.name = "";
+					if (c === GREATER) this.openTag();
+					else if (isNameStartChar(c)) {
+						this.unget();
+						this.state = S_ATTRIB_NAME;
+					} else {
+						this.fail("disallowed character in attribute name.");
+						this.state = S_ATTRIB;
+					}
+			}
+		}
+		sAttribValue() {
+			const c = this.getCodeNorm();
+			if (isQuote(c)) {
+				this.q = c;
+				this.state = S_ATTRIB_VALUE_QUOTED;
+			} else if (!isS(c)) {
+				this.fail("unquoted attribute value.");
+				this.state = S_ATTRIB_VALUE_UNQUOTED;
+				this.unget();
+			}
+		}
+		sAttribValueQuoted() {
+			const { q, chunk } = this;
+			let { i: start } = this;
+			while (true) switch (this.getCode()) {
+				case q:
+					this.pushAttrib(this.name, this.text + chunk.slice(start, this.prevI));
+					this.name = this.text = "";
+					this.q = null;
+					this.state = S_ATTRIB_VALUE_CLOSED;
+					return;
+				case AMP:
+					this.text += chunk.slice(start, this.prevI);
+					this.state = S_ENTITY;
+					this.entityReturnState = S_ATTRIB_VALUE_QUOTED;
+					return;
+				case NL:
+				case NL_LIKE:
+				case TAB:
+					this.text += `${chunk.slice(start, this.prevI)} `;
+					start = this.i;
+					break;
+				case LESS:
+					this.text += chunk.slice(start, this.prevI);
+					this.fail("disallowed character.");
+					return;
+				case EOC:
+					this.text += chunk.slice(start);
+					return;
+			}
+		}
+		sAttribValueClosed() {
+			const c = this.getCodeNorm();
+			if (isS(c)) this.state = S_ATTRIB;
+			else if (c === GREATER) this.openTag();
+			else if (c === FORWARD_SLASH) this.state = S_OPEN_TAG_SLASH;
+			else if (isNameStartChar(c)) {
+				this.fail("no whitespace between attributes.");
+				this.unget();
+				this.state = S_ATTRIB_NAME;
+			} else this.fail("disallowed character in attribute name.");
+		}
+		sAttribValueUnquoted() {
+			const c = this.captureTo(ATTRIB_VALUE_UNQUOTED_TERMINATOR);
+			switch (c) {
+				case AMP:
+					this.state = S_ENTITY;
+					this.entityReturnState = S_ATTRIB_VALUE_UNQUOTED;
+					break;
+				case LESS:
+					this.fail("disallowed character.");
+					break;
+				case EOC: break;
+				default:
+					if (this.text.includes("]]>")) this.fail("the string \"]]>\" is disallowed in char data.");
+					this.pushAttrib(this.name, this.text);
+					this.name = this.text = "";
+					if (c === GREATER) this.openTag();
+					else this.state = S_ATTRIB;
+			}
+		}
+		sCloseTag() {
+			const c = this.captureNameChars();
+			if (c === GREATER) this.closeTag();
+			else if (isS(c)) this.state = S_CLOSE_TAG_SAW_WHITE;
+			else if (c !== EOC) this.fail("disallowed character in closing tag.");
+		}
+		sCloseTagSawWhite() {
+			switch (this.skipSpaces()) {
+				case GREATER:
+					this.closeTag();
+					break;
+				case EOC: break;
+				default: this.fail("disallowed character in closing tag.");
+			}
+		}
+		handleTextInRoot() {
+			let { i: start, forbiddenState } = this;
+			const { chunk, textHandler: handler } = this;
+			scanLoop: while (true) switch (this.getCode()) {
+				case LESS:
+					this.state = S_OPEN_WAKA;
+					if (handler !== void 0) {
+						const { text } = this;
+						const slice = chunk.slice(start, this.prevI);
+						if (text.length !== 0) {
+							handler(text + slice);
+							this.text = "";
+						} else if (slice.length !== 0) handler(slice);
+					}
+					forbiddenState = FORBIDDEN_START;
+					break scanLoop;
+				case AMP:
+					this.state = S_ENTITY;
+					this.entityReturnState = S_TEXT;
+					if (handler !== void 0) this.text += chunk.slice(start, this.prevI);
+					forbiddenState = FORBIDDEN_START;
+					break scanLoop;
+				case CLOSE_BRACKET:
+					switch (forbiddenState) {
+						case FORBIDDEN_START:
+							forbiddenState = FORBIDDEN_BRACKET;
+							break;
+						case FORBIDDEN_BRACKET:
+							forbiddenState = FORBIDDEN_BRACKET_BRACKET;
+							break;
+						case FORBIDDEN_BRACKET_BRACKET: break;
+						default: throw new Error("impossible state");
+					}
+					break;
+				case GREATER:
+					if (forbiddenState === FORBIDDEN_BRACKET_BRACKET) this.fail("the string \"]]>\" is disallowed in char data.");
+					forbiddenState = FORBIDDEN_START;
+					break;
+				case NL_LIKE:
+					if (handler !== void 0) this.text += `${chunk.slice(start, this.prevI)}\n`;
+					start = this.i;
+					forbiddenState = FORBIDDEN_START;
+					break;
+				case EOC:
+					if (handler !== void 0) this.text += chunk.slice(start);
+					break scanLoop;
+				default: forbiddenState = FORBIDDEN_START;
+			}
+			this.forbiddenState = forbiddenState;
+		}
+		handleTextOutsideRoot() {
+			let { i: start } = this;
+			const { chunk, textHandler: handler } = this;
+			let nonSpace = false;
+			outRootLoop: while (true) {
+				const code = this.getCode();
+				switch (code) {
+					case LESS:
+						this.state = S_OPEN_WAKA;
+						if (handler !== void 0) {
+							const { text } = this;
+							const slice = chunk.slice(start, this.prevI);
+							if (text.length !== 0) {
+								handler(text + slice);
+								this.text = "";
+							} else if (slice.length !== 0) handler(slice);
+						}
+						break outRootLoop;
+					case AMP:
+						this.state = S_ENTITY;
+						this.entityReturnState = S_TEXT;
+						if (handler !== void 0) this.text += chunk.slice(start, this.prevI);
+						nonSpace = true;
+						break outRootLoop;
+					case NL_LIKE:
+						if (handler !== void 0) this.text += `${chunk.slice(start, this.prevI)}\n`;
+						start = this.i;
+						break;
+					case EOC:
+						if (handler !== void 0) this.text += chunk.slice(start);
+						break outRootLoop;
+					default: if (!isS(code)) nonSpace = true;
+				}
+			}
+			if (!nonSpace) return;
+			if (!this.sawRoot && !this.reportedTextBeforeRoot) {
+				this.fail("text data outside of root node.");
+				this.reportedTextBeforeRoot = true;
+			}
+			if (this.closedRoot && !this.reportedTextAfterRoot) {
+				this.fail("text data outside of root node.");
+				this.reportedTextAfterRoot = true;
+			}
+		}
+		pushAttribNS(name, value) {
+			var _a;
+			const { prefix, local } = this.qname(name);
+			const attr = {
+				name,
+				prefix,
+				local,
+				value
+			};
+			this.attribList.push(attr);
+			(_a = this.attributeHandler) === null || _a === void 0 || _a.call(this, attr);
+			if (prefix === "xmlns") {
+				const trimmed = value.trim();
+				if (this.currentXMLVersion === "1.0" && trimmed === "") this.fail("invalid attempt to undefine prefix in XML 1.0");
+				this.topNS[local] = trimmed;
+				nsPairCheck(this, local, trimmed);
+			} else if (name === "xmlns") {
+				const trimmed = value.trim();
+				this.topNS[""] = trimmed;
+				nsPairCheck(this, "", trimmed);
+			}
+		}
+		pushAttribPlain(name, value) {
+			var _a;
+			const attr = {
+				name,
+				value
+			};
+			this.attribList.push(attr);
+			(_a = this.attributeHandler) === null || _a === void 0 || _a.call(this, attr);
+		}
+		/**
+		* End parsing. This performs final well-formedness checks and resets the
+		* parser to a clean state.
+		*
+		* @returns this
+		*/
+		end() {
+			var _a, _b;
+			if (!this.sawRoot) this.fail("document must contain a root element.");
+			const { tags } = this;
+			while (tags.length > 0) {
+				const tag = tags.pop();
+				this.fail(`unclosed tag: ${tag.name}`);
+			}
+			if (this.state !== S_BEGIN && this.state !== S_TEXT) this.fail("unexpected end.");
+			const { text } = this;
+			if (text.length !== 0) {
+				(_a = this.textHandler) === null || _a === void 0 || _a.call(this, text);
+				this.text = "";
+			}
+			this._closed = true;
+			(_b = this.endHandler) === null || _b === void 0 || _b.call(this);
+			this._init();
+			return this;
+		}
+		/**
+		* Resolve a namespace prefix.
+		*
+		* @param prefix The prefix to resolve.
+		*
+		* @returns The namespace URI or ``undefined`` if the prefix is not defined.
+		*/
+		resolve(prefix) {
+			var _a, _b;
+			let uri = this.topNS[prefix];
+			if (uri !== void 0) return uri;
+			const { tags } = this;
+			for (let index = tags.length - 1; index >= 0; index--) {
+				uri = tags[index].ns[prefix];
+				if (uri !== void 0) return uri;
+			}
+			uri = this.ns[prefix];
+			if (uri !== void 0) return uri;
+			return (_b = (_a = this.opt).resolvePrefix) === null || _b === void 0 ? void 0 : _b.call(_a, prefix);
+		}
+		/**
+		* Parse a qname into its prefix and local name parts.
+		*
+		* @param name The name to parse
+		*
+		* @returns
+		*/
+		qname(name) {
+			const colon = name.indexOf(":");
+			if (colon === -1) return {
+				prefix: "",
+				local: name
+			};
+			const local = name.slice(colon + 1);
+			const prefix = name.slice(0, colon);
+			if (prefix === "" || local === "" || local.includes(":")) this.fail(`malformed name: ${name}.`);
+			return {
+				prefix,
+				local
+			};
+		}
+		processAttribsNS() {
+			var _a;
+			const { attribList } = this;
+			const tag = this.tag;
+			{
+				const { prefix, local } = this.qname(tag.name);
+				tag.prefix = prefix;
+				tag.local = local;
+				const uri = tag.uri = (_a = this.resolve(prefix)) !== null && _a !== void 0 ? _a : "";
+				if (prefix !== "") {
+					if (prefix === "xmlns") this.fail("tags may not have \"xmlns\" as prefix.");
+					if (uri === "") {
+						this.fail(`unbound namespace prefix: ${JSON.stringify(prefix)}.`);
+						tag.uri = prefix;
+					}
+				}
+			}
+			if (attribList.length === 0) return;
+			const { attributes } = tag;
+			const seen = /* @__PURE__ */ new Set();
+			for (const attr of attribList) {
+				const { name, prefix, local } = attr;
+				let uri;
+				let eqname;
+				if (prefix === "") {
+					uri = name === "xmlns" ? XMLNS_NAMESPACE : "";
+					eqname = name;
+				} else {
+					uri = this.resolve(prefix);
+					if (uri === void 0) {
+						this.fail(`unbound namespace prefix: ${JSON.stringify(prefix)}.`);
+						uri = prefix;
+					}
+					eqname = `{${uri}}${local}`;
+				}
+				if (seen.has(eqname)) this.fail(`duplicate attribute: ${eqname}.`);
+				seen.add(eqname);
+				attr.uri = uri;
+				attributes[name] = attr;
+			}
+			this.attribList = [];
+		}
+		processAttribsPlain() {
+			const { attribList } = this;
+			const attributes = this.tag.attributes;
+			for (const { name, value } of attribList) {
+				if (attributes[name] !== void 0) this.fail(`duplicate attribute: ${name}.`);
+				attributes[name] = value;
+			}
+			this.attribList = [];
+		}
+		/**
+		* Handle a complete open tag. This parser code calls this once it has seen
+		* the whole tag. This method checks for well-formeness and then emits
+		* ``onopentag``.
+		*/
+		openTag() {
+			var _a;
+			this.processAttribs();
+			const { tags } = this;
+			const tag = this.tag;
+			tag.isSelfClosing = false;
+			(_a = this.openTagHandler) === null || _a === void 0 || _a.call(this, tag);
+			tags.push(tag);
+			this.state = S_TEXT;
+			this.name = "";
+		}
+		/**
+		* Handle a complete self-closing tag. This parser code calls this once it has
+		* seen the whole tag. This method checks for well-formeness and then emits
+		* ``onopentag`` and ``onclosetag``.
+		*/
+		openSelfClosingTag() {
+			var _a, _b, _c;
+			this.processAttribs();
+			const { tags } = this;
+			const tag = this.tag;
+			tag.isSelfClosing = true;
+			(_a = this.openTagHandler) === null || _a === void 0 || _a.call(this, tag);
+			(_b = this.closeTagHandler) === null || _b === void 0 || _b.call(this, tag);
+			if ((this.tag = (_c = tags[tags.length - 1]) !== null && _c !== void 0 ? _c : null) === null) this.closedRoot = true;
+			this.state = S_TEXT;
+			this.name = "";
+		}
+		/**
+		* Handle a complete close tag. This parser code calls this once it has seen
+		* the whole tag. This method checks for well-formeness and then emits
+		* ``onclosetag``.
+		*/
+		closeTag() {
+			const { tags, name } = this;
+			this.state = S_TEXT;
+			this.name = "";
+			if (name === "") {
+				this.fail("weird empty close tag.");
+				this.text += "</>";
+				return;
+			}
+			const handler = this.closeTagHandler;
+			let l = tags.length;
+			while (l-- > 0) {
+				const tag = this.tag = tags.pop();
+				this.topNS = tag.ns;
+				handler === null || handler === void 0 || handler(tag);
+				if (tag.name === name) break;
+				this.fail("unexpected close tag.");
+			}
+			if (l === 0) this.closedRoot = true;
+			else if (l < 0) {
+				this.fail(`unmatched closing tag: ${name}.`);
+				this.text += `</${name}>`;
+			}
+		}
+		/**
+		* Resolves an entity. Makes any necessary well-formedness checks.
+		*
+		* @param entity The entity to resolve.
+		*
+		* @returns The parsed entity.
+		*/
+		parseEntity(entity) {
+			if (entity[0] !== "#") {
+				const defined = this.ENTITIES[entity];
+				if (defined !== void 0) return defined;
+				this.fail(this.isName(entity) ? "undefined entity." : "disallowed character in entity name.");
+				return `&${entity};`;
+			}
+			let num = NaN;
+			if (entity[1] === "x" && /^#x[0-9a-f]+$/i.test(entity)) num = parseInt(entity.slice(2), 16);
+			else if (/^#[0-9]+$/.test(entity)) num = parseInt(entity.slice(1), 10);
+			if (!this.isChar(num)) {
+				this.fail("malformed character entity.");
+				return `&${entity};`;
+			}
+			return String.fromCodePoint(num);
+		}
+	};
+	exports.SaxesParser = SaxesParser;
+})))();
+var ImageFormatError = class extends Error {
+	status;
+	constructor(status) {
+		super(status);
+		this.status = status;
+	}
+};
+const refuse = (status = "unsupported") => {
+	throw new ImageFormatError(status);
+};
+const size = (width, height) => {
+	if (!Number.isFinite(width) || !Number.isFinite(height) || width <= 0 || height <= 0) refuse();
+	width = Math.ceil(width);
+	height = Math.ceil(height);
+	if (width > 16384 || height > 16384 || width * height > 4e7) refuse("too-large");
+	return {
+		width: Math.ceil(width),
+		height: Math.ceil(height)
+	};
+};
+const ascii = (b, at, n) => String.fromCharCode(...b.subarray(at, at + n));
+const fragment = (value) => /^#[A-Za-z_][\w.:-]*$/u.test(value) ? value.slice(1) : refuse();
+const SVG = "http://www.w3.org/2000/svg";
+const XLINK = "http://www.w3.org/1999/xlink";
+const XMLNS = "http://www.w3.org/2000/xmlns/";
+const elements = new Set("svg g marker path rect circle ellipse line polyline polygon text tspan defs linearGradient radialGradient stop clipPath mask pattern use symbol title desc metadata style".split(" "));
+const properties = new Set("fill fill-opacity fill-rule stroke stroke-width stroke-opacity stroke-linecap stroke-linejoin stroke-miterlimit stroke-dasharray stroke-dashoffset opacity color font font-family font-size font-style font-weight font-variant text-anchor dominant-baseline alignment-baseline baseline-shift letter-spacing word-spacing text-decoration white-space display visibility clip-path clip-rule mask marker-start marker-mid marker-end paint-order vector-effect shape-rendering text-rendering stop-color stop-opacity transform transform-origin".split(" "));
+const functions = new Set("rgb rgba hsl hsla hwb lab lch oklab oklch color color-mix calc min max clamp var translate translateX translateY scale scaleX scaleY rotate skewX skewY matrix".toLowerCase().split(" "));
+function svgFormat(bytes) {
+	if (bytes.length > 1048576) refuse("too-large");
+	let source;
+	try {
+		source = new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+	} catch {
+		return refuse();
+	}
+	const nodes = [];
+	const stack = [];
+	const ids = /* @__PURE__ */ new Map();
+	const stylesheetRefs = [];
+	let dimensions;
+	let cssBytes = 0, cssNodes = 0;
+	let style = false;
+	let css = "";
+	const validateCss = (value, context, refs) => {
+		cssBytes += value.length;
+		if (cssBytes > 65536) refuse("too-large");
+		if (value.includes("\\")) refuse();
+		const ast = parse(value, {
+			context,
+			onParseError: () => refuse()
+		});
+		walk(ast, (node) => {
+			if (++cssNodes > 1e4) refuse("too-large");
+			if (node.type === "Atrule" || node.type === "Raw") refuse();
+			if (node.type === "Url") refs.push(fragment(node.value));
+			if (node.type === "Declaration" && !properties.has(node.property.toLowerCase()) && !/^--[\w-]+$/u.test(node.property)) refuse();
+			if (node.type === "Function" && !functions.has(node.name.toLowerCase())) refuse();
+		});
+	};
+	const parser = new import_saxes.SaxesParser({ xmlns: true });
+	parser.on("error", () => refuse());
+	parser.on("doctype", () => refuse());
+	parser.on("processinginstruction", () => refuse());
+	parser.on("opentag", (tag) => {
+		if (style) refuse();
+		if (nodes.length >= 1e4 || stack.length >= 64) refuse("too-large");
+		if (tag.uri !== SVG || !elements.has(tag.local)) refuse();
+		if (!nodes.length && tag.local !== "svg") refuse();
+		const index = nodes.length;
+		const current = {
+			children: [],
+			refs: []
+		};
+		nodes.push(current);
+		if (stack.length) nodes[stack.at(-1)].children.push(index);
+		stack.push(index);
+		const attrs = {};
+		for (const attribute of Object.values(tag.attributes)) {
+			const name = attribute.local;
+			const value = attribute.value;
+			if (value.length > 65536) refuse("too-large");
+			if (attribute.uri === XMLNS) {
+				if (![SVG, XLINK].includes(value)) refuse();
+				continue;
+			}
+			if (/^on/iu.test(name) || attribute.name === "xml:base" || name === "src" || name === "filter") refuse();
+			if (attribute.uri && attribute.uri !== XLINK && attribute.uri !== "http://www.w3.org/XML/1998/namespace") refuse();
+			if (name === "href") current.refs.push(fragment(value));
+			else if (name === "style") validateCss(value, "declarationList", current.refs);
+			else if (properties.has(name)) validateCss(value, "value", current.refs);
+			else if (/url\s*\(|\\/iu.test(value)) refuse();
+			if (name === "id") {
+				if (!/^[A-Za-z_][\w.:-]*$/u.test(value) || ids.has(value)) refuse();
+				ids.set(value, index);
+			}
+			attrs[name] = value;
+		}
+		if (index === 0) {
+			const box = attrs["viewBox"]?.trim().split(/[\s,]+/u).map(Number);
+			if (box && (box.length !== 4 || box.some((n) => !Number.isFinite(n)) || box[2] <= 0 || box[3] <= 0)) refuse();
+			const length = (value) => {
+				if (!value || /^\d+(?:\.\d+)?%$/u.test(value)) return void 0;
+				const match = /^(\d+(?:\.\d+)?|\.\d+)(px|pt|pc|in|cm|mm)?$/u.exec(value);
+				if (!match) return refuse();
+				return Number(match[1]) * ({
+					px: 1,
+					pt: 96 / 72,
+					pc: 16,
+					in: 96,
+					cm: 96 / 2.54,
+					mm: 96 / 25.4
+				}[match[2] ?? "px"] ?? 1);
+			};
+			let width = length(attrs["width"]), height = length(attrs["height"]);
+			if (width !== void 0 && height === void 0 && box) height = width * box[3] / box[2];
+			if (height !== void 0 && width === void 0 && box) width = height * box[2] / box[3];
+			dimensions = size(width ?? box?.[2] ?? 300, height ?? box?.[3] ?? 150);
+		}
+		if (tag.local === "style") {
+			style = true;
+			css = "";
+		}
+	});
+	const text = (value) => {
+		if (style) {
+			css += value;
+			if (css.length > 65536) refuse("too-large");
+		}
+	};
+	parser.on("text", text);
+	parser.on("cdata", text);
+	parser.on("closetag", (tag) => {
+		if (tag.local === "style") {
+			validateCss(css, "stylesheet", stylesheetRefs);
+			style = false;
+		}
+		stack.pop();
+	});
+	try {
+		parser.write(source).close();
+	} catch (error) {
+		if (error instanceof ImageFormatError) throw error;
+		return refuse();
+	}
+	if (!dimensions || stack.length || !nodes.length) return refuse();
+	const memo = /* @__PURE__ */ new Map();
+	const expanded = (index, visiting) => {
+		if (visiting.has(index)) return refuse();
+		if (visiting.size >= 64) return refuse("too-large");
+		const known = memo.get(index);
+		if (known !== void 0) return known;
+		visiting.add(index);
+		const node = nodes[index];
+		let cost = 1;
+		for (const child of node.children) cost += expanded(child, visiting);
+		for (const reference of node.refs) {
+			const target = ids.get(reference) ?? refuse();
+			cost += expanded(target, visiting);
+			if (cost > 2e4) refuse("too-large");
+		}
+		visiting.delete(index);
+		if (cost > 2e4) refuse("too-large");
+		memo.set(index, cost);
+		return cost;
+	};
+	let expandedNodes = expanded(0, /* @__PURE__ */ new Set());
+	for (const reference of stylesheetRefs) {
+		const target = ids.get(reference) ?? refuse();
+		expandedNodes += expanded(target, /* @__PURE__ */ new Set()) * nodes.length;
+		if (expandedNodes > 2e4) refuse("too-large");
+	}
+	return dimensions;
+}
+function inspectImage(bytes) {
+	if (bytes.length > 26214400) return refuse("too-large");
+	const b = bytes, n = b.length;
+	const view = new DataView(b.buffer, b.byteOffset, b.byteLength);
+	const format = (mime, extension, width, height) => ({
+		mime,
+		extension,
+		...size(width, height)
+	});
+	if (n >= 33 && ascii(b, 0, 8) === "‰PNG\r\n\n" && view.getUint32(8) === 13 && ascii(b, 12, 4) === "IHDR") return format("image/png", "png", view.getUint32(16), view.getUint32(20));
+	if (n >= 4 && b[0] === 255 && b[1] === 216) {
+		if (b[n - 2] !== 255 || b[n - 1] !== 217) return refuse();
+		let at = 2, dimensions;
+		while (at + 3 < n) {
+			if (b[at++] !== 255) return refuse();
+			while (at < n && b[at] === 255) at++;
+			if (at + 2 >= n) return refuse();
+			const marker = b[at++];
+			if (marker === 0 || marker === 216 || marker === 217 || marker >= 208 && marker <= 215) return refuse();
+			const length = view.getUint16(at);
+			if (length < 2 || at + length > n - 2) return refuse();
+			if (marker === 218) {
+				const components = b[at + 2] ?? 0;
+				if (components < 1 || components > 4 || length !== 6 + 2 * components || at + length >= n - 2) return refuse();
+				return dimensions ?? refuse();
+			}
+			if (marker >= 192 && marker <= 207 && ![
+				196,
+				200,
+				204
+			].includes(marker)) {
+				const components = b[at + 7] ?? 0;
+				if (components < 1 || components > 4 || length !== 8 + 3 * components) return refuse();
+				dimensions = format("image/jpeg", "jpg", view.getUint16(at + 5), view.getUint16(at + 3));
+			}
+			at += length;
+		}
+		return refuse();
+	}
+	if (n >= 14 && ["GIF87a", "GIF89a"].includes(ascii(b, 0, 6))) {
+		const width = view.getUint16(6, true), height = view.getUint16(8, true);
+		const result = format("image/gif", "gif", width, height);
+		let at = 13 + (b[10] & 128 ? 3 * (1 << (b[10] & 7) + 1) : 0), frames = 0, pixels = 0;
+		const blocks = () => {
+			for (;;) {
+				if (at >= n) return refuse();
+				const length = b[at++];
+				if (!length) return;
+				at += length;
+				if (at > n) return refuse();
+			}
+		};
+		while (at < n) {
+			const marker = b[at++];
+			if (marker === 59) return frames && at === n ? result : refuse();
+			if (marker === 33) {
+				at++;
+				blocks();
+				continue;
+			}
+			if (marker !== 44 || at + 9 >= n) return refuse();
+			const w = view.getUint16(at + 4, true), h = view.getUint16(at + 6, true);
+			size(w, h);
+			pixels += width * height;
+			if (++frames > 256 || pixels > 4e7) return refuse("too-large");
+			if (view.getUint16(at, true) + w > width || view.getUint16(at + 2, true) + h > height) return refuse();
+			const packed = b[at + 8];
+			at += 9;
+			if (packed & 128) at += 3 * (1 << (packed & 7) + 1);
+			const code = b[at++];
+			if (code < 2 || code > 8) return refuse();
+			blocks();
+		}
+		return refuse();
+	}
+	if (n >= 20 && ascii(b, 0, 4) === "RIFF" && ascii(b, 8, 4) === "WEBP") {
+		if (view.getUint32(4, true) + 8 !== n) return refuse();
+		let result, frames = 0, pixels = 0, image = false;
+		const u24 = (at) => b[at] | b[at + 1] << 8 | b[at + 2] << 16;
+		const payload = (tag, start, length) => {
+			if (tag === "VP8 ") {
+				if (length < 10 || ascii(b, start + 3, 3) !== "
*") return refuse();
+				return size(view.getUint16(start + 6, true) & 16383, view.getUint16(start + 8, true) & 16383);
+			}
+			if (tag === "VP8L") {
+				if (length < 5 || b[start] !== 47) return refuse();
+				const bits = view.getUint32(start + 1, true);
+				return size(1 + (bits & 16383), 1 + (bits >>> 14 & 16383));
+			}
+		};
+		for (let at = 12; at < n;) {
+			if (at + 8 > n) return refuse();
+			const tag = ascii(b, at, 4), length = view.getUint32(at + 4, true), start = at + 8;
+			if (start + length > n) return refuse();
+			if (tag === "VP8X") {
+				if (length !== 10 || at !== 12) return refuse();
+				result = format("image/webp", "webp", u24(start + 4) + 1, u24(start + 7) + 1);
+			}
+			const frame = payload(tag, start, length);
+			if (frame) {
+				result ??= format("image/webp", "webp", frame.width, frame.height);
+				if (frame.width > result.width || frame.height > result.height) return refuse();
+				image = true;
+			}
+			if (tag === "ANMF") {
+				if (length < 24 || !result) return refuse();
+				const w = u24(start + 6) + 1, h = u24(start + 9) + 1;
+				size(w, h);
+				pixels += result.width * result.height;
+				if (++frames > 256 || pixels > 4e7) return refuse("too-large");
+				if (u24(start) * 2 + w > result.width || u24(start + 3) * 2 + h > result.height) return refuse();
+				let encoded = false;
+				for (let part = start + 16; part < start + length;) {
+					if (part + 8 > start + length) return refuse();
+					const count = view.getUint32(part + 4, true);
+					if (part + 8 + count > start + length) return refuse();
+					const inner = payload(ascii(b, part, 4), part + 8, count);
+					if (inner) {
+						if (inner.width !== w || inner.height !== h) return refuse();
+						encoded = true;
+					}
+					part += 8 + count + (count & 1);
+					if (part > start + length) return refuse();
+				}
+				if (!encoded) return refuse();
+				image = true;
+			}
+			at = start + length + (length & 1);
+			if (at > n) return refuse();
+		}
+		return image && result ? result : refuse();
+	}
+	if (n && new TextDecoder().decode(b.subarray(0, Math.min(n, 512))).trimStart().startsWith("<")) return {
+		mime: "image/svg+xml",
+		extension: "svg",
+		...svgFormat(bytes)
+	};
+	return refuse();
+}
+const isMemoryImagePath = (path) => /\.(?:png|jpe?g|gif|webp|svg)$/iu.test(path);
+//#endregion
+//#region packages/core/src/memory/jail.ts
+var MemoryPathError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "MemoryPathError";
+	}
+};
+function toMemoryRelativePath(input) {
+	if (typeof input !== "string" || input.trim().length === 0) throw new MemoryPathError("memory path must be a non-empty string");
+	if (input.includes("\0")) throw new MemoryPathError("memory path must not contain NUL bytes");
+	const slashed = input.replaceAll("\\", "/");
+	if (slashed.startsWith("/") || /^[A-Za-z]:\//.test(slashed)) throw new MemoryPathError(`memory path must be relative: ${input}`);
+	const segments = [];
+	for (const segment of slashed.split("/")) {
+		if (segment === "" || segment === ".") continue;
+		if (segment === "..") throw new MemoryPathError(`memory path escapes the memory directory: ${input}`);
+		if (segment.toLowerCase() === ".git") throw new MemoryPathError(`memory path is reserved: ${input}`);
+		segments.push(segment);
+	}
+	if (segments.length === 0) throw new MemoryPathError(`memory path must name a file: ${input}`);
+	return segments.join("/");
+}
+function toMemoryWritePath(input) {
+	const relativePath = toMemoryRelativePath(input);
+	const segments = relativePath.split("/");
+	if (!(segments[segments.length - 1] ?? "").toLowerCase().endsWith(".md")) throw new MemoryPathError(`memory write path must end with .md: ${input}`);
+	for (const segment of segments.slice(0, -1)) if (segment.startsWith(".")) throw new MemoryPathError(`memory write path must not contain dot-directories: ${input}`);
+	return relativePath;
+}
+function resolveMemoryPath(root, input) {
+	const relativePath = toMemoryRelativePath(input);
+	const realRoot = realpathSync(root);
+	const target = join(realRoot, relativePath);
+	let probe = target;
+	while (!existsSync(probe)) {
+		const parent = dirname(probe);
+		if (parent === probe) break;
+		probe = parent;
+	}
+	const realProbe = realpathSync(probe);
+	const fromRoot = relative(realRoot, realProbe);
+	if (fromRoot.startsWith("..") || isAbsolute(fromRoot)) throw new MemoryPathError(`memory path escapes the memory directory through a link: ${input}`);
+	return target;
+}
+//#endregion
+//#region packages/core/src/memory/image.ts
+const MAX_MEMORY_IMAGE_BYTES = 26214400;
+var MemoryImageError = class extends Error {
+	code;
+	constructor(code, message) {
+		super(message);
+		this.code = code;
+	}
+};
+function readMemoryBytes(root, input, source, git, maxBytes = MAX_MEMORY_IMAGE_BYTES) {
+	const path = toMemoryRelativePath(input);
+	const fail = (status) => ({ status });
+	let bytes;
+	if (source === "worktree") {
+		const target = resolveMemoryPath(root, path);
+		let fd;
+		try {
+			fd = openSync(target, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0) | (constants.O_NONBLOCK ?? 0));
+		} catch (error) {
+			if ([
+				"ENOENT",
+				"ENOTDIR",
+				"ELOOP"
+			].includes(error.code ?? "")) return fail("missing");
+			throw error;
+		}
+		try {
+			const realRoot = realpathSync(root);
+			const current = realpathSync(resolveMemoryPath(root, path));
+			toMemoryRelativePath(relative(realRoot, current));
+			const before = fstatSync(fd);
+			const latest = statSync(current);
+			if (!before.isFile() || before.dev !== latest.dev || before.ino !== latest.ino) return fail("stale");
+			if (before.size > maxBytes) return fail("too-large");
+			bytes = Buffer.alloc(before.size + 1);
+			let count = 0;
+			while (count < bytes.length) {
+				const read = readSync(fd, bytes, count, bytes.length - count, null);
+				if (read === 0) break;
+				count += read;
+			}
+			const after = fstatSync(fd);
+			const finalPath = realpathSync(resolveMemoryPath(root, path));
+			const final = statSync(finalPath);
+			if (count > maxBytes) return fail("too-large");
+			if (count !== before.size || after.size !== before.size || after.mtimeMs !== before.mtimeMs || after.ctimeMs !== before.ctimeMs || finalPath !== current || final.ino !== before.ino || final.dev !== before.dev) return fail("stale");
+			bytes = bytes.subarray(0, count);
+		} finally {
+			closeSync(fd);
+		}
+	} else {
+		if (source !== "index") {
+			if (!/^[0-9a-f]{40}$/u.test(source)) throw new MemoryImageError("memory-unknown-commit", "Invalid image revision");
+			if (git(root, [
+				"cat-file",
+				"-t",
+				source
+			]).toString().trim() !== "commit") throw new MemoryImageError("memory-unknown-commit", "Unknown image commit");
+			const branches = git(root, [
+				"branch",
+				"--contains",
+				source,
+				"--format=%(refname)"
+			]).toString().trim();
+			let reachable = false;
+			try {
+				git(root, [
+					"merge-base",
+					"--is-ancestor",
+					source,
+					"HEAD"
+				]);
+				reachable = true;
+			} catch {}
+			if (!reachable && !branches) throw new MemoryImageError("memory-unknown-commit", "Image commit is not reachable");
+		}
+		const listing = source === "index" ? git(root, [
+			"--literal-pathspecs",
+			"ls-files",
+			"--stage",
+			"-z",
+			"--",
+			path
+		]).toString() : git(root, [
+			"--literal-pathspecs",
+			"ls-tree",
+			"-z",
+			source,
+			"--",
+			path
+		]).toString();
+		const entries = listing.split("\0").filter(Boolean);
+		if (entries.length === 0) return fail("missing");
+		if (entries.length !== 1) return fail("stale");
+		const entry = entries[0];
+		const tab = entry.indexOf("	");
+		const metadata = entry.slice(0, tab).split(" ");
+		if (entry.slice(tab + 1) !== path || !["100644", "100755"].includes(metadata[0] ?? "")) return fail("unsupported");
+		const oid = source === "index" ? metadata[1] : metadata[2];
+		if (source === "index" && metadata[2] !== "0") return fail("stale");
+		if (!oid || !/^[0-9a-f]{40}$/u.test(oid)) return fail("unsupported");
+		const size = Number(git(root, [
+			"cat-file",
+			"-s",
+			oid
+		]).toString());
+		if (!Number.isSafeInteger(size) || size < 0 || size > maxBytes) return fail("too-large");
+		bytes = git(root, [
+			"cat-file",
+			"blob",
+			oid
+		], maxBytes + 1);
+		if (source === "index" && git(root, [
+			"--literal-pathspecs",
+			"ls-files",
+			"--stage",
+			"-z",
+			"--",
+			path
+		]).toString() !== listing) return fail("stale");
+	}
+	return {
+		status: "ready",
+		bytes
+	};
+}
+function readMemoryImage(root, input, source, git) {
+	const fail = (status) => ({ image: {
+		source,
+		status
+	} });
+	const result = readMemoryBytes(root, input, source, git);
+	const bytes = result.bytes;
+	if (result.status !== "ready" || bytes === void 0) return fail(result.status);
+	try {
+		const format = inspectImage(bytes);
+		return {
+			image: {
+				source,
+				status: "ready",
+				mime: format.mime,
+				revision: createHash("sha256").update(bytes).digest("hex"),
+				size: bytes.length,
+				width: format.width,
+				height: format.height
+			},
+			bytes
+		};
+	} catch (error) {
+		if (error instanceof ImageFormatError) return fail(error.status);
+		throw error;
+	}
+}
+//#endregion
+//#region packages/core/src/memory/markdown.ts
+const MAX_MEMORY_MARKDOWN_BYTES = 4194304;
+const isMemoryMarkdown = (path) => /\.(?:md|markdown)$/iu.test(path);
+function readMemoryMarkdown(root, path, source, git, maxBytes = MAX_MEMORY_MARKDOWN_BYTES) {
+	if (!isMemoryMarkdown(path)) return {
+		source,
+		status: "unsupported",
+		body: ""
+	};
+	const { bytes, status } = readMemoryBytes(root, path, source, git, maxBytes);
+	if (bytes === void 0) return {
+		source,
+		status,
+		body: ""
+	};
+	try {
+		if (bytes.includes(0)) return {
+			source,
+			status: "unsupported",
+			body: ""
+		};
+		return {
+			source,
+			status: "ready",
+			revision: createHash("sha256").update(bytes).digest("hex"),
+			body: new TextDecoder("utf-8", { fatal: true }).decode(bytes)
+		};
+	} catch {
+		return {
+			source,
+			status: "unsupported",
+			body: ""
+		};
+	}
+}
+function memoryMarkdownImagePath(document, reference) {
+	const invalid = () => {
+		throw new MemoryImageError("memory-image-invalid", "Image reference must stay inside Memory");
+	};
+	if (!reference || /[\\\u0000-\u001f\u007f]/u.test(reference) || reference.startsWith("//")) invalid();
+	let decoded;
+	try {
+		decoded = decodeURIComponent(reference.split(/[?#]/u)[0]);
+	} catch {
+		return invalid();
+	}
+	if (!decoded || /[\\:\u0000-\u001f\u007f]/u.test(decoded) || decoded.startsWith("//")) invalid();
+	const segments = decoded.startsWith("/") ? [] : posix.dirname(toMemoryRelativePath(document)).split("/").filter((p) => p !== ".");
+	for (const part of decoded.split("/")) {
+		if (!part || part === ".") continue;
+		if (part.toLowerCase() === ".git") invalid();
+		if (part === "..") {
+			if (segments.length === 0) invalid();
+			segments.pop();
+		} else segments.push(part);
+	}
+	return toMemoryRelativePath(segments.join("/"));
+}
+//#endregion
 //#region packages/core/src/memory/front-matter.ts
 function firstNonEmptyLine(text) {
 	for (const line of text.split("\n")) {
@@ -43369,51 +45832,6 @@ function seedStandingFiles(root, options) {
 	return written;
 }
 //#endregion
-//#region packages/core/src/memory/jail.ts
-var MemoryPathError = class extends Error {
-	constructor(message) {
-		super(message);
-		this.name = "MemoryPathError";
-	}
-};
-function toMemoryRelativePath(input) {
-	if (typeof input !== "string" || input.trim().length === 0) throw new MemoryPathError("memory path must be a non-empty string");
-	if (input.includes("\0")) throw new MemoryPathError("memory path must not contain NUL bytes");
-	const slashed = input.replaceAll("\\", "/");
-	if (slashed.startsWith("/") || /^[A-Za-z]:\//.test(slashed)) throw new MemoryPathError(`memory path must be relative: ${input}`);
-	const segments = [];
-	for (const segment of slashed.split("/")) {
-		if (segment === "" || segment === ".") continue;
-		if (segment === "..") throw new MemoryPathError(`memory path escapes the memory directory: ${input}`);
-		if (segment.toLowerCase() === ".git") throw new MemoryPathError(`memory path is reserved: ${input}`);
-		segments.push(segment);
-	}
-	if (segments.length === 0) throw new MemoryPathError(`memory path must name a file: ${input}`);
-	return segments.join("/");
-}
-function toMemoryWritePath(input) {
-	const relativePath = toMemoryRelativePath(input);
-	const segments = relativePath.split("/");
-	if (!(segments[segments.length - 1] ?? "").toLowerCase().endsWith(".md")) throw new MemoryPathError(`memory write path must end with .md: ${input}`);
-	for (const segment of segments.slice(0, -1)) if (segment.startsWith(".")) throw new MemoryPathError(`memory write path must not contain dot-directories: ${input}`);
-	return relativePath;
-}
-function resolveMemoryPath(root, input) {
-	const relativePath = toMemoryRelativePath(input);
-	const realRoot = realpathSync(root);
-	const target = join(realRoot, relativePath);
-	let probe = target;
-	while (!existsSync(probe)) {
-		const parent = dirname(probe);
-		if (parent === probe) break;
-		probe = parent;
-	}
-	const realProbe = realpathSync(probe);
-	const fromRoot = relative(realRoot, realProbe);
-	if (fromRoot.startsWith("..") || isAbsolute(fromRoot)) throw new MemoryPathError(`memory path escapes the memory directory through a link: ${input}`);
-	return target;
-}
-//#endregion
 //#region packages/core/src/memory/recovery.ts
 const SHA$1 = /^[0-9a-f]{40}$/u;
 const MAX_GIT_OUTPUT = 4194304;
@@ -44616,11 +47034,45 @@ function createMemoryAcceptance(options) {
 				standing: standingUsage(root, registry.get(botSlug)?.standingLimits ?? DEFAULT_STANDING_LIMITS)
 			};
 		},
+		markdownImageFile(botSlug, path, source, revision, reference) {
+			const root = graphRepository(botSlug);
+			const document = readMemoryMarkdown(root, path, source, run$1);
+			if (document.status !== "ready") throw new MemoryImageError(`memory-image-${document.status}`, "Markdown is unavailable");
+			if (document.revision !== revision) throw new MemoryImageError("memory-image-stale", "Markdown changed; refresh the view");
+			const { image, bytes } = readMemoryImage(root, memoryMarkdownImagePath(path, reference), source, run$1);
+			if (image.status !== "ready" || bytes === void 0) throw new MemoryImageError(`memory-image-${image.status}`, "Image is unavailable or cannot be previewed");
+			if (readMemoryMarkdown(root, path, source, run$1).revision !== revision) throw new MemoryImageError("memory-image-stale", "Markdown changed; refresh the view");
+			return bytes;
+		},
+		imageFile(botSlug, path, source, revision) {
+			if (!/^[0-9a-f]{64}$/u.test(revision)) throw new MemoryImageError("memory-image-invalid", "Invalid image content revision");
+			const { image, bytes } = readMemoryImage(graphRepository(botSlug), path, source, run$1);
+			if (image.status !== "ready" || bytes === void 0) throw new MemoryImageError(`memory-image-${image.status}`, "Image is unavailable or cannot be previewed");
+			if (image.revision !== revision) throw new MemoryImageError("memory-image-stale", "Image changed; refresh the view");
+			return bytes;
+		},
 		readAccepted(botSlug, path) {
 			const { root } = readRepository(botSlug);
 			const relative = toMemoryRelativePath(path);
 			const target = resolveMemoryPath(root, relative);
 			if (!existsSync(target) || !statSync(target).isFile()) return void 0;
+			if (isMemoryMarkdown(relative)) {
+				const markdown = readMemoryMarkdown(root, relative, "worktree", run$1);
+				return {
+					path: relative,
+					body: markdown.body,
+					head: head(root),
+					markdown,
+					...markdown.status === "ready" ? {} : { binary: true }
+				};
+			}
+			if (isMemoryImagePath(relative)) return {
+				path: relative,
+				body: "",
+				head: head(root),
+				binary: true,
+				image: readMemoryImage(root, relative, "worktree", run$1).image
+			};
 			if (statSync(target).size > MAX_DIFF_BYTES) return {
 				path: relative,
 				body: "",
@@ -44767,10 +47219,28 @@ function createMemoryAcceptance(options) {
 				...range
 			]).toString("utf8").split("\0").filter(Boolean);
 			const files = [];
-			for (let index = 0; index < nameStatus.length; index += 2) files.push({
-				status: nameStatus[index] ?? "",
-				path: nameStatus[index + 1] ?? ""
-			});
+			let markdownBudget = MAX_MEMORY_MARKDOWN_BYTES;
+			const document = (path, source) => {
+				const result = readMemoryMarkdown(root, path, source, run$1, markdownBudget);
+				markdownBudget -= Buffer.byteLength(result.body, "utf8");
+				return result;
+			};
+			for (let index = 0; index < nameStatus.length; index += 2) {
+				const status = nameStatus[index] ?? "";
+				const path = nameStatus[index + 1] ?? "";
+				files.push({
+					status,
+					path,
+					...isMemoryMarkdown(path) ? { markdown: {
+						...status === "A" || firstParent === void 0 ? {} : { before: document(path, firstParent) },
+						...status === "D" ? {} : { after: document(path, sha) }
+					} } : {},
+					...isMemoryImagePath(path) ? { images: {
+						...status === "A" || firstParent === void 0 ? {} : { before: readMemoryImage(root, path, firstParent, run$1).image },
+						...status === "D" ? {} : { after: readMemoryImage(root, path, sha, run$1).image }
+					} } : {}
+				});
+			}
 			return {
 				sha,
 				subject: output(root, [
@@ -44817,20 +47287,45 @@ function createMemoryAcceptance(options) {
 				status: phases.some((entry) => entry.kind === "untracked" || entry.status === "A") ? "A" : phases.some((entry) => entry.status === "D") ? "D" : "M"
 			} : phases.find((entry) => entry.kind === kind);
 			if (change === void 0) throw new MemoryAcceptError("memory-invalid", "Memory working change no longer exists");
+			const comparisonHead = head(root);
+			const markdown = isMemoryMarkdown(relative) ? {
+				...change.status === "A" || kind === "untracked" ? {} : { before: readMemoryMarkdown(root, relative, kind === "unstaged" ? "index" : comparisonHead, run$1) },
+				...change.status === "D" ? {} : { after: readMemoryMarkdown(root, relative, kind === "staged" ? "index" : "worktree", run$1) }
+			} : void 0;
+			if (isMemoryImagePath(relative)) {
+				const oldSource = kind === "unstaged" ? "index" : head(root);
+				const newSource = kind === "staged" ? "index" : "worktree";
+				return {
+					...change,
+					diff: "",
+					binary: true,
+					images: {
+						...change.status === "A" || kind === "untracked" ? {} : { before: readMemoryImage(root, relative, oldSource, run$1).image },
+						...change.status === "D" ? {} : { after: readMemoryImage(root, relative, newSource, run$1).image }
+					}
+				};
+			}
 			if (kind !== "untracked" && !(kind === "current" && phases[0]?.kind === "untracked")) {
 				const diff = output(root, [
 					"diff",
 					"--no-ext-diff",
 					"--no-textconv",
 					"--no-renames",
-					...kind === "staged" ? ["--cached", "HEAD"] : kind === "current" ? ["HEAD"] : [],
+					...kind === "staged" ? ["--cached", comparisonHead] : kind === "current" ? [comparisonHead] : [],
 					"--",
 					relative
 				]);
+				if (markdown !== void 0) {
+					if (head(root) !== comparisonHead || Object.values(markdown).some((document) => {
+						const next = readMemoryMarkdown(root, relative, document.source, run$1);
+						return next.revision !== document.revision || next.status !== document.status;
+					})) throw new MemoryImageError("memory-image-stale", "Markdown changed; refresh the view");
+				}
 				return {
 					...change,
 					diff,
-					binary: /^Binary files .+ differ$/mu.test(diff)
+					binary: /^Binary files .+ differ$/mu.test(diff),
+					...markdown === void 0 ? {} : { markdown }
 				};
 			}
 			const target = resolveMemoryPath(root, relative);
@@ -44870,7 +47365,8 @@ function createMemoryAcceptance(options) {
 			return {
 				...change,
 				diff,
-				binary: false
+				binary: false,
+				...markdown === void 0 ? {} : { markdown }
 			};
 		},
 		recoveryHistory(botSlug) {
@@ -45625,6 +48121,8 @@ function createMemoryService(options) {
 		abortTurn: (botSlug, sessionId, preserveObservation) => requireAcceptance().abortTurn(botSlug, sessionId, preserveObservation),
 		snapshot: (botSlug) => requireAcceptance().snapshot(botSlug),
 		readAccepted: (botSlug, path) => requireAcceptance().readAccepted(botSlug, path),
+		markdownImageFile: (botSlug, path, source, revision, reference) => requireAcceptance().markdownImageFile(botSlug, path, source, revision, reference),
+		imageFile: (botSlug, path, source, revision) => requireAcceptance().imageFile(botSlug, path, source, revision),
 		history: (botSlug, limit) => requireAcceptance().history(botSlug, limit),
 		diff: (botSlug, sha) => requireAcceptance().diff(botSlug, sha),
 		gitGraph: (botSlug, offset) => requireAcceptance().gitGraph(botSlug, offset),
@@ -51446,6 +53944,32 @@ function createPersonaBotRegistry(options) {
 	};
 }
 //#endregion
+//#region packages/core/src/channels/live-frames.ts
+function parseLiveFrame(block) {
+	let event = "message";
+	let id;
+	const data = [];
+	for (const line of block.split("\n")) {
+		if (line.length === 0 || line.startsWith(":")) continue;
+		const colon = line.indexOf(":");
+		const field = colon < 0 ? line : line.slice(0, colon);
+		const rest = colon < 0 ? "" : line.slice(colon + 1);
+		const value = rest.startsWith(" ") ? rest.slice(1) : rest;
+		if (field === "event") event = value;
+		else if (field === "data") data.push(value);
+		else if (field === "id") id = value;
+	}
+	if (data.length === 0) return void 0;
+	return id === void 0 ? {
+		event,
+		data: data.join("\n")
+	} : {
+		event,
+		data: data.join("\n"),
+		id
+	};
+}
+//#endregion
 //#region packages/core/src/bots/cli-live-error.ts
 var CliLiveError = class extends Error {
 	code;
@@ -51461,10 +53985,64 @@ var CliLiveError = class extends Error {
 	}
 };
 //#endregion
+//#region packages/core/src/bots/cli-inbox-watch.ts
+async function watchInbox(stream, read, seconds) {
+	const response = await stream("/api/botharness/stream?scope=roster");
+	if (!response.body || !response.headers.get("content-type")?.includes("text/event-stream")) throw new CliLiveError("host-query-unsupported", "The Host did not open the inbox event stream.");
+	const reader = response.body.getReader();
+	let elapsed = false;
+	let invalidations = 0;
+	let failure;
+	const timer = setTimeout(() => {
+		elapsed = true;
+		reader.cancel().catch(() => {});
+	}, seconds * 1e3);
+	const consuming = (async () => {
+		const decoder = new TextDecoder();
+		let buffer = "";
+		for (;;) {
+			const { value, done } = await reader.read();
+			if (done) {
+				if (!elapsed) throw new CliLiveError("host-unreachable", "The inbox event stream ended before the observation completed.");
+				return;
+			}
+			buffer += decoder.decode(value, { stream: true }).replace(/\r/g, "");
+			let end;
+			while ((end = buffer.indexOf("\n\n")) !== -1) {
+				const frame = parseLiveFrame(buffer.slice(0, end));
+				buffer = buffer.slice(end + 2);
+				if (frame?.event === "human-attention/changed") invalidations++;
+			}
+			if (buffer.length > 1048576) throw new CliLiveError("host-query-unsupported", "The inbox event frame exceeds the supported size.");
+		}
+	})().catch((error) => {
+		failure = error;
+	});
+	try {
+		const initial = await read();
+		await consuming;
+		if (failure) throw failure;
+		return {
+			seconds,
+			invalidations,
+			initial,
+			current: await read()
+		};
+	} finally {
+		clearTimeout(timer);
+		elapsed = true;
+		await reader.cancel().catch(() => {});
+		await consuming;
+		reader.releaseLock();
+	}
+}
+//#endregion
 //#region packages/core/src/bots/cli-inbox.ts
 const INBOX_OPTIONS = {
 	category: { type: "string" },
+	"watch-seconds": { type: "string" },
 	channel: { type: "string" },
+	request: { type: "string" },
 	sort: { type: "string" },
 	search: { type: "string" },
 	unread: { type: "boolean" },
@@ -51482,6 +54060,14 @@ const INBOX_OPTIONS = {
 	snoozed: { type: "boolean" }
 };
 const INBOX_COMMANDS = [
+	{
+		command: "grant-request-approve",
+		description: "approve persistent read/write for one workspace request (needs --confirm)"
+	},
+	{
+		command: "inbox-watch",
+		description: "observe live inbox changes for a bounded time and return one JSON snapshot"
+	},
 	{
 		command: "inbox",
 		description: "list Human Inbox items by category, Bot or Channel"
@@ -51555,30 +54141,41 @@ const CATEGORIES = [
 	"replies",
 	"handled"
 ];
-function usage$17(message) {
+function usage$18(message) {
 	throw new CliLiveError("usage", message);
 }
 function isInboxCommand(command) {
 	return INBOX_COMMANDS.some((entry) => entry.command === command) || INBOX_HOST_COMMANDS.some((entry) => entry === command);
 }
 function positionals(command, rest, count, name) {
-	if (rest.length !== count || rest.some((value) => !value.trim())) usage$17(count === 0 ? `${command} takes no positional arguments.` : `${command} needs ${name}.`);
+	if (rest.length !== count || rest.some((value) => !value.trim())) usage$18(count === 0 ? `${command} takes no positional arguments.` : `${command} needs ${name}.`);
 	return rest.map((value) => value.trim());
 }
 function required$4(value, flag, command) {
 	const next = value?.trim();
-	if (!next) usage$17(`${command} requires --${flag}.`);
+	if (!next) usage$18(`${command} requires --${flag}.`);
 	return next;
 }
 function toggle(command, on, off, flags) {
-	if (on === true === (off === true)) usage$17(`${command} needs --${flags[0]} or --${flags[1]}, not both or neither.`);
+	if (on === true === (off === true)) usage$18(`${command} needs --${flags[0]} or --${flags[1]}, not both or neither.`);
 	return on === true;
 }
 function confirmed(command, values) {
-	if (values.confirm !== true) usage$17(`${command} is destructive; repeat it with --confirm, as the Web UI asks you to.`);
+	if (values.confirm !== true) usage$18(`${command} is destructive; repeat it with --confirm, as the Web UI asks you to.`);
 }
 async function runInboxCommand(command, rest, values, connect) {
-	const call = prepare(command, rest, values);
+	const call = prepare(command === "inbox-watch" ? "inbox" : command, rest, values);
+	if (command === "inbox-watch") {
+		const seconds = Number(values["watch-seconds"] ?? 10);
+		if (!Number.isInteger(seconds) || seconds < 1 || seconds > 60) usage$18("--watch-seconds must be 1–60.");
+		const host = await connect();
+		if (!host.stream) throw new CliLiveError("host-query-unsupported", "This connection cannot watch live inbox changes.");
+		return watchInbox(host.stream, async () => {
+			const result = await host.rpc(call.method, call.args);
+			if (call.args["queryVersion"] === 1 && result["queryVersion"] !== 1) throw new CliLiveError("host-query-unsupported", "Update the Host to use Activity query filters.");
+			return result;
+		}, seconds);
+	}
 	const { rpc } = await connect();
 	const result = await rpc(call.method, call.args);
 	if (call.args["queryVersion"] === 1 && result["queryVersion"] !== 1) throw new CliLiveError("host-query-unsupported", "Update the Host to use Activity search, unread filtering and mention ordering.");
@@ -51594,12 +54191,12 @@ function prepare(command, rest, values) {
 	switch (command) {
 		case "inbox": {
 			positionals(command, rest, 0, "");
-			if (values.category !== void 0 && !CATEGORIES.includes(values.category)) usage$17(`--category must be one of ${CATEGORIES.join(", ")}.`);
-			if (values.sort !== void 0 && values.sort !== "newest" && values.sort !== "oldest" && !(values.sort === "mentions-first" && values.category === "replies")) usage$17("--sort must be newest, oldest, or mentions-first with --category replies.");
-			if (values.search !== void 0 && values.search.length > 200) usage$17("--search must be at most 200 characters.");
-			if (values.kind !== void 0 && values.kind !== "auto-rejection") usage$17("--kind must be auto-rejection.");
+			if (values.category !== void 0 && !CATEGORIES.includes(values.category)) usage$18(`--category must be one of ${CATEGORIES.join(", ")}.`);
+			if (values.sort !== void 0 && values.sort !== "newest" && values.sort !== "oldest" && !(values.sort === "mentions-first" && values.category === "replies")) usage$18("--sort must be newest, oldest, or mentions-first with --category replies.");
+			if (values.search !== void 0 && values.search.length > 200) usage$18("--search must be at most 200 characters.");
+			if (values.kind !== void 0 && values.kind !== "auto-rejection") usage$18("--kind must be auto-rejection.");
 			const limit = values.limit === void 0 ? void 0 : Number(values.limit);
-			if (limit !== void 0 && (!Number.isSafeInteger(limit) || limit < 1 || limit > 100)) usage$17("--limit must be 1–100.");
+			if (limit !== void 0 && (!Number.isSafeInteger(limit) || limit < 1 || limit > 100)) usage$18("--limit must be 1–100.");
 			return {
 				method: "humanAttention",
 				args: {
@@ -51619,7 +54216,7 @@ function prepare(command, rest, values) {
 		}
 		case "inbox-allow-once": {
 			const [itemId] = positionals(command, rest, 1, "exactly one auto-rejection item id");
-			if (!itemId.startsWith("autoreject:")) usage$17("inbox-allow-once takes an auto-rejection item id (autoreject:…).");
+			if (!itemId.startsWith("autoreject:")) usage$18("inbox-allow-once takes an auto-rejection item id (autoreject:…).");
 			return {
 				method: "toolAutoRejectionOverride",
 				args: { itemId }
@@ -51629,7 +54226,7 @@ function prepare(command, rest, values) {
 			positionals(command, rest, 0, "");
 			return {
 				method: "humanAttentionStatus",
-				args: {}
+				args: { messageCounts: true }
 			};
 		case "inbox-dismiss": {
 			const [itemId] = positionals(command, rest, 1, "exactly one inbox item id");
@@ -51643,11 +54240,11 @@ function prepare(command, rest, values) {
 		}
 		case "inbox-snooze": {
 			const [itemId] = positionals(command, rest, 1, "exactly one inbox item id");
-			if (values.until !== void 0 === (values.clear === true)) usage$17("inbox-snooze needs --until <ISO time> or --clear, not both or neither.");
+			if (values.until !== void 0 === (values.clear === true)) usage$18("inbox-snooze needs --until <ISO time> or --clear, not both or neither.");
 			let until = null;
 			if (values.until !== void 0) {
 				const at = Date.parse(values.until.trim());
-				if (Number.isNaN(at)) usage$17("--until must be an ISO time such as 2026-10-15T09:00:00Z.");
+				if (Number.isNaN(at)) usage$18("--until must be an ISO time such as 2026-10-15T09:00:00Z.");
 				until = new Date(at).toISOString();
 			}
 			return {
@@ -51686,9 +54283,9 @@ function prepare(command, rest, values) {
 		}
 		case "channel-assign": {
 			const [channelId] = positionals(command, rest, 1, "exactly one channel id");
-			if (values.section !== void 0 === (values.unsectioned === true)) usage$17("channel-assign needs --section <id> or --unsectioned, not both or neither.");
+			if (values.section !== void 0 === (values.unsectioned === true)) usage$18("channel-assign needs --section <id> or --unsectioned, not both or neither.");
 			const index = values.index === void 0 ? void 0 : Number(values.index);
-			if (index !== void 0 && (!Number.isSafeInteger(index) || index < 0)) usage$17("--index must be a nonnegative integer.");
+			if (index !== void 0 && (!Number.isSafeInteger(index) || index < 0)) usage$18("--index must be a nonnegative integer.");
 			return {
 				method: "channelAssign",
 				args: {
@@ -51753,6 +54350,20 @@ function prepare(command, rest, values) {
 				}
 			};
 		}
+		case "grant-request-approve": {
+			const [slug] = positionals(command, rest, 1, "exactly one bot id");
+			confirmed(command, values);
+			return {
+				method: "grantRequestApprove",
+				args: {
+					slug,
+					channelId: required$4(values.channel, "channel", command),
+					requestMessageId: required$4(values.request, "request", command),
+					workspaceId: required$4(values.workspace, "workspace", command),
+					acknowledgeReadWrite: true
+				}
+			};
+		}
 		case "grant-write-set": {
 			const [slug] = positionals(command, rest, 1, "exactly one bot id");
 			return {
@@ -51787,10 +54398,274 @@ function prepare(command, rest, values) {
 				}
 			};
 		}
-		default: usage$17(`Unsupported inbox command ${command}.`);
+		default: usage$18(`Unsupported inbox command ${command}.`);
 	}
 }
 //#endregion
+//#region packages/core/src/bots/cli-window-zoom.ts
+const WINDOW_ZOOM_COMMANDS = [
+	{
+		command: "window-zoom-clients",
+		description: "list active desktop window targets"
+	},
+	{
+		command: "window-zoom-get",
+		description: "read zoom from an explicit --client-id"
+	},
+	{
+		command: "window-zoom-set",
+		description: "set --zoom-level (-8..8), optionally --zoom-default, on an explicit Client"
+	},
+	{
+		command: "window-zoom-reset",
+		description: "restore the explicit Client window to its saved default zoom"
+	}
+];
+const WINDOW_ZOOM_OPTIONS = {
+	"client-id": { type: "string" },
+	"zoom-level": { type: "string" },
+	"zoom-default": { type: "boolean" }
+};
+async function runWindowZoomCommand(command, rest, values, connect) {
+	const list = command === "window-zoom-clients";
+	const write = command === "window-zoom-set" || command === "window-zoom-reset";
+	if (rest.length || (list ? !!values["client-id"] : !values["client-id"])) throw new CliLiveError("usage", "Select exactly one --client-id from window-zoom-clients.");
+	if (write ? !values["expected-revision"] : !!values["expected-revision"]) throw new CliLiveError("usage", "Writes require --expected-revision from window-zoom-get.");
+	let operation;
+	if (command === "window-zoom-set") {
+		const raw = values["zoom-level"];
+		if (raw === void 0 || !/^-?[0-8]$/.test(raw)) throw new CliLiveError("usage", "Specify integer --zoom-level from -8 to 8.");
+		operation = {
+			type: values["zoom-default"] ? "default" : "set",
+			level: Number(raw)
+		};
+	} else {
+		if (values["zoom-level"] !== void 0 || values["zoom-default"]) throw new CliLiveError("usage", "Zoom level/default options require window-zoom-set.");
+		if (command === "window-zoom-reset") operation = { type: "reset" };
+	}
+	const result = await (await connect()).http("/api/botharness/window-zoom-control", list ? void 0 : {
+		action: "request",
+		clientId: values["client-id"],
+		...write ? {
+			operation,
+			expectedRevision: values["expected-revision"]
+		} : {}
+	});
+	return JSON.parse(new TextDecoder().decode(result.bytes));
+}
+//#endregion
+//#region packages/core/src/bots/cli-wallpaper.ts
+const WALLPAPER_COMMANDS = [
+	{
+		command: "wallpaper-get",
+		description: "read the explicit Client local wallpaper metadata and revision"
+	},
+	{
+		command: "wallpaper-import",
+		description: "read --file on this CLI machine and import image/video media to --client-id with --expected-revision"
+	},
+	{
+		command: "wallpaper-crop",
+		description: "save {x,y,zoom} from --patch-stdin on --client-id with --expected-revision"
+	},
+	{
+		command: "wallpaper-remove",
+		description: "delete the shown wallpaper, or --wallpaper-item, from the library with --expected-revision"
+	},
+	{
+		command: "wallpaper-select",
+		description: "show library --wallpaper-item <id>, or none, on --client-id with --expected-revision"
+	},
+	{
+		command: "wallpaper-rotation",
+		description: "set {interval,shuffle} from --patch-stdin; interval is 0 or 60000/300000/900000/1800000/3600000 ms"
+	}
+];
+const WALLPAPER_OPTIONS = { "wallpaper-item": { type: "string" } };
+async function runWallpaperCommand(command, rest, values, io, connect) {
+	if (rest.length || !values["client-id"]) throw new CliLiveError("usage", "Wallpaper commands require exactly one --client-id.");
+	if (command !== "wallpaper-get" && !values["expected-revision"]) throw new CliLiveError("usage", "Read wallpaper-get and supply its --expected-revision.");
+	if (command === "wallpaper-get" && (values["expected-revision"] || values.file || values["patch-stdin"])) throw new CliLiveError("usage", "wallpaper-get takes no write options.");
+	if (values.file && command !== "wallpaper-import") throw new CliLiveError("usage", "--file requires wallpaper-import.");
+	if (values["patch-stdin"] && ![
+		"wallpaper-import",
+		"wallpaper-crop",
+		"wallpaper-rotation"
+	].includes(command)) throw new CliLiveError("usage", "--patch-stdin requires wallpaper-import, wallpaper-crop or wallpaper-rotation.");
+	const item = values["wallpaper-item"];
+	if (item !== void 0 && ![
+		"wallpaper-crop",
+		"wallpaper-remove",
+		"wallpaper-select"
+	].includes(command)) throw new CliLiveError("usage", "--wallpaper-item requires wallpaper-crop, wallpaper-remove or wallpaper-select.");
+	if (command === "wallpaper-select" && !item) throw new CliLiveError("usage", "wallpaper-select requires --wallpaper-item <id> from wallpaper-get, or none.");
+	let crop;
+	if (values["patch-stdin"]) try {
+		crop = JSON.parse(await (io.readStdin?.() ?? Promise.resolve("")));
+	} catch {
+		throw new CliLiveError("usage", "Invalid crop JSON.");
+	}
+	if (command === "wallpaper-rotation") {
+		const rotation = crop;
+		if (!rotation || typeof rotation !== "object" || Array.isArray(rotation) || !Object.keys(rotation).length || Object.keys(rotation).some((key) => !["interval", "shuffle"].includes(key))) throw new CliLiveError("usage", "wallpaper-rotation requires --patch-stdin with interval and/or shuffle.");
+	}
+	if (command === "wallpaper-crop" && crop === void 0) throw new CliLiveError("usage", "wallpaper-crop requires --patch-stdin.");
+	let bytes;
+	if (command === "wallpaper-import") {
+		if (!values.file) throw new CliLiveError("usage", "wallpaper-import requires --file on this CLI machine.");
+		try {
+			const path = resolve(values.file);
+			const stat = statSync(path);
+			if (!stat.isFile() || stat.size < 1 || stat.size > 104857600) throw new CliLiveError("wallpaper-size-invalid", "Media must be nonempty: images up to 20 MB and videos up to 100 MB; the Client verifies decoding.");
+			bytes = readFileSync(path);
+			if (bytes.length !== stat.size) throw new CliLiveError("wallpaper-file-changed", "The input file changed while reading it.");
+		} catch (error) {
+			if (error instanceof CliLiveError) throw error;
+			throw new CliLiveError("wallpaper-file-unavailable", "Cannot read the input media on this CLI machine.");
+		}
+	}
+	const host = await connect();
+	const request = async (wallpaper) => {
+		for (let attempt = 0;; attempt++) try {
+			const reply = await host.http("/api/botharness/appearance-control", {
+				action: "request",
+				clientId: values["client-id"],
+				...values["expected-revision"] ? { expectedRevision: values["expected-revision"] } : {},
+				wallpaper
+			});
+			return JSON.parse(new TextDecoder().decode(reply.bytes));
+		} catch (error) {
+			if (!(error instanceof CliLiveError) || error.code !== "appearance-client-unavailable" || attempt >= 20) throw error;
+			await new Promise((resolve) => setTimeout(resolve, 50));
+		}
+	};
+	if (command === "wallpaper-get") return request({ action: "read" });
+	const target = item === void 0 ? {} : { item };
+	if (command === "wallpaper-remove") return request({
+		action: "remove",
+		...target
+	});
+	if (command === "wallpaper-crop") return request({
+		action: "crop",
+		crop,
+		...target
+	});
+	if (command === "wallpaper-select") return request({
+		action: "select",
+		...item === "none" ? {} : target
+	});
+	if (command === "wallpaper-rotation") return request({
+		action: "rotation",
+		...crop
+	});
+	const begin = await request({
+		action: "begin",
+		size: bytes.length
+	});
+	if (typeof begin.uploadId !== "string") throw new CliLiveError("host-protocol-error", "Client returned no upload receipt.");
+	try {
+		for (let offset = 0; offset < bytes.length; offset += 196608) {
+			const chunk = bytes.subarray(offset, offset + 196608);
+			if ((await request({
+				action: "append",
+				uploadId: begin.uploadId,
+				offset,
+				data: chunk.toString("base64")
+			})).offset !== offset + chunk.length) throw new CliLiveError("host-protocol-error", "Client acknowledged a different upload offset.");
+		}
+		return await request({
+			action: "commit",
+			uploadId: begin.uploadId,
+			...crop === void 0 ? {} : { crop }
+		});
+	} catch (error) {
+		await request({
+			action: "cancel",
+			uploadId: begin.uploadId
+		}).catch(() => {});
+		throw error;
+	}
+}
+//#endregion
+//#region packages/core/src/bots/cli-appearance.ts
+const APPEARANCE_COMMANDS = [
+	...WALLPAPER_COMMANDS,
+	{
+		command: "appearance-clear-panels",
+		description: "clear only --mode light/dark Panel overrides on an explicit Client with --expected-revision"
+	},
+	{
+		command: "appearance-reset",
+		description: "reset both modes and wallpaper on --client-id with --confirm-reset and both expected revisions"
+	},
+	{
+		command: "appearance-targets",
+		description: "list functional Panel appearance targets on an explicit --client-id"
+	},
+	{
+		command: "appearance-clients",
+		description: "list online Client targets for device-local DeepSeekBot appearance"
+	},
+	{
+		command: "appearance-get",
+		description: "read device-local appearance from an explicit --client-id"
+	},
+	{
+		command: "appearance-set",
+		description: "write --patch-stdin to an explicit --client-id with --expected-revision"
+	}
+];
+const APPEARANCE_OPTIONS = {
+	...WALLPAPER_OPTIONS,
+	"client-id": { type: "string" },
+	"confirm-reset": { type: "boolean" },
+	"expected-wallpaper-revision": { type: "string" }
+};
+async function runAppearanceCommand(command, rest, values, io, connect) {
+	if (command.startsWith("wallpaper-")) return runWallpaperCommand(command, rest, values, io, connect);
+	if (rest.length || command !== "appearance-clients" && !values["client-id"]) throw new CliLiveError("usage", "Specify exactly one --client-id from appearance-clients.");
+	if (command === "appearance-clients" && values["client-id"]) throw new CliLiveError("usage", "appearance-clients does not take a target.");
+	if (command !== "appearance-reset" && (values["confirm-reset"] || values["expected-wallpaper-revision"])) throw new CliLiveError("usage", "Reset confirmation and wallpaper revision require appearance-reset.");
+	let recovery;
+	let patch;
+	if (command === "appearance-reset") {
+		if (!values["confirm-reset"] || !values["expected-revision"] || !values["expected-wallpaper-revision"] || values["patch-stdin"] || values.mode || values.file) throw new CliLiveError("usage", "appearance-reset requires --confirm-reset, --expected-revision and --expected-wallpaper-revision from the selected Client.");
+		recovery = {
+			action: "reset-all",
+			confirmed: true,
+			wallpaperRevision: values["expected-wallpaper-revision"]
+		};
+	} else if (command === "appearance-clear-panels") {
+		if (!values["expected-revision"] || !["light", "dark"].includes(values.mode ?? "") || values["patch-stdin"] || values.file) throw new CliLiveError("usage", "appearance-clear-panels requires --mode light/dark and --expected-revision.");
+		patch = {
+			mode: values.mode,
+			clearPanels: true
+		};
+	}
+	if (command === "appearance-set") {
+		if (!values["patch-stdin"] || !values["expected-revision"]) throw new CliLiveError("usage", "appearance-set needs --patch-stdin and --expected-revision from appearance-get.");
+		try {
+			patch = JSON.parse(await (io.readStdin?.() ?? Promise.resolve("")));
+		} catch {
+			throw new CliLiveError("usage", "Invalid appearance JSON on stdin.");
+		}
+		if (typeof patch !== "object" || patch === null || Array.isArray(patch)) throw new CliLiveError("usage", "Appearance patch must be an object.");
+	} else if (!["appearance-clear-panels", "appearance-reset"].includes(command) && (values["patch-stdin"] || values["expected-revision"])) throw new CliLiveError("usage", "Write options require appearance-set.");
+	const response = await (await connect()).http("/api/botharness/appearance-control", command === "appearance-clients" ? void 0 : {
+		action: "request",
+		clientId: values["client-id"],
+		...patch === void 0 ? {} : {
+			patch,
+			expectedRevision: values["expected-revision"]
+		},
+		...recovery === void 0 ? {} : {
+			recovery,
+			expectedRevision: values["expected-revision"]
+		}
+	});
+	return JSON.parse(new TextDecoder().decode(response.bytes));
+}
+//#endregion
 //#region packages/core/src/cloud/management.ts
 function parseCloudManagement(value) {
 	if (!value || typeof value !== "object" || Array.isArray(value)) throw new ClientError("INVALID_CLOUD_INPUT");
@@ -51910,22 +54785,22 @@ const BOT_TOOL_COMMANDS = [{
 	command: "bot-tool",
 	description: "run one Harness Bot tool as a Bot directly, without the model (args JSON from stdin)"
 }];
-function usage$16(message) {
+function usage$17(message) {
 	throw new CliLiveError("usage", message);
 }
 async function runBotToolCommand(command, rest, values, io, connect) {
 	if (command === "bot-tools") {
-		if (rest.length !== 0) usage$16("bot-tools takes no positional arguments.");
+		if (rest.length !== 0) usage$17("bot-tools takes no positional arguments.");
 		return (await connect()).rpc("botTools", {});
 	}
-	if (rest.length !== 2 || rest.some((value) => !value.trim())) usage$16("bot-tool needs a bot id and a tool name.");
+	if (rest.length !== 2 || rest.some((value) => !value.trim())) usage$17("bot-tool needs a bot id and a tool name.");
 	let args = {};
 	if (values["args-stdin"] === true) try {
 		const parsed = JSON.parse(await (io.readStdin?.() ?? Promise.resolve("")));
 		if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) throw new Error("not an object");
 		args = parsed;
 	} catch {
-		usage$16("--args-stdin must be a JSON object of tool arguments.");
+		usage$17("--args-stdin must be a JSON object of tool arguments.");
 	}
 	return (await connect()).rpc("botToolRun", {
 		slug: rest[0].trim(),
@@ -52082,11 +54957,11 @@ const DIRECTIONS = /* @__PURE__ */ new Set([
 	"around"
 ]);
 const MAX_AVATAR_BYTES = 98304;
-function usage$15(message) {
+function usage$16(message) {
 	throw new CliLiveError("usage", message);
 }
 function channelOperationKey(value) {
-	if (!/^[A-Za-z0-9][A-Za-z0-9._:-]{7,127}$/u.test(value)) usage$15("--operation-key must be 8–128 letters, digits, dots, underscores, colons or hyphens, starting with a letter or digit.");
+	if (!/^[A-Za-z0-9][A-Za-z0-9._:-]{7,127}$/u.test(value)) usage$16("--operation-key must be 8–128 letters, digits, dots, underscores, colons or hyphens, starting with a letter or digit.");
 	return value;
 }
 function isChannelCommand(command) {
@@ -52095,12 +54970,12 @@ function isChannelCommand(command) {
 function integer$1(value, flag, min, max) {
 	if (value === void 0) return void 0;
 	const parsed = Number(value);
-	if (!/^\d+$/u.test(value.trim()) || !Number.isSafeInteger(parsed) || parsed < min || parsed > max) usage$15(`${flag} must be an integer from ${String(min)} to ${String(max)}.`);
+	if (!/^\d+$/u.test(value.trim()) || !Number.isSafeInteger(parsed) || parsed < min || parsed > max) usage$16(`${flag} must be an integer from ${String(min)} to ${String(max)}.`);
 	return parsed;
 }
 function required$3(value, flag) {
 	const trimmed = value?.trim();
-	if (!trimmed) usage$15(`${flag} is required.`);
+	if (!trimmed) usage$16(`${flag} is required.`);
 	return trimmed;
 }
 function channelAvatarDataUrl(path) {
@@ -52108,9 +54983,9 @@ function channelAvatarDataUrl(path) {
 	try {
 		bytes = readFileSync(path);
 	} catch {
-		usage$15("Cannot read --avatar-file.");
+		usage$16("Cannot read --avatar-file.");
 	}
-	if (bytes.length === 0 || bytes.length > MAX_AVATAR_BYTES) usage$15(`--avatar-file must be 1 to ${String(MAX_AVATAR_BYTES)} bytes.`);
+	if (bytes.length === 0 || bytes.length > MAX_AVATAR_BYTES) usage$16(`--avatar-file must be 1 to ${String(MAX_AVATAR_BYTES)} bytes.`);
 	return `data:image/${bytes.subarray(0, 8).equals(Buffer.from([
 		137,
 		80,
@@ -52120,26 +54995,26 @@ function channelAvatarDataUrl(path) {
 		10,
 		26,
 		10
-	])) ? "png" : bytes[0] === 255 && bytes[1] === 216 && bytes[2] === 255 ? "jpeg" : bytes.toString("ascii", 0, 4) === "RIFF" && bytes.toString("ascii", 8, 12) === "WEBP" ? "webp" : usage$15("--avatar-file must be a PNG, JPEG or WebP image.")};base64,${bytes.toString("base64")}`;
+	])) ? "png" : bytes[0] === 255 && bytes[1] === 216 && bytes[2] === 255 ? "jpeg" : bytes.toString("ascii", 0, 4) === "RIFF" && bytes.toString("ascii", 8, 12) === "WEBP" ? "webp" : usage$16("--avatar-file must be a PNG, JPEG or WebP image.")};base64,${bytes.toString("base64")}`;
 }
 async function purgeToken(io) {
 	let input;
 	try {
 		input = JSON.parse(await (io.readStdin?.() ?? Promise.resolve("")));
 	} catch {
-		usage$15("Confirmation stdin must be JSON with the token from channel-purge-preview.");
+		usage$16("Confirmation stdin must be JSON with the token from channel-purge-preview.");
 	}
-	if (typeof input !== "object" || input === null || !("token" in input) || typeof input.token !== "string" || !input.token.trim() || input.token.length > 512) usage$15("Confirmation stdin must contain the token string from channel-purge-preview.");
+	if (typeof input !== "object" || input === null || !("token" in input) || typeof input.token !== "string" || !input.token.trim() || input.token.length > 512) usage$16("Confirmation stdin must contain the token string from channel-purge-preview.");
 	return input.token;
 }
 async function runChannelCommand(command, rest, input, io, connect) {
 	const values = input;
 	const noTarget = command === "channel-history" || command === "channel-mark-all-read" || command === "channel-unread";
-	if (rest.length !== (noTarget ? 0 : 1)) usage$15(`${command} ${noTarget ? "takes no positional arguments" : "needs exactly one Channel ID"}.`);
+	if (rest.length !== (noTarget ? 0 : 1)) usage$16(`${command} ${noTarget ? "takes no positional arguments" : "needs exactly one Channel ID"}.`);
 	const channelId = rest[0]?.trim() ?? "";
-	if (!noTarget && !channelId) usage$15(`${command} requires a nonempty Channel ID.`);
+	if (!noTarget && !channelId) usage$16(`${command} requires a nonempty Channel ID.`);
 	const seconds = values.timeout === void 0 ? 120 : Number(values.timeout);
-	if (!Number.isFinite(seconds) || seconds <= 0 || seconds > 600) usage$15("--timeout must be between 0 and 600 seconds.");
+	if (!Number.isFinite(seconds) || seconds <= 0 || seconds > 600) usage$16("--timeout must be between 0 and 600 seconds.");
 	let args = { channelId };
 	let method;
 	switch (command) {
@@ -52149,7 +55024,7 @@ async function runChannelCommand(command, rest, input, io, connect) {
 		case "channel-media-target":
 		case "channel-media-download":
 			method = "channelMediaTarget";
-			if (values["source-event"]?.length !== 1) usage$15("--source-event must identify exactly one Source Event.");
+			if (values["source-event"]?.length !== 1) usage$16("--source-event must identify exactly one Source Event.");
 			args.sourceEventId = required$3(values["source-event"][0], "--source-event");
 			args.attachmentId = required$3(values.attachment, "--attachment");
 			if (command === "channel-media-download") required$3(values.out, "--out");
@@ -52160,7 +55035,7 @@ async function runChannelCommand(command, rest, input, io, connect) {
 			break;
 		case "group-avatar-set":
 			method = "channelGroupAvatarSet";
-			if (values["avatar-file"] === void 0 === (values.clear !== true)) usage$15("group-avatar-set needs exactly one of --avatar-file <path> or --clear.");
+			if (values["avatar-file"] === void 0 === (values.clear !== true)) usage$16("group-avatar-set needs exactly one of --avatar-file <path> or --clear.");
 			args.avatar = values.clear === true ? null : channelAvatarDataUrl(values["avatar-file"]);
 			break;
 		case "group-invite":
@@ -52175,7 +55050,7 @@ async function runChannelCommand(command, rest, input, io, connect) {
 			break;
 		case "group-join-decide":
 			method = "channelGroupJoinDecide";
-			if (values.accept === values.decline) usage$15("group-join-decide needs exactly one of --accept or --decline.");
+			if (values.accept === values.decline) usage$16("group-join-decide needs exactly one of --accept or --decline.");
 			args.requestId = required$3(values.request, "--request");
 			args.accept = values.accept === true;
 			break;
@@ -52185,7 +55060,7 @@ async function runChannelCommand(command, rest, input, io, connect) {
 			break;
 		case "group-send-review":
 			method = "channelGroupSendReview";
-			if (values.accept && values.off) usage$15("Choose --accept or --off");
+			if (values.accept && values.off) usage$16("Choose --accept or --off");
 			if (values.accept || values.off) args.enabled = values.accept === true;
 			break;
 		case "group-wake-policies":
@@ -52194,7 +55069,7 @@ async function runChannelCommand(command, rest, input, io, connect) {
 		case "group-wake-set": {
 			method = "channelGroupWakeSet";
 			const mode = values.mode ?? (values.inherit === true ? "digest" : void 0);
-			if (mode === void 0 || !WAKE_MODES.has(mode)) usage$15("--mode must be all, mentions, digest or silent, unless --inherit resets it.");
+			if (mode === void 0 || !WAKE_MODES.has(mode)) usage$16("--mode must be all, mentions, digest or silent, unless --inherit resets it.");
 			args = {
 				channelId,
 				botSlug: required$3(values.bot, "--bot"),
@@ -52207,7 +55082,7 @@ async function runChannelCommand(command, rest, input, io, connect) {
 		}
 		case "group-delete":
 			method = "channelGroupDelete";
-			if (values.confirm !== true) usage$15("Deleting a group removes it for every member. Pass --confirm to delete it.");
+			if (values.confirm !== true) usage$16("Deleting a group removes it for every member. Pass --confirm to delete it.");
 			break;
 		case "channel-history":
 			method = "channelHistory";
@@ -52215,7 +55090,7 @@ async function runChannelCommand(command, rest, input, io, connect) {
 			break;
 		case "channel-history-sources":
 			method = "channelHistorySources";
-			if (values.before !== void 0 && !/^\d+$/u.test(values.before)) usage$15("--before must be the numeric cursor from the previous page.");
+			if (values.before !== void 0 && !/^\d+$/u.test(values.before)) usage$16("--before must be the numeric cursor from the previous page.");
 			if (values.before !== void 0) args.before = values.before;
 			break;
 		case "channel-journal": {
@@ -52233,8 +55108,8 @@ async function runChannelCommand(command, rest, input, io, connect) {
 		}
 		case "channel-timeline": {
 			method = "channelTimeline";
-			if (values.direction !== void 0 && !DIRECTIONS.has(values.direction)) usage$15("--direction must be older, newer or around.");
-			if (values.direction === "around" && !values.around?.trim()) usage$15("--direction around needs --around <message-id>.");
+			if (values.direction !== void 0 && !DIRECTIONS.has(values.direction)) usage$16("--direction must be older, newer or around.");
+			if (values.direction === "around" && !values.around?.trim()) usage$16("--direction around needs --around <message-id>.");
 			const limit = integer$1(values.limit, "--limit", 1, 200);
 			const olderLimit = integer$1(values["older-limit"], "--older-limit", 0, 200);
 			const newerLimit = integer$1(values["newer-limit"], "--newer-limit", 0, 200);
@@ -52291,11 +55166,11 @@ async function runChannelCommand(command, rest, input, io, connect) {
 		case "channel-purge-confirm": {
 			method = command === "channel-purge-preview" ? "channelPurgePreview" : "channelPurgeConfirm";
 			const sourceEventIds = (values["source-event"] ?? []).map((id) => id.trim()).filter(Boolean);
-			if (sourceEventIds.length === 0 || sourceEventIds.length > 100) usage$15(`${command} needs 1 to 100 --source-event <id> flags.`);
+			if (sourceEventIds.length === 0 || sourceEventIds.length > 100) usage$16(`${command} needs 1 to 100 --source-event <id> flags.`);
 			args.sourceEventIds = [...new Set(sourceEventIds)];
 			if (command === "channel-purge-confirm") {
-				if (values.confirm !== true) usage$15("Purging permanently removes these Source Events and their content. Pass --confirm.");
-				if (values["confirmation-stdin"] !== true) usage$15("channel-purge-confirm reads the preview token with --confirmation-stdin.");
+				if (values.confirm !== true) usage$16("Purging permanently removes these Source Events and their content. Pass --confirm.");
+				if (values["confirmation-stdin"] !== true) usage$16("channel-purge-confirm reads the preview token with --confirmation-stdin.");
 				args.token = await purgeToken(io);
 			}
 			break;
@@ -52303,7 +55178,7 @@ async function runChannelCommand(command, rest, input, io, connect) {
 	}
 	if (values["expected-channel"] !== void 0 && command !== "group-invite") {
 		const fingerprint = required$3(values["expected-channel"], "--expected-channel");
-		if (!/^[a-f0-9]{64}$/u.test(fingerprint)) usage$15("--expected-channel must be the observed Channel fingerprint.");
+		if (!/^[a-f0-9]{64}$/u.test(fingerprint)) usage$16("--expected-channel must be the observed Channel fingerprint.");
 		args.expectedChannel = fingerprint;
 	}
 	const host = await connect(values, io, AbortSignal.timeout(Math.ceil(seconds * 1e3)));
@@ -52429,7 +55304,7 @@ const CONFIRMED = [
 function isBrowserComputerCommand(command) {
 	return BROWSER_COMPUTER_COMMANDS.some((entry) => entry.command === command);
 }
-function usage$14(message) {
+function usage$15(message) {
 	throw new CliLiveError("usage", message);
 }
 const absolute = (value) => value.startsWith("/") || /^[A-Za-z]:[\\/]/u.test(value);
@@ -52514,34 +55389,34 @@ function probeSignaling(socket, deadlineMs = PROBE_DEADLINE_MS) {
 function count$1(value, flag, max) {
 	if (value === void 0) return void 0;
 	const parsed = Number(value);
-	if (!Number.isSafeInteger(parsed) || parsed < 0 || parsed > max) usage$14(`${flag} must be an integer from 0 to ${String(max)}.`);
+	if (!Number.isSafeInteger(parsed) || parsed < 0 || parsed > max) usage$15(`${flag} must be an integer from 0 to ${String(max)}.`);
 	return parsed;
 }
 async function runBrowserComputerCommand(command, rest, values, io, connect) {
 	const positionals = BOT_COMMANDS.includes(command) || FILE_COMMANDS.includes(command) ? 1 : 0;
-	if (rest.length !== positionals || rest.some((value) => !value.trim())) usage$14(positionals === 0 ? `${command} takes no positional arguments.` : FILE_COMMANDS.includes(command) ? `${command} needs exactly one ${command === "computer-upload" ? "local file" : "archive name"}.` : `${command} needs exactly one bot id.`);
+	if (rest.length !== positionals || rest.some((value) => !value.trim())) usage$15(positionals === 0 ? `${command} takes no positional arguments.` : FILE_COMMANDS.includes(command) ? `${command} needs exactly one ${command === "computer-upload" ? "local file" : "archive name"}.` : `${command} needs exactly one bot id.`);
 	const target = rest[0]?.trim() ?? "";
-	if (CONFIRMED.includes(command) && values.confirm !== true) usage$14(command === "computer-import" ? "computer-import replaces Container Computer data with the archive. Pass --confirm." : `${command} installs system packages on the Host. Pass --confirm.`);
-	if (values.out !== void 0 && !absolute(values.out)) usage$14("--out must be an absolute file path.");
-	if (values.dir !== void 0 && !absolute(values.dir)) usage$14("--dir must be an absolute folder.");
+	if (CONFIRMED.includes(command) && values.confirm !== true) usage$15(command === "computer-import" ? "computer-import replaces Container Computer data with the archive. Pass --confirm." : `${command} installs system packages on the Host. Pass --confirm.`);
+	if (values.out !== void 0 && !absolute(values.out)) usage$15("--out must be an absolute file path.");
+	if (values.dir !== void 0 && !absolute(values.dir)) usage$15("--dir must be an absolute folder.");
 	const viewer = values.viewer?.trim() ?? "";
-	if (command === "browser-webrtc" && !/^[a-f0-9]{24}$/u.test(viewer)) usage$14("browser-webrtc needs --viewer <id>, the id in the Container Browser viewer path /botharness-browser/viewer/<id>/.");
-	if (command === "browser-profile-set" && !values.profile?.trim()) usage$14("browser-profile-set requires --profile <name> or --profile default.");
+	if (command === "browser-webrtc" && !/^[a-f0-9]{24}$/u.test(viewer)) usage$15("browser-webrtc needs --viewer <id>, the id in the Container Browser viewer path /botharness-browser/viewer/<id>/.");
+	if (command === "browser-profile-set" && !values.profile?.trim()) usage$15("browser-profile-set requires --profile <name> or --profile default.");
 	const packages = (values.package ?? []).map((name) => name.trim()).filter(Boolean);
-	if (command === "browser-install-packages" && packages.length === 0) usage$14("browser-install-packages needs --package for each library the Browser reported.");
-	if (command === "computer-import" && !archiveName(target)) usage$14("computer-import needs an archive name from computer-exports, such as computer.tar.");
+	if (command === "browser-install-packages" && packages.length === 0) usage$15("browser-install-packages needs --package for each library the Browser reported.");
+	if (command === "computer-import" && !archiveName(target)) usage$15("computer-import needs an archive name from computer-exports, such as computer.tar.");
 	let upload;
 	if (command === "computer-upload") {
-		if (!absolute(target)) usage$14("computer-upload needs an absolute local file path.");
+		if (!absolute(target)) usage$15("computer-upload needs an absolute local file path.");
 		const name = values.name?.trim() || basename(target);
-		if (!archiveName(name)) usage$14("The uploaded archive name must end in .tar, such as computer.tar.");
+		if (!archiveName(name)) usage$15("The uploaded archive name must end in .tar, such as computer.tar.");
 		let bytes;
 		try {
 			const info = statSync(target);
 			if (!info.isFile()) throw new Error("not a file");
 			bytes = info.size;
 		} catch {
-			usage$14(`Cannot read ${target}.`);
+			usage$15(`Cannot read ${target}.`);
 		}
 		upload = {
 			path: target,
@@ -52551,9 +55426,9 @@ async function runBrowserComputerCommand(command, rest, values, io, connect) {
 	}
 	let token = "";
 	if (command === "browser-takeover-recording") {
-		if (values["token-stdin"] !== true) usage$14("browser-takeover-recording requires --token-stdin.");
+		if (values["token-stdin"] !== true) usage$15("browser-takeover-recording requires --token-stdin.");
 		token = (await (io.readStdin?.() ?? Promise.resolve(""))).trim();
-		if (!/^[A-Za-z0-9_-]{1,128}$/u.test(token)) usage$14("stdin must hold the takeover token from the takeover link.");
+		if (!/^[A-Za-z0-9_-]{1,128}$/u.test(token)) usage$15("stdin must hold the takeover token from the takeover link.");
 	}
 	const since = count$1(values.since, "--since", Number.MAX_SAFE_INTEGER);
 	const limit = count$1(values.limit, "--limit", 1e3);
@@ -52745,7 +55620,7 @@ const states = [
 	"failed"
 ];
 const record$5 = (value) => value !== null && typeof value === "object" && !Array.isArray(value) ? value : {};
-function usage$13(message) {
+function usage$14(message) {
 	throw new CliLiveError("usage", message);
 }
 function invalidResponse() {
@@ -52759,36 +55634,36 @@ async function prepareImAuthorization(command, rest, values, io) {
 			"im-credentials",
 			"im-verify"
 		].includes(command)) throw new CliLiveError("secret-in-argv", "IM应用授权 inputs must arrive through stdin.");
-		usage$13(`${command} requires ${count} positional arguments.`);
+		usage$14(`${command} requires ${count} positional arguments.`);
 	}
 	const target = rest[0]?.trim() ?? "";
 	if (command === "im-authorize") {
-		if (!["feishu", "weixin"].includes(target)) usage$13("Choose feishu or weixin.");
-	} else if (count === 1 && !/^[A-Za-z0-9_-]{1,128}$/u.test(target)) usage$13("Use the attemptId returned by im-authorize.");
-	if (values["credentials-stdin"] && command !== "im-credentials") usage$13("--credentials-stdin is only valid for im-credentials.");
-	if (values["verification-stdin"] && command !== "im-verify") usage$13("--verification-stdin is only valid for im-verify.");
-	if (values.wait && command !== "pairing-status") usage$13("--wait is only valid for pairing-status.");
+		if (!["feishu", "weixin"].includes(target)) usage$14("Choose feishu or weixin.");
+	} else if (count === 1 && !/^[A-Za-z0-9_-]{1,128}$/u.test(target)) usage$14("Use the attemptId returned by im-authorize.");
+	if (values["credentials-stdin"] && command !== "im-credentials") usage$14("--credentials-stdin is only valid for im-credentials.");
+	if (values["verification-stdin"] && command !== "im-verify") usage$14("--verification-stdin is only valid for im-verify.");
+	if (values.wait && command !== "pairing-status") usage$14("--wait is only valid for pairing-status.");
 	const operation = {
 		command,
 		target,
 		wait: values.wait === true
 	};
 	if (command === "im-credentials") {
-		if (!values["credentials-stdin"]) usage$13("im-credentials requires --credentials-stdin.");
+		if (!values["credentials-stdin"]) usage$14("im-credentials requires --credentials-stdin.");
 		const input = await (io.readStdin?.() ?? Promise.resolve(""));
 		let credentials;
 		try {
-			if (input.length > 16384) usage$13("IM credential JSON is too large.");
+			if (input.length > 16384) usage$14("IM credential JSON is too large.");
 			credentials = record$5(JSON.parse(input));
 		} catch {
-			usage$13("IM credentials require JSON from stdin.");
+			usage$14("IM credentials require JSON from stdin.");
 		}
 		const { appId, appSecret, domain } = credentials;
 		if (Object.keys(credentials).some((key) => ![
 			"appId",
 			"appSecret",
 			"domain"
-		].includes(key)) || typeof appId !== "string" || !/^cli_[A-Za-z0-9_-]+$/u.test(appId) || typeof appSecret !== "string" || !appSecret.trim() || appSecret.length > 4096 || domain !== "lark" && domain !== "feishu") usage$13("Credential JSON requires appId, appSecret and domain (lark or feishu).");
+		].includes(key)) || typeof appId !== "string" || !/^cli_[A-Za-z0-9_-]+$/u.test(appId) || typeof appSecret !== "string" || !appSecret.trim() || appSecret.length > 4096 || domain !== "lark" && domain !== "feishu") usage$14("Credential JSON requires appId, appSecret and domain (lark or feishu).");
 		operation.credentials = {
 			appId,
 			appSecret,
@@ -52796,9 +55671,9 @@ async function prepareImAuthorization(command, rest, values, io) {
 		};
 	}
 	if (command === "im-verify") {
-		if (!values["verification-stdin"]) usage$13("im-verify requires --verification-stdin.");
+		if (!values["verification-stdin"]) usage$14("im-verify requires --verification-stdin.");
 		const verifyCode = (await (io.readStdin?.() ?? Promise.resolve(""))).trim();
-		if (!/^\d{4,8}$/u.test(verifyCode)) usage$13("Verification stdin must contain 4–8 digits.");
+		if (!/^\d{4,8}$/u.test(verifyCode)) usage$14("Verification stdin must contain 4–8 digits.");
 		operation.verifyCode = verifyCode;
 	}
 	return operation;
@@ -52867,7 +55742,7 @@ async function runImAuthorization(operation, rpc, signal) {
 		"im-cancel": "setup.cancel",
 		"pairing-status": "setup.poll"
 	}[operation.command];
-	if (!method) usage$13("Unknown IM应用授权 command.");
+	if (!method) usage$14("Unknown IM应用授权 command.");
 	const start = operation.command === "im-authorize";
 	const payload = start ? { channel: operation.target } : {
 		attemptId: operation.target,
@@ -53074,7 +55949,7 @@ const BODY_COMMANDS = /* @__PURE__ */ new Set([
 	"messaging-post-status",
 	"messaging-send"
 ]);
-function usage$12(message) {
+function usage$13(message) {
 	throw new CliLiveError("usage", message);
 }
 function record$4(value) {
@@ -53085,12 +55960,12 @@ function list(value) {
 }
 function uuid(value, flag) {
 	const trimmed = value?.trim() ?? "";
-	if (!UUID.test(trimmed)) usage$12(`${flag} must be a UUID.`);
+	if (!UUID.test(trimmed)) usage$13(`${flag} must be a UUID.`);
 	return trimmed;
 }
 function required$2(value, flag) {
 	const trimmed = value?.trim() ?? "";
-	if (!trimmed) usage$12(`${flag} is required.`);
+	if (!trimmed) usage$13(`${flag} is required.`);
 	return trimmed;
 }
 function destructive(input, command) {
@@ -53102,37 +55977,37 @@ function destructive(input, command) {
 }
 async function prepareMessaging(command, rest, values, io) {
 	const what = command === "messaging-defaults" || command === "messaging-defaults-set" ? "a platform" : command === "messaging-targets" ? "an IM app ref" : command.startsWith("channel-") ? "a Channel id" : "a Bot id";
-	if (rest.length !== 1 || !rest[0]?.trim()) usage$12(`${command} needs exactly one target: ${what}.`);
+	if (rest.length !== 1 || !rest[0]?.trim()) usage$13(`${command} needs exactly one target: ${what}.`);
 	const target = rest[0].trim();
-	if (what === "a platform" && !PLATFORMS.includes(target)) usage$12(`Choose one of ${PLATFORMS.join(", ")}.`);
+	if (what === "a platform" && !PLATFORMS.includes(target)) usage$13(`Choose one of ${PLATFORMS.join(", ")}.`);
 	const operation = {
 		command,
 		target,
 		values
 	};
 	if (STDIN_COMMANDS.has(command)) {
-		if (values["input-stdin"] !== true) usage$12(`${command} requires --input-stdin.`);
+		if (values["input-stdin"] !== true) usage$13(`${command} requires --input-stdin.`);
 		const raw = await (io.readStdin?.() ?? Promise.resolve(""));
 		let parsed;
 		try {
 			if (raw.length > 65536) throw new Error("too large");
 			parsed = JSON.parse(raw);
 		} catch {
-			usage$12("--input-stdin must be one JSON object of at most 64 KiB.");
+			usage$13("--input-stdin must be one JSON object of at most 64 KiB.");
 		}
-		if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) usage$12("--input-stdin must be one JSON object of at most 64 KiB.");
+		if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) usage$13("--input-stdin must be one JSON object of at most 64 KiB.");
 		operation.input = parsed;
-		if (destructive(operation.input, command) && values.confirm !== true) usage$12(`This ${String(operation.input["kind"])} change needs --confirm.`);
-	} else if (values["input-stdin"] === true) usage$12(`--input-stdin is not valid for ${command}.`);
+		if (destructive(operation.input, command) && values.confirm !== true) usage$13(`This ${String(operation.input["kind"])} change needs --confirm.`);
+	} else if (values["input-stdin"] === true) usage$13(`--input-stdin is not valid for ${command}.`);
 	if (BODY_COMMANDS.has(command)) {
-		if (values.body !== void 0 === (values["body-stdin"] === true)) usage$12(`${command} requires exactly one of --body or --body-stdin.`);
+		if (values.body !== void 0 === (values["body-stdin"] === true)) usage$13(`${command} requires exactly one of --body or --body-stdin.`);
 		const text = values["body-stdin"] ? await (io.readStdin?.() ?? Promise.resolve("")) : values.body;
-		if (!text?.trim()) usage$12(`${command} requires a nonempty message.`);
-		if (text.length > 4e3) usage$12("Messages are limited to 4000 characters.");
+		if (!text?.trim()) usage$13(`${command} requires a nonempty message.`);
+		if (text.length > 4e3) usage$13("Messages are limited to 4000 characters.");
 		operation.text = text;
 	}
 	const requestId = values["request-id"];
-	if (requestId !== void 0 && !/^[A-Za-z0-9_:.-]{8,128}$/u.test(requestId)) usage$12("--request-id must be 8–128 letters, digits, _ : . or -.");
+	if (requestId !== void 0 && !/^[A-Za-z0-9_:.-]{8,128}$/u.test(requestId)) usage$13("--request-id must be 8–128 letters, digits, _ : . or -.");
 	switch (command) {
 		case "messaging-targets":
 		case "messaging-defaults":
@@ -53152,12 +56027,12 @@ async function prepareMessaging(command, rest, values, io) {
 			break;
 		case "messaging-revoke":
 			uuid(values.grant, "--grant");
-			if (values.confirm !== true) usage$12("Revoking stops the Bot from messaging this conversation. Pass --confirm.");
+			if (values.confirm !== true) usage$13("Revoking stops the Bot from messaging this conversation. Pass --confirm.");
 			break;
 		case "messaging-receive":
 		case "failure-alerts-set":
 			if (command === "messaging-receive") uuid(values.grant, "--grant");
-			if (values.enabled === values.disabled) usage$12(`${command} needs exactly one of --enabled or --disabled.`);
+			if (values.enabled === values.disabled) usage$13(`${command} needs exactly one of --enabled or --disabled.`);
 			break;
 		case "messaging-channel-target":
 			uuid(values.grant, "--grant");
@@ -53178,12 +56053,12 @@ async function prepareMessaging(command, rest, values, io) {
 		case "messaging-post-status":
 			uuid(values.binding, "--binding");
 			required$2(values.conversation, "--conversation");
-			if (command === "messaging-post-status" && requestId === void 0) usage$12("messaging-post-status requires the --request-id of the post.");
+			if (command === "messaging-post-status" && requestId === void 0) usage$13("messaging-post-status requires the --request-id of the post.");
 			break;
 		case "messaging-post-limit": {
 			uuid(values.binding, "--binding");
 			const limit = values.limit?.trim();
-			if (limit !== "none" && !(Number.isSafeInteger(Number(limit)) && Number(limit) >= 1 && Number(limit) <= 1e4)) usage$12("--limit must be 1–10000, or none to clear it.");
+			if (limit !== "none" && !(Number.isSafeInteger(Number(limit)) && Number(limit) >= 1 && Number(limit) <= 1e4)) usage$13("--limit must be 1–10000, or none to clear it.");
 			break;
 		}
 		case "approval-route":
@@ -53504,38 +56379,38 @@ const NO_TARGET = /* @__PURE__ */ new Set([
 	"channel-activity-today"
 ]);
 const DAY = /^\d{4}-\d{2}-\d{2}$/u;
-function usage$11(message) {
+function usage$12(message) {
 	throw new CliLiveError("usage", message);
 }
 function revision$1(value) {
 	if (value === void 0) return void 0;
 	const parsed = Number(value);
-	if (!/^\d+$/u.test(value) || !Number.isSafeInteger(parsed)) usage$11("--expected-revision must be a nonnegative integer.");
+	if (!/^\d+$/u.test(value) || !Number.isSafeInteger(parsed)) usage$12("--expected-revision must be a nonnegative integer.");
 	return parsed;
 }
 function cursor(value) {
 	if (value === void 0) return void 0;
-	if (value.length === 0 || value.length > 255) usage$11("--after must be 1–255 characters.");
+	if (value.length === 0 || value.length > 255) usage$12("--after must be 1–255 characters.");
 	return value;
 }
 function day(value, flag) {
 	if (value === void 0) return void 0;
-	if (!DAY.test(value)) usage$11(`--${flag} must be a YYYY-MM-DD day.`);
+	if (!DAY.test(value)) usage$12(`--${flag} must be a YYYY-MM-DD day.`);
 	return value;
 }
 async function planInput$1(io, values, keys, required) {
-	if (!values["plan-stdin"]) usage$11("This command reads its plan JSON with --plan-stdin.");
+	if (!values["plan-stdin"]) usage$12("This command reads its plan JSON with --plan-stdin.");
 	let input;
 	try {
 		input = JSON.parse(await (io.readStdin?.() ?? Promise.resolve("")));
 	} catch {
-		usage$11("Plan stdin must be one JSON object.");
+		usage$12("Plan stdin must be one JSON object.");
 	}
-	if (typeof input !== "object" || input === null || Array.isArray(input)) usage$11("Plan stdin must be one JSON object.");
+	if (typeof input !== "object" || input === null || Array.isArray(input)) usage$12("Plan stdin must be one JSON object.");
 	const plan = input;
-	if (Object.keys(plan).filter((key) => !keys.includes(key)).length > 0) usage$11(`Plan stdin accepts only ${keys.join(", ")}.`);
+	if (Object.keys(plan).filter((key) => !keys.includes(key)).length > 0) usage$12(`Plan stdin accepts only ${keys.join(", ")}.`);
 	const missing = required.filter((key) => plan[key] === void 0);
-	if (missing.length > 0) usage$11(`Plan stdin requires ${missing.join(", ")}.`);
+	if (missing.length > 0) usage$12(`Plan stdin requires ${missing.join(", ")}.`);
 	return plan;
 }
 function routeOverride(values, prefix, current) {
@@ -53546,7 +56421,7 @@ function routeOverride(values, prefix, current) {
 		["provider", provider],
 		["model", model],
 		["effort", effort]
-	]) if (value === "") usage$11(`--${prefix}-${flag} must not be empty.`);
+	]) if (value === "") usage$12(`--${prefix}-${flag} must not be empty.`);
 	const next = {
 		provider: provider ?? current.provider,
 		model: model ?? current.model
@@ -53563,12 +56438,12 @@ function isModelsUsageCommand(command) {
 }
 async function runModelsUsage(command, rest, values, io, connect) {
 	const noTarget = NO_TARGET.has(command);
-	if (rest.length !== (noTarget ? 0 : 1)) usage$11(`${command} ${noTarget ? "takes no positional arguments" : "needs exactly one target id"}.`);
+	if (rest.length !== (noTarget ? 0 : 1)) usage$12(`${command} ${noTarget ? "takes no positional arguments" : "needs exactly one target id"}.`);
 	const target = rest[0]?.trim() ?? "";
-	if (!noTarget && !target) usage$11(`${command} requires a nonempty target id.`);
+	if (!noTarget && !target) usage$12(`${command} requires a nonempty target id.`);
 	const expected = revision$1(values["expected-revision"]);
 	if (command === "home-model-set") {
-		if (!values.provider || !values.model) usage$11("home-model-set requires --provider and --model.");
+		if (!values.provider || !values.model) usage$12("home-model-set requires --provider and --model.");
 		const rpc = await connect();
 		const expectedDefaultRevision = expected ?? (await rpc("modelCatalog", {})).defaultRevision;
 		if (!Number.isSafeInteger(expectedDefaultRevision) || Number(expectedDefaultRevision) < 0) throw new CliLiveError("settings-unavailable", "The Host does not expose its native default model revision.");
@@ -53592,7 +56467,7 @@ async function runModelsUsage(command, rest, values, io, connect) {
 	}
 	if (command === "overview-usage") {
 		const period = values.period ?? "today";
-		if (!isUsageOverviewPeriod(period)) usage$11(`--period must be one of ${usageOverviewPeriods.join(", ")}.`);
+		if (!isUsageOverviewPeriod(period)) usage$12(`--period must be one of ${usageOverviewPeriods.join(", ")}.`);
 		const after = cursor(values.after);
 		return (await connect())("overviewUsage", {
 			period,
@@ -53604,7 +56479,7 @@ async function runModelsUsage(command, rest, values, io, connect) {
 	if (command === "bot-activity-history") {
 		const before = day(values.before, "before");
 		const weeks = values.weeks === void 0 ? void 0 : Number(values.weeks);
-		if (weeks !== void 0 && (!Number.isInteger(weeks) || weeks < 1 || weeks > 104)) usage$11("--weeks must be an integer from 1 to 104.");
+		if (weeks !== void 0 && (!Number.isInteger(weeks) || weeks < 1 || weeks > 104)) usage$12("--weeks must be an integer from 1 to 104.");
 		return (await connect())("profileActivity", {
 			channelId: dmChannelId(target),
 			...before === void 0 ? {} : { before },
@@ -53614,7 +56489,7 @@ async function runModelsUsage(command, rest, values, io, connect) {
 	if (command === "bot-usage") {
 		const start = day(values.start, "start");
 		const end = day(values.end, "end");
-		if (start === void 0 || end === void 0) usage$11("bot-usage requires --start and --end.");
+		if (start === void 0 || end === void 0) usage$12("bot-usage requires --start and --end.");
 		const filter = {
 			start,
 			end,
@@ -53631,7 +56506,7 @@ async function runModelsUsage(command, rest, values, io, connect) {
 		const provider = values["orchestrator-provider"]?.trim();
 		const model = values["orchestrator-model"]?.trim();
 		const effort = values["orchestrator-effort"]?.trim();
-		if (!provider || !model) usage$11("--orchestrator-provider and --orchestrator-model are required.");
+		if (!provider || !model) usage$12("--orchestrator-provider and --orchestrator-model are required.");
 		const rpc = await connect();
 		return rpc("modelPlanCustomize", {
 			slug: target,
@@ -53668,7 +56543,7 @@ async function runModelsUsage(command, rest, values, io, connect) {
 	}
 	if (command === "model-preset-update") {
 		const name = values.name?.trim();
-		if (values.name !== void 0 && !name) usage$11("--name must not be empty.");
+		if (values.name !== void 0 && !name) usage$12("--name must not be empty.");
 		const plan = values["plan-stdin"] ? await planInput$1(io, values, ["assignmentModels"], ["assignmentModels"]) : {};
 		const rpc = await connect();
 		const { presets } = await rpc("modelPresets", {});
@@ -53683,7 +56558,7 @@ async function runModelsUsage(command, rest, values, io, connect) {
 			...plan
 		});
 	}
-	return usage$11(`Unsupported models or usage command ${command}.`);
+	return usage$12(`Unsupported models or usage command ${command}.`);
 }
 //#endregion
 //#region packages/core/src/marketplace/altcha.ts
@@ -53822,7 +56697,7 @@ const HOST_ADMIN_COMMANDS = [
 	}
 ];
 const MAX_REPORT_REASON_LENGTH = 500;
-function usage$10(message) {
+function usage$11(message) {
 	throw new CliLiveError("usage", message);
 }
 function record$2(value) {
@@ -53857,26 +56732,26 @@ const POSITIONAL_NAMES = {
 };
 function validate(command, rest, values) {
 	const expected = POSITIONALS$2[command];
-	if (rest.length !== expected || rest.some((value) => !value.trim())) usage$10(expected === 0 ? `${command} takes no positional arguments.` : `${command} needs ${POSITIONAL_NAMES[expected]}.`);
-	if (values.sort !== void 0 && (command !== "marketplace-list" || values.sort !== "updated" && values.sort !== "stars")) usage$10("--sort must be updated or stars, on marketplace-list.");
+	if (rest.length !== expected || rest.some((value) => !value.trim())) usage$11(expected === 0 ? `${command} takes no positional arguments.` : `${command} needs ${POSITIONAL_NAMES[expected]}.`);
+	if (values.sort !== void 0 && (command !== "marketplace-list" || values.sort !== "updated" && values.sort !== "stars")) usage$11("--sort must be updated or stars, on marketplace-list.");
 	if (command === "marketplace-report" && values.reason !== void 0) {
-		if (values.reason.trim().length > MAX_REPORT_REASON_LENGTH) usage$10(`--reason must be at most ${String(MAX_REPORT_REASON_LENGTH)} characters.`);
+		if (values.reason.trim().length > MAX_REPORT_REASON_LENGTH) usage$11(`--reason must be at most ${String(MAX_REPORT_REASON_LENGTH)} characters.`);
 	}
-	if ((command === "release-install" || command === "release-restart") && values.confirm !== true) usage$10(command === "release-install" ? "release-install replaces the installed DeepSeekBot. Pass --confirm to install." : "release-restart stops every running Bot turn on this Host. Pass --confirm to restart.");
-	if (command === "telemetry-set" && values.enabled === values.disabled) usage$10("telemetry-set needs exactly one of --enabled or --disabled.");
+	if ((command === "release-install" || command === "release-restart") && values.confirm !== true) usage$11(command === "release-install" ? "release-install replaces the installed DeepSeekBot. Pass --confirm to install." : "release-restart stops every running Bot turn on this Host. Pass --confirm to restart.");
+	if (command === "telemetry-set" && values.enabled === values.disabled) usage$11("telemetry-set needs exactly one of --enabled or --disabled.");
 	if (command !== "pairing-review") return void 0;
 	const kind = values.decision;
-	if (kind !== "approve" && kind !== "reject" && kind !== "revoke") usage$10("--decision must be approve, reject or revoke.");
+	if (kind !== "approve" && kind !== "reject" && kind !== "revoke") usage$11("--decision must be approve, reject or revoke.");
 	const roles = (values.role ?? []).map((role) => role.trim()).filter(Boolean);
 	const capabilities = (values.capability ?? []).map((capability) => capability.trim());
-	for (const capability of capabilities) if (!pairingCapabilities.includes(capability)) usage$10(`--capability must be one of ${pairingCapabilities.join(", ")}.`);
+	for (const capability of capabilities) if (!pairingCapabilities.includes(capability)) usage$11(`--capability must be one of ${pairingCapabilities.join(", ")}.`);
 	if (kind !== "approve") {
-		if (roles.length > 0 || capabilities.length > 0) usage$10("--role and --capability only apply to --decision approve.");
-		if (kind === "revoke" && values.confirm !== true) usage$10("Revoking ends this person’s access through the Bot. Pass --confirm to revoke.");
+		if (roles.length > 0 || capabilities.length > 0) usage$11("--role and --capability only apply to --decision approve.");
+		if (kind === "revoke" && values.confirm !== true) usage$11("Revoking ends this person’s access through the Bot. Pass --confirm to revoke.");
 		return { kind };
 	}
-	if (roles.length > 1) usage$10("pairing-review takes at most one --role.");
-	if (roles.length === 1 === capabilities.length > 0) usage$10("Approve needs exactly one of --role <role-id> or --capability <capability> ...");
+	if (roles.length > 1) usage$11("pairing-review takes at most one --role.");
+	if (roles.length === 1 === capabilities.length > 0) usage$11("Approve needs exactly one of --role <role-id> or --capability <capability> ...");
 	return roles.length === 1 ? {
 		kind,
 		roleId: roles[0]
@@ -53935,7 +56810,7 @@ async function runHostAdminCommand(command, rest, values, _io, host) {
 				"continue",
 				"restart",
 				"finish"
-			].includes(values.action)) usage$10("Invalid onboarding action.");
+			].includes(values.action)) usage$11("Invalid onboarding action.");
 			return rpc("onboarding", values.action === void 0 ? {} : { action: values.action });
 		case "tob-home": return rpc("tobHome", {});
 		case "marketplace-list": return rpc("marketplaceList", { query: {
@@ -54098,14 +56973,14 @@ function scheduleToggleFromFlags(values, on, off, fail) {
 	if (isOn) return true;
 	if (isOff) return false;
 }
-function usage$9(message) {
+function usage$10(message) {
 	return new CliLiveError("usage", message);
 }
 function prepareScheduleCommand(command, rest, values) {
 	if (command === "schedule-preview") {
-		if (rest.length > 0) throw usage$9("schedule-preview takes no bot id.");
-		const trigger = scheduleTriggerFromFlags(values, usage$9);
-		if (trigger === void 0) throw usage$9("schedule-preview needs a trigger flag.");
+		if (rest.length > 0) throw usage$10("schedule-preview takes no bot id.");
+		const trigger = scheduleTriggerFromFlags(values, usage$10);
+		if (trigger === void 0) throw usage$10("schedule-preview needs a trigger flag.");
 		return {
 			method: "schedulePreview",
 			args: { trigger },
@@ -54113,7 +56988,7 @@ function prepareScheduleCommand(command, rest, values) {
 		};
 	}
 	const slug = rest.length === 1 ? rest[0].trim() : "";
-	if (slug.length === 0) throw usage$9(`${command} needs exactly one bot id.`);
+	if (slug.length === 0) throw usage$10(`${command} needs exactly one bot id.`);
 	if (command === "schedules") return {
 		method: "scheduleList",
 		args: { slug }
@@ -54121,11 +56996,11 @@ function prepareScheduleCommand(command, rest, values) {
 	if (command === "schedule-create") {
 		const title = trimmed$1(values.title);
 		const prompt = trimmed$1(values.prompt);
-		if (title === void 0 || prompt === void 0) throw usage$9("--title and --prompt are required for schedule-create.");
-		const trigger = scheduleTriggerFromFlags(values, usage$9);
-		if (trigger === void 0) throw usage$9("schedule-create needs a trigger flag.");
-		const enabled = scheduleToggleFromFlags(values, "enabled", "disabled", usage$9);
-		const locked = scheduleToggleFromFlags(values, "locked", "unlocked", usage$9);
+		if (title === void 0 || prompt === void 0) throw usage$10("--title and --prompt are required for schedule-create.");
+		const trigger = scheduleTriggerFromFlags(values, usage$10);
+		if (trigger === void 0) throw usage$10("schedule-create needs a trigger flag.");
+		const enabled = scheduleToggleFromFlags(values, "enabled", "disabled", usage$10);
+		const locked = scheduleToggleFromFlags(values, "locked", "unlocked", usage$10);
 		return {
 			method: "scheduleCreate",
 			args: {
@@ -54141,13 +57016,13 @@ function prepareScheduleCommand(command, rest, values) {
 		};
 	}
 	const id = trimmed$1(values.sid);
-	if (id === void 0) throw usage$9(`--sid is required for ${command}.`);
+	if (id === void 0) throw usage$10(`--sid is required for ${command}.`);
 	if (command === "schedule-update") {
 		const title = trimmed$1(values.title);
 		const prompt = trimmed$1(values.prompt);
-		const trigger = scheduleTriggerFromFlags(values, usage$9);
-		const enabled = scheduleToggleFromFlags(values, "enabled", "disabled", usage$9);
-		const locked = scheduleToggleFromFlags(values, "locked", "unlocked", usage$9);
+		const trigger = scheduleTriggerFromFlags(values, usage$10);
+		const enabled = scheduleToggleFromFlags(values, "enabled", "disabled", usage$10);
+		const locked = scheduleToggleFromFlags(values, "locked", "unlocked", usage$10);
 		const change = {
 			...title === void 0 ? {} : { title },
 			...prompt === void 0 ? {} : { prompt },
@@ -54155,7 +57030,7 @@ function prepareScheduleCommand(command, rest, values) {
 			...enabled === void 0 ? {} : { enabled },
 			...locked === void 0 ? {} : { locked }
 		};
-		if (Object.keys(change).length === 0) throw usage$9("schedule-update needs at least one change flag.");
+		if (Object.keys(change).length === 0) throw usage$10("schedule-update needs at least one change flag.");
 		return {
 			method: "scheduleUpdate",
 			args: {
@@ -54166,7 +57041,7 @@ function prepareScheduleCommand(command, rest, values) {
 		};
 	}
 	if (command === "schedule-delete") {
-		if (values.confirm !== true) throw usage$9("schedule-delete removes the schedule and its history. Pass --confirm.");
+		if (values.confirm !== true) throw usage$10("schedule-delete removes the schedule and its history. Pass --confirm.");
 		return {
 			method: "scheduleDelete",
 			args: {
@@ -54330,14 +57205,14 @@ const SOURCE_CLASSES = /* @__PURE__ */ new Set([
 	"bot-dm",
 	"group-mention"
 ]);
-function usage$8(message) {
+function usage$9(message) {
 	throw new CliLiveError("usage", message);
 }
 function isProfileCommand(command) {
 	return PROFILE_COMMANDS.some((entry) => entry.command === command) || PROFILE_ONLINE_COMMANDS.some((entry) => entry === command);
 }
 function readBytes(path, flag = "--file") {
-	if (!path?.trim()) usage$8(`${flag} <path> is required.`);
+	if (!path?.trim()) usage$9(`${flag} <path> is required.`);
 	try {
 		return readFileSync(path);
 	} catch {
@@ -54355,27 +57230,27 @@ function imageDataUrl(bytes) {
 		26,
 		10
 	])) ? "png" : bytes[0] === 255 && bytes[1] === 216 && bytes[2] === 255 ? "jpeg" : bytes.toString("ascii", 0, 4) === "RIFF" && bytes.toString("ascii", 8, 12) === "WEBP" ? "webp" : void 0;
-	if (type === void 0) usage$8("--file must be a PNG, JPEG or WebP image.");
+	if (type === void 0) usage$9("--file must be a PNG, JPEG or WebP image.");
 	return `data:image/${type};base64,${bytes.toString("base64")}`;
 }
 async function stdinJson(io, flag) {
 	try {
 		return JSON.parse(await (io.readStdin?.() ?? Promise.resolve("")));
 	} catch {
-		usage$8(`${flag} must be one JSON document.`);
+		usage$9(`${flag} must be one JSON document.`);
 	}
 }
 function count(value, flag, min = 0) {
 	const parsed = Number(value);
-	if (value === void 0 || value.trim() === "" || !Number.isSafeInteger(parsed) || parsed < min) usage$8(`${flag} must be a whole number of at least ${String(min)}.`);
+	if (value === void 0 || value.trim() === "" || !Number.isSafeInteger(parsed) || parsed < min) usage$9(`${flag} must be a whole number of at least ${String(min)}.`);
 	return parsed;
 }
 function oneBot(command, rest) {
-	if (rest.length !== 1 || !rest[0]?.trim()) usage$8(`${command} needs exactly one bot id.`);
+	if (rest.length !== 1 || !rest[0]?.trim()) usage$9(`${command} needs exactly one bot id.`);
 	return rest[0].trim();
 }
 function noArguments(command, rest) {
-	if (rest.length > 0) usage$8(`${command} takes no positional arguments.`);
+	if (rest.length > 0) usage$9(`${command} takes no positional arguments.`);
 }
 function ids(rest) {
 	return rest.map((id) => id.trim()).filter((id) => id.length > 0);
@@ -54384,7 +57259,7 @@ async function profileCall(command, rest, values, io) {
 	switch (command) {
 		case "bot-avatar-set": {
 			const channelId = dmChannelId(oneBot(command, rest));
-			if (values.file !== void 0 === (values.clear === true)) usage$8("bot-avatar-set needs exactly one of --file or --clear.");
+			if (values.file !== void 0 === (values.clear === true)) usage$9("bot-avatar-set needs exactly one of --file or --clear.");
 			return ["botAvatarSet", {
 				channelId,
 				avatar: values.clear ? null : imageDataUrl(readBytes(values.file))
@@ -54396,7 +57271,7 @@ async function profileCall(command, rest, values, io) {
 				values.file !== void 0,
 				values["recipe-stdin"] === true,
 				values.clear
-			].filter(Boolean).length !== 1) usage$8("bot-banner-set needs exactly one of --file, --recipe-stdin or --clear.");
+			].filter(Boolean).length !== 1) usage$9("bot-banner-set needs exactly one of --file, --recipe-stdin or --clear.");
 			return ["botBannerSet", {
 				channelId,
 				banner: values.clear ? null : values["recipe-stdin"] ? { recipe: await stdinJson(io, "--recipe-stdin") } : { image: `data:image/png;base64,${readBytes(values.file).toString("base64")}` }
@@ -54404,7 +57279,7 @@ async function profileCall(command, rest, values, io) {
 		}
 		case "bot-appearance-set": {
 			const channelId = dmChannelId(oneBot(command, rest));
-			if (values["recipe-stdin"] !== true) usage$8("bot-appearance-set requires --recipe-stdin.");
+			if (values["recipe-stdin"] !== true) usage$9("bot-appearance-set requires --recipe-stdin.");
 			return ["botAppearanceSet", {
 				channelId,
 				recipe: await stdinJson(io, "--recipe-stdin")
@@ -54412,8 +57287,8 @@ async function profileCall(command, rest, values, io) {
 		}
 		case "bot-primary-color-set": {
 			const channelId = dmChannelId(oneBot(command, rest));
-			if (values.color !== void 0 === (values.automatic === true)) usage$8("bot-primary-color-set needs exactly one of --color or --automatic.");
-			if (values.color !== void 0 && !/^#[0-9a-f]{6}$/iu.test(values.color)) usage$8("--color must be #rrggbb.");
+			if (values.color !== void 0 === (values.automatic === true)) usage$9("bot-primary-color-set needs exactly one of --color or --automatic.");
+			if (values.color !== void 0 && !/^#[0-9a-f]{6}$/iu.test(values.color)) usage$9("--color must be #rrggbb.");
 			return ["botPrimaryColorSet", {
 				channelId,
 				primaryColor: values.automatic ? { mode: "automatic" } : {
@@ -54427,13 +57302,13 @@ async function profileCall(command, rest, values, io) {
 		case "bot-source-policy-reset": {
 			const slug = oneBot(command, rest);
 			const sourceClass = values["source-class"] ?? "";
-			if (!SOURCE_CLASSES.has(sourceClass)) usage$8("--source-class must be assignment-report, group-ordinary, human-dm, bot-dm or group-mention.");
+			if (!SOURCE_CLASSES.has(sourceClass)) usage$9("--source-class must be assignment-report, group-ordinary, human-dm, bot-dm or group-mention.");
 			if (command === "bot-source-policy-reset") return ["botSourcePolicyReset", {
 				slug,
 				sourceClass
 			}];
 			if (IMMEDIATE_CLASSES.has(sourceClass)) {
-				if (values.delivery !== "steer" && values.delivery !== "turn") usage$8(`${sourceClass} needs --delivery steer or turn.`);
+				if (values.delivery !== "steer" && values.delivery !== "turn") usage$9(`${sourceClass} needs --delivery steer or turn.`);
 				return ["botSourcePolicySet", {
 					slug,
 					sourceClass,
@@ -54447,7 +57322,7 @@ async function profileCall(command, rest, values, io) {
 					"digest",
 					"mentions",
 					"silent"
-				].includes(values.wake ?? "")) usage$8("group-ordinary needs --wake immediate, digest, mentions or silent.");
+				].includes(values.wake ?? "")) usage$9("group-ordinary needs --wake immediate, digest, mentions or silent.");
 				return ["botSourcePolicySet", {
 					slug,
 					sourceClass,
@@ -54456,7 +57331,7 @@ async function profileCall(command, rest, values, io) {
 					digestIntervalSeconds: count(values["digest-interval"], "--digest-interval", 1)
 				}];
 			}
-			if (values.wake !== "conditional" && values.wake !== "immediate") usage$8("assignment-report needs --wake conditional or immediate.");
+			if (values.wake !== "conditional" && values.wake !== "immediate") usage$9("assignment-report needs --wake conditional or immediate.");
 			return ["botSourcePolicySet", {
 				slug,
 				sourceClass,
@@ -54470,7 +57345,7 @@ async function profileCall(command, rest, values, io) {
 		}];
 		case "developer-mode-set":
 			noArguments(command, rest);
-			if (values.enabled === values.disabled) usage$8("developer-mode-set needs exactly one of --enabled or --disabled.");
+			if (values.enabled === values.disabled) usage$9("developer-mode-set needs exactly one of --enabled or --disabled.");
 			return ["developerModeSet", { enabled: values.enabled === true }];
 		case "roster":
 			noArguments(command, rest);
@@ -54482,9 +57357,9 @@ async function profileCall(command, rest, values, io) {
 				"unpin",
 				"hide",
 				"move"
-			].includes(action ?? "")) usage$8("roster-batch needs an action: pin, unpin, hide or move.");
-			if (ids(channelIds).length === 0) usage$8("roster-batch needs at least one channel id.");
-			if (action !== "move" && values.section !== void 0) usage$8("--section is only valid for roster-batch move.");
+			].includes(action ?? "")) usage$9("roster-batch needs an action: pin, unpin, hide or move.");
+			if (ids(channelIds).length === 0) usage$9("roster-batch needs at least one channel id.");
+			if (action !== "move" && values.section !== void 0) usage$9("--section is only valid for roster-batch move.");
 			return ["rosterBatch", {
 				action,
 				channelIds: ids(channelIds),
@@ -54494,27 +57369,27 @@ async function profileCall(command, rest, values, io) {
 		case "roster-pins-set": return ["pinsSet", { pins: ids(rest) }];
 		case "roster-hidden-set": return ["hiddenSet", { hidden: ids(rest) }];
 		case "roster-section-create":
-			if (rest.length !== 1 || !rest[0]?.trim()) usage$8("roster-section-create needs one name.");
+			if (rest.length !== 1 || !rest[0]?.trim()) usage$9("roster-section-create needs one name.");
 			return ["sectionCreate", { name: rest[0].trim() }];
 		case "roster-section-rename":
-			if (rest.length !== 1 || !rest[0]?.trim()) usage$8("roster-section-rename needs exactly one section id.");
-			if (!values.name?.trim()) usage$8("roster-section-rename requires --name <text>.");
+			if (rest.length !== 1 || !rest[0]?.trim()) usage$9("roster-section-rename needs exactly one section id.");
+			if (!values.name?.trim()) usage$9("roster-section-rename requires --name <text>.");
 			return ["sectionRename", {
 				sectionId: rest[0].trim(),
 				name: values.name.trim()
 			}];
 		case "roster-section-remove":
-			if (rest.length !== 1 || !rest[0]?.trim()) usage$8("roster-section-remove needs exactly one section id.");
-			if (values.confirm !== true) usage$8("roster-section-remove requires --confirm; its Channels move to the top level.");
+			if (rest.length !== 1 || !rest[0]?.trim()) usage$9("roster-section-remove needs exactly one section id.");
+			if (values.confirm !== true) usage$9("roster-section-remove requires --confirm; its Channels move to the top level.");
 			return ["sectionRemove", { sectionId: rest[0].trim() }];
 		case "roster-section-reorder":
-			if (ids(rest).length === 0) usage$8("roster-section-reorder needs the section ids in order.");
+			if (ids(rest).length === 0) usage$9("roster-section-reorder needs the section ids in order.");
 			return ["sectionReorder", { order: ids(rest) }];
 		case "roster-top-reorder":
-			if (ids(rest).length === 0) usage$8("roster-top-reorder needs section:<id> and channel:<id> entries in order.");
+			if (ids(rest).length === 0) usage$9("roster-top-reorder needs section:<id> and channel:<id> entries in order.");
 			return ["topReorder", { order: ids(rest).map((entry) => {
 				const match = /^(section|channel):(.+)$/u.exec(entry);
-				if (match === null) usage$8(`roster-top-reorder entry ${entry} must be section:<id> or channel:<id>.`);
+				if (match === null) usage$9(`roster-top-reorder entry ${entry} must be section:<id> or channel:<id>.`);
 				return {
 					kind: match[1],
 					id: match[2]
@@ -54526,13 +57401,13 @@ async function profileCall(command, rest, values, io) {
 		case "human-name-set": {
 			noArguments(command, rest);
 			const name = values.name?.trim();
-			if ((name === void 0 || name === "") === (values.clear !== true)) usage$8("human-name-set needs --name or --clear, not both or neither.");
+			if ((name === void 0 || name === "") === (values.clear !== true)) usage$9("human-name-set needs --name or --clear, not both or neither.");
 			return ["humanNameSet", { displayName: values.clear ? null : name }];
 		}
 		case "channel-human-name-set": {
-			if (rest.length !== 1 || !rest[0]?.trim()) usage$8("channel-human-name-set needs exactly one channel id.");
+			if (rest.length !== 1 || !rest[0]?.trim()) usage$9("channel-human-name-set needs exactly one channel id.");
 			const nickname = values.nickname?.trim();
-			if ((nickname === void 0 || nickname === "") === (values.clear !== true)) usage$8("channel-human-name-set needs --nickname or --clear, not both or neither.");
+			if ((nickname === void 0 || nickname === "") === (values.clear !== true)) usage$9("channel-human-name-set needs --nickname or --clear, not both or neither.");
 			return ["channelHumanNameSet", {
 				channelId: rest[0].trim(),
 				nickname: values.clear ? null : nickname
@@ -54543,7 +57418,7 @@ async function profileCall(command, rest, values, io) {
 			return ["partLibraryList", {}];
 		case "part-library-add":
 			noArguments(command, rest);
-			if (values["part-stdin"] !== true) usage$8("part-library-add requires --part-stdin.");
+			if (values["part-stdin"] !== true) usage$9("part-library-add requires --part-stdin.");
 			return ["partLibraryAdd", {
 				part: await stdinJson(io, "--part-stdin"),
 				name: values.name ?? "",
@@ -54554,7 +57429,7 @@ async function profileCall(command, rest, values, io) {
 			return ["partLibraryImport", { data: readBytes(values.file).toString("base64") }];
 		case "part-library-import-image":
 			noArguments(command, rest);
-			if (!values.slot?.trim()) usage$8("part-library-import-image requires --slot <slot>.");
+			if (!values.slot?.trim()) usage$9("part-library-import-image requires --slot <slot>.");
 			return ["partLibraryImportImage", {
 				data: readBytes(values.file).toString("base64"),
 				slot: values.slot.trim(),
@@ -54564,12 +57439,12 @@ async function profileCall(command, rest, values, io) {
 		case "part-library-export": {
 			noArguments(command, rest);
 			const out = values.out ?? "";
-			if (!out.startsWith("/") && !/^[A-Za-z]:[\\/]/u.test(out)) usage$8("part-library-export requires --out <absolute-file>.");
-			if (values["part-id"] !== void 0 && values["part-stdin"] === true) usage$8("part-library-export takes --part-id or --part-stdin, not both.");
+			if (!out.startsWith("/") && !/^[A-Za-z]:[\\/]/u.test(out)) usage$9("part-library-export requires --out <absolute-file>.");
+			if (values["part-id"] !== void 0 && values["part-stdin"] === true) usage$9("part-library-export takes --part-id or --part-stdin, not both.");
 			if (values["part-stdin"] === true) return ["partLibraryExport", { part: await stdinJson(io, "--part-stdin") }];
 			return ["partLibraryExport", values["part-id"] === void 0 ? {} : { id: values["part-id"].trim() }];
 		}
-		default: usage$8(`Unknown profile command ${command}.`);
+		default: usage$9(`Unknown profile command ${command}.`);
 	}
 }
 async function runProfileCommand(command, rest, values, io, connect) {
@@ -54621,7 +57496,7 @@ const TODO_COMMANDS = [
 function isTodoCommand(command) {
 	return TODO_COMMANDS.some((entry) => entry.command === command);
 }
-function usage$7(message) {
+function usage$8(message) {
 	throw new CliLiveError("usage", message);
 }
 const POSITIONALS$1 = {
@@ -54634,18 +57509,18 @@ const POSITIONALS$1 = {
 };
 async function runTodoCommand(command, rest, values, io, connect) {
 	const count = POSITIONALS$1[command];
-	if (rest.length !== count || rest.some((value) => !value.trim())) usage$7(count === 0 ? `${command} takes no positional arguments.` : command === "todo-tool" ? "todo-tool needs a bot id and a tool name." : `${command} needs exactly one to-do id.`);
+	if (rest.length !== count || rest.some((value) => !value.trim())) usage$8(count === 0 ? `${command} takes no positional arguments.` : command === "todo-tool" ? "todo-tool needs a bot id and a tool name." : `${command} needs exactly one to-do id.`);
 	const title = values.title?.trim();
-	if (command === "todo-add" && !title) usage$7("todo-add needs --title <text>.");
-	if (values.done === true && values["not-done"] === true) usage$7("Pass at most one of --done and --not-done.");
-	if (command === "todo-update" && title === void 0 && !values.done && !values["not-done"]) usage$7("todo-update needs --title, --done or --not-done.");
+	if (command === "todo-add" && !title) usage$8("todo-add needs --title <text>.");
+	if (values.done === true && values["not-done"] === true) usage$8("Pass at most one of --done and --not-done.");
+	if (command === "todo-update" && title === void 0 && !values.done && !values["not-done"]) usage$8("todo-update needs --title, --done or --not-done.");
 	let args = {};
 	if (command === "todo-tool" && values["args-stdin"] === true) try {
 		const parsed = JSON.parse(await (io.readStdin?.() ?? Promise.resolve("")));
 		if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) throw new Error("not an object");
 		args = parsed;
 	} catch {
-		usage$7("--args-stdin must be a JSON object of tool arguments.");
+		usage$8("--args-stdin must be a JSON object of tool arguments.");
 	}
 	const { http } = await connect();
 	const json = async (path, body) => {
@@ -54715,7 +57590,7 @@ const SUBCOMMANDS = [
 function isApprovalTemplateCommand(command) {
 	return APPROVAL_TEMPLATE_COMMANDS.some((entry) => entry.command === command);
 }
-function usage$6(message) {
+function usage$7(message) {
 	throw new CliLiveError("usage", message);
 }
 const POSITIONALS = {
@@ -54726,14 +57601,14 @@ const POSITIONALS = {
 	delete: 1
 };
 async function templateText(values, io) {
-	if (values.file !== void 0 && values["text-stdin"] === true) usage$6("Give the template text with --file or --text-stdin, not both.");
+	if (values.file !== void 0 && values["text-stdin"] === true) usage$7("Give the template text with --file or --text-stdin, not both.");
 	if (values.file !== void 0) try {
 		return readFileSync(values.file, "utf8");
 	} catch {
 		throw new CliLiveError("invalid-input", `Cannot read ${values.file}.`);
 	}
 	if (values["text-stdin"] === true) return io.readStdin?.() ?? Promise.resolve("");
-	return usage$6("Give the template Markdown with --file <path> or --text-stdin.");
+	return usage$7("Give the template Markdown with --file <path> or --text-stdin.");
 }
 function normalize(command, rest) {
 	if (command === "approval-templates") return {
@@ -54745,7 +57620,7 @@ function normalize(command, rest) {
 		args: rest
 	};
 	const [subcommand, ...args] = rest;
-	if (!SUBCOMMANDS.includes(subcommand)) usage$6("approval-template needs one of: " + SUBCOMMANDS.join(", ") + ".");
+	if (!SUBCOMMANDS.includes(subcommand)) usage$7("approval-template needs one of: " + SUBCOMMANDS.join(", ") + ".");
 	return {
 		subcommand,
 		args
@@ -54753,7 +57628,7 @@ function normalize(command, rest) {
 }
 async function runApprovalTemplateCommand(command, rest, values, io, connect) {
 	if (command === "approval-template-set") {
-		if (rest.length !== 2 || rest.some((value) => !value.trim())) usage$6("approval-template-set needs a bot id and a template name (or off).");
+		if (rest.length !== 2 || rest.some((value) => !value.trim())) usage$7("approval-template-set needs a bot id and a template name (or off).");
 		const rpc = await connect();
 		const template = rest[1].trim();
 		return rpc("botApprovalTemplateSet", {
@@ -54762,11 +57637,11 @@ async function runApprovalTemplateCommand(command, rest, values, io, connect) {
 		});
 	}
 	const { subcommand, args } = normalize(command, rest);
-	if (args.length !== POSITIONALS[subcommand] || args.some((value) => !value.trim())) usage$6(subcommand === "list" ? "approval-template list takes no positional arguments." : `approval-template ${subcommand} needs exactly one template name.`);
+	if (args.length !== POSITIONALS[subcommand] || args.some((value) => !value.trim())) usage$7(subcommand === "list" ? "approval-template list takes no positional arguments." : `approval-template ${subcommand} needs exactly one template name.`);
 	const name = args[0]?.trim() ?? "";
 	if (subcommand === "create") {
 		const from = values.from?.trim();
-		if (from !== void 0 && (values.file !== void 0 || values["text-stdin"] === true)) usage$6("approval-template create takes --from, or the text with --file or --text-stdin.");
+		if (from !== void 0 && (values.file !== void 0 || values["text-stdin"] === true)) usage$7("approval-template create takes --from, or the text with --file or --text-stdin.");
 		const text = from === void 0 ? await templateText(values, io) : void 0;
 		return (await connect())("approvalTemplateCreate", {
 			name,
@@ -54810,19 +57685,19 @@ const APPROVAL_REVIEWER_COMMANDS = [{
 function isApprovalReviewerCommand(command) {
 	return APPROVAL_REVIEWER_COMMANDS.some((entry) => entry.command === command);
 }
-function usage$5(message) {
+function usage$6(message) {
 	throw new CliLiveError("usage", message);
 }
 function modelArgument(value, effort) {
 	if (value === "bot") {
-		if (effort !== void 0) usage$5("--effort applies only to a named model, not `bot`.");
+		if (effort !== void 0) usage$6("--effort applies only to a named model, not `bot`.");
 		return null;
 	}
 	const slash = value.indexOf("/");
 	const provider = slash < 0 ? "" : value.slice(0, slash).trim();
 	const model = slash < 0 ? "" : value.slice(slash + 1).trim();
-	if (!provider || !model) usage$5("approval-reviewer-model-set needs <provider>/<model> (for example deepseek/<model>) or bot.");
-	if (effort !== void 0 && !effort.trim()) usage$5("--effort must not be empty.");
+	if (!provider || !model) usage$6("approval-reviewer-model-set needs <provider>/<model> (for example deepseek/<model>) or bot.");
+	if (effort !== void 0 && !effort.trim()) usage$6("--effort must not be empty.");
 	return {
 		provider,
 		model,
@@ -54831,16 +57706,71 @@ function modelArgument(value, effort) {
 }
 async function runApprovalReviewerCommand(command, rest, values, connect) {
 	if (command === "approval-reviewer-model") {
-		if (rest.length !== 0 || values.effort !== void 0) usage$5("approval-reviewer-model takes no arguments.");
+		if (rest.length !== 0 || values.effort !== void 0) usage$6("approval-reviewer-model takes no arguments.");
 		return (await connect())("approvalReviewerModel", {});
 	}
-	if (rest.length !== 1 || !rest[0].trim()) usage$5("approval-reviewer-model-set needs exactly one <provider>/<model>, or bot.");
+	if (rest.length !== 1 || !rest[0].trim()) usage$6("approval-reviewer-model-set needs exactly one <provider>/<model>, or bot.");
 	const model = modelArgument(rest[0].trim(), values.effort);
 	return (await connect())("approvalReviewerModelSet", { model });
 }
 //#endregion
+//#region packages/core/src/runtime/idle-compaction-settings.ts
+const MAX_CACHE_LIFETIME_SECONDS = 604800;
+//#endregion
+//#region packages/core/src/bots/cli-idle-compaction.ts
+const IDLE_COMPACTION_COMMANDS = [
+	{
+		command: "idle-compaction",
+		description: "show whether idle Orchestrator Sessions are compacted while their prompt cache is warm, and each route’s cache lifetime"
+	},
+	{
+		command: "idle-compaction-set",
+		description: "turn idle compaction on or off for every Bot (on | off)"
+	},
+	{
+		command: "idle-compaction-cache-set",
+		description: "set one route’s prompt-cache lifetime in seconds (<provider>/<model> <seconds>), or `auto` to resolve it again"
+	}
+];
+function isIdleCompactionCommand(command) {
+	return IDLE_COMPACTION_COMMANDS.some((entry) => entry.command === command);
+}
+function usage$5(message) {
+	throw new CliLiveError("usage", message);
+}
+async function runIdleCompactionCommand(command, rest, connect) {
+	if (command === "idle-compaction") {
+		if (rest.length !== 0) usage$5("idle-compaction takes no arguments.");
+		return (await connect())("idleCompaction", {});
+	}
+	if (command === "idle-compaction-set") {
+		const value = rest.length === 1 ? rest[0].trim() : "";
+		if (value !== "on" && value !== "off") usage$5("idle-compaction-set needs exactly on or off.");
+		return (await connect())("idleCompactionSet", { enabled: value === "on" });
+	}
+	if (rest.length !== 2) usage$5("idle-compaction-cache-set needs <provider>/<model> and <seconds> or auto.");
+	const route = rest[0].trim();
+	const slash = route.indexOf("/");
+	const provider = slash < 0 ? "" : route.slice(0, slash).trim();
+	const model = slash < 0 ? "" : route.slice(slash + 1).trim();
+	if (!provider || !model) usage$5("idle-compaction-cache-set needs <provider>/<model>, for example deepseek/<model>.");
+	const value = rest[1].trim();
+	let seconds = null;
+	if (value !== "auto") {
+		if (!/^\d+$/u.test(value) || Number(value) > 604800) usage$5(`idle-compaction-cache-set needs whole seconds from 0 to ${MAX_CACHE_LIFETIME_SECONDS}, or auto.`);
+		seconds = Number(value);
+	}
+	return (await connect())("idleCompactionCacheLifetimeSet", {
+		provider,
+		model,
+		seconds
+	});
+}
+//#endregion
 //#region packages/core/src/bots/cli-live.ts
 const LIVE_OPTIONS = {
+	...WINDOW_ZOOM_OPTIONS,
+	...APPEARANCE_OPTIONS,
 	...IM_OPTIONS,
 	...MESSAGING_OPTIONS,
 	...MODELS_USAGE_OPTIONS,
@@ -54855,6 +57785,9 @@ const LIVE_OPTIONS = {
 	...APPROVAL_REVIEWER_OPTIONS,
 	host: { type: "string" },
 	"token-file": { type: "string" },
+	"image-source": { type: "string" },
+	"image-revision": { type: "string" },
+	"image-reference": { type: "string" },
 	timeout: { type: "string" },
 	"message-id": { type: "string" },
 	outcome: { type: "string" },
@@ -54934,6 +57867,7 @@ const CONTROL_COMMANDS = [
 	"group-create"
 ];
 const LIVE_COMMANDS = [
+	...WINDOW_ZOOM_COMMANDS,
 	...IM_COMMANDS,
 	...MESSAGING_COMMANDS,
 	{
@@ -54947,6 +57881,7 @@ const LIVE_COMMANDS = [
 	...MODELS_USAGE_COMMANDS,
 	...CHANNEL_COMMANDS,
 	...HOST_ADMIN_COMMANDS,
+	...APPEARANCE_COMMANDS,
 	...INBOX_COMMANDS,
 	...BROWSER_COMPUTER_COMMANDS,
 	...PROFILE_COMMANDS,
@@ -54954,6 +57889,7 @@ const LIVE_COMMANDS = [
 	...TODO_COMMANDS,
 	...APPROVAL_TEMPLATE_COMMANDS,
 	...APPROVAL_REVIEWER_COMMANDS,
+	...IDLE_COMPACTION_COMMANDS,
 	{
 		command: "send",
 		description: "send a Human DM and collect its committed Bot reply from a live Host"
@@ -55134,6 +58070,10 @@ const LIVE_COMMANDS = [
 		command: "browser-tool",
 		description: "run one Browser tool directly for a Bot, without the model (args JSON from stdin)"
 	},
+	{
+		command: "memory-image",
+		description: "export version-bound Memory image bytes (--path --image-source --image-revision [--image-reference] --out)"
+	},
 	{
 		command: "memory-file-target",
 		description: "resolve a memory file path for a Bot"
@@ -55408,6 +58348,7 @@ async function runLiveCli(command, rest, values, io) {
 	if (isModelsUsageCommand(command)) return runModelsUsage(command, rest, values, io, async () => {
 		return (await connectLiveHost(values, io, AbortSignal.timeout(timeoutMs(values.timeout)))).rpc;
 	});
+	if (WINDOW_ZOOM_COMMANDS.some((entry) => entry.command === command)) return runWindowZoomCommand(command, rest, values, () => connectLiveHost(values, io, AbortSignal.timeout(timeoutMs(values.timeout))));
 	if (command === "cloud-work") {
 		const input = await prepareCloudWork(rest, values, io);
 		return (await connectLiveHost(values, io, AbortSignal.timeout(timeoutMs(values.timeout)))).rpc("cloudWork", input);
@@ -55420,12 +58361,16 @@ async function runLiveCli(command, rest, values, io) {
 	if (isInboxCommand(command)) return runInboxCommand(command, rest, values, () => connectLiveHost(values, io, AbortSignal.timeout(timeoutMs(values.timeout))));
 	if (isScheduleCommand(command)) return runScheduleCommand(prepareScheduleCommand(command, rest, values), (await connectLiveHost(values, io, AbortSignal.timeout(timeoutMs(values.timeout)))).rpc);
 	if (isBrowserComputerCommand(command)) return runBrowserComputerCommand(command, rest, values, io, () => connectLiveHost(values, io, AbortSignal.timeout(timeoutMs(values.timeout))));
+	if (APPEARANCE_COMMANDS.some((entry) => entry.command === command)) return runAppearanceCommand(command, rest, values, io, () => connectLiveHost(values, io, AbortSignal.timeout(timeoutMs(values.timeout))));
 	if (isProfileCommand(command)) return runProfileCommand(command, rest, values, io, async () => {
 		return (await connectLiveHost(values, io, AbortSignal.timeout(timeoutMs(values.timeout)))).rpc;
 	});
 	if (isApprovalReviewerCommand(command)) return runApprovalReviewerCommand(command, rest, values, async () => {
 		return (await connectLiveHost(values, io, AbortSignal.timeout(timeoutMs(values.timeout)))).rpc;
 	});
+	if (isIdleCompactionCommand(command)) return runIdleCompactionCommand(command, rest, async () => {
+		return (await connectLiveHost(values, io, AbortSignal.timeout(timeoutMs(values.timeout)))).rpc;
+	});
 	if (isApprovalTemplateCommand(command)) return runApprovalTemplateCommand(command, rest, values, io, async () => {
 		return (await connectLiveHost(values, io, AbortSignal.timeout(timeoutMs(values.timeout)))).rpc;
 	});
@@ -55497,7 +58442,7 @@ async function runLiveCli(command, rest, values, io) {
 		if (!body?.trim()) usage$4("send requires a nonempty message.");
 		if (messageId !== void 0 && !/^human-[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/iu.test(messageId)) usage$4("--message-id must be human- followed by a UUID.");
 	}
-	if (command === "tool-approval-decide" && values.outcome !== "allowed-once" && values.outcome !== "allowed-always-kind" && values.outcome !== "rejected") usage$4("--outcome must be allowed-once, allowed-always-kind or rejected.");
+	if (command === "tool-approval-decide" && values.outcome !== "allowed-once" && values.outcome !== "allowed-always-tool" && values.outcome !== "allowed-always-kind" && values.outcome !== "rejected") usage$4("--outcome must be allowed-once, allowed-always-tool, allowed-always-kind or rejected.");
 	if (command === "user-question-answer") {
 		if (!values["answer-stdin"]) usage$4("user-question-answer requires --answer-stdin.");
 		try {
@@ -55991,6 +58936,7 @@ async function runDeviceCommand(command, rest, values, io) {
 const MEMORY_COMMANDS = /* @__PURE__ */ new Set([
 	"memory-snapshot",
 	"memory-file",
+	"memory-image",
 	"memory-history",
 	"memory-diff",
 	"memory-save",
@@ -56034,6 +58980,40 @@ async function runMemoryCommand(command, rest, values, io) {
 		case "memory-snapshot":
 			[method, args] = ["memorySnapshot", { channelId }];
 			break;
+		case "memory-image": {
+			const path = required("path", "path <file>");
+			const source = required("image-source", "image-source worktree|index|<commit>");
+			const revision = required("image-revision", "image-revision <sha256>");
+			const out = required("out", "out <absolute file>");
+			if (!isAbsolute(out)) usage$4("--out must be an absolute path.");
+			const host = await connectLiveHost(values, io, AbortSignal.timeout(timeoutMs(values.timeout)));
+			const reference = values["image-reference"];
+			const { bytes, response } = await host.http("/api/botharness/memory/image?" + new URLSearchParams({
+				slug,
+				path,
+				source,
+				revision,
+				...reference === void 0 ? {} : { reference }
+			}));
+			const mime = response.headers.get("content-type");
+			if (![
+				"image/png",
+				"image/jpeg",
+				"image/gif",
+				"image/webp",
+				"image/svg+xml"
+			].includes(mime ?? "")) throw new CliLiveError("host-protocol-error", "Expected a supported Memory image");
+			writeFileSync(out, bytes, { flag: "wx" });
+			return {
+				path,
+				source,
+				revision,
+				...reference === void 0 ? {} : { reference },
+				mime,
+				bytes: bytes.length,
+				out
+			};
+		}
 		case "memory-file":
 			[method, args] = ["memoryFile", {
 				channelId,
@@ -56908,9 +59888,9 @@ async function runAgentCli(command, rest, values, io) {
 			});
 		}
 	}
-	const seconds = values["timeout"] === void 0 ? 120 : Number(values["timeout"]);
-	if (!Number.isFinite(seconds) || seconds <= 0 || seconds > 600) refuse("usage", "--timeout must be between 0 and 600 seconds.");
 	const write = managed?.write ?? operation === "settings-set";
+	const seconds = values["timeout"] === void 0 ? write ? 600 : 120 : Number(values["timeout"]);
+	if (!Number.isFinite(seconds) || seconds <= 0 || seconds > 600) refuse("usage", "--timeout must be between 0 and 600 seconds.");
 	let response;
 	let body;
 	try {
@@ -56978,6 +59958,10 @@ const LIFECYCLE_COMMANDS = [
 		command: "bot-new-session",
 		description: "retire an idle Bot's Orchestrator Session; the next message starts a fresh one"
 	},
+	{
+		command: "bot-compact",
+		description: "compact an idle Bot's Orchestrator Session now through DSH /compact; refuses while it works"
+	},
 	{
 		command: "bot-delete-preview",
 		description: "inspect the current PersonaBot deletion scope and confirmation token"
@@ -57089,6 +60073,7 @@ async function runOnlineManagement(command, rest, values, io, create, bundle) {
 	}
 	if (command === "model-plan") return rpc("modelPlan", { slug });
 	if (command === "bot-new-session") return rpc("botNewSession", { slug });
+	if (command === "bot-compact") return rpc("botCompact", { slug });
 	if (command === "bot-delete-preview") return rpc("deletionPreview", { slug });
 	if (command === "bot-delete-memory-folder") return rpc("deletionMemoryFolder", { slug });
 	if (command === "bot-delete-confirm") return rpc("deletionConfirm", {