@aigne/afs-ui 1.11.0-beta.12

package/dist/ui-provider.mjs

@@ -0,0 +1,4616 @@
+import { DEVICE_CAPS_TERM, DEVICE_CAPS_TTY, DEVICE_CAPS_WEB_FULL, validateDeviceCaps, validateNode } from "./aup-types.mjs";
+import { AUPNodeStore, AUPSceneManager } from "./aup-protocol.mjs";
+import { isAUPTransport, isSessionAware } from "./backend.mjs";
+import { degradeTree } from "./degradation.mjs";
+import { SessionManager } from "./session.mjs";
+import { TTYBackend } from "./tty.mjs";
+import { TermBackend } from "./term.mjs";
+import { OVERLAY_THEMES, PRIMITIVES, THEMES } from "./aup-registry.mjs";
+import { AUP_EXAMPLES, AUP_SPEC } from "./aup-spec.mjs";
+import { generateSnapshot } from "./snapshot.mjs";
+import { WebBackend } from "./web.mjs";
+import { PANEL_PRESETS, autoArrange } from "./wm-state.mjs";
+import { __decorate } from "./_virtual/_@oxc-project_runtime@0.108.0/helpers/decorate.mjs";
+import { joinURL } from "ufo";
+import { existsSync, mkdirSync, readFileSync, readdirSync, unlinkSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { AFSNotFoundError } from "@aigne/afs";
+import { AFSBaseProvider, Actions, Delete, Explain, List, Meta, Read, Stat, Write } from "@aigne/afs/provider";
+import { z } from "zod";
+
+//#region src/ui-provider.ts
+const VALID_ACCESS_LEVELS = new Set([
+	"guest",
+	"link-only",
+	"user",
+	"admin"
+]);
+const VALID_SHARING_MODES = new Set(["static", "live"]);
+const afsUISchema = z.object({
+	backend: z.enum([
+		"tty",
+		"web",
+		"term"
+	]).default("tty"),
+	port: z.coerce.number().optional()
+});
+var AFSUIProvider = class extends AFSBaseProvider {
+	name;
+	description;
+	accessMode = "readwrite";
+	backend;
+	inputTimeout;
+	pages = /* @__PURE__ */ new Map();
+	pagesDir;
+	initPromise = null;
+	serverUrl = null;
+	/** Web sharing entries: slug -> SharingEntry */
+	sharingEntries = /* @__PURE__ */ new Map();
+	/** Session management */
+	sessions = new SessionManager();
+	/** Per-session AUP node stores */
+	aupStores = /* @__PURE__ */ new Map();
+	/** Per-session AUP scene managers (for stage-to-live dual buffer) */
+	aupManagers = /* @__PURE__ */ new Map();
+	/** AFS root reference for auto-dispatching AUP events to afs.exec() */
+	afsRoot = null;
+	/** Endpoint type derived from backend (tty, web, term) */
+	endpointType;
+	/** External callback for AUP events — allows app code to handle navigation etc. */
+	onAupEvent;
+	constructor(options = {}) {
+		super();
+		this.name = options.name ?? "ui";
+		this.description = options.description ?? "Interactive UI device";
+		this.inputTimeout = options.inputTimeout ?? 0;
+		this.pagesDir = options.pagesDir ?? "";
+		if (typeof options.backend === "object") {
+			this.backend = options.backend;
+			if ("url" in this.backend && typeof this.backend.url === "string") this.serverUrl = this.backend.url;
+		} else if (options.backend === "web") {
+			const webOpts = { ...options.webOptions };
+			if (options.port != null) webOpts.port = options.port;
+			const web = new WebBackend(webOpts);
+			this.backend = web;
+			this.initPromise = web.listen().then(() => {
+				this.serverUrl = web.url;
+			});
+		} else if (options.backend === "term") {
+			const termOpts = { ...options.termOptions };
+			if (options.port != null) termOpts.port = options.port;
+			const term = new TermBackend(termOpts);
+			this.backend = term;
+			this.initPromise = term.listen().then(() => {
+				this.serverUrl = term.url;
+			});
+		} else this.backend = new TTYBackend({
+			...options.ttyOptions,
+			inputTimeout: this.inputTimeout
+		});
+		this.endpointType = this.backend.type;
+		if (isSessionAware(this.backend)) {
+			const defaultCaps = this.backend.type === "term" ? DEVICE_CAPS_TERM : DEVICE_CAPS_WEB_FULL;
+			this.backend.setSessionFactory((endpoint, requestedSid, requestedSessionToken, rawCaps) => {
+				const caps = rawCaps && !validateDeviceCaps(rawCaps) ? rawCaps : defaultCaps;
+				if (requestedSid && this.sessions.has(requestedSid)) {
+					const existing = this.sessions.get(requestedSid);
+					if (requestedSessionToken && requestedSessionToken === existing.resumeToken) {
+						existing.touch();
+						existing.setDeviceCaps(caps);
+						return {
+							sessionId: requestedSid,
+							sessionToken: existing.resumeToken
+						};
+					}
+					const rotated = this.sessions.create(endpoint, caps);
+					return {
+						sessionId: rotated.id,
+						sessionToken: rotated.resumeToken
+					};
+				}
+				const fresh = this.sessions.create(endpoint, caps);
+				return {
+					sessionId: fresh.id,
+					sessionToken: fresh.resumeToken
+				};
+			});
+		}
+		if (isAUPTransport(this.backend)) {
+			this.backend.setAupEventHandler(async (msg, sessionId, channelId) => {
+				const storeId = channelId ? this.channelAupKey(channelId) : sessionId;
+				if (!storeId) throw new Error("No session or channel for AUP event");
+				return this.handleAupEvent(storeId, msg.nodeId, msg.event, msg.data);
+			});
+			this.backend.setChannelJoinHandler((channelId, send) => {
+				const store = this.aupStores.get(this.channelAupKey(channelId));
+				const root = store?.getRoot();
+				if (store && root) {
+					const opts = store.renderOptions;
+					const msg = {
+						type: "aup",
+						action: "render",
+						root,
+						treeVersion: store.version
+					};
+					if (opts.fullPage) msg.fullPage = true;
+					if (opts.chrome) msg.chrome = true;
+					if (opts.theme) msg.theme = opts.theme;
+					if (opts.style) msg.style = opts.style;
+					if (opts.locale) msg.locale = opts.locale;
+					send(msg);
+				}
+			});
+			this.backend.setSessionJoinHandler((sessionId, clientVersion, send) => {
+				const session = this.sessions.has(sessionId) ? this.sessions.get(sessionId) : null;
+				const activeScene = this.aupManagers.get(sessionId)?.getActiveScene();
+				if (activeScene) {
+					const { store: store$1 } = activeScene;
+					const root$1 = store$1.getRoot();
+					if (root$1) {
+						if (clientVersion > 0 && clientVersion >= store$1.version) return;
+						const degraded$1 = session ? this.degradeForSession(root$1, session) : root$1;
+						const opts$1 = store$1.renderOptions;
+						const msg$1 = {
+							type: "aup",
+							action: "stage",
+							sceneId: activeScene.sceneId,
+							root: degraded$1,
+							treeVersion: store$1.version
+						};
+						if (opts$1.fullPage) msg$1.fullPage = true;
+						if (opts$1.chrome) msg$1.chrome = true;
+						if (opts$1.theme) msg$1.theme = opts$1.theme;
+						if (opts$1.style) msg$1.style = opts$1.style;
+						if (opts$1.locale) msg$1.locale = opts$1.locale;
+						send(msg$1);
+						send({
+							type: "aup",
+							action: "take",
+							sceneId: activeScene.sceneId
+						});
+						return;
+					}
+				}
+				const store = this.aupStores.get(sessionId);
+				if (!store) return;
+				const root = store.getRoot();
+				if (!root) return;
+				if (clientVersion > 0 && clientVersion >= store.version) return;
+				const degraded = session ? this.degradeForSession(root, session) : root;
+				const opts = store.renderOptions;
+				const msg = {
+					type: "aup",
+					action: "render",
+					root: degraded,
+					treeVersion: store.version
+				};
+				if (opts.fullPage) msg.fullPage = true;
+				if (opts.chrome) msg.chrome = true;
+				if (opts.theme) msg.theme = opts.theme;
+				if (opts.style) msg.style = opts.style;
+				if (opts.locale) msg.locale = opts.locale;
+				send(msg);
+			});
+			this.backend.setPageResolver(async (pageId, sessionId, sessionToken) => {
+				if (sessionId && sessionToken && this.sessions.has(sessionId)) {
+					const session = this.sessions.get(sessionId);
+					if (session.resumeToken === sessionToken) {
+						const page$1 = session.getPage(pageId);
+						if (page$1) return {
+							content: page$1.content,
+							format: page$1.format
+						};
+					}
+				}
+				const page = this.pages.get(pageId);
+				if (page) return {
+					content: page.content,
+					format: page.format
+				};
+				return null;
+			});
+			if ("setSnapshotResolver" in this.backend) this.backend.setSnapshotResolver((slug) => {
+				const entry = this.sharingEntries.get(slug);
+				if (!entry?.snapshot) return null;
+				return entry.snapshot;
+			});
+		}
+		if (this.endpointType === "tty") this.sessions.create("tty", DEVICE_CAPS_TTY);
+	}
+	/** Inject AFS root into AUP transport for browser AFS proxy + discover pages dir. */
+	onMount(root, _mountPath) {
+		this.afsRoot = root;
+		if (isAUPTransport(this.backend)) this.backend.setAFS(root);
+		if (this.pagesDir !== false) this.discoverAndLoadPages(root);
+	}
+	/** Discover workspace path from AFS root meta, then load persisted pages. */
+	async discoverAndLoadPages(root) {
+		try {
+			if (this.pagesDir) {
+				this.loadPagesFromDisk(this.pagesDir);
+				return;
+			}
+			if (root.read) try {
+				const storagePath = (await root.read("/.meta"))?.data?.content?.storagePath;
+				if (storagePath) {
+					this.pagesDir = join(storagePath, ".afs-ui", "pages");
+					this.loadPagesFromDisk(this.pagesDir);
+					return;
+				}
+			} catch {}
+			this.pagesDir = join(process.cwd(), ".afs-ui", "pages");
+			this.loadPagesFromDisk(this.pagesDir);
+		} catch {}
+	}
+	/** Load persisted page files from disk into the pages Map. */
+	loadPagesFromDisk(dir) {
+		if (!existsSync(dir)) return;
+		for (const file of readdirSync(dir)) {
+			if (file.startsWith(".")) continue;
+			try {
+				const content = readFileSync(join(dir, file), "utf-8");
+				const now = Date.now();
+				this.pages.set(file, {
+					content,
+					format: "html",
+					createdAt: now,
+					updatedAt: now
+				});
+			} catch {}
+		}
+	}
+	/** Persist a page to disk as a plain file (best-effort). */
+	persistPageToDisk(pageId, data) {
+		if (!this.pagesDir) return;
+		try {
+			if (!existsSync(this.pagesDir)) mkdirSync(this.pagesDir, { recursive: true });
+			writeFileSync(join(this.pagesDir, pageId), data.content, "utf-8");
+		} catch {}
+	}
+	/** Remove a persisted page from disk (best-effort). */
+	removePageFromDisk(pageId) {
+		if (!this.pagesDir) return;
+		try {
+			const filePath = join(this.pagesDir, pageId);
+			if (existsSync(filePath)) unlinkSync(filePath);
+		} catch {}
+	}
+	/** Assert the endpoint param matches this provider's type */
+	assertEndpoint(ctx) {
+		const endpoint = ctx.params.endpoint;
+		if (endpoint !== this.endpointType) throw new AFSNotFoundError(`/${endpoint}`);
+		return endpoint;
+	}
+	/** Resolve session from route params, throwing if not found */
+	resolveSession(ctx) {
+		this.assertEndpoint(ctx);
+		const sid = ctx.params.sid;
+		return this.sessions.get(sid);
+	}
+	/** Get or create AUP node store for a session */
+	getAupStore(sessionId) {
+		let store = this.aupStores.get(sessionId);
+		if (!store) {
+			store = new AUPNodeStore();
+			this.aupStores.set(sessionId, store);
+		}
+		return store;
+	}
+	/** Get or create AUP scene manager for a session */
+	getAupManager(sessionId) {
+		let mgr = this.aupManagers.get(sessionId);
+		if (!mgr) {
+			mgr = new AUPSceneManager();
+			this.aupManagers.set(sessionId, mgr);
+		}
+		return mgr;
+	}
+	/** Get the WM node from the AUP tree, or null if it doesn't exist yet. */
+	getWmNode(sessionId) {
+		const store = this.aupStores.get(sessionId);
+		if (!store) return null;
+		const wmNode = store.findNode("wm");
+		if (!wmNode) return null;
+		return {
+			store,
+			wmNode
+		};
+	}
+	/**
+	* Ensure a WM node exists in the session's AUP tree.
+	* Creates a minimal root + wm node if the tree is empty.
+	*/
+	ensureWmNode(sessionId, strategy = "floating") {
+		const store = this.getAupStore(sessionId);
+		let wmNode = store.findNode("wm");
+		if (wmNode) return {
+			store,
+			wmNode
+		};
+		if (!store.getRoot()) {
+			store.setRoot({
+				id: "root",
+				type: "view",
+				children: [{
+					id: "wm",
+					type: "wm",
+					props: { strategy }
+				}]
+			});
+			if (isAUPTransport(this.backend)) this.backend.sendToSession(sessionId, {
+				type: "aup",
+				action: "render",
+				root: store.getRoot(),
+				treeVersion: store.version,
+				fullPage: true
+			});
+		} else store.applyPatch([{
+			op: "create",
+			id: "wm",
+			parentId: store.getRoot().id,
+			node: {
+				id: "wm",
+				type: "wm",
+				props: { strategy }
+			}
+		}]);
+		wmNode = store.findNode("wm");
+		return {
+			store,
+			wmNode
+		};
+	}
+	/**
+	* Apply WM-related AUP patch ops and notify the client.
+	*/
+	applyWmPatch(sessionId, ctx, ops) {
+		const store = this.getAupStore(sessionId);
+		store.applyPatch(ops);
+		if (isAUPTransport(this.backend)) this.backend.sendToSession(sessionId, {
+			type: "aup",
+			action: "patch",
+			ops,
+			treeVersion: store.version
+		});
+		const endpoint = ctx.params.endpoint;
+		const treePath = joinURL("/", endpoint, "sessions", sessionId, "tree");
+		this.emit({
+			type: "afs:write",
+			path: treePath,
+			data: { root: store.getRoot() }
+		});
+		return store;
+	}
+	/** Find a WM surface child node by surface name. */
+	findWmSurface(wmNode, name) {
+		return (wmNode.children || []).find((c) => c.type === "wm-surface" && (c.props?.surfaceName === name || c.id === `wm-surface-${name}`));
+	}
+	/**
+	* Handle built-in WM events from client-side panel interactions.
+	* Returns undefined if the event is not a WM-specific event.
+	*/
+	handleWmEvent(sessionId, event, data) {
+		const wm = this.getWmNode(sessionId);
+		if (!wm) return void 0;
+		const panels = (wm.wmNode.props ?? {}).panels ?? [];
+		if (event === "panel-collapse") {
+			const panelId = data.panelId;
+			if (!panelId) return void 0;
+			const updated = panels.map((p) => p.id === panelId ? {
+				...p,
+				collapsed: true
+			} : p);
+			this.applyWmPatchDirect(sessionId, [{
+				op: "update",
+				id: "wm",
+				props: { panels: updated }
+			}]);
+			return {
+				success: true,
+				panelId,
+				collapsed: true
+			};
+		}
+		if (event === "panel-expand") {
+			const panelId = data.panelId;
+			if (!panelId) return void 0;
+			const updated = panels.map((p) => p.id === panelId ? {
+				...p,
+				collapsed: false
+			} : p);
+			this.applyWmPatchDirect(sessionId, [{
+				op: "update",
+				id: "wm",
+				props: { panels: updated }
+			}]);
+			return {
+				success: true,
+				panelId,
+				collapsed: false
+			};
+		}
+		if (event === "panel-resize") {
+			const panelId = data.panelId;
+			const size = data.size;
+			if (!panelId || !size) return void 0;
+			const updated = panels.map((p) => p.id === panelId ? {
+				...p,
+				defaultSize: size
+			} : p);
+			this.applyWmPatchDirect(sessionId, [{
+				op: "update",
+				id: "wm",
+				props: { panels: updated }
+			}]);
+			return {
+				success: true,
+				panelId,
+				size
+			};
+		}
+	}
+	/**
+	* Apply WM patch directly without needing a RouteContext.
+	* Used for client-initiated WM events.
+	*/
+	applyWmPatchDirect(sessionId, ops) {
+		const store = this.getAupStore(sessionId);
+		store.applyPatch(ops);
+		if (isAUPTransport(this.backend)) this.backend.sendToSession(sessionId, {
+			type: "aup",
+			action: "patch",
+			ops,
+			treeVersion: store.version
+		});
+	}
+	/** AUP store key for a live channel */
+	channelAupKey(channelId) {
+		return `live:${channelId}`;
+	}
+	/** Get or create AUP node store for a live channel */
+	getChannelAupStore(channelId) {
+		const key = this.channelAupKey(channelId);
+		let store = this.aupStores.get(key);
+		if (!store) {
+			store = new AUPNodeStore();
+			this.aupStores.set(key, store);
+		}
+		return store;
+	}
+	/** Degrade an AUP root for a session's device capabilities (D14). */
+	degradeForSession(root, session) {
+		return degradeTree(root, session.deviceCaps);
+	}
+	/** Count active live channels (stores with live: prefix that have content) */
+	getActiveChannelCount() {
+		let count = 0;
+		for (const key of this.aupStores.keys()) if (key.startsWith("live:")) count++;
+		return count;
+	}
+	/** List active channel IDs */
+	getActiveChannelIds() {
+		const ids = [];
+		for (const key of this.aupStores.keys()) if (key.startsWith("live:")) ids.push(key.slice(5));
+		if (isAUPTransport(this.backend)) {
+			for (const id of this.backend.getActiveChannelIds()) if (!ids.includes(id)) ids.push(id);
+		}
+		return ids;
+	}
+	/** Handle an AUP event from a client — resolve exec path and call it */
+	async handleAupEvent(sessionId, nodeId, event, data) {
+		const node = this.getAupStore(sessionId).findNode(nodeId);
+		if (!node) throw new Error(`AUP node not found: ${nodeId}`);
+		if (node.type === "wm") {
+			const wmResult = this.handleWmEvent(sessionId, event, data ?? {});
+			if (wmResult !== void 0) return wmResult;
+		}
+		const evtConfig = node.events?.[event];
+		if (!evtConfig) {
+			if (this.onAupEvent) {
+				const config$1 = {
+					exec: event,
+					args: data ?? {}
+				};
+				const result = await this.onAupEvent(sessionId, nodeId, event, config$1);
+				if (result !== void 0) return result;
+			}
+			if (!node.events) throw new Error(`Node '${nodeId}' has no events`);
+			throw new Error(`Node '${nodeId}' has no '${event}' event`);
+		}
+		const execPath = evtConfig.exec;
+		if (!execPath || typeof execPath !== "string") throw new Error("Event exec path is required");
+		if (execPath.includes("..")) throw new Error("Event exec path cannot contain '..'");
+		const config = {
+			exec: execPath,
+			args: {
+				...evtConfig.args ?? {},
+				...data ?? {}
+			}
+		};
+		if (this.onAupEvent) {
+			const result = await this.onAupEvent(sessionId, nodeId, event, config);
+			if (result !== void 0) return result;
+		}
+		if (this.afsRoot?.exec) return (await this.afsRoot.exec(config.exec, config.args, {}))?.data;
+		return {
+			...config,
+			nodeId,
+			event
+		};
+	}
+	static schema() {
+		return afsUISchema;
+	}
+	static manifest() {
+		return {
+			name: "ui",
+			description: "Interactive UI device — terminal (xterm.js), web chat, or messaging",
+			uriTemplate: "ui://{backend}",
+			category: "device",
+			schema: afsUISchema,
+			tags: [
+				"ui",
+				"device",
+				"interactive",
+				"term"
+			],
+			capabilityTags: [
+				"read-write",
+				"auth:none",
+				"local"
+			],
+			security: {
+				riskLevel: "local",
+				resourceAccess: ["local-network"],
+				notes: ["Interacts with local terminal, web, or messaging backend"]
+			},
+			capabilities: { network: {
+				egress: true,
+				ingress: true
+			} }
+		};
+	}
+	static treeSchema() {
+		return {
+			operations: [
+				"list",
+				"read",
+				"write",
+				"delete",
+				"exec",
+				"stat",
+				"explain"
+			],
+			tree: {
+				"/": {
+					kind: "device",
+					operations: [
+						"list",
+						"read",
+						"exec"
+					],
+					actions: [
+						"prompt",
+						"clear",
+						"notify",
+						"navigate",
+						"dialog",
+						"progress",
+						"form",
+						"table",
+						"toast"
+					]
+				},
+				"/input": {
+					kind: "input-channel",
+					operations: ["read"]
+				},
+				"/output": {
+					kind: "output-channel",
+					operations: ["read", "write"]
+				},
+				"/pages": {
+					kind: "pages-directory",
+					operations: ["list", "read"]
+				},
+				"/pages/{id}": {
+					kind: "page",
+					operations: [
+						"read",
+						"write",
+						"delete"
+					]
+				}
+			},
+			auth: { type: "none" },
+			bestFor: [
+				"user interaction",
+				"terminal UI",
+				"web chat"
+			],
+			notFor: ["data storage"]
+		};
+	}
+	async readCapabilities(_ctx) {
+		return {
+			id: "/.meta/.capabilities",
+			path: "/.meta/.capabilities",
+			content: {
+				schemaVersion: 1,
+				provider: this.name,
+				description: this.description,
+				tools: [],
+				actions: [],
+				operations: this.getOperationsDeclaration()
+			},
+			meta: { kind: "afs:capabilities" }
+		};
+	}
+	async metaRoot(_ctx) {
+		if (this.initPromise) await this.initPromise;
+		const viewport = this.backend.getViewport();
+		const meta = {
+			kind: "device",
+			backend: this.backend.type,
+			supportedFormats: this.backend.supportedFormats,
+			capabilities: this.backend.capabilities,
+			viewport,
+			childrenCount: 10
+		};
+		if (this.serverUrl) meta.url = this.serverUrl;
+		return {
+			id: ".meta",
+			path: "/.meta",
+			meta
+		};
+	}
+	async metaInput(_ctx) {
+		return {
+			id: ".meta",
+			path: "/input/.meta",
+			meta: {
+				kind: "input-channel",
+				childrenCount: 0,
+				description: "Read user input from this device",
+				pending: this.backend.hasPendingInput()
+			}
+		};
+	}
+	async metaOutput(_ctx) {
+		return {
+			id: ".meta",
+			path: "/output/.meta",
+			meta: {
+				kind: "output-channel",
+				childrenCount: 0,
+				description: "Write content to this device"
+			}
+		};
+	}
+	async metaPages(_ctx) {
+		return {
+			id: ".meta",
+			path: "/pages/.meta",
+			meta: {
+				kind: "pages-directory",
+				childrenCount: this.pages.size,
+				description: "Managed pages for full-page rendering"
+			}
+		};
+	}
+	async metaPage(ctx) {
+		const pageId = ctx.params.id;
+		const page = this.pages.get(pageId);
+		if (!page) throw new Error(`Page not found: ${pageId}`);
+		return {
+			id: ".meta",
+			path: joinURL("/pages", pageId, ".meta"),
+			meta: {
+				kind: "page",
+				format: page.format,
+				childrenCount: 0,
+				createdAt: page.createdAt,
+				updatedAt: page.updatedAt
+			}
+		};
+	}
+	async listInput(_ctx) {
+		return { data: [] };
+	}
+	async listOutput(_ctx) {
+		return { data: [] };
+	}
+	async listPages(_ctx) {
+		const entries = [];
+		for (const [id, page] of this.pages) entries.push({
+			id,
+			path: joinURL("/pages", id),
+			meta: {
+				kind: "page",
+				format: page.format,
+				childrenCount: 0,
+				createdAt: page.createdAt,
+				updatedAt: page.updatedAt
+			}
+		});
+		return { data: entries };
+	}
+	async listRoot(_ctx) {
+		return { data: [
+			{
+				id: "spec",
+				path: "/spec",
+				meta: {
+					kind: "aup:spec",
+					description: "AUP document format specification — start here"
+				}
+			},
+			{
+				id: "primitives",
+				path: "/primitives",
+				meta: {
+					kind: "primitives-directory",
+					childrenCount: Object.keys(PRIMITIVES).length,
+					description: "Available UI components with full props, events, and examples"
+				}
+			},
+			{
+				id: "themes",
+				path: "/themes",
+				meta: {
+					kind: "themes-directory",
+					childrenCount: Object.keys(THEMES).length,
+					description: "Visual themes with color tokens"
+				}
+			},
+			{
+				id: "overlay-themes",
+				path: "/overlay-themes",
+				meta: {
+					kind: "overlay-themes-directory",
+					childrenCount: Object.keys(OVERLAY_THEMES).length,
+					description: "Broadcast overlay themes (graphics packages) for overlay-grid"
+				}
+			},
+			{
+				id: "examples",
+				path: "/examples",
+				meta: {
+					kind: "examples-directory",
+					childrenCount: Object.keys(AUP_EXAMPLES).length,
+					description: "Complete working AUP documents to learn from"
+				}
+			},
+			{
+				id: this.endpointType,
+				path: joinURL("/", this.endpointType),
+				meta: {
+					kind: "endpoint",
+					childrenCount: 1,
+					description: `${this.endpointType} endpoint with session management`
+				}
+			},
+			{
+				id: "input",
+				path: "/input",
+				meta: {
+					kind: "input-channel",
+					childrenCount: 0,
+					description: "Read user input (legacy — use sessions/:id/messages instead)"
+				}
+			},
+			{
+				id: "output",
+				path: "/output",
+				meta: {
+					kind: "output-channel",
+					childrenCount: 0,
+					description: "Write content (legacy — use sessions/:id/messages instead)"
+				}
+			},
+			{
+				id: "pages",
+				path: "/pages",
+				meta: {
+					kind: "pages-directory",
+					childrenCount: this.pages.size,
+					description: "Managed pages (legacy — use sessions/:id/pages instead)"
+				}
+			},
+			{
+				id: "sharing",
+				path: "/sharing",
+				meta: {
+					kind: "sharing-directory",
+					childrenCount: this.sharingEntries.size,
+					description: "Web sharing entries — publish AFS subtrees as public URLs"
+				}
+			}
+		] };
+	}
+	async readRoot(_ctx) {
+		return {
+			id: this.name,
+			path: "/",
+			content: `UI Device (${this.backend.type})`,
+			meta: {
+				kind: "device",
+				childrenCount: 10,
+				backend: this.backend.type
+			}
+		};
+	}
+	async readInput(_ctx) {
+		return {
+			id: "input",
+			path: "/input",
+			content: await this.backend.read({ timeout: this.inputTimeout })
+		};
+	}
+	async readOutput(_ctx) {
+		return {
+			id: "output",
+			path: "/output",
+			content: "",
+			meta: { kind: "output-channel" }
+		};
+	}
+	async readPages(_ctx) {
+		return {
+			id: "pages",
+			path: "/pages",
+			content: "",
+			meta: {
+				kind: "pages-directory",
+				childrenCount: this.pages.size
+			}
+		};
+	}
+	async readPage(ctx) {
+		const pageId = ctx.params.id;
+		const page = this.pages.get(pageId);
+		if (!page) throw new Error(`Page not found: ${pageId}`);
+		return {
+			id: pageId,
+			path: joinURL("/pages", pageId),
+			content: page.content,
+			meta: {
+				kind: "page",
+				format: page.format,
+				layout: page.layout
+			}
+		};
+	}
+	async listPrimitives(_ctx) {
+		return { data: Object.values(PRIMITIVES).map((p) => ({
+			id: p.name,
+			name: p.name,
+			path: joinURL("/primitives", p.name),
+			meta: {
+				kind: "aup:primitive",
+				category: p.category,
+				description: p.description
+			}
+		})) };
+	}
+	async readPrimitivesDir(_ctx) {
+		return {
+			id: "primitives",
+			path: "/primitives",
+			content: `AUP Primitive Registry (${Object.keys(PRIMITIVES).length} primitives)`,
+			meta: {
+				kind: "primitives-directory",
+				childrenCount: Object.keys(PRIMITIVES).length
+			}
+		};
+	}
+	async statPrimitivesDir(_ctx) {
+		return { data: {
+			id: "primitives",
+			path: "/primitives",
+			meta: {
+				kind: "primitives-directory",
+				childrenCount: Object.keys(PRIMITIVES).length
+			}
+		} };
+	}
+	async metaPrimitivesDir(_ctx) {
+		return {
+			id: "primitives",
+			path: "/primitives/.meta",
+			meta: {
+				kind: "primitives-directory",
+				childrenCount: Object.keys(PRIMITIVES).length
+			}
+		};
+	}
+	async readPrimitive(ctx) {
+		const name = ctx.params.name;
+		const prim = PRIMITIVES[name];
+		if (!prim) throw new AFSNotFoundError(joinURL("/primitives", name));
+		return {
+			id: prim.name,
+			path: joinURL("/primitives", prim.name),
+			content: prim,
+			meta: {
+				kind: "aup:primitive",
+				category: prim.category,
+				description: prim.description
+			}
+		};
+	}
+	async statPrimitive(ctx) {
+		const name = ctx.params.name;
+		const prim = PRIMITIVES[name];
+		if (!prim) throw new AFSNotFoundError(joinURL("/primitives", name));
+		return { data: {
+			id: prim.name,
+			path: joinURL("/primitives", prim.name),
+			meta: {
+				kind: "aup:primitive",
+				category: prim.category,
+				description: prim.description
+			}
+		} };
+	}
+	async metaPrimitive(ctx) {
+		const name = ctx.params.name;
+		const prim = PRIMITIVES[name];
+		if (!prim) throw new AFSNotFoundError(joinURL("/primitives", name));
+		return {
+			id: prim.name,
+			path: joinURL("/primitives", prim.name, ".meta"),
+			meta: {
+				kind: "aup:primitive",
+				category: prim.category,
+				description: prim.description
+			}
+		};
+	}
+	async listThemes(_ctx) {
+		return { data: Object.values(THEMES).map((t) => ({
+			id: t.name,
+			name: t.name,
+			path: joinURL("/themes", t.name),
+			meta: {
+				kind: "aup:theme",
+				description: t.description
+			}
+		})) };
+	}
+	async readThemesDir(_ctx) {
+		return {
+			id: "themes",
+			path: "/themes",
+			content: `AUP Theme Registry (${Object.keys(THEMES).length} themes)`,
+			meta: {
+				kind: "themes-directory",
+				childrenCount: Object.keys(THEMES).length
+			}
+		};
+	}
+	async statThemesDir(_ctx) {
+		return { data: {
+			id: "themes",
+			path: "/themes",
+			meta: {
+				kind: "themes-directory",
+				childrenCount: Object.keys(THEMES).length
+			}
+		} };
+	}
+	async metaThemesDir(_ctx) {
+		return {
+			id: "themes",
+			path: "/themes/.meta",
+			meta: {
+				kind: "themes-directory",
+				childrenCount: Object.keys(THEMES).length
+			}
+		};
+	}
+	async readTheme(ctx) {
+		const name = ctx.params.name;
+		const theme = THEMES[name];
+		if (!theme) throw new AFSNotFoundError(joinURL("/themes", name));
+		return {
+			id: theme.name,
+			path: joinURL("/themes", theme.name),
+			content: theme,
+			meta: {
+				kind: "aup:theme",
+				description: theme.description
+			}
+		};
+	}
+	async statTheme(ctx) {
+		const name = ctx.params.name;
+		const theme = THEMES[name];
+		if (!theme) throw new AFSNotFoundError(joinURL("/themes", name));
+		return { data: {
+			id: theme.name,
+			path: joinURL("/themes", theme.name),
+			meta: {
+				kind: "aup:theme",
+				description: theme.description
+			}
+		} };
+	}
+	async metaTheme(ctx) {
+		const name = ctx.params.name;
+		const theme = THEMES[name];
+		if (!theme) throw new AFSNotFoundError(joinURL("/themes", name));
+		return {
+			id: theme.name,
+			path: joinURL("/themes", theme.name, ".meta"),
+			meta: {
+				kind: "aup:theme",
+				description: theme.description
+			}
+		};
+	}
+	async listOverlayThemes(_ctx) {
+		return { data: Object.values(OVERLAY_THEMES).map((t) => ({
+			id: t.name,
+			name: t.name,
+			path: joinURL("/overlay-themes", t.name),
+			meta: {
+				kind: "aup:overlay-theme",
+				description: t.description
+			}
+		})) };
+	}
+	async readOverlayThemesDir(_ctx) {
+		return {
+			id: "overlay-themes",
+			path: "/overlay-themes",
+			content: `AUP Overlay Theme Registry (${Object.keys(OVERLAY_THEMES).length} themes)\n\nBroadcast "graphics packages" for overlay-grid layouts. Apply via theme prop on view with layout: "overlay-grid".\n\nAvailable: ${Object.keys(OVERLAY_THEMES).join(", ")}`,
+			meta: {
+				kind: "overlay-themes-directory",
+				childrenCount: Object.keys(OVERLAY_THEMES).length
+			}
+		};
+	}
+	async statOverlayThemesDir(_ctx) {
+		return { data: {
+			id: "overlay-themes",
+			path: "/overlay-themes",
+			meta: {
+				kind: "overlay-themes-directory",
+				childrenCount: Object.keys(OVERLAY_THEMES).length
+			}
+		} };
+	}
+	async metaOverlayThemesDir(_ctx) {
+		return {
+			id: "overlay-themes",
+			path: "/overlay-themes/.meta",
+			meta: {
+				kind: "overlay-themes-directory",
+				childrenCount: Object.keys(OVERLAY_THEMES).length
+			}
+		};
+	}
+	async readOverlayTheme(ctx) {
+		const name = ctx.params.name;
+		const theme = OVERLAY_THEMES[name];
+		if (!theme) throw new AFSNotFoundError(joinURL("/overlay-themes", name));
+		return {
+			id: theme.name,
+			path: joinURL("/overlay-themes", theme.name),
+			content: theme,
+			meta: {
+				kind: "aup:overlay-theme",
+				description: theme.description
+			}
+		};
+	}
+	async statOverlayTheme(ctx) {
+		const name = ctx.params.name;
+		const theme = OVERLAY_THEMES[name];
+		if (!theme) throw new AFSNotFoundError(joinURL("/overlay-themes", name));
+		return { data: {
+			id: theme.name,
+			path: joinURL("/overlay-themes", theme.name),
+			meta: {
+				kind: "aup:overlay-theme",
+				description: theme.description
+			}
+		} };
+	}
+	async metaOverlayTheme(ctx) {
+		const name = ctx.params.name;
+		const theme = OVERLAY_THEMES[name];
+		if (!theme) throw new AFSNotFoundError(joinURL("/overlay-themes", name));
+		return {
+			id: theme.name,
+			path: joinURL("/overlay-themes", theme.name, ".meta"),
+			meta: {
+				kind: "aup:overlay-theme",
+				description: theme.description
+			}
+		};
+	}
+	async listOverlayExamples(ctx) {
+		const name = ctx.params.name;
+		const theme = OVERLAY_THEMES[name];
+		if (!theme) throw new AFSNotFoundError(joinURL("/overlay-themes", name));
+		return { data: (theme.examples || []).map((ex) => ({
+			id: ex.name,
+			name: ex.name,
+			path: joinURL("/overlay-themes", name, "examples", ex.name),
+			meta: {
+				kind: "aup:overlay-example",
+				description: ex.description
+			}
+		})) };
+	}
+	async readOverlayExample(ctx) {
+		const name = ctx.params.name;
+		const exName = ctx.params.example;
+		const theme = OVERLAY_THEMES[name];
+		if (!theme) throw new AFSNotFoundError(joinURL("/overlay-themes", name));
+		const ex = (theme.examples || []).find((e) => e.name === exName);
+		if (!ex) throw new AFSNotFoundError(joinURL("/overlay-themes", name, "examples", exName));
+		return {
+			id: ex.name,
+			path: joinURL("/overlay-themes", name, "examples", ex.name),
+			content: ex.tree,
+			meta: {
+				kind: "aup:overlay-example",
+				description: ex.description
+			}
+		};
+	}
+	async readSpec(_ctx) {
+		return {
+			id: "spec",
+			path: "/spec",
+			content: AUP_SPEC,
+			meta: {
+				kind: "aup:spec",
+				version: AUP_SPEC.version
+			}
+		};
+	}
+	async statSpec(_ctx) {
+		return { data: {
+			id: "spec",
+			path: "/spec",
+			meta: {
+				kind: "aup:spec",
+				version: AUP_SPEC.version
+			}
+		} };
+	}
+	async listSpec(_ctx) {
+		return { data: [] };
+	}
+	async metaSpec(_ctx) {
+		return {
+			id: ".meta",
+			path: "/spec/.meta",
+			meta: {
+				kind: "aup:spec",
+				version: AUP_SPEC.version,
+				childrenCount: 0
+			}
+		};
+	}
+	async explainSpec(_ctx) {
+		return {
+			format: "markdown",
+			content: [
+				"# AUP Document Specification",
+				"",
+				"Read `/spec` to get the full AUP wire format definition,",
+				"including node fields, spatial intent system, sizing, event model, and workflow.",
+				"",
+				"This is the starting point for any agent building UI with AUP."
+			].join("\n")
+		};
+	}
+	async listExamples(_ctx) {
+		return { data: Object.values(AUP_EXAMPLES).map((ex) => ({
+			id: ex.name,
+			name: ex.name,
+			path: joinURL("/examples", ex.name),
+			meta: {
+				kind: "aup:example",
+				title: ex.title,
+				description: ex.description,
+				concepts: ex.concepts
+			}
+		})) };
+	}
+	async readExamplesDir(_ctx) {
+		return {
+			id: "examples",
+			path: "/examples",
+			content: `AUP Examples (${Object.keys(AUP_EXAMPLES).length} examples)`,
+			meta: {
+				kind: "examples-directory",
+				childrenCount: Object.keys(AUP_EXAMPLES).length
+			}
+		};
+	}
+	async statExamplesDir(_ctx) {
+		return { data: {
+			id: "examples",
+			path: "/examples",
+			meta: {
+				kind: "examples-directory",
+				childrenCount: Object.keys(AUP_EXAMPLES).length
+			}
+		} };
+	}
+	async metaExamplesDir(_ctx) {
+		return {
+			id: "examples",
+			path: "/examples/.meta",
+			meta: {
+				kind: "examples-directory",
+				childrenCount: Object.keys(AUP_EXAMPLES).length
+			}
+		};
+	}
+	async readExample(ctx) {
+		const name = ctx.params.name;
+		const ex = AUP_EXAMPLES[name];
+		if (!ex) throw new AFSNotFoundError(joinURL("/examples", name));
+		return {
+			id: ex.name,
+			path: joinURL("/examples", ex.name),
+			content: ex,
+			meta: {
+				kind: "aup:example",
+				title: ex.title,
+				description: ex.description,
+				concepts: ex.concepts
+			}
+		};
+	}
+	async statExample(ctx) {
+		const name = ctx.params.name;
+		const ex = AUP_EXAMPLES[name];
+		if (!ex) throw new AFSNotFoundError(joinURL("/examples", name));
+		return { data: {
+			id: ex.name,
+			path: joinURL("/examples", ex.name),
+			meta: {
+				kind: "aup:example",
+				title: ex.title,
+				description: ex.description
+			}
+		} };
+	}
+	async metaExample(ctx) {
+		const name = ctx.params.name;
+		const ex = AUP_EXAMPLES[name];
+		if (!ex) throw new AFSNotFoundError(joinURL("/examples", name));
+		return {
+			id: ex.name,
+			path: joinURL("/examples", ex.name, ".meta"),
+			meta: {
+				kind: "aup:example",
+				title: ex.title,
+				description: ex.description
+			}
+		};
+	}
+	async writeOutput(_ctx, payload) {
+		const content = typeof payload.content === "string" ? payload.content : String(payload.content ?? "");
+		const format = payload.meta?.format ?? void 0;
+		const component = payload.meta?.component ?? void 0;
+		const componentProps = payload.meta?.componentProps ?? void 0;
+		await this.backend.write(content, {
+			format,
+			component,
+			componentProps
+		});
+		return { data: {
+			id: "output",
+			path: "/output",
+			content,
+			meta: { kind: "output-channel" }
+		} };
+	}
+	async writePage(ctx, payload) {
+		const pageId = ctx.params.id;
+		const content = typeof payload.content === "string" ? payload.content : String(payload.content ?? "");
+		const format = payload.meta?.format ?? "html";
+		const layout = payload.meta?.layout ?? void 0;
+		const now = Date.now();
+		const pageData = {
+			content,
+			format,
+			layout,
+			createdAt: this.pages.get(pageId)?.createdAt ?? now,
+			updatedAt: now
+		};
+		this.pages.set(pageId, pageData);
+		this.persistPageToDisk(pageId, pageData);
+		return { data: {
+			id: pageId,
+			path: joinURL("/pages", pageId),
+			content,
+			meta: {
+				kind: "page",
+				format
+			}
+		} };
+	}
+	async deletePage(ctx) {
+		const pageId = ctx.params.id;
+		if (!this.pages.has(pageId)) throw new Error(`Page not found: ${pageId}`);
+		this.pages.delete(pageId);
+		this.removePageFromDisk(pageId);
+		return { message: `Deleted page: ${pageId}` };
+	}
+	/** Validate and parse a sharing entry payload */
+	parseSharingPayload(payload, existingCreatedAt) {
+		const raw = payload.content;
+		if (!raw || typeof raw !== "object") throw new Error("Sharing entry requires a content object");
+		const target = raw.target;
+		if (!target || typeof target !== "string") throw new Error("Sharing entry requires 'target' field");
+		const access = raw.access ?? "guest";
+		if (!VALID_ACCESS_LEVELS.has(access)) throw new Error(`Invalid access level: '${access}'. Must be one of: ${[...VALID_ACCESS_LEVELS].join(", ")}`);
+		const mode = raw.mode ?? "static";
+		if (!VALID_SHARING_MODES.has(mode)) throw new Error(`Invalid sharing mode: '${mode}'. Must be one of: ${[...VALID_SHARING_MODES].join(", ")}`);
+		const now = Date.now();
+		return {
+			target,
+			access,
+			mode,
+			slug: "",
+			meta: raw.meta,
+			createdAt: existingCreatedAt ?? now,
+			updatedAt: now
+		};
+	}
+	async writeSharingEntry(ctx, payload) {
+		const slug = ctx.params.slug;
+		const existing = this.sharingEntries.get(slug);
+		const entry = this.parseSharingPayload(payload, existing?.createdAt);
+		entry.slug = slug;
+		this.sharingEntries.set(slug, entry);
+		return { data: {
+			id: slug,
+			path: joinURL("/sharing", slug),
+			content: entry,
+			meta: { kind: "sharing-entry" }
+		} };
+	}
+	async readSharingEntry(ctx) {
+		const slug = ctx.params.slug;
+		const entry = this.sharingEntries.get(slug);
+		if (!entry) throw new AFSNotFoundError(joinURL("/sharing", slug));
+		return {
+			id: slug,
+			path: joinURL("/sharing", slug),
+			content: entry,
+			meta: {
+				kind: "sharing-entry",
+				access: entry.access,
+				mode: entry.mode
+			}
+		};
+	}
+	async readSharingDir(_ctx) {
+		return {
+			id: "sharing",
+			path: "/sharing",
+			content: `Web Sharing Entries (${this.sharingEntries.size} entries)`,
+			meta: {
+				kind: "sharing-directory",
+				childrenCount: this.sharingEntries.size
+			}
+		};
+	}
+	async listSharingEntries(_ctx) {
+		const entries = [];
+		for (const [slug, entry] of this.sharingEntries) entries.push({
+			id: slug,
+			path: joinURL("/sharing", slug),
+			meta: {
+				kind: "sharing-entry",
+				target: entry.target,
+				access: entry.access,
+				mode: entry.mode
+			}
+		});
+		return { data: entries };
+	}
+	async deleteSharingEntry(ctx) {
+		const slug = ctx.params.slug;
+		if (!this.sharingEntries.has(slug)) throw new AFSNotFoundError(joinURL("/sharing", slug));
+		this.sharingEntries.delete(slug);
+		return { message: `Deleted sharing entry: ${slug}` };
+	}
+	async metaSharingDir(_ctx) {
+		return {
+			id: "sharing",
+			path: "/sharing/.meta",
+			meta: {
+				kind: "sharing-directory",
+				childrenCount: this.sharingEntries.size
+			}
+		};
+	}
+	async metaSharingEntry(ctx) {
+		const slug = ctx.params.slug;
+		const entry = this.sharingEntries.get(slug);
+		if (!entry) throw new AFSNotFoundError(joinURL("/sharing", slug));
+		return {
+			id: slug,
+			path: joinURL("/sharing", slug, ".meta"),
+			meta: {
+				kind: "sharing-entry",
+				access: entry.access,
+				mode: entry.mode
+			}
+		};
+	}
+	async statSharingDir(_ctx) {
+		return { data: {
+			id: "sharing",
+			path: "/sharing",
+			meta: {
+				kind: "sharing-directory",
+				childrenCount: this.sharingEntries.size
+			}
+		} };
+	}
+	async statSharingEntry(ctx) {
+		const slug = ctx.params.slug;
+		const entry = this.sharingEntries.get(slug);
+		if (!entry) throw new AFSNotFoundError(joinURL("/sharing", slug));
+		return { data: {
+			id: slug,
+			path: joinURL("/sharing", slug),
+			meta: {
+				kind: "sharing-entry",
+				access: entry.access,
+				mode: entry.mode
+			}
+		} };
+	}
+	async listSharingActions(ctx) {
+		const slug = ctx.params.slug;
+		const entry = this.sharingEntries.get(slug);
+		if (!entry) throw new AFSNotFoundError(joinURL("/sharing", slug));
+		const basePath = joinURL("/sharing", slug, ".actions");
+		const actions = [];
+		if (entry.mode === "static") actions.push({
+			id: "snapshot",
+			path: joinURL(basePath, "snapshot"),
+			meta: {
+				kind: "afs:executable",
+				description: "Freeze the AUP tree from a session into a static HTML snapshot",
+				inputSchema: {
+					type: "object",
+					required: ["sessionId"],
+					properties: { sessionId: {
+						type: "string",
+						description: "Session ID whose AUP tree to snapshot"
+					} }
+				}
+			}
+		});
+		return { data: actions };
+	}
+	async execSharingSnapshot(ctx, args) {
+		const slug = ctx.params.slug;
+		const entry = this.sharingEntries.get(slug);
+		if (!entry) throw new AFSNotFoundError(joinURL("/sharing", slug));
+		if (entry.mode !== "static") throw new Error("Static snapshot not available for live mode entries");
+		const sessionId = args.sessionId;
+		if (!sessionId) throw new Error("snapshot action requires 'sessionId' argument");
+		const store = this.aupStores.get(sessionId);
+		const tree = store?.getRoot();
+		if (!tree) throw new Error("No AUP tree found for the specified session — render content first");
+		const html = generateSnapshot({
+			tree,
+			slug,
+			meta: entry.meta,
+			style: store.renderOptions.style,
+			locale: store.renderOptions.locale
+		});
+		entry.snapshot = html;
+		entry.updatedAt = Date.now();
+		return {
+			success: true,
+			data: {
+				slug,
+				size: html.length
+			}
+		};
+	}
+	async statRoot(_ctx) {
+		if (this.initPromise) await this.initPromise;
+		const meta = {
+			kind: "device",
+			childrenCount: 10,
+			backend: this.backend.type
+		};
+		if (this.serverUrl) meta.url = this.serverUrl;
+		return { data: {
+			id: this.name,
+			path: "/",
+			meta
+		} };
+	}
+	async statInput(_ctx) {
+		return { data: {
+			id: "input",
+			path: "/input",
+			meta: {
+				kind: "input-channel",
+				childrenCount: 0,
+				pending: this.backend.hasPendingInput()
+			}
+		} };
+	}
+	async statOutput(_ctx) {
+		return { data: {
+			id: "output",
+			path: "/output",
+			meta: {
+				kind: "output-channel",
+				childrenCount: 0
+			}
+		} };
+	}
+	async statPages(_ctx) {
+		return { data: {
+			id: "pages",
+			path: "/pages",
+			meta: {
+				kind: "pages-directory",
+				childrenCount: this.pages.size
+			}
+		} };
+	}
+	async statPage(ctx) {
+		const pageId = ctx.params.id;
+		const page = this.pages.get(pageId);
+		if (!page) throw new Error(`Page not found: ${pageId}`);
+		return { data: {
+			id: pageId,
+			path: joinURL("/pages", pageId),
+			meta: {
+				kind: "page",
+				format: page.format,
+				childrenCount: 0
+			}
+		} };
+	}
+	async explainRoot(_ctx) {
+		return {
+			format: "markdown",
+			content: [
+				`# UI Device (${this.backend.type})`,
+				"",
+				"You can build **any UI** by composing AUP (Agentic UI Protocol) component trees.",
+				"",
+				"## Quick Start",
+				"",
+				"1. **Read `/spec`** — Full AUP document format, node fields, event model, and workflow",
+				`2. **Read \`/primitives\`** — ${Object.keys(PRIMITIVES).length} available components with complete props, events, and examples`,
+				`3. **Read \`/themes\`** — ${Object.keys(THEMES).length} visual themes with color tokens`,
+				`4. **Read \`/overlay-themes\`** — ${Object.keys(OVERLAY_THEMES).length} broadcast overlay themes (graphics packages) for overlay-grid`,
+				`5. **Read \`/examples\`** — ${Object.keys(AUP_EXAMPLES).length} complete working documents to learn from`,
+				"",
+				"## Creating a UI",
+				"",
+				"```",
+				"// 1. Build a node tree",
+				"{ id: \"root\", type: \"view\", props: { layout: \"column\" }, children: [...] }",
+				"",
+				"// 2. Render it via session action",
+				`exec('/${this.endpointType}/sessions/:sid/.actions/aup_render', {`,
+				"  root: nodeTree,",
+				"  fullPage: true,",
+				"  style: 'midnight'",
+				"})",
+				"",
+				"// 3. Handle events (user clicks, input changes)",
+				"// Events call your AFS exec paths defined in node.events",
+				"",
+				"// 4. Update UI incrementally",
+				`exec('/${this.endpointType}/sessions/:sid/.actions/aup_patch', {`,
+				"  ops: [{ op: \"update\", id: \"node-id\", props: { content: \"new text\" } }]",
+				"})",
+				"```",
+				"",
+				"## Key Concepts",
+				"",
+				`- **${Object.keys(PRIMITIVES).length} primitives**: view, text, action, input, media, overlay, table, time, chart, map, calendar, moonphase, natal-chart, chat, terminal, editor, explorer, canvas, globe, finance-chart, rtc`,
+				"- **Events**: click, change, send, sort, select, confirm, cancel — each triggers an AFS exec call",
+				"- **Live data**: Set `node.src` to an AFS path for auto-updating charts, maps, etc.",
+				"- **Themes**: midnight, clean, glass, brutalist, soft, cyber, editorial",
+				"",
+				"## Session Actions",
+				"",
+				"| Action | Description |",
+				"|--------|-------------|",
+				"| `aup_render` | Render a full AUP component tree |",
+				"| `aup_patch` | Incremental updates (create/update/remove/reorder) |",
+				"| `aup_stage` | Stage a scene off-screen (pre-render for instant switching) |",
+				"| `aup_take` | Take a staged scene live (CSS swap, zero DOM teardown) |",
+				"| `aup_release` | Release a staged scene's resources |",
+				"| `aup_save` | Save current graph to a session page |",
+				"| `aup_load` | Load a saved graph and render it |",
+				"| `prompt` | Ask user a question (text/password/confirm/select) |",
+				"| `dialog` | Show dialog with custom buttons |",
+				"| `toast` | Lightweight toast notification |",
+				"| `form` | Collect structured input |",
+				"| `navigate` | Navigate to a page |",
+				"",
+				`## Capabilities: ${this.backend.capabilities.join(", ")}`,
+				`## Formats: ${this.backend.supportedFormats.join(", ")}`
+			].join("\n")
+		};
+	}
+	async explainInput(_ctx) {
+		return {
+			format: "text",
+			content: "Input channel — use `read('/input')` to wait for user input. Use `stat('/input')` to check if input is pending without blocking."
+		};
+	}
+	async explainOutput(_ctx) {
+		return {
+			format: "text",
+			content: "Output channel — use `write('/output', { content: '...' })` to display content to the user."
+		};
+	}
+	async explainPages(_ctx) {
+		return {
+			format: "text",
+			content: "Pages directory — use `write('/pages/:id', { content, meta: { format } })` to create pages. Use `exec('/.actions/navigate', { page: ':id' })` to display a page."
+		};
+	}
+	async readEndpoint(ctx) {
+		const endpoint = this.assertEndpoint(ctx);
+		const sessions = this.sessions.list(endpoint);
+		const isWeb = endpoint === "web";
+		return {
+			id: endpoint,
+			path: joinURL("/", endpoint),
+			content: `${endpoint} endpoint — ${sessions.length} active session(s)`,
+			meta: {
+				kind: "endpoint",
+				childrenCount: isWeb ? 2 : 1
+			}
+		};
+	}
+	async statEndpoint(ctx) {
+		const endpoint = this.assertEndpoint(ctx);
+		const isWeb = endpoint === "web";
+		return { data: {
+			id: endpoint,
+			path: joinURL("/", endpoint),
+			meta: {
+				kind: "endpoint",
+				childrenCount: isWeb ? 2 : 1
+			}
+		} };
+	}
+	async listEndpoint(ctx) {
+		const endpoint = this.assertEndpoint(ctx);
+		const sessions = this.sessions.list(endpoint);
+		const entries = [{
+			id: "sessions",
+			path: joinURL("/", endpoint, "sessions"),
+			meta: {
+				kind: "sessions-directory",
+				childrenCount: sessions.length
+			}
+		}];
+		if (endpoint === "web") {
+			const channelCount = this.getActiveChannelCount();
+			entries.push({
+				id: "live",
+				path: joinURL("/", endpoint, "live"),
+				meta: {
+					kind: "live-directory",
+					childrenCount: channelCount
+				}
+			});
+		}
+		return { data: entries };
+	}
+	async metaEndpoint(ctx) {
+		const endpoint = this.assertEndpoint(ctx);
+		const isWeb = endpoint === "web";
+		return {
+			id: endpoint,
+			path: joinURL("/", endpoint, ".meta"),
+			meta: {
+				kind: "endpoint",
+				childrenCount: isWeb ? 2 : 1
+			}
+		};
+	}
+	async readSessions(ctx) {
+		const endpoint = this.assertEndpoint(ctx);
+		const sessions = this.sessions.list(endpoint);
+		return {
+			id: "sessions",
+			path: joinURL("/", endpoint, "sessions"),
+			content: `${sessions.length} active session(s)`,
+			meta: {
+				kind: "sessions-directory",
+				childrenCount: sessions.length
+			}
+		};
+	}
+	async metaSessions(ctx) {
+		const endpoint = this.assertEndpoint(ctx);
+		const sessions = this.sessions.list(endpoint);
+		return {
+			id: "sessions",
+			path: joinURL("/", endpoint, "sessions", ".meta"),
+			meta: {
+				kind: "sessions-directory",
+				childrenCount: sessions.length
+			}
+		};
+	}
+	async listSessions(_ctx) {
+		const endpoint = this.assertEndpoint(_ctx);
+		return { data: this.sessions.list(endpoint).map((s) => ({
+			id: s.id,
+			path: joinURL("/", endpoint, "sessions", s.id),
+			meta: {
+				...s.toMeta(),
+				kind: "session",
+				childrenCount: -1
+			}
+		})) };
+	}
+	async listSession(ctx) {
+		const session = this.resolveSession(ctx);
+		const endpoint = ctx.params.endpoint;
+		const basePath = joinURL("/", endpoint, "sessions", session.id);
+		return { data: [
+			{
+				id: "messages",
+				path: joinURL(basePath, "messages"),
+				meta: {
+					kind: "messages-directory",
+					childrenCount: session.listMessages().length
+				}
+			},
+			{
+				id: "pages",
+				path: joinURL(basePath, "pages"),
+				meta: {
+					kind: "pages-directory",
+					childrenCount: session.listPages().length
+				}
+			},
+			{
+				id: "tree",
+				path: joinURL(basePath, "tree"),
+				meta: {
+					kind: "aup:tree",
+					childrenCount: 0
+				}
+			},
+			{
+				id: "wm",
+				path: joinURL(basePath, "wm"),
+				meta: {
+					kind: "wm",
+					childrenCount: 3
+				}
+			}
+		] };
+	}
+	async readSession(ctx) {
+		const session = this.resolveSession(ctx);
+		const endpoint = ctx.params.endpoint;
+		return {
+			id: session.id,
+			path: joinURL("/", endpoint, "sessions", session.id),
+			content: `Session ${session.id} (${session.endpoint})`,
+			meta: {
+				kind: "session",
+				...session.toMeta()
+			}
+		};
+	}
+	async metaSession(ctx) {
+		const session = this.resolveSession(ctx);
+		const endpoint = ctx.params.endpoint;
+		return {
+			id: session.id,
+			path: joinURL("/", endpoint, "sessions", session.id, ".meta"),
+			meta: {
+				kind: "session",
+				...session.toMeta(),
+				capabilities: {
+					supportedTypes: [
+						"text",
+						"table",
+						"form",
+						"select",
+						"confirm",
+						"dialog",
+						"progress",
+						"notification",
+						"markdown",
+						"code"
+					],
+					interactive: [
+						"prompt",
+						"select",
+						"confirm",
+						"form",
+						"dialog"
+					],
+					pages: true,
+					fallback: "degrade_to_text"
+				},
+				viewport: this.backend.getViewport()
+			}
+		};
+	}
+	async statSession(ctx) {
+		const session = this.resolveSession(ctx);
+		const endpoint = ctx.params.endpoint;
+		return { data: {
+			id: session.id,
+			path: joinURL("/", endpoint, "sessions", session.id),
+			meta: {
+				kind: "session",
+				...session.toMeta()
+			}
+		} };
+	}
+	async listSessionMessages(ctx) {
+		const session = this.resolveSession(ctx);
+		const endpoint = ctx.params.endpoint;
+		return { data: session.listMessages().map((m) => ({
+			id: m.id,
+			path: joinURL("/", endpoint, "sessions", session.id, "messages", m.id),
+			content: m,
+			meta: {
+				kind: "message",
+				type: m.type,
+				from: m.from
+			}
+		})) };
+	}
+	async readSessionMessage(ctx) {
+		const session = this.resolveSession(ctx);
+		const mid = ctx.params.mid;
+		const endpoint = ctx.params.endpoint;
+		const msg = session.findMessage(mid);
+		if (!msg) throw new Error(`Message not found: ${mid}`);
+		return {
+			id: msg.id,
+			path: joinURL("/", endpoint, "sessions", session.id, "messages", mid),
+			content: msg,
+			meta: {
+				kind: "message",
+				type: msg.type,
+				from: msg.from
+			}
+		};
+	}
+	async writeSessionMessage(ctx, payload) {
+		const session = this.resolveSession(ctx);
+		const endpoint = ctx.params.endpoint;
+		const msgData = typeof payload.content === "object" && payload.content !== null ? payload.content : {
+			type: "text",
+			from: "agent",
+			content: String(payload.content ?? "")
+		};
+		const msg = session.addMessage(msgData);
+		if (msg.type === "text" && msg.from === "agent" && typeof msg.content === "string") await this.backend.write(msg.content);
+		return { data: {
+			id: msg.id,
+			path: joinURL("/", endpoint, "sessions", session.id, "messages", msg.id),
+			content: msg,
+			meta: {
+				kind: "message",
+				type: msg.type
+			}
+		} };
+	}
+	async listSessionPages(ctx) {
+		const session = this.resolveSession(ctx);
+		const endpoint = ctx.params.endpoint;
+		return { data: session.listPages().map(({ id, page }) => ({
+			id,
+			path: joinURL("/", endpoint, "sessions", session.id, "pages", id),
+			meta: {
+				kind: "page",
+				format: page.format,
+				childrenCount: 0
+			}
+		})) };
+	}
+	async readSessionPage(ctx) {
+		const session = this.resolveSession(ctx);
+		const pid = ctx.params.pid;
+		const endpoint = ctx.params.endpoint;
+		const page = session.getPage(pid);
+		if (!page) throw new Error(`Page not found: ${pid}`);
+		return {
+			id: pid,
+			path: joinURL("/", endpoint, "sessions", session.id, "pages", pid),
+			content: page.content,
+			meta: {
+				kind: "page",
+				format: page.format,
+				layout: page.layout
+			}
+		};
+	}
+	async writeSessionPage(ctx, payload) {
+		const session = this.resolveSession(ctx);
+		const pid = ctx.params.pid;
+		const endpoint = ctx.params.endpoint;
+		const content = typeof payload.content === "string" ? payload.content : String(payload.content ?? "");
+		const format = payload.meta?.format ?? "html";
+		const layout = payload.meta?.layout ?? void 0;
+		session.setPage(pid, {
+			content,
+			format,
+			layout
+		});
+		return { data: {
+			id: pid,
+			path: joinURL("/", endpoint, "sessions", session.id, "pages", pid),
+			content,
+			meta: {
+				kind: "page",
+				format
+			}
+		} };
+	}
+	async readSessionCaps(ctx) {
+		const session = this.resolveSession(ctx);
+		const endpoint = ctx.params.endpoint;
+		return {
+			id: ".caps",
+			path: joinURL("/", endpoint, "sessions", session.id, ".caps"),
+			content: session.deviceCaps,
+			meta: { kind: "aup:device-caps" }
+		};
+	}
+	async writeSessionCaps(ctx, payload) {
+		const session = this.resolveSession(ctx);
+		const endpoint = ctx.params.endpoint;
+		const err = session.setDeviceCaps(payload.content);
+		if (err) throw new Error(`Invalid DeviceCaps: ${err}`);
+		const capsPath = joinURL("/", endpoint, "sessions", session.id, ".caps");
+		return { data: {
+			id: capsPath,
+			path: capsPath
+		} };
+	}
+	async readSessionTree(ctx) {
+		const session = this.resolveSession(ctx);
+		const endpoint = ctx.params.endpoint;
+		const root = this.aupStores.get(session.id)?.getRoot() ?? null;
+		return {
+			id: "tree",
+			path: joinURL("/", endpoint, "sessions", session.id, "tree"),
+			content: root,
+			meta: { kind: "aup:tree" }
+		};
+	}
+	async writeSessionTree(ctx, payload) {
+		const session = this.resolveSession(ctx);
+		const endpoint = ctx.params.endpoint;
+		const root = payload.content;
+		if (!root || typeof root !== "object") throw new Error("tree write requires a node object as content");
+		const err = validateNode(root);
+		if (err) throw new Error(`Invalid AUP node: ${err}`);
+		const store = this.getAupStore(session.id);
+		store.setRoot(root);
+		const meta = payload.meta ?? {};
+		const fullPage = meta.fullPage === true;
+		const chrome = meta.chrome === true;
+		const theme = typeof meta.theme === "string" ? meta.theme : void 0;
+		const style = typeof meta.style === "string" ? meta.style : void 0;
+		const locale = typeof meta.locale === "string" ? meta.locale : void 0;
+		if (isAUPTransport(this.backend)) {
+			const msg = {
+				type: "aup",
+				action: "render",
+				root: this.degradeForSession(store.getRoot(), session)
+			};
+			if (fullPage) msg.fullPage = true;
+			if (chrome) msg.chrome = true;
+			if (theme) msg.theme = theme;
+			if (style) msg.style = style;
+			if (locale) msg.locale = locale;
+			this.backend.sendToSession(session.id, msg);
+		}
+		const treePath = joinURL("/", endpoint, "sessions", session.id, "tree");
+		this.emit({
+			type: "afs:write",
+			path: treePath,
+			data: { root: store.getRoot() }
+		});
+		return { data: {
+			id: "tree",
+			path: treePath,
+			content: store.getRoot(),
+			meta: { kind: "aup:tree" }
+		} };
+	}
+	async readSessionWm(ctx) {
+		const session = this.resolveSession(ctx);
+		const endpoint = ctx.params.endpoint;
+		const wm = this.getWmNode(session.id);
+		const wmProps = wm?.wmNode.props ?? {};
+		const wmState = wm?.wmNode.state ?? {};
+		const surfaces = (wm?.wmNode.children ?? []).filter((c) => c.type === "wm-surface");
+		return {
+			id: "wm",
+			path: joinURL("/", endpoint, "sessions", session.id, "wm"),
+			content: {
+				strategy: wmProps.strategy ?? "single",
+				active: wmState.active ?? null,
+				surfaceCount: surfaces.length
+			},
+			meta: { kind: "wm" }
+		};
+	}
+	async listSessionWm(ctx) {
+		const session = this.resolveSession(ctx);
+		const endpoint = ctx.params.endpoint;
+		const basePath = joinURL("/", endpoint, "sessions", session.id, "wm");
+		return { data: [
+			{
+				id: "strategy",
+				path: joinURL(basePath, "strategy"),
+				meta: { kind: "wm:strategy" }
+			},
+			{
+				id: "layout",
+				path: joinURL(basePath, "layout"),
+				meta: { kind: "wm:layout" }
+			},
+			{
+				id: "surfaces",
+				path: joinURL(basePath, "surfaces"),
+				meta: { kind: "wm:surfaces" }
+			}
+		] };
+	}
+	async readWmStrategy(ctx) {
+		const session = this.resolveSession(ctx);
+		const endpoint = ctx.params.endpoint;
+		const strategy = (this.getWmNode(session.id)?.wmNode.props ?? {}).strategy ?? "single";
+		return {
+			id: "strategy",
+			path: joinURL("/", endpoint, "sessions", session.id, "wm", "strategy"),
+			content: strategy,
+			meta: { kind: "wm:strategy" }
+		};
+	}
+	async writeWmStrategy(ctx, payload) {
+		const session = this.resolveSession(ctx);
+		const endpoint = ctx.params.endpoint;
+		const value = payload.content;
+		if (typeof value !== "string") throw new Error("WM strategy must be a string");
+		const { wmNode } = this.ensureWmNode(session.id, value);
+		this.applyWmPatch(session.id, ctx, [{
+			op: "update",
+			id: wmNode.id,
+			props: { strategy: value }
+		}]);
+		return { data: {
+			id: "strategy",
+			path: joinURL("/", endpoint, "sessions", session.id, "wm", "strategy"),
+			content: value,
+			meta: { kind: "wm:strategy" }
+		} };
+	}
+	async readWmLayout(ctx) {
+		const session = this.resolveSession(ctx);
+		const endpoint = ctx.params.endpoint;
+		const wm = this.getWmNode(session.id);
+		const wmProps = wm?.wmNode.props ?? {};
+		const wmState = wm?.wmNode.state ?? {};
+		return {
+			id: "layout",
+			path: joinURL("/", endpoint, "sessions", session.id, "wm", "layout"),
+			content: {
+				active: wmState.active ?? null,
+				panels: wmProps.panels ?? [],
+				preset: wmProps.layoutPreset ?? null,
+				panelActives: wmState.panelActives ?? null
+			},
+			meta: { kind: "wm:layout" }
+		};
+	}
+	async listWmSurfaces(ctx) {
+		const session = this.resolveSession(ctx);
+		const endpoint = ctx.params.endpoint;
+		const surfaces = (this.getWmNode(session.id)?.wmNode.children ?? []).filter((c) => c.type === "wm-surface");
+		const basePath = joinURL("/", endpoint, "sessions", session.id, "wm", "surfaces");
+		return { data: surfaces.map((c) => {
+			const cp = c.props ?? {};
+			const name = cp.surfaceName || c.id.replace(/^wm-surface-/, "");
+			return {
+				id: name,
+				path: joinURL(basePath, name),
+				meta: {
+					kind: "wm:surface",
+					title: cp.title ?? name,
+					panel: cp.panel || void 0
+				}
+			};
+		}) };
+	}
+	async readWmSurface(ctx) {
+		const session = this.resolveSession(ctx);
+		const endpoint = ctx.params.endpoint;
+		const surfaceName = ctx.params.surfaceName;
+		const wm = this.getWmNode(session.id);
+		const surfNode = wm ? this.findWmSurface(wm.wmNode, surfaceName) : void 0;
+		if (!surfNode) throw new AFSNotFoundError(`Surface not found: ${surfaceName}`);
+		const cp = surfNode.props ?? {};
+		return {
+			id: surfaceName,
+			path: joinURL("/", endpoint, "sessions", session.id, "wm", "surfaces", surfaceName),
+			content: {
+				session: surfNode.src,
+				panel: cp.panel ?? void 0,
+				title: cp.title ?? cp.surfaceName ?? surfaceName,
+				position: cp.position,
+				size: cp.size,
+				docked: !!cp.docked,
+				originalPanel: cp.originalPanel ?? void 0
+			},
+			meta: {
+				kind: "wm:surface",
+				title: cp.title ?? surfaceName
+			}
+		};
+	}
+	async listWmActions(ctx) {
+		const session = this.resolveSession(ctx);
+		const endpoint = ctx.params.endpoint;
+		const basePath = joinURL("/", endpoint, "sessions", session.id, "wm", ".actions");
+		return { data: [
+			{
+				id: "open-surface",
+				path: joinURL(basePath, "open-surface"),
+				meta: {
+					kind: "afs:executable",
+					description: "Open (or replace) a WM surface. Universal: src can be ws:// URL, AFS path, or omitted for inline content.",
+					inputSchema: {
+						type: "object",
+						required: ["name"],
+						properties: {
+							name: {
+								type: "string",
+								description: "Unique surface name"
+							},
+							src: {
+								type: "string",
+								description: "Source: ws:// URL, http:// URL, or /afs/path"
+							},
+							session: {
+								type: "string",
+								description: "Alias for src (backward compat)"
+							},
+							content: {
+								type: "object",
+								description: "Initial inline AUP tree (when no src)"
+							},
+							panel: {
+								type: "string",
+								description: "Panel assignment"
+							},
+							title: {
+								type: "string",
+								description: "Display title"
+							}
+						}
+					}
+				}
+			},
+			{
+				id: "set-surface-content",
+				path: joinURL(basePath, "set-surface-content"),
+				meta: {
+					kind: "afs:executable",
+					description: "Replace the inline AUP content of a surface.",
+					inputSchema: {
+						type: "object",
+						required: ["surface", "content"],
+						properties: {
+							surface: {
+								type: "string",
+								description: "Surface name"
+							},
+							content: {
+								type: "object",
+								description: "AUP node tree to render"
+							}
+						}
+					}
+				}
+			},
+			{
+				id: "close-surface",
+				path: joinURL(basePath, "close-surface"),
+				meta: {
+					kind: "afs:executable",
+					description: "Close a WM surface.",
+					inputSchema: {
+						type: "object",
+						required: ["name"],
+						properties: { name: {
+							type: "string",
+							description: "Surface name to close"
+						} }
+					}
+				}
+			},
+			{
+				id: "set-strategy",
+				path: joinURL(basePath, "set-strategy"),
+				meta: {
+					kind: "afs:executable",
+					description: "Change WM strategy.",
+					inputSchema: {
+						type: "object",
+						required: ["strategy"],
+						properties: { strategy: {
+							type: "string",
+							enum: [
+								"single",
+								"panels",
+								"floating",
+								"virtual"
+							],
+							description: "WM strategy"
+						} }
+					}
+				}
+			},
+			{
+				id: "set-active",
+				path: joinURL(basePath, "set-active"),
+				meta: {
+					kind: "afs:executable",
+					description: "Set the active (focused) surface.",
+					inputSchema: {
+						type: "object",
+						required: ["name"],
+						properties: { name: {
+							type: "string",
+							description: "Surface name to activate"
+						} }
+					}
+				}
+			},
+			{
+				id: "pin-to-dock",
+				path: joinURL(basePath, "pin-to-dock"),
+				meta: {
+					kind: "afs:executable",
+					description: "Pin a floating surface to the dock strip.",
+					inputSchema: {
+						type: "object",
+						required: ["name"],
+						properties: { name: {
+							type: "string",
+							description: "Surface name to dock"
+						} }
+					}
+				}
+			},
+			{
+				id: "unpin-from-dock",
+				path: joinURL(basePath, "unpin-from-dock"),
+				meta: {
+					kind: "afs:executable",
+					description: "Unpin a surface from the dock, restore to floating.",
+					inputSchema: {
+						type: "object",
+						required: ["name"],
+						properties: { name: {
+							type: "string",
+							description: "Surface name to undock"
+						} }
+					}
+				}
+			},
+			{
+				id: "set-layout",
+				path: joinURL(basePath, "set-layout"),
+				meta: {
+					kind: "afs:executable",
+					description: "Set panel layout preset (explorer, settings, simple, miller).",
+					inputSchema: {
+						type: "object",
+						required: ["preset"],
+						properties: { preset: {
+							type: "string",
+							description: "Panel preset name (explorer, settings, simple, miller). Unknown names fall back to simple."
+						} }
+					}
+				}
+			},
+			{
+				id: "collapse-panel",
+				path: joinURL(basePath, "collapse-panel"),
+				meta: {
+					kind: "afs:executable",
+					description: "Collapse a panel in the layout.",
+					inputSchema: {
+						type: "object",
+						required: ["panelId"],
+						properties: { panelId: {
+							type: "string",
+							description: "Panel ID to collapse"
+						} }
+					}
+				}
+			},
+			{
+				id: "expand-panel",
+				path: joinURL(basePath, "expand-panel"),
+				meta: {
+					kind: "afs:executable",
+					description: "Expand a collapsed panel.",
+					inputSchema: {
+						type: "object",
+						required: ["panelId"],
+						properties: { panelId: {
+							type: "string",
+							description: "Panel ID to expand"
+						} }
+					}
+				}
+			},
+			{
+				id: "move-surface",
+				path: joinURL(basePath, "move-surface"),
+				meta: {
+					kind: "afs:executable",
+					description: "Move a surface to a different panel.",
+					inputSchema: {
+						type: "object",
+						required: ["name", "panel"],
+						properties: {
+							name: {
+								type: "string",
+								description: "Surface name to move"
+							},
+							panel: {
+								type: "string",
+								description: "Target panel ID"
+							}
+						}
+					}
+				}
+			},
+			{
+				id: "add-to-panel",
+				path: joinURL(basePath, "add-to-panel"),
+				meta: {
+					kind: "afs:executable",
+					description: "Add a surface to a panel as a new tab.",
+					inputSchema: {
+						type: "object",
+						required: [
+							"name",
+							"session",
+							"panel"
+						],
+						properties: {
+							name: {
+								type: "string",
+								description: "Surface name"
+							},
+							session: {
+								type: "string",
+								description: "AUP session ID for this surface"
+							},
+							panel: {
+								type: "string",
+								description: "Target panel ID"
+							},
+							title: {
+								type: "string",
+								description: "Display title for the tab"
+							}
+						}
+					}
+				}
+			},
+			{
+				id: "set-panel-active",
+				path: joinURL(basePath, "set-panel-active"),
+				meta: {
+					kind: "afs:executable",
+					description: "Set the active tab (surface) within a specific panel.",
+					inputSchema: {
+						type: "object",
+						required: ["panel", "surface"],
+						properties: {
+							panel: {
+								type: "string",
+								description: "Panel ID"
+							},
+							surface: {
+								type: "string",
+								description: "Surface name to activate in the panel"
+							}
+						}
+					}
+				}
+			},
+			{
+				id: "popout",
+				path: joinURL(basePath, "popout"),
+				meta: {
+					kind: "afs:executable",
+					description: "Detach a surface from its panel to a floating overlay.",
+					inputSchema: {
+						type: "object",
+						required: ["name"],
+						properties: { name: {
+							type: "string",
+							description: "Surface name to pop out"
+						} }
+					}
+				}
+			},
+			{
+				id: "redock",
+				path: joinURL(basePath, "redock"),
+				meta: {
+					kind: "afs:executable",
+					description: "Return a floating overlay surface to its original panel.",
+					inputSchema: {
+						type: "object",
+						required: ["name"],
+						properties: { name: {
+							type: "string",
+							description: "Surface name to redock"
+						} }
+					}
+				}
+			},
+			{
+				id: "auto-arrange",
+				path: joinURL(basePath, "auto-arrange"),
+				meta: {
+					kind: "afs:executable",
+					description: "Tile all floating surfaces evenly within the viewport. Computes non-overlapping positions using an optimal grid layout.",
+					inputSchema: {
+						type: "object",
+						required: ["viewport"],
+						properties: {
+							viewport: {
+								type: "object",
+								description: "Desktop viewport size",
+								properties: {
+									width: {
+										type: "number",
+										description: "Viewport width in px"
+									},
+									height: {
+										type: "number",
+										description: "Viewport height in px"
+									}
+								},
+								required: ["width", "height"]
+							},
+							gap: {
+								type: "number",
+								description: "Gap between windows in px (default 8)"
+							},
+							padding: {
+								type: "number",
+								description: "Padding from viewport edges in px (default 8)"
+							},
+							preserveAspect: {
+								type: "boolean",
+								description: "Preserve each window's aspect ratio (default false)"
+							}
+						}
+					}
+				}
+			}
+		] };
+	}
+	async execWmOpenSurface(ctx, args) {
+		const session = this.resolveSession(ctx);
+		const name = args.name;
+		if (!name) throw new Error("open-surface action requires 'name' argument");
+		const sessionRef = args.session;
+		const src = args.src || sessionRef;
+		const { wmNode } = this.ensureWmNode(session.id);
+		const surfId = `wm-surface-${name}`;
+		const existing = this.findWmSurface(wmNode, name);
+		const surfProps = {
+			surfaceName: name,
+			title: typeof args.title === "string" ? args.title : name
+		};
+		if (typeof args.panel === "string") surfProps.panel = args.panel;
+		if (args.position) surfProps.position = args.position;
+		if (args.size) surfProps.size = args.size;
+		const surfNode = {
+			id: surfId,
+			type: "wm-surface",
+			props: surfProps
+		};
+		if (src) surfNode.src = src;
+		const content = args.content;
+		if (content && typeof content === "object" && content.type) surfNode.children = [content];
+		const ops = [];
+		if (existing) ops.push({
+			op: "remove",
+			id: existing.id
+		});
+		ops.push({
+			op: "create",
+			id: surfId,
+			parentId: "wm",
+			node: surfNode
+		});
+		ops.push({
+			op: "update",
+			id: "wm",
+			state: { active: name }
+		});
+		this.applyWmPatch(session.id, ctx, ops);
+		return {
+			success: true,
+			data: {
+				name,
+				active: name
+			}
+		};
+	}
+	async execWmSetSurfaceContent(ctx, args) {
+		const session = this.resolveSession(ctx);
+		const surfaceName = args.surface;
+		if (!surfaceName) throw new Error("set-surface-content requires 'surface' argument");
+		const content = args.content;
+		const wm = this.getWmNode(session.id);
+		if (!wm) throw new Error(`No WM node for session ${session.id}`);
+		const surfNode = this.findWmSurface(wm.wmNode, surfaceName);
+		if (!surfNode) throw new Error(`Surface not found: ${surfaceName}`);
+		if (content && typeof content === "object" && content.type) surfNode.children = [content];
+		else surfNode.children = [];
+		const store = this.getAupStore(session.id);
+		const root = store.getRoot();
+		if (root) store.setRoot(root);
+		if (isAUPTransport(this.backend)) this.backend.sendToSession(session.id, {
+			type: "aup",
+			action: "surface-update",
+			surfaceId: surfNode.id,
+			children: surfNode.children || [],
+			treeVersion: store.version
+		});
+		return {
+			success: true,
+			data: { surface: surfaceName }
+		};
+	}
+	async execWmCloseSurface(ctx, args) {
+		const session = this.resolveSession(ctx);
+		const name = args.name;
+		if (!name) throw new Error("close-surface action requires 'name' argument");
+		const wm = this.getWmNode(session.id);
+		if (!wm) throw new Error(`Surface not found: ${name}`);
+		const surfNode = this.findWmSurface(wm.wmNode, name);
+		if (!surfNode) throw new Error(`Surface not found: ${name}`);
+		const ops = [{
+			op: "remove",
+			id: surfNode.id
+		}];
+		const wmState = wm.wmNode.state ?? {};
+		if (wmState.active === name) {
+			const remaining = (wm.wmNode.children ?? []).filter((c) => c.type === "wm-surface" && c.id !== surfNode.id);
+			const next = remaining.length > 0 ? remaining[0].props?.surfaceName || remaining[0].id.replace(/^wm-surface-/, "") : null;
+			ops.push({
+				op: "update",
+				id: "wm",
+				state: { active: next }
+			});
+		}
+		const surfPanel = (surfNode.props ?? {}).panel;
+		const panelActives = wmState.panelActives ?? {};
+		if (surfPanel && panelActives[surfPanel] === name) {
+			const remainingInPanel = (wm.wmNode.children ?? []).filter((c) => c.type === "wm-surface" && c.id !== surfNode.id && c.props?.panel === surfPanel);
+			const nextTab = remainingInPanel.length > 0 ? remainingInPanel[0].props?.surfaceName || remainingInPanel[0].id.replace(/^wm-surface-/, "") : void 0;
+			const updatedPanelActives = { ...panelActives };
+			if (nextTab) updatedPanelActives[surfPanel] = nextTab;
+			else delete updatedPanelActives[surfPanel];
+			ops.push({
+				op: "update",
+				id: "wm",
+				state: { panelActives: updatedPanelActives }
+			});
+		}
+		this.applyWmPatch(session.id, ctx, ops);
+		return {
+			success: true,
+			data: { active: (wm.wmNode.state ?? {}).active ?? null }
+		};
+	}
+	async execWmSetStrategy(ctx, args) {
+		const session = this.resolveSession(ctx);
+		const strategy = args.strategy;
+		if (!strategy) throw new Error("set-strategy action requires 'strategy' argument");
+		const validStrategies = [
+			"single",
+			"panels",
+			"floating",
+			"virtual"
+		];
+		if (!validStrategies.includes(strategy)) throw new Error(`Invalid WM strategy: ${strategy}. Must be one of: ${validStrategies.join(", ")}`);
+		this.ensureWmNode(session.id, strategy);
+		this.applyWmPatch(session.id, ctx, [{
+			op: "update",
+			id: "wm",
+			props: { strategy }
+		}]);
+		return {
+			success: true,
+			data: { strategy }
+		};
+	}
+	async execWmSetActive(ctx, args) {
+		const session = this.resolveSession(ctx);
+		const name = args.name;
+		if (!name) throw new Error("set-active action requires 'name' argument");
+		this.ensureWmNode(session.id);
+		this.applyWmPatch(session.id, ctx, [{
+			op: "update",
+			id: "wm",
+			state: { active: name }
+		}]);
+		return {
+			success: true,
+			data: { active: name }
+		};
+	}
+	async execWmPinToDock(ctx, args) {
+		const session = this.resolveSession(ctx);
+		const name = args.name;
+		if (!name) throw new Error("pin-to-dock action requires 'name' argument");
+		const wm = this.getWmNode(session.id);
+		const surfNode = wm ? this.findWmSurface(wm.wmNode, name) : void 0;
+		if (!surfNode) throw new Error(`Surface not found: ${name}`);
+		this.applyWmPatch(session.id, ctx, [{
+			op: "update",
+			id: surfNode.id,
+			props: { docked: true }
+		}]);
+		return {
+			success: true,
+			data: {
+				name,
+				docked: true
+			}
+		};
+	}
+	async execWmUnpinFromDock(ctx, args) {
+		const session = this.resolveSession(ctx);
+		const name = args.name;
+		if (!name) throw new Error("unpin-from-dock action requires 'name' argument");
+		const wm = this.getWmNode(session.id);
+		const surfNode = wm ? this.findWmSurface(wm.wmNode, name) : void 0;
+		if (!surfNode) throw new Error(`Surface not found: ${name}`);
+		this.applyWmPatch(session.id, ctx, [{
+			op: "update",
+			id: surfNode.id,
+			props: { docked: false }
+		}]);
+		return {
+			success: true,
+			data: {
+				name,
+				docked: false
+			}
+		};
+	}
+	async execWmSetLayout(ctx, args) {
+		const session = this.resolveSession(ctx);
+		const preset = args.preset;
+		if (!preset) throw new Error("set-layout action requires 'preset' argument");
+		const resolved = PANEL_PRESETS[preset] ?? PANEL_PRESETS.simple;
+		const effectivePreset = PANEL_PRESETS[preset] ? preset : "simple";
+		this.ensureWmNode(session.id, "panels");
+		this.applyWmPatch(session.id, ctx, [{
+			op: "update",
+			id: "wm",
+			props: {
+				strategy: "panels",
+				layoutPreset: effectivePreset,
+				panels: resolved
+			}
+		}]);
+		return {
+			success: true,
+			data: { preset: effectivePreset }
+		};
+	}
+	async execWmCollapsePanel(ctx, args) {
+		const session = this.resolveSession(ctx);
+		const panelId = args.panelId;
+		if (!panelId) throw new Error("collapse-panel action requires 'panelId' argument");
+		const wm = this.getWmNode(session.id);
+		if (!wm) throw new Error(`Panel not found: ${panelId}`);
+		const panels = (wm.wmNode.props ?? {}).panels ?? [];
+		if (!panels.find((p) => p.id === panelId)) throw new Error(`Panel not found: ${panelId}`);
+		const updated = panels.map((p) => p.id === panelId ? {
+			...p,
+			collapsed: true
+		} : p);
+		this.applyWmPatch(session.id, ctx, [{
+			op: "update",
+			id: "wm",
+			props: { panels: updated }
+		}]);
+		return {
+			success: true,
+			data: {
+				panelId,
+				collapsed: true
+			}
+		};
+	}
+	async execWmExpandPanel(ctx, args) {
+		const session = this.resolveSession(ctx);
+		const panelId = args.panelId;
+		if (!panelId) throw new Error("expand-panel action requires 'panelId' argument");
+		const wm = this.getWmNode(session.id);
+		if (!wm) throw new Error(`Panel not found: ${panelId}`);
+		const panels = (wm.wmNode.props ?? {}).panels ?? [];
+		if (!panels.find((p) => p.id === panelId)) throw new Error(`Panel not found: ${panelId}`);
+		const updated = panels.map((p) => p.id === panelId ? {
+			...p,
+			collapsed: false
+		} : p);
+		this.applyWmPatch(session.id, ctx, [{
+			op: "update",
+			id: "wm",
+			props: { panels: updated }
+		}]);
+		return {
+			success: true,
+			data: {
+				panelId,
+				collapsed: false
+			}
+		};
+	}
+	async execWmMoveSurface(ctx, args) {
+		const session = this.resolveSession(ctx);
+		const name = args.name;
+		if (!name) throw new Error("move-surface action requires 'name' argument");
+		const panel = args.panel;
+		if (!panel) throw new Error("move-surface action requires 'panel' argument");
+		const wm = this.getWmNode(session.id);
+		const surfNode = wm ? this.findWmSurface(wm.wmNode, name) : void 0;
+		if (!surfNode) throw new Error(`Surface not found: ${name}`);
+		const panels = (wm.wmNode.props ?? {}).panels ?? [];
+		if (panels.length > 0 && !panels.some((p) => p.id === panel)) throw new Error(`Panel not found: ${panel}`);
+		this.applyWmPatch(session.id, ctx, [{
+			op: "update",
+			id: surfNode.id,
+			props: { panel }
+		}]);
+		return {
+			success: true,
+			data: {
+				name,
+				panel
+			}
+		};
+	}
+	async execWmAddToPanel(ctx, args) {
+		const session = this.resolveSession(ctx);
+		const name = args.name;
+		if (!name) throw new Error("add-to-panel action requires 'name' argument");
+		const sessionRef = args.session;
+		if (!sessionRef) throw new Error("add-to-panel action requires 'session' argument");
+		const panel = args.panel;
+		if (!panel) throw new Error("add-to-panel action requires 'panel' argument");
+		this.ensureWmNode(session.id, "panels");
+		const panels = (this.getWmNode(session.id).wmNode.props ?? {}).panels ?? [];
+		if (panels.length > 0 && !panels.some((p) => p.id === panel)) throw new Error(`Panel not found: ${panel}`);
+		const surfId = `wm-surface-${name}`;
+		const ops = [{
+			op: "create",
+			id: surfId,
+			parentId: "wm",
+			node: {
+				id: surfId,
+				type: "wm-surface",
+				src: sessionRef,
+				props: {
+					surfaceName: name,
+					title: typeof args.title === "string" ? args.title : name,
+					panel
+				}
+			}
+		}, {
+			op: "update",
+			id: "wm",
+			state: { active: name }
+		}];
+		this.applyWmPatch(session.id, ctx, ops);
+		return {
+			success: true,
+			data: {
+				name,
+				panel,
+				active: name
+			}
+		};
+	}
+	async execWmSetPanelActive(ctx, args) {
+		const session = this.resolveSession(ctx);
+		const panel = args.panel;
+		if (!panel) throw new Error("set-panel-active action requires 'panel' argument");
+		const surface = args.surface;
+		if (!surface) throw new Error("set-panel-active action requires 'surface' argument");
+		this.ensureWmNode(session.id);
+		const wm = this.getWmNode(session.id);
+		if (!this.findWmSurface(wm.wmNode, surface)) throw new Error(`Surface not found: ${surface}`);
+		const panelActives = { ...(wm.wmNode.state ?? {}).panelActives ?? {} };
+		panelActives[panel] = surface;
+		this.applyWmPatch(session.id, ctx, [{
+			op: "update",
+			id: "wm",
+			state: { panelActives }
+		}]);
+		return {
+			success: true,
+			data: {
+				panel,
+				surface
+			}
+		};
+	}
+	async execWmPopout(ctx, args) {
+		const session = this.resolveSession(ctx);
+		const name = args.name;
+		if (!name) throw new Error("popout action requires 'name' argument");
+		const wm = this.getWmNode(session.id);
+		const surfNode = wm ? this.findWmSurface(wm.wmNode, name) : void 0;
+		if (!surfNode) throw new Error(`Surface not found: ${name}`);
+		const originalPanel = (surfNode.props ?? {}).panel;
+		if (!originalPanel) throw new Error(`Surface "${name}" has no panel to pop out from`);
+		this.applyWmPatch(session.id, ctx, [{
+			op: "update",
+			id: surfNode.id,
+			props: {
+				panel: null,
+				originalPanel
+			}
+		}]);
+		return {
+			success: true,
+			data: {
+				name,
+				originalPanel
+			}
+		};
+	}
+	async execWmRedock(ctx, args) {
+		const session = this.resolveSession(ctx);
+		const name = args.name;
+		if (!name) throw new Error("redock action requires 'name' argument");
+		const wm = this.getWmNode(session.id);
+		const surfNode = wm ? this.findWmSurface(wm.wmNode, name) : void 0;
+		if (!surfNode) throw new Error(`Surface not found: ${name}`);
+		const panel = (surfNode.props ?? {}).originalPanel;
+		if (!panel) throw new Error(`Surface "${name}" was not popped out`);
+		this.applyWmPatch(session.id, ctx, [{
+			op: "update",
+			id: surfNode.id,
+			props: {
+				panel,
+				originalPanel: null
+			}
+		}]);
+		return {
+			success: true,
+			data: {
+				name,
+				panel
+			}
+		};
+	}
+	async execWmAutoArrange(ctx, args) {
+		const session = this.resolveSession(ctx);
+		const viewport = args.viewport;
+		if (!viewport || typeof viewport.width !== "number" || typeof viewport.height !== "number") throw new Error("auto-arrange action requires 'viewport' with width and height");
+		const wm = this.getWmNode(session.id);
+		if (!wm) return {
+			success: true,
+			data: { arranged: [] }
+		};
+		const arranged = autoArrange((wm.wmNode.children ?? []).filter((c) => c.type === "wm-surface" && !c.props?.docked).map((c) => {
+			const cp = c.props ?? {};
+			return {
+				name: cp.surfaceName || c.id.replace(/^wm-surface-/, ""),
+				size: cp.size
+			};
+		}), viewport, {
+			gap: typeof args.gap === "number" ? args.gap : void 0,
+			padding: typeof args.padding === "number" ? args.padding : void 0,
+			preserveAspect: typeof args.preserveAspect === "boolean" ? args.preserveAspect : void 0
+		});
+		const ops = [];
+		for (const a of arranged) {
+			const surfNode = this.findWmSurface(wm.wmNode, a.name);
+			if (surfNode) ops.push({
+				op: "update",
+				id: surfNode.id,
+				props: {
+					position: {
+						x: a.x,
+						y: a.y
+					},
+					size: {
+						width: a.width,
+						height: a.height
+					}
+				}
+			});
+		}
+		if (ops.length > 0) this.applyWmPatch(session.id, ctx, ops);
+		return {
+			success: true,
+			data: { arranged }
+		};
+	}
+	async explainSession(ctx) {
+		const session = this.resolveSession(ctx);
+		return {
+			format: "markdown",
+			content: [
+				`# Session ${session.id}`,
+				"",
+				`Endpoint: ${session.endpoint}`,
+				`Messages: ${session.listMessages().length}`,
+				`Pages: ${session.listPages().length}`,
+				"",
+				"## Paths",
+				"- `messages/` — Message stream (read/write)",
+				"- `pages/:id` — Managed pages (CRUD)",
+				"- `.actions/*` — Interactive actions"
+			].join("\n")
+		};
+	}
+	/** Assert web endpoint and return channelId from params */
+	assertLiveChannel(ctx) {
+		const endpoint = ctx.params.endpoint;
+		if (endpoint !== "web") throw new AFSNotFoundError(`/${endpoint}/live`);
+		this.assertEndpoint(ctx);
+		return ctx.params.channelId;
+	}
+	async listLiveChannels(ctx) {
+		const endpoint = ctx.params.endpoint;
+		if (endpoint !== "web") throw new AFSNotFoundError(`/${endpoint}/live`);
+		this.assertEndpoint(ctx);
+		return { data: this.getActiveChannelIds().map((id) => ({
+			id,
+			path: joinURL("/", endpoint, "live", id),
+			meta: {
+				kind: "live-channel",
+				childrenCount: 1
+			}
+		})) };
+	}
+	async readLiveDirectory(ctx) {
+		const endpoint = ctx.params.endpoint;
+		if (endpoint !== "web") throw new AFSNotFoundError(`/${endpoint}/live`);
+		this.assertEndpoint(ctx);
+		const ids = this.getActiveChannelIds();
+		return {
+			id: "live",
+			path: joinURL("/", endpoint, "live"),
+			content: `${ids.length} active live channel(s)`,
+			meta: {
+				kind: "live-directory",
+				childrenCount: ids.length
+			}
+		};
+	}
+	async metaLiveDirectory(ctx) {
+		const endpoint = ctx.params.endpoint;
+		if (endpoint !== "web") throw new AFSNotFoundError(`/${endpoint}/live`);
+		this.assertEndpoint(ctx);
+		const ids = this.getActiveChannelIds();
+		return {
+			id: "live",
+			path: joinURL("/", endpoint, "live", ".meta"),
+			meta: {
+				kind: "live-directory",
+				childrenCount: ids.length
+			}
+		};
+	}
+	async readLiveChannel(ctx) {
+		const channelId = this.assertLiveChannel(ctx);
+		const endpoint = ctx.params.endpoint;
+		const hasTree = !!this.aupStores.get(this.channelAupKey(channelId))?.getRoot();
+		return {
+			id: channelId,
+			path: joinURL("/", endpoint, "live", channelId),
+			content: `Live channel: ${channelId}`,
+			meta: {
+				kind: "live-channel",
+				hasTree,
+				childrenCount: 1
+			}
+		};
+	}
+	async metaLiveChannel(ctx) {
+		const channelId = this.assertLiveChannel(ctx);
+		const endpoint = ctx.params.endpoint;
+		return {
+			id: channelId,
+			path: joinURL("/", endpoint, "live", channelId, ".meta"),
+			meta: {
+				kind: "live-channel",
+				childrenCount: 1
+			}
+		};
+	}
+	async listLiveChannel(ctx) {
+		const channelId = this.assertLiveChannel(ctx);
+		const endpoint = ctx.params.endpoint;
+		return { data: [{
+			id: "tree",
+			path: joinURL("/", endpoint, "live", channelId, "tree"),
+			meta: {
+				kind: "aup:tree",
+				childrenCount: 0
+			}
+		}] };
+	}
+	async readLiveChannelTree(ctx) {
+		const channelId = this.assertLiveChannel(ctx);
+		const endpoint = ctx.params.endpoint;
+		const root = this.aupStores.get(this.channelAupKey(channelId))?.getRoot() ?? null;
+		return {
+			id: "tree",
+			path: joinURL("/", endpoint, "live", channelId, "tree"),
+			content: root,
+			meta: { kind: "aup:tree" }
+		};
+	}
+	async metaLiveChannelTree(ctx) {
+		const channelId = this.assertLiveChannel(ctx);
+		const endpoint = ctx.params.endpoint;
+		return {
+			id: "tree",
+			path: joinURL("/", endpoint, "live", channelId, "tree", ".meta"),
+			meta: { kind: "aup:tree" }
+		};
+	}
+	async writeLiveChannelTree(ctx, payload) {
+		const channelId = this.assertLiveChannel(ctx);
+		const endpoint = ctx.params.endpoint;
+		const root = payload.content;
+		if (!root || typeof root !== "object") throw new Error("tree write requires a node object as content");
+		const err = validateNode(root);
+		if (err) throw new Error(`Invalid AUP node: ${err}`);
+		const store = this.getChannelAupStore(channelId);
+		store.setRoot(root);
+		const meta = payload.meta ?? {};
+		const fullPage = meta.fullPage !== false;
+		const chrome = meta.chrome === true;
+		const theme = typeof meta.theme === "string" ? meta.theme : void 0;
+		const style = typeof meta.style === "string" ? meta.style : void 0;
+		const locale = typeof meta.locale === "string" ? meta.locale : void 0;
+		if (isAUPTransport(this.backend)) {
+			const msg = {
+				type: "aup",
+				action: "render",
+				root: store.getRoot()
+			};
+			if (fullPage) msg.fullPage = true;
+			if (chrome) msg.chrome = true;
+			if (theme) msg.theme = theme;
+			if (style) msg.style = style;
+			if (locale) msg.locale = locale;
+			this.backend.sendToLiveChannel(channelId, msg);
+		}
+		const treePath = joinURL("/", endpoint, "live", channelId, "tree");
+		this.emit({
+			type: "afs:write",
+			path: treePath,
+			data: { root: store.getRoot() }
+		});
+		return { data: {
+			id: "tree",
+			path: treePath,
+			content: store.getRoot(),
+			meta: { kind: "aup:tree" }
+		} };
+	}
+	async listLiveChannelActions(ctx) {
+		const channelId = this.assertLiveChannel(ctx);
+		const endpoint = ctx.params.endpoint;
+		const basePath = joinURL("/", endpoint, "live", channelId, ".actions");
+		return { data: [{
+			id: "aup_render",
+			path: joinURL(basePath, "aup_render"),
+			meta: {
+				kind: "afs:executable",
+				description: "Render AUP tree to all live channel viewers",
+				inputSchema: {
+					type: "object",
+					required: ["root"],
+					properties: {
+						root: {
+							type: "object",
+							description: "AUP node tree"
+						},
+						fullPage: {
+							type: "boolean",
+							default: true
+						},
+						chrome: {
+							type: "boolean",
+							description: "Show lang/theme/mode toolbar"
+						},
+						theme: {
+							type: "string",
+							enum: [
+								"dark",
+								"light",
+								"auto"
+							]
+						},
+						style: { type: "string" },
+						locale: { type: "string" }
+					}
+				}
+			}
+		}, {
+			id: "aup_patch",
+			path: joinURL(basePath, "aup_patch"),
+			meta: {
+				kind: "afs:executable",
+				description: "Patch AUP tree for all live channel viewers",
+				inputSchema: {
+					type: "object",
+					required: ["ops"],
+					properties: { ops: {
+						type: "array",
+						description: "Patch operations to apply",
+						items: {
+							type: "object",
+							required: ["op", "id"],
+							properties: {
+								op: {
+									type: "string",
+									enum: [
+										"create",
+										"update",
+										"remove",
+										"reorder"
+									],
+									description: "Operation type"
+								},
+								id: {
+									type: "string",
+									description: "Target node id (for update/remove/reorder) or new node id (for create)"
+								},
+								props: {
+									type: "object",
+									description: "Props to merge into node (for update)"
+								},
+								parentId: {
+									type: "string",
+									description: "Parent node id (for create)"
+								},
+								node: {
+									type: "object",
+									description: "Full AUP node { id, type, props, children } (for create)"
+								},
+								index: {
+									type: "number",
+									description: "Position index (for create/reorder)"
+								}
+							}
+						}
+					} }
+				}
+			}
+		}] };
+	}
+	async execLiveChannelAupRender(ctx, args) {
+		const channelId = this.assertLiveChannel(ctx);
+		const endpoint = ctx.params.endpoint;
+		const root = args.root;
+		if (!root) throw new Error("aup_render action requires 'root' argument");
+		const fullPage = args.fullPage !== false;
+		const chrome = args.chrome === true;
+		const theme = typeof args.theme === "string" ? args.theme : void 0;
+		const style = typeof args.style === "string" ? args.style : void 0;
+		const locale = typeof args.locale === "string" ? args.locale : void 0;
+		const err = validateNode(root);
+		if (err) throw new Error(`Invalid AUP node: ${err}`);
+		const store = this.getChannelAupStore(channelId);
+		store.setRoot(root);
+		store.setRenderOptions({
+			fullPage,
+			chrome,
+			theme,
+			style,
+			locale
+		});
+		if (isAUPTransport(this.backend)) {
+			const msg = {
+				type: "aup",
+				action: "render",
+				root: store.getRoot(),
+				treeVersion: store.version
+			};
+			if (fullPage) msg.fullPage = true;
+			if (chrome) msg.chrome = true;
+			if (theme) msg.theme = theme;
+			if (style) msg.style = style;
+			if (locale) msg.locale = locale;
+			this.backend.sendToLiveChannel(channelId, msg);
+		}
+		const treePath = joinURL("/", endpoint, "live", channelId, "tree");
+		this.emit({
+			type: "afs:write",
+			path: treePath,
+			data: { root: store.getRoot() }
+		});
+		return { success: true };
+	}
+	async execLiveChannelAupPatch(ctx, args) {
+		const channelId = this.assertLiveChannel(ctx);
+		const endpoint = ctx.params.endpoint;
+		const ops = args.ops;
+		if (!ops || !Array.isArray(ops)) throw new Error("aup_patch action requires 'ops' array argument");
+		const store = this.getChannelAupStore(channelId);
+		store.applyPatch(ops);
+		if (isAUPTransport(this.backend)) this.backend.sendToLiveChannel(channelId, {
+			type: "aup",
+			action: "patch",
+			ops,
+			treeVersion: store.version
+		});
+		const treePath = joinURL("/", endpoint, "live", channelId, "tree");
+		this.emit({
+			type: "afs:write",
+			path: treePath,
+			data: { root: store.getRoot() }
+		});
+		return { success: true };
+	}
+	sessionActionEntries(basePath) {
+		return [
+			{
+				id: "prompt",
+				path: joinURL(basePath, "prompt"),
+				meta: {
+					kind: "afs:executable",
+					description: "Ask user a question",
+					inputSchema: {
+						type: "object",
+						required: ["message"],
+						properties: {
+							message: { type: "string" },
+							type: {
+								type: "string",
+								enum: [
+									"text",
+									"password",
+									"confirm",
+									"select",
+									"multiselect"
+								],
+								default: "text"
+							},
+							options: {
+								type: "array",
+								items: { type: "string" }
+							}
+						}
+					}
+				}
+			},
+			{
+				id: "clear",
+				path: joinURL(basePath, "clear"),
+				meta: {
+					kind: "afs:executable",
+					description: "Clear screen",
+					inputSchema: {
+						type: "object",
+						properties: {}
+					}
+				}
+			},
+			{
+				id: "notify",
+				path: joinURL(basePath, "notify"),
+				meta: {
+					kind: "afs:executable",
+					description: "Send notification",
+					inputSchema: {
+						type: "object",
+						required: ["message"],
+						properties: { message: { type: "string" } }
+					}
+				}
+			},
+			{
+				id: "navigate",
+				path: joinURL(basePath, "navigate"),
+				meta: {
+					kind: "afs:executable",
+					description: "Navigate to a managed page",
+					inputSchema: {
+						type: "object",
+						required: ["page"],
+						properties: { page: { type: "string" } }
+					}
+				}
+			},
+			{
+				id: "dialog",
+				path: joinURL(basePath, "dialog"),
+				meta: {
+					kind: "afs:executable",
+					description: "Show dialog with custom buttons",
+					inputSchema: {
+						type: "object",
+						required: [
+							"title",
+							"content",
+							"buttons"
+						],
+						properties: {
+							title: { type: "string" },
+							content: { type: "string" },
+							buttons: {
+								type: "array",
+								items: { type: "string" }
+							}
+						}
+					}
+				}
+			},
+			{
+				id: "progress",
+				path: joinURL(basePath, "progress"),
+				meta: {
+					kind: "afs:executable",
+					description: "Display/update progress indicator",
+					inputSchema: {
+						type: "object",
+						required: [
+							"label",
+							"value",
+							"max"
+						],
+						properties: {
+							label: { type: "string" },
+							value: { type: "number" },
+							max: { type: "number" }
+						}
+					}
+				}
+			},
+			{
+				id: "form",
+				path: joinURL(basePath, "form"),
+				meta: {
+					kind: "afs:executable",
+					description: "Collect structured input via form",
+					inputSchema: {
+						type: "object",
+						required: ["fields"],
+						properties: {
+							title: { type: "string" },
+							fields: {
+								type: "array",
+								items: { type: "object" }
+							}
+						}
+					}
+				}
+			},
+			{
+				id: "table",
+				path: joinURL(basePath, "table"),
+				meta: {
+					kind: "afs:executable",
+					description: "Display tabular data",
+					inputSchema: {
+						type: "object",
+						required: ["headers", "rows"],
+						properties: {
+							headers: {
+								type: "array",
+								items: { type: "string" }
+							},
+							rows: {
+								type: "array",
+								items: {
+									type: "array",
+									items: { type: "string" }
+								}
+							}
+						}
+					}
+				}
+			},
+			{
+				id: "toast",
+				path: joinURL(basePath, "toast"),
+				meta: {
+					kind: "afs:executable",
+					description: "Show lightweight toast notification",
+					inputSchema: {
+						type: "object",
+						required: ["message"],
+						properties: {
+							message: { type: "string" },
+							toastType: {
+								type: "string",
+								enum: [
+									"info",
+									"success",
+									"warning",
+									"error"
+								],
+								default: "info"
+							}
+						}
+					}
+				}
+			},
+			{
+				id: "aup_render",
+				path: joinURL(basePath, "aup_render"),
+				meta: {
+					kind: "afs:executable",
+					description: "Render an AUP node graph (full replacement)",
+					inputSchema: {
+						type: "object",
+						required: ["root"],
+						properties: {
+							root: {
+								type: "object",
+								description: "AUP node tree (id, type, props, children)"
+							},
+							fullPage: {
+								type: "boolean",
+								description: "When true, renders AUP as full-page (no chat chrome)"
+							},
+							chrome: {
+								type: "boolean",
+								description: "When true, shows lang/theme/mode toolbar. Hidden by default."
+							},
+							theme: {
+								type: "string",
+								enum: [
+									"dark",
+									"light",
+									"auto"
+								],
+								description: "Color mode (default: auto, follows system preference)"
+							},
+							style: {
+								type: "string",
+								enum: [
+									"midnight",
+									"clean",
+									"glass",
+									"brutalist",
+									"soft",
+									"cyber"
+								],
+								description: "Structural style (default: midnight)"
+							},
+							locale: {
+								type: "string",
+								description: "Display locale for UI chrome (e.g. 'en', 'zh', 'ja')"
+							}
+						}
+					}
+				}
+			},
+			{
+				id: "aup_patch",
+				path: joinURL(basePath, "aup_patch"),
+				meta: {
+					kind: "afs:executable",
+					description: "Apply incremental patches to the AUP graph",
+					inputSchema: {
+						type: "object",
+						required: ["ops"],
+						properties: { ops: {
+							type: "array",
+							description: "Patch operations to apply",
+							items: {
+								type: "object",
+								required: ["op", "id"],
+								properties: {
+									op: {
+										type: "string",
+										enum: [
+											"create",
+											"update",
+											"remove",
+											"reorder"
+										],
+										description: "Operation type"
+									},
+									id: {
+										type: "string",
+										description: "Target node id (for update/remove/reorder) or new node id (for create)"
+									},
+									props: {
+										type: "object",
+										description: "Props to merge into node (for update)"
+									},
+									parentId: {
+										type: "string",
+										description: "Parent node id (for create)"
+									},
+									node: {
+										type: "object",
+										description: "Full AUP node { id, type, props, children } (for create)"
+									},
+									index: {
+										type: "number",
+										description: "Position index (for create/reorder)"
+									}
+								}
+							}
+						} }
+					}
+				}
+			},
+			{
+				id: "aup_save",
+				path: joinURL(basePath, "aup_save"),
+				meta: {
+					kind: "afs:executable",
+					description: "Save current AUP graph to a session page",
+					inputSchema: {
+						type: "object",
+						required: ["pageId"],
+						properties: { pageId: {
+							type: "string",
+							description: "Page ID to save the graph under"
+						} }
+					}
+				}
+			},
+			{
+				id: "aup_load",
+				path: joinURL(basePath, "aup_load"),
+				meta: {
+					kind: "afs:executable",
+					description: "Load a previously saved AUP graph from a session page",
+					inputSchema: {
+						type: "object",
+						required: ["pageId"],
+						properties: {
+							pageId: {
+								type: "string",
+								description: "Page ID to load the graph from"
+							},
+							fullPage: {
+								type: "boolean",
+								description: "When true, renders AUP as full-page (no chat chrome)"
+							},
+							chrome: {
+								type: "boolean",
+								description: "When true, shows lang/theme/mode toolbar. Hidden by default."
+							},
+							theme: {
+								type: "string",
+								enum: [
+									"dark",
+									"light",
+									"auto"
+								],
+								description: "Color mode (default: auto, follows system preference)"
+							},
+							style: {
+								type: "string",
+								enum: [
+									"midnight",
+									"clean",
+									"glass",
+									"brutalist",
+									"soft",
+									"cyber"
+								],
+								description: "Structural style (default: midnight)"
+							},
+							locale: {
+								type: "string",
+								description: "Display locale for UI chrome (e.g. 'en', 'zh', 'ja')"
+							}
+						}
+					}
+				}
+			},
+			{
+				id: "aup_stage",
+				path: joinURL(basePath, "aup_stage"),
+				meta: {
+					kind: "afs:executable",
+					description: "Stage an AUP scene (pre-render off-screen). Use aup_take to swap it live.",
+					inputSchema: {
+						type: "object",
+						required: ["sceneId", "root"],
+						properties: {
+							sceneId: {
+								type: "string",
+								description: "Unique scene identifier"
+							},
+							root: {
+								type: "object",
+								description: "AUP node tree"
+							},
+							fullPage: { type: "boolean" },
+							chrome: { type: "boolean" },
+							theme: { type: "string" },
+							style: { type: "string" },
+							locale: { type: "string" }
+						}
+					}
+				}
+			},
+			{
+				id: "aup_take",
+				path: joinURL(basePath, "aup_take"),
+				meta: {
+					kind: "afs:executable",
+					description: "Take a staged scene live (CSS swap, zero DOM teardown).",
+					inputSchema: {
+						type: "object",
+						required: ["sceneId"],
+						properties: {
+							sceneId: {
+								type: "string",
+								description: "Scene to take live"
+							},
+							transition: {
+								type: "string",
+								enum: ["cut", "dissolve"],
+								description: "Transition type (default: cut)"
+							},
+							duration: {
+								type: "number",
+								description: "Transition duration in ms"
+							}
+						}
+					}
+				}
+			},
+			{
+				id: "aup_release",
+				path: joinURL(basePath, "aup_release"),
+				meta: {
+					kind: "afs:executable",
+					description: "Release a staged scene's resources. Cannot release the active scene.",
+					inputSchema: {
+						type: "object",
+						required: ["sceneId"],
+						properties: { sceneId: {
+							type: "string",
+							description: "Scene to release"
+						} }
+					}
+				}
+			}
+		];
+	}
+	async listSessionActions(ctx) {
+		const session = this.resolveSession(ctx);
+		const endpoint = ctx.params.endpoint;
+		const basePath = joinURL("/", endpoint, "sessions", session.id, ".actions");
+		return { data: this.sessionActionEntries(basePath) };
+	}
+	async execSessionPrompt(ctx, args) {
+		const session = this.resolveSession(ctx);
+		const message = args.message;
+		if (!message) throw new Error("prompt action requires 'message' argument");
+		const type = args.type ?? "text";
+		const options = args.options;
+		const promptMsg = session.addMessage({
+			type: "prompt",
+			from: "agent",
+			message,
+			promptType: type,
+			...options ? { options } : {}
+		});
+		const result = await this.backend.prompt({
+			message,
+			type,
+			options
+		});
+		session.addMessage({
+			type: "prompt.response",
+			from: "user",
+			ref: promptMsg.id,
+			value: result
+		});
+		return {
+			success: true,
+			data: { response: result }
+		};
+	}
+	async execSessionForm(ctx, args) {
+		const session = this.resolveSession(ctx);
+		const fields = args.fields;
+		if (!fields || fields.length === 0) throw new Error("form action requires non-empty 'fields' argument");
+		const title = args.title;
+		const formMsg = session.addMessage({
+			type: "form",
+			from: "agent",
+			...title ? { title } : {},
+			fields
+		});
+		const values = {};
+		for (const field of fields) {
+			const promptType = field.type === "password" ? "password" : "text";
+			const result = await this.backend.prompt({
+				message: `${field.label}:`,
+				type: promptType
+			});
+			values[field.name] = result;
+		}
+		session.addMessage({
+			type: "form.response",
+			from: "user",
+			ref: formMsg.id,
+			data: values
+		});
+		return {
+			success: true,
+			data: { values }
+		};
+	}
+	async execSessionDialog(ctx, args) {
+		const session = this.resolveSession(ctx);
+		const title = args.title;
+		if (!title) throw new Error("dialog action requires 'title' argument");
+		const content = args.content ?? "";
+		const buttons = args.buttons;
+		if (!buttons || buttons.length === 0) throw new Error("dialog action requires 'buttons' argument");
+		const dialogMsg = session.addMessage({
+			type: "dialog",
+			from: "agent",
+			title,
+			content,
+			buttons
+		});
+		const result = await this.backend.prompt({
+			message: `${title}\n${content}`,
+			type: "select",
+			options: buttons
+		});
+		session.addMessage({
+			type: "dialog.response",
+			from: "user",
+			ref: dialogMsg.id,
+			selected: result
+		});
+		return {
+			success: true,
+			data: { selection: result }
+		};
+	}
+	async execSessionTable(ctx, args) {
+		const session = this.resolveSession(ctx);
+		const headers = args.headers;
+		if (!headers || headers.length === 0) throw new Error("table action requires 'headers' argument");
+		const rows = args.rows ?? [];
+		session.addMessage({
+			type: "table",
+			from: "agent",
+			headers,
+			rows
+		});
+		const colWidths = headers.map((h, i) => {
+			let max = h.length;
+			for (const row of rows) if (row[i] && row[i].length > max) max = row[i].length;
+			return max;
+		});
+		const pad = (s, w) => s + " ".repeat(Math.max(0, w - s.length));
+		const headerLine = headers.map((h, i) => pad(h, colWidths[i])).join(" | ");
+		const separator = colWidths.map((w) => "-".repeat(w)).join("-+-");
+		const dataLines = rows.map((row) => headers.map((_, i) => pad(row[i] ?? "", colWidths[i])).join(" | "));
+		await this.backend.write([
+			headerLine,
+			separator,
+			...dataLines
+		].join("\n"));
+		return { success: true };
+	}
+	async execSessionToast(ctx, args) {
+		const session = this.resolveSession(ctx);
+		const message = args.message;
+		if (!message) throw new Error("toast action requires 'message' argument");
+		session.addMessage({
+			type: "notification",
+			from: "agent",
+			message
+		});
+		await this.backend.notify(message);
+		return { success: true };
+	}
+	async execSessionProgress(ctx, args) {
+		const session = this.resolveSession(ctx);
+		const label = args.label ?? "";
+		const value = args.value;
+		if (value === void 0 || value === null) throw new Error("progress action requires 'value' argument");
+		const max = args.max ?? 100;
+		const pct = Math.round(value / max * 100);
+		session.addMessage({
+			type: "progress",
+			from: "agent",
+			label,
+			value,
+			max
+		});
+		await this.backend.notify(`[${pct}%] ${label}`);
+		return {
+			success: true,
+			data: {
+				value,
+				max,
+				percent: pct
+			}
+		};
+	}
+	async execSessionClear(ctx, _args) {
+		this.resolveSession(ctx);
+		await this.backend.clear();
+		return { success: true };
+	}
+	async execSessionNavigate(ctx, args) {
+		const session = this.resolveSession(ctx);
+		const pageId = args.page;
+		if (!pageId) throw new Error("navigate action requires 'page' argument");
+		const page = session.getPage(pageId) ?? this.pages.get(pageId);
+		if (!page) throw new Error(`Page not found: ${pageId}`);
+		if (this.backend.navigate) await this.backend.navigate(pageId, page.content, page.format, page.layout);
+		else await this.backend.write(page.content);
+		return { success: true };
+	}
+	async execSessionNotify(ctx, args) {
+		const session = this.resolveSession(ctx);
+		const message = args.message;
+		if (!message) throw new Error("notify action requires 'message' argument");
+		session.addMessage({
+			type: "notification",
+			from: "agent",
+			message
+		});
+		await this.backend.notify(message);
+		return { success: true };
+	}
+	async execSessionAupRender(ctx, args) {
+		const session = this.resolveSession(ctx);
+		const root = args.root;
+		if (!root) throw new Error("aup_render action requires 'root' argument");
+		const fullPage = args.fullPage === true;
+		const chrome = args.chrome === true;
+		const theme = typeof args.theme === "string" ? args.theme : void 0;
+		const style = typeof args.style === "string" ? args.style : void 0;
+		const locale = typeof args.locale === "string" ? args.locale : void 0;
+		const err = validateNode(root);
+		if (err) throw new Error(`Invalid AUP node: ${err}`);
+		const store = this.getAupStore(session.id);
+		store.setRoot(root);
+		store.setRenderOptions({
+			fullPage,
+			chrome,
+			theme,
+			style,
+			locale
+		});
+		if (isAUPTransport(this.backend)) {
+			const msg = {
+				type: "aup",
+				action: "render",
+				root: this.degradeForSession(store.getRoot(), session),
+				treeVersion: store.version
+			};
+			if (fullPage) msg.fullPage = true;
+			if (chrome) msg.chrome = true;
+			if (theme) msg.theme = theme;
+			if (style) msg.style = style;
+			if (locale) msg.locale = locale;
+			this.backend.sendToSession(session.id, msg);
+		}
+		const endpoint = ctx.params.endpoint;
+		const treePath = joinURL("/", endpoint, "sessions", session.id, "tree");
+		this.emit({
+			type: "afs:write",
+			path: treePath,
+			data: { root: store.getRoot() }
+		});
+		return { success: true };
+	}
+	async execSessionAupPatch(ctx, args) {
+		const session = this.resolveSession(ctx);
+		const ops = args.ops;
+		if (!ops || !Array.isArray(ops)) throw new Error("aup_patch action requires 'ops' array argument");
+		const store = this.getAupStore(session.id);
+		store.applyPatch(ops);
+		if (isAUPTransport(this.backend)) this.backend.sendToSession(session.id, {
+			type: "aup",
+			action: "patch",
+			ops,
+			treeVersion: store.version
+		});
+		const endpoint = ctx.params.endpoint;
+		const treePath = joinURL("/", endpoint, "sessions", session.id, "tree");
+		this.emit({
+			type: "afs:write",
+			path: treePath,
+			data: { root: store.getRoot() }
+		});
+		return { success: true };
+	}
+	async execSessionAupSave(ctx, args) {
+		const session = this.resolveSession(ctx);
+		const pageId = args.pageId;
+		if (!pageId) throw new Error("aup_save action requires 'pageId' argument");
+		const root = this.aupStores.get(session.id)?.getRoot();
+		if (!root) throw new Error("No active AUP graph to save");
+		const graphJson = JSON.stringify(root);
+		session.setPage(pageId, {
+			content: graphJson,
+			format: "application/json"
+		});
+		return { success: true };
+	}
+	async execSessionAupLoad(ctx, args) {
+		const session = this.resolveSession(ctx);
+		const pageId = args.pageId;
+		if (!pageId) throw new Error("aup_load action requires 'pageId' argument");
+		const fullPage = args.fullPage === true;
+		const chrome = args.chrome === true;
+		const theme = typeof args.theme === "string" ? args.theme : void 0;
+		const style = typeof args.style === "string" ? args.style : void 0;
+		const locale = typeof args.locale === "string" ? args.locale : void 0;
+		const page = session.getPage(pageId);
+		if (!page) throw new Error(`AUP page not found: ${pageId}`);
+		const root = JSON.parse(page.content);
+		const err = validateNode(root);
+		if (err) throw new Error(`Invalid stored AUP graph: ${err}`);
+		const store = this.getAupStore(session.id);
+		store.setRoot(root);
+		if (isAUPTransport(this.backend)) {
+			const msg = {
+				type: "aup",
+				action: "render",
+				root: this.degradeForSession(store.getRoot(), session)
+			};
+			if (fullPage) msg.fullPage = true;
+			if (chrome) msg.chrome = true;
+			if (theme) msg.theme = theme;
+			if (style) msg.style = style;
+			if (locale) msg.locale = locale;
+			this.backend.sendToSession(session.id, msg);
+		}
+		return { success: true };
+	}
+	async execSessionAupStage(ctx, args) {
+		const session = this.resolveSession(ctx);
+		const sceneId = args.sceneId;
+		if (!sceneId) throw new Error("aup_stage action requires 'sceneId' argument");
+		const root = args.root;
+		if (!root) throw new Error("aup_stage action requires 'root' argument");
+		const fullPage = args.fullPage === true;
+		const chrome = args.chrome === true;
+		const theme = typeof args.theme === "string" ? args.theme : void 0;
+		const style = typeof args.style === "string" ? args.style : void 0;
+		const locale = typeof args.locale === "string" ? args.locale : void 0;
+		const err = validateNode(root);
+		if (err) throw new Error(`Invalid AUP node: ${err}`);
+		const store = this.getAupManager(session.id).stage(sceneId, root, {
+			fullPage,
+			chrome,
+			theme,
+			style,
+			locale
+		});
+		if (isAUPTransport(this.backend)) {
+			const msg = {
+				type: "aup",
+				action: "stage",
+				sceneId,
+				root: this.degradeForSession(store.getRoot(), session),
+				treeVersion: store.version
+			};
+			if (fullPage) msg.fullPage = true;
+			if (chrome) msg.chrome = true;
+			if (theme) msg.theme = theme;
+			if (style) msg.style = style;
+			if (locale) msg.locale = locale;
+			this.backend.sendToSession(session.id, msg);
+		}
+		return { success: true };
+	}
+	async execSessionAupTake(ctx, args) {
+		const session = this.resolveSession(ctx);
+		const sceneId = args.sceneId;
+		if (!sceneId) throw new Error("aup_take action requires 'sceneId' argument");
+		const transition = typeof args.transition === "string" ? args.transition : void 0;
+		const duration = typeof args.duration === "number" ? args.duration : void 0;
+		this.getAupManager(session.id).take(sceneId);
+		if (isAUPTransport(this.backend)) {
+			const msg = {
+				type: "aup",
+				action: "take",
+				sceneId
+			};
+			if (transition) msg.transition = transition;
+			if (duration) msg.duration = duration;
+			this.backend.sendToSession(session.id, msg);
+		}
+		return { success: true };
+	}
+	async execSessionAupRelease(ctx, args) {
+		const session = this.resolveSession(ctx);
+		const sceneId = args.sceneId;
+		if (!sceneId) throw new Error("aup_release action requires 'sceneId' argument");
+		this.getAupManager(session.id).release(sceneId);
+		if (isAUPTransport(this.backend)) this.backend.sendToSession(session.id, {
+			type: "aup",
+			action: "release",
+			sceneId
+		});
+		return { success: true };
+	}
+	async listActions(_ctx) {
+		return { data: [
+			{
+				id: "prompt",
+				path: "/.actions/prompt",
+				meta: {
+					kind: "afs:executable",
+					description: "Ask user a question",
+					inputSchema: {
+						type: "object",
+						required: ["message"],
+						properties: {
+							message: {
+								type: "string",
+								description: "The question to ask"
+							},
+							type: {
+								type: "string",
+								enum: [
+									"text",
+									"password",
+									"confirm",
+									"select",
+									"multiselect"
+								],
+								default: "text",
+								description: "Input type"
+							},
+							options: {
+								type: "array",
+								items: { type: "string" },
+								description: "Options for select/multiselect"
+							}
+						}
+					}
+				}
+			},
+			{
+				id: "clear",
+				path: "/.actions/clear",
+				meta: {
+					kind: "afs:executable",
+					description: "Clear screen",
+					inputSchema: {
+						type: "object",
+						properties: {}
+					}
+				}
+			},
+			{
+				id: "notify",
+				path: "/.actions/notify",
+				meta: {
+					kind: "afs:executable",
+					description: "Send notification",
+					inputSchema: {
+						type: "object",
+						required: ["message"],
+						properties: { message: {
+							type: "string",
+							description: "Notification message"
+						} }
+					}
+				}
+			},
+			{
+				id: "navigate",
+				path: "/.actions/navigate",
+				meta: {
+					kind: "afs:executable",
+					description: "Navigate to a managed page",
+					inputSchema: {
+						type: "object",
+						required: ["page"],
+						properties: { page: {
+							type: "string",
+							description: "Page ID to navigate to"
+						} }
+					}
+				}
+			},
+			{
+				id: "dialog",
+				path: "/.actions/dialog",
+				meta: {
+					kind: "afs:executable",
+					description: "Show dialog with custom buttons",
+					inputSchema: {
+						type: "object",
+						required: [
+							"title",
+							"content",
+							"buttons"
+						],
+						properties: {
+							title: {
+								type: "string",
+								description: "Dialog title"
+							},
+							content: {
+								type: "string",
+								description: "Dialog content"
+							},
+							buttons: {
+								type: "array",
+								items: { type: "string" },
+								description: "Button labels"
+							}
+						}
+					}
+				}
+			},
+			{
+				id: "progress",
+				path: "/.actions/progress",
+				meta: {
+					kind: "afs:executable",
+					description: "Display/update progress indicator",
+					inputSchema: {
+						type: "object",
+						required: [
+							"label",
+							"value",
+							"max"
+						],
+						properties: {
+							label: {
+								type: "string",
+								description: "Progress label"
+							},
+							value: {
+								type: "number",
+								description: "Current value"
+							},
+							max: {
+								type: "number",
+								description: "Maximum value"
+							}
+						}
+					}
+				}
+			},
+			{
+				id: "form",
+				path: "/.actions/form",
+				meta: {
+					kind: "afs:executable",
+					description: "Collect structured input via form",
+					inputSchema: {
+						type: "object",
+						required: ["fields"],
+						properties: {
+							title: {
+								type: "string",
+								description: "Form title"
+							},
+							fields: {
+								type: "array",
+								items: {
+									type: "object",
+									required: [
+										"name",
+										"label",
+										"type"
+									],
+									properties: {
+										name: { type: "string" },
+										label: { type: "string" },
+										type: {
+											type: "string",
+											enum: [
+												"text",
+												"number",
+												"password",
+												"select",
+												"checkbox",
+												"textarea"
+											]
+										},
+										options: {
+											type: "array",
+											items: { type: "string" }
+										},
+										required: { type: "boolean" }
+									}
+								},
+								description: "Form field definitions"
+							}
+						}
+					}
+				}
+			},
+			{
+				id: "table",
+				path: "/.actions/table",
+				meta: {
+					kind: "afs:executable",
+					description: "Display tabular data",
+					inputSchema: {
+						type: "object",
+						required: ["headers", "rows"],
+						properties: {
+							headers: {
+								type: "array",
+								items: { type: "string" },
+								description: "Column headers"
+							},
+							rows: {
+								type: "array",
+								items: {
+									type: "array",
+									items: { type: "string" }
+								},
+								description: "Table rows"
+							}
+						}
+					}
+				}
+			},
+			{
+				id: "toast",
+				path: "/.actions/toast",
+				meta: {
+					kind: "afs:executable",
+					description: "Show lightweight toast notification",
+					inputSchema: {
+						type: "object",
+						required: ["message"],
+						properties: {
+							message: {
+								type: "string",
+								description: "Toast message"
+							},
+							toastType: {
+								type: "string",
+								enum: [
+									"info",
+									"success",
+									"warning",
+									"error"
+								],
+								default: "info",
+								description: "Toast type"
+							}
+						}
+					}
+				}
+			}
+		] };
+	}
+	async execPrompt(_ctx, args) {
+		const message = args.message;
+		if (!message) throw new Error("prompt action requires 'message' argument");
+		const type = args.type ?? "text";
+		const validTypes = [
+			"text",
+			"password",
+			"confirm",
+			"select",
+			"multiselect"
+		];
+		if (!validTypes.includes(type)) throw new Error(`Invalid prompt type: ${type}. Must be one of: ${validTypes.join(", ")}`);
+		const options = args.options;
+		return {
+			success: true,
+			data: { response: await this.backend.prompt({
+				message,
+				type,
+				options
+			}) }
+		};
+	}
+	async execClear(_ctx, _args) {
+		await this.backend.clear();
+		return { success: true };
+	}
+	async execNotify(_ctx, args) {
+		const message = args.message;
+		if (!message) throw new Error("notify action requires 'message' argument");
+		await this.backend.notify(message);
+		return { success: true };
+	}
+	async execNavigate(_ctx, args) {
+		const pageId = args.page;
+		if (!pageId) throw new Error("navigate action requires 'page' argument");
+		const page = this.pages.get(pageId);
+		if (!page) throw new Error(`Page not found: ${pageId}`);
+		if (this.backend.navigate) await this.backend.navigate(pageId, page.content, page.format, page.layout);
+		else await this.backend.write(page.content);
+		return { success: true };
+	}
+	async execDialog(_ctx, args) {
+		const title = args.title;
+		if (!title) throw new Error("dialog action requires 'title' argument");
+		const content = args.content ?? "";
+		const buttons = args.buttons;
+		if (!buttons || buttons.length === 0) throw new Error("dialog action requires 'buttons' argument");
+		return {
+			success: true,
+			data: { selection: await this.backend.prompt({
+				message: `${title}\n${content}`,
+				type: "select",
+				options: buttons
+			}) }
+		};
+	}
+	async execProgress(_ctx, args) {
+		const label = args.label ?? "";
+		const value = args.value;
+		if (value === void 0 || value === null) throw new Error("progress action requires 'value' argument");
+		const max = args.max ?? 100;
+		const pct = Math.round(value / max * 100);
+		await this.backend.notify(`[${pct}%] ${label}`);
+		return {
+			success: true,
+			data: {
+				value,
+				max,
+				percent: pct
+			}
+		};
+	}
+	async execForm(_ctx, args) {
+		const fields = args.fields;
+		if (!fields || fields.length === 0) throw new Error("form action requires non-empty 'fields' argument");
+		const values = {};
+		for (const field of fields) {
+			const promptType = field.type === "password" ? "password" : "text";
+			const result = await this.backend.prompt({
+				message: `${field.label}:`,
+				type: promptType
+			});
+			values[field.name] = result;
+		}
+		return {
+			success: true,
+			data: { values }
+		};
+	}
+	async execTable(_ctx, args) {
+		const headers = args.headers;
+		if (!headers || headers.length === 0) throw new Error("table action requires 'headers' argument");
+		const rows = args.rows ?? [];
+		const colWidths = headers.map((h, i) => {
+			let max = h.length;
+			for (const row of rows) if (row[i] && row[i].length > max) max = row[i].length;
+			return max;
+		});
+		const pad = (s, w) => s + " ".repeat(Math.max(0, w - s.length));
+		const tableText = [
+			headers.map((h, i) => pad(h, colWidths[i])).join(" | "),
+			colWidths.map((w) => "-".repeat(w)).join("-+-"),
+			...rows.map((row) => headers.map((_, i) => pad(row[i] ?? "", colWidths[i])).join(" | "))
+		].join("\n");
+		await this.backend.write(tableText);
+		return { success: true };
+	}
+	async execToast(_ctx, args) {
+		const message = args.message;
+		if (!message) throw new Error("toast action requires 'message' argument");
+		await this.backend.notify(message);
+		return { success: true };
+	}
+};
+__decorate([Read("/.meta/.capabilities")], AFSUIProvider.prototype, "readCapabilities", null);
+__decorate([Meta("/")], AFSUIProvider.prototype, "metaRoot", null);
+__decorate([Meta("/input")], AFSUIProvider.prototype, "metaInput", null);
+__decorate([Meta("/output")], AFSUIProvider.prototype, "metaOutput", null);
+__decorate([Meta("/pages")], AFSUIProvider.prototype, "metaPages", null);
+__decorate([Meta("/pages/:id")], AFSUIProvider.prototype, "metaPage", null);
+__decorate([List("/input")], AFSUIProvider.prototype, "listInput", null);
+__decorate([List("/output")], AFSUIProvider.prototype, "listOutput", null);
+__decorate([List("/pages")], AFSUIProvider.prototype, "listPages", null);
+__decorate([List("/")], AFSUIProvider.prototype, "listRoot", null);
+__decorate([Read("/")], AFSUIProvider.prototype, "readRoot", null);
+__decorate([Read("/input")], AFSUIProvider.prototype, "readInput", null);
+__decorate([Read("/output")], AFSUIProvider.prototype, "readOutput", null);
+__decorate([Read("/pages")], AFSUIProvider.prototype, "readPages", null);
+__decorate([Read("/pages/:id")], AFSUIProvider.prototype, "readPage", null);
+__decorate([List("/primitives")], AFSUIProvider.prototype, "listPrimitives", null);
+__decorate([Read("/primitives")], AFSUIProvider.prototype, "readPrimitivesDir", null);
+__decorate([Stat("/primitives")], AFSUIProvider.prototype, "statPrimitivesDir", null);
+__decorate([Meta("/primitives")], AFSUIProvider.prototype, "metaPrimitivesDir", null);
+__decorate([Read("/primitives/:name")], AFSUIProvider.prototype, "readPrimitive", null);
+__decorate([Stat("/primitives/:name")], AFSUIProvider.prototype, "statPrimitive", null);
+__decorate([Meta("/primitives/:name")], AFSUIProvider.prototype, "metaPrimitive", null);
+__decorate([List("/themes")], AFSUIProvider.prototype, "listThemes", null);
+__decorate([Read("/themes")], AFSUIProvider.prototype, "readThemesDir", null);
+__decorate([Stat("/themes")], AFSUIProvider.prototype, "statThemesDir", null);
+__decorate([Meta("/themes")], AFSUIProvider.prototype, "metaThemesDir", null);
+__decorate([Read("/themes/:name")], AFSUIProvider.prototype, "readTheme", null);
+__decorate([Stat("/themes/:name")], AFSUIProvider.prototype, "statTheme", null);
+__decorate([Meta("/themes/:name")], AFSUIProvider.prototype, "metaTheme", null);
+__decorate([List("/overlay-themes")], AFSUIProvider.prototype, "listOverlayThemes", null);
+__decorate([Read("/overlay-themes")], AFSUIProvider.prototype, "readOverlayThemesDir", null);
+__decorate([Stat("/overlay-themes")], AFSUIProvider.prototype, "statOverlayThemesDir", null);
+__decorate([Meta("/overlay-themes")], AFSUIProvider.prototype, "metaOverlayThemesDir", null);
+__decorate([Read("/overlay-themes/:name")], AFSUIProvider.prototype, "readOverlayTheme", null);
+__decorate([Stat("/overlay-themes/:name")], AFSUIProvider.prototype, "statOverlayTheme", null);
+__decorate([Meta("/overlay-themes/:name")], AFSUIProvider.prototype, "metaOverlayTheme", null);
+__decorate([List("/overlay-themes/:name/examples")], AFSUIProvider.prototype, "listOverlayExamples", null);
+__decorate([Read("/overlay-themes/:name/examples/:example")], AFSUIProvider.prototype, "readOverlayExample", null);
+__decorate([Read("/spec")], AFSUIProvider.prototype, "readSpec", null);
+__decorate([Stat("/spec")], AFSUIProvider.prototype, "statSpec", null);
+__decorate([List("/spec")], AFSUIProvider.prototype, "listSpec", null);
+__decorate([Meta("/spec")], AFSUIProvider.prototype, "metaSpec", null);
+__decorate([Explain("/spec")], AFSUIProvider.prototype, "explainSpec", null);
+__decorate([List("/examples")], AFSUIProvider.prototype, "listExamples", null);
+__decorate([Read("/examples")], AFSUIProvider.prototype, "readExamplesDir", null);
+__decorate([Stat("/examples")], AFSUIProvider.prototype, "statExamplesDir", null);
+__decorate([Meta("/examples")], AFSUIProvider.prototype, "metaExamplesDir", null);
+__decorate([Read("/examples/:name")], AFSUIProvider.prototype, "readExample", null);
+__decorate([Stat("/examples/:name")], AFSUIProvider.prototype, "statExample", null);
+__decorate([Meta("/examples/:name")], AFSUIProvider.prototype, "metaExample", null);
+__decorate([Write("/output")], AFSUIProvider.prototype, "writeOutput", null);
+__decorate([Write("/pages/:id")], AFSUIProvider.prototype, "writePage", null);
+__decorate([Delete("/pages/:id")], AFSUIProvider.prototype, "deletePage", null);
+__decorate([Write("/sharing/:slug")], AFSUIProvider.prototype, "writeSharingEntry", null);
+__decorate([Read("/sharing/:slug")], AFSUIProvider.prototype, "readSharingEntry", null);
+__decorate([Read("/sharing")], AFSUIProvider.prototype, "readSharingDir", null);
+__decorate([List("/sharing")], AFSUIProvider.prototype, "listSharingEntries", null);
+__decorate([Delete("/sharing/:slug")], AFSUIProvider.prototype, "deleteSharingEntry", null);
+__decorate([Meta("/sharing")], AFSUIProvider.prototype, "metaSharingDir", null);
+__decorate([Meta("/sharing/:slug")], AFSUIProvider.prototype, "metaSharingEntry", null);
+__decorate([Stat("/sharing")], AFSUIProvider.prototype, "statSharingDir", null);
+__decorate([Stat("/sharing/:slug")], AFSUIProvider.prototype, "statSharingEntry", null);
+__decorate([Actions("/sharing/:slug")], AFSUIProvider.prototype, "listSharingActions", null);
+__decorate([Actions.Exec("/sharing/:slug", "snapshot")], AFSUIProvider.prototype, "execSharingSnapshot", null);
+__decorate([Stat("/")], AFSUIProvider.prototype, "statRoot", null);
+__decorate([Stat("/input")], AFSUIProvider.prototype, "statInput", null);
+__decorate([Stat("/output")], AFSUIProvider.prototype, "statOutput", null);
+__decorate([Stat("/pages")], AFSUIProvider.prototype, "statPages", null);
+__decorate([Stat("/pages/:id")], AFSUIProvider.prototype, "statPage", null);
+__decorate([Explain("/")], AFSUIProvider.prototype, "explainRoot", null);
+__decorate([Explain("/input")], AFSUIProvider.prototype, "explainInput", null);
+__decorate([Explain("/output")], AFSUIProvider.prototype, "explainOutput", null);
+__decorate([Explain("/pages")], AFSUIProvider.prototype, "explainPages", null);
+__decorate([Read("/:endpoint")], AFSUIProvider.prototype, "readEndpoint", null);
+__decorate([Stat("/:endpoint")], AFSUIProvider.prototype, "statEndpoint", null);
+__decorate([List("/:endpoint")], AFSUIProvider.prototype, "listEndpoint", null);
+__decorate([Meta("/:endpoint")], AFSUIProvider.prototype, "metaEndpoint", null);
+__decorate([Read("/:endpoint/sessions")], AFSUIProvider.prototype, "readSessions", null);
+__decorate([Meta("/:endpoint/sessions")], AFSUIProvider.prototype, "metaSessions", null);
+__decorate([List("/:endpoint/sessions")], AFSUIProvider.prototype, "listSessions", null);
+__decorate([List("/:endpoint/sessions/:sid")], AFSUIProvider.prototype, "listSession", null);
+__decorate([Read("/:endpoint/sessions/:sid")], AFSUIProvider.prototype, "readSession", null);
+__decorate([Meta("/:endpoint/sessions/:sid")], AFSUIProvider.prototype, "metaSession", null);
+__decorate([Stat("/:endpoint/sessions/:sid")], AFSUIProvider.prototype, "statSession", null);
+__decorate([List("/:endpoint/sessions/:sid/messages")], AFSUIProvider.prototype, "listSessionMessages", null);
+__decorate([Read("/:endpoint/sessions/:sid/messages/:mid")], AFSUIProvider.prototype, "readSessionMessage", null);
+__decorate([Write("/:endpoint/sessions/:sid/messages")], AFSUIProvider.prototype, "writeSessionMessage", null);
+__decorate([List("/:endpoint/sessions/:sid/pages")], AFSUIProvider.prototype, "listSessionPages", null);
+__decorate([Read("/:endpoint/sessions/:sid/pages/:pid")], AFSUIProvider.prototype, "readSessionPage", null);
+__decorate([Write("/:endpoint/sessions/:sid/pages/:pid")], AFSUIProvider.prototype, "writeSessionPage", null);
+__decorate([Read("/:endpoint/sessions/:sid/.caps")], AFSUIProvider.prototype, "readSessionCaps", null);
+__decorate([Write("/:endpoint/sessions/:sid/.caps")], AFSUIProvider.prototype, "writeSessionCaps", null);
+__decorate([Read("/:endpoint/sessions/:sid/tree")], AFSUIProvider.prototype, "readSessionTree", null);
+__decorate([Write("/:endpoint/sessions/:sid/tree")], AFSUIProvider.prototype, "writeSessionTree", null);
+__decorate([Read("/:endpoint/sessions/:sid/wm")], AFSUIProvider.prototype, "readSessionWm", null);
+__decorate([List("/:endpoint/sessions/:sid/wm")], AFSUIProvider.prototype, "listSessionWm", null);
+__decorate([Read("/:endpoint/sessions/:sid/wm/strategy")], AFSUIProvider.prototype, "readWmStrategy", null);
+__decorate([Write("/:endpoint/sessions/:sid/wm/strategy")], AFSUIProvider.prototype, "writeWmStrategy", null);
+__decorate([Read("/:endpoint/sessions/:sid/wm/layout")], AFSUIProvider.prototype, "readWmLayout", null);
+__decorate([List("/:endpoint/sessions/:sid/wm/surfaces")], AFSUIProvider.prototype, "listWmSurfaces", null);
+__decorate([Read("/:endpoint/sessions/:sid/wm/surfaces/:surfaceName")], AFSUIProvider.prototype, "readWmSurface", null);
+__decorate([Actions("/:endpoint/sessions/:sid/wm")], AFSUIProvider.prototype, "listWmActions", null);
+__decorate([Actions.Exec("/:endpoint/sessions/:sid/wm", "open-surface")], AFSUIProvider.prototype, "execWmOpenSurface", null);
+__decorate([Actions.Exec("/:endpoint/sessions/:sid/wm", "set-surface-content")], AFSUIProvider.prototype, "execWmSetSurfaceContent", null);
+__decorate([Actions.Exec("/:endpoint/sessions/:sid/wm", "close-surface")], AFSUIProvider.prototype, "execWmCloseSurface", null);
+__decorate([Actions.Exec("/:endpoint/sessions/:sid/wm", "set-strategy")], AFSUIProvider.prototype, "execWmSetStrategy", null);
+__decorate([Actions.Exec("/:endpoint/sessions/:sid/wm", "set-active")], AFSUIProvider.prototype, "execWmSetActive", null);
+__decorate([Actions.Exec("/:endpoint/sessions/:sid/wm", "pin-to-dock")], AFSUIProvider.prototype, "execWmPinToDock", null);
+__decorate([Actions.Exec("/:endpoint/sessions/:sid/wm", "unpin-from-dock")], AFSUIProvider.prototype, "execWmUnpinFromDock", null);
+__decorate([Actions.Exec("/:endpoint/sessions/:sid/wm", "set-layout")], AFSUIProvider.prototype, "execWmSetLayout", null);
+__decorate([Actions.Exec("/:endpoint/sessions/:sid/wm", "collapse-panel")], AFSUIProvider.prototype, "execWmCollapsePanel", null);
+__decorate([Actions.Exec("/:endpoint/sessions/:sid/wm", "expand-panel")], AFSUIProvider.prototype, "execWmExpandPanel", null);
+__decorate([Actions.Exec("/:endpoint/sessions/:sid/wm", "move-surface")], AFSUIProvider.prototype, "execWmMoveSurface", null);
+__decorate([Actions.Exec("/:endpoint/sessions/:sid/wm", "add-to-panel")], AFSUIProvider.prototype, "execWmAddToPanel", null);
+__decorate([Actions.Exec("/:endpoint/sessions/:sid/wm", "set-panel-active")], AFSUIProvider.prototype, "execWmSetPanelActive", null);
+__decorate([Actions.Exec("/:endpoint/sessions/:sid/wm", "popout")], AFSUIProvider.prototype, "execWmPopout", null);
+__decorate([Actions.Exec("/:endpoint/sessions/:sid/wm", "redock")], AFSUIProvider.prototype, "execWmRedock", null);
+__decorate([Actions.Exec("/:endpoint/sessions/:sid/wm", "auto-arrange")], AFSUIProvider.prototype, "execWmAutoArrange", null);
+__decorate([Explain("/:endpoint/sessions/:sid")], AFSUIProvider.prototype, "explainSession", null);
+__decorate([List("/:endpoint/live")], AFSUIProvider.prototype, "listLiveChannels", null);
+__decorate([Read("/:endpoint/live")], AFSUIProvider.prototype, "readLiveDirectory", null);
+__decorate([Meta("/:endpoint/live")], AFSUIProvider.prototype, "metaLiveDirectory", null);
+__decorate([Read("/:endpoint/live/:channelId")], AFSUIProvider.prototype, "readLiveChannel", null);
+__decorate([Meta("/:endpoint/live/:channelId")], AFSUIProvider.prototype, "metaLiveChannel", null);
+__decorate([List("/:endpoint/live/:channelId")], AFSUIProvider.prototype, "listLiveChannel", null);
+__decorate([Read("/:endpoint/live/:channelId/tree")], AFSUIProvider.prototype, "readLiveChannelTree", null);
+__decorate([Meta("/:endpoint/live/:channelId/tree")], AFSUIProvider.prototype, "metaLiveChannelTree", null);
+__decorate([Write("/:endpoint/live/:channelId/tree")], AFSUIProvider.prototype, "writeLiveChannelTree", null);
+__decorate([Actions("/:endpoint/live/:channelId")], AFSUIProvider.prototype, "listLiveChannelActions", null);
+__decorate([Actions.Exec("/:endpoint/live/:channelId", "aup_render")], AFSUIProvider.prototype, "execLiveChannelAupRender", null);
+__decorate([Actions.Exec("/:endpoint/live/:channelId", "aup_patch")], AFSUIProvider.prototype, "execLiveChannelAupPatch", null);
+__decorate([Actions("/:endpoint/sessions/:sid")], AFSUIProvider.prototype, "listSessionActions", null);
+__decorate([Actions.Exec("/:endpoint/sessions/:sid", "prompt")], AFSUIProvider.prototype, "execSessionPrompt", null);
+__decorate([Actions.Exec("/:endpoint/sessions/:sid", "form")], AFSUIProvider.prototype, "execSessionForm", null);
+__decorate([Actions.Exec("/:endpoint/sessions/:sid", "dialog")], AFSUIProvider.prototype, "execSessionDialog", null);
+__decorate([Actions.Exec("/:endpoint/sessions/:sid", "table")], AFSUIProvider.prototype, "execSessionTable", null);
+__decorate([Actions.Exec("/:endpoint/sessions/:sid", "toast")], AFSUIProvider.prototype, "execSessionToast", null);
+__decorate([Actions.Exec("/:endpoint/sessions/:sid", "progress")], AFSUIProvider.prototype, "execSessionProgress", null);
+__decorate([Actions.Exec("/:endpoint/sessions/:sid", "clear")], AFSUIProvider.prototype, "execSessionClear", null);
+__decorate([Actions.Exec("/:endpoint/sessions/:sid", "navigate")], AFSUIProvider.prototype, "execSessionNavigate", null);
+__decorate([Actions.Exec("/:endpoint/sessions/:sid", "notify")], AFSUIProvider.prototype, "execSessionNotify", null);
+__decorate([Actions.Exec("/:endpoint/sessions/:sid", "aup_render")], AFSUIProvider.prototype, "execSessionAupRender", null);
+__decorate([Actions.Exec("/:endpoint/sessions/:sid", "aup_patch")], AFSUIProvider.prototype, "execSessionAupPatch", null);
+__decorate([Actions.Exec("/:endpoint/sessions/:sid", "aup_save")], AFSUIProvider.prototype, "execSessionAupSave", null);
+__decorate([Actions.Exec("/:endpoint/sessions/:sid", "aup_load")], AFSUIProvider.prototype, "execSessionAupLoad", null);
+__decorate([Actions.Exec("/:endpoint/sessions/:sid", "aup_stage")], AFSUIProvider.prototype, "execSessionAupStage", null);
+__decorate([Actions.Exec("/:endpoint/sessions/:sid", "aup_take")], AFSUIProvider.prototype, "execSessionAupTake", null);
+__decorate([Actions.Exec("/:endpoint/sessions/:sid", "aup_release")], AFSUIProvider.prototype, "execSessionAupRelease", null);
+__decorate([Actions("/")], AFSUIProvider.prototype, "listActions", null);
+__decorate([Actions.Exec("/", "prompt")], AFSUIProvider.prototype, "execPrompt", null);
+__decorate([Actions.Exec("/", "clear")], AFSUIProvider.prototype, "execClear", null);
+__decorate([Actions.Exec("/", "notify")], AFSUIProvider.prototype, "execNotify", null);
+__decorate([Actions.Exec("/", "navigate")], AFSUIProvider.prototype, "execNavigate", null);
+__decorate([Actions.Exec("/", "dialog")], AFSUIProvider.prototype, "execDialog", null);
+__decorate([Actions.Exec("/", "progress")], AFSUIProvider.prototype, "execProgress", null);
+__decorate([Actions.Exec("/", "form")], AFSUIProvider.prototype, "execForm", null);
+__decorate([Actions.Exec("/", "table")], AFSUIProvider.prototype, "execTable", null);
+__decorate([Actions.Exec("/", "toast")], AFSUIProvider.prototype, "execToast", null);
+
+//#endregion
+export { AFSUIProvider };
+//# sourceMappingURL=ui-provider.mjs.map