@agimon-ai/po-author 0.0.0-alpha.41 → 0.0.0-alpha.43

package/dist/extensions/native.mjs

@@ -0,0 +1,3109 @@
+import { apiResponse, createApiClient, decodeBase64, defineChannelFile, defineFileLinks, defineFill, defineGlobalStore, defineNativePlugin, defineSessionStore, defineSlotFile, defineToolRenderer, defineWebLifecycle, encodeBase64, nativeApiTransport, sessionApiAddress } from "@agimon-ai/po-core/native";
+import { Store } from "@tanstack/store";
+import { Image } from "react-native-unistyles/components/native/Image";
+import { AnnotationSurface, Badge, Button, EmptyState, Markdown, MessageItem, MessageItemBody, MessageItemHeader, MessageItemStatus, SectionLabel, SegmentedControl, Spinner, Textarea, TrashIcon, collapseLines, fontOf, resultTextLines, toolTone } from "@agimon-ai/po-native-components";
+import { useCallback, useEffect, useRef, useState, useSyncExternalStore } from "react";
+import { AppState } from "react-native";
+import { View } from "react-native-unistyles/components/native/View";
+import { Text } from "react-native-unistyles/components/native/Text";
+import { ScrollView } from "react-native-unistyles/components/native/ScrollView";
+import { Pressable } from "react-native-unistyles/components/native/Pressable";
+import { StyleSheet } from "react-native-unistyles";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+//#region src/types/webAuthor.ts
+const authorChannelType = "author_webmcp";
+//#endregion
+//#region src/types/author.ts
+const AUTHOR_MODE_ID = "author";
+//#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}`;
+/** How long a refused viewport waits before asking again, so it takes over once the holder lets go. */
+const REJECTED_RETRY_MS = 1e4;
+/** Why the server refused a canvas here, usually another device holding the document for the agent. */
+const authorCanvasRejections = new Store({});
+const setRejection = (key, reason) => {
+	if (authorCanvasRejections.state[key] === reason) return;
+	authorCanvasRejections.setState((state) => {
+		const next = { ...state };
+		if (reason === void 0) delete next[key];
+		else next[key] = reason;
+		return next;
+	});
+};
+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();
+	#parked = /* @__PURE__ */ new Map();
+	#opening = /* @__PURE__ */ new Map();
+	#modeWatches = /* @__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");
+		this.#watch(sessionId);
+		const key = canvasKey(sessionId, alias);
+		if (this.#canvases.has(key)) return;
+		const parkedCanvas = this.#parked.get(key);
+		if (parkedCanvas !== void 0) {
+			if (this.#agentEnabled(sessionId)) await this.#openLive(parkedCanvas);
+			return;
+		}
+		const pending = this.#opening.get(key);
+		if (pending !== void 0) return await pending.promise;
+		const parked = {
+			sessionId,
+			alias,
+			profiles: documentProfiles(profiles)
+		};
+		if (!this.#agentEnabled(sessionId)) {
+			this.#parked.set(key, parked);
+			return;
+		}
+		await this.#openLive(parked);
+	}
+	async #openLive(parked) {
+		const { sessionId, alias } = parked;
+		const profiles = parked.focus?.profiles ?? parked.profiles;
+		const key = canvasKey(sessionId, alias);
+		if (this.#disposed || this.#canvases.has(key)) return;
+		const pending = this.#opening.get(key);
+		if (pending !== void 0) return await pending.promise;
+		if (!this.#agentEnabled(sessionId)) {
+			this.#parked.set(key, parked);
+			return;
+		}
+		this.#parked.delete(key);
+		const runtime = new AuthorRuntime(this.#host);
+		const generation = ++this.#generation;
+		let opening;
+		opening = (async () => {
+			let release;
+			try {
+				release = await runtime.replaceProfiles(profiles);
+			} catch (error) {
+				if (this.#disposed || !this.#agentEnabled(sessionId) || this.#opening.get(key)?.promise !== opening) return;
+				throw error;
+			}
+			if (this.#disposed || !this.#agentEnabled(sessionId) || this.#canvases.has(key) || this.#opening.get(key)?.promise !== opening) {
+				release();
+				runtime.dispose();
+				if (!this.#disposed && !this.#agentEnabled(sessionId)) this.#parked.set(key, parked);
+				return;
+			}
+			const canvas = {
+				sessionId,
+				alias,
+				generation,
+				profiles,
+				intent: parked,
+				runtime,
+				release,
+				pending: /* @__PURE__ */ new Map(),
+				replacementId: 0
+			};
+			this.#canvases.set(key, canvas);
+			const currentProfiles = parked.focus?.profiles ?? parked.profiles;
+			if (currentProfiles !== profiles) await this.#replace(canvas, currentProfiles);
+			else this.#register(canvas);
+		})();
+		this.#opening.set(key, {
+			promise: opening,
+			runtime,
+			parked
+		});
+		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 key = canvasKey(sessionId, alias);
+		const canvas = this.#canvases.get(key);
+		const intent = canvas?.intent ?? this.#parked.get(key) ?? this.#opening.get(key)?.parked;
+		if (intent === void 0) return () => void 0;
+		const focus = { profiles };
+		intent.focus = focus;
+		if (canvas !== void 0) await this.#replace(canvas, profiles);
+		return () => {
+			if (intent.focus !== focus) return;
+			intent.focus = void 0;
+			const current = this.#canvases.get(key);
+			if (current?.intent === intent) this.#replace(current, intent.profiles);
+		};
+	}
+	drop(sessionId, alias) {
+		for (const [key, entry] of this.#opening) {
+			if (entry.parked.sessionId !== sessionId || alias !== void 0 && entry.parked.alias !== alias) continue;
+			this.#opening.delete(key);
+			entry.runtime.dispose();
+		}
+		for (const [key, parked] of this.#parked) {
+			if (parked.sessionId !== sessionId || alias !== void 0 && parked.alias !== alias) continue;
+			this.#parked.delete(key);
+		}
+		for (const canvas of this.#canvases.values()) {
+			if (canvas.sessionId !== sessionId || alias !== void 0 && canvas.alias !== alias) continue;
+			this.#dropLive(canvas);
+		}
+	}
+	apply(sessionId, message) {
+		if (!this.#agentEnabled(sessionId) || message.alias === void 0) return;
+		const canvas = this.#canvases.get(canvasKey(sessionId, message.alias));
+		if (canvas === void 0) return;
+		if (message.kind === "rejected") {
+			setRejection(canvasKey(sessionId, message.alias), message.reason);
+			clearTimeout(canvas.leaseTimer);
+			canvas.leaseTimer = setTimeout(() => this.#register(canvas), REJECTED_RETRY_MS);
+			return;
+		}
+		if (message.generation !== canvas.generation || message.ownerToken !== canvas.ownerToken && canvas.ownerToken !== void 0) return;
+		if (message.kind === "accepted") {
+			setRejection(canvasKey(sessionId, message.alias), void 0);
+			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 release of this.#modeWatches.values()) release();
+		this.#modeWatches.clear();
+		for (const canvas of this.#canvases.values()) this.#dropLive(canvas);
+		this.#parked.clear();
+		for (const entry of this.#opening.values()) entry.runtime.dispose();
+		this.#opening.clear();
+	}
+	#agentEnabled(sessionId) {
+		return this.#host.minorModes?.active(sessionId).includes(AUTHOR_MODE_ID) === true;
+	}
+	#watch(sessionId) {
+		if (this.#modeWatches.has(sessionId) || this.#host.minorModes === void 0) return;
+		const release = this.#host.minorModes.subscribe(sessionId, () => this.#modeChanged(sessionId));
+		this.#modeWatches.set(sessionId, release);
+	}
+	#modeChanged(sessionId) {
+		if (this.#disposed) return;
+		if (this.#agentEnabled(sessionId)) {
+			for (const parked of this.#parked.values()) {
+				if (parked.sessionId !== sessionId) continue;
+				this.#openLive(parked).catch((error) => console.warn(`Author canvas '${parked.alias}' could not enable browser tools: ${error instanceof Error ? error.message : String(error)}`));
+			}
+			return;
+		}
+		for (const [key, entry] of this.#opening) {
+			if (entry.parked.sessionId !== sessionId) continue;
+			this.#opening.delete(key);
+			this.#parked.set(key, entry.parked);
+			entry.runtime.dispose();
+		}
+		for (const canvas of this.#canvases.values()) {
+			if (canvas.sessionId !== sessionId) continue;
+			this.#parked.set(canvasKey(canvas.sessionId, canvas.alias), canvas.intent);
+			this.#dropLive(canvas);
+		}
+	}
+	#dropLive(canvas) {
+		this.#canvases.delete(canvasKey(canvas.sessionId, canvas.alias));
+		setRejection(canvasKey(canvas.sessionId, canvas.alias), void 0);
+		this.#release(canvas);
+		canvas.runtime.dispose();
+	}
+	async #replace(canvas, profiles) {
+		const key = canvasKey(canvas.sessionId, canvas.alias);
+		if (this.#disposed || !this.#agentEnabled(canvas.sessionId) || 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.#agentEnabled(canvas.sessionId) && 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((error) => console.warn(`Author canvas '${canvas.alias}' could not send '${payload.kind}': ${error instanceof Error ? error.message : String(error)}`));
+	}
+	#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);
+}
+function applyAuthorHubMessage(sessionId, message) {
+	bridgeFor(sessionId)?.apply(sessionId, message);
+}
+function dropAuthorViewportSession(sessionId, alias) {
+	bridgeFor(sessionId)?.drop(sessionId, alias);
+}
+/** Why the agent cannot use this canvas here, such as another device holding it; undefined when it can. */
+function authorCanvasRejection(sessionId, alias) {
+	return authorCanvasRejections.state[canvasKey(sessionId, alias)];
+}
+function subscribeAuthorCanvasRejections(listener) {
+	const subscription = authorCanvasRejections.subscribe(listener);
+	return () => subscription.unsubscribe();
+}
+function authorBridgeView(sessionId) {
+	return bridgeFor(sessionId)?.activeView(sessionId) ?? {
+		activation: "inactive",
+		capabilityCount: 0
+	};
+}
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/channel/_lib/authorHubMessage.ts
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/** Gates one Author hub frame for the web and native channels alike: a bridge message, a view, or nothing. */
+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/_lib/authorStore.native.ts
+/**
+* The native copy of authorStore.ts. The phone keeps no grid or workspace
+* annotations, so a dropped session only releases its canvases.
+*/
+const author = defineSessionStore({
+	activation: "inactive",
+	capabilityCount: 0
+});
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/channel/author-webmcp.native.ts
+var author_webmcp_native_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) {
+		dropAuthorViewportSession(sessionId);
+		author.drop(sessionId);
+	}
+});
+//#endregion
+//#region src/constants/author.ts
+const AUTHOR_FILE_TAB_PREFIX = "author-file-";
+/** Names a file in the session's artifact folder rather than the working tree. Artifacts open read-only. */
+const AUTHOR_ARTIFACT_PREFIX = "artifact:";
+//#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
+};
+/** 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))
+	};
+}
+/** 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
+	};
+}
+const AUTHOR_QUOTE_MAX_BYTES = 4096;
+function bytes$1(value) {
+	let length = 0;
+	for (const character of value) {
+		const code = character.codePointAt(0);
+		length += code < 128 ? 1 : code < 2048 ? 2 : code < 65536 ? 3 : 4;
+	}
+	return length;
+}
+/** Capture DTOs are JSON; detach nested provenance and anchors without host clone APIs. */
+function cloneJson(value) {
+	return JSON.parse(JSON.stringify(value));
+}
+function utf8Prefix(value, limit) {
+	if (bytes$1(value) <= limit) return value;
+	let low = 0;
+	let high = value.length;
+	while (low < high) {
+		const middle = Math.ceil((low + high) / 2);
+		if (bytes$1(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: cloneJson(document.storyPreview) },
+			...document.imageArtifact === void 0 ? {} : { imageArtifact: { ...document.imageArtifact } },
+			...document.markdownMedia === void 0 ? {} : { markdownMedia: { ...document.markdownMedia } }
+		},
+		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$1(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: cloneJson(region.anchor),
+				...region.stroke === void 0 ? {} : { stroke: region.stroke.map((point) => ({ ...point })) },
+				viewport: { ...region.viewport },
+				...region.voiceGrid === void 0 ? {} : { voiceGrid: { ...region.voiceGrid } }
+			};
+		})
+	};
+	if (bytes$1(JSON.stringify(packet)) > 65536) throw new Error("Author capture packet exceeds 64 KiB.");
+	return packet;
+}
+function percent$1(value) {
+	return `${String(Math.round(value * 1e3) / 10)}%`;
+}
+function rectLocation(rect) {
+	return `x ${percent$1(rect.x)}, y ${percent$1(rect.y)}, w ${percent$1(rect.width)}, h ${percent$1(rect.height)}`;
+}
+function anchorLocation(anchor) {
+	switch (anchor.kind) {
+		case "text-range": return anchor.startLine === anchor.endLine ? `line ${String(anchor.startLine)}` : `lines ${String(anchor.startLine)}-${String(anchor.endLine)}`;
+		case "cell": return `${anchor.sheet === void 0 ? "" : `${anchor.sheet}!`}${anchor.location}`;
+		case "slide-element": return `slide ${String(anchor.slide)}: ${anchor.location}`;
+		case "image-rect": return `image ${rectLocation(anchor.rect)}`;
+		case "pdf-page-rect": return `page ${String(anchor.page)}, ${rectLocation(anchor.rect)}`;
+		case "video-time-rect": return `time ${anchor.timeSeconds.toFixed(3)}s${anchor.frame === void 0 ? "" : `, frame ${String(anchor.frame)}`}, ${rectLocation(anchor.rect)}`;
+		case "story-preview-rect": return `story preview ${rectLocation(anchor.rect)}`;
+		case "image-point": return `image point x ${percent$1(anchor.point.x)}, y ${percent$1(anchor.point.y)}`;
+		case "pdf-page-point": return `page ${String(anchor.page)}, point x ${percent$1(anchor.point.x)}, y ${percent$1(anchor.point.y)}`;
+		case "video-time-point": return `time ${anchor.timeSeconds.toFixed(3)}s, point x ${percent$1(anchor.point.x)}, y ${percent$1(anchor.point.y)}`;
+		case "story-preview-point": return `story preview point x ${percent$1(anchor.point.x)}, y ${percent$1(anchor.point.y)}`;
+		case "html-rect": return `rendered page ${anchor.element === void 0 ? "" : `${anchor.element.selector}, `}${rectLocation(anchor.rect)}`;
+		case "html-point": return `rendered page ${anchor.element === void 0 ? "" : `${anchor.element.selector}, `}point x ${percent$1(anchor.point.x)}, y ${percent$1(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 filePath(path) {
+	return path.startsWith("artifact:") ? `${path} (relative to the session artifact folder)` : path;
+}
+function markdownMediaProvenance(packet) {
+	const media = packet.document.markdownMedia;
+	if (media === void 0) return void 0;
+	const lines = [media.kind === "mermaid" ? "Reviewed a mermaid diagram rendered from Markdown. Change the diagram by editing its source." : "Reviewed an image shown in rendered Markdown. Change it by editing or regenerating its source file."];
+	if (media.sourcePath !== void 0) lines.push(`Source image: ${filePath(media.sourcePath)}`);
+	if (media.documentPath !== void 0) lines.push(`Embedded in document: ${filePath(media.documentPath)}`);
+	if (media.documentPath === void 0 && media.sourcePath === void 0) lines.push("Embedded in a conversation message, not a file.");
+	if (media.mermaidSource !== void 0) lines.push("Mermaid source:", "```mermaid", media.mermaidSource, "```");
+	return lines.join("\n");
+}
+function authorCaptureContext(packet) {
+	const metadata = JSON.stringify(packet);
+	if (bytes$1(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)}]\nregionId: ${JSON.stringify(region.id)}${region.quote ? `\nQuoted text: ${region.quote}` : ""}`).join("\n\n");
+	const artifact = packet.document.imageArtifact;
+	const provenance = artifact === void 0 ? markdownMediaProvenance(packet) ?? storyPreviewProvenance(packet) ?? (packet.document.kind === "html" ? "Annotations mark the rendered page. Locations are relative to the visible frame; the selector and quoted text name the marked element. Change the page by editing this HTML source." : void 0) : [
+		"Generated image feedback: preserve the original image; generate a new refinement only when requested.",
+		`Original artifact: ${artifact.id} (session ${artifact.sessionId})`,
+		`Original canonical path: ${artifact.originalPath}`,
+		`Original SHA-256: ${artifact.sourceSha256}`,
+		`For imagegen refinement use referenced_image_paths: ${JSON.stringify([artifact.originalPath])}`
+	].join("\n");
+	const content = provenance === void 0 ? annotations : `${provenance}\n\nAnnotations:\n${annotations}`;
+	const fences = JSON.stringify({
+		expectedRevision: packet.document.revision,
+		expectedSourceSha256: packet.document.sourceSha256
+	});
+	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})`}\nMutation fences: ${fences}\n${content}`,
+		metadata
+	};
+}
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/_lib/authorFiles.native.ts
+const MAX_FILE_BYTES = 5242880;
+const IMAGE_TYPES = /* @__PURE__ */ new Set([
+	"image/png",
+	"image/jpeg",
+	"image/gif",
+	"image/webp",
+	"image/bmp"
+]);
+const TEXT_EXTENSIONS = /* @__PURE__ */ new Set([
+	"md",
+	"mmd",
+	"mermaid",
+	"txt",
+	"json",
+	"yaml",
+	"yml",
+	"xml",
+	"svg",
+	"css",
+	"html",
+	"htm",
+	"js",
+	"jsx",
+	"ts",
+	"tsx"
+]);
+function structuredFormat(path) {
+	const extension = extensionOf(path);
+	return extension === "csv" || extension === "xlsx" || extension === "pptx" ? extension : void 0;
+}
+const IMAGE_EXTENSIONS = /* @__PURE__ */ new Set([
+	"png",
+	"jpg",
+	"jpeg",
+	"gif",
+	"webp",
+	"bmp"
+]);
+const VIDEO_MIMES = {
+	mp4: "video/mp4",
+	m4v: "video/mp4",
+	mov: "video/quicktime",
+	webm: "video/webm"
+};
+const IMAGE_SAVE_MAX_BYTES = 33554432;
+const PDF_MAX_BYTES = 33554432;
+const VIDEO_MAX_BYTES = 134217728;
+const extensionOf = (path) => path.toLowerCase().split("/").at(-1)?.split(".").slice(1).at(-1) ?? "";
+/** Whether the phone's canvas can mark this path up; anything else stays with its own viewer. */
+function authorNativeCanOpen(path) {
+	const extension = extensionOf(path);
+	return extension === "pdf" || VIDEO_MIMES[extension] !== void 0 || structuredFormat(path) !== void 0 || IMAGE_EXTENSIONS.has(extension) || TEXT_EXTENSIONS.has(extension);
+}
+/**
+* The raw reads Author's canvas already uses, restated for the native transport:
+* po-artifact's guarded artifact read and the host's session file, plus the two
+* canvas routes from apiRoutes.ts, whose definer the phone does not load.
+*/
+const artifactFiles = createApiClient({ content: {
+	method: "GET",
+	path: "/content",
+	query: ["path"],
+	raw: true
+} }, {
+	scopes: ["session"],
+	basePath: "artifacts",
+	transport: nativeApiTransport,
+	sessionAddress: sessionApiAddress
+});
+const sessionFiles = createApiClient({
+	file: {
+		method: "GET",
+		path: "/file",
+		query: ["path"],
+		host: true,
+		raw: true
+	},
+	fileWrite: {
+		method: "PUT",
+		path: "/file",
+		query: ["path"],
+		host: true,
+		raw: true
+	},
+	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()
+	}
+}, {
+	scopes: ["session"],
+	basePath: "author",
+	transport: nativeApiTransport,
+	sessionAddress: sessionApiAddress
+});
+/** Opens the document's canvas on the server, the one the agent's Author tools address, and returns its alias. */
+async function openAuthorNativeCanvas(sessionId, path, signal) {
+	const result = await sessionFiles.session(sessionId).documentsOpen({
+		body: { path },
+		query: { session: sessionId },
+		signal
+	});
+	if (!result.ok) throw new Error(result.error || `Author canvas could not open (${String(result.status)})`);
+	if (!("alias" in result.data) || typeof result.data.alias !== "string") throw new Error("The Author canvas did not return an alias.");
+	return {
+		alias: result.data.alias,
+		path: result.data.path
+	};
+}
+/** Writes only against the digest we read. A stale document is refused, never silently overwritten. */
+async function saveAuthorNativeText(sessionId, path, text, sourceSha256, signal) {
+	if (path.startsWith("artifact:")) throw new Error("Artifacts are read-only.");
+	if (!/^[a-f0-9]{64}$/.test(sourceSha256)) throw new Error("This Author view has no valid source digest.");
+	if (new Blob([text]).size > MAX_FILE_BYTES) throw new Error("This file is too large to save here.");
+	return await saveAuthorNativeBytes(sessionId, path, text, sourceSha256, signal);
+}
+/** Saves a crop without changing the original file's image encoding. */
+async function saveAuthorNativeImage(sessionId, path, image, sourceSha256, signal) {
+	if (path.startsWith("artifact:")) throw new Error("Artifacts are read-only.");
+	if (!validDigest(sourceSha256)) throw new Error("This Author view has no valid source digest.");
+	const extension = extensionOf(path);
+	const mimeType = extension === "png" ? "image/png" : extension === "jpg" || extension === "jpeg" ? "image/jpeg" : void 0;
+	if (mimeType === void 0 || image.mimeType !== mimeType) throw new Error("The cropped image encoding does not match its path.");
+	const bytes = image.bytes;
+	if (bytes.byteLength === 0 || bytes.byteLength > IMAGE_SAVE_MAX_BYTES) throw new Error("This image is empty or too large to save here.");
+	if (!(mimeType === "image/png" ? [
+		137,
+		80,
+		78,
+		71,
+		13,
+		10,
+		26,
+		10
+	] : [
+		255,
+		216,
+		255
+	]).every((byte, index) => bytes[index] === byte)) throw new Error("The cropped image bytes do not match their encoding.");
+	const digest = await saveAuthorNativeBytes(sessionId, path, bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength), sourceSha256, signal);
+	if (digest === sourceSha256) throw new Error("Author save returned a stale digest.");
+	return digest;
+}
+async function saveAuthorNativeBytes(sessionId, path, body, sourceSha256, signal) {
+	const result = await sessionFiles.session(sessionId).fileWrite({
+		query: { path },
+		headers: {
+			"Content-Type": "application/octet-stream",
+			"X-Expected-SHA256": sourceSha256
+		},
+		body,
+		signal
+	});
+	if (!result.ok) {
+		if (result.status === 409) throw new Error("This file changed elsewhere. Keep your edits and reopen it before saving.");
+		throw new Error(result.error || `Author save failed (${String(result.status)})`);
+	}
+	const digest = result.response.headers.get("X-File-SHA256");
+	if (digest === null || !/^[a-f0-9]{64}$/.test(digest)) throw new Error("Author save returned an invalid digest.");
+	return digest;
+}
+/** Reads one document for marking up on the phone: an image as base64, anything textual as a string. */
+async function loadAuthorFile(sessionId, path, signal) {
+	const format = structuredFormat(path);
+	if (format !== void 0) return await loadStructuredFile(sessionId, path, format, signal);
+	const artifact = path.startsWith(AUTHOR_ARTIFACT_PREFIX);
+	const query = { path: artifact ? path.slice(9) : path };
+	const result = artifact ? await artifactFiles.session(sessionId).content({
+		query,
+		signal
+	}) : await sessionFiles.session(sessionId).file({
+		query,
+		signal
+	});
+	if (!result.ok) throw new Error(result.error || "This file could not be read.");
+	const response = result.response;
+	if (!response) throw new Error("This file could not be read.");
+	const extension = extensionOf(query.path);
+	const mediaMime = extension === "pdf" ? "application/pdf" : VIDEO_MIMES[extension];
+	const limit = extension === "pdf" ? PDF_MAX_BYTES : mediaMime ? VIDEO_MAX_BYTES : MAX_FILE_BYTES;
+	if (Number(response.headers.get("content-length") ?? 0) > limit) throw new Error("This file is too large to open here.");
+	const mimeType = (response.headers.get("content-type")?.split(";")[0]?.trim() ?? "").toLowerCase();
+	const sourceSha256 = response.headers.get("X-File-SHA256") ?? void 0;
+	if (mediaMime !== void 0) {
+		const bytes = new Uint8Array(await response.arrayBuffer());
+		if (signal.aborted) throw new Error("Opening was cancelled.");
+		if (bytes.byteLength > limit) throw new Error("This file is too large to open here.");
+		return {
+			kind: extension === "pdf" ? "pdf" : "video",
+			bytes,
+			mimeType: mediaMime,
+			...sourceSha256 === void 0 ? {} : { sourceSha256 }
+		};
+	}
+	if (IMAGE_TYPES.has(mimeType)) {
+		const bytes = new Uint8Array(await response.arrayBuffer());
+		if (signal.aborted) throw new Error("Opening was cancelled.");
+		if (bytes.byteLength > MAX_FILE_BYTES) throw new Error("This file is too large to open here.");
+		return {
+			kind: "image",
+			data: encodeBase64(bytes),
+			mimeType,
+			...sourceSha256 === void 0 ? {} : { sourceSha256 }
+		};
+	}
+	if (mimeType.startsWith("text/") || mimeType === "application/json" || TEXT_EXTENSIONS.has(extension)) {
+		const text = await response.text();
+		if (signal.aborted) throw new Error("Opening was cancelled.");
+		if (new Blob([text]).size > MAX_FILE_BYTES) throw new Error("This file is too large to open here.");
+		const sourceSha256 = response.headers.get("X-File-SHA256") ?? void 0;
+		return {
+			kind: "text",
+			text,
+			...sourceSha256 === void 0 ? {} : { sourceSha256 }
+		};
+	}
+	throw new Error("This kind of file cannot be marked up on this device yet.");
+}
+const validDigest = (value) => typeof value === "string" && /^[a-f0-9]{64}$/.test(value);
+async function loadStructuredFile(sessionId, path, format, signal) {
+	const result = await sessionFiles.session(sessionId).documentsOpen({
+		body: {
+			path,
+			format
+		},
+		query: { session: sessionId },
+		signal
+	});
+	if (!result.ok) throw new Error(result.error || "This document could not be parsed.");
+	const parsed = result.data;
+	if (!("fragments" in parsed) || !Array.isArray(parsed.fragments) || parsed.manifest?.format !== format || !validDigest(parsed.manifest.sourceDigest)) throw new Error("Author returned an invalid structured document or source digest.");
+	if (!Number.isSafeInteger(parsed.manifest.byteLength) || parsed.manifest.byteLength < 0 || parsed.manifest.byteLength > MAX_FILE_BYTES || new Blob([JSON.stringify(parsed.fragments)]).size > MAX_FILE_BYTES) throw new Error("This file is too large to open here.");
+	const ids = /* @__PURE__ */ new Set();
+	for (const fragment of parsed.fragments) {
+		if (typeof fragment.id !== "string" || typeof fragment.text !== "string" || ids.has(fragment.id)) throw new Error("Author returned invalid structured fragments.");
+		ids.add(fragment.id);
+	}
+	let csvDialect;
+	if (format === "csv") {
+		const { delimiter, quote, recordDelimiter } = parsed.manifest.metadata ?? {};
+		if (delimiter !== "," && delimiter !== ";" && delimiter !== "	" && delimiter !== "|" || quote !== "\"" && quote !== "'" || recordDelimiter !== "\n" && recordDelimiter !== "\r\n") throw new Error("Author returned an invalid CSV dialect.");
+		csvDialect = {
+			delimiter,
+			quote,
+			recordDelimiter
+		};
+	}
+	if (signal.aborted) throw new Error("Opening was cancelled.");
+	return {
+		kind: "structured",
+		format,
+		fragments: parsed.fragments,
+		originalFragments: parsed.fragments.map((fragment) => ({ ...fragment })),
+		sourceSha256: parsed.manifest.sourceDigest,
+		...csvDialect === void 0 ? {} : { csvDialect }
+	};
+}
+/** The server owns parsing and preservation. Native sends only replacements of known editable fragments. */
+async function saveAuthorNativeStructured(sessionId, path, file, signal) {
+	if (path.startsWith("artifact:")) throw new Error("Artifacts are read-only.");
+	if (!validDigest(file.sourceSha256)) throw new Error("This Author view has no valid source digest.");
+	if (structuredFormat(path) !== file.format) throw new Error("The structured document format does not match its path.");
+	const originals = new Map(file.originalFragments.map((fragment) => [fragment.id, fragment]));
+	const seen = /* @__PURE__ */ new Set();
+	const operations = [];
+	for (const fragment of file.fragments) {
+		const original = originals.get(fragment.id);
+		if (original === void 0 || seen.has(fragment.id)) throw new Error("Unknown or duplicate structured fragment.");
+		seen.add(fragment.id);
+		if (original.text === fragment.text) continue;
+		if (original.readOnly || fragment.readOnly) throw new Error("This structured fragment is read-only.");
+		operations.push({
+			fragmentId: fragment.id,
+			replacement: fragment.text
+		});
+	}
+	if (seen.size !== originals.size) throw new Error("Structured fragments cannot be removed.");
+	if (operations.length > 1e5 || new Blob([JSON.stringify(operations)]).size > MAX_FILE_BYTES) throw new Error("This file is too large to save here.");
+	const body = {
+		path,
+		format: file.format,
+		operations,
+		...file.csvDialect === void 0 ? {} : { csvDialect: file.csvDialect }
+	};
+	const client = sessionFiles.session(sessionId);
+	const preflight = await client.documentsPreflight({
+		body,
+		query: { session: sessionId },
+		signal
+	});
+	if (!preflight.ok) throw new Error(preflight.error || "Author preflight failed.");
+	if (!validDigest(preflight.data.sourceDigest) || preflight.data.sourceDigest !== file.sourceSha256) throw new Error("Document source changed before saving. Reopen the document.");
+	if (!preflight.data.accepted) throw new Error(preflight.data.issues.map((issue) => issue.message).join("\n") || "Author preflight rejected the edit.");
+	if (!validDigest(preflight.data.digest)) throw new Error("Author preflight returned an invalid digest.");
+	const serialized = await client.documentsSerialize({
+		body: {
+			...body,
+			preflightDigest: preflight.data.digest
+		},
+		query: { session: sessionId },
+		signal
+	});
+	if (!serialized.ok) throw new Error(serialized.error || "Author serialization failed.");
+	if (serialized.data.encoding !== "base64" || typeof serialized.data.bytes !== "string") throw new Error("Author serialize returned an unsupported encoding.");
+	if (serialized.data.bytes.length > Math.ceil(MAX_FILE_BYTES / 3) * 4) throw new Error("This file is too large to save here.");
+	const bytes = decodeBase64(serialized.data.bytes);
+	if (bytes.byteLength > MAX_FILE_BYTES) throw new Error("This file is too large to save here.");
+	return await saveAuthorNativeBytes(sessionId, path, bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength), file.sourceSha256, signal);
+}
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/_lib/authorMarkdownText.ts
+const HEADING = /^#{1,6} /;
+const LIST_ITEM = /^(?:[-*+]|\d+[.)]) /;
+/**
+* One formatting edit for the selected source range. Bold, Heading and List toggle off when already applied;
+* Heading and List apply to every touched line and replace each other.
+*/
+function authorMarkdownFormat(content, from, to, format) {
+	if (format === "bold") {
+		const selected = content.slice(from, to);
+		if (selected.length >= 4 && selected.startsWith("**") && selected.endsWith("**")) return {
+			from,
+			to,
+			insert: selected.slice(2, -2),
+			select: {
+				from,
+				to: to - 4
+			}
+		};
+		if (from >= 2 && content.slice(from - 2, from) === "**" && content.slice(to, to + 2) === "**") return {
+			from: from - 2,
+			to: to + 2,
+			insert: selected,
+			select: {
+				from: from - 2,
+				to: to - 2
+			}
+		};
+		const text = selected || "bold text";
+		return {
+			from,
+			to,
+			insert: `**${text}**`,
+			select: {
+				from: from + 2,
+				to: from + 2 + text.length
+			}
+		};
+	}
+	if (format === "link") {
+		const text = content.slice(from, to) || "link text";
+		const url = from + text.length + 3;
+		return {
+			from,
+			to,
+			insert: `[${text}](https://)`,
+			select: {
+				from: url,
+				to: url + 8
+			}
+		};
+	}
+	const start = content.lastIndexOf("\n", from - 1) + 1;
+	const last = to > from && content[to - 1] === "\n" ? to - 1 : to;
+	const lineEnd = content.indexOf("\n", Math.max(last, start));
+	const end = lineEnd === -1 ? content.length : lineEnd;
+	const own = format === "heading" ? HEADING : LIST_ITEM;
+	const prefix = format === "heading" ? "## " : "- ";
+	const lines = content.slice(start, end).split("\n");
+	const written = lines.filter((line) => line.trim() !== "");
+	const remove = written.length > 0 && written.every((line) => own.test(line));
+	const insert = lines.map((line) => line.trim() === "" ? line : remove ? line.replace(own, "") : prefix + line.replace(HEADING, "").replace(LIST_ITEM, "")).join("\n");
+	return {
+		from: start,
+		to: end,
+		insert,
+		select: {
+			from: start,
+			to: start + insert.length
+		}
+	};
+}
+/** One-based source line of an offset. */
+function authorSourceLine(source, offset) {
+	return source.slice(0, offset).split("\n").length;
+}
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/_lib/authorNotes.ts
+const NOTE_MAX_CHARS = 1e3;
+/** Validate against canonical loaded source, using the same one-based line convention as web Author. */
+function nativeAuthorTextRange(source, range) {
+	const { startOffset, endOffset } = range;
+	if (!Number.isSafeInteger(startOffset) || !Number.isSafeInteger(endOffset) || startOffset < 0 || endOffset <= startOffset || endOffset > source.length) return void 0;
+	return {
+		kind: "text-range",
+		startOffset,
+		endOffset,
+		startLine: authorSourceLine(source, startOffset),
+		endLine: authorSourceLine(source, endOffset)
+	};
+}
+/** One screenshot evidences only the displayed page or captured frame. Sub-millisecond clock noise is not another frame. */
+function nativeAuthorVisibleNotes(notes, kind, page, timeSeconds) {
+	return notes.filter((note) => kind === "pdf" ? note.page === page && page !== void 0 : kind === "video" ? timeSeconds !== void 0 && note.timeSeconds !== void 0 && Math.abs(note.timeSeconds - timeSeconds) < .001 : true);
+}
+const percent = (value) => `${Math.round(Math.min(1, Math.max(0, Number.isFinite(value) ? value : 0)) * 100)}%`;
+/** A repository-relative or `artifact:` path, or undefined when it could escape the session's folders. */
+function authorNotePath(path) {
+	const local = (path.startsWith("artifact:") ? path.slice(9) : path).replaceAll("\\", "/");
+	const parts = local.split("/");
+	if (local.trim() === "" || local.startsWith("/") || /^[A-Za-z]:/u.test(local) || /[\u0000-\u001f]/u.test(local) || parts.includes("..")) return;
+	return path;
+}
+/** The model-facing text for the notes a person placed on one document. */
+function authorNotesContent(path, notes) {
+	const heading = `Author document: ${path}`;
+	if (notes.length === 0) return heading;
+	return [
+		heading,
+		"Notes from the person: source selections use UTF-16 source offsets; point notes use fractions of the document shown on the phone.",
+		...notes.map((note, index) => {
+			const anchors = [
+				...note.page !== void 0 ? [`page ${String(note.page)}`] : [],
+				...note.timeSeconds !== void 0 ? [`time ${String(note.timeSeconds)}s`] : [],
+				...note.textRange === void 0 ? [`x ${percent(note.x)}, y ${percent(note.y)}`] : [`source offsets ${String(note.textRange.startOffset)}-${String(note.textRange.endOffset)}`]
+			];
+			const stroke = note.points?.slice(0, 128).filter((point) => Number.isFinite(point.x) && Number.isFinite(point.y));
+			return `(${String(index + 1)}) ${note.text.trim().slice(0, NOTE_MAX_CHARS)} [${anchors.join("; ")}]${stroke?.length ? ` stroke: ${stroke.map((point) => `${percent(point.x)},${percent(point.y)}`).join(" -> ")}` : ""}`;
+		})
+	].join("\n");
+}
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/_lib/authorNativeCapture.ts
+/** A native mark is feedback on what was displayed, never source-edit authority. */
+function nativeAuthorCapture(captureId, capturedAt, document, notes, viewport, alias) {
+	const regions = notes.map((note) => {
+		if (![note.x, note.y].every((value) => Number.isFinite(value) && value >= 0 && value <= 1)) throw new Error("A note has invalid native coordinates.");
+		if (note.sourceSha256 !== void 0 && note.sourceSha256 !== document.sourceSha256) throw new Error("These notes refer to an earlier file version. Keep them and reopen the original before sending.");
+		const point = {
+			x: note.x,
+			y: note.y
+		};
+		const rect = note.points === void 0 ? void 0 : authorStrokeBounds(note.points);
+		if (rect === null) throw new Error("A note has invalid freehand geometry.");
+		let anchor;
+		let comment = note.text;
+		let quote;
+		if (note.textRange !== void 0) {
+			if (document.kind !== "text" || document.sourceText === void 0 || note.sourceSha256 === void 0 || !/^[a-f0-9]{64}$/u.test(note.sourceSha256)) throw new Error("A source selection requires loaded text and its source digest.");
+			const range = nativeAuthorTextRange(document.sourceText, note.textRange);
+			if (range === void 0) throw new Error("A source selection is outside the loaded text.");
+			anchor = range;
+			quote = document.sourceText.slice(range.startOffset, range.endOffset);
+		} else if (document.kind === "pdf") {
+			if (!Number.isSafeInteger(note.page) || note.page < 1) throw new Error("A PDF note has no page.");
+			comment = `[Native PDF page viewport coordinates, not intrinsic PDF coordinates] ${comment}`;
+			anchor = rect ? {
+				kind: "pdf-page-rect",
+				page: note.page,
+				rect
+			} : {
+				kind: "pdf-page-point",
+				page: note.page,
+				point
+			};
+		} else if (document.kind === "video") {
+			if (!Number.isFinite(note.timeSeconds) || note.timeSeconds < 0) throw new Error("A video note has no frame time.");
+			anchor = rect ? {
+				kind: "video-time-rect",
+				timeSeconds: note.timeSeconds,
+				rect
+			} : {
+				kind: "video-time-point",
+				timeSeconds: note.timeSeconds,
+				point
+			};
+		} else if (document.kind === "html") {
+			comment = `[Native semantic HTML viewport, not browser layout] ${comment}`;
+			anchor = rect ? {
+				kind: "html-rect",
+				rect
+			} : {
+				kind: "html-point",
+				point
+			};
+		} else if (note.fragmentId !== void 0 && !rect) {
+			const fragment = document.fragments?.find((entry) => entry.id === note.fragmentId);
+			if (!fragment) throw new Error("This note refers to a fragment that is no longer displayed.");
+			if (document.kind === "pptx") {
+				const slide = /slide(\d+)\.xml$/u.exec(fragment.location)?.[1];
+				if (slide === void 0) throw new Error("This slide note has no source slide.");
+				anchor = {
+					kind: "slide-element",
+					fragmentId: fragment.id,
+					location: fragment.location,
+					slide: Number(slide)
+				};
+			} else anchor = {
+				kind: "cell",
+				fragmentId: fragment.id,
+				location: fragment.location
+			};
+		} else {
+			const naturalWidth = document.naturalWidth ?? viewport.width;
+			const naturalHeight = document.naturalHeight ?? viewport.height;
+			if (document.kind !== "image") comment = `[Native viewport feedback, not a source selection] ${comment}`;
+			anchor = rect ? {
+				kind: "image-rect",
+				rect,
+				naturalWidth,
+				naturalHeight
+			} : {
+				kind: "image-point",
+				point,
+				naturalWidth,
+				naturalHeight
+			};
+		}
+		return {
+			id: note.id,
+			documentPath: document.path,
+			revision: document.version,
+			version: 1,
+			sourceSha256: document.sourceSha256,
+			mode: rect || note.textRange ? "region" : "point",
+			comment,
+			quote,
+			anchor,
+			stroke: note.points,
+			viewport: {
+				...viewport,
+				page: note.page,
+				timeSeconds: note.timeSeconds
+			},
+			createdAt: capturedAt
+		};
+	});
+	return {
+		packet: createAuthorCapturePacket(captureId, capturedAt, document, regions, alias),
+		regions
+	};
+}
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/_lib/authorNativeDrafts.ts
+function object(value) {
+	if (value === null || typeof value !== "object" || Array.isArray(value)) throw new Error("Invalid stored Author draft.");
+	return value;
+}
+function text(value, limit) {
+	if (typeof value !== "string" || value.length > limit) throw new Error("Invalid stored Author draft text.");
+	return value;
+}
+function fraction(value) {
+	if (typeof value !== "number" || !Number.isFinite(value) || value < 0 || value > 1) throw new Error("Invalid stored Author mark.");
+	return value;
+}
+function digest(value) {
+	if (typeof value !== "string" || !/^[a-f0-9]{64}$/u.test(value)) throw new Error("Invalid stored Author source digest.");
+	return value;
+}
+function note(value) {
+	const record = object(value);
+	const result = {
+		x: fraction(record.x),
+		y: fraction(record.y),
+		text: text(record.text, 2048)
+	};
+	if (record.points !== void 0) {
+		if (!Array.isArray(record.points) || record.points.length < 2 || record.points.length > 128) throw new Error("Invalid stored Author stroke.");
+		result.points = record.points.map((value) => {
+			const point = object(value);
+			return {
+				x: fraction(point.x),
+				y: fraction(point.y)
+			};
+		});
+	}
+	if (record.page !== void 0) {
+		if (typeof record.page !== "number" || !Number.isSafeInteger(record.page) || record.page < 1) throw new Error("Invalid stored Author page.");
+		result.page = record.page;
+	}
+	if (record.timeSeconds !== void 0) {
+		if (typeof record.timeSeconds !== "number" || !Number.isFinite(record.timeSeconds) || record.timeSeconds < 0) throw new Error("Invalid stored Author frame.");
+		result.timeSeconds = record.timeSeconds;
+	}
+	if (record.fragmentId !== void 0) result.fragmentId = text(record.fragmentId, 4096);
+	if (record.sourceSha256 !== void 0) result.sourceSha256 = digest(record.sourceSha256);
+	if (record.textRange !== void 0) {
+		const { startOffset, endOffset } = object(record.textRange);
+		if (typeof startOffset !== "number" || typeof endOffset !== "number" || !Number.isSafeInteger(startOffset) || !Number.isSafeInteger(endOffset) || startOffset < 0 || endOffset <= startOffset || endOffset > 5242880 || result.sourceSha256 === void 0) throw new Error("Invalid stored Author source selection.");
+		result.textRange = {
+			startOffset,
+			endOffset
+		};
+	}
+	return result;
+}
+/** Validate and detach restored local data before it can become marks or a file edit. */
+function parseNativeAuthorDraft(value) {
+	const record = object(value);
+	if (record.version !== 1 || !Array.isArray(record.notes) || record.notes.length > 100) throw new Error("Unsupported stored Author draft.");
+	const ids = /* @__PURE__ */ new Set();
+	const result = {
+		version: 1,
+		notes: record.notes.map((value) => {
+			const id = text(object(value).id, 512);
+			if (!id || ids.has(id)) throw new Error("Duplicate or empty stored Author note.");
+			ids.add(id);
+			return {
+				id,
+				...note(value)
+			};
+		})
+	};
+	if (record.draft !== void 0) result.draft = note(record.draft);
+	if (record.edit !== void 0) {
+		const edit = object(record.edit);
+		const sourceSha256 = digest(edit.sourceSha256);
+		if (edit.kind === "text") result.edit = {
+			kind: "text",
+			sourceSha256,
+			text: text(edit.text, 65536)
+		};
+		else if (edit.kind === "structured" && Array.isArray(edit.fragments) && edit.fragments.length <= 1e5) {
+			const seen = /* @__PURE__ */ new Set();
+			result.edit = {
+				kind: "structured",
+				sourceSha256,
+				fragments: edit.fragments.map((value) => {
+					const fragment = object(value);
+					const id = text(fragment.id, 4096);
+					if (!id || seen.has(id)) throw new Error("Duplicate or empty stored Author fragment.");
+					seen.add(id);
+					return {
+						id,
+						text: text(fragment.text, 65536)
+					};
+				})
+			};
+		} else throw new Error("Unsupported stored Author edit.");
+	}
+	return result;
+}
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/_lib/authorNativeRequests.native.ts
+const RECORD_LIMIT = 100;
+const BYTE_LIMIT = 524288;
+const ACTIVE_RESERVE_BYTES = 2048;
+const ERROR_CHARACTER_LIMIT = 256;
+const terminal = (record) => [
+	"COMPLETE",
+	"FAILED",
+	"CANCELLED",
+	"UNTRACKED"
+].includes(record.status);
+/** Subscribe to store, then select(state, sessionId) for only that session's history. */
+const nativeAuthorRequests = defineSessionStore([]);
+const mounts = defineGlobalStore(/* @__PURE__ */ new Map());
+function requireSession(sessionId) {
+	if (!mounts.store.state.has(sessionId)) throw new Error("Native Author requests require a mounted session.");
+}
+function bytes(value) {
+	let size = 0;
+	for (const character of JSON.stringify(value)) {
+		const code = character.codePointAt(0);
+		size += code < 128 ? 1 : code < 2048 ? 2 : code < 65536 ? 3 : 4;
+	}
+	return size;
+}
+function bound(records) {
+	const next = [...records];
+	while (next.length > RECORD_LIMIT || bytes(next) + next.filter((record) => !terminal(record)).length * ACTIVE_RESERVE_BYTES > BYTE_LIMIT) {
+		const index = next.findIndex(terminal);
+		if (index < 0) throw new Error("Author request history is full while active requests are still running.");
+		next.splice(index, 1);
+	}
+	return next;
+}
+function comparableJson(value) {
+	return JSON.stringify(value, (_key, item) => item !== null && typeof item === "object" && !Array.isArray(item) ? Object.fromEntries(Object.entries(item).sort(([left], [right]) => left.localeCompare(right))) : item);
+}
+/** Record before submitCapture. Throws without changing history on validation or backpressure. */
+function recordNativeAuthorRequest(sessionId, packet, regions) {
+	requireSession(sessionId);
+	if (packet.version !== 1 || packet.captureId.trim() === "" || !Number.isFinite(packet.capturedAt) || packet.document.path.trim() === "" || !Number.isSafeInteger(packet.document.revision) || packet.document.revision < 0) throw new Error("Invalid Author capture identity.");
+	if (packet.document.imageArtifact !== void 0 && packet.document.imageArtifact.sessionId !== sessionId) throw new Error("Author capture belongs to another session.");
+	const validated = createAuthorCapturePacket(packet.captureId, packet.capturedAt, {
+		...packet.document,
+		version: packet.document.revision
+	}, regions, packet.document.alias);
+	if (comparableJson(validated) !== comparableJson(packet) || regions.some((region) => region.id.trim() === "") || new Set(regions.map((region) => region.id)).size !== regions.length) throw new Error("Author capture does not match its regions.");
+	const detachedRegions = validated.regions.map((region) => ({
+		...region,
+		documentPath: validated.document.path,
+		revision: validated.document.revision,
+		sourceSha256: validated.document.sourceSha256,
+		createdAt: validated.capturedAt
+	}));
+	const record = JSON.parse(JSON.stringify({
+		id: packet.captureId,
+		captureId: packet.captureId,
+		documentPath: packet.document.path,
+		requestText: authorCaptureContext(validated).content,
+		regions: detachedRegions,
+		pendingRegions: detachedRegions,
+		status: "REQUESTED",
+		createdAt: packet.capturedAt,
+		updatedAt: packet.capturedAt,
+		revision: packet.document.revision,
+		sourceSha256: packet.document.sourceSha256
+	}));
+	nativeAuthorRequests.update(sessionId, (records) => {
+		if (records.some((item) => item.captureId === record.captureId)) throw new Error("Author capture already recorded.");
+		return bound([...records, record]);
+	});
+}
+function fold(sessionId, event) {
+	if (event.sessionId !== sessionId || event.status === "queued") return;
+	nativeAuthorRequests.update(sessionId, (records) => {
+		const index = records.findIndex((record) => record.captureId === event.captureId);
+		const record = records[index];
+		if (record === void 0 || terminal(record)) return records;
+		const next = {
+			...record,
+			status: event.status === "working" ? "CHANGING" : event.status === "completed" ? "COMPLETE" : event.status === "untracked" ? "UNTRACKED" : "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.").slice(0, ERROR_CHARACTER_LIMIT) : void 0,
+			updatedAt: Date.now()
+		};
+		return records.map((item, position) => position === index ? next : item);
+	});
+}
+function failNativeAuthorRequest(sessionId, captureId, error) {
+	requireSession(sessionId);
+	fold(sessionId, {
+		sessionId,
+		captureId,
+		status: "error",
+		error: error instanceof Error ? error.message : String(error)
+	});
+}
+function startNativeAuthorRequests(runtime) {
+	if (runtime.mount?.scope !== "session") throw new Error("Native Author requests require a session mount.");
+	const sessionId = runtime.mount.sessionId;
+	const token = {};
+	mounts.update((current) => new Map(current).set(sessionId, token));
+	let active = true;
+	const stop = runtime.onCaptureStatus?.((event) => {
+		if (active && mounts.store.state.get(sessionId) === token) fold(sessionId, event);
+	});
+	return () => {
+		active = false;
+		stop?.();
+		mounts.update((current) => {
+			if (current.get(sessionId) !== token) return current;
+			const next = new Map(current);
+			next.delete(sessionId);
+			return next;
+		});
+	};
+}
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/_components/AuthorDocumentView.native.tsx
+const DRAFT_ID = "draft";
+/** One open document on the phone: the content to mark up, its notes, and one way to hand them to the agent. */
+function AuthorDocumentView(props) {
+	const { body, notes, draft, status } = props;
+	const [tool, setTool] = useState("pin");
+	const [readingMode, setReadingMode] = useState("read");
+	const [selection, setSelection] = useState({
+		start: 0,
+		end: 0
+	});
+	const [sourceSelection, setSourceSelection] = useState();
+	const sourceKey = `${props.name}\n${props.sourceSha256 ?? ""}`;
+	const selectedRange = body.kind === "text" && sourceSelection?.key === sourceKey ? nativeAuthorTextRange(body.text, sourceSelection) : void 0;
+	const canInspectSource = body.kind === "text" && props.nativeContent === void 0;
+	const markdown = body.kind === "text" && /\.(?:md|markdown)$/iu.test(props.name);
+	const rangeLabel = (note) => {
+		if (note.textRange === void 0) return "";
+		const range = body.kind === "text" && note.sourceSha256 === props.sourceSha256 ? nativeAuthorTextRange(body.text, note.textRange) : void 0;
+		return range === void 0 ? "Source selection: " : range.startLine === range.endLine ? `Line ${String(range.startLine)}: ` : `Lines ${String(range.startLine)} to ${String(range.endLine)}: `;
+	};
+	const formatMarkdown = (format) => {
+		if (props.edit?.text === void 0 || props.edit.saving || !props.onEditChange) return;
+		const text = props.edit.text;
+		const edit = authorMarkdownFormat(text, Math.min(selection.start, text.length), Math.min(selection.end, text.length), format);
+		props.onEditChange(text.slice(0, edit.from) + edit.insert + text.slice(edit.to));
+		setSelection({
+			start: edit.select.from,
+			end: edit.select.to
+		});
+	};
+	const marks = nativeAuthorVisibleNotes([...notes.map((note, index) => ({
+		id: note.id,
+		x: note.x,
+		y: note.y,
+		label: String(index + 1),
+		description: note.text,
+		points: note.points,
+		page: note.page,
+		timeSeconds: note.timeSeconds,
+		sourceSha256: note.sourceSha256,
+		textRange: note.textRange
+	})), ...draft ? [{
+		id: DRAFT_ID,
+		x: draft.x,
+		y: draft.y,
+		label: String(notes.length + 1),
+		points: draft.points,
+		page: draft.page,
+		timeSeconds: draft.timeSeconds,
+		sourceSha256: draft.sourceSha256,
+		textRange: draft.textRange
+	}] : []].filter((mark) => mark.textRange === void 0 && (mark.sourceSha256 === void 0 || mark.sourceSha256 === props.sourceSha256)), body.kind, props.page, props.timeSeconds);
+	const sending = status.state === "sending";
+	const inspectingSource = canInspectSource && readingMode === "source";
+	const annotation = /* @__PURE__ */ jsx(AnnotationSurface, {
+		accessibilityLabel: props.name,
+		zoomable: body.kind === "image" && !sending,
+		onViewportChange: (viewport) => props.onZoomChange?.(viewport.zoom),
+		marks: inspectingSource ? [] : marks,
+		selectedId: inspectingSource ? void 0 : draft ? DRAFT_ID : props.selectedId,
+		onPlace: inspectingSource || draft || sending || tool !== "pin" ? void 0 : props.onPlace,
+		onDraw: !inspectingSource && !draft && !sending && props.onDraw && tool !== "pin" ? (points) => {
+			if (tool === "draw") {
+				props.onDraw?.(points);
+				return;
+			}
+			const first = points[0];
+			const last = points.at(-1);
+			if (!first || !last) return;
+			const rect = normalizedAuthorRectangle({
+				left: 0,
+				top: 0,
+				right: 1,
+				bottom: 1
+			}, {
+				left: first.x,
+				top: first.y,
+				right: last.x,
+				bottom: last.y
+			});
+			if (rect) props.onDraw?.([
+				{
+					x: rect.x,
+					y: rect.y
+				},
+				{
+					x: rect.x + rect.width,
+					y: rect.y
+				},
+				{
+					x: rect.x + rect.width,
+					y: rect.y + rect.height
+				},
+				{
+					x: rect.x,
+					y: rect.y + rect.height
+				},
+				{
+					x: rect.x,
+					y: rect.y
+				}
+			]);
+		} : void 0,
+		onSelectMark: inspectingSource ? void 0 : (id) => id !== DRAFT_ID && props.onSelect?.(id),
+		children: body.kind === "image" ? /* @__PURE__ */ jsx(Image, {
+			source: { uri: body.uri },
+			style: [s.image, { aspectRatio: body.aspectRatio }],
+			resizeMode: "contain"
+		}) : body.kind === "structured" ? /* @__PURE__ */ jsxs(View, {
+			style: s.notes,
+			children: [body.format === "pptx" ? /* @__PURE__ */ jsx(Text, {
+				style: s.meta,
+				children: "Slide text, not a layout preview. Images, notes and embedded objects stay in the file."
+			}) : null, body.fragments.map((fragment, index) => /* @__PURE__ */ jsxs(Pressable, {
+				accessibilityRole: "button",
+				accessibilityLabel: `Comment on ${fragment.location}`,
+				disabled: !!draft || sending || !props.onPlace,
+				style: [s.notes, s.fragment],
+				onPress: (event) => {
+					event.stopPropagation();
+					props.onPlace?.({
+						x: .5,
+						y: (index + .5) / body.fragments.length,
+						fragmentId: fragment.id
+					});
+				},
+				children: [/* @__PURE__ */ jsx(SectionLabel, { children: fragment.location }), /* @__PURE__ */ jsx(Text, {
+					style: s.text,
+					children: fragment.text
+				})]
+			}, fragment.id))]
+		}) : props.nativeContent ?? (body.kind === "text" ? inspectingSource ? /* @__PURE__ */ jsx(Textarea, {
+			accessibilityLabel: `Select source text in ${props.name}`,
+			style: s.text,
+			rows: 16,
+			value: body.text,
+			readOnly: true,
+			showSoftInputOnFocus: false,
+			scrollEnabled: true,
+			onSelectionChange: (event) => {
+				const { start, end } = event.nativeEvent.selection;
+				setSourceSelection({
+					key: sourceKey,
+					startOffset: start,
+					endOffset: end
+				});
+			}
+		}) : markdown ? /* @__PURE__ */ jsx(Markdown, { text: body.text }) : /* @__PURE__ */ jsx(Text, {
+			style: s.text,
+			children: body.text
+		}) : null)
+	});
+	return /* @__PURE__ */ jsxs(View, {
+		style: s.screen,
+		children: [
+			/* @__PURE__ */ jsxs(View, {
+				style: s.header,
+				children: [
+					/* @__PURE__ */ jsx(Text, {
+						style: s.title,
+						numberOfLines: 1,
+						children: props.name
+					}),
+					props.ownedElsewhere ? /* @__PURE__ */ jsxs(View, {
+						style: s.ask,
+						children: [/* @__PURE__ */ jsx(Badge, {
+							tone: "magenta",
+							children: "Open on another device"
+						}), /* @__PURE__ */ jsx(Text, {
+							style: s.meta,
+							children: "You can still add notes. The agent keeps using the other device until it closes there."
+						})]
+					}) : null,
+					props.onEdit && !props.edit ? /* @__PURE__ */ jsx(Button, {
+						variant: "ghost",
+						disabled: sending || draft !== void 0,
+						onPress: props.onEdit,
+						children: body.kind === "structured" ? "Edit document" : "Edit text"
+					}) : null,
+					props.onDraw && !props.edit && !inspectingSource ? /* @__PURE__ */ jsx(SegmentedControl, {
+						accessibilityLabel: "Mark tool",
+						options: [
+							{
+								value: "pin",
+								label: "Pin"
+							},
+							{
+								value: "rectangle",
+								label: "Rectangle"
+							},
+							{
+								value: "draw",
+								label: "Draw"
+							}
+						],
+						value: tool,
+						disabled: sending || draft !== void 0,
+						onValueChange: (value) => {
+							if (value === "pin" || value === "rectangle" || value === "draw") setTool(value);
+						}
+					}) : null,
+					props.onCrop && !props.edit ? /* @__PURE__ */ jsx(Button, {
+						variant: "ghost",
+						disabled: sending || !!draft,
+						loading: props.cropping,
+						onPress: props.onCrop,
+						children: "Crop to selected mark"
+					}) : null,
+					props.onResumeVideo ? /* @__PURE__ */ jsx(Button, {
+						variant: "ghost",
+						disabled: sending || !!draft,
+						onPress: props.onResumeVideo,
+						children: "Back to video"
+					}) : null,
+					canInspectSource && !props.edit ? /* @__PURE__ */ jsx(SegmentedControl, {
+						accessibilityLabel: "Document view",
+						options: [{
+							value: "read",
+							label: "Read"
+						}, {
+							value: "source",
+							label: "Source"
+						}],
+						value: readingMode,
+						disabled: sending || !!draft,
+						onValueChange: (value) => {
+							if (value === "read" || value === "source") setReadingMode(value);
+						}
+					}) : null,
+					inspectingSource && props.onSelectText && !props.edit ? /* @__PURE__ */ jsx(Button, {
+						variant: "ghost",
+						disabled: sending || !!draft || selectedRange === void 0,
+						onPress: () => {
+							if (selectedRange !== void 0) props.onSelectText?.({
+								startOffset: selectedRange.startOffset,
+								endOffset: selectedRange.endOffset
+							});
+						},
+						children: "Note on selected text"
+					}) : null,
+					props.storageMessage ? /* @__PURE__ */ jsx(Text, {
+						style: s.meta,
+						accessibilityLiveRegion: "polite",
+						children: props.storageMessage
+					}) : null
+				]
+			}),
+			/* @__PURE__ */ jsxs(ScrollView, {
+				style: s.scroll,
+				contentContainerStyle: s.content,
+				keyboardShouldPersistTaps: "handled",
+				children: [
+					props.edit?.image ? /* @__PURE__ */ jsx(Image, {
+						accessibilityLabel: "Crop preview",
+						source: { uri: props.edit.image.uri },
+						style: [s.image, { aspectRatio: props.edit.image.aspectRatio }],
+						resizeMode: "contain"
+					}) : props.edit?.fragments !== void 0 ? /* @__PURE__ */ jsx(View, {
+						style: s.notes,
+						children: props.edit.fragments.map((fragment) => /* @__PURE__ */ jsxs(View, {
+							style: s.notes,
+							children: [/* @__PURE__ */ jsxs(SectionLabel, { children: [fragment.location, fragment.readOnly ? " (read-only)" : ""] }), /* @__PURE__ */ jsx(Textarea, {
+								accessibilityLabel: `Edit ${fragment.location}`,
+								value: fragment.text,
+								disabled: props.edit?.saving || fragment.readOnly,
+								onChangeText: (text) => props.onEditFragmentChange?.(fragment.id, text)
+							})]
+						}, fragment.id))
+					}) : props.edit ? /* @__PURE__ */ jsxs(View, {
+						style: s.notes,
+						children: [markdown ? /* @__PURE__ */ jsx(View, {
+							style: s.toolbar,
+							children: [
+								"bold",
+								"heading",
+								"list",
+								"link"
+							].map((format) => /* @__PURE__ */ jsx(Button, {
+								variant: "ghost",
+								disabled: props.edit?.saving || !props.onEditChange,
+								accessibilityLabel: `Format ${format}`,
+								onPress: () => formatMarkdown(format),
+								children: format[0].toUpperCase() + format.slice(1)
+							}, format))
+						}) : null, /* @__PURE__ */ jsx(Textarea, {
+							accessibilityLabel: `Edit ${props.name}`,
+							rows: 16,
+							value: props.edit.text,
+							onChangeText: props.onEditChange,
+							selection: markdown ? selection : void 0,
+							onSelectionChange: markdown ? (event) => setSelection(event.nativeEvent.selection) : void 0,
+							disabled: props.edit.saving,
+							autoFocus: true
+						})]
+					}) : props.captureContent ? props.captureContent(annotation) : annotation,
+					(notes.length === 0 || inspectingSource) && !draft && !props.edit ? /* @__PURE__ */ jsx(Text, {
+						style: s.meta,
+						children: inspectingSource ? "Select source text to add a note. Switch to Read to send notes." : `${body.kind === "image" ? "Tap the image" : "Tap the document"} where something should change, then say what.`
+					}) : null,
+					notes.length > 0 ? /* @__PURE__ */ jsxs(View, {
+						style: s.notes,
+						children: [/* @__PURE__ */ jsx(SectionLabel, { children: "Notes" }), notes.map((note, index) => /* @__PURE__ */ jsxs(Pressable, {
+							accessibilityRole: "button",
+							accessibilityState: { selected: note.id === props.selectedId },
+							onPress: () => props.onSelect?.(note.id),
+							style: [s.note, note.id === props.selectedId && s.noteSelected],
+							children: [
+								/* @__PURE__ */ jsx(Text, {
+									style: s.number,
+									children: index + 1
+								}),
+								/* @__PURE__ */ jsxs(Text, {
+									style: s.noteText,
+									children: [
+										note.sourceSha256 !== void 0 && note.sourceSha256 !== props.sourceSha256 ? "Earlier version: " : "",
+										note.page !== void 0 ? `Page ${String(note.page)}: ` : note.timeSeconds !== void 0 ? `${String(Math.round(note.timeSeconds * 10) / 10)}s: ` : "",
+										rangeLabel(note),
+										note.text
+									]
+								}),
+								/* @__PURE__ */ jsx(Button, {
+									variant: "ghost",
+									size: "icon",
+									accessibilityLabel: `Remove note ${index + 1}`,
+									disabled: sending,
+									onPress: () => props.onDelete?.(note.id),
+									children: /* @__PURE__ */ jsx(TrashIcon, {})
+								})
+							]
+						}, note.id))]
+					}) : null,
+					props.requests?.length ? /* @__PURE__ */ jsxs(View, {
+						style: s.notes,
+						children: [/* @__PURE__ */ jsx(SectionLabel, { children: "Requests" }), props.requests.map((request, index) => /* @__PURE__ */ jsxs(View, {
+							style: s.notes,
+							children: [/* @__PURE__ */ jsx(Text, {
+								style: request.status === "FAILED" ? s.failed : s.meta,
+								children: `Request ${String(index + 1)}: ${request.status.toLowerCase()}`
+							}), request.error ? /* @__PURE__ */ jsx(Text, {
+								style: s.failed,
+								children: request.error
+							}) : null]
+						}, request.id))]
+					}) : null
+				]
+			}),
+			props.edit || draft || notes.length > 0 || status.state !== "idle" ? /* @__PURE__ */ jsx(View, {
+				style: s.footer,
+				children: props.edit ? /* @__PURE__ */ jsxs(Fragment, { children: [props.edit.error ? /* @__PURE__ */ jsxs(Text, {
+					style: s.failed,
+					accessibilityLiveRegion: "polite",
+					children: [props.edit.error, " Your edits are still here."]
+				}) : null, /* @__PURE__ */ jsxs(View, {
+					style: s.row,
+					children: [/* @__PURE__ */ jsx(Button, {
+						variant: "ghost",
+						style: s.grow,
+						disabled: props.edit.saving,
+						onPress: props.onEditCancel,
+						children: "Cancel"
+					}), /* @__PURE__ */ jsx(Button, {
+						variant: "primary",
+						style: s.grow,
+						loading: props.edit.saving,
+						loadingLabel: "Saving document",
+						onPress: props.onEditSave,
+						children: "Save"
+					})]
+				})] }) : draft ? /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx(Textarea, {
+					autoFocus: true,
+					accessibilityLabel: `Note ${notes.length + 1}`,
+					placeholder: "What should change here?",
+					maxLength: 2048,
+					value: draft.text,
+					onChangeText: props.onDraftChange
+				}), /* @__PURE__ */ jsxs(View, {
+					style: s.row,
+					children: [/* @__PURE__ */ jsx(Button, {
+						variant: "ghost",
+						style: s.grow,
+						onPress: props.onDraftCancel,
+						children: "Cancel"
+					}), /* @__PURE__ */ jsx(Button, {
+						variant: "primary",
+						style: s.grow,
+						disabled: !draft.text.trim(),
+						onPress: props.onDraftSave,
+						children: "Add note"
+					})]
+				})] }) : /* @__PURE__ */ jsxs(Fragment, { children: [
+					status.state === "failed" ? /* @__PURE__ */ jsxs(Text, {
+						style: s.failed,
+						accessibilityLiveRegion: "polite",
+						children: [
+							"Couldn't send: ",
+							status.message,
+							" Your notes are still here."
+						]
+					}) : null,
+					status.state === "sent" ? /* @__PURE__ */ jsx(Text, {
+						style: s.meta,
+						accessibilityLiveRegion: "polite",
+						children: "Sent to the agent. You can keep adding notes."
+					}) : null,
+					notes.length > 0 ? /* @__PURE__ */ jsx(Button, {
+						variant: "primary",
+						size: "lg",
+						loading: sending,
+						disabled: inspectingSource || props.sendCount === 0,
+						loadingLabel: "Sending notes",
+						onPress: props.onSend,
+						children: status.state === "failed" ? "Try again" : props.sendCount === 0 ? "Open a marked page or frame to send" : `Send ${props.sendCount ?? notes.length} note${(props.sendCount ?? notes.length) === 1 ? "" : "s"} to the agent`
+					}) : null
+				] })
+			}) : null
+		]
+	});
+}
+const s = StyleSheet.create((theme) => ({
+	screen: {
+		flex: 1,
+		backgroundColor: theme.colors.bg,
+		uni__dependencies: [0]
+	},
+	header: {
+		gap: theme.spacing(2),
+		padding: theme.spacing(4),
+		paddingBottom: theme.spacing(2),
+		uni__dependencies: [0]
+	},
+	title: {
+		color: theme.colors.hi,
+		fontFamily: fontOf(theme.fontFamily.sans),
+		fontSize: theme.fontSize.lg,
+		lineHeight: theme.lineHeight.lg,
+		fontWeight: theme.fontWeight.semibold,
+		uni__dependencies: [0]
+	},
+	ask: {
+		alignItems: "flex-start",
+		gap: theme.spacing(2),
+		padding: theme.spacing(3),
+		borderWidth: 1,
+		borderColor: theme.colors["edge-magenta"],
+		backgroundColor: theme.colors["tint-magenta"],
+		borderRadius: theme.borderRadius.md,
+		uni__dependencies: [0]
+	},
+	scroll: { flex: 1 },
+	content: {
+		gap: theme.spacing(4),
+		padding: theme.spacing(4),
+		uni__dependencies: [0]
+	},
+	image: {
+		width: "100%",
+		borderRadius: theme.borderRadius.md,
+		backgroundColor: theme.colors.deep,
+		uni__dependencies: [0]
+	},
+	text: {
+		padding: theme.spacing(3),
+		borderRadius: theme.borderRadius.md,
+		backgroundColor: theme.colors.deep,
+		color: theme.colors.hi,
+		fontFamily: fontOf(theme.fontFamily.mono),
+		fontSize: theme.fontSize.sm,
+		lineHeight: theme.lineHeightRelaxed.sm,
+		uni__dependencies: [0]
+	},
+	meta: {
+		color: theme.colors.dim,
+		fontFamily: fontOf(theme.fontFamily.sans),
+		fontSize: theme.fontSize.sm,
+		lineHeight: theme.lineHeight.sm,
+		uni__dependencies: [0]
+	},
+	notes: {
+		gap: theme.spacing(2),
+		uni__dependencies: [0]
+	},
+	fragment: { minHeight: 44 },
+	note: {
+		minHeight: 44,
+		flexDirection: "row",
+		alignItems: "center",
+		gap: theme.spacing(3),
+		paddingLeft: theme.spacing(3),
+		borderWidth: 1,
+		borderColor: theme.colors.border,
+		borderRadius: theme.borderRadius.md,
+		uni__dependencies: [0]
+	},
+	noteSelected: {
+		borderColor: theme.colors["edge-magenta"],
+		backgroundColor: theme.colors["tint-magenta"],
+		uni__dependencies: [0]
+	},
+	number: {
+		color: theme.colors.magenta,
+		fontFamily: fontOf(theme.fontFamily.sans),
+		fontSize: theme.fontSize.sm,
+		fontWeight: theme.fontWeight.semibold,
+		uni__dependencies: [0]
+	},
+	noteText: {
+		flex: 1,
+		paddingVertical: theme.spacing(2),
+		color: theme.colors.hi,
+		fontFamily: fontOf(theme.fontFamily.sans),
+		fontSize: theme.fontSize.base,
+		lineHeight: theme.lineHeight.base,
+		uni__dependencies: [0]
+	},
+	footer: {
+		gap: theme.spacing(3),
+		padding: theme.spacing(4),
+		borderTopWidth: 1,
+		borderTopColor: theme.colors.border,
+		backgroundColor: theme.colors.rail,
+		uni__dependencies: [0]
+	},
+	failed: {
+		color: theme.colors.red,
+		fontFamily: fontOf(theme.fontFamily.sans),
+		fontSize: theme.fontSize.sm,
+		lineHeight: theme.lineHeight.sm,
+		uni__dependencies: [0]
+	},
+	toolbar: {
+		flexDirection: "row",
+		flexWrap: "wrap",
+		gap: theme.spacing(1),
+		uni__dependencies: [0]
+	},
+	row: {
+		flexDirection: "row",
+		gap: theme.spacing(2),
+		uni__dependencies: [0]
+	},
+	grow: { flex: 1 }
+}));
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/_components/AuthorDocumentPanel.native.tsx
+const notesStore = defineGlobalStore({});
+const noteKey = (sessionId, path) => `${sessionId}\n${path}`;
+const EMPTY = [];
+const subscribeNotes = (listener) => {
+	const subscription = notesStore.store.subscribe(listener);
+	return () => subscription.unsubscribe();
+};
+const subscribeRequests = (listener) => {
+	const subscription = nativeAuthorRequests.store.subscribe(listener);
+	return () => subscription.unsubscribe();
+};
+function setNotes(key, update) {
+	notesStore.update((state) => ({
+		...state,
+		[key]: update(state[key] ?? EMPTY)
+	}));
+}
+const formsStore = defineGlobalStore({});
+const subscribeForms = (listener) => {
+	const subscription = formsStore.store.subscribe(listener);
+	return () => subscription.unsubscribe();
+};
+const hydratedKeys = /* @__PURE__ */ new Set();
+function setForm(key, draft) {
+	formsStore.update((state) => ({
+		...state,
+		[key]: draft
+	}));
+}
+/** The server-confirmed canvas alias for each open document, the only name the agent knows it by. */
+const aliasStore = defineGlobalStore({});
+const subscribeAliases = (listener) => {
+	const subscription = aliasStore.store.subscribe(listener);
+	return () => subscription.unsubscribe();
+};
+const pendingCanvases = /* @__PURE__ */ new Map();
+/** The loaded text per document, so the agent's comments can be pinned beside the line they quote. */
+const documentTexts = /* @__PURE__ */ new Map();
+function forgetAlias(key) {
+	aliasStore.update((state) => {
+		const next = { ...state };
+		delete next[key];
+		return next;
+	});
+}
+const COMMENT_SCHEMA = {
+	type: "object",
+	additionalProperties: false,
+	required: ["body"],
+	properties: {
+		body: {
+			type: "string",
+			minLength: 1
+		},
+		quote: { type: "string" }
+	}
+};
+/** What the agent may do on the phone's canvas: text takes comments as notes, images are read-only as on web. */
+function nativeProfiles(key, kind) {
+	if (kind !== "text" && kind !== "structured") return [{
+		id: AUTHOR_RUNTIME_BINDING_IDS.media,
+		tools: []
+	}];
+	return [{
+		id: AUTHOR_RUNTIME_BINDING_IDS.text,
+		tools: [{
+			name: "author_add_comment",
+			label: "Add comment",
+			description: "Add a review note to the open Author document, beside the quoted text when given.",
+			inputSchema: COMMENT_SCHEMA,
+			execute: async (input) => {
+				const value = typeof input === "object" && input !== null ? input : {};
+				if (typeof value.body !== "string" || value.body.trim() === "" || value.body.length > 2048) throw new Error("body must be 1 to 2048 characters");
+				if (value.quote !== void 0 && (typeof value.quote !== "string" || value.quote.length > 4096)) throw new Error("quote must be bounded text");
+				if (Object.keys(value).some((name) => name !== "body" && name !== "quote")) throw new Error("Unknown comment argument.");
+				const body = value.body;
+				const document = documentTexts.get(key);
+				const text = document?.text ?? "";
+				const at = typeof value.quote === "string" && value.quote !== "" ? text.indexOf(value.quote) : -1;
+				const lines = text.split("\n").length;
+				const line = at < 0 ? 0 : text.slice(0, at).split("\n").length - 1;
+				const y = Math.min(1, (line + .5) / Math.max(1, lines));
+				setNotes(key, (notes) => [...notes, {
+					id: `agent-${String(Date.now())}-${String(notes.length)}`,
+					x: .04,
+					y,
+					text: body,
+					sourceSha256: document?.sourceSha256
+				}]);
+				return { added: true };
+			}
+		}]
+	}];
+}
+/** Hands the document to the agent once per tab; a second call while open or opening does nothing. */
+function openNativeCanvas(sessionId, path, kind) {
+	const key = noteKey(sessionId, path);
+	if (pendingCanvases.has(key) || aliasStore.store.state[key] !== void 0) return;
+	const controller = new AbortController();
+	pendingCanvases.set(key, controller);
+	openAuthorNativeCanvas(sessionId, path, controller.signal).then(async ({ alias }) => {
+		if (controller.signal.aborted) return;
+		aliasStore.update((state) => ({
+			...state,
+			[key]: alias
+		}));
+		await openAuthorCanvas(sessionId, alias, nativeProfiles(key, kind));
+	}).catch((error) => {
+		if (!controller.signal.aborted) console.warn(`Author could not hand '${path}' to the agent: ${String(error)}`);
+	}).finally(() => {
+		if (pendingCanvases.get(key) === controller) pendingCanvases.delete(key);
+	});
+}
+function closeNativeCanvas(sessionId, path) {
+	const key = noteKey(sessionId, path);
+	pendingCanvases.get(key)?.abort();
+	pendingCanvases.delete(key);
+	documentTexts.delete(key);
+	const alias = aliasStore.store.state[key];
+	if (alias === void 0) return;
+	forgetAlias(key);
+	dropAuthorViewportSession(sessionId, alias);
+}
+const fileName = (path) => (path.startsWith("artifact:") ? path.slice(9) : path).split("/").at(-1) ?? path;
+const editsStore = defineGlobalStore({});
+const subscribeEdits = (listener) => {
+	const subscription = editsStore.store.subscribe(listener);
+	return () => subscription.unsubscribe();
+};
+function setEdit(key, edit) {
+	editsStore.update((state) => ({
+		...state,
+		[key]: edit
+	}));
+}
+async function persistNativeDraft(key, path, host) {
+	if (!hydratedKeys.has(key) || typeof host?.saveDraft !== "function") return;
+	const edit = editsStore.store.state[key];
+	const savedEdit = edit?.kind === "text" ? {
+		kind: "text",
+		text: edit.text,
+		sourceSha256: edit.sourceSha256
+	} : edit?.kind === "structured" ? {
+		kind: "structured",
+		sourceSha256: edit.file.sourceSha256,
+		fragments: edit.file.fragments.map(({ id, text }) => ({
+			id,
+			text
+		}))
+	} : void 0;
+	const value = parseNativeAuthorDraft({
+		version: 1,
+		notes: notesStore.store.state[key] ?? EMPTY,
+		draft: formsStore.store.state[key],
+		edit: savedEdit
+	});
+	await host.saveDraft(path, value.notes.length || value.draft || value.edit ? value : null);
+}
+/** The phone's Author canvas: loads one document, keeps its notes, and hands them to the agent. */
+function AuthorDocumentPanel({ path, ...props }) {
+	const { sessionId } = props;
+	const key = noteKey(sessionId ?? "", path);
+	const notes = useSyncExternalStore(subscribeNotes, () => notesStore.store.state[key] ?? EMPTY);
+	const alias = useSyncExternalStore(subscribeAliases, () => aliasStore.store.state[key]);
+	const ownedElsewhere = useSyncExternalStore(subscribeAuthorCanvasRejections, () => alias !== void 0 && sessionId !== null && authorCanvasRejection(sessionId, alias) !== void 0);
+	const [loaded, setLoaded] = useState();
+	const draft = useSyncExternalStore(subscribeForms, () => formsStore.store.state[key]);
+	const setDraft = (value) => setForm(key, value);
+	const [storageState, setStorageState] = useState();
+	const [selectedId, setSelectedId] = useState();
+	const [status, setStatus] = useState({ state: "idle" });
+	const requests = useSyncExternalStore(subscribeRequests, () => nativeAuthorRequests.select(nativeAuthorRequests.store.state, sessionId));
+	const sending = useRef(false);
+	const [mediaPage, setMediaPage] = useState(1);
+	const [seekSeconds, setSeekSeconds] = useState();
+	const [cropping, setCropping] = useState(false);
+	const [videoFrame, setVideoFrame] = useState();
+	const mediaTime = useRef(0);
+	const imageZoom = useRef(1);
+	const edit = useSyncExternalStore(subscribeEdits, () => editsStore.store.state[key]);
+	const captureRef = useRef(void 0);
+	const onCaptureReady = useCallback((capture) => {
+		if (capture !== void 0) captureRef.current = {
+			key,
+			capture
+		};
+		else if (captureRef.current?.key === key) captureRef.current = void 0;
+	}, [key]);
+	useEffect(() => {
+		if (sessionId === null) return;
+		const controller = new AbortController();
+		const host = props.nativeAuthor;
+		const fail = (error) => {
+			if (!controller.signal.aborted) setLoaded({
+				key,
+				error: error instanceof Error ? error.message : String(error)
+			});
+		};
+		(async () => {
+			let restoredEdit;
+			let restoreReady = hydratedKeys.has(key);
+			if (!hydratedKeys.has(key)) try {
+				if (typeof host?.loadDraft !== "function") throw new Error("Update the native app to keep drafts across restarts.");
+				const value = await host.loadDraft(path);
+				if (controller.signal.aborted) return;
+				if (value !== null) {
+					const restored = parseNativeAuthorDraft(value);
+					setNotes(key, (notes) => [...restored.notes.filter((note) => !notes.some((current) => current.id === note.id)), ...notes]);
+					if (formsStore.store.state[key] === void 0) setForm(key, restored.draft);
+					restoredEdit = restored.edit;
+				}
+				restoreReady = true;
+			} catch (error) {
+				if (controller.signal.aborted) return;
+				setStorageState({
+					key,
+					message: `Draft storage unavailable: ${error instanceof Error ? error.message : String(error)} Keep this tab open.`
+				});
+			}
+			const file = await loadAuthorFile(sessionId, path, controller.signal);
+			if (controller.signal.aborted) return;
+			if (restoredEdit && editsStore.store.state[key] === void 0) {
+				if (restoredEdit.kind === "text" && file.kind === "text") setEdit(key, {
+					...restoredEdit,
+					saving: false
+				});
+				else if (restoredEdit.kind === "structured" && file.kind === "structured" && restoredEdit.sourceSha256 === file.sourceSha256) {
+					const replacements = new Map(restoredEdit.fragments.map((fragment) => [fragment.id, fragment.text]));
+					if (replacements.size === file.fragments.length && file.fragments.every((fragment) => replacements.has(fragment.id) && (!fragment.readOnly || replacements.get(fragment.id) === fragment.text))) setEdit(key, {
+						kind: "structured",
+						file: {
+							...file,
+							fragments: file.fragments.map((fragment) => ({
+								...fragment,
+								text: replacements.get(fragment.id)
+							}))
+						},
+						saving: false
+					});
+					else restoredEdit = void 0;
+				} else restoredEdit = void 0;
+				if (restoredEdit === void 0) {
+					restoreReady = false;
+					setStorageState({
+						key,
+						message: "The stored edit no longer matches this document. Its stored copy was kept; new notes stay in memory. Keep this tab open."
+					});
+				}
+			}
+			if (restoreReady) {
+				hydratedKeys.add(key);
+				setStorageState({ key });
+			}
+			openNativeCanvas(sessionId, path, file.kind);
+			if (file.kind === "text") {
+				documentTexts.set(key, {
+					text: file.text,
+					sourceSha256: file.sourceSha256
+				});
+				setLoaded({
+					key,
+					file,
+					body: {
+						kind: "text",
+						text: file.text
+					}
+				});
+			} else if (file.kind === "structured") {
+				documentTexts.set(key, {
+					text: file.fragments.map((fragment) => fragment.text).join("\n"),
+					sourceSha256: file.sourceSha256
+				});
+				setLoaded({
+					key,
+					file,
+					body: {
+						kind: "structured",
+						format: file.format,
+						fragments: file.fragments
+					}
+				});
+			} else if (file.kind === "pdf" || file.kind === "video") {
+				setLoaded({
+					key,
+					file,
+					body: { kind: file.kind }
+				});
+				setMediaPage(1);
+				setSeekSeconds(void 0);
+				setVideoFrame(void 0);
+				mediaTime.current = 0;
+			} else {
+				const uri = `data:${file.mimeType};base64,${file.data}`;
+				Image.getSize(uri, (width, height) => {
+					if (!controller.signal.aborted) setLoaded({
+						key,
+						file,
+						body: {
+							kind: "image",
+							uri,
+							aspectRatio: height > 0 ? width / height : 1,
+							naturalWidth: width,
+							naturalHeight: height
+						}
+					});
+				}, fail);
+			}
+		})().catch(fail);
+		return () => controller.abort();
+	}, [
+		sessionId,
+		path,
+		key
+	]);
+	useEffect(() => {
+		const timer = setTimeout(() => {
+			persistNativeDraft(key, path, props.nativeAuthor).then(() => {
+				if (hydratedKeys.has(key)) setStorageState({ key });
+			}).catch((error) => setStorageState({
+				key,
+				message: `Couldn't store this draft: ${error instanceof Error ? error.message : String(error)} Keep this tab open.`
+			}));
+		}, 300);
+		return () => clearTimeout(timer);
+	}, [
+		key,
+		path,
+		notes,
+		draft,
+		edit
+	]);
+	useEffect(() => {
+		let mounted = true;
+		const host = props.nativeAuthor;
+		const flush = () => {
+			persistNativeDraft(key, path, host).catch((error) => {
+				console.warn(`Author draft storage failed for '${path}': ${String(error)}`);
+				if (mounted) setStorageState({
+					key,
+					message: `Couldn't store this draft: ${String(error)} Keep this tab open.`
+				});
+			});
+		};
+		const subscription = AppState.addEventListener("change", (state) => {
+			if (state !== "active") flush();
+		});
+		return () => {
+			mounted = false;
+			subscription.remove();
+			flush();
+		};
+	}, [key, path]);
+	if (sessionId === null) return /* @__PURE__ */ jsx(EmptyState, { title: "This session is unavailable." });
+	const current = loaded?.key === key ? loaded : void 0;
+	if (current === void 0) return /* @__PURE__ */ jsx(Spinner, { label: "Opening" });
+	if ("error" in current) return /* @__PURE__ */ jsx(EmptyState, {
+		title: "Couldn't open this file",
+		description: current.error
+	});
+	const visibleNotes = nativeAuthorVisibleNotes(notes, current.file.kind, mediaPage, videoFrame?.timeSeconds);
+	const send = async () => {
+		if (sending.current) return;
+		sending.current = true;
+		const sent = visibleNotes.slice(0, 16);
+		const capturedAt = Date.now();
+		const captureId = `native-author-${String(capturedAt)}-${sent[0]?.id ?? "notes"}`;
+		let recorded = false;
+		try {
+			if (!sent.length) throw new Error("Open a marked page or capture its video frame before sending notes.");
+			if (!props.submitCapture) throw new Error("This host cannot confirm feedback delivery. Your notes have not been sent.");
+			const provider = captureRef.current;
+			if (provider?.key !== key) throw new Error("The document is not ready to capture. Try again when it has finished opening.");
+			const capture = await provider.capture();
+			setStatus({ state: "sending" });
+			if (capture.bytes.byteLength > 2097152 || Math.max(capture.width, capture.height) > 1600) throw new Error("This capture exceeds the Author evidence budget.");
+			const { file, body } = current;
+			const { packet, regions } = nativeAuthorCapture(captureId, capturedAt, {
+				path,
+				version: 1,
+				sourceSha256: file.sourceSha256,
+				kind: file.kind === "structured" ? file.format : file.kind === "text" && /\.html?$/iu.test(path) ? "html" : file.kind,
+				...file.kind === "structured" ? { fragments: file.fragments } : {},
+				...file.kind === "text" ? { sourceText: file.text } : {},
+				...body.kind === "image" ? {
+					naturalWidth: body.naturalWidth,
+					naturalHeight: body.naturalHeight
+				} : {}
+			}, sent, {
+				width: capture.width,
+				height: capture.height,
+				...file.kind === "image" ? { zoom: imageZoom.current } : {}
+			}, alias);
+			recordNativeAuthorRequest(sessionId, packet, regions);
+			recorded = true;
+			await props.submitCapture({
+				data: encodeBase64(capture.bytes),
+				mimeType: capture.mimeType,
+				context: authorCaptureContext(packet)
+			});
+			setNotes(key, (notes) => notes.filter((note) => !sent.includes(note)));
+			setSelectedId(void 0);
+			setStatus({ state: "sent" });
+			await persistNativeDraft(key, path, props.nativeAuthor).catch((error) => setStorageState({
+				key,
+				message: `Sent, but couldn't update the stored draft: ${String(error)} It may reappear after restart.`
+			}));
+		} catch (error) {
+			if (recorded) failNativeAuthorRequest(sessionId, captureId, error);
+			setStatus({
+				state: "failed",
+				message: error instanceof Error ? error.message : String(error)
+			});
+		} finally {
+			sending.current = false;
+		}
+	};
+	const save = async () => {
+		const pending = editsStore.store.state[key];
+		if (pending === void 0 || pending.saving) return;
+		setEdit(key, {
+			...pending,
+			saving: true
+		});
+		try {
+			const signal = new AbortController().signal;
+			if (pending.kind === "structured") {
+				const digest = await saveAuthorNativeStructured(sessionId, path, pending.file, signal);
+				const file = {
+					...pending.file,
+					sourceSha256: digest,
+					originalFragments: pending.file.fragments.map((fragment) => ({ ...fragment }))
+				};
+				documentTexts.set(key, {
+					text: file.fragments.map((fragment) => fragment.text).join("\n"),
+					sourceSha256: file.sourceSha256
+				});
+				setLoaded({
+					key,
+					file,
+					body: {
+						kind: "structured",
+						format: file.format,
+						fragments: file.fragments
+					}
+				});
+			} else if (pending.kind === "image") {
+				const digest = await saveAuthorNativeImage(sessionId, path, pending.image, pending.sourceSha256, signal);
+				const { width, height, mimeType, bytes } = pending.image;
+				setLoaded({
+					key,
+					file: {
+						kind: "image",
+						data: encodeBase64(bytes),
+						mimeType,
+						sourceSha256: digest
+					},
+					body: {
+						kind: "image",
+						uri: pending.uri,
+						aspectRatio: width / height,
+						naturalWidth: width,
+						naturalHeight: height
+					}
+				});
+			} else {
+				const digest = await saveAuthorNativeText(sessionId, path, pending.text, pending.sourceSha256, signal);
+				documentTexts.set(key, {
+					text: pending.text,
+					sourceSha256: digest
+				});
+				setLoaded({
+					key,
+					file: {
+						kind: "text",
+						text: pending.text,
+						sourceSha256: digest
+					},
+					body: {
+						kind: "text",
+						text: pending.text
+					}
+				});
+			}
+			setEdit(key, void 0);
+		} catch (error) {
+			setEdit(key, {
+				...pending,
+				saving: false,
+				error: error instanceof Error ? error.message : String(error)
+			});
+		}
+	};
+	const native = props.nativeAuthor;
+	const selectedNote = notes.find((note) => note.id === selectedId);
+	const cropBounds = selectedNote?.points === void 0 ? null : authorStrokeBounds(selectedNote.points);
+	const canCrop = native !== void 0 && current.file.kind === "image" && current.file.sourceSha256 !== void 0 && selectedNote?.sourceSha256 === current.file.sourceSha256 && /\.(?:png|jpe?g)$/iu.test(path) && !path.startsWith("artifact:") && current.body.kind === "image" && current.body.naturalWidth !== void 0 && current.body.naturalHeight !== void 0 && cropBounds !== null;
+	const crop = async () => {
+		if (!canCrop || cropping || current.file.kind !== "image" || current.body.kind !== "image" || !native || !cropBounds) return;
+		const width = current.body.naturalWidth;
+		const height = current.body.naturalHeight;
+		const originX = Math.floor(cropBounds.x * width);
+		const originY = Math.floor(cropBounds.y * height);
+		setCropping(true);
+		try {
+			const image = await native.cropImage({
+				source: {
+					sessionId,
+					bytes: decodeBase64(current.file.data),
+					mimeType: current.file.mimeType
+				},
+				rect: {
+					originX,
+					originY,
+					width: Math.max(1, Math.min(width, Math.ceil((cropBounds.x + cropBounds.width) * width)) - originX),
+					height: Math.max(1, Math.min(height, Math.ceil((cropBounds.y + cropBounds.height) * height)) - originY)
+				},
+				format: /\.png$/iu.test(path) ? "png" : "jpeg",
+				signal: new AbortController().signal
+			});
+			setEdit(key, {
+				kind: "image",
+				image,
+				uri: `data:${image.mimeType};base64,${encodeBase64(image.bytes)}`,
+				sourceSha256: current.file.sourceSha256,
+				saving: false
+			});
+		} catch (error) {
+			setStatus({
+				state: "failed",
+				message: `Crop failed: ${error instanceof Error ? error.message : String(error)}`
+			});
+		} finally {
+			setCropping(false);
+		}
+	};
+	const nativeContent = current.file.kind === "pdf" ? native?.renderPdf({
+		key,
+		source: {
+			sessionId,
+			bytes: current.file.bytes,
+			mimeType: current.file.mimeType
+		},
+		page: mediaPage,
+		onPageChange: ({ page }) => setMediaPage(page)
+	}) ?? /* @__PURE__ */ jsx(EmptyState, { title: "Update the native app to view this PDF." }) : current.file.kind === "video" ? videoFrame !== void 0 ? /* @__PURE__ */ jsx(Image, {
+		accessibilityLabel: `Video frame at ${String(videoFrame.timeSeconds)} seconds`,
+		source: { uri: `data:${videoFrame.mimeType};base64,${encodeBase64(videoFrame.bytes)}` },
+		style: {
+			width: "100%",
+			aspectRatio: videoFrame.width / videoFrame.height
+		},
+		resizeMode: "contain"
+	}) : native?.renderVideo({
+		key,
+		source: {
+			sessionId,
+			bytes: current.file.bytes,
+			mimeType: current.file.mimeType
+		},
+		seekSeconds,
+		onTimeChange: (seconds) => {
+			mediaTime.current = seconds;
+		},
+		onFrame: (frame) => {
+			mediaTime.current = frame.timeSeconds;
+			setVideoFrame(frame);
+		}
+	}) ?? /* @__PURE__ */ jsx(EmptyState, { title: "Update the native app to play this video." }) : current.file.kind === "text" && /\.html?$/iu.test(path) ? native?.renderHtml({
+		key,
+		html: current.file.text
+	}) : void 0;
+	const noteLocation = () => current.file.kind === "pdf" ? { page: mediaPage } : current.file.kind === "video" ? { timeSeconds: mediaTime.current } : {};
+	return /* @__PURE__ */ jsx(AuthorDocumentView, {
+		name: fileName(path),
+		body: current.body,
+		sourceSha256: current.file.sourceSha256,
+		nativeContent,
+		captureContent: (children) => native?.renderCapture({
+			key,
+			children,
+			onReady: onCaptureReady
+		}) ?? children,
+		onZoomChange: (zoom) => {
+			imageZoom.current = zoom;
+		},
+		onResumeVideo: videoFrame === void 0 ? void 0 : () => {
+			setSeekSeconds(videoFrame.timeSeconds);
+			setVideoFrame(void 0);
+		},
+		storageMessage: storageState?.key === key ? storageState.message ?? (edit?.kind === "image" ? "Crop previews are temporary until saved." : void 0) : void 0,
+		page: current.file.kind === "pdf" ? mediaPage : void 0,
+		timeSeconds: current.file.kind === "video" ? mediaTime.current : void 0,
+		notes,
+		requests: requests.filter((request) => request.documentPath === path),
+		draft,
+		status,
+		edit: edit?.kind === "structured" ? {
+			fragments: edit.file.fragments,
+			saving: edit.saving,
+			error: edit.error
+		} : edit?.kind === "image" ? {
+			image: {
+				uri: edit.uri,
+				aspectRatio: edit.image.width / edit.image.height
+			},
+			saving: edit.saving,
+			error: edit.error
+		} : edit,
+		onCrop: canCrop ? () => void crop() : void 0,
+		cropping,
+		onEdit: (current.file.kind === "text" || current.file.kind === "structured") && current.file.sourceSha256 !== void 0 && !path.startsWith("artifact:") ? () => {
+			if (current.file.kind === "text" && current.file.sourceSha256 !== void 0) setEdit(key, {
+				kind: "text",
+				text: current.file.text,
+				sourceSha256: current.file.sourceSha256,
+				saving: false
+			});
+			else if (current.file.kind === "structured") setEdit(key, {
+				kind: "structured",
+				file: current.file,
+				saving: false
+			});
+		} : void 0,
+		onEditChange: (text) => {
+			if (edit?.kind === "text" && !edit.saving) setEdit(key, {
+				...edit,
+				text
+			});
+		},
+		onEditFragmentChange: (id, text) => {
+			if (edit?.kind !== "structured" || edit.saving) return;
+			const fragments = edit.file.fragments.map((fragment) => fragment.id === id && !fragment.readOnly ? {
+				...fragment,
+				text
+			} : fragment);
+			setEdit(key, {
+				...edit,
+				file: {
+					...edit.file,
+					fragments
+				}
+			});
+		},
+		onEditCancel: () => {
+			if (!edit?.saving) setEdit(key, void 0);
+		},
+		onEditSave: () => void save(),
+		ownedElsewhere,
+		...selectedId === void 0 ? {} : { selectedId },
+		onPlace: current.file.kind === "video" && videoFrame === void 0 ? void 0 : (point) => {
+			setSelectedId(void 0);
+			setDraft({
+				...point,
+				...noteLocation(),
+				sourceSha256: current.file.sourceSha256,
+				text: draft?.text ?? ""
+			});
+		},
+		onSelectText: current.file.kind === "text" && current.file.sourceSha256 !== void 0 && /^[a-f0-9]{64}$/u.test(current.file.sourceSha256) && !/\.html?$/iu.test(path) ? (textRange) => {
+			if (current.file.kind !== "text" || nativeAuthorTextRange(current.file.text, textRange) === void 0) return;
+			setSelectedId(void 0);
+			setDraft({
+				x: .5,
+				y: .5,
+				textRange: { ...textRange },
+				sourceSha256: current.file.sourceSha256,
+				text: ""
+			});
+		} : void 0,
+		onDraw: current.file.kind === "video" && videoFrame === void 0 ? void 0 : (points) => {
+			const point = points.at(-1);
+			if (point === void 0) return;
+			setSelectedId(void 0);
+			setDraft({
+				...point,
+				...noteLocation(),
+				sourceSha256: current.file.sourceSha256,
+				text: "",
+				points
+			});
+		},
+		onSelect: (id) => {
+			const note = notes.find((note) => note.id === id);
+			if (note?.page !== void 0) setMediaPage(note.page);
+			if (note?.timeSeconds !== void 0) {
+				setVideoFrame(void 0);
+				setSeekSeconds(note.timeSeconds);
+			}
+			setSelectedId((value) => value === id ? void 0 : id);
+		},
+		onDelete: (id) => {
+			setNotes(key, (notes) => notes.filter((note) => note.id !== id));
+			if (selectedId === id) setSelectedId(void 0);
+		},
+		onDraftChange: (text) => {
+			if (draft !== void 0) setDraft({
+				...draft,
+				text
+			});
+		},
+		onDraftCancel: () => setDraft(void 0),
+		onDraftSave: () => {
+			if (draft === void 0 || draft.text.trim() === "") return;
+			setNotes(key, (notes) => [...notes, {
+				id: `note-${String(Date.now())}-${String(notes.length)}`,
+				...draft
+			}]);
+			setDraft(void 0);
+			if (status.state !== "sending") setStatus({ state: "idle" });
+		},
+		sendCount: Math.min(16, visibleNotes.length),
+		onSend: () => void send()
+	});
+}
+function tabId(sessionId, path) {
+	let hash = 2166136261;
+	for (const char of `${sessionId}\n${path}`) hash = Math.imul(hash ^ char.charCodeAt(0), 16777619);
+	return `${AUTHOR_FILE_TAB_PREFIX}${(hash >>> 0).toString(36)}`;
+}
+/** The `author.open-source` fill on the phone: the same contract web reads, opening the native canvas. */
+const authorNativeOpenSourceAction = {
+	version: 1,
+	createTab({ sessionId, path, preview }) {
+		const valid = authorNotePath(path);
+		if (sessionId.trim() === "" || valid === void 0) throw new Error("Author source opening requires a session and a repository-relative path.");
+		if (!authorNativeCanOpen(valid)) throw new Error("This kind of file cannot be marked up on this device yet.");
+		return {
+			id: tabId(sessionId, valid),
+			label: fileName(valid),
+			retainComposer: true,
+			panel: (props) => {
+				if (/\.stories\.(?:jsx?|tsx?)$/iu.test(valid)) {
+					const source = {
+						path: valid,
+						kind: "story-preview",
+						hasUnsavedChanges: editsStore.store.state[noteKey(sessionId, valid)] !== void 0,
+						preview: {
+							appPath: preview?.appPath ?? "",
+							storyExport: preview?.storyExport ?? "Playground",
+							snapshot: true
+						}
+					};
+					const Preview = props.slotData(authorPreviewActionSlot).find((fill) => fill.data.supportsSource?.(source))?.data.embeddedPanel;
+					if (Preview !== void 0) return /* @__PURE__ */ jsx(Preview, {
+						...props,
+						sessionId,
+						source
+					});
+				}
+				return /* @__PURE__ */ jsx(AuthorDocumentPanel, {
+					...props,
+					sessionId,
+					path: valid
+				});
+			},
+			onClose(target) {
+				closeNativeCanvas(target, valid);
+			},
+			composerContext(target) {
+				const key = noteKey(target, valid);
+				const notes = notesStore.store.state[key] ?? EMPTY;
+				if (notes.length === 0) return void 0;
+				const alias = aliasStore.store.state[key];
+				return {
+					kind: "author-document",
+					source: "author",
+					id: valid,
+					label: alias === void 0 ? fileName(valid) : `${alias} · ${fileName(valid)}`,
+					content: authorNotesContent(valid, notes)
+				};
+			}
+		};
+	}
+};
+const nativeFileTab = (sessionId, path) => {
+	if (sessionId === null) return void 0;
+	const normalized = authorNotePath(path.replace(/:\d+(?::\d+)?$/, ""));
+	return normalized !== void 0 && authorNativeCanOpen(normalized) ? authorNativeOpenSourceAction.createTab({
+		sessionId,
+		path: normalized
+	}) : void 0;
+};
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/file-links/author-document.native.ts
+var author_document_native_default = defineFileLinks({
+	requiredMinorMode: "author",
+	subscribe: subscribeAliases,
+	fingerprint(sessionId) {
+		return Object.keys(aliasStore.store.state).filter((key) => key.startsWith(`${sessionId ?? ""}\n`)).sort().join("\n");
+	},
+	resolve(sessionId, path) {
+		const normalized = authorNotePath(path.replace(/:\d+(?::\d+)?$/, ""));
+		return sessionId !== null && normalized !== void 0 && aliasStore.store.state[noteKey(sessionId, normalized)] !== void 0 ? nativeFileTab(sessionId, normalized) : void 0;
+	},
+	openPath: nativeFileTab
+});
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/fill/Author.author.open-source.native.ts
+var Author_author_open_source_native_default = defineFill({
+	slot: "author.open-source",
+	id: "author",
+	data: authorNativeOpenSourceAction
+});
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/lifecycle/start.native.ts
+var start_native_default = defineWebLifecycle((runtime) => {
+	const stopRequests = startNativeAuthorRequests(runtime);
+	const stopBridge = startAuthorBrowserBridge(runtime);
+	return () => {
+		try {
+			stopBridge();
+		} finally {
+			stopRequests();
+		}
+	};
+});
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/slot/open-source.native.ts
+var open_source_native_default = defineSlotFile({
+	slot: "author.open-source",
+	parse: parseAuthorOpenSourceAction
+});
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/slot/preview-action.native.ts
+var preview_action_native_default = defineSlotFile({
+	slot: "author.preview-action",
+	parse: parseAuthorPreviewAction
+});
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/tool/_lib/authorToolFile.native.ts
+/** Read only server result details, never the unvalidated requested path. */
+function nativeAuthorToolFile(result) {
+	const details = result?.details;
+	if (typeof details !== "object" || details === null || !("path" in details) || typeof details.path !== "string") return void 0;
+	const path = authorNotePath(details.path);
+	if (path === void 0) return void 0;
+	const alias = "alias" in details && typeof details.alias === "string" && details.alias.trim() !== "" ? details.alias : void 0;
+	return {
+		path,
+		...alias === void 0 ? {} : { alias }
+	};
+}
+/** Unsupported results remain a readable tool card instead of breaking live frame delivery. */
+function nativeAuthorToolTab(sessionId, result) {
+	const file = nativeAuthorToolFile(result);
+	if (sessionId === null || sessionId.trim() === "" || file === void 0) return void 0;
+	try {
+		const tab = authorNativeOpenSourceAction.createTab({
+			sessionId,
+			path: file.path
+		});
+		return file.alias === void 0 ? tab : {
+			...tab,
+			label: `${file.alias} · ${tab.label}`
+		};
+	} catch {
+		return;
+	}
+}
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/tool/_components/AuthorToolMessage.native.tsx
+const COLLAPSED_LINES = 8;
+/** Native Author tool outcomes use the same shared timeline shell as the host's tools. */
+function AuthorToolMessage(props) {
+	const { toolName, args, result, output, running, isError, sessionId } = props;
+	const opening = toolName === "open_authoring_file";
+	const file = opening ? nativeAuthorToolFile(result) : void 0;
+	const tab = opening && !running && !isError ? nativeAuthorToolTab(sessionId, result) : void 0;
+	const unavailable = opening && !running && !isError && result !== null && tab === void 0;
+	const failed = isError || unavailable;
+	const summary = opening ? file?.alias === void 0 ? typeof args.path === "string" ? args.path : "document" : `${file.alias} · ${file.path}` : toolName === "use_author_tools" && typeof args.name === "string" ? args.name : "";
+	const lines = resultTextLines(result, output);
+	const collapsed = collapseLines(lines, COLLAPSED_LINES, false);
+	return /* @__PURE__ */ jsx(MessageItem, {
+		tone: toolTone({
+			running,
+			isError: failed
+		}),
+		expandable: collapsed.hidden > 0,
+		children: ({ expanded }) => {
+			const view = expanded ? collapseLines(lines, COLLAPSED_LINES, true) : collapsed;
+			return /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx(MessageItemHeader, {
+				title: toolName,
+				children: summary
+			}), view.shown.length > 0 || running || failed || opening ? /* @__PURE__ */ jsxs(MessageItemBody, {
+				testID: `tool-result-${toolName}`,
+				children: [
+					view.shown.map((line, index) => /* @__PURE__ */ jsx(Text, {
+						selectable: true,
+						style: [styles.line, isError && styles.error],
+						children: line
+					}, index)),
+					view.hidden > 0 ? /* @__PURE__ */ jsxs(MessageItemStatus, {
+						expands: true,
+						children: [view.hidden, " more line(s)"]
+					}) : null,
+					opening || running || isError ? /* @__PURE__ */ jsx(MessageItemStatus, {
+						tone: failed ? "error" : running ? "running" : void 0,
+						children: isError ? "failed" : running ? opening ? "validating" : "running" : unavailable ? "unavailable" : tab === void 0 ? "waiting" : "ready"
+					}) : null,
+					tab !== void 0 ? /* @__PURE__ */ jsx(Button, {
+						variant: "outline",
+						onPress: () => {
+							props.openTransientTab(tab);
+							props.openTab(tab.id);
+						},
+						children: "Open in Author"
+					}) : null
+				]
+			}) : null] });
+		}
+	});
+}
+const styles = StyleSheet.create((theme) => ({
+	line: {
+		fontFamily: fontOf(theme.fontFamily.sans),
+		fontSize: theme.fontSize.base,
+		lineHeight: theme.lineHeight.base,
+		color: theme.colors.dim,
+		uni__dependencies: [0]
+	},
+	error: {
+		color: theme.colors.red,
+		uni__dependencies: [0]
+	}
+}));
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/tool/describe-author-tools.native.tsx
+var describe_author_tools_native_default = defineToolRenderer({
+	tools: ["describe_author_tools"],
+	message: AuthorToolMessage
+});
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/tool/open-authoring-file.native.tsx
+var open_authoring_file_native_default = defineToolRenderer({
+	tools: ["open_authoring_file"],
+	message: AuthorToolMessage,
+	completionTab: ({ sessionId, result }) => nativeAuthorToolTab(sessionId, result)
+});
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/tool/use-author-tools.native.tsx
+var use_author_tools_native_default = defineToolRenderer({
+	tools: ["use_author_tools"],
+	message: AuthorToolMessage
+});
+//#endregion
+//#region generated/native.ts
+const via = (identity, value) => value === void 0 ? void 0 : {
+	...identity,
+	...value
+};
+const nativePlugin = defineNativePlugin({
+	id: "author",
+	session: {
+		get channels() {
+			return [via({ channel: "author_webmcp" }, author_webmcp_native_default)];
+		},
+		get fileLinks() {
+			return author_document_native_default;
+		},
+		get fills() {
+			return [via({
+				slot: "author.open-source",
+				id: "author"
+			}, Author_author_open_source_native_default)];
+		},
+		get slots() {
+			return [via({ slot: "author.open-source" }, open_source_native_default), via({ slot: "author.preview-action" }, preview_action_native_default)];
+		},
+		get start() {
+			return start_native_default;
+		},
+		get toolRenderers() {
+			return [
+				via({ tools: ["describe_author_tools"] }, describe_author_tools_native_default),
+				via({ tools: ["open_authoring_file"] }, open_authoring_file_native_default),
+				via({ tools: ["use_author_tools"] }, use_author_tools_native_default)
+			];
+		}
+	}
+});
+//#endregion
+export { nativePlugin };
+
+//# sourceMappingURL=native.mjs.map