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

package/src/web/api/authorFiles.ts

@@ -0,0 +1,219 @@
+import { sealedTransport } from '@agimon-ai/doompi-web-security/browser';
+import type {
+  CsvDialect,
+  DocumentFragment,
+  DocumentOperation,
+  DocumentPreflightReport,
+  ParsedStructuredDocument,
+  StructuredDocumentFormat,
+} from '../../types/structuredDocuments.ts';
+import type { AuthorDocumentInput, AuthorDocumentKind } from '../lib/authorViewportTypes.ts';
+
+const IMAGE_EXTENSIONS = new Set(['avif', 'bmp', 'gif', 'jpeg', 'jpg', 'png', 'svg', 'webp']);
+const VIDEO_EXTENSIONS = new Set(['m4v', 'mov', 'mp4', 'webm']);
+
+function structuredFormat(path: string): StructuredDocumentFormat | undefined {
+  const lower = path.toLowerCase();
+  if (lower.endsWith('.slides.md')) return 'markdown-slides';
+  if (lower.endsWith('.csv')) return 'csv';
+  if (lower.endsWith('.pptx')) return 'pptx';
+  if (lower.endsWith('.xlsx')) return 'xlsx';
+  return undefined;
+}
+
+export function authorKindForPath(path: string): AuthorDocumentKind {
+  const format = structuredFormat(path);
+  if (format === 'markdown-slides') return 'slides';
+  if (format !== undefined) return format;
+  const extension = path.split('.').at(-1)?.toLowerCase() ?? '';
+  if (extension === 'md') return 'markdown';
+  if (IMAGE_EXTENSIONS.has(extension)) return 'image';
+  if (VIDEO_EXTENSIONS.has(extension)) return 'video';
+  if (extension === 'pdf') return 'pdf';
+  if (['txt', 'json', 'yaml', 'yml', 'xml', 'html', 'css', 'js', 'ts', 'tsx', 'jsx'].includes(extension)) return 'text';
+  return 'opaque';
+}
+
+export function authorSessionFileUrl(sessionId: string, path: string): string {
+  return `/api/sessions/${encodeURIComponent(sessionId)}/file?path=${encodeURIComponent(path)}`;
+}
+
+function authorDocumentApiUrl(sessionId: string, operation: 'open' | 'preflight' | 'serialize'): string {
+  return `/api/plugin/author/documents/${operation}?session=${encodeURIComponent(sessionId)}`;
+}
+
+async function jsonRequest<T>(url: string, body: Record<string, unknown>, signal?: AbortSignal): Promise<T> {
+  const response = await sealedTransport.fetch(url, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify(body),
+    signal,
+  });
+  const value = (await response.json()) as T & { error?: unknown };
+  if (!response.ok)
+    throw new Error(typeof value.error === 'string' ? value.error : `Author document API failed (${response.status})`);
+  return value;
+}
+
+export async function loadAuthorDocument(
+  sessionId: string,
+  path: string,
+  signal?: AbortSignal,
+): Promise<AuthorDocumentInput> {
+  const kind = authorKindForPath(path);
+  const url = authorSessionFileUrl(sessionId, path);
+  const response = await sealedTransport.fetch(url, { signal });
+  if (!response.ok) throw new Error(`Author could not open ${path} (${response.status})`);
+  const sourceSha256 = response.headers.get('X-File-SHA256') ?? undefined;
+  const format = structuredFormat(path);
+  if (format !== undefined) {
+    const parsed = await jsonRequest<ParsedStructuredDocument>(
+      authorDocumentApiUrl(sessionId, 'open'),
+      { path, format },
+      signal,
+    );
+    const parsedDigest = parsed.manifest?.sourceDigest;
+    if (sourceSha256 !== undefined && parsedDigest !== undefined && sourceSha256 !== parsedDigest) {
+      throw new Error('Document source changed while opening. Reopen the document.');
+    }
+    const csvDialect = format === 'csv' ? csvDialectFromMetadata(parsed.manifest?.metadata) : undefined;
+    return {
+      path,
+      kind,
+      title: path.split('/').at(-1) ?? path,
+      structuredFormat: format,
+      fragments: parsed.fragments,
+      ...(csvDialect === undefined ? {} : { csvDialect }),
+      originalFragments: parsed.fragments.map((fragment) => ({ ...fragment })),
+      ...(sourceSha256 === undefined ? {} : { sourceSha256 }),
+    };
+  }
+  const mediaUrl = kind === 'image' || kind === 'video' || kind === 'pdf' || kind === 'opaque' ? url : undefined;
+  const content = kind === 'text' || kind === 'markdown' ? await response.text() : undefined;
+  return {
+    path,
+    kind,
+    title: path.split('/').at(-1) ?? path,
+    ...(content === undefined ? {} : { content }),
+    ...(mediaUrl === undefined ? {} : { mediaUrl }),
+    ...(sourceSha256 === undefined ? {} : { sourceSha256 }),
+  };
+}
+
+function operationsFor(document: AuthorDocumentInput): DocumentOperation[] {
+  const originals = new Map((document.originalFragments ?? []).map((fragment) => [fragment.id, fragment.text]));
+  return (document.fragments ?? [])
+    .filter((fragment) => !fragment.readOnly && originals.get(fragment.id) !== fragment.text)
+    .map((fragment) => ({ fragmentId: fragment.id, replacement: fragment.text }));
+}
+
+function decodeBase64(value: string): Uint8Array {
+  if (!/^(?:[A-Za-z\d+/]{4})*(?:[A-Za-z\d+/]{2}==|[A-Za-z\d+/]{3}=)?$/.test(value))
+    throw new Error('Invalid serialized document bytes.');
+  const binary = atob(value);
+  return Uint8Array.from(binary, (character) => character.charCodeAt(0));
+}
+
+function imageMimeType(path: string): 'image/png' | 'image/jpeg' | 'image/webp' | undefined {
+  const extension = path.split('.').at(-1)?.toLowerCase();
+  if (extension === 'png') return 'image/png';
+  if (extension === 'jpg' || extension === 'jpeg') return 'image/jpeg';
+  if (extension === 'webp') return 'image/webp';
+  return undefined;
+}
+
+async function croppedImageBytes(documentInput: AuthorDocumentInput, signal?: AbortSignal): Promise<Blob> {
+  const { crop, mediaUrl } = documentInput;
+  if (crop === undefined || mediaUrl === undefined) throw new Error('This Author image has no crop source.');
+  const mimeType = imageMimeType(documentInput.path);
+  if (mimeType === undefined) throw new Error('This image format cannot preserve its encoding after crop.');
+  const response = await sealedTransport.fetch(mediaUrl, { signal, cache: 'no-store' });
+  if (!response.ok) throw new Error(`Author could not read the image before saving (${response.status})`);
+  const bitmap = await createImageBitmap(await response.blob());
+  try {
+    const sourceX = Math.round(crop.x * bitmap.width);
+    const sourceY = Math.round(crop.y * bitmap.height);
+    const sourceWidth = Math.max(1, Math.round(crop.width * bitmap.width));
+    const sourceHeight = Math.max(1, Math.round(crop.height * bitmap.height));
+    const canvas = window.document.createElement('canvas');
+    canvas.width = sourceWidth;
+    canvas.height = sourceHeight;
+    const context = canvas.getContext('2d');
+    if (context === null) throw new Error('Canvas is unavailable for image crop.');
+    context.drawImage(bitmap, sourceX, sourceY, sourceWidth, sourceHeight, 0, 0, sourceWidth, sourceHeight);
+    const blob = await new Promise<Blob | null>((resolve) => canvas.toBlob(resolve, mimeType));
+    if (blob === null || blob.type !== mimeType)
+      throw new Error('The browser cannot encode this cropped image format.');
+    return blob;
+  } finally {
+    bitmap.close();
+  }
+}
+
+async function bytesToSave(sessionId: string, document: AuthorDocumentInput, signal?: AbortSignal): Promise<BodyInit> {
+  if (document.kind === 'text' || document.kind === 'markdown') return document.content ?? '';
+  if (document.kind === 'image' && document.crop !== undefined) return await croppedImageBytes(document, signal);
+  if (document.structuredFormat === undefined) throw new Error('This Author view cannot be saved.');
+  const operations = operationsFor(document);
+  const request = {
+    path: document.path,
+    format: document.structuredFormat,
+    operations,
+    ...(document.csvDialect === undefined ? {} : { csvDialect: document.csvDialect }),
+  };
+  const preflight = await jsonRequest<DocumentPreflightReport>(
+    authorDocumentApiUrl(sessionId, 'preflight'),
+    request,
+    signal,
+  );
+  if (preflight.sourceDigest !== undefined && preflight.sourceDigest !== document.sourceSha256) {
+    throw new Error('Document source changed before saving. Reopen the document.');
+  }
+  if (!preflight.accepted)
+    throw new Error(preflight.issues.map((issue) => issue.message).join('\n') || 'Author preflight rejected the edit.');
+  const serialized = await jsonRequest<{ bytes: string; encoding: string }>(
+    authorDocumentApiUrl(sessionId, 'serialize'),
+    { ...request, preflightDigest: preflight.digest },
+    signal,
+  );
+  if (serialized.encoding !== 'base64') throw new Error('Author serialize returned an unsupported encoding.');
+  const bytes = decodeBase64(serialized.bytes);
+  return bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength) as ArrayBuffer;
+}
+
+export async function saveAuthorDocument(
+  sessionId: string,
+  document: AuthorDocumentInput,
+  signal?: AbortSignal,
+): Promise<string> {
+  if (document.sourceSha256 === undefined) throw new Error('This Author view has no source digest.');
+  const response = await sealedTransport.fetch(authorSessionFileUrl(sessionId, document.path), {
+    method: 'PUT',
+    headers: { 'Content-Type': 'application/octet-stream', 'X-Expected-SHA256': document.sourceSha256 },
+    body: await bytesToSave(sessionId, document, signal),
+    signal,
+  });
+  if (!response.ok) throw new Error(`Author save failed (${response.status})`);
+  const sha256 = response.headers.get('X-File-SHA256');
+  if (sha256 === null || !/^[a-f0-9]{64}$/.test(sha256)) throw new Error('Author save returned an invalid digest.');
+  return sha256;
+}
+
+function csvDialectFromMetadata(
+  metadata: Record<string, string | number | boolean> | undefined,
+): CsvDialect | undefined {
+  if (metadata === undefined) return undefined;
+  const { delimiter, quote, recordDelimiter } = metadata;
+  if (
+    (delimiter !== ',' && delimiter !== ';' && delimiter !== '\t' && delimiter !== '|') ||
+    (quote !== '"' && quote !== "'") ||
+    (recordDelimiter !== '\n' && recordDelimiter !== '\r\n')
+  ) {
+    throw new Error('Author document API returned an invalid CSV dialect.');
+  }
+  return { delimiter, quote, recordDelimiter };
+}
+
+export function editableStructuredFragments(document: AuthorDocumentInput): readonly DocumentFragment[] {
+  return document.fragments ?? [];
+}

package/src/web/api/authorMedia.ts

@@ -0,0 +1,19 @@
+import { sealedTransport } from '@agimon-ai/doompi-web-security/browser';
+
+/** Native media elements cannot perform the remote session's encrypted HTTP exchange. */
+export async function loadAuthorMedia(source: string, signal: AbortSignal): Promise<{ url: string; dispose(): void }> {
+  const response = await sealedTransport.fetch(source, { signal, cache: 'no-store' });
+  if (!response.ok) throw new Error(`Author media could not be loaded (${response.status}).`);
+  const blob = await response.blob();
+  signal.throwIfAborted();
+  const url = URL.createObjectURL(blob);
+  let disposed = false;
+  return {
+    url,
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      URL.revokeObjectURL(url);
+    },
+  };
+}

package/src/web/api/authorRuntime.ts

@@ -0,0 +1,164 @@
+import type {
+  ModelContext,
+  ModelContextAbortSignal,
+  ModelContextToolDescriptor,
+  WebPluginRuntime,
+} from '@agimon-ai/doompi-web-contracts';
+import type { AuthorTrustedProfile, AuthorTrustedTool } from '../lib/authorViewportTypes.ts';
+
+export const AUTHOR_RUNTIME_BINDING_IDS = {
+  text: 'author.viewport.text',
+  media: 'author.viewport.media',
+} as const;
+
+interface ActiveCatalog {
+  generation: number;
+  controller: AbortController;
+  profiles: ReadonlyMap<string, AuthorTrustedProfile>;
+}
+
+function assertProfile(profile: AuthorTrustedProfile): void {
+  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 = new Set<string>();
+  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: ModelContextToolDescriptor, expected: AuthorTrustedTool): boolean {
+  return (
+    actual.name === expected.name &&
+    actual.description === expected.description &&
+    JSON.stringify(actual.inputSchema) === JSON.stringify(expected.inputSchema)
+  );
+}
+
+function staleError(): Error {
+  return new Error('Author viewport catalog is stale');
+}
+
+function invocationSignal(
+  catalogSignal: AbortSignal,
+  requestSignal: ModelContextAbortSignal,
+): { signal: AbortSignal; release: () => void } {
+  const controller = new AbortController();
+  const abortCatalog = (): void => controller.abort(catalogSignal.reason);
+  const abortRequest = (): void => 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. */
+export class AuthorRuntime {
+  readonly #runtime: WebPluginRuntime;
+  #context: ModelContext | undefined;
+  #active: ActiveCatalog | undefined;
+  #pending: ActiveCatalog | undefined;
+  #generation = 0;
+  #disposed = false;
+
+  constructor(runtime: WebPluginRuntime) {
+    this.#runtime = runtime;
+  }
+
+  async replaceProfiles(profiles: readonly AuthorTrustedProfile[]): Promise<() => void> {
+    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 === undefined) throw new Error('Model Context is unavailable');
+    this.#context = context;
+    const generation = ++this.#generation;
+    const controller = new AbortController();
+    const candidate: ActiveCatalog = { generation, controller, profiles: profileMap };
+    const inactive = staleError();
+    this.#pending?.controller.abort(inactive);
+    this.#active?.controller.abort(inactive);
+    this.#pending = candidate;
+    this.#active = undefined;
+    const assertCurrent = (): void => {
+      if (controller.signal.aborted || this.#disposed || this.#active?.generation !== generation) throw staleError();
+    };
+
+    try {
+      await Promise.all(
+        tools.map(async (tool) =>
+          context.registerTool(
+            {
+              name: tool.name,
+              description: tool.description,
+              inputSchema: tool.inputSchema,
+              execute: async (input, options) => {
+                assertCurrent();
+                const parsed: unknown = JSON.parse(input);
+                assertCurrent();
+                const invocation = invocationSignal(controller.signal, options.signal);
+                try {
+                  const result = await tool.execute(parsed, invocation.signal);
+                  assertCurrent();
+                  return result;
+                } finally {
+                  invocation.release();
+                }
+              },
+            },
+            { signal: controller.signal },
+          ),
+        ),
+      );
+      const registered = await context.getTools();
+      if (!tools.every((tool) => registered.some((descriptor) => descriptorMatches(descriptor, tool)))) {
+        throw new Error('Model Context did not confirm the Author catalog');
+      }
+      if (this.#disposed || generation !== this.#generation || this.#pending !== candidate) throw staleError();
+      this.#pending = undefined;
+      this.#active = candidate;
+    } catch (error) {
+      controller.abort(error);
+      if (this.#pending === candidate) this.#pending = undefined;
+      throw error;
+    }
+
+    return () => {
+      if (this.#active?.generation !== generation) return;
+      controller.abort(staleError());
+      this.#active = undefined;
+      this.#generation += 1;
+    };
+  }
+
+  async execute(name: string, input: unknown, signal: AbortSignal): Promise<unknown> {
+    const context = this.#context;
+    if (context === undefined || this.#active === undefined) throw new Error('Author catalog is not registered');
+    return context.executeTool(name, JSON.stringify(input), { signal });
+  }
+
+  dispose(): void {
+    if (this.#disposed) return;
+    this.#disposed = true;
+    this.#generation += 1;
+    this.#pending?.controller.abort(new Error('Author runtime disposed'));
+    this.#active?.controller.abort(new Error('Author runtime disposed'));
+    this.#pending = undefined;
+    this.#active = undefined;
+  }
+}

package/src/web/components/AuthorDocumentPanel.tsx

@@ -0,0 +1,232 @@
+import { Button } from '@agimon-ai/doompi-web-components';
+import { AuthorGridOverlay, autonomousVoiceGridVisible } from './AuthorGridOverlay.tsx';
+import { AuthorMediaView } from './AuthorMediaView.tsx';
+import { AuthorTextView } from './AuthorTextView.tsx';
+import type { FileLinkSource, TransientTab, WebPluginSlotProps } from '@agimon-ai/doompi-web-contracts';
+import { useStore } from '@tanstack/react-store';
+import { useEffect, useRef, useState } from 'react';
+import { focusAuthorViewport } from '../api/authorBrowserBridge.ts';
+import { loadAuthorDocument, saveAuthorDocument } from '../api/authorFiles.ts';
+import { authorProfilesForDocument } from '../stores/authorProfiles.ts';
+import type { AuthorDisplayedRegion } from '../lib/authorViewportTypes.ts';
+import {
+  authorDocumentKey,
+  authorWorkspace,
+  completeAuthorSave,
+  failAuthorSave,
+  focusAuthorDocument,
+  normalizeAuthorPath,
+  putAuthorDocument,
+  releaseAuthorDocumentFocus,
+  requestAuthorSave,
+  syncAuthorDocumentFocus,
+  type AuthorSessionWorkspace,
+} from '../stores/authorWorkspaceStore.ts';
+import { AuthorStructuredView } from './AuthorStructuredView.tsx';
+interface AuthorDocumentPanelProps extends WebPluginSlotProps {
+  path: string;
+}
+
+function tabId(path: string): string {
+  let hash = 2166136261;
+  for (const char of normalizeAuthorPath(path)) hash = Math.imul(hash ^ char.charCodeAt(0), 16777619);
+  return `author-file-${(hash >>> 0).toString(36)}`;
+}
+
+export function displayedAuthorRegions(
+  workspace: AuthorSessionWorkspace | undefined,
+): readonly AuthorDisplayedRegion[] {
+  const draftRegions = workspace?.regions ?? [];
+  if (draftRegions.length > 0) return draftRegions.map((region, index) => ({ ordinal: index + 1, region }));
+  const activeRequest = workspace?.requests.findLast(
+    (request) => request.status === 'REQUESTED' || request.status === 'CHANGING',
+  );
+  return (activeRequest?.pendingRegions ?? []).map((region) => ({
+    ordinal: Math.max(1, (activeRequest?.regions.findIndex((original) => original.id === region.id) ?? 0) + 1),
+    region,
+  }));
+}
+export function AuthorDocumentPanel(props: AuthorDocumentPanelProps) {
+  if (!props.activeMinorModes?.includes('author')) {
+    const fallback = props.fileTabFor(props.path);
+    if (fallback !== undefined && fallback.id !== tabId(props.path)) {
+      return <fallback.panel {...props} />;
+    }
+    return (
+      <p data-testid="author-mode-inactive" className="p-3 text-xs text-doom-dim">
+        No file viewer is available for this path.
+      </p>
+    );
+  }
+  return <ActiveAuthorDocumentPanel {...props} />;
+}
+
+function ActiveAuthorDocumentPanel({ path, sessionId, statuses }: AuthorDocumentPanelProps) {
+  const document = useStore(authorWorkspace.store, (state) =>
+    sessionId === null ? undefined : state.documents[authorDocumentKey(sessionId, path)],
+  );
+  const focusGeneration = useRef<number | undefined>(undefined);
+  const workspace = useStore(authorWorkspace.store, (state) =>
+    sessionId === null ? undefined : state.sessions[sessionId],
+  );
+  const activeTool = workspace?.activeTool ?? 'select';
+  const [markdownPreview, setMarkdownPreview] = useState(true);
+  const [status, setStatus] = useState<string | undefined>();
+  const kind = document?.kind;
+  useEffect(() => {
+    if (document !== undefined || sessionId === null) return;
+    const controller = new AbortController();
+    setStatus('loading');
+    void loadAuthorDocument(sessionId, path, controller.signal)
+      .then((loaded) => {
+        if (controller.signal.aborted) return;
+        putAuthorDocument(sessionId, loaded);
+        setStatus(undefined);
+      })
+      .catch((error: unknown) => {
+        if (!controller.signal.aborted) setStatus(error instanceof Error ? error.message : String(error));
+      });
+    return () => controller.abort();
+  }, [document, path, sessionId]);
+  useEffect(() => {
+    if (document === undefined || sessionId === null) return;
+    const generation = focusAuthorDocument(sessionId, path, document.version, document.sourceSha256);
+    focusGeneration.current = generation;
+    return () => releaseAuthorDocumentFocus(sessionId, generation);
+  }, [kind, document?.sourceSha256, path, sessionId]);
+  useEffect(() => {
+    const generation = focusGeneration.current;
+    if (document === undefined || sessionId === null || generation === undefined) return;
+    syncAuthorDocumentFocus(sessionId, generation, document.version, document.sourceSha256);
+  }, [document?.sourceSha256, document?.version, sessionId]);
+  useEffect(() => {
+    if (kind === undefined || sessionId === null) return;
+    const profiles = authorProfilesForDocument(sessionId, path, kind);
+    let release: (() => void) | undefined;
+    let cancelled = false;
+    void focusAuthorViewport(sessionId, profiles).then((nextRelease) => {
+      if (cancelled) nextRelease();
+      else release = nextRelease;
+    });
+    return () => {
+      cancelled = true;
+      release?.();
+    };
+  }, [kind, path, sessionId]);
+  if (document === undefined || sessionId === null) {
+    return <p className="p-4 text-[11px] text-doom-faint">{status ?? 'Loading document...'}</p>;
+  }
+
+  const save = async (): Promise<void> => {
+    const savedVersion = document.version;
+    const savedFragments = document.fragments;
+    requestAuthorSave(sessionId, path);
+    setStatus('saving');
+    try {
+      const sha256 = await saveAuthorDocument(sessionId, document);
+      completeAuthorSave(sessionId, path, sha256, savedVersion, savedFragments);
+      setStatus('saved');
+    } catch (error) {
+      failAuthorSave(sessionId, path, savedVersion);
+      setStatus(error instanceof Error ? error.message : String(error));
+    }
+  };
+  const gridVisible = autonomousVoiceGridVisible(statuses);
+  const displayedRegions = displayedAuthorRegions(workspace);
+  const textPanel = (
+    <AuthorTextView
+      sessionId={sessionId}
+      document={document}
+      preview={document.kind === 'markdown' && markdownPreview && activeTool === 'select' && !gridVisible}
+      displayedRegions={displayedRegions}
+    />
+  );
+
+  return (
+    <section data-testid="author-document" className="flex min-h-0 flex-1 flex-col">
+      <header className="flex items-center gap-2 border-b border-doom-border px-4 py-2">
+        <strong className="min-w-0 flex-1 truncate text-sm text-doom-hi">{document.title ?? document.path}</strong>
+        {document.kind === 'markdown' ? (
+          <Button
+            size="xs"
+            variant="ghost"
+            data-testid="author-markdown-toggle"
+            onClick={() => setMarkdownPreview(!markdownPreview)}
+          >
+            {markdownPreview ? 'edit' : 'preview'}
+          </Button>
+        ) : null}
+        {document.kind === 'video' ? (
+          <span className="text-sm text-doom-dim">Video feedback</span>
+        ) : (
+          <Button
+            className="min-h-11 px-4 text-sm"
+            variant="outline"
+            data-testid="author-save"
+            disabled={document.revisions.length === 0 || document.savingVersion !== undefined}
+            onClick={() => void save()}
+          >
+            Save
+          </Button>
+        )}
+      </header>
+      {status === undefined ? null : <output className="px-4 py-1 text-[10px] text-doom-faint">{status}</output>}
+      <div className="relative flex min-h-0 flex-1 overflow-hidden">
+        {document.kind === 'text' || document.kind === 'markdown' ? (
+          textPanel
+        ) : document.structuredFormat !== undefined ? (
+          <AuthorStructuredView sessionId={sessionId} document={document} displayedRegions={displayedRegions} />
+        ) : (
+          <AuthorMediaView
+            key={document.path}
+            sessionId={sessionId}
+            document={document}
+            activeTool={activeTool}
+            displayedRegions={displayedRegions}
+            pendingCandidate={workspace?.candidate !== undefined}
+            seekRequest={workspace?.videoSeekRequest}
+          />
+        )}
+        <AuthorGridOverlay sessionId={sessionId} document={document} visible={gridVisible} />
+      </div>
+    </section>
+  );
+}
+
+export function authorFileTab(path: string): TransientTab {
+  const normalized = normalizeAuthorPath(path);
+  return {
+    id: tabId(normalized),
+    label: normalized.split('/').at(-1) ?? normalized,
+    retainComposer: true,
+    panel: (props) => <AuthorDocumentPanel {...props} path={normalized} />,
+  };
+}
+
+export const authorFileLinks: FileLinkSource = {
+  requiredMinorMode: 'author',
+  subscribe(listener) {
+    const subscription = authorWorkspace.store.subscribe(listener);
+    return () => subscription.unsubscribe();
+  },
+  fingerprint(sessionId) {
+    if (sessionId === null) return '';
+    const prefix = `${sessionId}\n`;
+    return Object.keys(authorWorkspace.store.state.documents)
+      .filter((key) => key.startsWith(prefix))
+      .sort()
+      .join('\n');
+  },
+  resolve(sessionId, path) {
+    if (sessionId === null) return undefined;
+    const normalized = normalizeAuthorPath(path.replace(/:\d+(?::\d+)?$/, ''));
+    return authorWorkspace.store.state.documents[authorDocumentKey(sessionId, normalized)] === undefined
+      ? undefined
+      : authorFileTab(normalized);
+  },
+  openPath(sessionId, path) {
+    if (sessionId === null) return undefined;
+    const normalized = normalizeAuthorPath(path);
+    return normalized === '' ? undefined : authorFileTab(normalized);
+  },
+};