@arbidocs/blocks 0.4.147 → 0.4.150

package/dist/connect/viewer.js

@@ -0,0 +1,1226 @@
+"use client";
+import { ViewerTitle, ViewerTabBar, ViewerImageActions, ViewerFrame, ViewerMessage, DocumentLabelBar, ViewerControlBar, ViewerZoomControl, PdfPageNav, ViewerPageCounter, summariseDocTags, isDocumentLabel, ViewerPreviewUnavailable, ViewerLoadError } from '../chunk-TC25LGIM.js';
+import { useDocumentViewerSupport } from '../chunk-XRWHFMHK.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 '../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 { useBlocksEnvironment } from '../chunk-TBEVGWY3.js';
+import '../chunk-TX2ZICS7.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 { fmtDate } from '../chunk-OXF2IFXG.js';
+import '../chunk-VUNV25KB.js';
+import { 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 } 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, PdfViewer } from '@arbidocs/react/viewers';
+import { Button, getEntityLabel, isImageFile, isVideoFile, isAudioFile, isDownloadOnlyFile, friendlyFileType } 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,
+  isCompact
+}) {
+  const finalise = useFinaliseTranslation();
+  const { openDocument } = useDocumentTools();
+  const { notify } = useBlocksEnvironment();
+  if (!document || !isTranslationDraft(document)) return null;
+  const pending = finalise.isPending;
+  const onClick = async () => {
+    try {
+      const { document_ext_id: finalId } = await finalise.mutateAsync(document.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 };
+}
+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-IPEZDERL.js').then((m) => ({
+    default: m.ConnectedNativeDocxEditor
+  }))
+);
+var StreamedWordArtifact = lazy(
+  () => import('../ConnectedStreamedWordArtifact-UZVNBKQB.js').then((m) => ({
+    default: m.ConnectedStreamedWordArtifact
+  }))
+);
+var NativeDocxComparison = lazy(
+  () => import('../ConnectedNativeDocxComparison-XQSXVGHR.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) && support.renderParsedView && /* @__PURE__ */ jsx(ViewerPane, { children: /* @__PURE__ */ jsx(ViewerControlBar, { controls: pageNav, children: support.renderParsedView({
+          documentId: pdfSnapshotId || documentId,
+          onLoadSuccess: handleLoadSuccess,
+          scrollTrigger,
+          zoom,
+          onZoomChange: setZoom
+        }) }) })
+      ]
+    }
+  );
+}
+
+export { ConnectedDocumentToolsProvider, ConnectedDocumentViewer };
+//# sourceMappingURL=viewer.js.map
+//# sourceMappingURL=viewer.js.map