@agimon-ai/po-author 0.0.0-alpha.0

package/dist/extensions/web.mjs

@@ -0,0 +1,4758 @@
+import { apiResponse, createApiClient, defineApiRoutes, defineChannelFile, defineDockFace, defineFileLinks, defineFill, defineGlobalStore, defineLeaderBinding, defineMinorModeFile, defineSessionStore, defineSlotFile, defineToolRenderer, defineWebLifecycle, defineWebPlugin, sessionApiAddress, toolResultTextLines } from "@agimon-ai/po-core/web";
+import { Store } from "@tanstack/store";
+import { useStore } from "@tanstack/react-store";
+import { useEffect, useRef, useState } from "react";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { Button, CodeEditor, Markdown, MediaPreview, MessageItem, MessageItemBody, MessageItemHeader, MessageItemStatus, MessageLines, collapseLines, toolTone } from "@agimon-ai/po-web-components";
+import { sealedTransport } from "@agimon-ai/po-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"
+};
+const runtimeIds = new Store(0);
+function runtimePrefix() {
+	runtimeIds.setState((id) => id + 1);
+	return `a${runtimeIds.state.toString(36)}_`;
+}
+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;
+	#registrationPrefix = runtimePrefix();
+	#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 registrations = new Map(tools.map((tool, index) => [tool.name, `${this.#registrationPrefix}${index.toString(36)}`]));
+		const generation = ++this.#generation;
+		const controller = new AbortController();
+		const candidate = {
+			generation,
+			controller,
+			profiles: profileMap,
+			registrations
+		};
+		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: registrations.get(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,
+				name: registrations.get(tool.name)
+			})))) 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");
+		const registration = this.#active.registrations.get(name);
+		if (registration === void 0) throw new Error(`Unknown Author capability: ${name}`);
+		return context.executeTool(registration, 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
+const canvasKey = (sessionId, alias) => `${sessionId}\n${alias}`;
+const VISIBLE_ONLY = /* @__PURE__ */ new Set(["author_describe_grid", "author_resolve_grid_cell"]);
+const documentProfiles = (profiles) => profiles.map((profile) => ({
+	...profile,
+	tools: profile.tools.filter((tool) => !VISIBLE_ONLY.has(tool.name))
+}));
+var AuthorBrowserBridge = class {
+	#host;
+	#canvases = /* @__PURE__ */ new Map();
+	#opening = /* @__PURE__ */ new Map();
+	#generation = 0;
+	#disposed = false;
+	#releaseConnected;
+	constructor(host) {
+		this.#host = host;
+		this.#releaseConnected = host.onHubConnected(() => {
+			for (const canvas of this.#canvases.values()) {
+				canvas.ownerToken = void 0;
+				canvas.catalogToken = void 0;
+				this.#register(canvas);
+			}
+		});
+	}
+	async open(sessionId, alias, profiles) {
+		if (this.#disposed) throw new Error("Author browser bridge is disposed");
+		const key = canvasKey(sessionId, alias);
+		if (this.#canvases.has(key)) return;
+		const pending = this.#opening.get(key);
+		if (pending !== void 0) return await pending.promise;
+		const runtime = new AuthorRuntime(this.#host);
+		const generation = ++this.#generation;
+		const base = documentProfiles(profiles);
+		let opening;
+		opening = (async () => {
+			const release = await runtime.replaceProfiles(base);
+			if (this.#disposed || this.#canvases.has(key) || this.#opening.get(key)?.promise !== opening) {
+				release();
+				runtime.dispose();
+				return;
+			}
+			const canvas = {
+				sessionId,
+				alias,
+				generation,
+				profiles: base,
+				documentProfiles: base,
+				runtime,
+				release,
+				pending: /* @__PURE__ */ new Map(),
+				visible: false,
+				focusId: 0,
+				replacementId: 0
+			};
+			this.#canvases.set(key, canvas);
+			this.#register(canvas);
+		})();
+		this.#opening.set(key, {
+			promise: opening,
+			runtime
+		});
+		try {
+			await opening;
+		} finally {
+			if (this.#opening.get(key)?.promise === opening) this.#opening.delete(key);
+		}
+	}
+	async focus(sessionId, alias, profiles) {
+		await this.open(sessionId, alias, profiles);
+		const canvas = this.#canvases.get(canvasKey(sessionId, alias));
+		if (canvas === void 0) return () => void 0;
+		canvas.visible = true;
+		const focusId = ++canvas.focusId;
+		await this.#replace(canvas, profiles);
+		return () => {
+			if (this.#canvases.get(canvasKey(sessionId, alias)) !== canvas || canvas.focusId !== focusId) return;
+			canvas.visible = false;
+			canvas.focusId += 1;
+			this.#replace(canvas, canvas.documentProfiles);
+		};
+	}
+	drop(sessionId, alias) {
+		for (const [key, entry] of this.#opening) if (key.startsWith(`${sessionId}\n`) && (alias === void 0 || key === canvasKey(sessionId, alias))) {
+			this.#opening.delete(key);
+			entry.runtime.dispose();
+		}
+		for (const canvas of this.#canvases.values()) {
+			if (canvas.sessionId !== sessionId || alias !== void 0 && canvas.alias !== alias) continue;
+			this.#canvases.delete(canvasKey(sessionId, canvas.alias));
+			this.#release(canvas);
+			canvas.runtime.dispose();
+		}
+	}
+	apply(sessionId, message) {
+		if (message.alias === void 0) return;
+		const canvas = this.#canvases.get(canvasKey(sessionId, message.alias));
+		if (canvas === void 0 || message.kind === "rejected") return;
+		if (message.generation !== canvas.generation || message.ownerToken !== canvas.ownerToken && canvas.ownerToken !== void 0) return;
+		if (message.kind === "accepted") {
+			canvas.ownerToken = message.ownerToken;
+			clearTimeout(canvas.leaseTimer);
+			canvas.leaseTimer = setTimeout(() => this.#register(canvas), Math.max(1e3, Math.floor(message.leaseMs / 2)));
+			if (message.catalogToken === void 0) this.#sendCatalog(canvas);
+			else canvas.catalogToken = message.catalogToken;
+			return;
+		}
+		if (message.catalogToken !== canvas.catalogToken) return;
+		if (message.kind === "cancel") {
+			canvas.pending.get(message.requestId)?.abort(/* @__PURE__ */ new Error("Author tool request cancelled"));
+			return;
+		}
+		if (message.kind !== "request" || canvas.pending.has(message.requestId)) return;
+		const controller = new AbortController();
+		canvas.pending.set(message.requestId, controller);
+		canvas.runtime.execute(message.name, message.arguments, controller.signal).then((result) => {
+			if (!this.#current(canvas, message.requestId, controller)) return;
+			if (controller.signal.aborted) this.#sendCancelled(canvas, message.requestId);
+			else this.#send(canvas, {
+				kind: "result",
+				alias: canvas.alias,
+				generation: canvas.generation,
+				ownerToken: canvas.ownerToken,
+				catalogToken: canvas.catalogToken,
+				requestId: message.requestId,
+				result
+			});
+		}).catch((error) => {
+			if (!this.#current(canvas, message.requestId, controller)) return;
+			if (controller.signal.aborted) this.#sendCancelled(canvas, 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(canvas, {
+					kind: "result",
+					alias: canvas.alias,
+					generation: canvas.generation,
+					ownerToken: canvas.ownerToken,
+					catalogToken: canvas.catalogToken,
+					requestId: message.requestId,
+					result: { error: {
+						code,
+						message: messageText
+					} }
+				});
+			}
+		}).finally(() => {
+			if (canvas.pending.get(message.requestId) === controller) canvas.pending.delete(message.requestId);
+		});
+	}
+	activeView(sessionId) {
+		const active = [...this.#canvases.values()].filter((canvas) => canvas.sessionId === sessionId && canvas.catalogToken);
+		return active.length > 0 ? {
+			activation: "active",
+			capabilityCount: active.reduce((count, canvas) => count + canvas.profiles.reduce((total, profile) => total + profile.tools.length, 0), 0)
+		} : {
+			activation: "inactive",
+			capabilityCount: 0
+		};
+	}
+	dispose() {
+		if (this.#disposed) return;
+		this.#disposed = true;
+		this.#releaseConnected();
+		for (const canvas of this.#canvases.values()) {
+			this.#release(canvas);
+			canvas.runtime.dispose();
+		}
+		this.#canvases.clear();
+		for (const entry of this.#opening.values()) entry.runtime.dispose();
+		this.#opening.clear();
+	}
+	async #replace(canvas, profiles) {
+		const key = canvasKey(canvas.sessionId, canvas.alias);
+		if (this.#disposed || this.#canvases.get(key) !== canvas) return;
+		this.#release(canvas);
+		const generation = canvas.generation;
+		const replacementId = ++canvas.replacementId;
+		let release;
+		try {
+			release = await canvas.runtime.replaceProfiles(profiles);
+		} catch (error) {
+			if (canvas.replacementId !== replacementId || this.#canvases.get(key) !== canvas) return;
+			throw error;
+		}
+		if (this.#disposed || this.#canvases.get(key) !== canvas || canvas.generation !== generation || canvas.replacementId !== replacementId) {
+			release();
+			return;
+		}
+		canvas.release = release;
+		canvas.profiles = profiles;
+		this.#register(canvas);
+	}
+	#register(canvas) {
+		if (this.#canvases.get(canvasKey(canvas.sessionId, canvas.alias)) === canvas) this.#send(canvas, {
+			kind: "register",
+			alias: canvas.alias,
+			generation: canvas.generation
+		});
+	}
+	#sendCatalog(canvas) {
+		this.#send(canvas, {
+			kind: "catalog",
+			alias: canvas.alias,
+			generation: canvas.generation,
+			ownerToken: canvas.ownerToken,
+			tools: canvas.profiles.flatMap((profile) => profile.tools.map((tool) => ({
+				name: tool.name,
+				label: tool.label ?? tool.name,
+				description: tool.description,
+				inputSchema: tool.inputSchema
+			})))
+		});
+	}
+	#sendCancelled(canvas, requestId) {
+		this.#send(canvas, {
+			kind: "cancelled",
+			alias: canvas.alias,
+			generation: canvas.generation,
+			ownerToken: canvas.ownerToken,
+			catalogToken: canvas.catalogToken,
+			requestId
+		});
+	}
+	#send(canvas, 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: canvas.sessionId,
+				message: payload
+			}
+		}).catch(() => void 0);
+	}
+	#current(canvas, requestId, controller) {
+		return this.#canvases.get(canvasKey(canvas.sessionId, canvas.alias)) === canvas && canvas.pending.get(requestId) === controller;
+	}
+	#release(canvas) {
+		clearTimeout(canvas.leaseTimer);
+		canvas.leaseTimer = void 0;
+		this.#send(canvas, {
+			kind: "release",
+			alias: canvas.alias,
+			generation: canvas.generation
+		});
+		canvas.release();
+		for (const controller of canvas.pending.values()) controller.abort(/* @__PURE__ */ new Error("Author viewport changed"));
+		canvas.pending.clear();
+		canvas.ownerToken = void 0;
+		canvas.catalogToken = void 0;
+		canvas.generation = ++this.#generation;
+	}
+};
+const authorBridgeRuntimes = new Store(/* @__PURE__ */ new Map());
+const bridgeFor = (sessionId) => authorBridgeRuntimes.state.get(sessionId) ?? authorBridgeRuntimes.state.get("global");
+function startAuthorBrowserBridge(runtime) {
+	const key = runtime.mount?.scope === "session" ? runtime.mount.sessionId : "global";
+	authorBridgeRuntimes.state.get(key)?.dispose();
+	const next = new AuthorBrowserBridge(runtime);
+	authorBridgeRuntimes.setState((state) => new Map(state).set(key, next));
+	return () => {
+		if (authorBridgeRuntimes.state.get(key) !== next) return;
+		next.dispose();
+		authorBridgeRuntimes.setState((state) => {
+			const remaining = new Map(state);
+			remaining.delete(key);
+			return remaining;
+		});
+	};
+}
+async function openAuthorCanvas(sessionId, alias, profiles) {
+	await bridgeFor(sessionId)?.open(sessionId, alias, profiles);
+}
+async function focusAuthorViewport(sessionId, profiles, alias = "default") {
+	return await bridgeFor(sessionId)?.focus(sessionId, alias, profiles) ?? (() => void 0);
+}
+function applyAuthorHubMessage(sessionId, message) {
+	bridgeFor(sessionId)?.apply(sessionId, message);
+}
+function dropAuthorViewportSession(sessionId, alias) {
+	bridgeFor(sessionId)?.drop(sessionId, alias);
+}
+function authorBridgeView(sessionId) {
+	return bridgeFor(sessionId)?.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,
+	annotationsByDocument: {},
+	toolsByDocument: {},
+	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;
+}
+const EMPTY_COLLECTION = Object.freeze({
+	revision: 0,
+	stale: false,
+	candidate: void 0,
+	candidateText: "",
+	annotations: Object.freeze([]),
+	updatedAt: 0
+});
+function authorDocumentAnnotations(sessionId, path, state = authorWorkspace.store.state) {
+	if (sessionId === null) return EMPTY_COLLECTION;
+	const document = state.documents[authorDocumentKey(sessionId, path)];
+	const collection = state.sessions[sessionId]?.annotationsByDocument[normalizeAuthorPath(path)];
+	return document !== void 0 && collection !== void 0 && !collection.stale && collection.revision === document.version && collection.sourceSha256 === document.sourceSha256 ? collection : EMPTY_COLLECTION;
+}
+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
+			});
+			sessions = {
+				...sessions,
+				[record.sessionId]: {
+					...session,
+					annotationsByDocument: {
+						...session.annotationsByDocument,
+						[path]: collection
+					}
+				}
+			};
+		}
+		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 !== 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]));
+			const now = Date.now();
+			const staleCollection = staleAuthorCollection(collection, now);
+			sessions = {
+				...sessions,
+				[sessionId]: {
+					...session,
+					annotationsByDocument: {
+						...session.annotationsByDocument,
+						...staleCollection && { [path]: staleCollection }
+					},
+					requests: session.requests.map((request) => input.kind !== "story-preview" && request.documentPath === path && [
+						"REQUESTED",
+						"CHANGING",
+						"CHANGED"
+					].includes(request.status) ? {
+						...request,
+						status: "FAILED",
+						currentOperation: void 0,
+						error: "The document source changed before the request completed.",
+						updatedAt: now
+					} : request)
+				}
+			};
+		}
+		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) {
+	let generation = 0;
+	updateSession(sessionId, (session) => {
+		generation = session.generation + 1;
+		return {
+			...session,
+			generation,
+			focusedDocument: {
+				path: normalizeAuthorPath(path),
+				generation,
+				focusedAt: Date.now()
+			}
+		};
+	});
+	return generation;
+}
+function releaseAuthorDocumentFocus(sessionId, generation) {
+	updateSession(sessionId, (session) => session.focusedDocument?.generation === generation ? {
+		...session,
+		focusedDocument: void 0
+	} : session);
+}
+function seekAuthorVideo(sessionId, path, timeSeconds) {
+	const normalized = normalizeAuthorPath(path);
+	const focused = authorSessionWorkspace(sessionId).focusedDocument;
+	if (focused?.path !== normalized || authorDocumentAnnotations(sessionId, normalized).candidate || !Number.isFinite(timeSeconds) || timeSeconds < 0 || authorDocument(sessionId, normalized)?.kind !== "video") return false;
+	setAuthorToolMode(sessionId, normalized, "select");
+	updateSession(sessionId, (session) => ({
+		...session,
+		videoSeekRequest: {
+			path: normalized,
+			generation: focused.generation,
+			timeSeconds,
+			sequence: (session.videoSeekRequest?.sequence ?? 0) + 1
+		}
+	}));
+	return true;
+}
+function setAuthorPreviewSelection(sessionId, path, preview) {
+	const normalized = normalizeAuthorPath(path);
+	updateSession(sessionId, (session) => {
+		const selections = { ...session.previewSelections };
+		if (preview === void 0) delete selections[normalized];
+		else selections[normalized] = { ...preview };
+		return {
+			...session,
+			previewSelections: selections
+		};
+	});
+}
+function setAuthorToolMode(sessionId, path, tool) {
+	const normalized = normalizeAuthorPath(path);
+	updateSession(sessionId, (session) => ({
+		...session,
+		toolsByDocument: {
+			...session.toolsByDocument,
+			[normalized]: tool
+		}
+	}));
+}
+function validateCandidate(sessionId, path, candidate) {
+	const document = authorDocument(sessionId, path);
+	if (document === void 0 || normalizeAuthorPath(candidate.documentPath) !== normalizeAuthorPath(path)) throw new Error("The Author selection does not belong to the document.");
+	if (document.version !== candidate.revision || document.sourceSha256 !== candidate.sourceSha256) throw new Error("The Author selection is stale for the document.");
+}
+function setAuthorRegionCandidate(sessionId, path, candidate) {
+	if (candidate !== void 0) validateCandidate(sessionId, path, candidate);
+	const thumbnail = authorDocumentAnnotations(sessionId, path).candidate?.thumbnailUrl;
+	updateCollection(sessionId, path, (collection) => ({
+		...collection,
+		candidate: candidate && copyCandidate(candidate)
+	}));
+	if (thumbnail !== void 0 && thumbnail !== candidate?.thumbnailUrl) revokeThumbnail(thumbnail);
+}
+function setAuthorCandidateText(sessionId, path, candidateText) {
+	if (new TextEncoder().encode(candidateText).byteLength > 2048) throw new Error("Author candidate text must not exceed 2 KiB.");
+	updateCollection(sessionId, path, (collection) => ({
+		...collection,
+		candidateText
+	}));
+}
+function commitAuthorRegion(sessionId, path, comment) {
+	const candidate = authorDocumentAnnotations(sessionId, path).candidate;
+	if (candidate === void 0) throw new Error("Select a document annotation before adding a comment.");
+	const id = crypto.randomUUID();
+	addAuthorRegion(sessionId, {
+		...candidate,
+		id,
+		comment,
+		version: 1
+	});
+	updateCollection(sessionId, path, (collection) => ({
+		...collection,
+		candidate: void 0,
+		candidateText: ""
+	}));
+	return id;
+}
+function addAuthorRegion(sessionId, region) {
+	if (region.comment.trim() === "") throw new Error("Every Author annotation requires a comment.");
+	validateCandidate(sessionId, region.documentPath, region);
+	updateCollection(sessionId, region.documentPath, (collection) => {
+		if (collection.annotations.length >= 16) throw new Error(`Author requests support at most 16 annotations.`);
+		if (collection.annotations.some((candidate) => candidate.id === region.id)) throw new Error(`Author annotation '${region.id}' already exists.`);
+		return {
+			...collection,
+			annotations: [...collection.annotations, copyRegion({
+				...region,
+				version: region.version ?? 1
+			})]
+		};
+	});
+}
+function removeAuthorRegion(sessionId, path, regionId, expectedVersion) {
+	let thumbnail;
+	updateCollection(sessionId, path, (collection) => {
+		const annotation = collection.annotations.find((candidate) => candidate.id === regionId);
+		if (annotation === void 0 || expectedVersion !== void 0 && (annotation.version ?? 1) !== expectedVersion) return collection;
+		thumbnail = annotation.thumbnailUrl;
+		return {
+			...collection,
+			annotations: collection.annotations.filter((candidate) => candidate.id !== regionId)
+		};
+	});
+	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 identityChanged = document.version !== next.version || document.sourceSha256 !== next.sourceSha256;
+		const collection = identityChanged ? session?.annotationsByDocument[document.path] : void 0;
+		if (collection !== void 0) {
+			if (collection.candidate?.thumbnailUrl !== void 0) staleThumbnails.push(collection.candidate.thumbnailUrl);
+			staleThumbnails.push(...collection.annotations.flatMap((annotation) => annotation.thumbnailUrl === void 0 ? [] : [annotation.thumbnailUrl]));
+		}
+		const staleCollection = identityChanged ? staleAuthorCollection(collection, Date.now()) : void 0;
+		const sessions = identityChanged && session !== void 0 ? {
+			...state.sessions,
+			[sessionId]: {
+				...session,
+				annotationsByDocument: {
+					...session.annotationsByDocument,
+					...staleCollection && { [document.path]: staleCollection }
+				}
+			}
+		} : 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 },
+		stroke: candidate.stroke?.map((point) => ({ ...point })),
+		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 updateCollection(sessionId, path, update) {
+	const normalized = normalizeAuthorPath(path);
+	const document = authorDocument(sessionId, normalized);
+	if (document === void 0) return;
+	updateSession(sessionId, (session) => {
+		const current = authorDocumentAnnotations(sessionId, normalized);
+		const base = current === EMPTY_COLLECTION ? {
+			...EMPTY_COLLECTION,
+			revision: document.version,
+			sourceSha256: document.sourceSha256
+		} : current;
+		const next = update(base);
+		if (next === base) return session;
+		return {
+			...session,
+			annotationsByDocument: {
+				...session.annotationsByDocument,
+				[normalized]: {
+					...next,
+					stale: false,
+					updatedAt: Date.now()
+				}
+			}
+		};
+	});
+}
+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-semibold text-doom-red",
+					children: [AUTHOR_GRID_COLUMNS[column], row + 1]
+				})
+			}, index);
+		})
+	});
+}
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/_lib/authorCanvasState.ts
+const canvasAliases = new Store({});
+const canvasPaths = new Store({});
+const canvasFailures = new Store({});
+const authorCanvasAlias = (sessionId, path) => canvasAliases.state[authorDocumentKey(sessionId, path)];
+/** Keep freehand evidence small and source-relative. Reject malformed geometry rather than degrading it into a crop. */
+function validAuthorStroke(value) {
+	return Array.isArray(value) && value.length >= 2 && value.length <= 128 && value.some((point) => point.x !== value[0]?.x || point.y !== value[0]?.y) && value.every((point) => typeof point === "object" && point !== null && Number.isFinite(point.x) && Number.isFinite(point.y) && point.x >= 0 && point.x <= 1 && point.y >= 0 && point.y <= 1);
+}
+function authorStrokeBounds(points) {
+	if (!validAuthorStroke(points)) return null;
+	const left = Math.min(...points.map((point) => point.x));
+	const top = Math.min(...points.map((point) => point.y));
+	const right = Math.max(...points.map((point) => point.x));
+	const bottom = Math.max(...points.map((point) => point.y));
+	const x = Math.max(0, Math.min(left, .999));
+	const y = Math.max(0, Math.min(top, .999));
+	return {
+		x,
+		y,
+		width: Math.min(1 - x, Math.max(right - x, .001)),
+		height: Math.min(1 - y, Math.max(bottom - y, .001))
+	};
+}
+function appendAuthorStrokePoint(points, point) {
+	if (!Number.isFinite(point.x) || !Number.isFinite(point.y)) return points;
+	const next = {
+		x: Math.max(0, Math.min(1, point.x)),
+		y: Math.max(0, Math.min(1, point.y))
+	};
+	if (points.length >= 128) return points;
+	const last = points.at(-1);
+	return last?.x === next.x && last.y === next.y ? points : [...points, next];
+}
+/** 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)/_lib/authorCapture.ts
+const AUTHOR_CAPTURE_MAX_DIMENSION = 1600;
+const AUTHOR_PACKET_MAX_BYTES = 65536;
+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, alias) {
+	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,
+			...alias === void 0 ? {} : { alias },
+			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.stroke !== void 0 && (!validAuthorStroke(region.stroke) || !("rect" in region.anchor) || region.mode !== "region")) throw new Error(`Region ${String(index + 1)} has invalid feedback stroke geometry.`);
+			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),
+				...region.stroke === void 0 ? {} : { stroke: region.stroke.map((point) => ({ ...point })) },
+				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)}`;
+}
+/** Context stays below the host limit even when paths and anchor locations are unusually long. */
+function authorDocumentContextContent(path, alias, annotations) {
+	const heading = `Author document: ${path}${alias === void 0 ? "" : ` (canvas ${alias})`}`;
+	const drafts = annotations.map((region, index) => `(${index + 1}) ${region.comment.slice(0, 1e3)} [${anchorLocation(region.anchor)}]`);
+	return utf8Prefix([heading, ...drafts.length === 0 ? [] : ["Unsent annotations (not yet submitted):", ...drafts]].join("\n"), AUTHOR_PACKET_MAX_BYTES);
+}
+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: `Author document: ${packet.document.path}${packet.document.alias === void 0 ? "" : ` (canvas ${packet.document.alias})`}\n${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 (region.stroke !== void 0) {
+					if (!validAuthorStroke(region.stroke)) throw new Error("Invalid feedback stroke geometry.");
+					context.beginPath();
+					region.stroke.forEach((point, index) => {
+						const x = drawX + point.x * drawWidth;
+						const y = drawY + point.y * drawHeight;
+						if (index === 0) context.moveTo(x, y);
+						else context.lineTo(x, y);
+					});
+					context.strokeStyle = annotationColor;
+					context.lineWidth = Math.max(3, Math.min(drawWidth, drawHeight) / 150);
+					context.lineCap = "round";
+					context.lineJoin = "round";
+					context.stroke();
+					labelX = drawX + region.stroke[0].x * drawWidth;
+					labelY = drawY + region.stroke[0].y * drawHeight;
+				} else 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, path, drafts }) {
+	const [error, setError] = useState();
+	const add = () => {
+		try {
+			commitAuthorRegion(sessionId, path, drafts.candidateText);
+			setError(void 0);
+		} catch (reason) {
+			setError(reason instanceof Error ? reason.message : String(reason));
+		}
+	};
+	if (!drafts.candidate && drafts.annotations.length === 0) return null;
+	const candidateKind = drafts.candidate?.mode === "point" ? "point" : "region";
+	return /* @__PURE__ */ jsxs("section", {
+		className: "space-y-2",
+		"data-testid": "author-region-drafts",
+		children: [
+			drafts.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."
+					]
+				}),
+				drafts.candidate.anchor.kind === "video-time-rect" || drafts.candidate.anchor.kind === "video-time-point" ? /* @__PURE__ */ jsxs("p", {
+					className: "text-base text-doom-dim sm:text-sm",
+					children: [
+						"Frame at ",
+						drafts.candidate.anchor.timeSeconds.toFixed(3),
+						"s"
+					]
+				}) : null,
+				/* @__PURE__ */ jsx("textarea", {
+					"aria-label": "Annotation comment",
+					value: drafts.candidateText,
+					onChange: (event) => setAuthorCandidateText(sessionId, path, 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: !drafts.candidate || !drafts.candidateText.trim() || drafts.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, path, void 0);
+						setAuthorCandidateText(sessionId, path, "");
+						setError(void 0);
+					},
+					children: "Discard annotation"
+				})
+			] }) : null,
+			error ? /* @__PURE__ */ jsx("output", {
+				className: "block text-base text-doom-red",
+				children: error
+			}) : null,
+			drafts.annotations.length > 0 ? /* @__PURE__ */ jsxs("h3", {
+				className: "text-base font-semibold text-doom-text",
+				children: [
+					"Unsent annotations (",
+					drafts.annotations.length,
+					")"
+				]
+			}) : null,
+			/* @__PURE__ */ jsx("ol", {
+				className: "space-y-2",
+				children: drafts.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: drafts.candidate !== void 0,
+							onClick: () => {
+								if (region.anchor.kind === "video-time-rect" || region.anchor.kind === "video-time-point") seekAuthorVideo(sessionId, path, 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, path, region.id),
+							children: "remove"
+						})
+					]
+				}, region.id))
+			})
+		]
+	});
+}
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/dock/_components/AuthorFeedbackControls.tsx
+function AuthorFeedbackControls({ sessionId, document, drafts, submitCapture }) {
+	const [status, setStatus] = useState();
+	const [capturing, setCapturing] = useState(false);
+	return /* @__PURE__ */ jsxs("div", {
+		className: "space-y-2",
+		children: [
+			/* @__PURE__ */ jsx(AuthorRegionDrafts, {
+				sessionId,
+				path: document.path,
+				drafts
+			}),
+			drafts.annotations.length > 0 ? /* @__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 || drafts.candidate !== void 0 || submitCapture === void 0,
+				onClick: async () => {
+					if (capturing || drafts.candidate || submitCapture === void 0) return;
+					setCapturing(true);
+					setStatus("Submitting annotations…");
+					try {
+						const packet = createAuthorCapturePacket(crypto.randomUUID(), Date.now(), document, drafts.annotations, authorCanvasAlias(sessionId, document.path));
+						await submitCapture({
+							...await multiRegionCaptureProvider(drafts.annotations).capture(),
+							context: authorCaptureContext(packet)
+						});
+						setStatus("Request submitted. You can keep annotating here.");
+					} catch (reason) {
+						setStatus(reason instanceof Error ? reason.message : String(reason));
+					} finally {
+						setCapturing(false);
+					}
+				},
+				children: capturing ? "Submitting…" : `Submit ${drafts.annotations.length} annotation${drafts.annotations.length === 1 ? "" : "s"}`
+			}) : null,
+			submitCapture === void 0 ? /* @__PURE__ */ jsx("output", {
+				className: "text-sm text-doom-red",
+				children: "Submission unavailable. Reload to update the app."
+			}) : null,
+			status ? /* @__PURE__ */ jsx("output", {
+				className: "block text-sm text-doom-dim",
+				children: status
+			}) : null
+		]
+	});
+}
+//#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-lg font-semibold text-doom-hi",
+					children: "Document context"
+				}), /* @__PURE__ */ jsxs("p", {
+					className: "mt-2 flex items-center gap-2 truncate text-base font-semibold 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: "text-sm font-medium 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-base italic leading-relaxed text-doom-text",
+								children: [
+									"“",
+									region.quote,
+									"”"
+								]
+							}) : null,
+							/* @__PURE__ */ jsx("p", {
+								className: "text-base 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: "text-sm font-semibold",
+						children: [
+							"●",
+							" ",
+							request.status === "CHANGING" ? "Working" : request.status === "COMPLETE" ? "Completed" : request.status === "FAILED" ? "Error" : STATUS_LABELS[request.status]
+						]
+					}),
+					/* @__PURE__ */ jsx("p", {
+						className: "mt-2 text-base leading-relaxed text-doom-hi",
+						children: request.currentOperation || STATUS_LABELS[request.status]
+					}),
+					request.error ? /* @__PURE__ */ jsx("p", {
+						className: "mt-2 text-sm 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-base 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-lg font-semibold text-doom-hi",
+					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-base leading-relaxed text-doom-text",
+						children: instruction || "No additional instruction."
+					})
+				})]
+			}),
+			/* @__PURE__ */ jsx("footer", {
+				className: "text-sm 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-lg font-semibold text-doom-hi",
+				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-base font-medium text-doom-dim",
+					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, path, kind, activeTool }) {
+	const [error, setError] = useState();
+	const format = (style) => {
+		const selected = authorDocumentAnnotations(sessionId, path).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, path, void 0);
+		setError(void 0);
+	};
+	const tools = [
+		...[
+			"image",
+			"pdf",
+			"video",
+			"story-preview"
+		].includes(kind) ? [{
+			label: "Pan",
+			glyph: "✋",
+			action: () => setAuthorToolMode(sessionId, path, activeTool === "pan" ? "select" : "pan"),
+			active: activeTool === "pan"
+		}, {
+			label: "Draw",
+			glyph: "✎",
+			action: () => setAuthorToolMode(sessionId, path, activeTool === "draw" ? "select" : "draw"),
+			active: activeTool === "draw"
+		}] : [],
+		{
+			label: "Region",
+			glyph: "⌗",
+			action: () => setAuthorToolMode(sessionId, path, 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, path, 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: "text-lg font-semibold text-doom-hi",
+					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 ${tool.active ? "border-doom-red bg-doom-red/10 text-doom-hi 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",
+				children: activeTool === "draw" ? "Draw a location mark, then enter feedback text. Marks never edit the source." : activeTool === "pan" ? "Drag to pan; pinch to zoom. Use Fit to reset the view." : 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 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 focusedPath = workspace?.focusedDocument?.path;
+	const requests = (workspace?.requests ?? []).filter((request) => focusedPath === void 0 || request.documentPath === focusedPath);
+	const drafts = useStore(authorWorkspace.store, (state) => authorDocumentAnnotations(sessionId, focusedPath ?? "", state));
+	const activity = sessionId !== null && focusedPath !== void 0 && requests.some((request) => request.status === "REQUESTED" || request.status === "CHANGING") ? renderSessionActivity?.() ?? null : 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,
+							path: focused.path,
+							kind: focused.kind,
+							activeTool: workspace.toolsByDocument[normalizeAuthorPath(focused.path)] ?? "select"
+						}),
+						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("div", {
+							className: "hidden sm:block",
+							children: /* @__PURE__ */ jsx(AuthorFeedbackControls, {
+								sessionId,
+								document: focused,
+								drafts,
+								submitCapture
+							}, focused.path)
+						})
+					] }) : null,
+					/* @__PURE__ */ jsx(AuthorRequestLog, { 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/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"
+	},
+	bridgeClose: {
+		method: "POST",
+		path: "/bridge/close"
+	},
+	bridgeDescribe: {
+		method: "GET",
+		path: "/bridge/describe",
+		query: ["alias"]
+	},
+	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/authorPreview.ts
+function parseAuthorOpenSourceAction(input) {
+	if (typeof input !== "object" || input === null) return null;
+	const candidate = input;
+	return candidate.version === 1 && typeof candidate.createTab === "function" ? candidate : null;
+}
+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/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);
+		if (!("fragments" in parsed) || !Array.isArray(parsed.fragments)) throw new Error("Author returned an invalid structured document.");
+		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 = authorDocumentAnnotations(sessionId, path)?.annotations.find((candidate) => candidate.id === regionId) ?? workspace.requests.filter((request) => request.documentPath === path && (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.stroke !== void 0) throw new Error("UNSUPPORTED_REGION: Freehand feedback cannot authorize a document mutation.");
+	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.documentPath === path && candidate.status === "REQUESTED" && (candidate.pendingRegions ?? candidate.regions).some((item) => item.id === regionId));
+			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)/_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 pointers = useRef(/* @__PURE__ */ new Map());
+	const pan = useRef(void 0);
+	const pinch = useRef(void 0);
+	const [zoom, setZoom] = useState(1);
+	const [stroke, setStroke] = useState();
+	const [pdfPlane, setPdfPlane] = useState();
+	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();
+	useEffect(() => {
+		start.current = void 0;
+		pointers.current.clear();
+		pinch.current = void 0;
+		pan.current = void 0;
+		setStroke(void 0);
+		setSelection(void 0);
+		setZoom(1);
+	}, [
+		source.path,
+		source.version,
+		source.sourceSha256,
+		source.mediaUrl
+	]);
+	useEffect(() => {
+		start.current = void 0;
+		setStroke(void 0);
+		pointers.current.clear();
+		pinch.current = void 0;
+		pan.current = void 0;
+	}, [activeTool]);
+	const mediaUrl = media?.source === source.mediaUrl ? media?.url : void 0;
+	useEffect(() => {
+		if (source.kind !== "pdf" || mediaUrl === void 0) return;
+		const container = host.current;
+		if (container === null) return;
+		const update = () => {
+			const canvas = container.querySelector("canvas");
+			const wrapper = container.querySelector("[data-testid=\"author-media\"]");
+			if (!canvas || !wrapper) return;
+			const bounds = canvas.getBoundingClientRect();
+			const outer = wrapper.getBoundingClientRect();
+			const next = {
+				left: (bounds.left - outer.left) / zoom,
+				top: (bounds.top - outer.top) / zoom,
+				width: bounds.width / zoom,
+				height: bounds.height / zoom
+			};
+			setPdfPlane((current) => current && Object.keys(next).every((key) => Math.abs(current[key] - next[key]) < .01) ? current : next);
+		};
+		const resize = new ResizeObserver(update);
+		const mutation = new MutationObserver(() => {
+			const canvas = container.querySelector("canvas");
+			if (canvas) resize.observe(canvas);
+			update();
+		});
+		mutation.observe(container, {
+			childList: true,
+			subtree: true
+		});
+		const canvas = container.querySelector("canvas");
+		if (canvas) resize.observe(canvas);
+		update();
+		return () => {
+			resize.disconnect();
+			mutation.disconnect();
+		};
+	}, [
+		source.kind,
+		mediaUrl,
+		zoom
+	]);
+	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 (authorDocumentAnnotations(sessionId, source.path).candidate || !Number.isFinite(seconds)) return;
+		const player = video.current;
+		if (!player) return;
+		player.pause();
+		setAuthorToolMode(sessionId, source.path, "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;
+		if (!drag || drag.pointerId !== event.pointerId || pinch.current !== void 0) return;
+		start.current = void 0;
+		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 points = drag.mode === "draw" ? appendAuthorStrokePoint(drag.points, point) : void 0;
+		const rect = drag.mode === "draw" ? authorStrokeBounds(points ?? []) : drag.mode === "mark" ? normalizedAuthorRectangle(bounds, {
+			left: drag.x,
+			top: drag.y,
+			right: event.clientX,
+			bottom: event.clientY
+		}) : void 0;
+		if (drag.mode !== "comment" && !rect) return;
+		setStroke(void 0);
+		setSelection(drag.mode === "draw" ? void 0 : 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 !== "comment" ? {
+					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 !== "comment" ? {
+					kind: "pdf-page-rect",
+					page: page.page,
+					rect
+				} : {
+					kind: "pdf-page-point",
+					page: page.page,
+					point
+				};
+				blob = await pdf.current.capturePage();
+				if (pdf.current?.getState().page !== page.page) return;
+			} else {
+				const frame = await video.current?.captureFrame();
+				if (!frame) throw new Error("Video frame is not ready.");
+				anchor = drag.mode !== "comment" ? {
+					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 (Math.abs((video.current?.getState().currentTime ?? -1) - frame.timeSeconds) > .1 || video.current?.isFrameReady() === false) return;
+			}
+			if (!blob) throw new Error("Unable to capture selected media.");
+			if (authorSessionWorkspace(sessionId).focusedDocument?.generation !== focused.generation) return;
+			thumbnailUrl = URL.createObjectURL(blob);
+			setAuthorRegionCandidate(sessionId, source.path, {
+				documentPath: source.path,
+				revision: source.version,
+				sourceSha256: source.sourceSha256,
+				mode: drag.mode === "comment" ? "point" : "region",
+				anchor,
+				...points === void 0 ? {} : { stroke: points },
+				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 strokeOverlay = (points, ordinal) => points === void 0 ? null : /* @__PURE__ */ jsx("svg", {
+		"data-testid": ordinal === void 0 ? "author-media-stroke-selection" : "author-media-stroke",
+		"data-author-stroke": ordinal,
+		"aria-hidden": "true",
+		className: "pointer-events-none absolute inset-0 h-full w-full overflow-visible",
+		viewBox: "0 0 1000 1000",
+		preserveAspectRatio: "none",
+		children: /* @__PURE__ */ jsx("polyline", {
+			points: points.map((point) => `${String(point.x * 1e3)},${String(point.y * 1e3)}`).join(" "),
+			fill: "none",
+			stroke: "currentColor",
+			strokeWidth: "5",
+			strokeLinecap: "round",
+			strokeLinejoin: "round",
+			className: ordinal === void 0 ? "text-doom-red" : "text-doom-yellow"
+		})
+	});
+	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-semibold ${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: { cursor: activeTool === "draw" || activeTool === "mark" ? "crosshair" : void 0 },
+		onPointerMove: (event) => {
+			if (pointers.current.has(event.pointerId)) pointers.current.set(event.pointerId, {
+				x: event.clientX,
+				y: event.clientY
+			});
+			if (pinch.current !== void 0 && pointers.current.size >= 2) {
+				const [a, b] = [...pointers.current.values()];
+				const distance = Math.hypot(a.x - b.x, a.y - b.y);
+				if (pinch.current.distance > 0) setZoom(Math.min(8, Math.max(1, pinch.current.zoom * distance / pinch.current.distance)));
+				return;
+			}
+			if (pan.current !== void 0 && activeTool === "pan") {
+				const element = host.current;
+				if (element) {
+					element.scrollLeft = pan.current.left + pan.current.x - event.clientX;
+					element.scrollTop = pan.current.top + pan.current.y - event.clientY;
+				}
+				return;
+			}
+			const drag = start.current;
+			if (drag?.pointerId !== event.pointerId) return;
+			if (drag.mode === "draw") {
+				const bounds = drag.element.getBoundingClientRect();
+				if (bounds.width <= 0 || bounds.height <= 0) return;
+				drag.points = appendAuthorStrokePoint(drag.points, {
+					x: (event.clientX - bounds.left) / bounds.width,
+					y: (event.clientY - bounds.top) / bounds.height
+				});
+				setStroke(drag.points);
+				return;
+			}
+			if (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 (event.button !== 0) return;
+			const element = event.target;
+			if (!(element instanceof HTMLImageElement || element instanceof HTMLVideoElement || element instanceof HTMLCanvasElement)) return;
+			pointers.current.set(event.pointerId, {
+				x: event.clientX,
+				y: event.clientY
+			});
+			if (pointers.current.size === 2) {
+				start.current = void 0;
+				setStroke(void 0);
+				setSelection(void 0);
+				pan.current = void 0;
+				const [a, b] = [...pointers.current.values()];
+				pinch.current = {
+					distance: Math.hypot(a.x - b.x, a.y - b.y),
+					zoom
+				};
+				event.currentTarget.setPointerCapture(event.pointerId);
+				return;
+			}
+			if (activeTool === "pan") {
+				const container = host.current;
+				if (container) pan.current = {
+					x: event.clientX,
+					y: event.clientY,
+					left: container.scrollLeft,
+					top: container.scrollTop
+				};
+				event.currentTarget.setPointerCapture(event.pointerId);
+				return;
+			}
+			if (activeTool !== "mark" && activeTool !== "comment" && activeTool !== "draw" || pendingCandidate) 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();
+			}
+			const bounds = element.getBoundingClientRect();
+			start.current = {
+				x: event.clientX,
+				y: event.clientY,
+				pointerId: event.pointerId,
+				mode: activeTool,
+				element,
+				points: activeTool === "draw" ? [{
+					x: (event.clientX - bounds.left) / bounds.width,
+					y: (event.clientY - bounds.top) / bounds.height
+				}] : []
+			};
+			event.currentTarget.setPointerCapture(event.pointerId);
+		},
+		onPointerUp: (event) => {
+			if (pinch.current === void 0 && pan.current === void 0) mark(event);
+			pointers.current.delete(event.pointerId);
+			pan.current = void 0;
+			if (pointers.current.size < 2) pinch.current = void 0;
+		},
+		onPointerCancel: (event) => {
+			pointers.current.delete(event.pointerId);
+			pinch.current = void 0;
+			pan.current = void 0;
+			start.current = void 0;
+			setStroke(void 0);
+			setSelection(void 0);
+		},
+		onLostPointerCapture: () => {
+			start.current = void 0;
+			pan.current = void 0;
+			setStroke(void 0);
+		},
+		children: [
+			/* @__PURE__ */ jsxs("div", {
+				className: "sticky top-0 z-20 mb-2 flex items-center gap-2 bg-doom-bg py-1",
+				role: "group",
+				"aria-label": "Canvas zoom",
+				children: [
+					/* @__PURE__ */ jsx(Button, {
+						size: "md",
+						variant: "outline",
+						"aria-label": "Zoom out",
+						className: "min-h-11 min-w-11",
+						onClick: () => setZoom((current) => Math.max(1, current / 1.5)),
+						children: "−"
+					}),
+					/* @__PURE__ */ jsxs("output", {
+						className: "text-sm text-doom-dim",
+						children: [Math.round(zoom * 100), "%"]
+					}),
+					/* @__PURE__ */ jsx(Button, {
+						size: "md",
+						variant: "outline",
+						"aria-label": "Zoom in",
+						className: "min-h-11 min-w-11",
+						onClick: () => setZoom((current) => Math.min(8, current * 1.5)),
+						children: "+"
+					}),
+					/* @__PURE__ */ jsx(Button, {
+						size: "md",
+						variant: "outline",
+						"aria-label": "Fit canvas",
+						className: "min-h-11",
+						onClick: () => {
+							setZoom(1);
+							if (host.current) {
+								host.current.scrollLeft = 0;
+								host.current.scrollTop = 0;
+							}
+						},
+						children: "Fit"
+					})
+				]
+			}),
+			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",
+				style: {
+					zoom,
+					touchAction: activeTool === "select" ? "auto" : "none"
+				},
+				children: [
+					/* @__PURE__ */ jsx("img", {
+						ref: image,
+						src: mediaUrl,
+						alt: source.path,
+						draggable: false,
+						className: "block max-w-full"
+					}),
+					selectionOverlay,
+					pointSelectionOverlay,
+					strokeOverlay(stroke),
+					displayedRegions.flatMap(({ ordinal, region }) => {
+						if (region.stroke !== void 0) return [/* @__PURE__ */ jsxs("div", {
+							className: "pointer-events-none absolute inset-0",
+							children: [strokeOverlay(region.stroke, ordinal), pointPin(ordinal, region.stroke[0], `label:${region.id}`)]
+						}, region.id)];
+						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-semibold text-doom-deep",
+								children: ordinal
+							})
+						}, region.id)];
+					})
+				]
+			}) : /* @__PURE__ */ jsxs("div", {
+				className: "relative w-fit max-w-full",
+				style: {
+					zoom,
+					touchAction: activeTool === "select" ? "auto" : "none"
+				},
+				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);
+					}
+				}), /* @__PURE__ */ jsxs("div", {
+					className: "pointer-events-none absolute",
+					style: source.kind === "pdf" ? pdfPlane === void 0 ? { display: "none" } : {
+						left: pdfPlane.left,
+						top: pdfPlane.top,
+						width: pdfPlane.width,
+						height: pdfPlane.height
+					} : { inset: 0 },
+					children: [
+						selectionOverlay,
+						pointSelectionOverlay,
+						strokeOverlay(stroke),
+						displayedRegions.map(({ ordinal, region }) => {
+							if (region.stroke !== void 0) {
+								const anchor = region.anchor;
+								if (source.kind === "pdf" && (anchor.kind !== "pdf-page-rect" || anchor.page !== pdf.current?.getState().page)) return null;
+								if (source.kind === "video" && (anchor.kind !== "video-time-rect" || playback.playing || Math.abs(anchor.timeSeconds - playback.currentTime) > .1)) return null;
+								return /* @__PURE__ */ jsxs("div", {
+									className: "pointer-events-none absolute inset-0",
+									children: [strokeOverlay(region.stroke, ordinal), pointPin(ordinal, region.stroke[0], `label:${region.id}`)]
+								}, region.id);
+							}
+							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, source.path, "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, source.path, "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-sm text-doom-dim",
+			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-sm text-doom-dim",
+				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-semibold 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, document.path, {
+									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-base 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-base 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, document.path, {
+					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
+const pendingCanvases = /* @__PURE__ */ new Map();
+const canvasOwners = /* @__PURE__ */ new Map();
+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)}`;
+}
+/** Unsent annotations only. Sent ones live in the request log, not on the canvas. */
+function displayedAuthorRegions(workspace) {
+	return (workspace?.annotations ?? []).map((region, index) => ({
+		ordinal: index + 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 { sessionId, statuses } = props;
+	const path = useStore(canvasPaths, (state) => sessionId === null ? props.path : state[authorDocumentKey(sessionId, props.path)] ?? props.path);
+	const alias = useStore(canvasAliases, (state) => props.alias ?? (sessionId === null ? void 0 : state[authorDocumentKey(sessionId, props.path)]));
+	const loadFailure = useStore(canvasFailures, (state) => sessionId === null ? void 0 : state[authorDocumentKey(sessionId, props.path)]);
+	const document = useStore(authorWorkspace.store, (state) => sessionId === null ? void 0 : state.documents[authorDocumentKey(sessionId, path)]);
+	const workspace = useStore(authorWorkspace.store, (state) => sessionId === null ? void 0 : state.sessions[sessionId]);
+	const drafts = useStore(authorWorkspace.store, (state) => authorDocumentAnnotations(sessionId, path, state));
+	const activeTool = workspace?.toolsByDocument[normalizeAuthorPath(path)] ?? "select";
+	const [markdownPreview, setMarkdownPreview] = useState(true);
+	const [status, setStatus] = useState();
+	const previewSelection = workspace?.previewSelections?.[normalizeAuthorPath(props.path)] ?? workspace?.previewSelections?.[normalizeAuthorPath(path)];
+	const [previewOpen, setPreviewOpen] = useState(previewSelection !== void 0);
+	useEffect(() => {
+		if (previewSelection !== void 0) setPreviewOpen(true);
+	}, [previewSelection]);
+	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,
+		...previewSelection === void 0 ? {} : { preview: previewSelection }
+	};
+	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 (sessionId === null) return;
+		const generation = focusAuthorDocument(sessionId, path);
+		return () => releaseAuthorDocumentFocus(sessionId, generation);
+	}, [path, sessionId]);
+	useEffect(() => {
+		if (kind === void 0 || sessionId === null || alias === void 0) return;
+		const profiles = authorProfilesForDocument(sessionId, path, kind);
+		let release;
+		let cancelled = false;
+		focusAuthorViewport(sessionId, profiles, alias).then((nextRelease) => {
+			if (cancelled) nextRelease();
+			else release = nextRelease;
+		});
+		return () => {
+			cancelled = true;
+			release?.();
+		};
+	}, [
+		alias,
+		kind,
+		path,
+		sessionId
+	]);
+	if (document === void 0 || sessionId === null) return /* @__PURE__ */ jsx("p", {
+		className: "p-4 text-sm text-doom-dim",
+		children: loadFailure ?? 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(drafts);
+	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,
+			stroke: region.stroke
+		}];
+		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: drafts.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__ */ jsxs("strong", {
+						className: "min-w-0 flex-1 truncate text-base text-doom-hi",
+						children: [alias === void 0 ? "" : `${alias} · `, 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-sm text-doom-dim",
+				children: status
+			}),
+			[
+				"image",
+				"pdf",
+				"video",
+				"story-preview"
+			].includes(document.kind) ? /* @__PURE__ */ jsx("nav", {
+				"aria-label": "Author canvas tools",
+				className: "flex shrink-0 gap-1 overflow-x-auto border-b border-doom-border px-2 py-1 sm:hidden",
+				children: [
+					"select",
+					"pan",
+					"mark",
+					"comment",
+					"draw"
+				].map((mode) => /* @__PURE__ */ jsx(Button, {
+					size: "xs",
+					variant: activeTool === mode ? "primary" : "outline",
+					className: "min-h-11 min-w-11 shrink-0",
+					"aria-label": `${mode} tool`,
+					"aria-pressed": activeTool === mode,
+					onClick: () => setAuthorToolMode(sessionId, document.path, mode),
+					children: mode
+				}, mode))
+			}) : null,
+			/* @__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: drafts.candidate !== void 0,
+					onAnnotationCandidate: (candidate) => {
+						setAuthorStoryPreview(sessionId, document.path, candidate.preview);
+						setAuthorRegionCandidate(sessionId, document.path, {
+							documentPath: document.path,
+							revision: document.version,
+							sourceSha256: document.sourceSha256,
+							mode: candidate.mode,
+							stroke: candidate.stroke,
+							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
+				})]
+			}),
+			[
+				"image",
+				"pdf",
+				"video",
+				"story-preview"
+			].includes(document.kind) ? /* @__PURE__ */ jsx("div", {
+				className: "max-h-56 shrink-0 overflow-y-auto border-t border-doom-border p-2 sm:hidden",
+				children: /* @__PURE__ */ jsx(AuthorFeedbackControls, {
+					sessionId,
+					document,
+					drafts,
+					submitCapture: props.submitCapture
+				})
+			}) : null
+		]
+	});
+}
+const authorOpenSourceAction = {
+	version: 1,
+	createTab({ sessionId, path, preview }) {
+		const normalized = normalizeAuthorPath(path);
+		if (sessionId.trim() === "" || normalized === "" || path.startsWith("/") || /^[A-Za-z]:/.test(path) || path.replaceAll("\\", "/").split("/").includes("..")) throw new Error("Author source opening requires a session and a repository-relative path.");
+		if (preview !== void 0 && (typeof preview.appPath !== "string" || preview.appPath.trim() === "" || typeof preview.storyExport !== "string" || !/^[A-Za-z_$][A-Za-z0-9_$]*$/.test(preview.storyExport) || preview.snapshot !== void 0 && typeof preview.snapshot !== "boolean")) throw new Error("Author preview requires a project and an exact story export.");
+		const canonical = canvasPaths.state[authorDocumentKey(sessionId, normalized)] ?? normalized;
+		const prefix = `${sessionId}\n`;
+		const tabPath = (Object.entries(canvasPaths.state).find(([key, path]) => key.startsWith(prefix) && path === canonical)?.[0])?.slice(prefix.length) ?? normalized;
+		setAuthorPreviewSelection(sessionId, tabPath, preview);
+		if (canonical !== tabPath) setAuthorPreviewSelection(sessionId, canonical, preview);
+		return authorFileTab(tabPath, canvasAliases.state[authorDocumentKey(sessionId, tabPath)]);
+	}
+};
+function authorFileTab(path, preferredAlias) {
+	const normalized = normalizeAuthorPath(path);
+	return {
+		id: tabId(normalized),
+		label: preferredAlias === void 0 ? normalized.split("/").at(-1) ?? normalized : `${preferredAlias} · ${normalized.split("/").at(-1) ?? normalized}`,
+		retainComposer: true,
+		composerContext(sessionId) {
+			const key = authorDocumentKey(sessionId, normalized);
+			const documentPath = canvasPaths.state[key] ?? normalized;
+			const alias = canvasAliases.state[key];
+			const name = documentPath.split("/").at(-1) ?? documentPath;
+			return {
+				kind: "author-document",
+				source: "author",
+				id: documentPath,
+				label: alias === void 0 ? name : `${alias} · ${name}`,
+				content: authorDocumentContextContent(documentPath, alias, authorDocumentAnnotations(sessionId, documentPath).annotations)
+			};
+		},
+		onOpen(sessionId) {
+			const key = authorDocumentKey(sessionId, normalized);
+			const controller = new AbortController();
+			pendingCanvases.set(key, controller);
+			canvasFailures.setState((state) => {
+				const next = { ...state };
+				delete next[key];
+				return next;
+			});
+			(async () => {
+				const result = await api.session(sessionId).documentsOpen({
+					body: {
+						path: normalized,
+						...preferredAlias === void 0 ? {} : { alias: preferredAlias }
+					},
+					query: { session: sessionId },
+					signal: controller.signal
+				});
+				if (!result.ok) throw new Error(result.error);
+				if (!("alias" in result.data) || typeof result.data.alias !== "string") throw new Error("The Author canvas did not return an alias. Reopen the document.");
+				const opened = result.data;
+				const canonicalAlias = opened.alias;
+				if (controller.signal.aborted || pendingCanvases.get(key) !== controller) {
+					if ((canvasOwners.get(`${sessionId}\n${canonicalAlias}`)?.size ?? 0) === 0) api.session(sessionId).bridgeClose({ body: { alias: canonicalAlias } }).catch(() => void 0);
+					return;
+				}
+				canvasAliases.setState((state) => ({
+					...state,
+					[key]: canonicalAlias,
+					[authorDocumentKey(sessionId, opened.path)]: canonicalAlias
+				}));
+				canvasPaths.setState((state) => ({
+					...state,
+					[key]: opened.path
+				}));
+				const ownerKey = `${sessionId}\n${canonicalAlias}`;
+				const owners = canvasOwners.get(ownerKey) ?? /* @__PURE__ */ new Set();
+				owners.add(key);
+				canvasOwners.set(ownerKey, owners);
+				const documentKey = authorDocumentKey(sessionId, opened.path);
+				if (authorWorkspace.store.state.documents[documentKey] === void 0) {
+					const loaded = await loadAuthorDocument(sessionId, opened.path, controller.signal);
+					if (controller.signal.aborted || pendingCanvases.get(key) !== controller) return;
+					putAuthorDocument(sessionId, loaded);
+				}
+				const document = authorWorkspace.store.state.documents[documentKey];
+				if (document !== void 0 && !controller.signal.aborted) await openAuthorCanvas(sessionId, canonicalAlias, authorProfilesForDocument(sessionId, opened.path, document.kind));
+			})().catch((error) => {
+				if (!controller.signal.aborted) canvasFailures.setState((state) => ({
+					...state,
+					[key]: error instanceof Error ? error.message : String(error)
+				}));
+			}).finally(() => {
+				if (pendingCanvases.get(key) === controller) pendingCanvases.delete(key);
+			});
+		},
+		onClose(sessionId) {
+			const key = authorDocumentKey(sessionId, normalized);
+			const canonical = canvasPaths.state[key] ?? normalized;
+			setAuthorToolMode(sessionId, canonical, "select");
+			setAuthorPreviewSelection(sessionId, normalized, void 0);
+			if (canonical !== normalized) setAuthorPreviewSelection(sessionId, canonical, void 0);
+			pendingCanvases.get(key)?.abort();
+			pendingCanvases.delete(key);
+			const alias = canvasAliases.state[key] ?? preferredAlias;
+			if (alias === void 0) {
+				api.session(sessionId).documentsOpen({
+					body: { path: normalized },
+					query: { session: sessionId }
+				}).then((result) => {
+					if (!result.ok || !("alias" in result.data) || typeof result.data.alias !== "string") return;
+					const recoveredAlias = result.data.alias;
+					if ((canvasOwners.get(`${sessionId}\n${recoveredAlias}`)?.size ?? 0) === 0) api.session(sessionId).bridgeClose({ body: { alias: recoveredAlias } }).catch(() => void 0);
+				}).catch(() => void 0);
+				return;
+			}
+			const owners = canvasOwners.get(`${sessionId}\n${alias}`);
+			owners?.delete(key);
+			if (owners !== void 0 && owners.size === 0) canvasOwners.delete(`${sessionId}\n${alias}`);
+			const lastOwner = owners === void 0 || owners.size === 0;
+			if (lastOwner) dropAuthorViewportSession(sessionId, alias);
+			canvasAliases.setState((state) => {
+				const next = { ...state };
+				delete next[key];
+				return next;
+			});
+			canvasPaths.setState((state) => {
+				const next = { ...state };
+				delete next[key];
+				return next;
+			});
+			canvasFailures.setState((state) => {
+				const next = { ...state };
+				delete next[key];
+				return next;
+			});
+			if (lastOwner) api.session(sessionId).bridgeClose({ body: { alias } }).catch(() => void 0);
+		},
+		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, canvasAliases.state[authorDocumentKey(sessionId, normalized)]);
+	},
+	openPath(sessionId, path) {
+		if (sessionId === null) return void 0;
+		const normalized = normalizeAuthorPath(path);
+		return normalized === "" ? void 0 : authorFileTab(normalized, canvasAliases.state[authorDocumentKey(sessionId, normalized)]);
+	}
+});
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/fill/Author.author.open-source.web.ts
+var Author_author_open_source_web_default = defineFill({
+	slot: "author.open-source",
+	id: "author",
+	data: authorOpenSourceAction
+});
+//#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 = "po-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 && finite(value.x) && finite(value.y) && value.x + value.width <= 1 && value.y + value.height <= 1;
+}
+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) && (value.stroke === void 0 || validAuthorStroke(value.stroke) && "rect" in value.anchor && value.mode === "region") && 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,
+		...candidate.stroke === void 0 ? {} : { stroke: candidate.stroke.map((point) => ({ ...point })) }
+	};
+}
+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 || value.regions.length > 16 || value.regions.some((region) => region.stroke !== void 0 && (!validAuthorStroke(region.stroke) || region.mode !== "region" || !("rect" in region.anchor)))) 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),
+			...region.stroke === void 0 ? {} : { stroke: region.stroke.map((point) => ({ ...point })) },
+			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, packet.document.path, region.id, region.version ?? 1);
+	}
+}
+/** 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/open-source.web.ts
+var open_source_web_default = defineSlotFile({
+	slot: "author.open-source",
+	parse: parseAuthorOpenSourceAction
+});
+//#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, alias) {
+	const tab = authorFileTab(path, alias);
+	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";
+	const alias = typeof result?.details === "object" && result.details !== null && "alias" in result.details && typeof result.details.alias === "string" ? result.details.alias : void 0;
+	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: alias === void 0 ? requestedPath : `${alias} · ${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, alias),
+					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);
+		const details = result?.details;
+		return path === void 0 ? void 0 : authorFileTab(path, typeof details?.alias === "string" ? details.alias : void 0);
+	}
+});
+//#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) => value === void 0 ? void 0 : {
+	...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 fills() {
+			return [via({
+				slot: "author.open-source",
+				id: "author"
+			}, Author_author_open_source_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.open-source" }, open_source_web_default),
+				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