@agimon-ai/doompi-author 0.0.1-alpha.2 → 0.0.1-alpha.21

package/dist/extensions/web.mjs

@@ -0,0 +1,4231 @@
+import { apiResponse, createApiClient, defineApiRoutes, defineChannelFile, defineDockFace, defineFileLinks, defineGlobalStore, defineLeaderBinding, defineMinorModeFile, defineSessionStore, defineSlotFile, defineToolRenderer, defineWebLifecycle, defineWebPlugin, sessionApiAddress, toolResultTextLines } from "@agimon-ai/doompi-core/web";
+import { Store } from "@tanstack/store";
+import { Button, CodeEditor, Markdown, MediaPreview, MessageItem, MessageItemBody, MessageItemHeader, MessageItemStatus, MessageLines, collapseLines, toolTone } from "@agimon-ai/doompi-web-components";
+import { useStore } from "@tanstack/react-store";
+import { useEffect, useRef, useState } from "react";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { sealedTransport } from "@agimon-ai/doompi-web-security/browser";
+//#region src/types/webAuthor.ts
+const authorChannelType = "author_webmcp";
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/_lib/authorRuntime.ts
+const AUTHOR_RUNTIME_BINDING_IDS = {
+	text: "author.viewport.text",
+	media: "author.viewport.media"
+};
+function assertProfile(profile) {
+	if (profile.id.trim() === "") throw new Error("Author profile id must not be empty");
+	if (profile.tools.length > 15) throw new Error("Author profiles may expose at most 15 tools");
+	const names = /* @__PURE__ */ new Set();
+	for (const tool of profile.tools) {
+		if (!/^[a-z][a-z0-9_]{0,29}$/.test(tool.name)) throw new Error(`Invalid Author tool name: ${tool.name}`);
+		if (names.has(tool.name)) throw new Error(`Duplicate Author tool name: ${tool.name}`);
+		names.add(tool.name);
+	}
+}
+function descriptorMatches(actual, expected) {
+	return actual.name === expected.name && actual.description === expected.description && JSON.stringify(actual.inputSchema) === JSON.stringify(expected.inputSchema);
+}
+function staleError() {
+	return /* @__PURE__ */ new Error("Author viewport catalog is stale");
+}
+function invocationSignal(catalogSignal, requestSignal) {
+	const controller = new AbortController();
+	const abortCatalog = () => controller.abort(catalogSignal.reason);
+	const abortRequest = () => controller.abort(requestSignal.reason);
+	if (catalogSignal.aborted) abortCatalog();
+	else if (requestSignal.aborted) abortRequest();
+	else {
+		catalogSignal.addEventListener("abort", abortCatalog, { once: true });
+		requestSignal.addEventListener("abort", abortRequest, { once: true });
+	}
+	return {
+		signal: controller.signal,
+		release: () => {
+			catalogSignal.removeEventListener("abort", abortCatalog);
+			requestSignal.removeEventListener("abort", abortRequest);
+		}
+	};
+}
+/** Owns page-lifetime WebMCP registrations. Profiles are replaced as one abortable catalog. */
+var AuthorRuntime = class {
+	#runtime;
+	#context;
+	#active;
+	#pending;
+	#generation = 0;
+	#disposed = false;
+	constructor(runtime) {
+		this.#runtime = runtime;
+	}
+	async replaceProfiles(profiles) {
+		if (this.#disposed) throw new Error("Author runtime is disposed");
+		for (const profile of profiles) assertProfile(profile);
+		const profileMap = new Map(profiles.map((profile) => [profile.id, profile]));
+		const tools = profiles.flatMap((profile) => profile.tools);
+		if (new Set(tools.map((tool) => tool.name)).size !== tools.length) throw new Error("Author tool names must be unique across trusted profiles");
+		const context = this.#context ?? (await this.#runtime.acquireModelContext?.())?.modelContext;
+		if (context === void 0) throw new Error("Model Context is unavailable");
+		this.#context = context;
+		const generation = ++this.#generation;
+		const controller = new AbortController();
+		const candidate = {
+			generation,
+			controller,
+			profiles: profileMap
+		};
+		const inactive = staleError();
+		this.#pending?.controller.abort(inactive);
+		this.#active?.controller.abort(inactive);
+		this.#pending = candidate;
+		this.#active = void 0;
+		const assertCurrent = () => {
+			if (controller.signal.aborted || this.#disposed || this.#active?.generation !== generation) throw staleError();
+		};
+		try {
+			await Promise.all(tools.map(async (tool) => context.registerTool({
+				name: tool.name,
+				description: tool.description,
+				inputSchema: tool.inputSchema,
+				execute: async (input, options) => {
+					assertCurrent();
+					const parsed = JSON.parse(input);
+					assertCurrent();
+					const invocation = invocationSignal(controller.signal, options.signal);
+					try {
+						const result = await tool.execute(parsed, invocation.signal);
+						assertCurrent();
+						return result;
+					} finally {
+						invocation.release();
+					}
+				}
+			}, { signal: controller.signal })));
+			const registered = await context.getTools();
+			if (!tools.every((tool) => registered.some((descriptor) => descriptorMatches(descriptor, tool)))) throw new Error("Model Context did not confirm the Author catalog");
+			if (this.#disposed || generation !== this.#generation || this.#pending !== candidate) throw staleError();
+			this.#pending = void 0;
+			this.#active = candidate;
+		} catch (error) {
+			controller.abort(error);
+			if (this.#pending === candidate) this.#pending = void 0;
+			throw error;
+		}
+		return () => {
+			if (this.#active?.generation !== generation) return;
+			controller.abort(staleError());
+			this.#active = void 0;
+			this.#generation += 1;
+		};
+	}
+	async execute(name, input, signal) {
+		const context = this.#context;
+		if (context === void 0 || this.#active === void 0) throw new Error("Author catalog is not registered");
+		return context.executeTool(name, JSON.stringify(input), { signal });
+	}
+	dispose() {
+		if (this.#disposed) return;
+		this.#disposed = true;
+		this.#generation += 1;
+		this.#pending?.controller.abort(/* @__PURE__ */ new Error("Author runtime disposed"));
+		this.#active?.controller.abort(/* @__PURE__ */ new Error("Author runtime disposed"));
+		this.#pending = void 0;
+		this.#active = void 0;
+	}
+};
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/_lib/authorBrowserBridge.ts
+var AuthorBrowserBridge = class {
+	#host;
+	#runtime;
+	#pending = /* @__PURE__ */ new Map();
+	#active;
+	#generation = 0;
+	#disposed = false;
+	#releaseConnected;
+	#leaseTimer;
+	constructor(host) {
+		this.#host = host;
+		this.#runtime = new AuthorRuntime(host);
+		this.#releaseConnected = host.onHubConnected(() => {
+			if (this.#active !== void 0) {
+				this.#active.ownerToken = void 0;
+				this.#active.catalogToken = void 0;
+			}
+			this.#register();
+		});
+	}
+	async focus(sessionId, profiles) {
+		if (this.#disposed) throw new Error("Author browser bridge is disposed");
+		const generation = ++this.#generation;
+		const release = await this.#runtime.replaceProfiles(profiles);
+		if (this.#disposed || generation !== this.#generation) {
+			release();
+			return () => void 0;
+		}
+		this.#clearActive();
+		this.#active = {
+			sessionId,
+			generation,
+			profiles,
+			release
+		};
+		this.#register();
+		return () => {
+			if (this.#active?.generation !== generation) return;
+			this.#clearActive();
+			this.#generation += 1;
+		};
+	}
+	drop(sessionId) {
+		if (this.#active?.sessionId !== sessionId) return;
+		this.#clearActive();
+		this.#generation += 1;
+	}
+	apply(sessionId, message) {
+		const active = this.#active;
+		if (active === void 0 || active.sessionId !== sessionId || message.kind === "rejected") return;
+		if (message.generation !== active.generation || message.ownerToken !== active.ownerToken && active.ownerToken !== void 0) return;
+		if (message.kind === "accepted") {
+			active.ownerToken = message.ownerToken;
+			clearTimeout(this.#leaseTimer);
+			this.#leaseTimer = setTimeout(() => this.#register(), Math.max(1e3, Math.floor(message.leaseMs / 2)));
+			if (message.catalogToken === void 0) this.#sendCatalog(active);
+			else active.catalogToken = message.catalogToken;
+			return;
+		}
+		if (message.catalogToken !== active.catalogToken) return;
+		if (message.kind === "cancel") {
+			this.#pending.get(message.requestId)?.abort(/* @__PURE__ */ new Error("Author tool request cancelled"));
+			return;
+		}
+		if (message.kind !== "request" || this.#pending.has(message.requestId)) return;
+		const controller = new AbortController();
+		this.#pending.set(message.requestId, controller);
+		this.#runtime.execute(message.name, message.arguments, controller.signal).then((result) => {
+			if (!this.#current(active, message.requestId, controller)) return;
+			if (controller.signal.aborted) this.#sendCancelled(active, message.requestId);
+			else this.#send(active.sessionId, {
+				kind: "result",
+				generation: active.generation,
+				ownerToken: active.ownerToken,
+				catalogToken: active.catalogToken,
+				requestId: message.requestId,
+				result
+			});
+		}).catch((error) => {
+			if (!this.#current(active, message.requestId, controller)) return;
+			if (controller.signal.aborted) this.#sendCancelled(active, message.requestId);
+			else {
+				const messageText = error instanceof Error ? error.message : String(error);
+				const code = /^([A-Z][A-Z_]+):/u.exec(messageText)?.[1] ?? "AUTHOR_TOOL_ERROR";
+				this.#send(active.sessionId, {
+					kind: "result",
+					generation: active.generation,
+					ownerToken: active.ownerToken,
+					catalogToken: active.catalogToken,
+					requestId: message.requestId,
+					result: { error: {
+						code,
+						message: messageText
+					} }
+				});
+			}
+		}).finally(() => {
+			if (this.#pending.get(message.requestId) === controller) this.#pending.delete(message.requestId);
+		});
+	}
+	activeView(sessionId) {
+		const active = this.#active;
+		return active?.sessionId === sessionId && active.catalogToken !== void 0 ? {
+			activation: "active",
+			capabilityCount: active.profiles.reduce((count, profile) => count + profile.tools.length, 0)
+		} : {
+			activation: "inactive",
+			capabilityCount: 0
+		};
+	}
+	dispose() {
+		if (this.#disposed) return;
+		this.#disposed = true;
+		clearTimeout(this.#leaseTimer);
+		this.#releaseConnected();
+		this.#clearActive();
+		this.#runtime.dispose();
+	}
+	#register() {
+		const active = this.#active;
+		if (active !== void 0) this.#send(active.sessionId, {
+			kind: "register",
+			generation: active.generation
+		});
+	}
+	#sendCatalog(active) {
+		this.#send(active.sessionId, {
+			kind: "catalog",
+			generation: active.generation,
+			ownerToken: active.ownerToken,
+			tools: active.profiles.flatMap((profile) => profile.tools.map((tool) => ({
+				name: tool.name,
+				label: tool.label ?? tool.name,
+				description: tool.description,
+				inputSchema: tool.inputSchema
+			})))
+		});
+	}
+	#sendCancelled(active, requestId) {
+		this.#send(active.sessionId, {
+			kind: "cancelled",
+			generation: active.generation,
+			ownerToken: active.ownerToken,
+			catalogToken: active.catalogToken,
+			requestId
+		});
+	}
+	#send(sessionId, payload) {
+		const workspaceId = this.#host.mount?.scope === "session" ? this.#host.mount.workspaceId : void 0;
+		const mount = workspaceId ? {
+			scope: "workspace",
+			workspaceId
+		} : { scope: "global" };
+		this.#host.invokeServerMethod({
+			mount,
+			service: "author.bridge",
+			method: "send",
+			input: {
+				sessionId,
+				message: payload
+			}
+		}).catch(() => void 0);
+	}
+	#current(active, requestId, controller) {
+		return this.#active === active && this.#pending.get(requestId) === controller;
+	}
+	#clearActive() {
+		clearTimeout(this.#leaseTimer);
+		this.#leaseTimer = void 0;
+		const active = this.#active;
+		if (active !== void 0) {
+			this.#send(active.sessionId, {
+				kind: "release",
+				generation: active.generation
+			});
+			active.release();
+		}
+		this.#active = void 0;
+		for (const controller of this.#pending.values()) controller.abort(/* @__PURE__ */ new Error("Author viewport changed"));
+		this.#pending.clear();
+	}
+};
+const authorBridgeRuntime = new Store(void 0);
+function startAuthorBrowserBridge(runtime) {
+	authorBridgeRuntime.state?.dispose();
+	const next = new AuthorBrowserBridge(runtime);
+	authorBridgeRuntime.setState(() => next);
+	return () => {
+		if (authorBridgeRuntime.state !== next) return;
+		next.dispose();
+		authorBridgeRuntime.setState(() => void 0);
+	};
+}
+async function focusAuthorViewport(sessionId, profiles) {
+	return await authorBridgeRuntime.state?.focus(sessionId, profiles) ?? (() => void 0);
+}
+function applyAuthorHubMessage(sessionId, message) {
+	authorBridgeRuntime.state?.apply(sessionId, message);
+}
+function dropAuthorViewportSession(sessionId) {
+	authorBridgeRuntime.state?.drop(sessionId);
+}
+function authorBridgeView(sessionId) {
+	return authorBridgeRuntime.state?.activeView(sessionId) ?? {
+		activation: "inactive",
+		capabilityCount: 0
+	};
+}
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/_lib/authorGrid.ts
+const AUTHOR_GRID_COLUMNS = "ABCDEFGH";
+const nativeResolvers = /* @__PURE__ */ new Map();
+const authorGrid = defineGlobalStore({ sessions: {} });
+function parseAuthorGridCell(cell) {
+	const normalized = cell.trim().toUpperCase();
+	if (!/^[A-H][1-8]$/u.test(normalized)) throw new Error(`Invalid Author grid cell '${cell}'. Expected A1 through H8.`);
+	return {
+		cell: normalized,
+		column: AUTHOR_GRID_COLUMNS.indexOf(normalized[0]),
+		row: Number(normalized[1]) - 1
+	};
+}
+function updateAuthorGridGeometry(sessionId, input) {
+	const previous = authorGrid.store.state.sessions[sessionId];
+	const geometry = {
+		...input,
+		geometryToken: crypto.randomUUID(),
+		snapshotId: previous?.documentPath === input.documentPath && previous.revision === input.revision && previous.sourceSha256 === input.sourceSha256 ? previous.snapshotId : crypto.randomUUID(),
+		updatedAt: Date.now()
+	};
+	authorGrid.update((state) => ({
+		...state,
+		sessions: {
+			...state.sessions,
+			[sessionId]: geometry
+		}
+	}));
+	return geometry;
+}
+function authorGridGeometry(sessionId) {
+	return authorGrid.store.state.sessions[sessionId];
+}
+function clearAuthorGridGeometry(sessionId) {
+	authorGrid.update((state) => {
+		if (state.sessions[sessionId] === void 0) return state;
+		const sessions = { ...state.sessions };
+		delete sessions[sessionId];
+		return {
+			...state,
+			sessions
+		};
+	});
+}
+function registerAuthorGridResolver(sessionId, resolver) {
+	nativeResolvers.set(sessionId, resolver);
+	return () => {
+		if (nativeResolvers.get(sessionId) === resolver) nativeResolvers.delete(sessionId);
+	};
+}
+function resolveAuthorGridNativeAnchor(sessionId, cell) {
+	const geometry = authorGridGeometry(sessionId);
+	const resolved = geometry === void 0 ? void 0 : nativeResolvers.get(sessionId)?.(cell, geometry);
+	if (resolved === void 0) throw new Error("AMBIGUOUS_GRID: The grid cell does not resolve to one visible native document target.");
+	return resolved;
+}
+function resolveAuthorGridCell(sessionId, cell, expectedGeometryToken) {
+	const geometry = authorGridGeometry(sessionId);
+	if (geometry === void 0 || geometry.geometryToken !== expectedGeometryToken) throw new Error("STALE_GRID: The Author grid geometry changed. Describe the grid again.");
+	const parsed = parseAuthorGridCell(cell);
+	const width = 1 / 8;
+	const height = 1 / 8;
+	const rect = {
+		x: parsed.column * width,
+		y: parsed.row * height,
+		width,
+		height
+	};
+	return {
+		...parsed,
+		rect,
+		center: {
+			x: rect.x + width / 2,
+			y: rect.y + height / 2
+		},
+		evidence: {
+			cell: parsed.cell,
+			geometryToken: geometry.geometryToken,
+			snapshotId: geometry.snapshotId
+		}
+	};
+}
+const TERMINAL_REQUEST_STATUSES = /* @__PURE__ */ new Set([
+	"COMPLETE",
+	"FAILED",
+	"CANCELLED"
+]);
+const EMPTY_SESSION = {
+	generation: 0,
+	activeTool: "select",
+	annotationsByDocument: {},
+	annotations: [],
+	candidateText: "",
+	regions: [],
+	requests: []
+};
+function normalizeAuthorPath(path) {
+	const parts = [];
+	for (const part of path.trim().replaceAll("\\", "/").split("/")) {
+		if (part === "" || part === ".") continue;
+		if (part === "..") parts.pop();
+		else parts.push(part);
+	}
+	return parts.join("/");
+}
+function authorDocumentKey(sessionId, path) {
+	return `${sessionId}\n${normalizeAuthorPath(path)}`;
+}
+const authorWorkspace = defineGlobalStore({
+	documents: {},
+	sessions: {}
+});
+function authorDocument(sessionId, path) {
+	if (sessionId === null) return void 0;
+	return authorWorkspace.store.state.documents[authorDocumentKey(sessionId, path)];
+}
+function authorSessionWorkspace(sessionId) {
+	if (sessionId === null) return EMPTY_SESSION;
+	return authorWorkspace.store.state.sessions[sessionId] ?? EMPTY_SESSION;
+}
+function hydrateAuthorAnnotationCollections(records) {
+	authorWorkspace.update((state) => {
+		let sessions = state.sessions;
+		for (const record of records) {
+			const path = normalizeAuthorPath(record.documentPath);
+			if (path === "") continue;
+			const session = sessions[record.sessionId] ?? EMPTY_SESSION;
+			const previous = session.annotationsByDocument[path];
+			if (previous !== void 0 && previous.updatedAt >= record.collection.updatedAt) continue;
+			const document = state.documents[authorDocumentKey(record.sessionId, path)];
+			const stale = record.collection.stale || document !== void 0 && (document.version !== record.collection.revision || document.sourceSha256 !== record.collection.sourceSha256);
+			const collection = restoreCollectionEvidence({
+				...record.collection,
+				stale
+			});
+			const visible = session.focusedDocument?.path === path && !stale;
+			const annotations = visible ? collection.annotations : session.annotations;
+			sessions = {
+				...sessions,
+				[record.sessionId]: {
+					...session,
+					annotationsByDocument: {
+						...session.annotationsByDocument,
+						[path]: collection
+					},
+					...visible ? {
+						annotations,
+						regions: annotations,
+						candidate: collection.candidate,
+						candidateText: collection.candidateText
+					} : {}
+				}
+			};
+		}
+		return sessions === state.sessions ? state : {
+			...state,
+			sessions
+		};
+	});
+}
+function putAuthorDocument(sessionId, input) {
+	const path = normalizeAuthorPath(input.path);
+	if (path === "") throw new Error("Author document path must not be empty");
+	const key = authorDocumentKey(sessionId, path);
+	const staleThumbnails = [];
+	let result;
+	authorWorkspace.update((state) => {
+		const previous = state.documents[key];
+		const sourceChanged = previous?.sourceSha256 !== void 0 && input.sourceSha256 !== void 0 && previous.sourceSha256 !== input.sourceSha256;
+		const baselineVersion = sourceChanged ? previous.version + 1 : previous?.version ?? 0;
+		result = {
+			...input,
+			path,
+			annotations: sourceChanged ? [] : previous?.annotations ?? [],
+			revisions: sourceChanged ? [] : previous?.revisions ?? [],
+			saveRequest: previous?.saveRequest ?? 0,
+			version: baselineVersion,
+			savedVersion: sourceChanged ? baselineVersion : previous?.savedVersion ?? 0,
+			...sourceChanged || previous?.crop === void 0 ? {} : { crop: previous.crop }
+		};
+		const session = state.sessions[sessionId];
+		let sessions = state.sessions;
+		if (sourceChanged && session?.focusedDocument?.path === path) {
+			staleThumbnails.push(...session.candidate?.thumbnailUrl === void 0 ? [] : [session.candidate.thumbnailUrl], ...session.annotations.flatMap((annotation) => annotation.thumbnailUrl === void 0 ? [] : [annotation.thumbnailUrl]));
+			const now = Date.now();
+			const generation = session.generation + 1;
+			const staleCollection = staleAuthorCollection(session.annotationsByDocument[path], now);
+			sessions = {
+				...sessions,
+				[sessionId]: {
+					...session,
+					generation,
+					focusedDocument: {
+						path,
+						generation,
+						revision: baselineVersion,
+						sourceSha256: input.sourceSha256,
+						focusedAt: now
+					},
+					annotationsByDocument: {
+						...session.annotationsByDocument,
+						...staleCollection && { [path]: staleCollection }
+					},
+					annotations: [],
+					regions: [],
+					candidate: void 0,
+					candidateText: "",
+					requests: session.requests.map((request) => input.kind !== "story-preview" && request.documentPath === path && (request.status === "REQUESTED" || request.status === "CHANGING" || request.status === "CHANGED") ? {
+						...request,
+						status: "FAILED",
+						currentOperation: void 0,
+						error: "The document source changed before the request completed.",
+						updatedAt: now
+					} : request)
+				}
+			};
+		} else if (sourceChanged && session?.annotationsByDocument[path] !== void 0) {
+			const collection = session.annotationsByDocument[path];
+			if (collection.candidate?.thumbnailUrl !== void 0) staleThumbnails.push(collection.candidate.thumbnailUrl);
+			staleThumbnails.push(...collection.annotations.flatMap((annotation) => annotation.thumbnailUrl === void 0 ? [] : [annotation.thumbnailUrl]));
+			sessions = {
+				...sessions,
+				[sessionId]: {
+					...session,
+					annotationsByDocument: {
+						...session.annotationsByDocument,
+						[path]: staleAuthorCollection(collection, Date.now())
+					}
+				}
+			};
+		}
+		return {
+			documents: {
+				...state.documents,
+				[key]: result
+			},
+			sessions
+		};
+	});
+	staleThumbnails.forEach(revokeThumbnail);
+	return result;
+}
+/** Claims focus and returns a generation token that makes cleanup race-safe. */
+function focusAuthorDocument(sessionId, path, revision, sourceSha256) {
+	const normalized = normalizeAuthorPath(path);
+	let generation = 0;
+	authorWorkspace.update((state) => {
+		const session = state.sessions[sessionId] ?? EMPTY_SESSION;
+		generation = session.generation + 1;
+		const stored = session.annotationsByDocument[normalized];
+		const current = stored !== void 0 && stored.revision === revision && stored.sourceSha256 === sourceSha256 && !stored.stale ? stored : void 0;
+		const annotations = current?.annotations ?? [];
+		return {
+			...state,
+			sessions: {
+				...state.sessions,
+				[sessionId]: {
+					...session,
+					generation,
+					focusedDocument: {
+						path: normalized,
+						generation,
+						revision,
+						sourceSha256,
+						focusedAt: Date.now()
+					},
+					annotations,
+					regions: annotations,
+					candidate: current?.candidate,
+					candidateText: current?.candidateText ?? ""
+				}
+			}
+		};
+	});
+	return generation;
+}
+function syncAuthorDocumentFocus(sessionId, generation, revision, sourceSha256) {
+	updateSession(sessionId, (session) => {
+		const focused = session.focusedDocument;
+		if (focused === void 0 || focused.generation !== generation) return session;
+		if (focused.revision === revision && focused.sourceSha256 === sourceSha256) return session;
+		return {
+			...session,
+			focusedDocument: {
+				...focused,
+				revision,
+				sourceSha256
+			}
+		};
+	});
+}
+function releaseAuthorDocumentFocus(sessionId, generation) {
+	updateSession(sessionId, (session) => {
+		if (session.focusedDocument?.generation !== generation) return session;
+		return {
+			...session,
+			focusedDocument: void 0,
+			candidate: void 0,
+			candidateText: "",
+			annotations: [],
+			regions: []
+		};
+	});
+}
+function seekAuthorVideo(sessionId, timeSeconds) {
+	const workspace = authorSessionWorkspace(sessionId);
+	const focused = workspace.focusedDocument;
+	if (!focused || workspace.candidate || !Number.isFinite(timeSeconds) || timeSeconds < 0 || authorDocument(sessionId, focused.path)?.kind !== "video") return false;
+	updateSession(sessionId, (session) => ({
+		...session,
+		activeTool: "select",
+		videoSeekRequest: {
+			path: focused.path,
+			generation: focused.generation,
+			timeSeconds,
+			sequence: (session.videoSeekRequest?.sequence ?? 0) + 1
+		}
+	}));
+	return true;
+}
+function setAuthorToolMode(sessionId, activeTool) {
+	updateSession(sessionId, (session) => session.activeTool === activeTool ? session : {
+		...session,
+		activeTool
+	});
+}
+function setAuthorRegionCandidate(sessionId, candidate) {
+	let staleThumbnail;
+	updateSession(sessionId, (session) => {
+		const focused = session.focusedDocument;
+		if (candidate !== void 0) {
+			if (focused === void 0 || focused.path !== normalizeAuthorPath(candidate.documentPath)) throw new Error("The Author selection does not belong to the focused document.");
+			if (focused.revision !== candidate.revision || focused.sourceSha256 !== candidate.sourceSha256) throw new Error("The Author selection is stale for the focused document.");
+		}
+		if (focused === void 0) return session;
+		staleThumbnail = session.candidate?.thumbnailUrl;
+		const copied = candidate === void 0 ? void 0 : copyCandidate(candidate);
+		return withFocusedCollection({
+			...session,
+			candidate: copied
+		}, focused.path, { candidate: copied });
+	});
+	if (staleThumbnail !== void 0 && staleThumbnail !== candidate?.thumbnailUrl) revokeThumbnail(staleThumbnail);
+}
+function setAuthorCandidateText(sessionId, candidateText) {
+	if (new TextEncoder().encode(candidateText).byteLength > 2048) throw new Error("Author candidate text must not exceed 2 KiB.");
+	updateSession(sessionId, (session) => {
+		const path = session.focusedDocument?.path;
+		return path === void 0 ? session : withFocusedCollection({
+			...session,
+			candidateText
+		}, path, { candidateText });
+	});
+}
+function commitAuthorRegion(sessionId, comment) {
+	const id = crypto.randomUUID();
+	const session = authorSessionWorkspace(sessionId);
+	if (session.candidate === void 0) throw new Error("Select a document annotation before adding a comment.");
+	addAuthorRegion(sessionId, {
+		...session.candidate,
+		id,
+		comment,
+		version: 1
+	});
+	updateSession(sessionId, (current) => {
+		const path = current.focusedDocument?.path;
+		return path === void 0 ? current : withFocusedCollection({
+			...current,
+			candidate: void 0,
+			candidateText: ""
+		}, path, {
+			candidate: void 0,
+			candidateText: ""
+		});
+	});
+	return id;
+}
+function addAuthorRegion(sessionId, region) {
+	if (region.comment.trim() === "") throw new Error("Every Author annotation requires a comment.");
+	updateSession(sessionId, (session) => {
+		const focused = session.focusedDocument;
+		if (focused === void 0 || focused.path !== normalizeAuthorPath(region.documentPath)) throw new Error("The Author annotation does not belong to the focused document.");
+		if (focused.revision !== region.revision || focused.sourceSha256 !== region.sourceSha256) throw new Error("The Author annotation is stale for the focused document.");
+		if (session.annotations.length >= 16) throw new Error(`Author requests support at most 16 annotations.`);
+		if (session.annotations.some((candidate) => candidate.id === region.id)) throw new Error(`Author annotation '${region.id}' already exists.`);
+		const annotations = [...session.annotations, copyRegion({
+			...region,
+			version: region.version ?? 1
+		})];
+		return withFocusedCollection({
+			...session,
+			annotations,
+			regions: annotations
+		}, focused.path, { annotations });
+	});
+}
+function removeAuthorRegion(sessionId, regionId, expectedVersion, documentPath) {
+	let thumbnail;
+	updateSession(sessionId, (session) => {
+		const path = documentPath === void 0 ? session.focusedDocument?.path : normalizeAuthorPath(documentPath);
+		if (path === void 0) return session;
+		const focused = session.focusedDocument?.path === path;
+		const collection = session.annotationsByDocument[path];
+		const current = focused ? session.annotations : collection?.annotations;
+		if (current === void 0) return session;
+		const annotation = current.find((candidate) => candidate.id === regionId);
+		if (annotation === void 0 || expectedVersion !== void 0 && (annotation.version ?? 1) !== expectedVersion) return session;
+		thumbnail = annotation.thumbnailUrl;
+		const annotations = current.filter((candidate) => candidate.id !== regionId);
+		if (focused) return withFocusedCollection({
+			...session,
+			annotations,
+			regions: annotations
+		}, path, { annotations });
+		return {
+			...session,
+			annotationsByDocument: {
+				...session.annotationsByDocument,
+				[path]: {
+					...collection,
+					annotations,
+					updatedAt: Date.now()
+				}
+			}
+		};
+	});
+	if (thumbnail !== void 0) revokeThumbnail(thumbnail);
+}
+function putAuthorRequest(sessionId, record) {
+	if (record.requestText.trim() === "") throw new Error("An Author request requires verbatim request text.");
+	if (record.regions.length === 0 || record.regions.some((region) => region.comment.trim() === "")) throw new Error("An Author request requires at least one commented region.");
+	updateSession(sessionId, (session) => {
+		if (session.requests.some((request) => request.id === record.id)) throw new Error(`Author request '${record.id}' already exists.`);
+		return {
+			...session,
+			requests: boundHistory([...session.requests, copyRequest(record)])
+		};
+	});
+}
+function updateAuthorRequest(sessionId, requestId, update) {
+	updateSession(sessionId, (session) => ({
+		...session,
+		requests: boundHistory(session.requests.map((request) => request.id === requestId ? copyRequest(update(request)) : request))
+	}));
+}
+function reviseAuthorDocument(sessionId, path, content) {
+	updateDocument(sessionId, path, (document) => {
+		if (document.content === content) return document;
+		const version = document.version + 1;
+		return {
+			...document,
+			content,
+			version,
+			revisions: [...document.revisions, {
+				revision: version,
+				content
+			}]
+		};
+	});
+}
+function reviseAuthorFragment(sessionId, path, fragmentId, text) {
+	updateDocument(sessionId, path, (document) => {
+		const fragment = document.fragments?.find((candidate) => candidate.id === fragmentId);
+		if (fragment === void 0 || fragment.text === text) return document;
+		const version = document.version + 1;
+		return {
+			...document,
+			fragments: document.fragments?.map((fragment) => fragment.id === fragmentId ? {
+				...fragment,
+				text
+			} : fragment),
+			version,
+			revisions: [...document.revisions, {
+				revision: version,
+				content: text
+			}]
+		};
+	});
+}
+function addAuthorAnnotation(sessionId, path, annotation) {
+	updateDocument(sessionId, path, (document) => ({
+		...document,
+		annotations: [...document.annotations, annotation]
+	}));
+}
+function setAuthorCrop(sessionId, path, crop) {
+	updateDocument(sessionId, path, (document) => {
+		const version = document.version + 1;
+		return {
+			...document,
+			...crop === void 0 ? { crop: void 0 } : { crop },
+			version,
+			revisions: [...document.revisions, {
+				revision: version,
+				content: JSON.stringify(crop ?? null)
+			}]
+		};
+	});
+}
+function requestAuthorSave(sessionId, path) {
+	updateDocument(sessionId, path, (document) => ({
+		...document,
+		saveRequest: document.saveRequest + 1,
+		savingVersion: document.version
+	}));
+}
+function failAuthorSave(sessionId, path, savingVersion) {
+	updateDocument(sessionId, path, (document) => document.savingVersion === savingVersion ? {
+		...document,
+		savingVersion: void 0
+	} : document);
+}
+function completeAuthorSave(sessionId, path, sourceSha256, savedVersion, savedFragments) {
+	updateDocument(sessionId, path, (document) => {
+		if (savedVersion < document.savedVersion) return document;
+		return {
+			...document,
+			sourceSha256,
+			savedVersion,
+			savingVersion: document.savingVersion === savedVersion ? void 0 : document.savingVersion,
+			originalFragments: savedFragments?.map((fragment) => ({ ...fragment })),
+			...document.version === savedVersion ? { crop: void 0 } : {},
+			revisions: document.revisions.filter((revision) => revision.revision > savedVersion)
+		};
+	});
+	const now = Date.now();
+	updateSession(sessionId, (session) => ({
+		...session,
+		requests: boundHistory(session.requests.map((request) => request.documentPath === normalizeAuthorPath(path) && request.status === "CHANGED" && request.revision <= savedVersion ? {
+			...request,
+			status: "COMPLETE",
+			currentOperation: void 0,
+			updatedAt: now
+		} : request))
+	}));
+}
+function dropAuthorSession(sessionId) {
+	const prefix = `${sessionId}\n`;
+	const session = authorWorkspace.store.state.sessions[sessionId];
+	for (const collection of Object.values(session?.annotationsByDocument ?? {})) {
+		if (collection.candidate?.thumbnailUrl !== void 0) revokeThumbnail(collection.candidate.thumbnailUrl);
+		collection.annotations.forEach((annotation) => {
+			if (annotation.thumbnailUrl !== void 0) revokeThumbnail(annotation.thumbnailUrl);
+		});
+	}
+	authorWorkspace.update((state) => {
+		const sessions = { ...state.sessions };
+		delete sessions[sessionId];
+		return {
+			documents: Object.fromEntries(Object.entries(state.documents).filter(([key]) => !key.startsWith(prefix))),
+			sessions
+		};
+	});
+}
+function setAuthorStoryPreview(sessionId, path, storyPreview) {
+	updateDocument(sessionId, path, (document) => ({
+		...document,
+		storyPreview: structuredClone(storyPreview)
+	}));
+}
+function updateDocument(sessionId, path, update) {
+	const key = authorDocumentKey(sessionId, path);
+	const staleThumbnails = [];
+	authorWorkspace.update((state) => {
+		const document = state.documents[key];
+		if (document === void 0) return state;
+		const next = update(document);
+		const session = state.sessions[sessionId];
+		const focused = session?.focusedDocument;
+		const identityChanged = focused?.path === document.path && (focused.revision !== next.version || focused.sourceSha256 !== next.sourceSha256);
+		if (identityChanged) staleThumbnails.push(...session.candidate?.thumbnailUrl === void 0 ? [] : [session.candidate.thumbnailUrl], ...session.annotations.flatMap((annotation) => annotation.thumbnailUrl === void 0 ? [] : [annotation.thumbnailUrl]));
+		const staleCollection = identityChanged ? staleAuthorCollection(session.annotationsByDocument[document.path], Date.now()) : void 0;
+		const sessions = identityChanged ? {
+			...state.sessions,
+			[sessionId]: {
+				...session,
+				focusedDocument: {
+					...focused,
+					revision: next.version,
+					sourceSha256: next.sourceSha256
+				},
+				annotationsByDocument: {
+					...session.annotationsByDocument,
+					...staleCollection && { [document.path]: staleCollection }
+				},
+				candidate: void 0,
+				candidateText: "",
+				annotations: [],
+				regions: []
+			}
+		} : state.sessions;
+		return {
+			documents: {
+				...state.documents,
+				[key]: next
+			},
+			sessions
+		};
+	});
+	staleThumbnails.forEach(revokeThumbnail);
+}
+function updateSession(sessionId, update) {
+	authorWorkspace.update((state) => {
+		const session = state.sessions[sessionId] ?? EMPTY_SESSION;
+		const next = update(session);
+		return next === session ? state : {
+			...state,
+			sessions: {
+				...state.sessions,
+				[sessionId]: next
+			}
+		};
+	});
+}
+function copyCandidate(candidate) {
+	const anchor = "rect" in candidate.anchor ? {
+		...candidate.anchor,
+		rect: { ...candidate.anchor.rect }
+	} : "point" in candidate.anchor ? {
+		...candidate.anchor,
+		point: { ...candidate.anchor.point }
+	} : { ...candidate.anchor };
+	return {
+		...candidate,
+		anchor,
+		viewport: { ...candidate.viewport },
+		voiceGrid: candidate.voiceGrid && { ...candidate.voiceGrid }
+	};
+}
+function copyRegion(region) {
+	return copyCandidate(region);
+}
+function staleAuthorCollection(collection, updatedAt) {
+	if (collection === void 0) return void 0;
+	return {
+		...collection,
+		stale: true,
+		candidate: collection.candidate && {
+			...copyCandidate(collection.candidate),
+			thumbnailUrl: void 0
+		},
+		annotations: collection.annotations.map((annotation) => ({
+			...copyRegion(annotation),
+			thumbnailUrl: void 0
+		})),
+		updatedAt
+	};
+}
+function withFocusedCollection(session, path, update) {
+	const focused = session.focusedDocument;
+	if (focused === void 0 || focused.path !== path) return session;
+	const collection = {
+		...session.annotationsByDocument[path],
+		revision: focused.revision,
+		sourceSha256: focused.sourceSha256,
+		stale: false,
+		candidate: session.candidate,
+		candidateText: session.candidateText,
+		annotations: session.annotations,
+		updatedAt: Date.now(),
+		...update
+	};
+	return {
+		...session,
+		annotationsByDocument: {
+			...session.annotationsByDocument,
+			[path]: collection
+		}
+	};
+}
+function boundedHistoryText(value) {
+	if (value === void 0) return void 0;
+	const encoder = new TextEncoder();
+	if (encoder.encode(value).byteLength <= 16384) return value;
+	let end = value.length;
+	while (end > 0 && encoder.encode(value.slice(0, end)).byteLength > 16384) end -= 256;
+	return value.slice(0, end);
+}
+function copyRequest(record) {
+	return {
+		...record,
+		before: boundedHistoryText(record.before),
+		after: boundedHistoryText(record.after),
+		regions: record.regions.map(copyRegion),
+		pendingRegions: record.pendingRegions?.map(copyRegion)
+	};
+}
+function boundHistory(records) {
+	const next = [...records];
+	const bytes = () => new TextEncoder().encode(JSON.stringify(next)).byteLength;
+	while (next.length > 100 || bytes() > 524288) {
+		const terminal = next.findIndex((record) => TERMINAL_REQUEST_STATUSES.has(record.status));
+		if (terminal < 0) throw new Error("Author request history is full while active requests are still running.");
+		next.splice(terminal, 1);
+	}
+	return next;
+}
+function restoreCollectionEvidence(collection) {
+	const restore = (item) => {
+		const copied = copyCandidate(item);
+		const existingVersion = Reflect.get(copied, "version");
+		const versioned = "id" in copied ? {
+			...copied,
+			version: typeof existingVersion === "number" ? existingVersion : 1
+		} : copied;
+		if (versioned.thumbnailUrl !== void 0 || versioned.evidence === void 0) return versioned;
+		try {
+			return {
+				...versioned,
+				thumbnailUrl: URL.createObjectURL(versioned.evidence)
+			};
+		} catch {
+			return versioned;
+		}
+	};
+	return {
+		...collection,
+		candidate: collection.candidate && restore(collection.candidate),
+		annotations: collection.annotations.map(restore)
+	};
+}
+function revokeThumbnail(url) {
+	if (!url.startsWith("blob:")) return;
+	try {
+		URL.revokeObjectURL(url);
+	} catch {}
+}
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/channel/_lib/authorStore.ts
+const author = defineSessionStore({
+	activation: "inactive",
+	capabilityCount: 0
+});
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parseAuthorHubMessage(input) {
+	if (!isRecord(input)) return null;
+	if ((input.activation === "active" || input.activation === "inactive") && Number.isSafeInteger(input.capabilityCount) && input.capabilityCount >= 0) return input;
+	if (typeof input.kind !== "string") return null;
+	if (input.kind === "rejected") return typeof input.reason === "string" ? input : null;
+	if (!Number.isSafeInteger(input.generation) || typeof input.ownerToken !== "string") return null;
+	if (input.kind === "accepted") return typeof input.leaseMs === "number" && (input.catalogToken === void 0 || typeof input.catalogToken === "string") ? input : null;
+	if ((input.kind === "request" || input.kind === "cancel") && typeof input.catalogToken === "string" && typeof input.requestId === "string") {
+		if (input.kind === "cancel") return input;
+		return typeof input.name === "string" && isRecord(input.arguments) ? input : null;
+	}
+	return null;
+}
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/channel/author-webmcp.web.ts
+var author_webmcp_web_default = defineChannelFile({
+	channel: authorChannelType,
+	parse: parseAuthorHubMessage,
+	apply(sessionId, message) {
+		if ("activation" in message) {
+			author.update(sessionId, () => message);
+			return;
+		}
+		applyAuthorHubMessage(sessionId, message);
+		author.update(sessionId, () => authorBridgeView(sessionId));
+	},
+	drop(sessionId) {
+		clearAuthorGridGeometry(sessionId);
+		dropAuthorViewportSession(sessionId);
+		dropAuthorSession(sessionId);
+		author.drop(sessionId);
+	}
+});
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/_components/AuthorGridOverlay.tsx
+function autonomousVoiceGridVisible(statuses) {
+	return statuses["doom-voice"]?.trimStart().startsWith("voice auto:") === true;
+}
+function AuthorGridOverlay({ sessionId, document, visible }) {
+	const host = useRef(null);
+	useEffect(() => {
+		const element = host.current?.parentElement;
+		if (!visible || element === null || element === void 0) {
+			clearAuthorGridGeometry(sessionId);
+			return;
+		}
+		const publish = () => {
+			const bounds = element.getBoundingClientRect();
+			updateAuthorGridGeometry(sessionId, {
+				documentPath: document.path,
+				revision: document.version,
+				sourceSha256: document.sourceSha256,
+				viewport: {
+					width: bounds.width,
+					height: bounds.height,
+					originX: bounds.left,
+					originY: bounds.top,
+					scrollX: element.scrollLeft,
+					scrollY: element.scrollTop,
+					zoom: window.devicePixelRatio
+				}
+			});
+		};
+		publish();
+		const observer = new ResizeObserver(publish);
+		observer.observe(element);
+		element.addEventListener("scroll", publish, {
+			passive: true,
+			capture: true
+		});
+		window.addEventListener("focus", publish);
+		return () => {
+			observer.disconnect();
+			element.removeEventListener("scroll", publish, true);
+			window.removeEventListener("focus", publish);
+			clearAuthorGridGeometry(sessionId);
+		};
+	}, [
+		document.path,
+		document.sourceSha256,
+		document.version,
+		sessionId,
+		visible
+	]);
+	if (!visible) return null;
+	return /* @__PURE__ */ jsx("div", {
+		ref: host,
+		"data-testid": "author-grid",
+		"aria-hidden": "true",
+		className: "pointer-events-none absolute inset-0 z-20 grid grid-cols-8 grid-rows-8",
+		children: Array.from({ length: 64 }, (_, index) => {
+			const column = index % 8;
+			const row = Math.floor(index / 8);
+			return /* @__PURE__ */ jsx("div", {
+				className: "relative border border-doom-red/25",
+				children: /* @__PURE__ */ jsxs("span", {
+					className: "absolute left-1 top-0.5 rounded bg-doom-deep/80 px-1 text-2xs font-bold text-doom-red",
+					children: [AUTHOR_GRID_COLUMNS[column], row + 1]
+				})
+			}, index);
+		})
+	});
+}
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/_lib/authorCapture.ts
+const AUTHOR_CAPTURE_MAX_DIMENSION = 1600;
+const AUTHOR_QUOTE_MAX_BYTES = 4096;
+const AUTHOR_REGION_COLORS = [
+	"#ff5f57",
+	"#00c2ff",
+	"#ffd166",
+	"#b388ff",
+	"#4ade80",
+	"#ff8c42",
+	"#f472b6",
+	"#2dd4bf",
+	"#a3e635",
+	"#60a5fa",
+	"#e879f9",
+	"#facc15",
+	"#34d399",
+	"#fb7185",
+	"#818cf8",
+	"#22d3ee"
+];
+function annotationForeground(color) {
+	const red = Number.parseInt(color.slice(1, 3), 16);
+	const green = Number.parseInt(color.slice(3, 5), 16);
+	const blue = Number.parseInt(color.slice(5, 7), 16);
+	return red * 299 + green * 587 + blue * 114 >= 15e4 ? "#101216" : "#ffffff";
+}
+const bytes = (value) => new TextEncoder().encode(value).byteLength;
+function utf8Prefix(value, limit) {
+	if (bytes(value) <= limit) return value;
+	let low = 0;
+	let high = value.length;
+	while (low < high) {
+		const middle = Math.ceil((low + high) / 2);
+		if (bytes(value.slice(0, middle)) <= limit) low = middle;
+		else high = middle - 1;
+	}
+	return value.slice(0, low);
+}
+function createAuthorCapturePacket(captureId, capturedAt, document, regions) {
+	if (regions.length === 0 || regions.length > 16) throw new Error("Capture requires between 1 and 16 regions.");
+	if (document.kind === "story-preview" && document.storyPreview === void 0) throw new Error("Story preview capture requires source provenance.");
+	const packet = {
+		version: 1,
+		captureId,
+		capturedAt,
+		document: {
+			path: document.path,
+			kind: document.kind,
+			revision: document.version,
+			...document.sourceSha256 === void 0 ? {} : { sourceSha256: document.sourceSha256 },
+			...document.storyPreview === void 0 ? {} : { storyPreview: structuredClone(document.storyPreview) }
+		},
+		regions: regions.map((region, index) => {
+			if (region.documentPath !== document.path || region.revision !== document.version || region.sourceSha256 !== document.sourceSha256) throw new Error(`Region ${String(index + 1)} is stale for the focused document.`);
+			if (region.comment.trim() === "") throw new Error(`Region ${String(index + 1)} requires a comment.`);
+			if (bytes(region.comment) > 2048) throw new Error(`Region ${String(index + 1)} comment exceeds 2 KiB.`);
+			return {
+				id: region.id,
+				ordinal: index + 1,
+				comment: region.comment,
+				version: region.version ?? 1,
+				mode: region.mode ?? ("point" in region.anchor ? "point" : "region"),
+				...region.quote === void 0 ? {} : { quote: utf8Prefix(region.quote, AUTHOR_QUOTE_MAX_BYTES) },
+				anchor: structuredClone(region.anchor),
+				viewport: { ...region.viewport },
+				...region.voiceGrid === void 0 ? {} : { voiceGrid: { ...region.voiceGrid } }
+			};
+		})
+	};
+	if (bytes(JSON.stringify(packet)) > 65536) throw new Error("Author capture packet exceeds 64 KiB.");
+	return packet;
+}
+function percent(value) {
+	return `${String(Math.round(value * 1e3) / 10)}%`;
+}
+function rectLocation(rect) {
+	return `x ${percent(rect.x)}, y ${percent(rect.y)}, w ${percent(rect.width)}, h ${percent(rect.height)}`;
+}
+function anchorLocation(anchor) {
+	switch (anchor.kind) {
+		case "text-range": return anchor.startLine === anchor.endLine ? `line ${String(anchor.startLine)}` : `lines ${String(anchor.startLine)}-${String(anchor.endLine)}`;
+		case "cell": return `${anchor.sheet === void 0 ? "" : `${anchor.sheet}!`}${anchor.location}`;
+		case "slide-element": return `slide ${String(anchor.slide)}: ${anchor.location}`;
+		case "image-rect": return `image ${rectLocation(anchor.rect)}`;
+		case "pdf-page-rect": return `page ${String(anchor.page)}, ${rectLocation(anchor.rect)}`;
+		case "video-time-rect": return `time ${anchor.timeSeconds.toFixed(3)}s${anchor.frame === void 0 ? "" : `, frame ${String(anchor.frame)}`}, ${rectLocation(anchor.rect)}`;
+		case "story-preview-rect": return `story preview ${rectLocation(anchor.rect)}`;
+		case "image-point": return `image point x ${percent(anchor.point.x)}, y ${percent(anchor.point.y)}`;
+		case "pdf-page-point": return `page ${String(anchor.page)}, point x ${percent(anchor.point.x)}, y ${percent(anchor.point.y)}`;
+		case "video-time-point": return `time ${anchor.timeSeconds.toFixed(3)}s, point x ${percent(anchor.point.x)}, y ${percent(anchor.point.y)}`;
+		case "story-preview-point": return `story preview point x ${percent(anchor.point.x)}, y ${percent(anchor.point.y)}`;
+	}
+}
+function storyPreviewProvenance(packet) {
+	const preview = packet.document.storyPreview;
+	if (preview === void 0) return void 0;
+	const sources = preview.sources.map((source) => `- ${source.path} (sha256 ${source.sha256})`).join("\n");
+	return [
+		"Story preview source (edit these sources, never the generated preview artifact):",
+		`Project: ${preview.projectPath}`,
+		`Story: ${preview.storyPath}#${preview.storyExport}`,
+		`Build revision: ${preview.buildRevision}`,
+		`Viewport: ${String(preview.viewport.width)}x${String(preview.viewport.height)}`,
+		"Sources:",
+		sources,
+		"After editing the underlying story or component source, rebuild the preview before treating it as visually verified."
+	].join("\n");
+}
+function authorCaptureContext(packet) {
+	const metadata = JSON.stringify(packet);
+	if (bytes(metadata) > 65536) throw new Error("Author capture packet exceeds 64 KiB.");
+	const annotations = packet.regions.map((region) => `(${String(region.ordinal)}) ${region.comment} [${anchorLocation(region.anchor)}]${region.quote ? `\nQuoted text: ${region.quote}` : ""}`).join("\n\n");
+	const provenance = storyPreviewProvenance(packet);
+	const content = provenance === void 0 ? annotations : `${provenance}\n\nAnnotations:\n${annotations}`;
+	return {
+		kind: "author-capture",
+		source: "author",
+		id: packet.captureId,
+		label: `${packet.regions.length} annotation${packet.regions.length === 1 ? "" : "s"} · ${packet.document.path}`,
+		content,
+		metadata
+	};
+}
+function canvasBlob(canvas, type, quality) {
+	return new Promise((resolve, reject) => {
+		canvas.toBlob((blob) => blob === null ? reject(/* @__PURE__ */ new Error("Unable to capture viewport")) : resolve(blob), type, quality);
+	});
+}
+async function base64(blob) {
+	const bytes = new Uint8Array(await blob.arrayBuffer());
+	let binary = "";
+	for (let offset = 0; offset < bytes.length; offset += 32768) binary += String.fromCharCode(...bytes.subarray(offset, offset + 32768));
+	return btoa(binary);
+}
+function throwIfAborted(signal) {
+	if (signal?.aborted === true) throw signal.reason;
+}
+async function boundedCanvasCapture(canvas) {
+	let mimeType = "image/png";
+	let blob = await canvasBlob(canvas, mimeType);
+	for (const quality of [
+		.9,
+		.75,
+		.6,
+		.45,
+		.3
+	]) {
+		if (blob.size <= 2097152) break;
+		mimeType = "image/jpeg";
+		blob = await canvasBlob(canvas, mimeType, quality);
+	}
+	if (blob.size > 2097152) throw new Error("Viewport capture exceeds 2 MiB");
+	return {
+		data: await base64(blob),
+		mimeType
+	};
+}
+function loadImage(url) {
+	return new Promise((resolve, reject) => {
+		const image = new Image();
+		image.onload = () => resolve(image);
+		image.onerror = () => reject(/* @__PURE__ */ new Error("Unable to load a region capture."));
+		image.src = url;
+	});
+}
+function multiRegionCaptureProvider(regions) {
+	return { async capture(signal) {
+		throwIfAborted(signal);
+		if (regions.length === 0 || regions.length > 16) throw new Error("Capture requires between 1 and 16 regions.");
+		const tiles = [];
+		for (const region of regions) {
+			const image = region.thumbnailUrl === void 0 ? void 0 : await loadImage(region.thumbnailUrl);
+			throwIfAborted(signal);
+			const width = image?.naturalWidth ?? region.viewport.width;
+			const height = image?.naturalHeight ?? region.viewport.height;
+			if (!Number.isFinite(width) || !Number.isFinite(height) || width <= 0 || height <= 0) throw new Error("Image is not ready to capture");
+			tiles.push({
+				region,
+				image,
+				width,
+				height
+			});
+		}
+		const width = Math.min(AUTHOR_CAPTURE_MAX_DIMENSION, Math.max(...tiles.map((tile) => tile.width)));
+		const naturalHeight = tiles.reduce((height, tile) => height + tile.height * width / tile.width, 0);
+		const scale = Math.min(1, AUTHOR_CAPTURE_MAX_DIMENSION / Math.max(width, naturalHeight));
+		const canvas = document.createElement("canvas");
+		canvas.width = Math.max(1, Math.round(width * scale));
+		canvas.height = Math.max(1, Math.round(naturalHeight * scale));
+		const context = canvas.getContext("2d");
+		if (context === null) throw new Error("Canvas is unavailable");
+		context.scale(scale, scale);
+		context.fillStyle = "#101216";
+		context.fillRect(0, 0, width, naturalHeight);
+		let y = 0;
+		for (const [index, { region, image, width: sourceWidth, height: sourceHeight }] of tiles.entries()) {
+			const annotationColor = AUTHOR_REGION_COLORS[index % AUTHOR_REGION_COLORS.length];
+			throwIfAborted(signal);
+			const tileHeight = sourceHeight * width / sourceWidth;
+			const drawWidth = width;
+			const drawHeight = tileHeight;
+			const drawX = 0;
+			const drawY = y;
+			let labelX = drawX;
+			let labelY = drawY;
+			if (image !== void 0) {
+				context.drawImage(image, drawX, drawY, drawWidth, drawHeight);
+				if ("rect" in region.anchor) {
+					const rect = region.anchor.rect;
+					const rx = drawX + rect.x * drawWidth;
+					const ry = drawY + rect.y * drawHeight;
+					const rw = rect.width * drawWidth;
+					const rh = rect.height * drawHeight;
+					context.fillStyle = "rgba(8,10,13,0.62)";
+					context.fillRect(drawX, drawY, drawWidth, Math.max(0, ry - drawY));
+					context.fillRect(drawX, ry + rh, drawWidth, Math.max(0, drawY + drawHeight - ry - rh));
+					context.fillRect(drawX, ry, Math.max(0, rx - drawX), rh);
+					context.fillRect(rx + rw, ry, Math.max(0, drawX + drawWidth - rx - rw), rh);
+					context.strokeStyle = annotationColor;
+					context.lineWidth = 3;
+					context.strokeRect(rx, ry, rw, rh);
+					labelX = rx;
+					labelY = ry;
+				} else if ("point" in region.anchor) {
+					const px = drawX + region.anchor.point.x * drawWidth;
+					const py = drawY + region.anchor.point.y * drawHeight;
+					const radius = Math.max(6, Math.min(14, Math.min(drawWidth, drawHeight) / 12));
+					context.beginPath();
+					context.arc(px, py, radius, 0, Math.PI * 2);
+					context.fillStyle = annotationColor;
+					context.fill();
+					context.strokeStyle = annotationForeground(annotationColor);
+					context.lineWidth = 2;
+					context.stroke();
+					labelX = px + radius;
+					labelY = py - radius;
+				}
+			}
+			const ordinal = String(index + 1);
+			let badgeScale = Math.min(1 / scale, drawHeight / 36);
+			context.font = `bold ${String(24 * badgeScale)}px monospace`;
+			const measuredWidth = context.measureText(ordinal).width + 12 * badgeScale;
+			if (measuredWidth > drawWidth) badgeScale *= drawWidth / measuredWidth;
+			context.font = `bold ${String(24 * badgeScale)}px monospace`;
+			context.textBaseline = "top";
+			const padding = 6 * badgeScale;
+			const labelWidth = Math.min(drawWidth, context.measureText(ordinal).width + padding * 2);
+			const labelHeight = 36 * badgeScale;
+			labelX = Math.max(drawX, Math.min(labelX, drawX + drawWidth - labelWidth));
+			labelY = Math.max(drawY, Math.min(labelY, drawY + drawHeight - labelHeight));
+			context.fillStyle = annotationColor;
+			context.fillRect(labelX, labelY, labelWidth, labelHeight);
+			context.fillStyle = annotationForeground(annotationColor);
+			context.fillText(ordinal, labelX + padding, labelY + padding);
+			y += tileHeight;
+		}
+		throwIfAborted(signal);
+		return boundedCanvasCapture(canvas);
+	} };
+}
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/dock/_components/AuthorRegionDrafts.tsx
+function AuthorRegionDrafts({ sessionId, workspace }) {
+	const [error, setError] = useState();
+	const add = () => {
+		try {
+			commitAuthorRegion(sessionId, workspace.candidateText);
+			setError(void 0);
+		} catch (reason) {
+			setError(reason instanceof Error ? reason.message : String(reason));
+		}
+	};
+	if (!workspace.candidate && workspace.annotations.length === 0) return null;
+	const candidateKind = workspace.candidate?.mode === "point" ? "point" : "region";
+	return /* @__PURE__ */ jsxs("section", {
+		className: "space-y-2",
+		"data-testid": "author-region-drafts",
+		children: [
+			workspace.candidate ? /* @__PURE__ */ jsxs(Fragment, { children: [
+				/* @__PURE__ */ jsxs("h3", {
+					className: "text-base font-semibold text-doom-text",
+					children: ["Current ", candidateKind]
+				}),
+				/* @__PURE__ */ jsxs("p", {
+					className: "text-base text-doom-dim sm:text-sm",
+					children: [
+						"Add feedback to keep this ",
+						candidateKind,
+						" as an unsent annotation."
+					]
+				}),
+				workspace.candidate.anchor.kind === "video-time-rect" || workspace.candidate.anchor.kind === "video-time-point" ? /* @__PURE__ */ jsxs("p", {
+					className: "text-base text-doom-dim sm:text-sm",
+					children: [
+						"Frame at ",
+						workspace.candidate.anchor.timeSeconds.toFixed(3),
+						"s"
+					]
+				}) : null,
+				/* @__PURE__ */ jsx("textarea", {
+					"aria-label": "Annotation comment",
+					value: workspace.candidateText,
+					onChange: (event) => setAuthorCandidateText(sessionId, event.target.value),
+					placeholder: "What should change here?",
+					rows: 3,
+					className: "min-h-11 w-full resize-y rounded border border-doom-border bg-doom-deep p-2 text-lg leading-normal text-doom-text focus:border-doom-red focus:outline-none sm:text-sm"
+				}),
+				/* @__PURE__ */ jsx(Button, {
+					className: "min-h-11 min-w-11 text-base [@media(pointer:fine)]:min-h-8 sm:text-sm",
+					variant: "outline",
+					onClick: add,
+					disabled: !workspace.candidate || !workspace.candidateText.trim() || workspace.annotations.length >= 16,
+					children: "add annotation"
+				}),
+				/* @__PURE__ */ jsx(Button, {
+					variant: "ghost",
+					className: "min-h-11 min-w-11 text-base [@media(pointer:fine)]:min-h-8 sm:text-sm",
+					onClick: () => {
+						setAuthorRegionCandidate(sessionId, void 0);
+						setAuthorCandidateText(sessionId, "");
+						setError(void 0);
+					},
+					children: "Discard annotation"
+				})
+			] }) : null,
+			error ? /* @__PURE__ */ jsx("output", {
+				className: "block text-base text-doom-red",
+				children: error
+			}) : null,
+			workspace.annotations.length > 0 ? /* @__PURE__ */ jsxs("h3", {
+				className: "text-base font-semibold text-doom-text",
+				children: [
+					"Unsent annotations (",
+					workspace.annotations.length,
+					")"
+				]
+			}) : null,
+			/* @__PURE__ */ jsx("ol", {
+				className: "space-y-2",
+				children: workspace.annotations.map((region, index) => /* @__PURE__ */ jsxs("li", {
+					className: "rounded border border-doom-border bg-doom-panel p-2 text-base leading-normal text-doom-text sm:text-sm",
+					children: [
+						/* @__PURE__ */ jsxs("span", { children: [
+							"(",
+							index + 1,
+							") ",
+							region.mode === "point" ? "Point" : "Region",
+							": ",
+							region.comment
+						] }),
+						region.anchor.kind === "video-time-rect" || region.anchor.kind === "video-time-point" ? /* @__PURE__ */ jsxs(Button, {
+							variant: "outline",
+							className: "min-h-11 min-w-11 text-base [@media(pointer:fine)]:min-h-8 sm:text-sm",
+							disabled: workspace.candidate !== void 0,
+							onClick: () => {
+								if (region.anchor.kind === "video-time-rect" || region.anchor.kind === "video-time-point") seekAuthorVideo(sessionId, region.anchor.timeSeconds);
+							},
+							children: [
+								"Go to ",
+								region.anchor.timeSeconds.toFixed(3),
+								"s"
+							]
+						}) : null,
+						/* @__PURE__ */ jsx(Button, {
+							className: "min-h-11 min-w-11 text-base [@media(pointer:fine)]:min-h-8 sm:text-sm",
+							variant: "ghost",
+							"aria-label": `Remove annotation ${index + 1}`,
+							onClick: () => removeAuthorRegion(sessionId, region.id),
+							children: "remove"
+						})
+					]
+				}, region.id))
+			})
+		]
+	});
+}
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/dock/_components/AuthorRequestLog.tsx
+const STATUS_LABELS = {
+	REQUESTED: "Request queued",
+	CHANGING: "Agent working",
+	CHANGED: "Change ready",
+	COMPLETE: "Request completed",
+	FAILED: "Request failed",
+	CANCELLED: "Request cancelled"
+};
+const STATUS_STYLES = {
+	REQUESTED: "border-doom-yellow/35 bg-doom-yellow/5 text-doom-yellow",
+	CHANGING: "border-doom-magenta/45 bg-doom-magenta/10 text-doom-yellow",
+	CHANGED: "border-doom-cyan/40 bg-doom-cyan/5 text-doom-cyan",
+	COMPLETE: "border-doom-green/40 bg-doom-green/5 text-doom-green",
+	FAILED: "border-doom-red/45 bg-doom-red/10 text-doom-red",
+	CANCELLED: "border-doom-border bg-doom-panel text-doom-dim"
+};
+function requestInstruction(requestText) {
+	const referencedContext = requestText.search(/(?:^|\s+)Referenced context "/u);
+	return requestText.slice(0, referencedContext < 0 ? void 0 : referencedContext).replace(/^Please address the attached feedback\.\s*Request ID: \S+\s*/u, "").trim();
+}
+function documentName(path) {
+	return path.replaceAll("\\", "/").split("/").at(-1) || path;
+}
+function anchorLabel(anchor) {
+	switch (anchor.kind) {
+		case "text-range": return anchor.startLine === anchor.endLine ? `Line ${anchor.startLine}` : `Lines ${anchor.startLine}–${anchor.endLine}`;
+		case "cell": return [anchor.sheet, anchor.location].filter(Boolean).join(" · ");
+		case "slide-element": return `Slide ${anchor.slide} · ${anchor.location}`;
+		case "image-rect": return "Image region";
+		case "pdf-page-rect": return `Page ${anchor.page}`;
+		case "video-time-rect": return `Video ${Math.floor(anchor.timeSeconds / 60)}:${Math.floor(anchor.timeSeconds % 60).toString().padStart(2, "0")}`;
+		case "story-preview-rect": return `${anchor.preview.storyPath}#${anchor.preview.storyExport}`;
+		case "image-point": return "Image point";
+		case "pdf-page-point": return `Page ${anchor.page} point`;
+		case "video-time-point": return `Video ${Math.floor(anchor.timeSeconds / 60)}:${Math.floor(anchor.timeSeconds % 60).toString().padStart(2, "0")} point`;
+		case "story-preview-point": return `${anchor.preview.storyPath}#${anchor.preview.storyExport} point`;
+	}
+}
+function progressLabel(request) {
+	const total = request.regions.length;
+	const pending = request.pendingRegions?.length;
+	if (request.status === "CHANGING" && request.currentOperation === "Agent is working on this request") return "Processing request";
+	if (request.status === "CHANGING" && pending !== void 0) return `${total - pending} of ${total} annotations applied`;
+	if (request.status === "CHANGED") return "Changes applied · awaiting save";
+	if (request.status === "COMPLETE") return "Agent finished processing this request";
+	if (request.status === "FAILED") return "Stopped with an error";
+	if (request.status === "CANCELLED") return "Stopped before completion";
+	return `${total} annotation${total === 1 ? "" : "s"} queued`;
+}
+function RequestRecord({ request, prominent = false }) {
+	const instruction = requestInstruction(request.requestText);
+	return /* @__PURE__ */ jsxs("article", {
+		"data-testid": prominent ? "author-active-request" : void 0,
+		className: "space-y-3",
+		children: [
+			/* @__PURE__ */ jsxs("header", {
+				className: "border-b border-doom-border-soft pb-3",
+				children: [/* @__PURE__ */ jsx("p", {
+					className: "text-2xs font-bold tracking-widest text-doom-faint",
+					children: "DOCUMENT CONTEXT"
+				}), /* @__PURE__ */ jsxs("p", {
+					className: "mt-2 flex items-center gap-2 truncate text-base font-bold text-doom-hi",
+					children: [/* @__PURE__ */ jsx("span", {
+						"aria-hidden": true,
+						className: "text-doom-magenta",
+						children: "↗"
+					}), documentName(request.documentPath)]
+				})]
+			}),
+			/* @__PURE__ */ jsx("section", {
+				"aria-label": "Request locations",
+				className: "rounded border border-doom-border bg-doom-panel p-3",
+				children: /* @__PURE__ */ jsx("ol", {
+					className: "space-y-3",
+					children: request.regions.map((region, index) => /* @__PURE__ */ jsxs("li", {
+						className: "space-y-2",
+						children: [
+							/* @__PURE__ */ jsxs("p", {
+								className: "font-mono text-2xs font-bold uppercase tracking-wider text-doom-yellow",
+								children: [
+									"WHERE · ",
+									request.regions.length > 1 ? `${index + 1} · ` : "",
+									documentName(request.documentPath),
+									" / ",
+									anchorLabel(region.anchor),
+									" · rev ",
+									request.revision
+								]
+							}),
+							region.quote ? /* @__PURE__ */ jsxs("blockquote", {
+								className: "line-clamp-3 text-sm italic leading-relaxed text-doom-text",
+								children: [
+									"“",
+									region.quote,
+									"”"
+								]
+							}) : null,
+							/* @__PURE__ */ jsx("p", {
+								className: "text-xs leading-relaxed text-doom-dim",
+								children: region.comment
+							})
+						]
+					}, region.id))
+				})
+			}),
+			/* @__PURE__ */ jsxs("section", {
+				"data-testid": prominent ? "author-operation-card" : void 0,
+				className: `rounded border p-3 ${STATUS_STYLES[request.status]}`,
+				children: [
+					/* @__PURE__ */ jsxs("p", {
+						className: "font-mono text-xs font-bold tracking-wider",
+						children: [
+							"●",
+							" ",
+							request.status === "CHANGING" ? "WORKING" : request.status === "COMPLETE" ? "COMPLETED" : request.status === "FAILED" ? "ERROR" : request.status
+						]
+					}),
+					/* @__PURE__ */ jsx("p", {
+						className: "mt-2 text-sm leading-relaxed text-doom-hi",
+						children: request.currentOperation || STATUS_LABELS[request.status]
+					}),
+					request.error ? /* @__PURE__ */ jsx("p", {
+						className: "mt-2 text-xs leading-relaxed text-doom-red",
+						children: request.error
+					}) : null,
+					request.before !== void 0 || request.after !== void 0 ? /* @__PURE__ */ jsxs("details", {
+						className: "mt-2 border-t border-current/20 pt-2 text-xs text-doom-dim",
+						children: [
+							/* @__PURE__ */ jsx("summary", {
+								className: "cursor-pointer select-none",
+								children: "change preview"
+							}),
+							request.before !== void 0 ? /* @__PURE__ */ jsxs("pre", {
+								className: "mt-2 max-h-28 overflow-auto whitespace-pre-wrap break-words font-mono",
+								children: ["before: ", request.before]
+							}) : null,
+							request.after !== void 0 ? /* @__PURE__ */ jsxs("pre", {
+								className: "mt-2 max-h-28 overflow-auto whitespace-pre-wrap break-words font-mono",
+								children: ["after: ", request.after]
+							}) : null
+						]
+					}) : null
+				]
+			}),
+			/* @__PURE__ */ jsxs("section", {
+				className: "space-y-2",
+				children: [/* @__PURE__ */ jsx("p", {
+					className: "text-2xs font-bold tracking-widest text-doom-faint",
+					children: "REQUEST · HOW TO CHANGE"
+				}), /* @__PURE__ */ jsx("div", {
+					className: "rounded border border-doom-border bg-doom-deep p-3",
+					children: /* @__PURE__ */ jsx("p", {
+						className: "whitespace-pre-wrap text-sm leading-relaxed text-doom-text",
+						children: instruction || "No additional instruction."
+					})
+				})]
+			}),
+			/* @__PURE__ */ jsx("footer", {
+				className: "font-mono text-2xs text-doom-dim",
+				children: progressLabel(request)
+			})
+		]
+	});
+}
+function AuthorRequestLog({ requests }) {
+	const latest = requests.at(-1);
+	const earlier = requests.slice(0, -1).reverse();
+	return /* @__PURE__ */ jsxs("section", {
+		"data-testid": "author-request-history",
+		className: "space-y-3",
+		children: [
+			/* @__PURE__ */ jsx("h3", {
+				className: "text-2xs font-bold tracking-widest text-doom-faint",
+				children: "AUTHORING"
+			}),
+			latest === void 0 ? /* @__PURE__ */ jsx("p", {
+				className: "text-sm leading-relaxed text-doom-dim",
+				children: "No requests or changes yet."
+			}) : /* @__PURE__ */ jsx(RequestRecord, {
+				request: latest,
+				prominent: true
+			}),
+			earlier.length > 0 ? /* @__PURE__ */ jsxs("details", {
+				className: "border-t border-doom-border-soft pt-3",
+				"data-testid": "author-earlier-requests",
+				children: [/* @__PURE__ */ jsxs("summary", {
+					className: "cursor-pointer select-none text-2xs font-bold tracking-wider text-doom-faint",
+					children: [
+						"EARLIER REQUESTS (",
+						earlier.length,
+						")"
+					]
+				}), /* @__PURE__ */ jsx("ol", {
+					className: "mt-3 space-y-5",
+					children: earlier.map((request) => /* @__PURE__ */ jsx("li", { children: /* @__PURE__ */ jsx(RequestRecord, { request }) }, request.id))
+				})]
+			}) : null
+		]
+	});
+}
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/dock/_components/AuthorToolPalette.tsx
+function AuthorToolPalette({ sessionId, kind, activeTool }) {
+	const [error, setError] = useState();
+	const format = (style) => {
+		const selected = authorSessionWorkspace(sessionId).candidate;
+		const document = selected && authorDocument(sessionId, selected.documentPath);
+		if (!selected || !document || selected.anchor.kind !== "text-range" || selected.revision !== document.version || selected.sourceSha256 !== document.sourceSha256) {
+			setError("Select text in the document first.");
+			return;
+		}
+		const { startOffset, endOffset } = selected.anchor;
+		const content = document.content ?? "";
+		const text = content.slice(startOffset, endOffset);
+		const replacement = style === "Bold" ? `**${text}**` : style === "Link" ? `[${text}](https://)` : text.split("\n").map((line) => `${style === "Heading" ? "## " : "- "}${line}`).join("\n");
+		reviseAuthorDocument(sessionId, document.path, content.slice(0, startOffset) + replacement + content.slice(endOffset));
+		setAuthorRegionCandidate(sessionId, void 0);
+		setError(void 0);
+	};
+	const tools = [
+		{
+			label: "Region",
+			glyph: "⌗",
+			action: () => setAuthorToolMode(sessionId, activeTool === "mark" ? "select" : "mark"),
+			active: activeTool === "mark"
+		},
+		...kind === "markdown" ? [
+			{
+				label: "Bold",
+				glyph: "B",
+				action: () => format("Bold")
+			},
+			{
+				label: "Heading",
+				glyph: "H",
+				action: () => format("Heading")
+			},
+			{
+				label: "Link",
+				glyph: "↗",
+				action: () => format("Link")
+			},
+			{
+				label: "List",
+				glyph: "≡",
+				action: () => format("List")
+			}
+		] : [],
+		{
+			label: "Comment",
+			glyph: "●",
+			action: () => setAuthorToolMode(sessionId, activeTool === "comment" ? "select" : "comment"),
+			active: activeTool === "comment"
+		}
+	];
+	return /* @__PURE__ */ jsxs("section", {
+		"data-testid": "author-tool-palette",
+		className: "space-y-2 border-b border-doom-border-soft pb-3",
+		children: [
+			/* @__PURE__ */ jsxs("div", {
+				className: "flex justify-between text-sm text-doom-dim",
+				children: [/* @__PURE__ */ jsx("h3", {
+					className: "font-bold tracking-widest",
+					children: "TOOLS"
+				}), /* @__PURE__ */ jsx("span", { children: "focused tab" })]
+			}),
+			/* @__PURE__ */ jsx("div", {
+				className: "grid grid-cols-3 gap-1.5",
+				children: tools.map((tool) => /* @__PURE__ */ jsxs(Button, {
+					size: "md",
+					variant: "outline",
+					"aria-label": tool.label === "Region" ? "mark region" : tool.label,
+					"aria-pressed": tool.active,
+					onClick: tool.action,
+					className: `min-h-11 min-w-11 gap-1.5 rounded border text-base [@media(pointer:fine)]:min-h-8 sm:text-sm ${tool.active ? "border-doom-red bg-doom-red/10 text-doom-red hover:bg-doom-red/15" : "border-doom-border bg-doom-panel text-doom-dim"}`,
+					children: [/* @__PURE__ */ jsx("span", {
+						"aria-hidden": "true",
+						children: tool.glyph
+					}), tool.label]
+				}, tool.label))
+			}),
+			/* @__PURE__ */ jsx("p", {
+				className: "text-base leading-normal text-doom-dim sm:text-sm",
+				children: activeTool === "mark" ? "Drag over the document to mark a region." : activeTool === "comment" ? "Click the document to place a comment pin." : "Choose Region to drag an area, or Comment to place a point."
+			}),
+			error ? /* @__PURE__ */ jsx("output", {
+				className: "block text-base text-doom-red",
+				children: error
+			}) : null
+		]
+	});
+}
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/dock/_components/AuthorPanel.tsx
+function AuthorPanel({ sessionId, activeMinorModes, submitCapture, statuses, renderSlot, renderSessionActivity }) {
+	const [captureStatus, setCaptureStatus] = useState();
+	const [capturing, setCapturing] = useState(false);
+	const documents = useStore(authorWorkspace.store, (state) => {
+		if (sessionId === null) return [];
+		const prefix = `${sessionId}\n`;
+		return Object.entries(state.documents).filter(([key]) => key.startsWith(prefix)).map(([, document]) => document);
+	});
+	const workspace = useStore(authorWorkspace.store, (state) => sessionId === null ? void 0 : state.sessions[sessionId]);
+	const grid = useStore(authorGrid.store, (state) => sessionId === null ? void 0 : state.sessions[sessionId]);
+	const focused = documents.find((document) => document.path === workspace?.focusedDocument?.path);
+	const activity = sessionId === null ? null : renderSessionActivity?.() ?? null;
+	if (!activeMinorModes?.includes("author")) return null;
+	return /* @__PURE__ */ jsxs("section", {
+		"data-testid": "author-panel",
+		className: "flex min-h-0 flex-1 flex-col overflow-hidden",
+		children: [/* @__PURE__ */ jsx("div", {
+			className: "min-h-0 flex-1 overflow-y-auto p-3",
+			children: /* @__PURE__ */ jsxs("div", {
+				className: "flex flex-col gap-2",
+				children: [
+					/* @__PURE__ */ jsx("div", {
+						"data-testid": "author-preview-providers",
+						children: renderSlot("author.preview-provider")
+					}),
+					sessionId !== null && workspace !== void 0 && focused !== void 0 ? /* @__PURE__ */ jsxs(Fragment, { children: [
+						/* @__PURE__ */ jsx("h2", {
+							className: "text-base font-semibold text-doom-text",
+							children: "Annotations"
+						}),
+						/* @__PURE__ */ jsx("p", {
+							className: "text-base leading-normal text-doom-dim sm:text-sm",
+							children: "Drag a region or place a point, add feedback, then submit here. Requests queue while the agent is working."
+						}),
+						focused.kind === "video" ? /* @__PURE__ */ jsx("p", {
+							className: "text-base text-doom-dim sm:text-sm",
+							children: "Annotations reference video frames. They do not save changes to the source video."
+						}) : null,
+						/* @__PURE__ */ jsx(AuthorToolPalette, {
+							sessionId,
+							kind: focused.kind,
+							activeTool: workspace.activeTool
+						}),
+						autonomousVoiceGridVisible(statuses) && grid !== void 0 ? /* @__PURE__ */ jsxs("div", {
+							"data-testid": "author-grid-snapshot",
+							className: "rounded border border-doom-red/40 bg-doom-red/5 p-2 text-base text-doom-dim",
+							children: [/* @__PURE__ */ jsx("strong", {
+								className: "text-doom-red",
+								children: "VOICE GRID A1–H8"
+							}), /* @__PURE__ */ jsxs("p", {
+								className: "mt-1 truncate",
+								children: ["token ", grid.geometryToken]
+							})]
+						}) : null,
+						/* @__PURE__ */ jsx(AuthorRegionDrafts, {
+							sessionId,
+							workspace
+						}, focused.path),
+						workspace.annotations.length > 0 ? /* @__PURE__ */ jsxs("div", {
+							className: "space-y-1.5 border-b border-doom-border-soft pb-3",
+							children: [/* @__PURE__ */ jsx(Button, {
+								className: "min-h-11 min-w-11 w-full text-base [@media(pointer:fine)]:min-h-8 sm:text-sm",
+								variant: "outline",
+								"data-testid": "author-attach-capture",
+								disabled: capturing || workspace.candidate !== void 0 || submitCapture === void 0,
+								onClick: async () => {
+									if (capturing || workspace.candidate || submitCapture === void 0) return;
+									setCapturing(true);
+									setCaptureStatus("Submitting annotations…");
+									try {
+										const packet = createAuthorCapturePacket(crypto.randomUUID(), Date.now(), focused, workspace.annotations);
+										await submitCapture({
+											...await multiRegionCaptureProvider(workspace.annotations).capture(),
+											context: authorCaptureContext(packet)
+										});
+										setCaptureStatus("Request submitted. You can keep annotating here.");
+									} catch (reason) {
+										setCaptureStatus(reason instanceof Error ? reason.message : String(reason));
+									} finally {
+										setCapturing(false);
+									}
+								},
+								children: capturing ? "Submitting…" : `Submit ${workspace.annotations.length} annotation${workspace.annotations.length === 1 ? "" : "s"}`
+							}), workspace.candidate ? /* @__PURE__ */ jsx("p", {
+								className: "text-base text-doom-dim sm:text-sm",
+								children: "Add or discard the current annotation before submitting."
+							}) : null]
+						}) : null,
+						submitCapture === void 0 ? /* @__PURE__ */ jsx("output", {
+							className: "text-sm text-doom-red",
+							children: "Submission unavailable. Reload to update the app."
+						}) : null,
+						captureStatus ? /* @__PURE__ */ jsx("output", {
+							className: "block text-sm text-doom-dim",
+							children: captureStatus
+						}) : null
+					] }) : null,
+					/* @__PURE__ */ jsx(AuthorRequestLog, { requests: workspace?.requests ?? [] })
+				]
+			})
+		}), activity === null ? null : /* @__PURE__ */ jsx("footer", {
+			"data-testid": "author-session-activity",
+			className: "shrink-0 border-t border-doom-border bg-doom-rail p-3",
+			children: activity
+		})]
+	});
+}
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/dock/authoring.web.tsx
+var authoring_web_default = defineDockFace({
+	id: "authoring",
+	label: "authoring",
+	order: 30,
+	autoSelect: true,
+	panel: AuthorPanel,
+	requiredMinorMode: "author",
+	visibility: {
+		subscribe() {
+			return () => void 0;
+		},
+		isVisible(sessionId) {
+			return sessionId !== null;
+		}
+	}
+});
+//#endregion
+//#region src/types/authorPreview.ts
+function parseAuthorPreviewAction(input) {
+	if (typeof input !== "object" || input === null) return null;
+	const candidate = input;
+	if (candidate.version !== 1 || typeof candidate.label !== "string" || candidate.label.trim() === "") return null;
+	if (candidate.detail !== void 0 && typeof candidate.detail !== "string") return null;
+	if (typeof candidate.createTab !== "function") return null;
+	if (candidate.supportsSource !== void 0 && typeof candidate.supportsSource !== "function") return null;
+	if (candidate.embeddedPanel !== void 0 && typeof candidate.embeddedPanel !== "function") return null;
+	return candidate;
+}
+const authorPreviewActionSlot = {
+	slot: "author.preview-action",
+	parse: parseAuthorPreviewAction
+};
+//#endregion
+//#region src/types/apiRoutes.ts
+/**
+* This package's routes, as data.
+*
+* No scope and no base path. The build reads both off
+* `src/extensions/workspaces/sessions/(backend)/api/author/`, so the mount is
+* stated once, by the folder that creates it. The browser used to restate it:
+* `authorStateUrl` built one URL from `API_BASE_PATH` and the document helper
+* two files away spelled `author` out again as a literal, so the two could
+* disagree and nothing would say so.
+*
+* The order below is the order the three Hono apps register in: `/state` in
+* `authorApi`, the eight bridge routes in `authorBridgeApi`, the three document
+* routes in `authorDocumentApi`. A reviewer can read the two side by side.
+*
+* Response types are named only where a caller reads the body. The bridge
+* routes are called by the hub's author channel over `requestSessionApi`, which
+* has its own message vocabulary and never sees this client.
+*/
+var apiRoutes_default = defineApiRoutes({
+	state: {
+		method: "GET",
+		path: "/state",
+		response: apiResponse()
+	},
+	bridgeRegister: {
+		method: "POST",
+		path: "/bridge/register"
+	},
+	bridgeCatalog: {
+		method: "POST",
+		path: "/bridge/catalog"
+	},
+	/** Long-polls for the next capability request, so it settles when one arrives. */
+	bridgeNext: {
+		method: "POST",
+		path: "/bridge/next"
+	},
+	bridgeResult: {
+		method: "POST",
+		path: "/bridge/result"
+	},
+	bridgeCancelled: {
+		method: "POST",
+		path: "/bridge/cancelled"
+	},
+	bridgeDisconnect: {
+		method: "POST",
+		path: "/bridge/disconnect"
+	},
+	bridgeDescribe: {
+		method: "GET",
+		path: "/bridge/describe"
+	},
+	bridgeInvoke: {
+		method: "POST",
+		path: "/bridge/invoke"
+	},
+	/**
+	* Parses one structured document.
+	*
+	* Answers a byte-length summary instead when the request names no format,
+	* which is the agent-side tool path; the page always names one.
+	*/
+	documentsOpen: {
+		method: "POST",
+		path: "/documents/open",
+		query: ["session"],
+		response: apiResponse()
+	},
+	documentsPreflight: {
+		method: "POST",
+		path: "/documents/preflight",
+		query: ["session"],
+		response: apiResponse()
+	},
+	documentsSerialize: {
+		method: "POST",
+		path: "/documents/serialize",
+		query: ["session"],
+		response: apiResponse()
+	},
+	/**
+	* The host's own bytes route, not this package's.
+	*
+	* `host: true` hangs it off the session root rather than under `/plugins`,
+	* which is how the cockpit already serves it. Author reads a document's
+	* bytes and its digest through it, and writes the edited bytes back to the
+	* same path, so both stay raw transfers rather than calls: the body is the
+	* file and the digest travels in a header.
+	*/
+	file: {
+		method: "GET",
+		path: "/file",
+		query: ["path"],
+		host: true
+	}
+});
+const api = createApiClient(apiRoutes_default, {
+	scopes: ["session"],
+	basePath: "author",
+	transport: (input, init) => sealedTransport.fetch(input, init),
+	sessionAddress: sessionApiAddress
+});
+//#endregion
+//#region src/types/authorApi.ts
+/** Query parameter naming the session a document request belongs to. */
+const SESSION_QUERY_PARAM = "session";
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/_lib/authorFiles.ts
+const IMAGE_EXTENSIONS = /* @__PURE__ */ new Set([
+	"avif",
+	"bmp",
+	"gif",
+	"jpeg",
+	"jpg",
+	"png",
+	"svg",
+	"webp"
+]);
+const VIDEO_EXTENSIONS = /* @__PURE__ */ new Set([
+	"m4v",
+	"mov",
+	"mp4",
+	"webm"
+]);
+function structuredFormat(path) {
+	const lower = path.toLowerCase();
+	if (lower.endsWith(".slides.md")) return "markdown-slides";
+	if (lower.endsWith(".csv")) return "csv";
+	if (lower.endsWith(".pptx")) return "pptx";
+	if (lower.endsWith(".xlsx")) return "xlsx";
+}
+function authorKindForPath(path) {
+	const lower = path.toLowerCase();
+	if (/\.stories\.(?:js|jsx|ts|tsx)$/u.test(lower)) return "story-preview";
+	const format = structuredFormat(path);
+	if (format === "markdown-slides") return "slides";
+	if (format !== void 0) return format;
+	const extension = lower.split(".").at(-1) ?? "";
+	if (extension === "md") return "markdown";
+	if (IMAGE_EXTENSIONS.has(extension)) return "image";
+	if (VIDEO_EXTENSIONS.has(extension)) return "video";
+	if (extension === "pdf") return "pdf";
+	if ([
+		"txt",
+		"json",
+		"yaml",
+		"yml",
+		"xml",
+		"html",
+		"css",
+		"js",
+		"ts",
+		"tsx",
+		"jsx"
+	].includes(extension)) return "text";
+	return "opaque";
+}
+/**
+* Where a document's bytes are read from and written back to.
+*
+* This is the host's route, not this package's, which is why the route table
+* marks it `host: true` and it lands beside the session rather than under
+* `/plugins`. It stays a raw transfer rather than a call: the body is the file
+* itself, and the digest travels in a header on both legs.
+*/
+function authorSessionFileUrl(sessionId, path) {
+	return api.session(sessionId).file.url({ query: { path } });
+}
+/** One document route, with the refusal the reader is shown: the route's own words, or its status. */
+async function documentRequest(method, sessionId, body, signal) {
+	const result = await method({
+		body,
+		query: { [SESSION_QUERY_PARAM]: sessionId },
+		...signal === void 0 ? {} : { signal }
+	});
+	if (!result.ok) throw new Error(result.error === "" ? `Author document API failed (${result.status})` : result.error);
+	return result.data;
+}
+async function loadAuthorDocument(sessionId, path, signal) {
+	const kind = authorKindForPath(path);
+	const url = authorSessionFileUrl(sessionId, path);
+	const response = await sealedTransport.fetch(url, { signal });
+	if (!response.ok) throw new Error(`Author could not open ${path} (${response.status})`);
+	const sourceSha256 = response.headers.get("X-File-SHA256") ?? void 0;
+	const format = structuredFormat(path);
+	if (format !== void 0) {
+		const parsed = await documentRequest(api.session(sessionId).documentsOpen, sessionId, {
+			path,
+			format
+		}, signal);
+		const parsedDigest = parsed.manifest?.sourceDigest;
+		if (sourceSha256 !== void 0 && parsedDigest !== void 0 && sourceSha256 !== parsedDigest) throw new Error("Document source changed while opening. Reopen the document.");
+		const csvDialect = format === "csv" ? csvDialectFromMetadata(parsed.manifest?.metadata) : void 0;
+		return {
+			path,
+			kind,
+			title: path.split("/").at(-1) ?? path,
+			structuredFormat: format,
+			fragments: parsed.fragments,
+			...csvDialect === void 0 ? {} : { csvDialect },
+			originalFragments: parsed.fragments.map((fragment) => ({ ...fragment })),
+			...sourceSha256 === void 0 ? {} : { sourceSha256 }
+		};
+	}
+	const mediaUrl = kind === "image" || kind === "video" || kind === "pdf" || kind === "opaque" ? url : void 0;
+	const content = kind === "text" || kind === "markdown" || kind === "story-preview" ? await response.text() : void 0;
+	return {
+		path,
+		kind,
+		title: path.split("/").at(-1) ?? path,
+		...content === void 0 ? {} : { content },
+		...mediaUrl === void 0 ? {} : { mediaUrl },
+		...sourceSha256 === void 0 ? {} : { sourceSha256 }
+	};
+}
+function operationsFor(document) {
+	const originals = new Map((document.originalFragments ?? []).map((fragment) => [fragment.id, fragment.text]));
+	return (document.fragments ?? []).filter((fragment) => !fragment.readOnly && originals.get(fragment.id) !== fragment.text).map((fragment) => ({
+		fragmentId: fragment.id,
+		replacement: fragment.text
+	}));
+}
+function decodeBase64(value) {
+	if (!/^(?:[A-Za-z\d+/]{4})*(?:[A-Za-z\d+/]{2}==|[A-Za-z\d+/]{3}=)?$/.test(value)) throw new Error("Invalid serialized document bytes.");
+	const binary = atob(value);
+	return Uint8Array.from(binary, (character) => character.charCodeAt(0));
+}
+function imageMimeType(path) {
+	const extension = path.split(".").at(-1)?.toLowerCase();
+	if (extension === "png") return "image/png";
+	if (extension === "jpg" || extension === "jpeg") return "image/jpeg";
+	if (extension === "webp") return "image/webp";
+}
+async function croppedImageBytes(documentInput, signal) {
+	const { crop, mediaUrl } = documentInput;
+	if (crop === void 0 || mediaUrl === void 0) throw new Error("This Author image has no crop source.");
+	const mimeType = imageMimeType(documentInput.path);
+	if (mimeType === void 0) throw new Error("This image format cannot preserve its encoding after crop.");
+	const response = await sealedTransport.fetch(mediaUrl, {
+		signal,
+		cache: "no-store"
+	});
+	if (!response.ok) throw new Error(`Author could not read the image before saving (${response.status})`);
+	const bitmap = await createImageBitmap(await response.blob());
+	try {
+		const sourceX = Math.round(crop.x * bitmap.width);
+		const sourceY = Math.round(crop.y * bitmap.height);
+		const sourceWidth = Math.max(1, Math.round(crop.width * bitmap.width));
+		const sourceHeight = Math.max(1, Math.round(crop.height * bitmap.height));
+		const canvas = window.document.createElement("canvas");
+		canvas.width = sourceWidth;
+		canvas.height = sourceHeight;
+		const context = canvas.getContext("2d");
+		if (context === null) throw new Error("Canvas is unavailable for image crop.");
+		context.drawImage(bitmap, sourceX, sourceY, sourceWidth, sourceHeight, 0, 0, sourceWidth, sourceHeight);
+		const blob = await new Promise((resolve) => canvas.toBlob(resolve, mimeType));
+		if (blob === null || blob.type !== mimeType) throw new Error("The browser cannot encode this cropped image format.");
+		return blob;
+	} finally {
+		bitmap.close();
+	}
+}
+async function bytesToSave(sessionId, document, signal) {
+	if (document.kind === "text" || document.kind === "markdown" || document.kind === "story-preview") return document.content ?? "";
+	if (document.kind === "image" && document.crop !== void 0) return await croppedImageBytes(document, signal);
+	if (document.structuredFormat === void 0) throw new Error("This Author view cannot be saved.");
+	const operations = operationsFor(document);
+	const request = {
+		path: document.path,
+		format: document.structuredFormat,
+		operations,
+		...document.csvDialect === void 0 ? {} : { csvDialect: document.csvDialect }
+	};
+	const preflight = await documentRequest(api.session(sessionId).documentsPreflight, sessionId, request, signal);
+	if (preflight.sourceDigest !== void 0 && preflight.sourceDigest !== document.sourceSha256) throw new Error("Document source changed before saving. Reopen the document.");
+	if (!preflight.accepted) throw new Error(preflight.issues.map((issue) => issue.message).join("\n") || "Author preflight rejected the edit.");
+	const serialized = await documentRequest(api.session(sessionId).documentsSerialize, sessionId, {
+		...request,
+		preflightDigest: preflight.digest
+	}, signal);
+	if (serialized.encoding !== "base64") throw new Error("Author serialize returned an unsupported encoding.");
+	const bytes = decodeBase64(serialized.bytes);
+	return bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
+}
+async function saveAuthorDocument(sessionId, document, signal) {
+	if (document.sourceSha256 === void 0) throw new Error("This Author view has no source digest.");
+	const response = await sealedTransport.fetch(authorSessionFileUrl(sessionId, document.path), {
+		method: "PUT",
+		headers: {
+			"Content-Type": "application/octet-stream",
+			"X-Expected-SHA256": document.sourceSha256
+		},
+		body: await bytesToSave(sessionId, document, signal),
+		signal
+	});
+	if (!response.ok) throw new Error(`Author save failed (${response.status})`);
+	const sha256 = response.headers.get("X-File-SHA256");
+	if (sha256 === null || !/^[a-f0-9]{64}$/.test(sha256)) throw new Error("Author save returned an invalid digest.");
+	return sha256;
+}
+function csvDialectFromMetadata(metadata) {
+	if (metadata === void 0) return void 0;
+	const { delimiter, quote, recordDelimiter } = metadata;
+	if (delimiter !== "," && delimiter !== ";" && delimiter !== "	" && delimiter !== "|" || quote !== "\"" && quote !== "'" || recordDelimiter !== "\n" && recordDelimiter !== "\r\n") throw new Error("Author document API returned an invalid CSV dialect.");
+	return {
+		delimiter,
+		quote,
+		recordDelimiter
+	};
+}
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/_lib/authorGridTools.ts
+const stringProperty = {
+	type: "string",
+	minLength: 1
+};
+function inputRecord(input) {
+	if (typeof input !== "object" || input === null || Array.isArray(input)) throw new Error("Expected an object.");
+	return input;
+}
+function requiredString(value, name) {
+	if (typeof value[name] !== "string" || value[name] === "") throw new Error(`${name} must be a non-empty string.`);
+	return value[name];
+}
+function resolvedAnchor(sessionId, path, kind, cell) {
+	if (authorDocument(sessionId, path) === void 0) throw new Error("STALE_DOCUMENT: The focused Author document is no longer open.");
+	if (kind === "pdf" || kind === "video" || kind === "opaque") throw new Error("UNSUPPORTED_GRID: PDF and video coordinates are capture-only and require a visible native selection.");
+	return resolveAuthorGridNativeAnchor(sessionId, cell);
+}
+function checkedRegion(sessionId, path, value) {
+	const document = authorDocument(sessionId, path);
+	if (document === void 0) throw new Error("STALE_DOCUMENT: The Author document is no longer open.");
+	if (document.savingVersion !== void 0) throw new Error("SAVE_IN_PROGRESS: Wait for the current Author save to finish.");
+	const expectedRevision = value.expectedRevision;
+	const expectedSourceSha256 = requiredString(value, "expectedSourceSha256");
+	if (expectedRevision !== document.version || expectedSourceSha256 !== document.sourceSha256) throw new Error("STALE_DOCUMENT: The Author revision or source digest changed.");
+	const regionId = requiredString(value, "regionId");
+	const workspace = authorSessionWorkspace(sessionId);
+	const region = workspace.regions.find((candidate) => candidate.id === regionId) ?? workspace.requests.filter((request) => request.status === "REQUESTED" || request.status === "CHANGING").flatMap((request) => request.pendingRegions ?? request.regions).find((candidate) => candidate.id === regionId);
+	if (region === void 0 || region.documentPath !== path) throw new Error("STALE_REGION: The resolved Author region is unavailable.");
+	if (region.revision !== document.version || region.sourceSha256 !== document.sourceSha256) throw new Error("STALE_REGION: The resolved Author region no longer matches the document.");
+	return {
+		document,
+		region
+	};
+}
+function gridTools(sessionId, path, kind) {
+	return [{
+		name: "author_describe_grid",
+		label: "Describe grid",
+		description: "Describe the current A1 through H8 grid and return its geometry token.",
+		inputSchema: {
+			type: "object",
+			additionalProperties: false,
+			properties: {}
+		},
+		execute: async () => {
+			const geometry = authorGridGeometry(sessionId);
+			const document = authorDocument(sessionId, path);
+			if (geometry === void 0 || document === void 0 || geometry.documentPath !== path || geometry.revision !== document.version) throw new Error("STALE_GRID: The visible Author grid is unavailable.");
+			return {
+				columns: "A-H",
+				rows: "1-8",
+				...geometry
+			};
+		}
+	}, {
+		name: "author_resolve_grid_cell",
+		label: "Resolve grid cell",
+		description: "Resolve one current grid cell to a native document anchor before mutation.",
+		inputSchema: {
+			type: "object",
+			additionalProperties: false,
+			required: [
+				"cell",
+				"geometryToken",
+				"instruction"
+			],
+			properties: {
+				cell: stringProperty,
+				geometryToken: stringProperty,
+				instruction: stringProperty
+			}
+		},
+		execute: async (input) => {
+			const value = inputRecord(input);
+			const instruction = requiredString(value, "instruction");
+			const cell = resolveAuthorGridCell(sessionId, requiredString(value, "cell"), requiredString(value, "geometryToken"));
+			const geometry = authorGridGeometry(sessionId);
+			const resolved = resolvedAnchor(sessionId, path, kind, cell);
+			const regionId = crypto.randomUUID();
+			const createdAt = Date.now();
+			const region = {
+				id: regionId,
+				documentPath: path,
+				revision: geometry.revision,
+				sourceSha256: geometry.sourceSha256,
+				comment: instruction,
+				...resolved,
+				viewport: { ...geometry.viewport },
+				voiceGrid: cell.evidence,
+				createdAt
+			};
+			addAuthorRegion(sessionId, region);
+			putAuthorRequest(sessionId, {
+				id: `voice:${regionId}`,
+				documentPath: path,
+				requestText: instruction,
+				regions: [region],
+				pendingRegions: [region],
+				status: "REQUESTED",
+				createdAt,
+				updatedAt: createdAt,
+				revision: geometry.revision,
+				sourceSha256: geometry.sourceSha256
+			});
+			return {
+				regionId,
+				anchor: resolved.anchor,
+				quote: resolved.quote,
+				evidence: cell.evidence
+			};
+		}
+	}];
+}
+function assertRebasable(pending, changed) {
+	const remaining = pending.filter((region) => region.id !== changed.id);
+	if (changed.anchor.kind === "image-rect" && remaining.length > 0) throw new Error("UNSUPPORTED_REGION: A multi-region image request cannot apply more than one crop.");
+	if (changed.anchor.kind !== "text-range") return;
+	for (const region of remaining) {
+		if (region.anchor.kind !== "text-range") continue;
+		if (!(region.anchor.endOffset <= changed.anchor.startOffset || region.anchor.startOffset >= changed.anchor.endOffset)) throw new Error("AMBIGUOUS_REGION: Submitted text regions overlap and cannot be safely rebased.");
+	}
+}
+function lineAtOffset(content, offset) {
+	return content.slice(0, Math.max(0, offset)).split("\n").length;
+}
+function rebasePendingRegions(pending, changed, result, nextContent) {
+	return pending.filter((region) => region.id !== changed.id).map((region) => {
+		if (changed.anchor.kind !== "text-range" || region.anchor.kind !== "text-range" || nextContent === void 0) return {
+			...region,
+			revision: result.revision
+		};
+		const delta = (result.after?.length ?? 0) - (result.before?.length ?? 0);
+		const shift = region.anchor.startOffset >= changed.anchor.endOffset ? delta : 0;
+		const startOffset = region.anchor.startOffset + shift;
+		const endOffset = region.anchor.endOffset + shift;
+		return {
+			...region,
+			revision: result.revision,
+			anchor: {
+				...region.anchor,
+				startOffset,
+				endOffset,
+				startLine: lineAtOffset(nextContent, startOffset),
+				endLine: lineAtOffset(nextContent, endOffset)
+			}
+		};
+	});
+}
+function mutationTool(sessionId, path, kind) {
+	if (kind === "pdf" || kind === "video" || kind === "opaque") return void 0;
+	const needsReplacement = kind !== "image";
+	return {
+		name: "author_apply_region",
+		label: "Apply region change",
+		description: "Apply a fenced mutation through a previously resolved native Author region.",
+		inputSchema: {
+			type: "object",
+			additionalProperties: false,
+			required: [
+				"regionId",
+				"expectedRevision",
+				"expectedSourceSha256",
+				...needsReplacement ? ["replacement"] : []
+			],
+			properties: {
+				regionId: stringProperty,
+				expectedRevision: {
+					type: "integer",
+					minimum: 0
+				},
+				expectedSourceSha256: stringProperty,
+				...needsReplacement ? { replacement: { type: "string" } } : {}
+			}
+		},
+		execute: async (input, signal) => {
+			const value = inputRecord(input);
+			const regionId = requiredString(value, "regionId");
+			const request = authorSessionWorkspace(sessionId).requests.find((candidate) => (candidate.pendingRegions ?? candidate.regions).some((item) => item.id === regionId) && candidate.status === "REQUESTED");
+			if (request !== void 0) updateAuthorRequest(sessionId, request.id, (current) => ({
+				...current,
+				status: "CHANGING",
+				currentOperation: "validating native anchor",
+				updatedAt: Date.now()
+			}));
+			try {
+				if (signal.aborted) throw signal.reason instanceof Error ? signal.reason : /* @__PURE__ */ new Error("Author mutation cancelled.");
+				const { document, region } = checkedRegion(sessionId, path, value);
+				const pending = request?.pendingRegions ?? request?.regions ?? [region];
+				assertRebasable(pending, region);
+				if (request !== void 0) updateAuthorRequest(sessionId, request.id, (current) => ({
+					...current,
+					currentOperation: `mutating ${region.anchor.kind}`,
+					updatedAt: Date.now()
+				}));
+				let result;
+				let nextContent;
+				if (region.anchor.kind === "text-range") {
+					const replacement = typeof value.replacement === "string" ? value.replacement : "";
+					const { startOffset, endOffset } = region.anchor;
+					const content = document.content ?? "";
+					const before = content.slice(startOffset, endOffset);
+					nextContent = content.slice(0, startOffset) + replacement + content.slice(endOffset);
+					reviseAuthorDocument(sessionId, path, nextContent);
+					result = {
+						changed: true,
+						before,
+						after: replacement,
+						revision: document.version + 1
+					};
+				} else if (region.anchor.kind === "cell" || region.anchor.kind === "slide-element") {
+					const fragmentId = region.anchor.fragmentId;
+					const fragment = document.fragments?.find((candidate) => candidate.id === fragmentId);
+					if (fragment === void 0 || fragment.readOnly === true) throw new Error("UNSUPPORTED_REGION: The native fragment is not editable.");
+					const replacement = typeof value.replacement === "string" ? value.replacement : "";
+					reviseAuthorFragment(sessionId, path, fragment.id, replacement);
+					result = {
+						changed: true,
+						before: fragment.text,
+						after: replacement,
+						revision: document.version + 1
+					};
+				} else if (region.anchor.kind === "image-rect") {
+					setAuthorCrop(sessionId, path, region.anchor.rect);
+					result = {
+						changed: true,
+						crop: region.anchor.rect,
+						revision: document.version + 1
+					};
+				} else throw new Error("UNSUPPORTED_REGION: PDF and video regions are capture-only.");
+				if (request !== void 0) {
+					const pendingRegions = rebasePendingRegions(pending, region, result, nextContent);
+					updateAuthorRequest(sessionId, request.id, (current) => ({
+						...current,
+						status: pendingRegions.length === 0 ? "CHANGED" : "REQUESTED",
+						currentOperation: void 0,
+						before: [current.before, result.before].filter((item) => item !== void 0).join("\n") || void 0,
+						after: [current.after, result.after ?? (result.crop === void 0 ? void 0 : JSON.stringify(result.crop))].filter((item) => item !== void 0).join("\n") || void 0,
+						pendingRegions,
+						revision: result.revision,
+						updatedAt: Date.now()
+					}));
+				}
+				return result;
+			} catch (error) {
+				if (request !== void 0) updateAuthorRequest(sessionId, request.id, (current) => ({
+					...current,
+					status: signal.aborted ? "CANCELLED" : "FAILED",
+					currentOperation: void 0,
+					error: signal.aborted ? "Author mutation cancelled." : error instanceof Error ? error.message : String(error),
+					updatedAt: Date.now()
+				}));
+				throw error;
+			}
+		}
+	};
+}
+function authorGridTools(sessionId, path, kind) {
+	const mutation = mutationTool(sessionId, path, kind);
+	return [...gridTools(sessionId, path, kind), ...mutation === void 0 ? [] : [mutation]];
+}
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/_lib/authorProfiles.ts
+function record(input) {
+	if (typeof input !== "object" || input === null || Array.isArray(input)) throw new Error("Expected an object");
+	return input;
+}
+function text(value, field) {
+	if (typeof value !== "string") throw new Error(`${field} must be a string`);
+	return value;
+}
+function target(input) {
+	const value = record(input);
+	return {
+		sessionId: text(value.sessionId, "sessionId"),
+		path: text(value.path, "path"),
+		value
+	};
+}
+const TARGET_PROPERTIES = {
+	sessionId: {
+		type: "string",
+		minLength: 1
+	},
+	path: {
+		type: "string",
+		minLength: 1
+	}
+};
+const AUTHOR_TEXT_PROFILE = {
+	id: AUTHOR_RUNTIME_BINDING_IDS.text,
+	tools: [{
+		name: "author_add_comment",
+		label: "Add comment",
+		description: "Add a local review comment to one open Author document.",
+		inputSchema: {
+			type: "object",
+			additionalProperties: false,
+			required: [
+				"sessionId",
+				"path",
+				"body"
+			],
+			properties: {
+				...TARGET_PROPERTIES,
+				body: { type: "string" },
+				quote: { type: "string" }
+			}
+		},
+		execute: async (input) => {
+			const { sessionId, path, value } = target(input);
+			const body = text(value.body, "body");
+			addAuthorAnnotation(sessionId, path, {
+				id: `${Date.now()}:${body.length}`,
+				kind: "comment",
+				body,
+				...typeof value.quote === "string" ? { quote: value.quote } : {}
+			});
+			return { added: true };
+		}
+	}, {
+		name: "author_add_highlight",
+		label: "Add highlight",
+		description: "Highlight a line range in one open Author text document.",
+		inputSchema: {
+			type: "object",
+			additionalProperties: false,
+			required: [
+				"sessionId",
+				"path",
+				"startLine",
+				"endLine"
+			],
+			properties: {
+				...TARGET_PROPERTIES,
+				startLine: {
+					type: "integer",
+					minimum: 1
+				},
+				endLine: {
+					type: "integer",
+					minimum: 1
+				}
+			}
+		},
+		execute: async (input) => {
+			const { sessionId, path, value } = target(input);
+			if (!Number.isSafeInteger(value.startLine) || !Number.isSafeInteger(value.endLine)) throw new Error("Highlight lines must be integers");
+			const startLine = value.startLine;
+			const endLine = value.endLine;
+			if (startLine < 1 || endLine < startLine) throw new Error("Invalid highlight range");
+			addAuthorAnnotation(sessionId, path, {
+				id: `${Date.now()}:${startLine}:${endLine}`,
+				kind: "highlight",
+				body: "",
+				startLine,
+				endLine
+			});
+			return { added: true };
+		}
+	}]
+};
+const AUTHOR_MEDIA_PROFILE = {
+	id: AUTHOR_RUNTIME_BINDING_IDS.media,
+	tools: []
+};
+function bindProfile(profile, sessionId, path) {
+	return {
+		id: profile.id,
+		tools: profile.tools.map((tool) => {
+			const schema = tool.inputSchema;
+			const { sessionId: _sessionId, path: _path, ...boundProperties } = record(schema.properties);
+			const required = Array.isArray(schema.required) ? schema.required.filter((entry) => entry !== "sessionId" && entry !== "path") : [];
+			return {
+				...tool,
+				inputSchema: {
+					...schema,
+					properties: boundProperties,
+					required
+				},
+				execute: async (input, signal) => await tool.execute({
+					...record(input),
+					sessionId,
+					path
+				}, signal)
+			};
+		})
+	};
+}
+function authorProfilesForDocument(sessionId, path, kind) {
+	const profiles = kind === "image" ? [bindProfile(AUTHOR_MEDIA_PROFILE, sessionId, path)] : kind === "text" || kind === "markdown" ? [bindProfile(AUTHOR_TEXT_PROFILE, sessionId, path)] : [];
+	const tools = authorGridTools(sessionId, path, kind);
+	if (tools.length === 0) return profiles;
+	return profiles.length === 0 ? [{
+		id: AUTHOR_RUNTIME_BINDING_IDS.media,
+		tools
+	}] : [{
+		...profiles[0],
+		tools: [...profiles[0].tools, ...tools]
+	}];
+}
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/_lib/authorMedia.ts
+/**
+* Native media elements cannot perform the remote session's encrypted HTTP exchange.
+*
+* `source` addresses the host's own session file route, which the route table
+* declares as `file` with `host: true`; this package serves no bytes of its
+* own. The transport stays raw because what comes back is a blob, and a call
+* through the generated client reads the body as JSON to report a refusal.
+*/
+async function loadAuthorMedia(source, signal) {
+	const response = await sealedTransport.fetch(source, {
+		signal,
+		cache: "no-store"
+	});
+	if (!response.ok) throw new Error(`Author media could not be loaded (${response.status}).`);
+	const blob = await response.blob();
+	signal.throwIfAborted();
+	const url = URL.createObjectURL(blob);
+	let disposed = false;
+	return {
+		url,
+		dispose() {
+			if (disposed) return;
+			disposed = true;
+			URL.revokeObjectURL(url);
+		}
+	};
+}
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/_lib/authorRegions.ts
+/** Clamp a drag to the source element, including drags made in reverse. */
+function normalizedAuthorRectangle(bounds, drag) {
+	const width = bounds.right - bounds.left;
+	const height = bounds.bottom - bounds.top;
+	if (![...Object.values(bounds), ...Object.values(drag)].every(Number.isFinite) || width <= 0 || height <= 0) return null;
+	const left = Math.max(bounds.left, Math.min(drag.left, drag.right));
+	const right = Math.min(bounds.right, Math.max(drag.left, drag.right));
+	const top = Math.max(bounds.top, Math.min(drag.top, drag.bottom));
+	const bottom = Math.min(bounds.bottom, Math.max(drag.top, drag.bottom));
+	if (right <= left || bottom <= top) return null;
+	return {
+		x: (left - bounds.left) / width,
+		y: (top - bounds.top) / height,
+		width: (right - left) / width,
+		height: (bottom - top) / height
+	};
+}
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/_components/AuthorVideoControls.tsx
+function videoTimeLabel(seconds) {
+	const milliseconds = Math.max(0, Math.round((Number.isFinite(seconds) ? seconds : 0) * 1e3));
+	return `${String(Math.floor(milliseconds / 6e4)).padStart(2, "0")}:${String(Math.floor(milliseconds / 1e3) % 60).padStart(2, "0")}.${String(milliseconds % 1e3).padStart(3, "0")}`;
+}
+function AuthorVideoControls({ playback, ready, locked, marking, onSeek, onToggle, onAnnotate }) {
+	const [seconds, setSeconds] = useState("");
+	const duration = playback.duration;
+	const invalid = seconds.trim() === "" || !Number.isFinite(Number(seconds)) || Number(seconds) < 0 || Number(seconds) > duration;
+	const buttonClass = "min-h-11 px-3 text-base [@media(pointer:fine)]:min-h-8 sm:text-sm";
+	return /* @__PURE__ */ jsxs("section", {
+		"aria-label": "Video annotation controls",
+		className: "mt-2 space-y-2 rounded border border-doom-border bg-doom-panel p-2.5 text-base text-doom-text sm:text-sm",
+		children: [
+			/* @__PURE__ */ jsxs("div", {
+				className: "flex flex-wrap items-center justify-between gap-3",
+				children: [/* @__PURE__ */ jsxs("output", {
+					"aria-label": "Playback position",
+					className: "font-mono text-base tabular-nums",
+					children: [
+						videoTimeLabel(playback.currentTime),
+						" / ",
+						videoTimeLabel(duration)
+					]
+				}), /* @__PURE__ */ jsx("span", {
+					className: "text-doom-dim",
+					children: locked ? "Annotation draft: add or discard it before seeking." : marking ? "Frame paused. Drag a region on the video." : "Seek to a moment, then choose Annotate this frame."
+				})]
+			}),
+			/* @__PURE__ */ jsx("input", {
+				"aria-label": "Video timeline",
+				type: "range",
+				min: 0,
+				max: duration || 0,
+				step: .001,
+				value: Math.min(playback.currentTime, duration),
+				disabled: locked || duration <= 0,
+				onChange: (event) => onSeek(Number(event.target.value)),
+				className: "h-11 w-full cursor-pointer accent-doom-blue [@media(pointer:fine)]:h-6"
+			}),
+			/* @__PURE__ */ jsxs("div", {
+				className: "flex flex-wrap items-center gap-2",
+				children: [
+					/* @__PURE__ */ jsx(Button, {
+						className: buttonClass,
+						disabled: locked || duration <= 0,
+						onClick: onToggle,
+						children: playback.playing ? "Pause" : "Play"
+					}),
+					/* @__PURE__ */ jsx(Button, {
+						className: buttonClass,
+						disabled: locked || duration <= 0,
+						onClick: () => onSeek(Math.max(0, playback.currentTime - .1)),
+						"aria-label": "Seek back 0.1 seconds",
+						children: "−0.1s"
+					}),
+					/* @__PURE__ */ jsx(Button, {
+						className: buttonClass,
+						disabled: locked || duration <= 0,
+						onClick: () => onSeek(Math.min(duration, playback.currentTime + .1)),
+						"aria-label": "Seek forward 0.1 seconds",
+						children: "+0.1s"
+					}),
+					/* @__PURE__ */ jsx(Button, {
+						variant: "primary",
+						className: buttonClass,
+						disabled: locked || !ready,
+						onClick: onAnnotate,
+						children: "Annotate this frame"
+					}),
+					/* @__PURE__ */ jsxs("form", {
+						className: "flex flex-wrap items-center gap-2 sm:ml-auto",
+						onSubmit: (event) => {
+							event.preventDefault();
+							if (!invalid && !locked) onSeek(Number(seconds));
+						},
+						children: [
+							/* @__PURE__ */ jsx("label", {
+								htmlFor: "author-video-seconds",
+								className: "text-doom-dim",
+								children: "Go to seconds"
+							}),
+							/* @__PURE__ */ jsx("input", {
+								id: "author-video-seconds",
+								type: "number",
+								min: 0,
+								max: duration,
+								step: .001,
+								value: seconds,
+								onChange: (event) => setSeconds(event.target.value),
+								disabled: locked || duration <= 0,
+								placeholder: "1.250",
+								className: "h-11 w-24 rounded border border-doom-border bg-doom-deep px-2 text-lg [@media(pointer:fine)]:h-8 sm:text-sm"
+							}),
+							/* @__PURE__ */ jsx(Button, {
+								type: "submit",
+								className: buttonClass,
+								disabled: locked || duration <= 0 || invalid,
+								children: "Go"
+							})
+						]
+					})
+				]
+			})
+		]
+	});
+}
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/_components/AuthorMediaView.tsx
+/** Marks source media. Native playback and page controls remain usable in select mode. */
+function AuthorMediaView({ sessionId, document: source, activeTool, displayedRegions, pendingCandidate = false, seekRequest }) {
+	const host = useRef(null);
+	const image = useRef(null);
+	const video = useRef(null);
+	const pdf = useRef(null);
+	const start = useRef(void 0);
+	const [playback, setPlayback] = useState({
+		playing: false,
+		currentTime: 0,
+		duration: 0
+	});
+	const [frameReady, setFrameReady] = useState(false);
+	const [selection, setSelection] = useState();
+	const [error, setError] = useState();
+	const [media, setMedia] = useState();
+	const mediaUrl = media?.source === source.mediaUrl ? media?.url : void 0;
+	useEffect(() => {
+		if (source.mediaUrl === void 0) return;
+		const input = source.mediaUrl;
+		const controller = new AbortController();
+		let dispose;
+		setError(void 0);
+		loadAuthorMedia(input, controller.signal).then((asset) => {
+			if (controller.signal.aborted) {
+				asset.dispose();
+				return;
+			}
+			dispose = () => asset.dispose();
+			setMedia({
+				source: input,
+				url: asset.url
+			});
+		}).catch((cause) => {
+			if (!controller.signal.aborted) setError(cause instanceof Error ? cause.message : String(cause));
+		});
+		return () => {
+			controller.abort();
+			dispose?.();
+		};
+	}, [source.mediaUrl]);
+	const seek = (seconds) => {
+		if (authorSessionWorkspace(sessionId).candidate || !Number.isFinite(seconds)) return;
+		const player = video.current;
+		if (!player) return;
+		player.pause();
+		setAuthorToolMode(sessionId, "select");
+		setSelection(void 0);
+		if (player.getState().currentTime === seconds) return;
+		setFrameReady(false);
+		player.seek(seconds);
+	};
+	useEffect(() => {
+		if (seekRequest?.path === source.path && seekRequest.generation === authorSessionWorkspace(sessionId).focusedDocument?.generation) seek(seekRequest.timeSeconds);
+	}, [seekRequest]);
+	useEffect(() => {
+		if (!pendingCandidate && start.current === void 0) setSelection(void 0);
+	}, [pendingCandidate]);
+	useEffect(() => registerAuthorGridResolver(sessionId, (cell, geometry) => {
+		const target = image.current;
+		if (source.kind !== "image" || target === null || target.naturalWidth === 0 || target.naturalHeight === 0) return void 0;
+		const { originX = 0, originY = 0, width, height } = geometry.viewport;
+		const cellBounds = {
+			left: originX + cell.rect.x * width,
+			top: originY + cell.rect.y * height,
+			right: originX + (cell.rect.x + cell.rect.width) * width,
+			bottom: originY + (cell.rect.y + cell.rect.height) * height
+		};
+		const bounds = target.getBoundingClientRect();
+		const left = Math.max(bounds.left, cellBounds.left);
+		const top = Math.max(bounds.top, cellBounds.top);
+		const right = Math.min(bounds.right, cellBounds.right);
+		const bottom = Math.min(bounds.bottom, cellBounds.bottom);
+		if (right <= left || bottom <= top || bounds.width <= 0 || bounds.height <= 0) return void 0;
+		return { anchor: {
+			kind: "image-rect",
+			rect: {
+				x: (left - bounds.left) / bounds.width,
+				y: (top - bounds.top) / bounds.height,
+				width: (right - left) / bounds.width,
+				height: (bottom - top) / bounds.height
+			},
+			naturalWidth: target.naturalWidth,
+			naturalHeight: target.naturalHeight
+		} };
+	}), [
+		sessionId,
+		source.kind,
+		source.path,
+		source.version
+	]);
+	const mark = async (event) => {
+		const drag = start.current;
+		start.current = void 0;
+		if (!drag) return;
+		const bounds = drag.element.getBoundingClientRect();
+		if (bounds.width <= 0 || bounds.height <= 0) return;
+		const point = {
+			x: Math.min(1, Math.max(0, (event.clientX - bounds.left) / bounds.width)),
+			y: Math.min(1, Math.max(0, (event.clientY - bounds.top) / bounds.height))
+		};
+		const rect = drag.mode === "mark" ? normalizedAuthorRectangle(bounds, {
+			left: drag.x,
+			top: drag.y,
+			right: event.clientX,
+			bottom: event.clientY
+		}) : void 0;
+		if (drag.mode === "mark" && !rect) return;
+		setSelection(drag.mode === "mark" ? {
+			path: source.path,
+			rect
+		} : {
+			path: source.path,
+			point
+		});
+		const focused = authorSessionWorkspace(sessionId).focusedDocument;
+		if (!focused || focused.path !== source.path) return;
+		let anchor;
+		let blob = null;
+		let thumbnailUrl;
+		try {
+			if (drag.element instanceof HTMLImageElement) {
+				const image = drag.element;
+				if (!image.naturalWidth || !image.naturalHeight) throw new Error("Image is not ready.");
+				anchor = drag.mode === "mark" ? {
+					kind: "image-rect",
+					rect,
+					naturalWidth: image.naturalWidth,
+					naturalHeight: image.naturalHeight
+				} : {
+					kind: "image-point",
+					point,
+					naturalWidth: image.naturalWidth,
+					naturalHeight: image.naturalHeight
+				};
+				const canvas = document.createElement("canvas");
+				const scale = Math.min(1, 1600 / Math.max(image.naturalWidth, image.naturalHeight));
+				canvas.width = Math.max(1, Math.round(image.naturalWidth * scale));
+				canvas.height = Math.max(1, Math.round(image.naturalHeight * scale));
+				const context = canvas.getContext("2d");
+				if (!context) throw new Error("Canvas is unavailable.");
+				context.drawImage(image, 0, 0, canvas.width, canvas.height);
+				blob = await new Promise((resolve) => canvas.toBlob(resolve, "image/png"));
+			} else if (source.kind === "pdf") {
+				const page = pdf.current?.getState();
+				if (!page?.sourceWidth) throw new Error("PDF page is not ready.");
+				anchor = drag.mode === "mark" ? {
+					kind: "pdf-page-rect",
+					page: page.page,
+					rect
+				} : {
+					kind: "pdf-page-point",
+					page: page.page,
+					point
+				};
+				blob = await pdf.current.capturePage();
+			} else {
+				const frame = await video.current?.captureFrame();
+				if (!frame) throw new Error("Video frame is not ready.");
+				anchor = drag.mode === "mark" ? {
+					kind: "video-time-rect",
+					rect,
+					timeSeconds: frame.timeSeconds,
+					intrinsicWidth: frame.width,
+					intrinsicHeight: frame.height
+				} : {
+					kind: "video-time-point",
+					point,
+					timeSeconds: frame.timeSeconds,
+					intrinsicWidth: frame.width,
+					intrinsicHeight: frame.height
+				};
+				blob = frame.blob;
+			}
+			if (!blob) throw new Error("Unable to capture selected media.");
+			if (authorSessionWorkspace(sessionId).focusedDocument?.generation !== focused.generation) return;
+			thumbnailUrl = URL.createObjectURL(blob);
+			setAuthorRegionCandidate(sessionId, {
+				documentPath: source.path,
+				revision: source.version,
+				sourceSha256: source.sourceSha256,
+				mode: drag.mode === "mark" ? "region" : "point",
+				anchor,
+				viewport: {
+					width: bounds.width,
+					height: bounds.height
+				},
+				thumbnailUrl,
+				evidence: blob,
+				createdAt: Date.now()
+			});
+			setError(void 0);
+		} catch (reason) {
+			if (thumbnailUrl) URL.revokeObjectURL(thumbnailUrl);
+			setError(reason instanceof Error ? reason.message : String(reason));
+		}
+	};
+	const selected = selection?.path === source.path ? selection.rect : void 0;
+	const selectedPoint = selection?.path === source.path ? selection.point : void 0;
+	const selectionOverlay = selected === void 0 ? null : /* @__PURE__ */ jsx("div", {
+		"data-testid": "author-media-selection",
+		className: "pointer-events-none absolute border-2 border-doom-red bg-doom-red/10",
+		style: {
+			left: `${selected.x * 100}%`,
+			top: `${selected.y * 100}%`,
+			width: `${selected.width * 100}%`,
+			height: `${selected.height * 100}%`
+		}
+	});
+	const pointPin = (ordinal, point, key) => /* @__PURE__ */ jsx("span", {
+		"data-author-point": ordinal,
+		"data-testid": ordinal === void 0 ? "author-media-point-selection" : void 0,
+		className: `pointer-events-none absolute z-10 flex h-5 min-w-5 -translate-x-1/2 -translate-y-1/2 items-center justify-center rounded-full border-2 px-1 text-2xs font-bold ${ordinal === void 0 ? "border-white bg-doom-red text-white" : "border-doom-deep bg-doom-yellow text-doom-deep"}`,
+		style: {
+			left: `${String(point.x * 100)}%`,
+			top: `${String(point.y * 100)}%`
+		},
+		children: ordinal ?? "•"
+	}, key);
+	const pointSelectionOverlay = selectedPoint === void 0 ? null : pointPin(void 0, selectedPoint, "selection");
+	return /* @__PURE__ */ jsxs("div", {
+		ref: host,
+		className: "min-h-0 flex-1 overflow-auto p-4",
+		style: {
+			touchAction: activeTool === "select" ? "auto" : "none",
+			cursor: activeTool === "select" ? void 0 : "crosshair"
+		},
+		onPointerMove: (event) => {
+			const drag = start.current;
+			if (drag === void 0 || drag.mode !== "mark") return;
+			const rect = normalizedAuthorRectangle(drag.element.getBoundingClientRect(), {
+				left: drag.x,
+				top: drag.y,
+				right: event.clientX,
+				bottom: event.clientY
+			});
+			setSelection(rect === null ? void 0 : {
+				path: source.path,
+				rect
+			});
+		},
+		onPointerDownCapture: (event) => {
+			if (activeTool !== "mark" && activeTool !== "comment" || event.button !== 0 || pendingCandidate) return;
+			const element = event.target;
+			if (!(element instanceof HTMLImageElement || element instanceof HTMLVideoElement || element instanceof HTMLCanvasElement)) return;
+			event.preventDefault();
+			setSelection(void 0);
+			if (element instanceof HTMLVideoElement) {
+				if (video.current?.isFrameReady?.() === false) {
+					setError("Wait for the selected frame to finish loading.");
+					return;
+				}
+				video.current?.pause();
+			}
+			start.current = {
+				x: event.clientX,
+				y: event.clientY,
+				mode: activeTool,
+				element
+			};
+			event.currentTarget.setPointerCapture(event.pointerId);
+		},
+		onPointerUp: (event) => void mark(event),
+		onPointerCancel: () => {
+			start.current = void 0;
+			setSelection(void 0);
+		},
+		children: [
+			mediaUrl === void 0 ? /* @__PURE__ */ jsx("p", {
+				className: "text-doom-dim",
+				children: error === void 0 ? "Loading media..." : "Media unavailable."
+			}) : source.kind === "image" ? /* @__PURE__ */ jsxs("div", {
+				className: "relative inline-block max-w-full",
+				children: [
+					/* @__PURE__ */ jsx("img", {
+						ref: image,
+						src: mediaUrl,
+						alt: source.path,
+						draggable: false,
+						className: "block max-w-full"
+					}),
+					selectionOverlay,
+					pointSelectionOverlay,
+					displayedRegions.flatMap(({ ordinal, region }) => {
+						if (region.anchor.kind === "image-point") return [pointPin(ordinal, region.anchor.point, region.id)];
+						if (region.anchor.kind !== "image-rect") return [];
+						const { rect } = region.anchor;
+						return [/* @__PURE__ */ jsx("div", {
+							"data-author-region": ordinal,
+							className: "pointer-events-none absolute border border-doom-yellow bg-doom-yellow/10",
+							style: {
+								left: `${String(rect.x * 100)}%`,
+								top: `${String(rect.y * 100)}%`,
+								width: `${String(rect.width * 100)}%`,
+								height: `${String(rect.height * 100)}%`
+							},
+							children: /* @__PURE__ */ jsx("span", {
+								className: "absolute -left-2 -top-2 flex h-4 min-w-4 items-center justify-center rounded-full bg-doom-yellow px-1 text-2xs font-bold text-doom-deep",
+								children: ordinal
+							})
+						}, region.id)];
+					})
+				]
+			}) : /* @__PURE__ */ jsxs("div", {
+				className: "relative w-fit max-w-full",
+				children: [
+					/* @__PURE__ */ jsx(MediaPreview, {
+						src: mediaUrl,
+						path: source.path,
+						kind: source.kind === "pdf" ? "pdf" : source.kind === "video" ? "video" : "download",
+						controllerRef: video,
+						pdfControllerRef: pdf,
+						"data-testid": "author-media",
+						videoControls: false,
+						onPlaybackStateChange: (state) => {
+							setPlayback(state);
+							setFrameReady(video.current?.isFrameReady() ?? false);
+							if (state.playing) setSelection(void 0);
+						}
+					}),
+					selectionOverlay,
+					pointSelectionOverlay,
+					displayedRegions.map(({ ordinal, region }) => {
+						if (source.kind === "pdf") {
+							if (region.anchor.kind !== "pdf-page-point" && region.anchor.kind !== "pdf-page-rect") return null;
+							if (region.anchor.page !== pdf.current?.getState().page) return null;
+							if (region.anchor.kind === "pdf-page-point") return pointPin(ordinal, region.anchor.point, region.id);
+							const { rect } = region.anchor;
+							return /* @__PURE__ */ jsx("div", {
+								"data-author-region": ordinal,
+								className: "pointer-events-none absolute border border-doom-yellow bg-doom-yellow/10",
+								style: {
+									left: `${String(rect.x * 100)}%`,
+									top: `${String(rect.y * 100)}%`,
+									width: `${String(rect.width * 100)}%`,
+									height: `${String(rect.height * 100)}%`
+								},
+								children: /* @__PURE__ */ jsx("span", {
+									className: "bg-doom-yellow text-doom-deep",
+									children: ordinal
+								})
+							}, region.id);
+						}
+						if (source.kind !== "video" || playback.playing) return null;
+						if (region.anchor.kind === "video-time-point" && Math.abs(region.anchor.timeSeconds - playback.currentTime) <= .1) return pointPin(ordinal, region.anchor.point, region.id);
+						if (region.anchor.kind !== "video-time-rect" || Math.abs(region.anchor.timeSeconds - playback.currentTime) > .1) return null;
+						const { rect } = region.anchor;
+						return /* @__PURE__ */ jsx("div", {
+							"data-author-region": ordinal,
+							className: "pointer-events-none absolute border border-doom-yellow bg-doom-yellow/10",
+							style: {
+								left: `${rect.x * 100}%`,
+								top: `${rect.y * 100}%`,
+								width: `${rect.width * 100}%`,
+								height: `${rect.height * 100}%`
+							},
+							children: /* @__PURE__ */ jsx("span", {
+								className: "bg-doom-yellow text-doom-deep",
+								children: ordinal
+							})
+						}, region.id);
+					})
+				]
+			}),
+			source.kind === "video" ? /* @__PURE__ */ jsx(AuthorVideoControls, {
+				playback,
+				ready: frameReady,
+				locked: pendingCandidate,
+				marking: activeTool === "mark",
+				onSeek: seek,
+				onToggle: () => {
+					setAuthorToolMode(sessionId, "select");
+					setSelection(void 0);
+					if (playback.playing) video.current?.pause();
+					else video.current?.play().catch((reason) => setError(String(reason)));
+				},
+				onAnnotate: () => {
+					video.current?.pause();
+					setAuthorToolMode(sessionId, "mark");
+				}
+			}) : null,
+			error ? /* @__PURE__ */ jsx("output", {
+				className: "text-base text-doom-red",
+				children: error
+			}) : null
+		]
+	});
+}
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/_components/AuthorStructuredView.tsx
+function AuthorStructuredView({ sessionId, document, displayedRegions }) {
+	useEffect(() => registerAuthorGridResolver(sessionId, (cell, geometry) => {
+		const { originX = 0, originY = 0, width, height } = geometry.viewport;
+		const fragmentId = window.document.elementFromPoint(originX + cell.center.x * width, originY + cell.center.y * height)?.closest("[data-author-fragment]")?.dataset.authorFragment;
+		const fragment = document.fragments?.find((candidate) => candidate.id === fragmentId);
+		if (fragment === void 0 || fragment.readOnly === true) return void 0;
+		if (document.kind === "csv" || document.kind === "xlsx") return {
+			anchor: {
+				kind: "cell",
+				fragmentId: fragment.id,
+				location: fragment.location
+			},
+			quote: fragment.text
+		};
+		const slide = Number(fragment.location.match(/(?:slide\s*|slides\/slide)(\d+)/u)?.[1]);
+		if (!Number.isSafeInteger(slide)) return void 0;
+		return {
+			anchor: {
+				kind: "slide-element",
+				fragmentId: fragment.id,
+				location: fragment.location,
+				slide
+			},
+			quote: fragment.text
+		};
+	}), [
+		document.fragments,
+		document.kind,
+		document.version,
+		sessionId
+	]);
+	const displayedByFragment = new Map(displayedRegions.flatMap(({ ordinal, region }) => region.anchor.kind === "cell" || region.anchor.kind === "slide-element" ? [[region.anchor.fragmentId, ordinal]] : []));
+	const cells = document.kind === "csv" || document.kind === "xlsx";
+	const groups = /* @__PURE__ */ new Map();
+	for (const fragment of document.fragments ?? []) {
+		const key = cells ? document.kind === "csv" ? fragment.location.split(",")[0] : fragment.location.replace(/![A-Z]+(\d+)$/, "!row $1") : fragment.location;
+		const group = groups.get(key) ?? [];
+		group.push(fragment);
+		groups.set(key, group);
+	}
+	return /* @__PURE__ */ jsxs("div", {
+		"data-testid": "author-structured",
+		className: "min-h-0 flex-1 space-y-3 overflow-auto p-4",
+		children: [!cells ? /* @__PURE__ */ jsx("p", {
+			className: "text-xs text-doom-faint",
+			children: "Slide text view, not a layout-faithful rendering."
+		}) : null, [...groups].map(([location, fragments]) => /* @__PURE__ */ jsxs("section", {
+			className: "space-y-1",
+			children: [/* @__PURE__ */ jsx("h3", {
+				className: "text-xs text-doom-faint",
+				children: location
+			}), /* @__PURE__ */ jsx("div", {
+				className: cells ? "flex gap-1" : "space-y-2",
+				children: fragments.map((fragment) => /* @__PURE__ */ jsxs("div", {
+					"data-author-fragment": fragment.id,
+					"data-author-region": displayedByFragment.get(fragment.id),
+					className: `${cells ? "w-40 shrink-0" : ""} relative rounded ${displayedByFragment.has(fragment.id) ? "ring-1 ring-doom-yellow" : ""}`,
+					children: [
+						displayedByFragment.has(fragment.id) ? /* @__PURE__ */ jsx("span", {
+							className: "absolute -left-1 -top-1 z-10 flex h-4 min-w-4 items-center justify-center rounded-full bg-doom-yellow px-1 text-2xs font-bold text-doom-deep",
+							children: displayedByFragment.get(fragment.id)
+						}) : null,
+						/* @__PURE__ */ jsxs(Button, {
+							size: "xs",
+							variant: "ghost",
+							onClick: (event) => {
+								const bounds = event.currentTarget.getBoundingClientRect();
+								const slide = Number(fragment.location.match(/(?:slide\s*|slides\/slide)(\d+)/)?.[1]);
+								if (!cells && !Number.isSafeInteger(slide)) return;
+								setAuthorRegionCandidate(sessionId, {
+									documentPath: document.path,
+									revision: document.version,
+									sourceSha256: document.sourceSha256,
+									quote: fragment.text,
+									anchor: cells ? {
+										kind: "cell",
+										fragmentId: fragment.id,
+										location: fragment.location
+									} : {
+										kind: "slide-element",
+										fragmentId: fragment.id,
+										location: fragment.location,
+										slide
+									},
+									viewport: {
+										width: bounds.width,
+										height: bounds.height
+									},
+									createdAt: Date.now()
+								});
+							},
+							children: ["mark ", fragment.location]
+						}),
+						/* @__PURE__ */ jsx("textarea", {
+							"aria-label": fragment.location,
+							value: fragment.text,
+							readOnly: fragment.readOnly === true,
+							className: "w-full rounded border border-doom-border bg-doom-deep p-2 text-sm text-doom-text",
+							onChange: (event) => reviseAuthorFragment(sessionId, document.path, fragment.id, event.target.value)
+						})
+					]
+				}, fragment.id))
+			})]
+		}, location))]
+	});
+}
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/_components/AuthorTextView.tsx
+function AuthorTextView({ sessionId, document, preview, displayedRegions }) {
+	const host = useRef(null);
+	const editor = useRef(null);
+	useEffect(() => registerAuthorGridResolver(sessionId, (cell, geometry) => {
+		if (preview || editor.current === null) return void 0;
+		const { originX = 0, originY = 0, width, height } = geometry.viewport;
+		const range = editor.current.resolveViewportRegion({
+			left: originX + cell.rect.x * width,
+			top: originY + cell.rect.y * height,
+			right: originX + (cell.rect.x + cell.rect.width) * width,
+			bottom: originY + (cell.rect.y + cell.rect.height) * height
+		});
+		if (range === null || range.from === range.to) return void 0;
+		return {
+			anchor: {
+				kind: "text-range",
+				startOffset: range.from,
+				endOffset: range.to,
+				startLine: range.startLine,
+				endLine: range.endLine
+			},
+			quote: range.text
+		};
+	}), [preview, sessionId]);
+	useEffect(() => {
+		editor.current?.setMarkedRanges(displayedRegions.flatMap(({ ordinal, region }) => region.anchor.kind === "text-range" ? [{
+			from: region.anchor.startOffset,
+			to: region.anchor.endOffset,
+			label: String(ordinal)
+		}] : []));
+	}, [displayedRegions]);
+	return /* @__PURE__ */ jsx("div", {
+		ref: host,
+		className: "flex min-h-0 flex-1 flex-col",
+		children: preview ? /* @__PURE__ */ jsx("div", {
+			"data-testid": "author-markdown",
+			className: "min-h-0 flex-1 overflow-auto p-4 text-sm text-doom-text",
+			children: /* @__PURE__ */ jsx(Markdown, { text: document.content ?? "" })
+		}) : /* @__PURE__ */ jsx(CodeEditor, {
+			value: document.content ?? "",
+			path: document.path,
+			"data-testid": "author-editor",
+			controllerRef: editor,
+			className: "min-h-0 flex-1",
+			onChange: (content) => reviseAuthorDocument(sessionId, document.path, content),
+			onSelect: (range) => {
+				const current = authorDocument(sessionId, document.path);
+				const bounds = host.current?.getBoundingClientRect();
+				if (!current || !bounds || range.from === range.to) return;
+				setAuthorRegionCandidate(sessionId, {
+					documentPath: current.path,
+					revision: current.version,
+					sourceSha256: current.sourceSha256,
+					quote: range.text,
+					anchor: {
+						kind: "text-range",
+						startOffset: range.from,
+						endOffset: range.to,
+						startLine: range.startLine,
+						endLine: range.endLine
+					},
+					viewport: {
+						width: bounds.width,
+						height: bounds.height
+					},
+					createdAt: Date.now()
+				});
+			}
+		})
+	});
+}
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/_components/AuthorDocumentPanel.tsx
+function tabId(path) {
+	let hash = 2166136261;
+	for (const char of normalizeAuthorPath(path)) hash = Math.imul(hash ^ char.charCodeAt(0), 16777619);
+	return `author-file-${(hash >>> 0).toString(36)}`;
+}
+function displayedAuthorRegions(workspace) {
+	const draftRegions = workspace?.regions ?? [];
+	if (draftRegions.length > 0) return draftRegions.map((region, index) => ({
+		ordinal: index + 1,
+		region
+	}));
+	const activeRequest = workspace?.requests.slice().reverse().find((request) => request.status === "REQUESTED" || request.status === "CHANGING");
+	return (activeRequest?.pendingRegions ?? []).map((region) => ({
+		ordinal: Math.max(1, (activeRequest?.regions.findIndex((original) => original.id === region.id) ?? 0) + 1),
+		region
+	}));
+}
+function AuthorDocumentPanel(props) {
+	if (!props.activeMinorModes?.includes("author")) {
+		const fallback = props.fileTabFor(props.path);
+		if (fallback !== void 0 && fallback.id !== tabId(props.path)) return /* @__PURE__ */ jsx(fallback.panel, { ...props });
+		return /* @__PURE__ */ jsx("p", {
+			"data-testid": "author-mode-inactive",
+			className: "p-3 text-sm text-doom-dim",
+			children: "No file viewer is available for this path."
+		});
+	}
+	return /* @__PURE__ */ jsx(ActiveAuthorDocumentPanel, { ...props });
+}
+function ActiveAuthorDocumentPanel(props) {
+	const { path, sessionId, statuses } = props;
+	const document = useStore(authorWorkspace.store, (state) => sessionId === null ? void 0 : state.documents[authorDocumentKey(sessionId, path)]);
+	const focusGeneration = useRef(void 0);
+	const workspace = useStore(authorWorkspace.store, (state) => sessionId === null ? void 0 : state.sessions[sessionId]);
+	const activeTool = workspace?.activeTool ?? "select";
+	const [markdownPreview, setMarkdownPreview] = useState(true);
+	const [status, setStatus] = useState();
+	const [previewOpen, setPreviewOpen] = useState(false);
+	const kind = document?.kind;
+	const previewSource = document === void 0 ? void 0 : {
+		path: document.path,
+		kind: document.kind,
+		hasUnsavedChanges: document.version !== document.savedVersion,
+		revision: document.savedVersion,
+		sourceSha256: document.sourceSha256
+	};
+	const PreviewPanel = (previewSource === void 0 ? void 0 : (props.slotData?.(authorPreviewActionSlot) ?? []).find(({ data }) => data.embeddedPanel !== void 0 && (data.supportsSource === void 0 || data.supportsSource(previewSource))))?.data.embeddedPanel;
+	useEffect(() => {
+		if (document !== void 0 || sessionId === null) return;
+		const controller = new AbortController();
+		setStatus("loading");
+		loadAuthorDocument(sessionId, path, controller.signal).then((loaded) => {
+			if (controller.signal.aborted) return;
+			putAuthorDocument(sessionId, loaded);
+			setStatus(void 0);
+		}).catch((error) => {
+			if (!controller.signal.aborted) setStatus(error instanceof Error ? error.message : String(error));
+		});
+		return () => controller.abort();
+	}, [
+		document,
+		path,
+		sessionId
+	]);
+	useEffect(() => {
+		if (document === void 0 || sessionId === null) return;
+		const generation = focusAuthorDocument(sessionId, path, document.version, document.sourceSha256);
+		focusGeneration.current = generation;
+		return () => releaseAuthorDocumentFocus(sessionId, generation);
+	}, [
+		kind,
+		document?.sourceSha256,
+		path,
+		sessionId
+	]);
+	useEffect(() => {
+		const generation = focusGeneration.current;
+		if (document === void 0 || sessionId === null || generation === void 0) return;
+		syncAuthorDocumentFocus(sessionId, generation, document.version, document.sourceSha256);
+	}, [
+		document?.sourceSha256,
+		document?.version,
+		sessionId
+	]);
+	useEffect(() => {
+		if (kind === void 0 || sessionId === null) return;
+		const profiles = authorProfilesForDocument(sessionId, path, kind);
+		let release;
+		let cancelled = false;
+		focusAuthorViewport(sessionId, profiles).then((nextRelease) => {
+			if (cancelled) nextRelease();
+			else release = nextRelease;
+		});
+		return () => {
+			cancelled = true;
+			release?.();
+		};
+	}, [
+		kind,
+		path,
+		sessionId
+	]);
+	if (document === void 0 || sessionId === null) return /* @__PURE__ */ jsx("p", {
+		className: "p-4 text-sm text-doom-faint",
+		children: status ?? "Loading document..."
+	});
+	const save = async () => {
+		const savedVersion = document.version;
+		const savedFragments = document.fragments;
+		requestAuthorSave(sessionId, path);
+		setStatus("saving");
+		try {
+			const sha256 = await saveAuthorDocument(sessionId, document);
+			completeAuthorSave(sessionId, path, sha256, savedVersion, savedFragments);
+			setStatus("saved");
+		} catch (error) {
+			failAuthorSave(sessionId, path, savedVersion);
+			setStatus(error instanceof Error ? error.message : String(error));
+		}
+	};
+	const gridVisible = autonomousVoiceGridVisible(statuses);
+	const displayedRegions = displayedAuthorRegions(workspace);
+	const displayedPreviewAnnotations = displayedRegions.flatMap(({ ordinal, region }) => {
+		if (region.anchor.kind === "story-preview-rect") return [{
+			ordinal,
+			mode: "region",
+			point: region.anchor.rect,
+			rect: region.anchor.rect
+		}];
+		if (region.anchor.kind === "story-preview-point") return [{
+			ordinal,
+			mode: "point",
+			point: region.anchor.point
+		}];
+		return [];
+	});
+	const textPanel = /* @__PURE__ */ jsx(AuthorTextView, {
+		sessionId,
+		document,
+		preview: document.kind === "markdown" && markdownPreview && activeTool === "select" && !gridVisible,
+		displayedRegions
+	});
+	const sourcePanel = document.kind === "text" || document.kind === "markdown" || document.kind === "story-preview" ? textPanel : document.structuredFormat !== void 0 ? /* @__PURE__ */ jsx(AuthorStructuredView, {
+		sessionId,
+		document,
+		displayedRegions
+	}) : /* @__PURE__ */ jsx(AuthorMediaView, {
+		sessionId,
+		document,
+		activeTool,
+		displayedRegions,
+		pendingCandidate: workspace?.candidate !== void 0,
+		seekRequest: workspace?.videoSeekRequest
+	}, document.path);
+	return /* @__PURE__ */ jsxs("section", {
+		"data-testid": "author-document",
+		className: "flex min-h-0 flex-1 flex-col",
+		children: [
+			/* @__PURE__ */ jsxs("header", {
+				className: "flex items-center gap-2 border-b border-doom-border px-4 py-2",
+				children: [
+					/* @__PURE__ */ jsx("strong", {
+						className: "min-w-0 flex-1 truncate text-base text-doom-hi",
+						children: document.title ?? document.path
+					}),
+					PreviewPanel !== void 0 && previewSource !== void 0 ? /* @__PURE__ */ jsx(Button, {
+						size: "xs",
+						variant: previewOpen ? "primary" : "outline",
+						"data-testid": "author-story-preview-toggle",
+						"aria-pressed": previewOpen,
+						"aria-label": previewOpen ? "show story source" : "show story preview",
+						onClick: () => setPreviewOpen(!previewOpen),
+						children: previewOpen ? "Source" : "Preview"
+					}) : null,
+					document.kind === "markdown" ? /* @__PURE__ */ jsx(Button, {
+						size: "xs",
+						variant: "ghost",
+						"data-testid": "author-markdown-toggle",
+						onClick: () => setMarkdownPreview(!markdownPreview),
+						children: markdownPreview ? "edit" : "preview"
+					}) : null,
+					document.kind === "video" ? /* @__PURE__ */ jsx("span", {
+						className: "text-base text-doom-dim",
+						children: "Video feedback"
+					}) : /* @__PURE__ */ jsx(Button, {
+						className: "min-h-11 px-4 text-base",
+						variant: "outline",
+						"data-testid": "author-save",
+						disabled: document.revisions.length === 0 || document.savingVersion !== void 0,
+						onClick: () => void save(),
+						children: previewOpen && previewSource?.hasUnsavedChanges ? "Save & refresh" : "Save"
+					})
+				]
+			}),
+			status === void 0 ? null : /* @__PURE__ */ jsx("output", {
+				className: "px-4 py-1 text-xs text-doom-faint",
+				children: status
+			}),
+			/* @__PURE__ */ jsxs("div", {
+				className: "relative flex min-h-0 flex-1 overflow-hidden",
+				children: [previewOpen && PreviewPanel !== void 0 && previewSource !== void 0 ? /* @__PURE__ */ jsx(PreviewPanel, {
+					...props,
+					source: previewSource,
+					activeTool: activeTool === "crop" ? "select" : activeTool,
+					displayedAnnotations: displayedPreviewAnnotations,
+					pendingCandidate: workspace?.candidate !== void 0,
+					onAnnotationCandidate: (candidate) => {
+						setAuthorStoryPreview(sessionId, document.path, candidate.preview);
+						setAuthorRegionCandidate(sessionId, {
+							documentPath: document.path,
+							revision: document.version,
+							sourceSha256: document.sourceSha256,
+							mode: candidate.mode,
+							anchor: candidate.mode === "region" && candidate.rect !== void 0 ? {
+								kind: "story-preview-rect",
+								rect: candidate.rect,
+								preview: candidate.preview
+							} : {
+								kind: "story-preview-point",
+								point: candidate.point,
+								preview: candidate.preview
+							},
+							viewport: candidate.preview.viewport,
+							evidence: candidate.evidence,
+							thumbnailUrl: candidate.thumbnailUrl,
+							createdAt: Date.now()
+						});
+					}
+				}) : sourcePanel, previewOpen && PreviewPanel !== void 0 && previewSource !== void 0 ? null : /* @__PURE__ */ jsx(AuthorGridOverlay, {
+					sessionId,
+					document,
+					visible: gridVisible
+				})]
+			})
+		]
+	});
+}
+function authorFileTab(path) {
+	const normalized = normalizeAuthorPath(path);
+	return {
+		id: tabId(normalized),
+		label: normalized.split("/").at(-1) ?? normalized,
+		retainComposer: true,
+		panel: (props) => /* @__PURE__ */ jsx(AuthorDocumentPanel, {
+			...props,
+			path: normalized
+		})
+	};
+}
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/file-links/author-document.web.ts
+var author_document_web_default = defineFileLinks({
+	requiredMinorMode: "author",
+	subscribe(listener) {
+		const subscription = authorWorkspace.store.subscribe(listener);
+		return () => subscription.unsubscribe();
+	},
+	fingerprint(sessionId) {
+		if (sessionId === null) return "";
+		const prefix = `${sessionId}\n`;
+		return Object.keys(authorWorkspace.store.state.documents).filter((key) => key.startsWith(prefix)).sort().join("\n");
+	},
+	resolve(sessionId, path) {
+		if (sessionId === null) return void 0;
+		const normalized = normalizeAuthorPath(path.replace(/:\d+(?::\d+)?$/, ""));
+		return authorWorkspace.store.state.documents[authorDocumentKey(sessionId, normalized)] === void 0 ? void 0 : authorFileTab(normalized);
+	},
+	openPath(sessionId, path) {
+		if (sessionId === null) return void 0;
+		const normalized = normalizeAuthorPath(path);
+		return normalized === "" ? void 0 : authorFileTab(normalized);
+	}
+});
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/leader/author-toggle.web.ts
+var author_toggle_web_default = defineLeaderBinding({
+	id: "author.toggle",
+	path: [{
+		key: "o",
+		label: "other",
+		detail: "optional modes and tools"
+	}, {
+		key: "a",
+		label: "author",
+		detail: "enable or disable focused document authoring"
+	}],
+	command: "minor author"
+});
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/_lib/authorAnnotationPersistence.ts
+const AUTHOR_ANNOTATION_DATABASE = "doompi-author-annotations";
+const STORE = "documents";
+const RECORD_VERSION = 1;
+function object(value) {
+	return typeof value === "object" && value !== null;
+}
+function finite(value) {
+	return typeof value === "number" && Number.isFinite(value);
+}
+function point(value) {
+	return object(value) && finite(value.x) && finite(value.y) && value.x >= 0 && value.x <= 1 && value.y >= 0 && value.y <= 1;
+}
+function rect(value) {
+	return point(value) && object(value) && finite(value.width) && finite(value.height) && value.width > 0 && value.height > 0;
+}
+function validAnchor(value) {
+	if (!object(value) || typeof value.kind !== "string") return false;
+	switch (value.kind) {
+		case "text-range": return finite(value.startOffset) && finite(value.endOffset) && finite(value.startLine) && finite(value.endLine);
+		case "cell": return typeof value.fragmentId === "string" && typeof value.location === "string";
+		case "slide-element": return typeof value.fragmentId === "string" && finite(value.slide) && typeof value.location === "string";
+		case "image-rect": return rect(value.rect) && finite(value.naturalWidth) && finite(value.naturalHeight);
+		case "pdf-page-rect": return finite(value.page) && rect(value.rect);
+		case "video-time-rect": return finite(value.timeSeconds) && rect(value.rect);
+		case "story-preview-rect": return rect(value.rect) && object(value.preview);
+		case "image-point": return point(value.point) && finite(value.naturalWidth) && finite(value.naturalHeight);
+		case "pdf-page-point": return finite(value.page) && point(value.point);
+		case "video-time-point": return finite(value.timeSeconds) && point(value.point);
+		case "story-preview-point": return point(value.point) && object(value.preview);
+		default: return false;
+	}
+}
+function validEvidence(value) {
+	return value === void 0 || typeof Blob !== "undefined" && value instanceof Blob && value.size <= 8388608;
+}
+function validCandidate(value) {
+	if (!object(value)) return false;
+	return typeof value.documentPath === "string" && normalizeAuthorPath(value.documentPath) !== "" && finite(value.revision) && (value.sourceSha256 === void 0 || typeof value.sourceSha256 === "string") && (value.mode === void 0 || value.mode === "region" || value.mode === "point") && validAnchor(value.anchor) && object(value.viewport) && finite(value.viewport.width) && finite(value.viewport.height) && finite(value.createdAt) && validEvidence(value.evidence);
+}
+function validAnnotation(value) {
+	return validCandidate(value) && object(value) && typeof value.id === "string" && value.id !== "" && typeof value.comment === "string" && value.comment.trim() !== "" && (value.version === void 0 || Number.isInteger(value.version) && value.version >= 1);
+}
+function utf8Length(value) {
+	return new TextEncoder().encode(value).byteLength;
+}
+function validateAuthorAnnotationRecord(input) {
+	if (!object(input) || input.version !== RECORD_VERSION || typeof input.key !== "string") return void 0;
+	if (typeof input.sessionId !== "string" || input.sessionId === "" || typeof input.documentPath !== "string") return void 0;
+	const path = normalizeAuthorPath(input.documentPath);
+	if (path === "" || input.key !== `${input.sessionId}\n${path}` || !object(input.collection)) return void 0;
+	const collection = input.collection;
+	if (!finite(collection.revision) || collection.sourceSha256 !== void 0 && typeof collection.sourceSha256 !== "string" || typeof collection.stale !== "boolean" || typeof collection.candidateText !== "string" || utf8Length(collection.candidateText) > 2048 || !Array.isArray(collection.annotations) || collection.annotations.length > 16 || !collection.annotations.every(validAnnotation) || collection.candidate !== void 0 && !validCandidate(collection.candidate) || !finite(collection.updatedAt)) return void 0;
+	return input;
+}
+function durableCandidate(candidate) {
+	const { thumbnailUrl: _thumbnailUrl, ...durable } = candidate;
+	return durable;
+}
+function persistenceRecords() {
+	const records = [];
+	for (const [sessionId, session] of Object.entries(authorWorkspace.store.state.sessions)) for (const [documentPath, collection] of Object.entries(session.annotationsByDocument)) {
+		if (collection.annotations.length === 0 && collection.candidate === void 0 && collection.candidateText === "") continue;
+		records.push({
+			key: `${sessionId}\n${documentPath}`,
+			version: RECORD_VERSION,
+			sessionId,
+			documentPath,
+			collection: {
+				...collection,
+				candidate: collection.candidate && durableCandidate(collection.candidate),
+				annotations: collection.annotations.map(durableCandidate)
+			}
+		});
+	}
+	return records.sort((a, b) => b.collection.updatedAt - a.collection.updatedAt).slice(0, 100);
+}
+var IndexedDbAuthorAnnotationRepository = class {
+	#database;
+	#writes = Promise.resolve();
+	constructor(factory) {
+		this.#database = new Promise((resolve, reject) => {
+			const request = factory.open(AUTHOR_ANNOTATION_DATABASE, 1);
+			request.onupgradeneeded = () => {
+				if (!request.result.objectStoreNames.contains(STORE)) request.result.createObjectStore(STORE, { keyPath: "key" });
+			};
+			request.onsuccess = () => resolve(request.result);
+			request.onerror = () => reject(request.error ?? /* @__PURE__ */ new Error("Unable to open Author annotation storage."));
+		});
+	}
+	async load() {
+		const database = await this.#database;
+		return await new Promise((resolve, reject) => {
+			const request = database.transaction(STORE, "readonly").objectStore(STORE).getAll();
+			request.onsuccess = () => resolve(request.result);
+			request.onerror = () => reject(request.error ?? /* @__PURE__ */ new Error("Unable to read Author annotations."));
+		});
+	}
+	replace(records) {
+		const write = async () => {
+			const database = await this.#database;
+			await new Promise((resolve, reject) => {
+				const transaction = database.transaction(STORE, "readwrite");
+				const store = transaction.objectStore(STORE);
+				store.clear();
+				records.forEach((record) => store.put(record));
+				transaction.oncomplete = () => resolve();
+				transaction.onerror = () => reject(transaction.error ?? /* @__PURE__ */ new Error("Unable to write Author annotations."));
+				transaction.onabort = () => reject(transaction.error ?? /* @__PURE__ */ new Error("Author annotation write was aborted."));
+			});
+		};
+		this.#writes = this.#writes.catch(() => void 0).then(write);
+		return this.#writes;
+	}
+	async close() {
+		try {
+			await this.#writes;
+		} finally {
+			(await this.#database).close();
+		}
+	}
+};
+function startAuthorAnnotationPersistence(repository) {
+	const factory = typeof indexedDB === "undefined" ? void 0 : indexedDB;
+	if (repository === void 0 && factory === void 0) return async () => void 0;
+	const storage = repository ?? new IndexedDbAuthorAnnotationRepository(factory);
+	let stopped = false;
+	let hydrated = false;
+	let dirty = false;
+	const subscription = authorWorkspace.store.subscribe(() => {
+		if (!hydrated) dirty = true;
+		else storage.replace(persistenceRecords()).catch(() => void 0);
+	});
+	storage.load().then((values) => {
+		if (stopped) return;
+		const records = values.map(validateAuthorAnnotationRecord).filter((record) => record !== void 0).sort((a, b) => b.collection.updatedAt - a.collection.updatedAt).slice(0, 100);
+		hydrateAuthorAnnotationCollections(records);
+		hydrated = true;
+		if (dirty || records.length > 0) storage.replace(persistenceRecords()).catch(() => void 0);
+	}).catch(() => {
+		if (stopped) return;
+		hydrated = true;
+		if (dirty) storage.replace(persistenceRecords()).catch(() => void 0);
+	});
+	return async () => {
+		stopped = true;
+		subscription.unsubscribe();
+		await storage.close();
+	};
+}
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/lifecycle/_lib/authorRequestLifecycle.ts
+function capturePacket(content) {
+	try {
+		const value = JSON.parse(content);
+		if (value.version !== 1 || typeof value.captureId !== "string" || typeof value.capturedAt !== "number" || typeof value.document?.path !== "string" || typeof value.document.revision !== "number" || !Array.isArray(value.regions) || value.regions.length === 0) return;
+		return value;
+	} catch {
+		return;
+	}
+}
+function recordAuthorComposerSubmission(submission) {
+	for (const item of submission.contextItems) {
+		if (item.source !== "author" || item.kind !== "author-capture") continue;
+		const packet = capturePacket(item.metadata ?? item.content);
+		if (packet === void 0 || packet.captureId !== item.id) continue;
+		if (authorSessionWorkspace(submission.sessionId).requests.some((request) => request.captureId === packet.captureId)) continue;
+		const regions = packet.regions.map((region) => ({
+			id: region.id,
+			documentPath: packet.document.path,
+			revision: packet.document.revision,
+			sourceSha256: packet.document.sourceSha256,
+			comment: region.comment,
+			version: region.version ?? 1,
+			mode: region.mode,
+			quote: region.quote,
+			anchor: structuredClone(region.anchor),
+			viewport: { ...region.viewport },
+			voiceGrid: region.voiceGrid && { ...region.voiceGrid },
+			createdAt: packet.capturedAt
+		}));
+		putAuthorRequest(submission.sessionId, {
+			id: crypto.randomUUID(),
+			captureId: packet.captureId,
+			documentPath: packet.document.path,
+			requestText: submission.message,
+			regions,
+			pendingRegions: regions,
+			status: "REQUESTED",
+			createdAt: submission.submittedAt,
+			updatedAt: submission.submittedAt,
+			revision: packet.document.revision,
+			sourceSha256: packet.document.sourceSha256
+		});
+		for (const region of packet.regions) removeAuthorRegion(submission.sessionId, region.id, region.version ?? 1, packet.document.path);
+	}
+}
+/** Only the host's correlated execution events may settle a submitted capture. */
+function recordAuthorCaptureStatus(event) {
+	const request = authorSessionWorkspace(event.sessionId).requests.find((record) => record.captureId === event.captureId);
+	if (request === void 0 || [
+		"COMPLETE",
+		"FAILED",
+		"CANCELLED"
+	].includes(request.status)) return;
+	if (event.status === "queued") return;
+	updateAuthorRequest(event.sessionId, request.id, (record) => ({
+		...record,
+		status: event.status === "working" ? "CHANGING" : event.status === "completed" ? "COMPLETE" : "FAILED",
+		currentOperation: event.status === "working" ? "Agent is working on this request" : void 0,
+		pendingRegions: event.status === "completed" ? [] : record.pendingRegions,
+		error: event.status === "error" ? event.error || "Request execution failed." : void 0,
+		updatedAt: Date.now()
+	}));
+}
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/lifecycle/_lib/authorBrowserLifecycle.ts
+function startAuthorBrowserLifecycle(runtime) {
+	const stopBridge = startAuthorBrowserBridge(runtime);
+	const stopPersistence = startAuthorAnnotationPersistence();
+	const stopSubmissions = runtime.onComposerSubmitted?.(recordAuthorComposerSubmission) ?? (() => void 0);
+	const stopCaptureStatus = runtime.onCaptureStatus?.(recordAuthorCaptureStatus) ?? (() => void 0);
+	return async () => {
+		stopSubmissions();
+		stopCaptureStatus();
+		stopBridge();
+		await stopPersistence().catch(() => void 0);
+	};
+}
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/lifecycle/start.web.ts
+var start_web_default = defineWebLifecycle(startAuthorBrowserLifecycle);
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/mode/author/mode.web.ts
+var mode_web_default = defineMinorModeFile({
+	name: "author",
+	keys: "o a",
+	order: 45
+});
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/slot/preview-action.web.ts
+/** Typed data slot for preview launchers that need Author's focused source. */
+var preview_action_web_default = defineSlotFile({
+	slot: "author.preview-action",
+	parse: parseAuthorPreviewAction
+});
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/slot/preview-provider.web.ts
+/**
+* Optional preview providers render launch controls here. The provider owns its
+* transient tab and preview lifecycle; Author owns the surrounding mode and
+* composer submission surface.
+*/
+var preview_provider_web_default = defineSlotFile({});
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/tool/_lib/describeAuthorToolsToolRender.ts
+function describeAuthorToolsCallSummary(_args) {
+	return "";
+}
+/**
+* The body as toned lines: what the result's details say, or its text. Pure,
+* so a unit test can pin it without a DOM; the item decides how many to show.
+*/
+function describeAuthorToolsResultLines(result) {
+	if (result === null) return [];
+	return toolResultTextLines(result.content).map((text) => ({
+		text,
+		tone: "dim"
+	}));
+}
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/tool/_components/DescribeAuthorToolsToolCard.tsx
+/**
+* The describe_author_tools tool's timeline item: Describe the current Author viewport capabilities. The shell owns
+* the frame, the outcome tone, the status badge, and the expand toggle; this
+* card supplies the header summary and the body lines, and says whether it
+* hides any so the toggle appears only when it reveals something.
+*/
+function DescribeAuthorToolsToolCard({ toolName, args, result, running, isError }) {
+	const lines = describeAuthorToolsResultLines(result);
+	const collapsed = collapseLines(lines, 8, false);
+	return /* @__PURE__ */ jsx(MessageItem, {
+		tone: toolTone({
+			running,
+			isError
+		}),
+		expandable: collapsed.hidden > 0,
+		children: ({ expanded }) => {
+			const view = expanded ? collapseLines(lines, 8, true) : collapsed;
+			return /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx(MessageItemHeader, {
+				title: toolName,
+				children: /* @__PURE__ */ jsx("span", {
+					"data-testid": `tool-call-${toolName}`,
+					className: "min-w-0 flex-1 truncate text-doom-text",
+					children: describeAuthorToolsCallSummary(args)
+				})
+			}), view.shown.length > 0 || running || isError ? /* @__PURE__ */ jsxs(MessageItemBody, {
+				"data-testid": `tool-result-${toolName}`,
+				className: "flex flex-col gap-1",
+				children: [
+					view.shown.length > 0 ? /* @__PURE__ */ jsx(MessageLines, { lines: view.shown }) : null,
+					view.hidden > 0 ? /* @__PURE__ */ jsxs(MessageItemStatus, {
+						expands: true,
+						children: [view.hidden, " more line(s)"]
+					}) : null,
+					running ? /* @__PURE__ */ jsx(MessageItemStatus, {
+						tone: "running",
+						children: "running"
+					}) : null,
+					isError ? /* @__PURE__ */ jsx(MessageItemStatus, {
+						tone: "error",
+						children: "failed"
+					}) : null
+				]
+			}) : null] });
+		}
+	});
+}
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/tool/describe-author-tools.web.tsx
+var describe_author_tools_web_default = defineToolRenderer({
+	tools: ["describe_author_tools"],
+	message: DescribeAuthorToolsToolCard
+});
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/tool/_components/OpenAuthoringFileToolCard.tsx
+function openAuthoringFileTab(path, openTransientTab, openTab) {
+	const tab = authorFileTab(path);
+	openTransientTab(tab);
+	openTab(tab.id);
+}
+function resultPath(result) {
+	if (typeof result?.details !== "object" || result.details === null || !("path" in result.details)) return void 0;
+	return typeof result.details.path === "string" ? result.details.path : void 0;
+}
+function OpenAuthoringFileToolCard({ args, result, running, isError, output, openTransientTab, openTab }) {
+	const path = resultPath(result);
+	const unavailable = !running && !isError && result !== null && path === void 0;
+	const errorLines = isError ? (output ?? "").trim().split(/\r?\n/u).filter(Boolean).slice(0, 4).map((text) => ({
+		text,
+		tone: "error"
+	})) : [];
+	const requestedPath = typeof args.path === "string" ? args.path : "document";
+	return /* @__PURE__ */ jsx(MessageItem, {
+		tone: toolTone({
+			running,
+			isError: isError || unavailable
+		}),
+		children: () => /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx(MessageItemHeader, {
+			title: "open_authoring_file",
+			children: /* @__PURE__ */ jsx("span", {
+				"data-testid": "tool-call-open_authoring_file",
+				className: "min-w-0 flex-1 truncate text-doom-text",
+				children: requestedPath
+			})
+		}), /* @__PURE__ */ jsxs(MessageItemBody, {
+			"data-testid": "tool-result-open_authoring_file",
+			className: "flex flex-col gap-1",
+			children: [
+				errorLines.length > 0 ? /* @__PURE__ */ jsx(MessageLines, { lines: errorLines }) : null,
+				/* @__PURE__ */ jsx(MessageItemStatus, {
+					tone: isError || unavailable ? "error" : running ? "running" : void 0,
+					children: isError ? "failed" : running ? "validating" : unavailable ? "unavailable" : path === void 0 ? "waiting" : "ready"
+				}),
+				!running && !isError && path !== void 0 ? /* @__PURE__ */ jsx(Button, {
+					size: "xs",
+					variant: "outline",
+					"data-testid": "author-open-file",
+					onClick: () => openAuthoringFileTab(path, openTransientTab, openTab),
+					children: "open in Author"
+				}) : null
+			]
+		})] })
+	});
+}
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/tool/open-authoring-file.web.tsx
+var open_authoring_file_web_default = defineToolRenderer({
+	tools: ["open_authoring_file"],
+	message: OpenAuthoringFileToolCard,
+	completionTab: ({ result }) => {
+		const path = resultPath(result);
+		return path === void 0 ? void 0 : authorFileTab(path);
+	}
+});
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/tool/_lib/useAuthorToolsToolRender.ts
+function useAuthorToolsCallSummary(args) {
+	return typeof args.name === "string" ? args.name : "";
+}
+/**
+* The body as toned lines: what the result's details say, or its text. Pure,
+* so a unit test can pin it without a DOM; the item decides how many to show.
+*/
+function useAuthorToolsResultLines(result) {
+	if (result === null) return [];
+	return toolResultTextLines(result.content).map((text) => ({
+		text,
+		tone: "dim"
+	}));
+}
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/tool/_components/UseAuthorToolsToolCard.tsx
+/**
+* The use_author_tools tool's timeline item: Use one capability of the current Author viewport. The shell owns
+* the frame, the outcome tone, the status badge, and the expand toggle; this
+* card supplies the header summary and the body lines, and says whether it
+* hides any so the toggle appears only when it reveals something.
+*/
+function UseAuthorToolsToolCard({ toolName, args, result, running, isError }) {
+	const lines = useAuthorToolsResultLines(result);
+	const collapsed = collapseLines(lines, 8, false);
+	return /* @__PURE__ */ jsx(MessageItem, {
+		tone: toolTone({
+			running,
+			isError
+		}),
+		expandable: collapsed.hidden > 0,
+		children: ({ expanded }) => {
+			const view = expanded ? collapseLines(lines, 8, true) : collapsed;
+			return /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx(MessageItemHeader, {
+				title: toolName,
+				children: /* @__PURE__ */ jsx("span", {
+					"data-testid": `tool-call-${toolName}`,
+					className: "min-w-0 flex-1 truncate text-doom-text",
+					children: useAuthorToolsCallSummary(args)
+				})
+			}), view.shown.length > 0 || running || isError ? /* @__PURE__ */ jsxs(MessageItemBody, {
+				"data-testid": `tool-result-${toolName}`,
+				className: "flex flex-col gap-1",
+				children: [
+					view.shown.length > 0 ? /* @__PURE__ */ jsx(MessageLines, { lines: view.shown }) : null,
+					view.hidden > 0 ? /* @__PURE__ */ jsxs(MessageItemStatus, {
+						expands: true,
+						children: [view.hidden, " more line(s)"]
+					}) : null,
+					running ? /* @__PURE__ */ jsx(MessageItemStatus, {
+						tone: "running",
+						children: "running"
+					}) : null,
+					isError ? /* @__PURE__ */ jsx(MessageItemStatus, {
+						tone: "error",
+						children: "failed"
+					}) : null
+				]
+			}) : null] });
+		}
+	});
+}
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/tool/use-author-tools.web.tsx
+var use_author_tools_web_default = defineToolRenderer({
+	tools: ["use_author_tools"],
+	message: UseAuthorToolsToolCard
+});
+//#endregion
+//#region generated/web.ts
+const via = (identity, value) => ({
+	...identity,
+	...value
+});
+const webPlugin = defineWebPlugin({
+	id: "author",
+	session: {
+		get channels() {
+			return [via({ channel: "author_webmcp" }, author_webmcp_web_default)];
+		},
+		get dockFaces() {
+			return [via({ id: "authoring" }, authoring_web_default)];
+		},
+		get fileLinks() {
+			return author_document_web_default;
+		},
+		get leaderBindings() {
+			return [via({ id: "author.author-toggle" }, author_toggle_web_default)];
+		},
+		get minorModes() {
+			return [via({ name: "author" }, mode_web_default)];
+		},
+		get slots() {
+			return [via({ slot: "author.preview-action" }, preview_action_web_default), via({ slot: "author.preview-provider" }, preview_provider_web_default)];
+		},
+		get start() {
+			return start_web_default;
+		},
+		get toolRenderers() {
+			return [
+				via({ tools: ["describe_author_tools"] }, describe_author_tools_web_default),
+				via({ tools: ["open_authoring_file"] }, open_authoring_file_web_default),
+				via({ tools: ["use_author_tools"] }, use_author_tools_web_default)
+			];
+		}
+	}
+});
+//#endregion
+export { webPlugin };
+
+//# sourceMappingURL=web.mjs.map