@arbidocs/blocks 0.4.147 → 0.4.151

package/dist/connect/viewer.js

@@ -0,0 +1,2350 @@
+"use client";
+import { HtmlPassage, ViewerTitle, ViewerTabBar, ViewerImageActions, ViewerFrame, ViewerMessage, DocumentLabelBar, ViewerControlBar, ViewerZoomControl, PdfPageNav, ViewerPageCounter, summariseDocTags, isDocumentLabel, ViewerPreviewUnavailable, ViewerLoadError, HtmlViewerRoot, CitedRunNav, HtmlViewerSurface, HtmlPage, HtmlViewerEmpty, TagPassagePanel } from '../chunk-HUJF2XM2.js';
+import { useDocumentViewerSupport } from '../chunk-EYJMMGXF.js';
+import '../chunk-JGOST4IL.js';
+import '../chunk-RC6VTY2H.js';
+import { useConnectedConversations, useConnectedDocuments, useConnectedTags } from '../chunk-DN2KI4BU.js';
+import { useConnectedWorkspace } from '../chunk-US3S4DCB.js';
+import { MarkupViewNote, SignatureStatus, AnnotateButton, ShowOriginalButton, DownloadMarkupButton, SignButton, RequestSignaturesButton, MarkupNotices, SignedEditNote, VersionSnapshotBar, SignatureRequestBanner } from '../chunk-KQYPP72K.js';
+import '../chunk-EQB3WELX.js';
+import { ViewerStatusNote, ViewerHeaderStart, ViewerHeaderEnd, ViewerPane } from '../chunk-6HKLTYNN.js';
+import { SignDocumentDialog } from '../chunk-2YOVK524.js';
+import '../chunk-JJA6GQKH.js';
+import '../chunk-H4D7WKDY.js';
+import { ShareControl } from '../chunk-K4BGOPGG.js';
+import '../chunk-SDOEHEJP.js';
+import '../chunk-A3XPS2EU.js';
+import { buildDeepLinkUrl } from '../chunk-SV65E4QW.js';
+import '../chunk-M4S75AEJ.js';
+import '../chunk-5LXQPP2K.js';
+import '../chunk-RLWIUUQ5.js';
+import '../chunk-YKQ2DPIP.js';
+import '../chunk-NUNKSZKU.js';
+import '../chunk-YU2KUMGE.js';
+import '../chunk-N5YEF3LC.js';
+import { ArtifactCompareBar, ArtifactPreview, ArtifactCodeView, VersionTimeline } from '../chunk-65S53MZK.js';
+import '../chunk-NS4JD2VR.js';
+import '../chunk-LOJVUGBJ.js';
+import { TabHeader } from '../chunk-4WWM3GQ5.js';
+import '../chunk-OKERRHLH.js';
+import '../chunk-7XF5SFJ2.js';
+import { useRegisterOpenDocument, savedDocumentIdFor } from '../chunk-YBLIKTJK.js';
+import '../chunk-AUS3KBHJ.js';
+import { useIsPhone } from '../chunk-SLSBJRWW.js';
+import '../chunk-NPLYHR2E.js';
+import '../chunk-7F6CBP3Z.js';
+import { PassageMark, NoteMark, LabelMark, PassagePill } from '../chunk-JAANWQGB.js';
+import { useBlocksEnvironment } from '../chunk-TBEVGWY3.js';
+import '../chunk-TX2ZICS7.js';
+import { fmtDate } from '../chunk-OXF2IFXG.js';
+import '../chunk-VUNV25KB.js';
+import React, { memo, lazy, useMemo, useCallback, useState, useRef, useEffect, Suspense } from 'react';
+import { MessageSquare, Mail, Languages, FileCheck2, MonitorPlay, Code, FileText, History } from 'lucide-react';
+import { useArbi, refreshDocuments, arbiQueryKeys, useArbiSessionState, useArbiSessionStore, ImageCropModal, DEFAULT_ASPECT_OPTIONS, useDocumentVersionList, useDocument, useParsedDocument, hasVideoTrack, useFinaliseTranslation, DocIcon, XlsIcon, HtmlIcon, VidIcon, AudIcon, ImgIcon, EmlIcon, PdfIcon, useAssignDocTags, useUpdateDocTag, useRemoveDocTags } from '@arbidocs/react';
+import { parseVersionRef, versionLabel, findVersion, documentVersions, toArtifactVersions, artifactKindFromMode, artifactKindFromFileName, useArtifactSource } from '@arbidocs/react/artifacts';
+import { useOptionalDocumentTools, documentBytesKey, clientUpload, DocumentToolsProvider, useDocumentTools, useDocumentSignatures, useDocumentMarkup, canAnnotate, SIGNED_LOCKED_REASON, useDocumentBytes, fetchDocumentFile } from '@arbidocs/react/document-tools';
+import { XlsxViewer, cycleZoom, VideoViewer, AudioViewer, ImageViewer, useProcessedChunks, useScrollAnchor, usePinchZoom, PdfViewer, computeSelectionRuns, usePageIntersectionObserver } from '@arbidocs/react/viewers';
+import { MarkdownRenderer, Button, getEntityLabel, isImageFile, isVideoFile, isAudioFile, isDownloadOnlyFile, friendlyFileType, getEntityColor, TagEntity } from '@arbidocs/react/ui';
+import { useQueryClient } from '@tanstack/react-query';
+import { jsx, Fragment, jsxs } from 'react/jsx-runtime';
+
+function ConnectedDocumentToolsProvider({ children }) {
+  const enclosing = useOptionalDocumentTools();
+  return enclosing ? /* @__PURE__ */ jsx(Fragment, { children }) : /* @__PURE__ */ jsx(OwnDocumentTools, { children });
+}
+function OwnDocumentTools({ children }) {
+  const arbi = useArbi();
+  const queryClient = useQueryClient();
+  const { user, ensureWorkspaceOpen } = useConnectedWorkspace();
+  const { notify: environmentNotify, openDocument: openInHost } = useBlocksEnvironment();
+  const client = arbi.isLoggedIn ? arbi.getClient().fetch : null;
+  const signer = useMemo(
+    () => user ? { name: user.name, email: user.email, externalId: user.externalId } : null,
+    [user]
+  );
+  const notify = useCallback(
+    (message, kind, options) => environmentNotify(message, kind, {
+      description: options?.description,
+      action: options?.action
+    }),
+    [environmentNotify]
+  );
+  const onDocumentsChanged = useCallback(
+    async (ids, change) => {
+      const refresh = [refreshDocuments(queryClient, arbi, ids)];
+      if (change === "signed" || change === "version")
+        for (const id of ids)
+          refresh.push(
+            queryClient.invalidateQueries({ queryKey: arbiQueryKeys.documentVersions(id) }),
+            queryClient.invalidateQueries({ queryKey: documentBytesKey(id) })
+          );
+      await Promise.all(refresh);
+    },
+    [queryClient, arbi]
+  );
+  const uploadDocument = useCallback(
+    async (request) => {
+      if (!client) throw new Error("Sign in to save a copy.");
+      await ensureWorkspaceOpen();
+      return clientUpload(client)(request);
+    },
+    [client, ensureWorkspaceOpen]
+  );
+  const openDocument = useCallback((ref) => openInHost(ref), [openInHost]);
+  if (!client) return /* @__PURE__ */ jsx(Fragment, { children });
+  return /* @__PURE__ */ jsx(
+    DocumentToolsProvider,
+    {
+      client,
+      user: signer,
+      notify,
+      openDocument,
+      onDocumentsChanged,
+      uploadDocument,
+      children
+    }
+  );
+}
+var isTranslationDraft = (doc) => !!doc?.derived_from?.some((d) => d.role === "translation") && !doc.derived_from.some((d) => d.role === "final");
+function FinaliseTranslationButton({
+  document: document2,
+  isCompact
+}) {
+  const finalise = useFinaliseTranslation();
+  const { openDocument } = useDocumentTools();
+  const { notify } = useBlocksEnvironment();
+  if (!document2 || !isTranslationDraft(document2)) return null;
+  const pending = finalise.isPending;
+  const onClick = async () => {
+    try {
+      const { document_ext_id: finalId } = await finalise.mutateAsync(document2.external_id);
+      notify("Saved the final PDF of this translation", "success");
+      openDocument?.(finalId);
+    } catch (error) {
+      const detail = error?.detail;
+      notify(
+        typeof detail === "string" ? detail : "The final PDF could not be saved. Try again.",
+        "error"
+      );
+    }
+  };
+  return /* @__PURE__ */ jsxs(
+    Button,
+    {
+      type: "button",
+      variant: "outline",
+      size: isCompact ? "icon" : "sm",
+      title: "Finalise: save this translation as a new PDF, labelled Translation and linked to the original",
+      "aria-label": "Finalise",
+      "data-testid": "finalise-translation-button",
+      className: "pointer-coarse:min-h-11",
+      disabled: pending,
+      onClick: () => void onClick(),
+      children: [
+        /* @__PURE__ */ jsx(FileCheck2, { className: "size-4" }),
+        !isCompact && /* @__PURE__ */ jsx("span", { className: "ml-1", children: pending ? "Finalising\u2026" : "Finalise" })
+      ]
+    }
+  );
+}
+function useImageCrop(documentId, fileName, imageBlob) {
+  const { uploadDocument, onDocumentsChanged, openDocument } = useDocumentTools();
+  const { notify } = useBlocksEnvironment();
+  const [cropImageUrl, setCropImageUrl] = useState(null);
+  const handleOpenCrop = useCallback(() => {
+    if (!imageBlob) return;
+    setCropImageUrl(URL.createObjectURL(imageBlob));
+  }, [imageBlob]);
+  const closeCrop = useCallback(() => {
+    setCropImageUrl((url) => {
+      if (url) URL.revokeObjectURL(url);
+      return null;
+    });
+  }, []);
+  const handleCropComplete = useCallback(
+    async (result) => {
+      const baseName = (fileName || "image").replace(/\.[^.]+$/, "");
+      const file = new File([result.blob], `${baseName} (cropped).png`, { type: "image/png" });
+      try {
+        const response = await uploadDocument({
+          file,
+          query: { derived_from: [documentId], derived_role: "crop" }
+        });
+        const newDocId = response?.doc_ext_ids?.[0];
+        if (newDocId) {
+          await onDocumentsChanged?.([newDocId], "copy");
+          openDocument?.(newDocId);
+        }
+        notify("Cropped image saved", "success");
+      } catch {
+        notify("Failed to save the cropped image", "error");
+      } finally {
+        closeCrop();
+      }
+    },
+    [fileName, documentId, uploadDocument, onDocumentsChanged, openDocument, notify, closeCrop]
+  );
+  return { cropImageUrl, handleOpenCrop, closeCrop, handleCropComplete };
+}
+var DOCX_EXTENSIONS = /* @__PURE__ */ new Set([".docx", ".doc"]);
+var XLSX_EXTENSIONS = /* @__PURE__ */ new Set([".xlsx", ".xls"]);
+var EMAIL_EXTENSIONS = /* @__PURE__ */ new Set([".eml", ".msg"]);
+function fileExtension(fileName) {
+  if (!fileName) return "";
+  return fileName.substring(fileName.lastIndexOf(".")).toLowerCase();
+}
+function useViewedDocument(documentId) {
+  const support = useDocumentViewerSupport();
+  const [webmHasVideoTrack, setWebmHasVideoTrack] = useState(null);
+  useEffect(() => setWebmHasVideoTrack(null), [documentId]);
+  const streamingDoc = support.streamingDocuments?.[documentId];
+  const isStreaming = !!streamingDoc && !streamingDoc.isComplete;
+  const draftDoc = support.draftDocuments?.[documentId];
+  const isDraft = !!draftDoc;
+  const isCaptureDraft = draftDoc?.kind === "audio" || draftDoc?.kind === "photo" || draftDoc?.kind === "video";
+  const isTextDraft = draftDoc?.kind === "text";
+  const { workspaceId, live } = useConnectedWorkspace();
+  const { data: record } = useDocument(documentId, {
+    enabled: live && !!workspaceId && !isStreaming && !isDraft,
+    // A new version (Save version, a signed copy) is processed before its PDF exists: keep
+    // re-reading until it is done, so the PDF tab and the signing tools come back on their own.
+    pollWhileProcessing: true
+  });
+  const documentData = record?.external_id === documentId ? record : void 0;
+  const { data: tags } = useConnectedTags();
+  const labelSummaries = useMemo(
+    () => summariseDocTags(documentData?.doctags ?? [], tags.filter(isDocumentLabel)),
+    [documentData, tags]
+  );
+  const fileName = documentData?.file_name;
+  const isMarkdown = fileExtension(fileName) === ".md";
+  const isImage = isImageFile(fileName);
+  const isWebmFile = fileExtension(fileName) === ".webm";
+  const isVideo = isWebmFile && webmHasVideoTrack === false ? false : isVideoFile(fileName);
+  const isAudio = isWebmFile && webmHasVideoTrack === false ? true : isAudioFile(fileName);
+  const isBlobArtifact = streamingDoc?.mode === "image" || documentData?.wp_type === "artifact" && (isImage || isVideo || isAudio);
+  const isArtifact = (!!streamingDoc || isTextDraft || documentData?.wp_type === "artifact" || isMarkdown) && !isBlobArtifact;
+  const liveKind = isArtifact ? artifactKindFromMode(streamingDoc?.mode ?? void 0) ?? artifactKindFromFileName(fileName) : null;
+  const savedDocumentId = savedDocumentIdFor({
+    documentId,
+    isDraft,
+    isStreaming,
+    isBlobArtifact,
+    documentData
+  });
+  const { data: liveSourceFetched } = useArtifactSource(
+    documentId,
+    !!liveKind && !streamingDoc && !!documentData && !isDraft
+  );
+  const liveSource = streamingDoc ? streamingDoc.content : liveSourceFetched ?? "";
+  const hasParsedDocStatus = documentData?.status === "completed" || documentData?.status === "low-content";
+  const { data: parsedDoc, isLoading: isParsedDocLoading } = useParsedDocument(
+    documentId,
+    "final",
+    {
+      enabled: !!documentId && live && !isStreaming && !isDraft && !isBlobArtifact && hasParsedDocStatus
+    }
+  );
+  const hasParsedContent = (parsedDoc?.chunks?.length ?? 0) > 0;
+  return {
+    workspaceId,
+    documentData,
+    streamingDoc,
+    isStreaming,
+    draftDoc,
+    isDraft,
+    isCaptureDraft,
+    isTextDraft,
+    labelSummaries,
+    isImage,
+    isWebmFile,
+    setWebmHasVideoTrack,
+    isVideo,
+    isAudio,
+    isMedia: isVideo || isAudio,
+    isBlobArtifact,
+    savedDocumentId,
+    isArtifact,
+    liveKind,
+    liveSource,
+    isDocx: DOCX_EXTENSIONS.has(fileExtension(fileName)),
+    isXlsx: XLSX_EXTENSIONS.has(fileExtension(fileName)),
+    isEmail: EMAIL_EXTENSIONS.has(fileExtension(fileName)),
+    isDownloadOnly: isDownloadOnlyFile(fileName),
+    isParsedDocLoading,
+    hasParsedContent
+  };
+}
+function useViewerBlobs(documentId, doc) {
+  const { documentData, isArtifact, isDocx, isXlsx, isDownloadOnly, isWebmFile } = doc;
+  const { setWebmHasVideoTrack } = doc;
+  const { client, saveFile } = useDocumentTools();
+  const { notify } = useBlocksEnvironment();
+  const { loadOfflineCopy } = useDocumentViewerSupport();
+  const currentVersion = documentData?.current_version ?? 1;
+  const name = documentData?.file_name;
+  const original = isImageFile(name) || isVideoFile(name) || isAudioFile(name);
+  const fallback = loadOfflineCopy && documentData && !parseVersionRef(documentId).version ? () => loadOfflineCopy(documentData) : void 0;
+  const pdf = useDocumentBytes(documentId, {
+    version: currentVersion,
+    kind: original ? "original" : "pdf",
+    enabled: !isArtifact && !!documentData && !isDownloadOnly && (!isDocx || documentData.status === "completed" || documentData.status === "low-content"),
+    fallback
+  });
+  const [pdfBlob, setPdfBlob] = useState(null);
+  useEffect(() => setPdfBlob(null), [documentId]);
+  useEffect(() => {
+    if (pdf.data) setPdfBlob(pdf.data);
+  }, [pdf.data]);
+  useEffect(() => {
+    if (!isWebmFile || !pdfBlob) return;
+    let cancelled = false;
+    void hasVideoTrack(pdfBlob).then((result) => {
+      if (!cancelled) setWebmHasVideoTrack(result);
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [isWebmFile, pdfBlob, setWebmHasVideoTrack]);
+  const xlsx = useDocumentBytes(documentId, {
+    version: currentVersion,
+    kind: "original",
+    enabled: !isArtifact && !!documentData && isXlsx
+  });
+  const handleDirectDownload = useCallback(async () => {
+    try {
+      saveFile(await fetchDocumentFile(client, documentId), documentData?.file_name || "download");
+    } catch {
+      notify("Failed to download file", "error");
+    }
+  }, [client, saveFile, notify, documentId, documentData?.file_name]);
+  return {
+    pdfBlob,
+    isPdfLoading: pdf.isLoading,
+    pdfError: pdf.error,
+    xlsxBlob: xlsx.data ?? null,
+    xlsxError: xlsx.error,
+    handleDirectDownload
+  };
+}
+function useViewerTabs(doc, isCompact, hasHistory = false) {
+  const {
+    documentData,
+    isArtifact,
+    isDocx,
+    isXlsx,
+    isEmail,
+    isVideo,
+    isAudio,
+    isImage,
+    liveKind,
+    hasParsedContent,
+    isParsedDocLoading
+  } = doc;
+  const session = useArbiSessionStore();
+  const {
+    tab: activeTab,
+    compareId,
+    tabRequest,
+    phonePdfChosen
+  } = useArbiSessionState((s) => s.documentViewer);
+  const setActiveTab = (tab) => session.setDocumentViewer({ tab });
+  const isTextFile = friendlyFileType(documentData?.file_type, documentData?.file_name) === "Text";
+  const isPhone = useIsPhone();
+  const phoneDefaultDecidedFor = useRef(null);
+  const hasDocumentData = !!documentData;
+  const documentKey = documentData?.external_id;
+  useEffect(() => {
+    if (isArtifact && (activeTab === "pdf" || !liveKind && activeTab === "docx")) {
+      setActiveTab(liveKind ? "preview" : "edit");
+    } else if (isDocx && activeTab === "pdf") {
+      setActiveTab("docx");
+    } else if (!liveKind && activeTab === "preview") {
+      setActiveTab(isArtifact ? "edit" : "pdf");
+    } else if (!isArtifact && documentData && activeTab === "edit") {
+      setActiveTab(isDocx ? "docx" : isXlsx ? "xlsx" : "pdf");
+    } else if (!isArtifact && !isDocx && !isXlsx && documentData && (activeTab === "docx" || activeTab === "xlsx")) {
+      setActiveTab("pdf");
+    }
+  }, [hasDocumentData, documentKey, isArtifact, isDocx, isXlsx, liveKind]);
+  useEffect(() => {
+    if (!tabRequest || !documentKey || tabRequest.documentId !== documentKey) return;
+    phoneDefaultDecidedFor.current = documentKey;
+    session.setDocumentViewer({ tabRequest: null, tab: tabRequest.tab });
+  }, [documentKey, tabRequest]);
+  const hasVersionsTab = isArtifact || isDocx || hasHistory;
+  useEffect(() => {
+    if (activeTab === "versions" && documentData && !hasVersionsTab) {
+      setActiveTab(isXlsx ? "xlsx" : "pdf");
+    }
+  }, [activeTab, documentData, hasVersionsTab]);
+  useEffect(() => {
+    if (activeTab === "html" && documentData !== void 0 && !isParsedDocLoading && !hasParsedContent && !compareId) {
+      setActiveTab(isArtifact ? "edit" : isDocx ? "docx" : isXlsx ? "xlsx" : "pdf");
+    }
+  }, [
+    activeTab,
+    documentData,
+    isParsedDocLoading,
+    hasParsedContent,
+    compareId,
+    isArtifact,
+    isDocx,
+    isXlsx
+  ]);
+  useEffect(() => {
+    if (!isPhone || !documentKey || isParsedDocLoading) return;
+    if (phoneDefaultDecidedFor.current === documentKey) return;
+    phoneDefaultDecidedFor.current = documentKey;
+    const opensOnPdf = !isArtifact && !isDocx && !isXlsx && !isVideo && !isAudio && !isImage && !isEmail;
+    if (opensOnPdf && hasParsedContent && !compareId && !phonePdfChosen && activeTab === "pdf") {
+      setActiveTab("html");
+    }
+  }, [isPhone, documentKey, isParsedDocLoading, hasParsedContent]);
+  const handleTabChange = (tabId) => {
+    const change = { tab: tabId };
+    if (tabId !== "html" && compareId) change.compareId = null;
+    if (isPhone && (tabId === "pdf" || tabId === "html")) change.phonePdfChosen = tabId === "pdf";
+    session.setDocumentViewer(change);
+  };
+  const mediaTab = isVideo ? { icon: /* @__PURE__ */ jsx(VidIcon, { size: 20 }), tooltip: "Video" } : isAudio ? { icon: /* @__PURE__ */ jsx(AudIcon, { size: 20 }), tooltip: "Audio" } : isImage ? { icon: /* @__PURE__ */ jsx(ImgIcon, { size: 20 }), tooltip: "Image" } : isEmail ? { icon: /* @__PURE__ */ jsx(EmlIcon, { size: 20 }), tooltip: "Email" } : isTextFile ? { icon: /* @__PURE__ */ jsx(FileText, { className: "size-5" }), tooltip: "Text" } : documentData ? { icon: /* @__PURE__ */ jsx(PdfIcon, { size: 20 }), tooltip: "PDF" } : (
+    // The file type is unknown until the record loads: name no guess (a text file
+    // would flip from PDF to Text once it arrives).
+    { icon: /* @__PURE__ */ jsx(FileText, { className: "size-5" }), tooltip: "Document" }
+  );
+  const tabLabel = (id, label) => !isCompact || activeTab === id || id === "html" ? label : void 0;
+  const versionsTab = {
+    id: "versions",
+    icon: /* @__PURE__ */ jsx(History, { className: "size-5" }),
+    tooltip: "Versions",
+    label: tabLabel("versions", "Versions")
+  };
+  const viewerTabs = [
+    ...isArtifact ? [
+      ...liveKind ? [
+        {
+          id: "preview",
+          icon: /* @__PURE__ */ jsx(MonitorPlay, { className: "size-5" }),
+          tooltip: "Preview",
+          label: tabLabel("preview", "Preview")
+        }
+      ] : [],
+      {
+        id: "edit",
+        icon: liveKind ? /* @__PURE__ */ jsx(Code, { className: "size-5" }) : /* @__PURE__ */ jsx(FileText, { className: "size-5" }),
+        tooltip: liveKind ? "Code" : "Editor",
+        label: tabLabel("edit", liveKind ? "Code" : "Document")
+      },
+      versionsTab
+    ] : [
+      ...isDocx ? [
+        {
+          id: "docx",
+          icon: /* @__PURE__ */ jsx(DocIcon, { size: 20 }),
+          tooltip: "DOCX (with track changes & comments)",
+          label: tabLabel("docx", "DOCX")
+        }
+      ] : [],
+      ...isXlsx ? [
+        {
+          id: "xlsx",
+          icon: /* @__PURE__ */ jsx(XlsIcon, { size: 20 }),
+          tooltip: "Spreadsheet",
+          label: tabLabel("xlsx", "Sheet")
+        }
+      ] : [],
+      { id: "pdf", ...mediaTab, label: tabLabel("pdf", mediaTab.tooltip) },
+      ...hasVersionsTab ? [versionsTab] : []
+    ],
+    ...(hasParsedContent || compareId) && !liveKind ? [
+      {
+        id: "html",
+        icon: compareId ? /* @__PURE__ */ jsx(FileText, { className: "size-5" }) : /* @__PURE__ */ jsx(HtmlIcon, { size: 20 }),
+        tooltip: compareId ? "Word redline" : "HTML",
+        label: tabLabel("html", compareId ? "Compare" : "HTML")
+      }
+    ] : []
+  ];
+  return { activeTab, handleTabChange, viewerTabs };
+}
+function useViewerVersions(docId) {
+  const plainId = docId ? parseVersionRef(docId).docId : "";
+  const { data: documents } = useConnectedDocuments();
+  const listed = useMemo(
+    () => plainId ? documents.find((d) => d.external_id === plainId) : void 0,
+    [documents, plainId]
+  );
+  const { data: history } = useDocumentVersionList(plainId, { enabled: !!plainId && !listed });
+  const versions = useMemo(
+    () => listed ? documentVersions(listed) : toArtifactVersions(plainId || null, history),
+    [listed, history, plainId]
+  );
+  const translations = useMemo(() => {
+    if (!plainId) return [];
+    return documents.flatMap((doc) => {
+      const link = doc.derived_from?.find(
+        (d) => d.role === "translation" && d.doc_ext_id === plainId
+      );
+      return link ? [
+        {
+          id: doc.external_id,
+          name: doc.doc_metadata?.title || doc.file_name || doc.external_id,
+          createdAt: doc.created_at,
+          sourceVersion: link.version ?? null,
+          final: !!doc.derived_from?.some((d) => d.role === "final")
+        }
+      ] : [];
+    }).sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+  }, [documents, plainId]);
+  return { versions, translations };
+}
+
+// src/connection/viewer/parsed/document-tags.ts
+function isDocumentTag(tag) {
+  if (tag.kind === "search") return false;
+  const onDocs = (tag.doctag_count ?? 0) > 0;
+  const onFacts = (tag.facttag_count ?? 0) > 0;
+  return onDocs || !onFacts;
+}
+function hasChunkInCitations(citations, chunkExtId) {
+  return (citations ?? []).some((d) => d.chunks?.some((c) => c.chunk_id === chunkExtId));
+}
+function removeChunkFromCitations(citations, chunkExtId) {
+  if (!citations) return null;
+  const next = citations.map((d) => ({ ...d, chunks: (d.chunks ?? []).filter((c) => c.chunk_id !== chunkExtId) })).filter((d) => d.chunks.length > 0);
+  return next.length ? next : null;
+}
+function addChunkToCitations(citations, documentId, chunkExtId) {
+  const chunk = { chunk_id: chunkExtId, page: null };
+  const list = citations ?? [];
+  const idx = list.findIndex((d) => d.doc_ext_id === documentId);
+  if (idx === -1) return [...list, { doc_ext_id: documentId, chunks: [chunk] }];
+  const doc = list[idx];
+  if ((doc.chunks ?? []).some((c) => c.chunk_id === chunkExtId)) return list;
+  const next = [...list];
+  next[idx] = { ...doc, chunks: [...doc.chunks ?? [], chunk] };
+  return next;
+}
+function useChunkTagging({ documentId, documentDoctags }) {
+  const createDocTag = useAssignDocTags();
+  const updateDocTag = useUpdateDocTag();
+  const deleteDocTag = useRemoveDocTags();
+  const getChunkTagState = useCallback(
+    (chunkExtId) => {
+      const appliedTags = documentDoctags.filter(
+        (dt) => hasChunkInCitations(dt.citations, chunkExtId)
+      );
+      const isTagApplied = (tagExtId) => {
+        return appliedTags.some((dt) => dt.tag_ext_id === tagExtId);
+      };
+      const getDoctagForChunk = (tagExtId) => {
+        return appliedTags.find((dt) => dt.tag_ext_id === tagExtId);
+      };
+      return {
+        appliedTags,
+        isTagApplied,
+        getDoctagForChunk
+      };
+    },
+    [documentDoctags]
+  );
+  const toggleChunkTag = useCallback(
+    async (chunkExtId, tag, note) => {
+      const existingDoctag = documentDoctags.find((dt) => dt.tag_ext_id === tag.external_id);
+      const isChunkTagged = hasChunkInCitations(existingDoctag?.citations, chunkExtId);
+      if (isChunkTagged) {
+        const updatedCitations = removeChunkFromCitations(existingDoctag.citations, chunkExtId);
+        if (!updatedCitations) {
+          await deleteDocTag.mutateAsync({
+            tagId: tag.external_id,
+            docIds: [documentId]
+          });
+        } else {
+          await updateDocTag.mutateAsync({
+            tagId: tag.external_id,
+            docId: documentId,
+            citations: updatedCitations,
+            note: existingDoctag.note
+          });
+        }
+      } else {
+        if (existingDoctag) {
+          const updatedCitations = addChunkToCitations(
+            existingDoctag.citations,
+            documentId,
+            chunkExtId
+          );
+          await updateDocTag.mutateAsync({
+            tagId: tag.external_id,
+            docId: documentId,
+            citations: updatedCitations,
+            note: note ?? existingDoctag.note
+          });
+        } else {
+          const newCitations = addChunkToCitations(null, documentId, chunkExtId);
+          await createDocTag.mutateAsync({
+            tagId: tag.external_id,
+            docIds: [documentId],
+            citations: newCitations,
+            note
+          });
+        }
+      }
+    },
+    [documentId, documentDoctags, createDocTag, updateDocTag, deleteDocTag]
+  );
+  const updateChunkTagNote = useCallback(
+    async (_chunkExtId, tag, note) => {
+      const existingDoctag = documentDoctags.find((dt) => dt.tag_ext_id === tag.external_id);
+      if (!existingDoctag) return;
+      await updateDocTag.mutateAsync({
+        tagId: tag.external_id,
+        docId: documentId,
+        citations: existingDoctag.citations,
+        note
+      });
+    },
+    [documentId, documentDoctags, updateDocTag]
+  );
+  const getChunkTagColors = useCallback(
+    (chunkExtId, workspaceTags) => {
+      const { appliedTags } = getChunkTagState(chunkExtId);
+      return appliedTags.map((dt) => {
+        const tag = workspaceTags.find((t) => t.external_id === dt.tag_ext_id);
+        return tag?.external_id;
+      }).filter((id) => !!id);
+    },
+    [getChunkTagState]
+  );
+  const isLoading = createDocTag.isPending || updateDocTag.isPending || deleteDocTag.isPending;
+  return {
+    getChunkTagState,
+    toggleChunkTag,
+    updateChunkTagNote,
+    getChunkTagColors,
+    isLoading
+  };
+}
+var GROUP_TITLES = {
+  checkbox: "Label",
+  select: "Choice",
+  text: "Text",
+  number: "Number"
+};
+function PassageTagPanel({
+  documentId,
+  chunkExtId,
+  chunkContent,
+  pageNumber,
+  documentDoctags,
+  onClose,
+  onViewTaggedChunks
+}) {
+  const { createTag } = useDocumentViewerSupport();
+  const [editingNoteTagId, setEditingNoteTagId] = useState(null);
+  const [noteValue, setNoteValue] = useState("");
+  const { data: allTags } = useConnectedTags();
+  const workspaceTags = useMemo(() => allTags.filter(isDocumentTag), [allTags]);
+  const { getChunkTagState, toggleChunkTag, updateChunkTagNote, isLoading } = useChunkTagging({
+    documentId,
+    documentDoctags
+  });
+  const chunkState = useMemo(() => getChunkTagState(chunkExtId), [getChunkTagState, chunkExtId]);
+  const groupedTags = useMemo(() => {
+    const groups2 = {
+      checkbox: [],
+      select: [],
+      text: [],
+      number: []
+    };
+    workspaceTags.forEach((tag) => {
+      const group = tag.kind === "label" ? "checkbox" : tag.kind === "annotation" ? tag.tag_type.type : null;
+      if (group && groups2[group]) {
+        groups2[group].push(tag);
+      }
+    });
+    return groups2;
+  }, [workspaceTags]);
+  const handleToggleTag = useCallback(
+    async (tag) => {
+      try {
+        await toggleChunkTag(chunkExtId, tag);
+      } catch (error) {
+        console.error("Failed to toggle chunk tag:", error);
+      }
+    },
+    [chunkExtId, toggleChunkTag]
+  );
+  const handleStartEditNote = useCallback(
+    (tagExtId) => {
+      const doctag = chunkState.getDoctagForChunk(tagExtId);
+      setNoteValue(doctag?.note || "");
+      setEditingNoteTagId(tagExtId);
+    },
+    [chunkState]
+  );
+  const handleSaveNote = useCallback(
+    async (tag) => {
+      try {
+        await updateChunkTagNote(chunkExtId, tag, noteValue || null);
+      } catch (error) {
+        console.error("Failed to save note:", error);
+      }
+      setEditingNoteTagId(null);
+      setNoteValue("");
+    },
+    [chunkExtId, noteValue, updateChunkTagNote]
+  );
+  const preview = useMemo(() => {
+    const maxLength = 200;
+    if (chunkContent.length <= maxLength) return chunkContent;
+    return chunkContent.slice(0, maxLength) + "...";
+  }, [chunkContent]);
+  const groups = useMemo(
+    () => Object.entries(groupedTags).filter(([, tags]) => tags.length > 0).map(([type, tags]) => ({
+      id: type,
+      title: GROUP_TITLES[type] ?? type,
+      tags: tags.map((tag) => ({
+        id: tag.external_id,
+        color: getEntityColor(tag.external_id, "medium"),
+        isApplied: chunkState.isTagApplied(tag.external_id),
+        note: chunkState.getDoctagForChunk(tag.external_id)?.note,
+        badge: /* @__PURE__ */ jsx(TagEntity, { tag, size: "sm", showTooltip: false })
+      }))
+    })),
+    [groupedTags, chunkState]
+  );
+  const tagById = useMemo(
+    () => new Map(workspaceTags.map((tag) => [tag.external_id, tag])),
+    [workspaceTags]
+  );
+  return /* @__PURE__ */ jsx(
+    TagPassagePanel,
+    {
+      pageNumber,
+      preview,
+      groups,
+      isEmpty: workspaceTags.length === 0,
+      isBusy: isLoading,
+      editingNoteTagId,
+      noteValue,
+      onNoteChange: setNoteValue,
+      onToggle: (id) => {
+        const tag = tagById.get(id);
+        if (tag) void handleToggleTag(tag);
+      },
+      onViewTagged: onViewTaggedChunks,
+      onStartNote: handleStartEditNote,
+      onSaveNote: (id) => {
+        const tag = tagById.get(id);
+        if (tag) void handleSaveNote(tag);
+      },
+      onCancelNote: () => {
+        setEditingNoteTagId(null);
+        setNoteValue("");
+      },
+      onCreate: createTag,
+      onClose
+    }
+  );
+}
+var ParsedPassage = memo(function ParsedPassage2({
+  chunk,
+  pageNumber,
+  isHighlighted,
+  isSelected,
+  isCitationHighlight,
+  isActiveCitation,
+  factCitationActive,
+  isCitationMode,
+  runIsStart,
+  runIsEnd,
+  runEndIndex,
+  labels,
+  activeTagColor,
+  onTagPassage,
+  onShowLabel,
+  onRemoveLabel,
+  onChunkClick,
+  formatChunkWithCitation,
+  getPassageDeepLink,
+  copyToClipboard,
+  onOpenNavigator
+}) {
+  const chunkId = chunk.chunkExtId;
+  const formattedContent = chunkId ? formatChunkWithCitation(chunk.content, pageNumber || void 0, chunkId) : "";
+  const isStrong = isActiveCitation || !factCitationActive && isSelected;
+  const isLight = isCitationHighlight || !factCitationActive && isHighlighted;
+  const ownIndex = chunk.chunkIndex !== void 0 ? chunk.chunkIndex + 1 : void 0;
+  const runLabel = runEndIndex !== void 0 && ownIndex !== void 0 && runEndIndex > ownIndex ? `\xB6${ownIndex}\u2013${runEndIndex}` : `\xB6${ownIndex ?? ""}`;
+  const showLabel = !!chunkId && (!isSelected || runIsStart);
+  const copyPassage = (type, text, href) => copyToClipboard(text, {
+    type,
+    documentTitle: chunk.docTitle || "Document",
+    pageNumber: pageNumber || void 0,
+    passageIndex: chunk.chunkIndex,
+    passageContent: formattedContent,
+    href
+  });
+  const passageItems = chunkId ? [
+    {
+      id: "copy-passage",
+      label: "Copy passage with citation",
+      primary: true,
+      testId: "passage-copy",
+      onSelect: () => copyPassage("passage", formattedContent, getPassageDeepLink(chunkId) || void 0)
+    },
+    {
+      id: "copy-link",
+      label: "Copy passage link",
+      testId: "passage-copy-link",
+      onSelect: () => {
+        const link = getPassageDeepLink(chunkId);
+        if (link) copyPassage("link", link, link);
+      }
+    },
+    ...onTagPassage ? [
+      {
+        id: "label",
+        label: "Label this passage",
+        testId: "passage-label",
+        onSelect: () => onTagPassage(chunkId)
+      }
+    ] : [],
+    ...onOpenNavigator ? [
+      {
+        id: "navigator",
+        label: "Open in navigator",
+        testId: "passage-navigator",
+        onSelect: onOpenNavigator
+      }
+    ] : []
+  ] : [];
+  const labelItems = chunkId ? labels.flatMap((l, i) => {
+    const suffix = labels.length > 1 ? ` \u201C${l.name}\u201D` : " label";
+    return [
+      ...onShowLabel ? [
+        {
+          id: `show-${l.tagExtId}`,
+          label: `Show${suffix}`,
+          primary: i === 0,
+          testId: "label-show",
+          onSelect: () => onShowLabel(l.tagExtId)
+        }
+      ] : [],
+      ...onRemoveLabel ? [
+        {
+          id: `remove-${l.tagExtId}`,
+          label: `Remove${suffix}`,
+          destructive: true,
+          testId: "label-remove",
+          onSelect: () => onRemoveLabel(chunkId, l.tagExtId)
+        }
+      ] : []
+    ];
+  }) : [];
+  return /* @__PURE__ */ jsx(
+    HtmlPassage,
+    {
+      chunkId,
+      highlight: isStrong ? "strong" : isLight ? "light" : void 0,
+      isHit: isHighlighted,
+      isSelected,
+      runIsStart,
+      runIsEnd,
+      isClickable: isCitationMode,
+      onSelect: onChunkClick && chunkId ? (extend) => onChunkClick(chunkId, extend) : void 0,
+      isTagged: labels.length > 0,
+      activeTagColor,
+      tagMark: labels.length > 0 ? /* @__PURE__ */ jsx(
+        LabelMark,
+        {
+          colors: labels.map((l) => l.color),
+          name: `Labels: ${labels.map((l) => l.name).join(", ")}`,
+          menuLabel: "Label actions",
+          testId: `passage-tag-dots-${chunkId}`,
+          preview: /* @__PURE__ */ jsx("span", { className: "block font-medium", children: labels.map((l) => l.name).join(", ") }),
+          items: labelItems
+        }
+      ) : void 0,
+      runMarker: isSelected && runIsStart ? /* @__PURE__ */ jsx(
+        NoteMark,
+        {
+          label: runLabel,
+          title: "Cited by this note \u2014 click a passage to add, shift-click for a range",
+          testId: `note-marker-${chunkId}`
+        }
+      ) : void 0,
+      mark: showLabel && chunkId ? /* @__PURE__ */ jsx(
+        PassageMark,
+        {
+          label: runLabel,
+          menuLabel: "Passage actions",
+          testId: `passage-mark-${chunkId}`,
+          items: passageItems
+        }
+      ) : void 0,
+      children: /* @__PURE__ */ jsx(MarkdownRenderer, { children: chunk.content })
+    }
+  );
+});
+
+// src/connection/viewer/parsed/citation-line.ts
+function formatCitation(data) {
+  const { documentTitle, documentDate, pageNumber } = data;
+  let citation = "";
+  if (documentTitle) {
+    citation += `${documentTitle}`;
+  }
+  if (documentDate) {
+    citation += documentTitle ? `, ${documentDate}` : documentDate;
+  }
+  if (pageNumber) {
+    citation += citation ? `, p. ${pageNumber}` : `p. ${pageNumber}`;
+  }
+  return citation;
+}
+
+// src/connection/viewer/parsed/usePassageCopy.ts
+function usePassageCopy({
+  documentId,
+  documentData,
+  selectedWorkspaceId
+}) {
+  const { notify, runtimeConfig } = useBlocksEnvironment();
+  const deploymentDomain = runtimeConfig.deploymentDomain;
+  const formatChunkWithCitation = useCallback(
+    (chunkContent, pageNumber, chunkExtId) => {
+      const docDate = documentData?.doc_metadata?.doc_date;
+      const citation = formatCitation({
+        documentTitle: documentData?.doc_metadata?.title || documentData?.file_name || "",
+        documentDate: docDate ? new Date(docDate).toISOString().split("T")[0] : void 0,
+        pageNumber
+      });
+      const deepLinkUrl = selectedWorkspaceId && documentId && chunkExtId ? buildDeepLinkUrl(
+        { workspaceId: selectedWorkspaceId, documentId, chunkId: chunkExtId },
+        deploymentDomain
+      ) : "";
+      let result = `"${chunkContent.trim()}"`;
+      if (citation) {
+        result += `
+
+\u2014 ${citation}`;
+      }
+      if (deepLinkUrl) {
+        result += `
+[ARBI Docs link](${deepLinkUrl})`;
+      }
+      return result;
+    },
+    [documentData, selectedWorkspaceId, documentId, deploymentDomain]
+  );
+  const getPassageDeepLink = useCallback(
+    (chunkExtId) => {
+      if (!selectedWorkspaceId || !documentId || !chunkExtId) {
+        return "";
+      }
+      return buildDeepLinkUrl(
+        { workspaceId: selectedWorkspaceId, documentId, chunkId: chunkExtId },
+        deploymentDomain
+      );
+    },
+    [selectedWorkspaceId, documentId, deploymentDomain]
+  );
+  const copyToClipboard = useCallback(
+    async (text, passageInfo) => {
+      try {
+        if (passageInfo?.href) {
+          const isLink = passageInfo.type === "link";
+          const { documentTitle, pageNumber, passageIndex, href } = passageInfo;
+          const pageNotation = pageNumber ? `p.${pageNumber}` : "";
+          const passageNotation = passageIndex !== void 0 ? `(${passageIndex})` : "";
+          const citation = `${documentTitle}${pageNotation ? `, ${pageNotation}${passageNotation}` : ""}`;
+          let html;
+          let plainText;
+          if (isLink) {
+            html = `<a href="${href}" target="_blank" rel="noopener noreferrer">${citation}</a>`;
+            plainText = href;
+          } else {
+            const linkHtml = `<p><a href="${href}" target="_blank" rel="noopener noreferrer">${citation}</a></p>`;
+            html = `${linkHtml}<blockquote style="margin: 8px 0; padding-left: 12px; border-left: 3px solid #ccc;">${text}</blockquote>`;
+            plainText = `${href}
+
+${text}
+
+\u2014 ${citation}`;
+          }
+          const clipboardItem = new ClipboardItem({
+            "text/html": new Blob([html], { type: "text/html" }),
+            "text/plain": new Blob([plainText], { type: "text/plain" })
+          });
+          await navigator.clipboard.write([clipboardItem]);
+          const prefix = isLink ? "Link copied:" : "Passage copied:";
+          const notificationElement = React.createElement(
+            "span",
+            { className: "inline-flex items-center gap-2" },
+            prefix,
+            React.createElement(PassagePill, {
+              icon: React.createElement(HtmlIcon, { size: 16, className: "flex-shrink-0" }),
+              documentTitle: passageInfo.documentTitle,
+              pageNumber: passageInfo.pageNumber,
+              passageIndex: passageInfo.passageIndex,
+              href: passageInfo.href,
+              onClick: (e) => e.stopPropagation(),
+              showTooltip: false
+            })
+          );
+          notify(notificationElement, "success", {
+            workspaceId: selectedWorkspaceId || void 0,
+            // The bell entry deep-links back to the copied passage.
+            href: passageInfo.href
+          });
+        } else {
+          await navigator.clipboard.writeText(text);
+          notify("Copied to clipboard", "success");
+        }
+      } catch (err) {
+        console.error("Clipboard copy failed:", err);
+        notify("Failed to copy to clipboard.", "error");
+      }
+    },
+    [selectedWorkspaceId, notify]
+  );
+  return {
+    formatChunkWithCitation,
+    getPassageDeepLink,
+    copyToClipboard
+  };
+}
+function useDocumentLabels(documentId, doctags, orderedChunkIds) {
+  const { data: allTags } = useConnectedTags();
+  const workspaceTags = useMemo(() => allTags.filter(isDocumentTag), [allTags]);
+  const documentDoctags = useMemo(() => doctags ?? [], [doctags]);
+  const tagSummaries = useMemo(
+    () => summariseDocTags(documentDoctags, workspaceTags),
+    [documentDoctags, workspaceTags]
+  );
+  const labelSummaries = useMemo(
+    () => summariseDocTags(documentDoctags, workspaceTags.filter(isDocumentLabel)),
+    [documentDoctags, workspaceTags]
+  );
+  const labelsByChunk = useMemo(() => {
+    const map = /* @__PURE__ */ new Map();
+    for (const s of tagSummaries) {
+      const label = {
+        tagExtId: s.tagExtId,
+        name: s.name,
+        color: getEntityColor(s.tagExtId, "medium")
+      };
+      for (const id of s.chunkIds) {
+        const list = map.get(id);
+        if (list) list.push(label);
+        else map.set(id, [label]);
+      }
+    }
+    return map;
+  }, [tagSummaries]);
+  const { toggleChunkTag } = useChunkTagging({ documentId, documentDoctags });
+  const removeLabel = useCallback(
+    async (chunkExtId, tagExtId) => {
+      const tag = workspaceTags.find((t) => t.external_id === tagExtId);
+      if (!tag) return;
+      try {
+        await toggleChunkTag(chunkExtId, tag);
+      } catch (error) {
+        console.error("Failed to remove passage label", error);
+      }
+    },
+    [workspaceTags, toggleChunkTag]
+  );
+  const [activeTagExtId, setActiveTagExtId] = useState(null);
+  const [tagCursor, setTagCursor] = useState(0);
+  const [taggingChunkId, setTaggingChunkId] = useState(null);
+  const activeTagSummary = tagSummaries.find((t) => t.tagExtId === activeTagExtId);
+  const activeTagColor = activeTagExtId ? getEntityColor(activeTagExtId, "medium") : void 0;
+  const activeChunkIds = useMemo(
+    () => new Set(activeTagSummary?.chunkIds ?? []),
+    [activeTagSummary]
+  );
+  const orderedActiveIds = useMemo(
+    () => orderedChunkIds.filter((id) => activeChunkIds.has(id)),
+    [orderedChunkIds, activeChunkIds]
+  );
+  const gotoTagged = useCallback(
+    (delta) => {
+      if (orderedActiveIds.length === 0) return;
+      const next = (tagCursor + delta + orderedActiveIds.length) % orderedActiveIds.length;
+      setTagCursor(next);
+      document.getElementById(orderedActiveIds[next])?.scrollIntoView({ behavior: "smooth", block: "center" });
+    },
+    [tagCursor, orderedActiveIds]
+  );
+  const selectTag = useCallback((tagExtId) => {
+    setActiveTagExtId(tagExtId);
+    setTagCursor(0);
+  }, []);
+  useEffect(() => {
+    if (!activeTagExtId || orderedActiveIds.length === 0) return;
+    document.getElementById(orderedActiveIds[0])?.scrollIntoView({ behavior: "smooth", block: "center" });
+  }, [activeTagExtId]);
+  return {
+    documentDoctags,
+    labelSummaries,
+    labelsByChunk,
+    removeLabel,
+    activeTagExtId,
+    activeTagColor,
+    activeChunkIds,
+    tagCursor,
+    gotoTagged,
+    selectTag,
+    taggingChunkId,
+    setTaggingChunkId
+  };
+}
+var NONE = [];
+var noop = () => {
+};
+function useCitationSelection({
+  documentId,
+  containerRef,
+  processedChunks,
+  orderedChunkIds,
+  pageOf
+}) {
+  const { passageCitation } = useDocumentViewerSupport();
+  const activeCitationContext = passageCitation?.active ?? null;
+  const setPendingPassagesForCitation = passageCitation?.pick ?? noop;
+  const setUnselectedPassagesForCitation = passageCitation?.unpick ?? noop;
+  const viewingPassageId = useArbiSessionState((s) => s.viewingDocument?.passageId ?? null);
+  const [selectedChunks, setSelectedChunks] = useState(/* @__PURE__ */ new Set());
+  const selectedChunksRef = useRef(selectedChunks);
+  selectedChunksRef.current = selectedChunks;
+  const selectionAnchorRef = useRef(null);
+  const factCitationChunkIds = passageCitation?.highlighted ?? NONE;
+  const factCitationSet = useMemo(() => new Set(factCitationChunkIds), [factCitationChunkIds]);
+  const factCitationActive = factCitationSet.size > 0;
+  const factCitationSetRef = useRef(factCitationSet);
+  factCitationSetRef.current = factCitationSet;
+  const isCitationMode = !!activeCitationContext && activeCitationContext.documentId === documentId;
+  const selectionRuns = useMemo(
+    () => computeSelectionRuns(processedChunks, selectedChunks),
+    [processedChunks, selectedChunks]
+  );
+  const runStartIds = useMemo(
+    () => orderedChunkIds.filter((id) => selectionRuns.get(id)?.isStart),
+    [orderedChunkIds, selectionRuns]
+  );
+  const [runCursor, setRunCursor] = useState(0);
+  const gotoRun = useCallback(
+    (delta) => {
+      if (runStartIds.length === 0) return;
+      const next = (runCursor + delta + runStartIds.length) % runStartIds.length;
+      setRunCursor(next);
+      document.getElementById(runStartIds[next])?.scrollIntoView({ behavior: "smooth", block: "center" });
+    },
+    [runCursor, runStartIds]
+  );
+  useEffect(() => {
+    if (runCursor >= runStartIds.length) setRunCursor(0);
+  }, [runStartIds.length, runCursor]);
+  useEffect(() => {
+    setSelectedChunks(/* @__PURE__ */ new Set());
+  }, [activeCitationContext?.key, activeCitationContext?.documentId]);
+  const handleSelectionEnd = useCallback(() => {
+    if (!activeCitationContext || activeCitationContext.documentId !== documentId) return;
+    const selection = window.getSelection();
+    if (!selection || selection.isCollapsed || selection.rangeCount === 0) return;
+    const container = containerRef.current;
+    if (!container) return;
+    const newSelectedChunks = /* @__PURE__ */ new Set();
+    container.querySelectorAll("[data-chunk-id]").forEach((el) => {
+      const chunkId = el.getAttribute("data-chunk-id");
+      if (!chunkId) return;
+      if (selection.containsNode(el, true)) newSelectedChunks.add(chunkId);
+    });
+    if (newSelectedChunks.size > 0) {
+      setSelectedChunks((prev) => /* @__PURE__ */ new Set([...prev, ...newSelectedChunks]));
+      setPendingPassagesForCitation(
+        Array.from(newSelectedChunks).map((id) => ({ chunk_id: id, page: pageOf(id) }))
+      );
+    }
+    selection.removeAllRanges();
+  }, [activeCitationContext, documentId, containerRef, setPendingPassagesForCitation, pageOf]);
+  const handleChunkClick = useCallback(
+    (chunkId, extendFromAnchor) => {
+      if (!activeCitationContext || activeCitationContext.documentId !== documentId) return;
+      const anchorId = selectionAnchorRef.current;
+      const anchorIdx = anchorId ? orderedChunkIds.indexOf(anchorId) : -1;
+      const targetIdx = orderedChunkIds.indexOf(chunkId);
+      if (extendFromAnchor && anchorIdx !== -1 && targetIdx !== -1) {
+        const [from, to] = anchorIdx <= targetIdx ? [anchorIdx, targetIdx] : [targetIdx, anchorIdx];
+        const range = orderedChunkIds.slice(from, to + 1);
+        setSelectedChunks((prev) => /* @__PURE__ */ new Set([...prev, ...range]));
+        setPendingPassagesForCitation(range.map((id) => ({ chunk_id: id, page: pageOf(id) })));
+        return;
+      }
+      selectionAnchorRef.current = chunkId;
+      const wasSelected = factCitationSetRef.current.size ? factCitationSetRef.current.has(chunkId) : selectedChunksRef.current.has(chunkId);
+      setSelectedChunks((prev) => {
+        const next = new Set(prev);
+        if (wasSelected) next.delete(chunkId);
+        else next.add(chunkId);
+        return next;
+      });
+      if (wasSelected) setUnselectedPassagesForCitation([chunkId]);
+      else setPendingPassagesForCitation([{ chunk_id: chunkId, page: pageOf(chunkId) }]);
+    },
+    [
+      activeCitationContext,
+      documentId,
+      orderedChunkIds,
+      setPendingPassagesForCitation,
+      setUnselectedPassagesForCitation,
+      pageOf
+    ]
+  );
+  return {
+    isCitationMode,
+    selectedChunks,
+    selectionRuns,
+    runStartIds,
+    runCursor,
+    gotoRun,
+    handleSelectionEnd,
+    handleChunkClick,
+    factCitationSet,
+    factCitationActive,
+    viewingPassageId
+  };
+}
+function scrollToChunk(chunkId) {
+  requestAnimationFrame(() => {
+    const element = document.getElementById(chunkId);
+    if (element) {
+      element.scrollIntoView({ behavior: "auto", block: "center" });
+      return;
+    }
+    setTimeout(() => {
+      document.getElementById(chunkId)?.scrollIntoView({ behavior: "auto", block: "center" });
+    }, 100);
+  });
+}
+function usePageScrollSync({
+  containerRef,
+  processedChunksLength,
+  scrollTrigger,
+  onVisibilityUpdate
+}) {
+  const session = useArbiSessionStore();
+  const viewingId = useArbiSessionState((s) => s.viewingDocument?.id);
+  const viewingDocumentPage = useArbiSessionState((s) => s.viewingDocument?.page ?? null);
+  const viewingPassageId = useArbiSessionState((s) => s.viewingDocument?.passageId ?? null);
+  const activeTab = useArbiSessionState((s) => s.documentViewer.tab);
+  const setViewingDocumentPage = useCallback(
+    (page) => {
+      if (viewingId) session.setViewingDocument({ id: viewingId, page });
+    },
+    [session, viewingId]
+  );
+  const [highlighted, setHighlighted] = useState(null);
+  const isChunkHighlighted = useCallback(
+    (chunkId) => chunkId === highlighted,
+    [highlighted]
+  );
+  const scrollCompleteRef = useRef(false);
+  const viewingPassageIdRef = useRef(viewingPassageId);
+  viewingPassageIdRef.current = viewingPassageId;
+  useEffect(() => {
+    if (activeTab !== "html") {
+      scrollCompleteRef.current = false;
+    }
+  }, [activeTab]);
+  useEffect(() => {
+    if (activeTab !== "html" || processedChunksLength === 0) return;
+    if (scrollCompleteRef.current) return;
+    if (viewingPassageIdRef.current) {
+      scrollCompleteRef.current = true;
+      return;
+    }
+    requestAnimationFrame(() => {
+      if (viewingDocumentPage) {
+        const pageElement = document.getElementById(`page-${viewingDocumentPage}`);
+        if (pageElement) {
+          pageElement.scrollIntoView({ behavior: "auto", block: "start" });
+          setTimeout(() => {
+            scrollCompleteRef.current = true;
+          }, 100);
+        }
+      } else {
+        scrollCompleteRef.current = true;
+      }
+    });
+  }, [activeTab, processedChunksLength]);
+  const lastScrolledPassageRef = useRef(null);
+  useEffect(() => {
+    if (!viewingPassageId) {
+      lastScrolledPassageRef.current = null;
+      setHighlighted(null);
+    }
+  }, [viewingPassageId]);
+  useEffect(() => {
+    if (!viewingPassageId || activeTab !== "html" || processedChunksLength === 0) return;
+    if (lastScrolledPassageRef.current === viewingPassageId) return;
+    lastScrolledPassageRef.current = viewingPassageId;
+    setHighlighted(viewingPassageId);
+    scrollToChunk(viewingPassageId);
+  }, [viewingPassageId, activeTab, processedChunksLength]);
+  const viewingPageRef = useRef(viewingDocumentPage);
+  viewingPageRef.current = viewingDocumentPage;
+  useEffect(() => {
+    const viewingDocumentPage2 = viewingPageRef.current;
+    if (!scrollTrigger || processedChunksLength === 0 || !viewingDocumentPage2) return;
+    scrollCompleteRef.current = false;
+    requestAnimationFrame(() => {
+      const pageElement = document.getElementById(`page-${viewingDocumentPage2}`);
+      if (pageElement) {
+        pageElement.scrollIntoView({ behavior: "smooth", block: "start" });
+      }
+      setTimeout(() => {
+        scrollCompleteRef.current = true;
+      }, 500);
+    });
+  }, [scrollTrigger, processedChunksLength]);
+  const getPageElements = useCallback(
+    () => Array.from(document.querySelectorAll('[id^="page-"]')),
+    []
+  );
+  const getPageNumber = useCallback((element) => {
+    const pageMatch = element.id.match(/page-(\d+)/);
+    return pageMatch ? parseInt(pageMatch[1], 10) : 0;
+  }, []);
+  usePageIntersectionObserver({
+    containerRef,
+    scrollCompleteRef,
+    isEnabled: activeTab === "html" && processedChunksLength > 0,
+    getPageElements,
+    getPageNumber,
+    onPageChange: setViewingDocumentPage,
+    onVisibilityUpdate,
+    observeKey: processedChunksLength
+  });
+  return {
+    isChunkHighlighted
+  };
+}
+
+// src/connection/viewer/parsed/useLazyPages.ts
+var LAZY_LOAD_BUFFER_BEFORE = 2;
+var LAZY_LOAD_BUFFER_AFTER = 5;
+var INITIAL_PAGES_TO_RENDER = 3;
+var PAGE_ASPECT_RATIO = 1.3;
+function useLazyPages({ containerRef, processedChunks, scrollTrigger }) {
+  const [containerWidth, setContainerWidth] = useState(0);
+  useEffect(() => {
+    const el = containerRef.current;
+    if (!el) return;
+    const observer = new ResizeObserver((entries) => {
+      setContainerWidth(entries[0]?.contentRect.width ?? 0);
+    });
+    observer.observe(el);
+    return () => observer.disconnect();
+  }, [containerRef]);
+  const [renderedPages, setRenderedPages] = useState(
+    () => new Set(Array.from({ length: INITIAL_PAGES_TO_RENDER }, (_, i) => i))
+  );
+  useEffect(() => {
+    if (processedChunks.length === 0) return;
+    const renderAll = () => {
+      setRenderedPages((prev) => {
+        if (prev.size === processedChunks.length) return prev;
+        return new Set(Array.from({ length: processedChunks.length }, (_, i) => i));
+      });
+    };
+    if (typeof window.requestIdleCallback !== "function") {
+      const timer = setTimeout(renderAll, 200);
+      return () => clearTimeout(timer);
+    }
+    const id = window.requestIdleCallback(renderAll);
+    return () => window.cancelIdleCallback(id);
+  }, [processedChunks.length]);
+  const handleVisibilityUpdate = useCallback(
+    (visibilityMap) => {
+      const visiblePageNumbers = Array.from(visibilityMap.entries()).filter(([, ratio]) => ratio > 0).map(([pageNum]) => pageNum);
+      if (visiblePageNumbers.length === 0) return;
+      const visibleIndices = [];
+      processedChunks.forEach((page, index) => {
+        if (page.pageNumber !== null && visiblePageNumbers.includes(page.pageNumber)) {
+          visibleIndices.push(index);
+        }
+      });
+      if (visibleIndices.length === 0) return;
+      const minIndex = Math.min(...visibleIndices);
+      const maxIndex = Math.max(...visibleIndices);
+      const pagesToRender = /* @__PURE__ */ new Set();
+      for (let i = Math.max(0, minIndex - LAZY_LOAD_BUFFER_BEFORE); i <= Math.min(processedChunks.length - 1, maxIndex + LAZY_LOAD_BUFFER_AFTER); i++) {
+        pagesToRender.add(i);
+      }
+      setRenderedPages((prev) => {
+        for (const i of pagesToRender) if (!prev.has(i)) return /* @__PURE__ */ new Set([...prev, ...pagesToRender]);
+        return prev;
+      });
+    },
+    [processedChunks]
+  );
+  const viewingDocumentPage = useArbiSessionState((s) => s.viewingDocument?.page ?? null);
+  const viewingPassageId = useArbiSessionState((s) => s.viewingDocument?.passageId ?? null);
+  const activeTab = useArbiSessionState((s) => s.documentViewer.tab);
+  useEffect(() => {
+    if (!viewingDocumentPage || processedChunks.length === 0) return;
+    if (!viewingPassageId && activeTab !== "html") return;
+    const targetIndex = processedChunks.findIndex((p) => p.pageNumber === viewingDocumentPage);
+    if (targetIndex === -1) return;
+    setRenderedPages((prev) => {
+      if (prev.has(targetIndex)) return prev;
+      const next = new Set(prev);
+      for (let i = Math.max(0, targetIndex - LAZY_LOAD_BUFFER_BEFORE); i <= Math.min(processedChunks.length - 1, targetIndex + LAZY_LOAD_BUFFER_AFTER); i++) {
+        next.add(i);
+      }
+      return next;
+    });
+  }, [viewingPassageId, viewingDocumentPage, processedChunks, activeTab]);
+  const tabSwitchScrolledRef = useRef(false);
+  const passageScrolledRef = useRef(null);
+  useEffect(() => {
+    if (activeTab !== "html") tabSwitchScrolledRef.current = false;
+  }, [activeTab]);
+  useEffect(() => {
+    if (!viewingPassageId) passageScrolledRef.current = null;
+  }, [viewingPassageId]);
+  useEffect(() => {
+    if (activeTab !== "html" || !viewingDocumentPage) return;
+    if (viewingPassageId && passageScrolledRef.current !== viewingPassageId) {
+      const target = viewingPassageId;
+      const deadline = performance.now() + 3e3;
+      let raf = 0;
+      const tick = () => {
+        const el = document.getElementById(target);
+        if (el) {
+          passageScrolledRef.current = target;
+          tabSwitchScrolledRef.current = true;
+          el.scrollIntoView({ behavior: "auto", block: "center" });
+          raf = requestAnimationFrame(
+            () => el.scrollIntoView({ behavior: "auto", block: "center" })
+          );
+          return;
+        }
+        if (performance.now() < deadline) raf = requestAnimationFrame(tick);
+      };
+      raf = requestAnimationFrame(tick);
+      return () => cancelAnimationFrame(raf);
+    }
+    if (tabSwitchScrolledRef.current) return;
+    const pageElement = document.getElementById(`page-${viewingDocumentPage}`);
+    if (!pageElement) return;
+    tabSwitchScrolledRef.current = true;
+    requestAnimationFrame(() => {
+      pageElement.scrollIntoView({ behavior: "auto", block: "start" });
+    });
+  }, [renderedPages, activeTab, viewingDocumentPage, viewingPassageId]);
+  const { isChunkHighlighted } = usePageScrollSync({
+    containerRef,
+    processedChunksLength: processedChunks.length,
+    scrollTrigger,
+    onVisibilityUpdate: handleVisibilityUpdate
+  });
+  return {
+    renderedPages,
+    isChunkHighlighted,
+    placeholderHeight: containerWidth ? containerWidth * PAGE_ASPECT_RATIO : 500
+  };
+}
+var EMPTY_LABELS = [];
+function ParsedTextView({
+  documentId,
+  stage = "final",
+  onLoadSuccess,
+  scrollTrigger,
+  zoom = 1,
+  onZoomChange
+}) {
+  const { workspaceId } = useConnectedWorkspace();
+  const { openInNavigator } = useDocumentViewerSupport();
+  const containerRef = useRef(null);
+  const { data: documentRecord } = useDocument(parseVersionRef(documentId).docId, {
+    enabled: !!documentId && !!workspaceId
+  });
+  const documentData = documentRecord ?? void 0;
+  const { data: parsedDoc, isLoading, error } = useParsedDocument(documentId, stage);
+  const { processedChunks, maxPageNumber } = useProcessedChunks(
+    parsedDoc?.chunks,
+    parsedDoc?.footnotes || {}
+  );
+  const pageByChunk = useMemo(() => {
+    const map = /* @__PURE__ */ new Map();
+    for (const page of processedChunks) {
+      for (const chunk of page.chunks) {
+        if (chunk.chunkExtId) map.set(chunk.chunkExtId, page.pageNumber ?? void 0);
+      }
+    }
+    return map;
+  }, [processedChunks]);
+  const pageOf = useCallback((id) => pageByChunk.get(id), [pageByChunk]);
+  const orderedChunkIds = useMemo(
+    () => processedChunks.flatMap(
+      (page) => page.chunks.map((c) => c.chunkExtId).filter((id) => !!id)
+    ),
+    [processedChunks]
+  );
+  const totalPages = useMemo(
+    () => processedChunks.filter((p) => p.pageNumber !== null).length,
+    [processedChunks]
+  );
+  const labels = useDocumentLabels(documentId, documentData?.doctags, orderedChunkIds);
+  const citation = useCitationSelection({
+    documentId,
+    containerRef,
+    processedChunks,
+    orderedChunkIds,
+    pageOf
+  });
+  const { renderedPages, isChunkHighlighted, placeholderHeight } = useLazyPages({
+    containerRef,
+    processedChunks,
+    scrollTrigger
+  });
+  useScrollAnchor(containerRef, processedChunks.length);
+  usePinchZoom({ containerRef, zoom, onZoomChange });
+  const { formatChunkWithCitation, getPassageDeepLink, copyToClipboard } = usePassageCopy({
+    documentId,
+    documentData,
+    selectedWorkspaceId: workspaceId
+  });
+  const handleOpenNavigator = useMemo(
+    () => openInNavigator ? () => openInNavigator(documentId) : void 0,
+    [openInNavigator, documentId]
+  );
+  useEffect(() => {
+    if (maxPageNumber > 0 && onLoadSuccess) {
+      try {
+        onLoadSuccess(maxPageNumber);
+      } catch (err) {
+        console.error("Error in onLoadSuccess callback:", err);
+      }
+    }
+  }, [maxPageNumber, onLoadSuccess]);
+  if (isLoading) return /* @__PURE__ */ jsx(ViewerMessage, { children: "Loading parsed document..." });
+  if (error) {
+    return /* @__PURE__ */ jsx(ViewerMessage, { children: /* @__PURE__ */ jsx("span", { className: "text-red-text", children: "Failed to load parsed document" }) });
+  }
+  const taggingChunk = labels.taggingChunkId ? processedChunks.flatMap((page) => page.chunks).find((c) => c.chunkExtId === labels.taggingChunkId) : void 0;
+  return /* @__PURE__ */ jsxs(HtmlViewerRoot, { children: [
+    /* @__PURE__ */ jsx(
+      DocumentLabelBar,
+      {
+        summaries: labels.labelSummaries,
+        activeTagExtId: labels.activeTagExtId,
+        cursor: labels.tagCursor,
+        onSelect: labels.selectTag,
+        onStep: labels.gotoTagged
+      }
+    ),
+    labels.taggingChunkId && /* @__PURE__ */ jsx(
+      PassageTagPanel,
+      {
+        documentId,
+        chunkExtId: labels.taggingChunkId,
+        chunkContent: taggingChunk?.content ?? "",
+        pageNumber: pageOf(labels.taggingChunkId),
+        documentDoctags: labels.documentDoctags,
+        onClose: () => labels.setTaggingChunkId(null),
+        onViewTaggedChunks: (tagExtId) => {
+          labels.selectTag(tagExtId);
+          labels.setTaggingChunkId(null);
+        }
+      }
+    ),
+    !citation.factCitationActive && citation.runStartIds.length > 0 && /* @__PURE__ */ jsx(
+      CitedRunNav,
+      {
+        position: citation.runCursor + 1,
+        total: citation.runStartIds.length,
+        onStep: citation.gotoRun
+      }
+    ),
+    /* @__PURE__ */ jsx(HtmlViewerSurface, { surfaceRef: containerRef, onMouseUp: citation.handleSelectionEnd, children: processedChunks.length > 0 ? processedChunks.map((page, pageIndex) => /* @__PURE__ */ jsx(
+      HtmlPage,
+      {
+        pageNumber: page.pageNumber,
+        totalPages,
+        isRendered: renderedPages.has(pageIndex),
+        placeholderHeight,
+        zoom,
+        children: page.chunks.map((chunk, chunkIndex) => {
+          const id = chunk.chunkExtId;
+          const run = id ? citation.selectionRuns.get(id) : void 0;
+          return /* @__PURE__ */ jsx(
+            ParsedPassage,
+            {
+              chunk,
+              pageNumber: page.pageNumber,
+              isHighlighted: !!(id && isChunkHighlighted(id)),
+              isSelected: !!(id && citation.selectedChunks.has(id)),
+              isCitationHighlight: !!(id && citation.factCitationSet.has(id)),
+              isActiveCitation: !!(id && citation.factCitationActive && citation.viewingPassageId === id && // Only while it is STILL cited: clicking it off must clear it.
+              citation.factCitationSet.has(id)),
+              factCitationActive: citation.factCitationActive,
+              isCitationMode: citation.isCitationMode,
+              runIsStart: !!run?.isStart,
+              runIsEnd: !!run?.isEnd,
+              runEndIndex: run?.endIndex,
+              onChunkClick: citation.isCitationMode ? citation.handleChunkClick : void 0,
+              formatChunkWithCitation,
+              getPassageDeepLink,
+              copyToClipboard,
+              onOpenNavigator: handleOpenNavigator,
+              labels: id ? labels.labelsByChunk.get(id) ?? EMPTY_LABELS : EMPTY_LABELS,
+              activeTagColor: id && labels.activeChunkIds.has(id) ? labels.activeTagColor : void 0,
+              onTagPassage: labels.setTaggingChunkId,
+              onShowLabel: labels.selectTag,
+              onRemoveLabel: labels.removeLabel
+            },
+            chunkIndex
+          );
+        })
+      },
+      pageIndex
+    )) : /* @__PURE__ */ jsx(HtmlViewerEmpty, {}) })
+  ] });
+}
+var AnnotatedPdfViewer = lazy(
+  () => import('../document-tools/viewer/index.js').then((m) => ({ default: m.AnnotatedPdfViewer }))
+);
+var SignaturePlacementViewer = lazy(
+  () => import('../document-tools/viewer/index.js').then((m) => ({ default: m.SignaturePlacementViewer }))
+);
+var SignatureRequestEditor = lazy(
+  () => import('../document-tools/viewer/index.js').then((m) => ({ default: m.SignatureRequestEditor }))
+);
+var GuidedSigningViewer = lazy(
+  () => import('../document-tools/viewer/index.js').then((m) => ({ default: m.GuidedSigningViewer }))
+);
+function SessionPdfViewer(props) {
+  const session = useArbiSessionStore();
+  const viewingId = useArbiSessionState((s) => s.viewingDocument?.id);
+  const { isDetached } = useDocumentViewerSupport();
+  const onPageChange = useCallback(
+    (page) => {
+      if (viewingId) session.setViewingDocument({ id: viewingId, page });
+    },
+    [session, viewingId]
+  );
+  return /* @__PURE__ */ jsx(PdfViewer, { ...props, onPageChange, disableFontFace: !!isDetached });
+}
+function ViewerPdfPane({
+  documentId,
+  doc,
+  pdfBlob,
+  isPdfLoading,
+  pdfError,
+  onDownload,
+  viewerProps,
+  signatureFlow,
+  onSignatureFlow,
+  currentUserId,
+  placingSignature,
+  onPlacingDone,
+  annotating,
+  markup,
+  pdfSnapshotNumber,
+  isSigned
+}) {
+  const { documentData, isDownloadOnly, isVideo, isAudio, isImage, isDocx } = doc;
+  const showMarkup = markup.hasMarkup && !markup.showOriginal;
+  if (isDownloadOnly) {
+    return /* @__PURE__ */ jsx(
+      ViewerPreviewUnavailable,
+      {
+        extension: fileExtension(documentData?.file_name),
+        onDownload
+      }
+    );
+  }
+  const loadingLabel = isVideo ? "Loading video..." : isAudio ? "Loading audio..." : isImage ? "Loading image..." : !documentData ? "Loading document..." : friendlyFileType(documentData.file_type, documentData.file_name) === "Text" ? "Loading text..." : "Loading PDF...";
+  const errorLabel = isVideo ? "Failed to load video" : isAudio ? "Failed to load audio" : isImage ? "Failed to load image" : "Failed to load PDF";
+  if (isDocx && documentData && !["completed", "low-content", "failed"].includes(documentData.status || "")) {
+    return /* @__PURE__ */ jsx(ViewerMessage, { children: "PDF and search indexing are processing. Open the DOCX tab to edit now." });
+  }
+  if (isPdfLoading) return /* @__PURE__ */ jsx(ViewerMessage, { children: loadingLabel });
+  if (pdfError) {
+    return /* @__PURE__ */ jsx(
+      ViewerLoadError,
+      {
+        message: isVideo || isAudio || isImage ? `${errorLabel} \u2014 download it instead.` : "Couldn't display the PDF \u2014 download it instead.",
+        onDownload
+      }
+    );
+  }
+  if (!pdfBlob) return /* @__PURE__ */ jsx(ViewerMessage, { children: loadingLabel });
+  if (isVideo) return /* @__PURE__ */ jsx(VideoViewer, { blob: pdfBlob, title: documentData?.file_name || "Video" });
+  if (isAudio) return /* @__PURE__ */ jsx(AudioViewer, { blob: pdfBlob, title: documentData?.file_name || "Audio" });
+  if (isImage) {
+    return /* @__PURE__ */ jsx(ImageViewer, { blob: pdfBlob, alt: documentData?.file_name || "Document image" });
+  }
+  if (signatureFlow?.kind === "prepare") {
+    return /* @__PURE__ */ jsx(Suspense, { fallback: /* @__PURE__ */ jsx(ViewerMessage, { children: "Loading\u2026" }), children: /* @__PURE__ */ jsx(
+      SignatureRequestEditor,
+      {
+        ...viewerProps,
+        file: pdfBlob,
+        documentId,
+        version: documentData?.current_version ?? void 0,
+        draft: signatureFlow.draft,
+        viewer: SessionPdfViewer,
+        onCancel: () => onSignatureFlow(null),
+        onSaved: () => onSignatureFlow(null)
+      }
+    ) });
+  }
+  if (signatureFlow?.kind === "sign" && currentUserId) {
+    const { currentPage: _page, scrollTrigger: _trigger, ...guidedProps } = viewerProps;
+    return /* @__PURE__ */ jsx(Suspense, { fallback: /* @__PURE__ */ jsx(ViewerMessage, { children: "Loading\u2026" }), children: /* @__PURE__ */ jsx(
+      GuidedSigningViewer,
+      {
+        ...guidedProps,
+        file: pdfBlob,
+        request: signatureFlow.request,
+        signer: currentUserId,
+        viewer: SessionPdfViewer,
+        onClose: () => onSignatureFlow(null),
+        onSigned: () => onSignatureFlow(null)
+      }
+    ) });
+  }
+  if (placingSignature) {
+    return /* @__PURE__ */ jsx(Suspense, { fallback: /* @__PURE__ */ jsx(ViewerMessage, { children: "Loading\u2026" }), children: /* @__PURE__ */ jsx(
+      SignaturePlacementViewer,
+      {
+        ...viewerProps,
+        file: pdfBlob,
+        documentId,
+        viewer: SessionPdfViewer,
+        onCancel: () => onPlacingDone(),
+        onContinue: (appearance) => onPlacingDone(appearance)
+      }
+    ) });
+  }
+  if (annotating || showMarkup) {
+    return /* @__PURE__ */ jsx(
+      Suspense,
+      {
+        fallback: /* @__PURE__ */ jsx(ViewerMessage, { children: annotating ? "Loading annotation tools\u2026" : "Loading markup\u2026" }),
+        children: /* @__PURE__ */ jsx(
+          AnnotatedPdfViewer,
+          {
+            ...viewerProps,
+            file: pdfBlob,
+            documentId,
+            version: pdfSnapshotNumber,
+            editing: annotating,
+            onMarkupChange: markup.onMarkupChange,
+            fileName: documentData?.file_name,
+            shared: documentData?.shared ?? false,
+            folder: documentData?.folder,
+            viewer: SessionPdfViewer,
+            signed: isSigned
+          },
+          `${documentId}@${pdfSnapshotNumber ?? "current"}`
+        )
+      }
+    );
+  }
+  return /* @__PURE__ */ jsx(SessionPdfViewer, { ...viewerProps, file: pdfBlob });
+}
+var NativeDocxEditor = lazy(
+  () => import('../ConnectedNativeDocxEditor-LRYU5HPA.js').then((m) => ({
+    default: m.ConnectedNativeDocxEditor
+  }))
+);
+var StreamedWordArtifact = lazy(
+  () => import('../ConnectedStreamedWordArtifact-QAUVUCSX.js').then((m) => ({
+    default: m.ConnectedStreamedWordArtifact
+  }))
+);
+var NativeDocxComparison = lazy(
+  () => import('../ConnectedNativeDocxComparison-OFPIXNJB.js').then((m) => ({
+    default: m.ConnectedNativeDocxComparison
+  }))
+);
+var UPLOADED_NO_VERSIONS = "No earlier versions yet. Replacing, editing or signing this file adds a new version here.";
+function canChangeVisibility(doc, userId) {
+  if (!doc || !userId) return false;
+  return userId.startsWith("agt-") || (doc.created_by_ext_id?.startsWith("agt-") ?? false) || doc.created_by_ext_id === userId;
+}
+function ConnectedDocumentViewer(props) {
+  const viewing = useArbiSessionState((s) => s.viewingDocument?.id);
+  const openedId = props.documentId ?? viewing;
+  if (!openedId) return null;
+  return /* @__PURE__ */ jsx(ConnectedDocumentToolsProvider, { children: /* @__PURE__ */ jsx(DocumentViewerContent, { ...props, openedId }) });
+}
+function DocumentViewerContent({
+  openedId,
+  headerActions,
+  artifactRuntimeUrl = "/artifact-runtime/"
+}) {
+  const arbi = useArbi();
+  const session = useArbiSessionStore();
+  const support = useDocumentViewerSupport();
+  const formatDate = support.formatDate ?? fmtDate;
+  const tools = useDocumentTools();
+  const { openConversation, notify } = useBlocksEnvironment();
+  const { userId: currentUserId } = useConnectedWorkspace();
+  const documentId = parseVersionRef(openedId).docId;
+  const [totalPages, setTotalPages] = useState(0);
+  const [isCompact, setIsCompact] = useState(false);
+  const [pdfZoom, setPdfZoom] = useState(1);
+  const {
+    tab: zoomTab,
+    textScale,
+    compareId: compareDocumentId
+  } = useArbiSessionState((s) => s.documentViewer);
+  const zoom = zoomTab === "html" ? textScale : pdfZoom;
+  const setZoom = useCallback(
+    (next) => {
+      const value = typeof next === "function" ? next(zoom) : next;
+      if (zoomTab === "html") session.setDocumentViewer({ textScale: value });
+      else setPdfZoom(value);
+    },
+    [zoomTab, session, zoom]
+  );
+  const [scrollTrigger, setScrollTrigger] = useState(0);
+  const containerRef = useRef(null);
+  const viewingDocumentPage = useArbiSessionState((s) => s.viewingDocument?.page ?? null);
+  const setViewingDocumentPage = (page) => session.setViewingDocument({ id: openedId, page });
+  const setViewingDocumentId = (id) => session.setViewingDocument({ id });
+  const setActiveTab = (tab) => session.setDocumentViewer({ tab });
+  const setCompareDocumentId = (id) => session.setDocumentViewer({ compareId: id });
+  const { data: conversations } = useConnectedConversations();
+  const snapshotRef = parseVersionRef(openedId).version ? openedId : null;
+  const { versions, translations } = useViewerVersions(documentId);
+  const currentVersionId = versions.find((v) => v.isCurrent)?.id ?? documentId;
+  const snapshotDocumentId = snapshotRef && snapshotRef !== currentVersionId ? snapshotRef : null;
+  const doc = useViewedDocument(documentId);
+  const setSnapshotDocumentId = (ref) => setViewingDocumentId(ref ?? documentId);
+  useRegisterOpenDocument({
+    documentId: doc.savedDocumentId,
+    shownId: openedId,
+    showLive: () => setViewingDocumentId(documentId),
+    workspaceId: doc.workspaceId
+  });
+  const {
+    documentData,
+    streamingDoc,
+    isStreaming,
+    draftDoc,
+    isDraft,
+    isCaptureDraft,
+    labelSummaries,
+    isImage,
+    isVideo,
+    isAudio,
+    isMedia,
+    isArtifact,
+    liveKind,
+    liveSource,
+    isDocx,
+    isXlsx,
+    isDownloadOnly
+  } = doc;
+  const threadTitle = (id) => conversations.find((c) => c.external_id === id)?.title?.trim() || "Its thread";
+  const madeInId = documentData?.conversation_ext_id ?? null;
+  const madeIn = madeInId ? { id: madeInId, title: threadTitle(madeInId) } : null;
+  const pdfSnapshotId = snapshotDocumentId && !isDocx && !isArtifact ? snapshotDocumentId : null;
+  const shownDocumentId = pdfSnapshotId || documentId;
+  const blobs = useViewerBlobs(shownDocumentId, doc);
+  const { pdfBlob, xlsxBlob, xlsxError, handleDirectDownload } = blobs;
+  const [annotating, setAnnotating] = useState(false);
+  useEffect(() => setAnnotating(false), [documentId]);
+  const hasHistory = versions.length > 1 || (documentData?.current_version ?? 1) > 1 || translations.length > 0;
+  const { activeTab, handleTabChange, viewerTabs } = useViewerTabs(doc, isCompact, hasHistory);
+  const crop = useImageCrop(documentId, documentData?.file_name, pdfBlob);
+  const [placingSignature, setPlacingSignature] = useState(false);
+  const [signAppearance, setSignAppearance] = useState();
+  const [isSignOpen, setIsSignOpen] = useState(false);
+  useEffect(() => setPlacingSignature(false), [documentId, snapshotDocumentId]);
+  const [signatureFlow, setSignatureFlow] = useState(null);
+  useEffect(() => setSignatureFlow(null), [documentId, snapshotDocumentId]);
+  const { data: signatureStatus } = useDocumentSignatures(shownDocumentId, !isDraft && !liveKind);
+  const isCoEditing = !snapshotDocumentId && !compareDocumentId && !isDraft && (activeTab === "docx" && isDocx || activeTab === "edit" && isArtifact && !liveKind && !isStreaming);
+  const currentVersionLabel = isCoEditing ? void 0 : !snapshotDocumentId && !compareDocumentId && (isDocx || isArtifact && !liveKind) ? "Live" : versionLabel(versions, snapshotDocumentId || documentId);
+  const compareVersionLabel = versionLabel(versions, compareDocumentId);
+  const snapshotNumber = findVersion(versions, snapshotDocumentId)?.number;
+  const pdfSnapshotNumber = pdfSnapshotId ? snapshotNumber : void 0;
+  const isSigned = !!signatureStatus?.signed;
+  const markup = useDocumentMarkup(documentData, pdfSnapshotNumber, isSigned);
+  useEffect(() => {
+    const container = containerRef.current;
+    if (!container) return;
+    const resizeObserver = new ResizeObserver((entries) => {
+      for (const entry of entries) setIsCompact(entry.contentRect.width < 640);
+    });
+    resizeObserver.observe(container);
+    return () => resizeObserver.disconnect();
+  }, []);
+  const handleLoadSuccess = useCallback((numPages) => setTotalPages(numPages), []);
+  const goToPage = (page) => {
+    setViewingDocumentPage(page);
+    setScrollTrigger((prev) => prev + 1);
+  };
+  const stepPage = (delta) => {
+    const next = (viewingDocumentPage || 1) + delta;
+    if (next >= 1 && next <= totalPages) goToPage(next);
+  };
+  const documentTitle = streamingDoc?.title || draftDoc?.title || documentData?.doc_metadata?.title || documentData?.file_name || "Document";
+  const pageNav = totalPages > 0 && /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsx(ViewerZoomControl, { zoom, onCycle: () => setZoom(cycleZoom(zoom)) }),
+    /* @__PURE__ */ jsx(
+      PdfPageNav,
+      {
+        canPrev: (viewingDocumentPage || 1) > 1,
+        canNext: (viewingDocumentPage || 1) < totalPages,
+        onPrev: () => stepPage(-1),
+        onNext: () => stepPage(1),
+        counter: /* @__PURE__ */ jsx(ViewerPageCounter, { page: viewingDocumentPage || 1, total: totalPages, onGoTo: goToPage })
+      }
+    )
+  ] });
+  const isComparing = !!compareDocumentId;
+  const compareTarget = compareDocumentId ? parseVersionRef(compareDocumentId).docId : null;
+  const compareIndicator = isComparing && compareTarget && /* @__PURE__ */ jsx(
+    ArtifactCompareBar,
+    {
+      compareTarget: support.renderDocumentPill?.(compareTarget) ?? compareTarget,
+      versionLabel: compareVersionLabel,
+      mode: "flip",
+      showTrackChanges: false,
+      onToggleTrackChanges: () => {
+      },
+      onFlip: () => {
+        setViewingDocumentId(compareDocumentId);
+        setCompareDocumentId(documentId);
+      },
+      onStop: () => setCompareDocumentId(null)
+    }
+  );
+  const titleBlock = /* @__PURE__ */ jsxs(Fragment, { children: [
+    isDraft ? support.renderDraftTitle?.(documentId) : /* @__PURE__ */ jsx(
+      ViewerTitle,
+      {
+        title: documentTitle,
+        versionLabel: currentVersionLabel,
+        shrink: !!liveKind || isCompact
+      }
+    ),
+    isCompact && !isDraft && documentData?.shared && /* @__PURE__ */ jsx(ViewerStatusNote, { testId: "document-shared-status", children: "Shared with the workspace" }),
+    isCompact && activeTab === "pdf" && pdfBlob && markup.hasMarkup && !annotating && !placingSignature && /* @__PURE__ */ jsx(
+      MarkupViewNote,
+      {
+        showOriginal: markup.showOriginal,
+        onToggle: () => markup.setShowOriginal((on) => !on)
+      }
+    ),
+    !isComparing && !liveKind && documentData && support.renderRelated?.(documentData),
+    isStreaming && /* @__PURE__ */ jsx(ViewerStatusNote, { pulse: true, children: "streaming..." }),
+    isDraft && /* @__PURE__ */ jsx(ViewerStatusNote, { testId: "draft-unsaved-indicator", children: "Draft \u2014 not saved" }),
+    signatureStatus?.signed && /* @__PURE__ */ jsx(SignatureStatus, { status: signatureStatus, formatDate })
+  ] });
+  const leftContent = /* @__PURE__ */ jsxs(ViewerHeaderStart, { children: [
+    isDraft ? (
+      // A draft's kind replaces the tabs: neither Versions nor the text view means anything
+      // before the first save.
+      support.renderDraftKind?.(documentId)
+    ) : /* @__PURE__ */ jsx(ViewerTabBar, { tabs: viewerTabs, activeId: activeTab, onChange: handleTabChange }),
+    !isCompact && titleBlock
+  ] });
+  const annotatable = canAnnotate({
+    activeTab,
+    hasPdf: !!pdfBlob,
+    isImage,
+    isVideo,
+    isAudio,
+    isDownloadOnly,
+    isDraft,
+    isStreaming,
+    isSnapshot: !!snapshotDocumentId,
+    isComparing
+  });
+  const signatureBanner = !isDraft && !liveKind && !snapshotDocumentId && /* @__PURE__ */ jsx(
+    SignatureRequestBanner,
+    {
+      documentId,
+      hidden: !!signatureFlow,
+      onSign: (request) => {
+        setAnnotating(false);
+        setPlacingSignature(false);
+        if (activeTab !== "pdf") handleTabChange("pdf");
+        setSignatureFlow({ kind: "sign", request });
+      },
+      onEditDraft: (draft) => {
+        if (activeTab !== "pdf") handleTabChange("pdf");
+        setSignatureFlow({ kind: "prepare", draft });
+      }
+    }
+  );
+  const share = () => {
+    const name = (liveKind ? documentTitle : documentData?.file_name) || void 0;
+    if (support.share) {
+      support.share({ id: documentId, name, isPrivate: !documentData?.shared });
+      return;
+    }
+    void arbi.documents.update([{ external_id: documentId, shared: !documentData?.shared }]).then(() => tools.onDocumentsChanged?.([documentId], "markup")).catch(() => notify("Couldn't change who can see this document", "error"));
+  };
+  const shownRef = snapshotDocumentId || documentId;
+  const rightContent = /* @__PURE__ */ jsxs(ViewerHeaderEnd, { isCompact, children: [
+    annotatable && /* @__PURE__ */ jsx(
+      AnnotateButton,
+      {
+        active: annotating,
+        compact: isCompact,
+        onClick: () => {
+          setPlacingSignature(false);
+          markup.setShowOriginal(false);
+          setAnnotating((on) => !on);
+        }
+      }
+    ),
+    activeTab === "pdf" && pdfBlob && !placingSignature && (markup.hasMarkup || annotating) && /* @__PURE__ */ jsx(
+      ShowOriginalButton,
+      {
+        active: markup.showOriginal,
+        compact: isCompact,
+        onClick: () => {
+          setAnnotating(false);
+          markup.setShowOriginal((on) => !on);
+        }
+      }
+    ),
+    activeTab === "pdf" && markup.hasMarkup && !annotating && /* @__PURE__ */ jsx(
+      DownloadMarkupButton,
+      {
+        onClick: () => void markup.downloadMarkup(),
+        disabledReason: isSigned ? SIGNED_LOCKED_REASON : void 0
+      }
+    ),
+    activeTab === "pdf" && isImage && pdfBlob && /* @__PURE__ */ jsx(
+      ViewerImageActions,
+      {
+        compact: isCompact,
+        onUseAsReference: support.useImageAsReference ? () => support.useImageAsReference(documentId) : void 0,
+        onCrop: crop.handleOpenCrop
+      }
+    ),
+    madeIn && /* @__PURE__ */ jsxs(
+      Button,
+      {
+        type: "button",
+        variant: "outline",
+        size: isCompact ? "icon" : "sm",
+        onClick: () => openConversation(madeIn.id, {
+          messageId: documentData?.source_message_ext_id ?? void 0
+        }),
+        title: `Open the thread it was made in: ${madeIn.title}`,
+        "aria-label": `Open the thread it was made in: ${madeIn.title}`,
+        "data-testid": "document-open-thread",
+        children: [
+          /* @__PURE__ */ jsx(MessageSquare, { className: "size-4" }),
+          !isCompact && /* @__PURE__ */ jsx("span", { className: "max-w-[10rem] truncate", children: madeIn.title })
+        ]
+      }
+    ),
+    documentId && doc.workspaceId && /* @__PURE__ */ jsx(
+      ShareControl,
+      {
+        state: documentData?.shared ? "shared" : "private",
+        onToggle: share,
+        disabled: !canChangeVisibility(documentData, currentUserId),
+        disabledTooltip: "Only the owner can change visibility",
+        tooltip: documentData?.shared ? "Shared with the workspace \u2014 click to share with specific people" : "Share with the workspace, then optionally notify specific people by email",
+        variant: "outline",
+        compact: isCompact,
+        showState: !isCompact,
+        labels: {
+          shared: getEntityLabel("WORKSPACE"),
+          private: "Only you",
+          mixed: "Partly shared"
+        },
+        testId: "share-document-button",
+        stateTestId: "document-title-shared-indicator"
+      }
+    ),
+    tools.emailDocument && !isDraft && !isStreaming && documentData?.file_name && /* @__PURE__ */ jsxs(Fragment, { children: [
+      /* @__PURE__ */ jsx("span", { className: "mx-1 h-5 w-px bg-border", "aria-hidden": "true" }),
+      /* @__PURE__ */ jsxs(
+        Button,
+        {
+          type: "button",
+          variant: "outline",
+          size: isCompact ? "icon" : "sm",
+          title: "Email this document",
+          "aria-label": "Email",
+          "data-testid": "email-document-button",
+          className: "pointer-coarse:min-h-11",
+          onClick: () => tools.emailDocument?.(shownRef),
+          children: [
+            /* @__PURE__ */ jsx(Mail, { className: "size-4" }),
+            !isCompact && /* @__PURE__ */ jsx("span", { className: "ml-1", children: "Email" })
+          ]
+        }
+      )
+    ] }),
+    support.translate && !isDraft && !isStreaming && !liveKind && !isImage && documentData?.file_name && /* @__PURE__ */ jsxs(
+      Button,
+      {
+        type: "button",
+        variant: "outline",
+        size: isCompact ? "icon" : "sm",
+        title: "Translate into another language: a new editable document, original and translation side by side",
+        "aria-label": "Translate",
+        "data-testid": "translate-document-button",
+        className: "pointer-coarse:min-h-11",
+        onClick: () => support.translate(shownRef),
+        children: [
+          /* @__PURE__ */ jsx(Languages, { className: "size-4" }),
+          !isCompact && /* @__PURE__ */ jsx("span", { className: "ml-1", children: "Translate" })
+        ]
+      }
+    ),
+    !isStreaming && !snapshotDocumentId && /* @__PURE__ */ jsx(FinaliseTranslationButton, { document: documentData ?? void 0, isCompact }),
+    annotatable && /* @__PURE__ */ jsx(
+      SignButton,
+      {
+        active: placingSignature,
+        compact: isCompact,
+        onClick: () => {
+          setAnnotating(false);
+          setSignatureFlow(null);
+          setPlacingSignature((on) => !on);
+        }
+      }
+    ),
+    annotatable && !isSigned && /* @__PURE__ */ jsx(
+      RequestSignaturesButton,
+      {
+        active: signatureFlow?.kind === "prepare",
+        compact: isCompact,
+        onClick: () => {
+          setAnnotating(false);
+          setPlacingSignature(false);
+          setSignatureFlow(signatureFlow?.kind === "prepare" ? null : { kind: "prepare" });
+        }
+      }
+    ),
+    isSignOpen && pdfBlob && /* @__PURE__ */ jsx(
+      SignDocumentDialog,
+      {
+        open: isSignOpen,
+        onOpenChange: setIsSignOpen,
+        documentId,
+        pdfBlob,
+        version: documentData?.current_version ?? void 0,
+        appearance: signAppearance
+      }
+    ),
+    headerActions
+  ] });
+  const viewerProps = {
+    currentPage: viewingDocumentPage || void 0,
+    onLoadSuccess: handleLoadSuccess,
+    scrollTrigger,
+    zoom,
+    onZoomChange: setZoom
+  };
+  return /* @__PURE__ */ jsxs(
+    ViewerFrame,
+    {
+      frameRef: containerRef,
+      contentId: documentId,
+      header: /* @__PURE__ */ jsxs(Fragment, { children: [
+        /* @__PURE__ */ jsx(
+          TabHeader,
+          {
+            tabs: [],
+            activeTabId: activeTab,
+            onTabChange: handleTabChange,
+            leftContent,
+            rightContent,
+            variant: "underline"
+          }
+        ),
+        isCompact && !isCoEditing && /* @__PURE__ */ jsx("div", { "data-slot": "viewer-title-row", className: "flex min-w-0 items-center gap-2 px-3 pb-2", children: titleBlock }),
+        snapshotDocumentId && /* @__PURE__ */ jsx(
+          VersionSnapshotBar,
+          {
+            versionNumber: snapshotNumber,
+            live: isDocx || isArtifact,
+            onAsk: support.askAboutVersion ? () => support.askAboutVersion(snapshotDocumentId) : void 0,
+            onReturn: () => setSnapshotDocumentId(null)
+          }
+        )
+      ] }),
+      compareRow: isComparing ? compareIndicator || void 0 : void 0,
+      footer: (
+        // Crop to a new document. Full resolution (no maxSize): a crop frames, it never downscales.
+        /* @__PURE__ */ jsx(
+          ImageCropModal,
+          {
+            open: crop.cropImageUrl !== null,
+            image: crop.cropImageUrl,
+            title: "Crop image",
+            saveLabel: "Save as a copy",
+            aspectOptions: DEFAULT_ASPECT_OPTIONS,
+            output: { mimeType: "image/png" },
+            onComplete: crop.handleCropComplete,
+            onCancel: crop.closeCrop
+          }
+        )
+      ),
+      children: [
+        isComparing && /* @__PURE__ */ jsx(Suspense, { fallback: /* @__PURE__ */ jsx(ViewerMessage, { children: "Loading comparison\u2026" }), children: /* @__PURE__ */ jsx(
+          NativeDocxComparison,
+          {
+            baseId: compareDocumentId,
+            revisedId: documentId,
+            title: documentTitle
+          }
+        ) }),
+        isCaptureDraft && support.renderCaptureDraft?.(documentId),
+        !isCaptureDraft && (activeTab === "pdf" || isMedia && activeTab === "html") && !isArtifact && !isComparing && /* @__PURE__ */ jsxs(ViewerPane, { hidden: activeTab !== "pdf", children: [
+          /* @__PURE__ */ jsx(DocumentLabelBar, { summaries: labelSummaries }),
+          !isMedia && !isImage && signatureBanner,
+          activeTab === "pdf" && !isMedia && !isImage && /* @__PURE__ */ jsx(
+            MarkupNotices,
+            {
+              legacyPrompt: markup.legacyPrompt,
+              olderNote: markup.olderNote,
+              onOpenVersion: (n) => setSnapshotDocumentId(`${documentId}@v${n}`)
+            }
+          ),
+          /* @__PURE__ */ jsx(ViewerControlBar, { controls: activeTab === "pdf" && pageNav, children: /* @__PURE__ */ jsx(
+            ViewerPdfPane,
+            {
+              documentId,
+              doc,
+              pdfBlob,
+              isPdfLoading: blobs.isPdfLoading,
+              pdfError: blobs.pdfError,
+              onDownload: () => void handleDirectDownload(),
+              viewerProps,
+              signatureFlow,
+              onSignatureFlow: setSignatureFlow,
+              currentUserId,
+              placingSignature,
+              onPlacingDone: (appearance) => {
+                setPlacingSignature(false);
+                if (!appearance) return;
+                setSignAppearance(appearance);
+                setIsSignOpen(true);
+              },
+              annotating,
+              markup,
+              pdfSnapshotNumber,
+              isSigned
+            }
+          ) })
+        ] }),
+        activeTab === "preview" && isArtifact && liveKind && // The preview loads its JSX compiler on first use, so it stays out of the main bundle.
+        /* @__PURE__ */ jsx(
+          ArtifactPreview,
+          {
+            kind: liveKind,
+            source: liveSource,
+            isStreaming,
+            runtimeUrl: artifactRuntimeUrl
+          }
+        ),
+        activeTab === "edit" && isArtifact && liveKind && /* @__PURE__ */ jsx(ArtifactCodeView, { source: liveSource, fileName: documentData?.file_name ?? void 0 }),
+        activeTab === "edit" && isArtifact && !liveKind && !isStreaming && !isComparing && /* @__PURE__ */ jsxs(Suspense, { fallback: /* @__PURE__ */ jsx(ViewerMessage, { children: "Loading editor\u2026" }), children: [
+          isSigned && !snapshotDocumentId && /* @__PURE__ */ jsx(SignedEditNote, {}),
+          /* @__PURE__ */ jsx(
+            NativeDocxEditor,
+            {
+              documentId: snapshotDocumentId || documentId,
+              title: documentTitle,
+              draftContent: isDraft ? draftDoc?.content || "" : void 0,
+              snapshot: !!snapshotDocumentId,
+              onSaved: (id) => {
+                if (!isDraft) return;
+                support.onDraftSaved?.(documentId, id);
+                setViewingDocumentId(id);
+              }
+            },
+            `${snapshotDocumentId || documentId}-${snapshotDocumentId ? "snapshot" : "live"}`
+          )
+        ] }),
+        activeTab === "versions" && (isArtifact || isDocx || hasHistory) && !isComparing && /* @__PURE__ */ jsx(
+          VersionTimeline,
+          {
+            versions: versions.map((v) => ({
+              ...v,
+              madeIn: v.thread ? {
+                label: threadTitle(v.thread.conversationId),
+                onOpen: () => openConversation(v.thread.conversationId, {
+                  messageId: v.thread.messageId ?? void 0
+                })
+              } : null
+            })),
+            currentId: currentVersionId,
+            live: !!liveKind,
+            labels: isArtifact ? void 0 : { emptyDocument: UPLOADED_NO_VERSIONS },
+            formatDate,
+            onOpen: (id) => {
+              setSnapshotDocumentId(id === currentVersionId ? null : id);
+              setActiveTab(isArtifact ? "edit" : isDocx ? "docx" : "pdf");
+            },
+            onCompare: (id) => session.setDocumentViewer({ compareId: id, tab: "html" }),
+            translations,
+            onOpenTranslation: (id) => setViewingDocumentId(id)
+          }
+        ),
+        activeTab === "xlsx" && isXlsx && (xlsxBlob ? /* @__PURE__ */ jsx(XlsxViewer, { blob: xlsxBlob }) : /* @__PURE__ */ jsx(ViewerMessage, { children: xlsxError ? "Failed to load spreadsheet" : "Loading spreadsheet..." })),
+        activeTab === "docx" && isDocx && !isComparing && /* @__PURE__ */ jsxs(Suspense, { fallback: /* @__PURE__ */ jsx(ViewerMessage, { children: "Loading editor\u2026" }), children: [
+          signatureBanner,
+          isSigned && !snapshotDocumentId && /* @__PURE__ */ jsx(SignedEditNote, {}),
+          /* @__PURE__ */ jsx(
+            NativeDocxEditor,
+            {
+              documentId: snapshotDocumentId || documentId,
+              title: documentTitle,
+              snapshot: !!snapshotDocumentId
+            },
+            `${snapshotDocumentId || documentId}-${snapshotDocumentId ? "snapshot" : "live"}`
+          )
+        ] }),
+        streamingDoc && isStreaming && isArtifact && !liveKind && !isComparing && (activeTab === "html" || activeTab === "edit") && /* @__PURE__ */ jsx(Suspense, { fallback: /* @__PURE__ */ jsx(ViewerMessage, { children: "Opening draft\u2026" }), children: /* @__PURE__ */ jsx(
+          StreamedWordArtifact,
+          {
+            documentId: documentId.startsWith("doc-") ? documentId : void 0,
+            title: documentTitle,
+            content: streamingDoc.content,
+            busy: isStreaming
+          },
+          documentId
+        ) }),
+        !isCaptureDraft && !isComparing && activeTab === "html" && !(isStreaming && isArtifact && !liveKind) && /* @__PURE__ */ jsx(ViewerPane, { children: /* @__PURE__ */ jsx(ViewerControlBar, { controls: pageNav, children: /* @__PURE__ */ jsx(
+          ParsedTextView,
+          {
+            documentId: pdfSnapshotId || documentId,
+            onLoadSuccess: handleLoadSuccess,
+            scrollTrigger,
+            zoom,
+            onZoomChange: setZoom
+          }
+        ) }) })
+      ]
+    }
+  );
+}
+
+export { ConnectedDocumentToolsProvider, ConnectedDocumentViewer };
+//# sourceMappingURL=viewer.js.map
+//# sourceMappingURL=viewer.js.map