@a3s-lab/office 0.2.2 → 0.4.0

package/dist/0~pdf-viewer.js

@@ -1,12 +1,13 @@
 import { __webpack_require__ } from "./0~rslib-runtime.js";
 import { Fragment, jsx, jsxs } from "react/jsx-runtime";
-import { AnnotationPlugin, DocumentManagerPlugin, ExportPlugin, HistoryPlugin, PDFViewer, ScrollPlugin, SearchPlugin, ThumbnailPlugin, ZoomMode, ZoomPlugin } from "@embedpdf/react-pdf-viewer";
+import { AnnotationPlugin, DocumentManagerPlugin, ExportPlugin, FormPlugin, HistoryPlugin, PDFViewer, PdfAnnotationSubtype, ScrollPlugin, SearchPlugin, ThumbnailPlugin, ViewportPlugin, ZoomMode, ZoomPlugin } from "@embedpdf/react-pdf-viewer";
 import { AlertCircle, Check, ChevronDown, ChevronLeft, ChevronRight, ChevronUp, Ellipsis, GalleryVerticalEnd, Highlighter, Loader2, Minus, MousePointer2, MoveHorizontal, Pencil, Plus, Redo2, Save, Scan, Search, SlidersHorizontal, Strikethrough, Trash2, Type, Underline, Undo2, X } from "lucide-react";
 import { useCallback, useEffect, useId, useLayoutEffect, useMemo, useRef, useState } from "react";
+import { readOfficePdfCollaborationSource as readWorkOfficePdfCollaborationSource, createOfficePdfCollaborationBinding as createWorkOfficePdfCollaborationBinding, assertPdfCollaborationSource as assertWorkOfficePdfCollaborationSource } from "./3818.js";
 import { createOfficeEditorExtension, useOfficeEditorRuntime, useOfficeEditorKeyboardShortcuts } from "./0~3557.js";
 import { isOfficeShortcutBlocked, OfficeColorPicker } from "./0~3635.js";
-import { button_Button, moveOfficeMenuFocus, icon_button_IconButton, office_text_field_OfficeTextField, Popover, useDialogFocusScope, useOfficeEditorWheelZoom } from "./0~9512.js";
-import { StateView } from "./432.js";
+import { officePresenceColorStyle, moveOfficeMenuFocus, useOfficeRemoteParticipants, WorkOfficeCollaborationParticipants, Popover, OfficePresenceAvatar, useOfficePublishPresenceLocation, button_Button, icon_button_IconButton, office_text_field_OfficeTextField, useDialogFocusScope, useOfficeEditorWheelZoom } from "./0~6090.js";
+import { StateView, useOfficeCollaborationLocationNavigator, PDF_EVIDENCE_COORDINATE_BASIS } from "./432.js";
 var pdf_viewer_namespaceObject = {};
 __webpack_require__.r(pdf_viewer_namespaceObject);
 __webpack_require__.d(pdf_viewer_namespaceObject, {
@@ -92,6 +93,25 @@ function usePdfAnnotationController(registry) {
                 })));
         if (deletions.length > 0) scope.deleteAnnotations(deletions);
     }, []);
+    const getSelectionLocation = useCallback(()=>{
+        const scope = activeAnnotationScope(capabilitiesRef.current);
+        const selected = safely(()=>scope?.getSelectedAnnotations());
+        if (selected?.length !== 1 || !selected[0]) return null;
+        return {
+            annotationId: selected[0].object.id,
+            pageIndex: selected[0].object.pageIndex
+        };
+    }, []);
+    const locateAnnotation = useCallback((pageIndex, annotationId)=>{
+        const scope = activeAnnotationScope(capabilitiesRef.current);
+        if (!scope) return false;
+        const annotation = safely(()=>scope.getAnnotationById(annotationId));
+        if (!annotation || annotation.object.pageIndex !== pageIndex) return false;
+        return Boolean(safely(()=>{
+            scope.selectAnnotation(pageIndex, annotationId);
+            return true;
+        }));
+    }, []);
     const setAnnotationColor = useCallback((color)=>{
         const normalizedColor = normalizeAnnotationColor(color);
         const capabilities = capabilitiesRef.current;
@@ -133,12 +153,16 @@ function usePdfAnnotationController(registry) {
     return useMemo(()=>({
             state,
             deleteSelection,
+            getSelectionLocation,
+            locateAnnotation,
             setAnnotationColor,
             setAnnotationOpacity,
             setAnnotationStrokeWidth,
             selectTool
         }), [
         deleteSelection,
+        getSelectionLocation,
+        locateAnnotation,
         setAnnotationColor,
         setAnnotationOpacity,
         setAnnotationStrokeWidth,
@@ -238,6 +262,457 @@ function safely(action) {
         return;
     }
 }
+const COLLABORATIVE_PDF_ANNOTATION_TYPES = new Set([
+    PdfAnnotationSubtype.FREETEXT,
+    PdfAnnotationSubtype.HIGHLIGHT,
+    PdfAnnotationSubtype.UNDERLINE,
+    PdfAnnotationSubtype.STRIKEOUT,
+    PdfAnnotationSubtype.INK
+]);
+function createWorkPdfCollaborationProjection(registry, session) {
+    const binding = createWorkOfficePdfCollaborationBinding(session);
+    const initialization = new AbortController();
+    let destroyed = false;
+    let failed = false;
+    let failure;
+    let projecting = false;
+    let scopes = null;
+    let previousRecords = new Map();
+    const pendingAnnotations = new Map();
+    let pendingFormValues = null;
+    const errorListeners = new Set();
+    const stop = [];
+    const close = ()=>{
+        initialization.abort();
+        scopes = null;
+        pendingAnnotations.clear();
+        pendingFormValues = null;
+        for (const unsubscribe of stop.splice(0))unsubscribe();
+        try {
+            binding.destroy();
+        } catch  {}
+    };
+    const reportError = (error)=>{
+        if (destroyed || failed) return;
+        failed = true;
+        failure = error;
+        close();
+        for (const listener of errorListeners)listener(error);
+    };
+    const project = (content)=>{
+        if (!scopes || destroyed || failed) return;
+        projecting = true;
+        try {
+            projectAnnotations(scopes.annotations, scopes.baseAnnotations, previousRecords, content.annotations, pendingAnnotations);
+            previousRecords = new Map(content.annotations.map((record)=>[
+                    record.id,
+                    record
+                ]));
+            const projectedFormValues = projectedPdfFormValues(scopes.form, scopes.baseFormValues, content.formValues);
+            if (projectedFormValues && scopes.form) {
+                pendingFormValues = projectedFormValues.expected;
+                applyPdfFormValues(scopes.form, projectedFormValues.updates, reportError);
+            }
+            purgeViewerHistory(scopes.history);
+        } finally{
+            projecting = false;
+        }
+    };
+    const ready = registry.pluginsReady().then(async ()=>{
+        if (destroyed || failed) return;
+        const plugins = pdfProjectionPlugins(registry);
+        const annotationsLoaded = await waitForPdfAnnotationsLoaded(registry, plugins, initialization.signal);
+        if (!annotationsLoaded || destroyed || failed) return;
+        scopes = pdfProjectionScopes(plugins);
+        const activeScopes = scopes;
+        stop.push(activeScopes.annotations.onAnnotationEvent((event)=>{
+            if (destroyed || projecting || 'loaded' === event.type) return;
+            if (!event.committed || event.documentId !== activeScopes.documentId) return;
+            try {
+                const pending = pendingAnnotations.get(event.annotation.id);
+                if (projectedAnnotationEventMatches(pending, event)) {
+                    pendingAnnotations.delete(event.annotation.id);
+                    purgeViewerHistory(activeScopes.history);
+                    return;
+                }
+                commitAnnotationEvent(binding, event);
+                purgeViewerHistory(activeScopes.history);
+            } catch (error) {
+                reportError(error);
+            }
+        }));
+        if (activeScopes.form) {
+            const form = activeScopes.form;
+            stop.push(form.onFieldValueChange(()=>{
+                if (destroyed || projecting) return;
+                try {
+                    const values = form.getFormValues();
+                    if (pendingFormValues) {
+                        if (pdfJsonEqual(values, pendingFormValues)) {
+                            pendingFormValues = null;
+                            purgeViewerHistory(activeScopes.history);
+                        }
+                        return;
+                    }
+                    commitFormValues(binding, activeScopes.baseFormValues, form, values);
+                    purgeViewerHistory(activeScopes.history);
+                } catch (error) {
+                    reportError(error);
+                }
+            }));
+            stop.push(form.onFormReady(()=>{
+                if (destroyed) return;
+                try {
+                    const projectedFormValues = projectedPdfFormValues(form, activeScopes.baseFormValues, binding.content().formValues);
+                    if (projectedFormValues) {
+                        pendingFormValues = projectedFormValues.expected;
+                        applyPdfFormValues(form, projectedFormValues.updates, reportError);
+                    }
+                    purgeViewerHistory(activeScopes.history);
+                } catch (error) {
+                    reportError(error);
+                }
+            }));
+        }
+        project(binding.content());
+    }).catch((error)=>{
+        reportError(error);
+        throw error;
+    });
+    stop.push(binding.subscribe(({ content })=>{
+        project(content);
+    }));
+    stop.push(binding.subscribeError(reportError));
+    return {
+        binding,
+        ready,
+        subscribeError (listener) {
+            if (failed) {
+                queueMicrotask(()=>listener(failure));
+                return ()=>void 0;
+            }
+            errorListeners.add(listener);
+            return ()=>errorListeners.delete(listener);
+        },
+        destroy () {
+            if (destroyed) return;
+            destroyed = true;
+            close();
+            errorListeners.clear();
+        }
+    };
+}
+function pdfProjectionPlugins(registry) {
+    const annotation = registry.getPlugin(AnnotationPlugin.id)?.provides();
+    const documentId = registry.getPlugin(DocumentManagerPlugin.id)?.provides().getActiveDocumentId();
+    if (!annotation || !documentId) throw new Error('PDF collaboration requires an open EmbedPDF annotation document.');
+    const form = registry.getPlugin(FormPlugin.id)?.provides().forDocument(documentId) ?? null;
+    const history = registry.getPlugin(HistoryPlugin.id)?.provides().forDocument(documentId) ?? null;
+    return {
+        annotation,
+        documentId,
+        form,
+        history
+    };
+}
+function pdfProjectionScopes({ annotation, documentId, form, history }) {
+    const annotations = annotation.forDocument(documentId);
+    return {
+        annotations,
+        baseAnnotations: new Map(annotations.getAnnotations().map(({ object })=>[
+                object.id,
+                viewerAnnotation(portableViewerAnnotation(object))
+            ])),
+        baseFormValues: form?.getFormValues() ?? {},
+        documentId,
+        form,
+        history
+    };
+}
+async function waitForPdfAnnotationsLoaded(registry, { annotation, documentId }, signal) {
+    if (signal.aborted) return false;
+    const document1 = registry.getPlugin(DocumentManagerPlugin.id)?.provides().getDocument(documentId);
+    if (!document1) throw new Error('PDF collaboration requires an open EmbedPDF annotation document.');
+    const scope = annotation.forDocument(documentId);
+    let resolveLoaded = ()=>void 0;
+    const loaded = new Promise((resolve)=>{
+        resolveLoaded = resolve;
+    });
+    const stopLoaded = scope.onAnnotationEvent((event)=>{
+        if ('loaded' === event.type && event.documentId === documentId) resolveLoaded();
+    });
+    let resolveAborted = ()=>void 0;
+    const aborted = new Promise((resolve)=>{
+        resolveAborted = resolve;
+    });
+    const onAbort = ()=>resolveAborted();
+    signal.addEventListener('abort', onAbort, {
+        once: true
+    });
+    if (signal.aborted) onAbort();
+    try {
+        const expected = await Promise.race([
+            registry.getEngine().getAllAnnotations(document1).toPromise(),
+            aborted.then(()=>null)
+        ]);
+        if (!expected || signal.aborted) return false;
+        const expectedIds = new Set(Object.values(expected).flatMap((records)=>records.map(({ id })=>id)));
+        if (pdfAnnotationIdsMatch(scope, expectedIds)) return true;
+        await Promise.race([
+            loaded,
+            aborted
+        ]);
+        if (signal.aborted) return false;
+        if (pdfAnnotationIdsMatch(scope, expectedIds)) return true;
+        throw new Error('PDF collaboration could not capture the source baseline.');
+    } finally{
+        signal.removeEventListener('abort', onAbort);
+        stopLoaded();
+    }
+}
+function pdfAnnotationIdsMatch(scope, expectedIds) {
+    const actualIds = new Set(scope.getAnnotations().map(({ object })=>object.id));
+    return expectedIds.size === actualIds.size && [
+        ...expectedIds
+    ].every((id)=>actualIds.has(id));
+}
+function purgeViewerHistory(history) {
+    history?.purgeByMetadata(()=>true);
+}
+function commitAnnotationEvent(binding, event) {
+    const previous = binding.content();
+    const current = previous.annotations.find(({ id })=>id === event.annotation.id);
+    assertCollaborativePdfAnnotation(event.annotation);
+    let annotations = previous.annotations;
+    if ('delete' === event.type) {
+        if (current?.deleted) return;
+        annotations = current ? previous.annotations.map((record)=>record.id === current.id ? {
+                ...record,
+                deleted: true
+            } : record) : [
+            ...previous.annotations,
+            {
+                id: event.annotation.id,
+                pageIndex: event.pageIndex,
+                source: 'base',
+                annotation: portableViewerAnnotation(event.annotation),
+                deleted: true
+            }
+        ];
+    } else {
+        const annotation = portableViewerAnnotation(event.annotation);
+        annotations = current ? previous.annotations.map((record)=>record.id === current.id ? {
+                ...record,
+                annotation,
+                pageIndex: event.pageIndex
+            } : record) : [
+            ...previous.annotations,
+            {
+                id: event.annotation.id,
+                pageIndex: event.pageIndex,
+                source: 'create' === event.type ? 'created' : 'base',
+                annotation
+            }
+        ];
+    }
+    binding.replace(previous, {
+        ...previous,
+        annotations
+    });
+}
+function commitFormValues(binding, baseValues, scope, values) {
+    const previous = binding.content();
+    const fields = new Map(scope.getFormFields().map((field)=>[
+            field.name,
+            field
+        ]));
+    const formValues = Object.entries(values).filter(([id, value])=>{
+        const field = fields.get(id);
+        if (!field) throw new Error(`PDF collaboration form field '${id}' does not exist.`);
+        if (field.readOnly && value !== baseValues[id]) throw new Error(`PDF collaboration form field '${id}' is read-only.`);
+        return value !== baseValues[id];
+    }).map(([id, value])=>({
+            id,
+            value
+        })).sort((left, right)=>left.id.localeCompare(right.id));
+    binding.replace(previous, {
+        ...previous,
+        formValues
+    });
+}
+function projectAnnotations(scope, baseAnnotations, previous, records, pending) {
+    assertPdfAnnotationSources(baseAnnotations, records);
+    const current = new Map(scope.getAnnotations().map(({ object })=>[
+            object.id,
+            object
+        ]));
+    const nextIds = new Set(records.map(({ id })=>id));
+    for (const [id, record] of previous){
+        if (nextIds.has(id)) continue;
+        const existing = current.get(id);
+        if ('created' === record.source) {
+            if (existing) {
+                pending.set(id, {
+                    expected: 'deleted',
+                    previous: existing
+                });
+                scope.deleteAnnotation(existing.pageIndex, id);
+            }
+            continue;
+        }
+        const base = baseAnnotations.get(id);
+        if (!(!base || pdfJsonEqual(existing, base))) {
+            pending.set(id, {
+                expected: base,
+                previous: existing
+            });
+            if (existing) scope.updateAnnotation(existing.pageIndex, id, base);
+            else scope.importAnnotations([
+                {
+                    annotation: base
+                }
+            ]);
+        }
+    }
+    for (const record of records){
+        const existing = current.get(record.id);
+        if (record.deleted) {
+            if (existing) {
+                pending.set(record.id, {
+                    expected: 'deleted',
+                    previous: existing
+                });
+                scope.deleteAnnotation(existing.pageIndex, existing.id);
+            }
+            continue;
+        }
+        const expected = viewerAnnotation(record.annotation);
+        assertCollaborativePdfAnnotation(expected);
+        if (!existing) {
+            pending.set(record.id, {
+                expected
+            });
+            scope.importAnnotations([
+                {
+                    annotation: expected
+                }
+            ]);
+            continue;
+        }
+        if (!projectedPdfAnnotationEqual(existing, expected, 'base' === record.source ? baseAnnotations.get(record.id) : void 0)) {
+            pending.set(record.id, {
+                expected,
+                previous: existing
+            });
+            scope.updateAnnotation(existing.pageIndex, existing.id, {
+                ...expected,
+                id: existing.id,
+                pageIndex: existing.pageIndex
+            });
+        }
+    }
+}
+function assertPdfAnnotationSources(baseAnnotations, records) {
+    for (const record of records){
+        const inSource = baseAnnotations.has(record.id);
+        if ('base' === record.source && !inSource) throw new Error(`PDF collaboration base annotation '${record.id}' does not exist in the source PDF.`);
+        if ('created' === record.source && inSource) throw new Error(`PDF collaboration annotation '${record.id}' conflicts with a source annotation.`);
+        const base = baseAnnotations.get(record.id);
+        if (base && (base.pageIndex !== record.pageIndex || base.type !== record.annotation.type)) throw new Error(`PDF collaboration base annotation '${record.id}' has a different source identity.`);
+    }
+}
+function assertCollaborativePdfAnnotation(annotation) {
+    if (COLLABORATIVE_PDF_ANNOTATION_TYPES.has(annotation.type)) return;
+    throw new Error(`PDF collaboration does not support annotation type '${annotation.type}'.`);
+}
+function projectedPdfFormValues(scope, baseValues, records) {
+    if (!scope) return null;
+    const fields = new Map(scope.getFormFields().map((field)=>[
+            field.name,
+            field
+        ]));
+    for (const { id, value } of records){
+        const field = fields.get(id);
+        if (!field) throw new Error(`PDF collaboration form field '${id}' does not exist.`);
+        if (field.readOnly && value !== baseValues[id]) throw new Error(`PDF collaboration form field '${id}' is read-only.`);
+    }
+    const expected = {
+        ...baseValues,
+        ...Object.fromEntries(records.map(({ id, value })=>[
+                id,
+                value
+            ]))
+    };
+    const current = scope.getFormValues();
+    const updates = Object.fromEntries(Object.entries(expected).filter(([id, value])=>current[id] !== value));
+    if (0 === Object.keys(updates).length) return null;
+    return {
+        expected,
+        updates
+    };
+}
+function applyPdfFormValues(scope, values, onError) {
+    scope.setFormValues(values).toPromise().catch(onError);
+}
+function projectedAnnotationEventMatches(pending, event) {
+    if (void 0 === pending) return false;
+    if ('deleted' === pending.expected) return 'delete' === event.type;
+    return 'delete' !== event.type && projectedPdfAnnotationEqual(event.annotation, pending.expected, pending.previous);
+}
+function projectedPdfAnnotationEqual(actual, expected, previous) {
+    const normalizedActual = portableViewerAnnotation(actual);
+    const normalizedExpected = portableViewerAnnotation(expected);
+    const normalizedPrevious = previous ? portableViewerAnnotation(previous) : void 0;
+    for (const key of Object.keys(normalizedActual))if (!Object.hasOwn(normalizedExpected, key)) {
+        if ('author' === key || normalizedPrevious && Object.hasOwn(normalizedPrevious, key) && pdfJsonEqual(normalizedActual[key], normalizedPrevious[key])) delete normalizedActual[key];
+    }
+    return pdfJsonEqual(normalizedActual, normalizedExpected);
+}
+function portableViewerAnnotation(annotation) {
+    return clonePdfValue(annotation);
+}
+function viewerAnnotation(annotation) {
+    return revivePdfDates(annotation);
+}
+function clonePdfValue(value) {
+    if (value instanceof Date) return value.toISOString();
+    if (Array.isArray(value)) return value.map(clonePdfValue);
+    if (!value || 'object' != typeof value) return value;
+    return Object.fromEntries(Object.entries(value).flatMap(([key, child])=>void 0 === child ? [] : [
+            [
+                key,
+                clonePdfValue(child)
+            ]
+        ]));
+}
+function revivePdfDates(value, key) {
+    if (Array.isArray(value)) return value.map((child)=>revivePdfDates(child));
+    if (!value || 'object' != typeof value) {
+        if (('created' === key || 'modified' === key) && 'string' == typeof value) {
+            const timestamp = Date.parse(value);
+            if (Number.isFinite(timestamp)) return new Date(timestamp);
+        }
+        return value;
+    }
+    return Object.fromEntries(Object.entries(value).map(([childKey, child])=>[
+            childKey,
+            revivePdfDates(child, childKey)
+        ]));
+}
+function pdfJsonEqual(left, right) {
+    return canonicalPdfJson(left) === canonicalPdfJson(right);
+}
+function canonicalPdfJson(value) {
+    return JSON.stringify(sortPdfJson(clonePdfValue(value)));
+}
+function sortPdfJson(value) {
+    if (Array.isArray(value)) return value.map(sortPdfJson);
+    if (!value || 'object' != typeof value) return value;
+    return Object.fromEntries(Object.entries(value).sort(([left], [right])=>left.localeCompare(right)).map(([key, child])=>[
+            key,
+            sortPdfJson(child)
+        ]));
+}
 function createPdfEditorExtensions() {
     return [
         createOfficeEditorExtension({
@@ -406,6 +881,353 @@ function canZoom(viewer) {
 function canSave({ editable, save, viewer }) {
     return editable && save.enabled && documentReady(viewer) && viewer.state.features.export;
 }
+function PdfCollaborationPresenceLayer({ pageIndex }) {
+    const participants = useOfficeRemoteParticipants().filter((participant)=>participant.location?.kind === 'pdf' && participant.location.pageIndex === pageIndex);
+    if (!participants.length) return null;
+    return /*#__PURE__*/ jsx("div", {
+        className: "work-pdf-remote-presence-layer",
+        "data-pdf-presence-page": pageIndex,
+        "aria-hidden": "true",
+        children: participants.map((participant)=>{
+            const location = participant.location;
+            if (location?.kind !== 'pdf') return null;
+            return /*#__PURE__*/ jsxs("span", {
+                className: "work-pdf-remote-participant",
+                "data-activity": participant.activity,
+                "data-annotation-id": location.annotationId,
+                "data-participant-id": participant.actor.id,
+                style: officePresenceColorStyle(participant),
+                children: [
+                    /*#__PURE__*/ jsx(OfficePresenceAvatar, {
+                        compact: true,
+                        participant: participant
+                    }),
+                    /*#__PURE__*/ jsxs("span", {
+                        children: [
+                            /*#__PURE__*/ jsx("strong", {
+                                children: participant.actor.name
+                            }),
+                            /*#__PURE__*/ jsx("small", {
+                                children: location.annotationId ? '正在查看批注' : '正在查看此页'
+                            })
+                        ]
+                    })
+                ]
+            }, participant.presenceId);
+        })
+    });
+}
+const MAX_EVIDENCE_REGIONS_PER_PAGE = 2000;
+const MAX_REGION_TARGETS = 128;
+const MAX_ID_LENGTH = 512;
+const PAGE_ASPECT_RATIO_TOLERANCE = 0.005;
+function PdfEvidenceOverlayLayer({ currentPage, evidenceOverlay, onEvidenceRegionSelect, registry, selectedEvidenceRegionId, sourceKey }) {
+    const [runtime, setRuntime] = useState(null);
+    const [pageState, setPageState] = useState({
+        status: 'idle'
+    });
+    const [viewportRevision, setViewportRevision] = useState(0);
+    const lastNavigationRef = useRef(null);
+    useEffect(()=>{
+        let disposed = false;
+        registry.pluginsReady().then(()=>{
+            if (!disposed) setRuntime(readEvidenceRuntime(registry));
+        }).catch((error)=>{
+            if (!disposed) setPageState({
+                message: evidenceErrorMessage(error),
+                status: 'error'
+            });
+        });
+        return ()=>{
+            disposed = true;
+        };
+    }, [
+        registry
+    ]);
+    useEffect(()=>{
+        if (!runtime) return;
+        let frame = 0;
+        const update = ()=>{
+            if (frame) return;
+            frame = window.requestAnimationFrame(()=>{
+                frame = 0;
+                setViewportRevision((value)=>value + 1);
+            });
+        };
+        const unsubscribe = [
+            runtime.scroll.onScroll(()=>update()),
+            runtime.scroll.onLayoutChange(()=>update()),
+            runtime.viewport.onScrollChange(()=>update()),
+            runtime.viewport.onViewportResize(()=>update()),
+            runtime.zoom?.onStateChange(()=>update())
+        ].filter((stop)=>Boolean(stop));
+        return ()=>{
+            if (frame) window.cancelAnimationFrame(frame);
+            for (const stop of unsubscribe)stop();
+        };
+    }, [
+        runtime
+    ]);
+    useEffect(()=>{
+        const abort = new AbortController();
+        if (!runtime || currentPage < 1) {
+            setPageState({
+                status: 'idle'
+            });
+            return ()=>abort.abort();
+        }
+        const identityError = validateOverlayIdentity(evidenceOverlay, sourceKey);
+        if (identityError) {
+            setPageState({
+                message: identityError,
+                status: 'error'
+            });
+            return ()=>abort.abort();
+        }
+        setPageState({
+            status: 'loading'
+        });
+        evidenceOverlay.loadPage(currentPage, abort.signal).then((page)=>{
+            if (abort.signal.aborted) return;
+            if (page) validatePdfEvidencePage(page, evidenceOverlay, runtime, currentPage);
+            setPageState({
+                page,
+                status: 'ready'
+            });
+        }).catch((error)=>{
+            if (!abort.signal.aborted) setPageState({
+                message: evidenceErrorMessage(error),
+                status: 'error'
+            });
+        });
+        return ()=>abort.abort();
+    }, [
+        currentPage,
+        evidenceOverlay,
+        runtime,
+        sourceKey
+    ]);
+    const page = 'ready' === pageState.status ? pageState.page : null;
+    const regions = useMemo(()=>page && runtime ? positionEvidenceRegions(page, runtime, viewportRevision) : [], [
+        page,
+        runtime,
+        viewportRevision
+    ]);
+    useEffect(()=>{
+        if (!runtime || !page || !selectedEvidenceRegionId) return;
+        const selected = page.regions.find((region)=>region.id === selectedEvidenceRegionId);
+        if (!selected) return;
+        const navigationKey = `${page.pageNumber}:${selected.id}`;
+        if (lastNavigationRef.current === navigationKey) return;
+        lastNavigationRef.current = navigationKey;
+        scrollEvidenceRegionIntoView(runtime, page, selected);
+    }, [
+        page,
+        runtime,
+        selectedEvidenceRegionId
+    ]);
+    useEffect(()=>{
+        if (!runtime || !selectedEvidenceRegionId || !evidenceOverlay.locateRegion || page?.regions.some((region)=>region.id === selectedEvidenceRegionId)) return;
+        const abort = new AbortController();
+        evidenceOverlay.locateRegion(selectedEvidenceRegionId, abort.signal).then((location)=>{
+            if (!abort.signal.aborted && location && location.pageNumber !== currentPage) scrollToEvidencePage(runtime, location.pageNumber);
+        }).catch(()=>void 0);
+        return ()=>abort.abort();
+    }, [
+        currentPage,
+        evidenceOverlay,
+        page,
+        runtime,
+        selectedEvidenceRegionId
+    ]);
+    if ('error' === pageState.status) return /*#__PURE__*/ jsx("div", {
+        className: "work-pdf-evidence-status",
+        role: "status",
+        title: pageState.message,
+        children: "当前页定位不可用"
+    });
+    if ('ready' === pageState.status && !pageState.page) return /*#__PURE__*/ jsx("div", {
+        className: "work-pdf-evidence-status",
+        role: "status",
+        children: "当前页暂无安全定位"
+    });
+    if (!page || 0 === regions.length) return null;
+    return /*#__PURE__*/ jsx("fieldset", {
+        className: "work-pdf-evidence-overlay",
+        "aria-label": "解析证据定位",
+        children: regions.map(({ region, style })=>{
+            const selected = region.id === selectedEvidenceRegionId;
+            return /*#__PURE__*/ jsx("button", {
+                type: "button",
+                className: "work-pdf-evidence-region",
+                "data-selected": selected || void 0,
+                style: style,
+                "aria-label": region.label ?? `解析区域 ${region.id}`,
+                "aria-pressed": selected,
+                title: region.label,
+                onClick: ()=>onEvidenceRegionSelect?.(region)
+            }, region.id);
+        })
+    });
+}
+function readEvidenceRuntime(registry) {
+    const documentManager = registry.getPlugin(DocumentManagerPlugin.id)?.provides();
+    const scroll = registry.getPlugin(ScrollPlugin.id)?.provides();
+    const viewport = registry.getPlugin(ViewportPlugin.id)?.provides();
+    if (!documentManager || !scroll || !viewport) throw new Error('Required PDF evidence capabilities are unavailable.');
+    return {
+        documentManager,
+        scroll,
+        viewport,
+        zoom: registry.getPlugin(ZoomPlugin.id)?.provides() ?? null
+    };
+}
+function validateOverlayIdentity(overlay, sourceKey) {
+    if (!sourceKey || sourceKey !== overlay.sourceSha256) return 'The evidence source identity does not match the PDF source.';
+    if (!isSha256(overlay.sourceSha256) || !isSha256(overlay.renderProfileSha256)) return 'The evidence overlay contains an invalid SHA-256 identity.';
+    if (overlay.coordinateBasis !== PDF_EVIDENCE_COORDINATE_BASIS) return 'The evidence overlay uses an unsupported coordinate basis.';
+    return null;
+}
+function validatePdfEvidencePage(page, overlay, runtime, requestedPage) {
+    if (page.pageNumber !== requestedPage || page.sourceSha256 !== overlay.sourceSha256 || page.renderProfileSha256 !== overlay.renderProfileSha256 || page.coordinateBasis !== PDF_EVIDENCE_COORDINATE_BASIS || 'source' !== page.canvasKind) throw new Error('The evidence page identity is invalid.');
+    if (!boundedId(page.canvasId) || !positiveFinite(page.canvasWidth) || !positiveFinite(page.canvasHeight)) throw new Error('The evidence canvas identity or dimensions are invalid.');
+    const documentPage = runtime.documentManager.getActiveDocument()?.pages[requestedPage - 1];
+    if (!documentPage) throw new Error('The PDF page is unavailable.');
+    const expectedRotation = 90 * documentPage.rotation;
+    if (page.rotationDegrees !== expectedRotation) throw new Error('The evidence canvas rotation does not match the PDF page.');
+    const rotatedWidth = documentPage.rotation % 2 ? documentPage.size.height : documentPage.size.width;
+    const rotatedHeight = documentPage.rotation % 2 ? documentPage.size.width : documentPage.size.height;
+    const expectedRatio = rotatedWidth / rotatedHeight;
+    const evidenceRatio = page.canvasWidth / page.canvasHeight;
+    if (Math.abs(evidenceRatio / expectedRatio - 1) > PAGE_ASPECT_RATIO_TOLERANCE) throw new Error('The evidence canvas aspect ratio does not match the PDF page.');
+    if (page.regions.length > MAX_EVIDENCE_REGIONS_PER_PAGE) throw new Error('The evidence page exceeds the bounded region limit.');
+    const ids = new Set();
+    for (const region of page.regions){
+        if (!boundedId(region.id) || ids.has(region.id)) throw new Error('The evidence page contains an invalid or duplicate region identity.');
+        ids.add(region.id);
+        if (region.targetIds.length > MAX_REGION_TARGETS || 0 === region.sourceRegionIds.length || region.sourceRegionIds.length > MAX_EVIDENCE_REGIONS_PER_PAGE || region.targetIds.some((id)=>!boundedId(id)) || region.sourceRegionIds.some((id)=>!boundedId(id)) || new Set(region.targetIds).size !== region.targetIds.length || new Set(region.sourceRegionIds).size !== region.sourceRegionIds.length) throw new Error('The evidence region identity receipts are invalid.');
+        validateBounds(region.bounds);
+    }
+}
+function validateBounds(bounds) {
+    const values = [
+        bounds.left,
+        bounds.top,
+        bounds.right,
+        bounds.bottom
+    ];
+    if (values.some((value)=>!Number.isInteger(value) || value < 0 || value > PDF_EVIDENCE_COORDINATE_BASIS) || bounds.right <= bounds.left || bounds.bottom <= bounds.top) throw new Error('The evidence region bounds are invalid.');
+}
+function positionEvidenceRegions(page, runtime, _revision) {
+    const documentId = runtime.documentManager.getActiveDocumentId();
+    const documentPage = runtime.documentManager.getActiveDocument()?.pages[page.pageNumber - 1];
+    if (!documentId || !documentPage) return [];
+    const scroll = runtime.scroll.forDocument(documentId);
+    const viewport = runtime.viewport.forDocument(documentId);
+    const metrics = viewport.getMetrics();
+    const viewportGap = runtime.viewport.getViewportGap();
+    const zoom = runtime.zoom?.forDocument(documentId).getState().currentZoomLevel ?? 1;
+    const contentWidth = scroll.getLayout().totalContentSize.width;
+    const horizontalCenterOffset = pdfEvidenceHorizontalCenterOffset(metrics.clientWidth, viewportGap, contentWidth, zoom);
+    const width = documentPage.rotation % 2 ? documentPage.size.height : documentPage.size.width;
+    const height = documentPage.rotation % 2 ? documentPage.size.width : documentPage.size.height;
+    return page.regions.flatMap((region)=>{
+        const rect = pdfEvidenceBoundsToPageRect(region.bounds, width, height);
+        const positioned = scroll.getRectPositionForPage(page.pageNumber - 1, rect, void 0, 0);
+        if (!positioned) return [];
+        return [
+            {
+                region,
+                style: {
+                    height: positioned.size.height,
+                    left: positioned.origin.x + viewportGap - metrics.scrollLeft + horizontalCenterOffset + metrics.clientLeft,
+                    top: positioned.origin.y + viewportGap - metrics.scrollTop + metrics.clientTop,
+                    width: positioned.size.width
+                }
+            }
+        ];
+    });
+}
+function scrollEvidenceRegionIntoView(runtime, page, region) {
+    const documentId = runtime.documentManager.getActiveDocumentId();
+    const documentPage = runtime.documentManager.getActiveDocument()?.pages[page.pageNumber - 1];
+    if (!documentId || !documentPage) return;
+    const width = documentPage.rotation % 2 ? documentPage.size.height : documentPage.size.width;
+    const height = documentPage.rotation % 2 ? documentPage.size.width : documentPage.size.height;
+    const rect = pdfEvidenceBoundsToPageRect(region.bounds, width, height);
+    const rotatedCenter = {
+        x: rect.origin.x + rect.size.width / 2,
+        y: rect.origin.y + rect.size.height / 2
+    };
+    const pageCoordinates = pdfEvidencePointToUnrotatedPage(rotatedCenter, documentPage.size.width, documentPage.size.height, documentPage.rotation);
+    runtime.scroll.forDocument(documentId).scrollToPage({
+        alignX: 50,
+        alignY: 32,
+        behavior: 'auto',
+        pageCoordinates,
+        pageNumber: page.pageNumber
+    });
+}
+function scrollToEvidencePage(runtime, pageNumber) {
+    const documentId = runtime.documentManager.getActiveDocumentId();
+    if (!documentId || !Number.isInteger(pageNumber) || pageNumber < 1) return;
+    const scroll = runtime.scroll.forDocument(documentId);
+    if (pageNumber > scroll.getTotalPages()) return;
+    scroll.scrollToPage({
+        behavior: 'auto',
+        pageNumber
+    });
+}
+function pdfEvidenceBoundsToPageRect(bounds, width, height) {
+    return {
+        origin: {
+            x: bounds.left / PDF_EVIDENCE_COORDINATE_BASIS * width,
+            y: bounds.top / PDF_EVIDENCE_COORDINATE_BASIS * height
+        },
+        size: {
+            height: (bounds.bottom - bounds.top) / PDF_EVIDENCE_COORDINATE_BASIS * height,
+            width: (bounds.right - bounds.left) / PDF_EVIDENCE_COORDINATE_BASIS * width
+        }
+    };
+}
+function pdfEvidencePointToUnrotatedPage(point, pageWidth, pageHeight, rotation) {
+    switch(rotation){
+        case 1:
+            return {
+                x: point.y,
+                y: pageHeight - point.x
+            };
+        case 2:
+            return {
+                x: pageWidth - point.x,
+                y: pageHeight - point.y
+            };
+        case 3:
+            return {
+                x: pageWidth - point.y,
+                y: point.x
+            };
+        default:
+            return point;
+    }
+}
+function pdfEvidenceHorizontalCenterOffset(viewportClientWidth, viewportGap, contentWidth, zoom) {
+    const availableWidth = viewportClientWidth - 2 * viewportGap;
+    const renderedContentWidth = contentWidth * zoom;
+    return Math.max(0, (availableWidth - renderedContentWidth) / 2);
+}
+function boundedId(value) {
+    return value.length > 0 && value.length <= MAX_ID_LENGTH;
+}
+function positiveFinite(value) {
+    return Number.isFinite(value) && value > 0;
+}
+function isSha256(value) {
+    return /^[a-f0-9]{64}$/.test(value);
+}
+function evidenceErrorMessage(error) {
+    return error instanceof Error && error.message ? error.message : 'Unable to load PDF evidence.';
+}
 const PDF_THUMBNAIL_ITEM_HEIGHT = 190;
 const PDF_THUMBNAIL_WINDOW_THRESHOLD = 48;
 const PDF_THUMBNAIL_OVERSCAN = 5;
@@ -701,7 +1523,8 @@ const pdfKeyboardShortcuts = {
     zoomIn: 'Control+= Meta+= Control+Shift++ Meta+Shift++',
     zoomOut: 'Control+- Meta+-'
 };
-function PdfToolbar({ annotationState, can, commands, editable, pageNavigation, saveLabel, saveState, searchInputRef, state }) {
+function PdfToolbar({ annotationState, can, commands, editable, pageNavigation, saveAvailable, saveLabel, saveState, searchInputRef, state }) {
+    const showSave = saveAvailable ?? editable;
     const [pageValue, setPageValue] = useState('');
     const [searchValue, setSearchValue] = useState('');
     const cancelPageBlurCommitRef = useRef(false);
@@ -736,7 +1559,7 @@ function PdfToolbar({ annotationState, can, commands, editable, pageNavigation,
         role: "toolbar",
         "aria-label": "PDF 工具栏",
         children: [
-            editable && /*#__PURE__*/ jsxs("div", {
+            showSave && /*#__PURE__*/ jsxs("div", {
                 className: "work-pdf-toolbar-group work-pdf-save",
                 children: [
                     /*#__PURE__*/ jsxs("output", {
@@ -1106,6 +1929,9 @@ function PdfToolbar({ annotationState, can, commands, editable, pageNavigation,
                         children: "页宽"
                     })
                 ]
+            }),
+            /*#__PURE__*/ jsx(WorkOfficeCollaborationParticipants, {
+                variant: "toolbar"
             })
         ]
     });
@@ -1534,6 +2360,7 @@ function searchStatus(state) {
     if (0 === search.total) return '0 / 0';
     return `${search.activeResultIndex + 1} / ${search.total}`;
 }
+const PDF_PAGE_NAVIGATION_RETRY_MS = 500;
 const EMPTY_FEATURES = {
     export: false,
     history: false,
@@ -1562,15 +2389,20 @@ const initialPdfViewerControllerState = {
     zoomMode: null,
     zoomPercent: 100
 };
-function usePdfViewerController(registry) {
+function usePdfViewerController(registry, historyOverride) {
     const capabilitiesRef = useRef(null);
-    const pendingPageRef = useRef(null);
+    const pendingPageRef = useRef({
+        page: null,
+        retryTimer: null
+    });
     const [state, setState] = useState(initialPdfViewerControllerState);
+    const historyOverrideRef = useRef(historyOverride);
+    historyOverrideRef.current = historyOverride;
     useEffect(()=>{
         let disposed = false;
         const unsubscribe = [];
         capabilitiesRef.current = null;
-        pendingPageRef.current = null;
+        clearPendingPdfPageNavigation(pendingPageRef);
         setState(initialPdfViewerControllerState);
         if (!registry) return;
         registry.pluginsReady().then(()=>{
@@ -1581,7 +2413,7 @@ function usePdfViewerController(registry) {
                 if (!disposed) setState(readControllerState(capabilities));
             };
             const syncDocument = ()=>{
-                pendingPageRef.current = null;
+                clearPendingPdfPageNavigation(pendingPageRef);
                 sync();
             };
             pdf_viewer_controller_subscribe(unsubscribe, capabilities.documentManager?.onActiveDocumentChanged, syncDocument);
@@ -1591,7 +2423,7 @@ function usePdfViewerController(registry) {
             pdf_viewer_controller_subscribe(unsubscribe, capabilities.scroll?.onLayoutReady, sync);
             const stopPageChangeState = pdf_viewer_controller_safely(()=>capabilities.scroll?.onPageChangeState((event)=>{
                     if (disposed || event.state.isChanging) return;
-                    const pendingPage = pendingPageRef.current;
+                    const pendingPage = pendingPageRef.current.page;
                     if (null === pendingPage) return;
                     withActiveDocument(capabilities, ({ scroll }, documentId)=>{
                         if (event.documentId !== documentId) return;
@@ -1614,7 +2446,7 @@ function usePdfViewerController(registry) {
         return ()=>{
             disposed = true;
             capabilitiesRef.current = null;
-            pendingPageRef.current = null;
+            clearPendingPdfPageNavigation(pendingPageRef);
             for (const stop of unsubscribe)stop();
         };
     }, [
@@ -1708,11 +2540,15 @@ function usePdfViewerController(registry) {
         });
     }, []);
     const undo = useCallback(()=>{
+        const collaborationHistory = historyOverrideRef.current;
+        if (collaborationHistory) return void collaborationHistory.undo();
         withActiveDocument(capabilitiesRef.current, ({ history }, documentId)=>{
             history?.forDocument(documentId).undo();
         });
     }, []);
     const redo = useCallback(()=>{
+        const collaborationHistory = historyOverrideRef.current;
+        if (collaborationHistory) return void collaborationHistory.redo();
         withActiveDocument(capabilitiesRef.current, ({ history }, documentId)=>{
             history?.forDocument(documentId).redo();
         });
@@ -1728,8 +2564,20 @@ function usePdfViewerController(registry) {
             type: 'application/pdf'
         });
     }, []);
+    const projectedState = useMemo(()=>historyOverride ? {
+            ...state,
+            canRedo: historyOverride.canRedo,
+            canUndo: historyOverride.canUndo,
+            features: {
+                ...state.features,
+                history: true
+            }
+        } : state, [
+        historyOverride,
+        state
+    ]);
     return useMemo(()=>({
-            state,
+            state: projectedState,
             clearSearch,
             fitPage,
             fitWidth,
@@ -1745,7 +2593,7 @@ function usePdfViewerController(registry) {
             zoomIn,
             zoomOut
         }), [
-        state,
+        projectedState,
         clearSearch,
         fitPage,
         fitWidth,
@@ -1821,21 +2669,31 @@ function withActiveDocument(capabilities, action) {
     if (!capabilities || !documentId) return;
     pdf_viewer_controller_safely(()=>action(capabilities, documentId));
 }
-function requestPdfPageNavigation(scope, page, pendingPage) {
+function requestPdfPageNavigation(scope, page, pendingPage, force = false) {
     const totalPages = scope.getTotalPages();
     if (totalPages < 1 || !Number.isFinite(page)) return;
     const nextPage = Math.min(totalPages, Math.max(1, Math.round(page)));
     const pageChangeInProgress = pdf_viewer_controller_safely(()=>scope.getPageChangeState().isChanging) ?? false;
-    if (pageChangeInProgress) {
-        pendingPage.current = nextPage;
+    if (pageChangeInProgress && !force) {
+        pendingPage.current.page = nextPage;
+        pendingPage.current.retryTimer ??= setTimeout(()=>{
+            const queuedPage = pendingPage.current.page;
+            if (null === queuedPage) return;
+            requestPdfPageNavigation(scope, queuedPage, pendingPage, true);
+        }, PDF_PAGE_NAVIGATION_RETRY_MS);
         return;
     }
-    pendingPage.current = null;
+    clearPendingPdfPageNavigation(pendingPage);
     scope.scrollToPage({
         pageNumber: nextPage,
-        behavior: 'auto'
+        behavior: force ? 'instant' : 'auto'
     });
 }
+function clearPendingPdfPageNavigation(pendingPage) {
+    if (null !== pendingPage.current.retryTimer) clearTimeout(pendingPage.current.retryTimer);
+    pendingPage.current.page = null;
+    pendingPage.current.retryTimer = null;
+}
 function pdf_viewer_controller_subscribe(unsubscribe, event, listener) {
     if (!event) return;
     const stop = pdf_viewer_controller_safely(()=>event(()=>listener()));
@@ -1864,23 +2722,34 @@ const a3sPdfUiSchema = {
     overlays: {},
     selectionMenus: {}
 };
-function PdfViewer({ fileName = 'document.pdf', loadSource, onSave, saveLabel = '保存', sourceKey, wasmUrl }) {
+function PdfViewer({ collaboration, evidenceOverlay, fileName = 'document.pdf', loadSource, onCollaborationChange, onEvidenceRegionSelect, onPageChange, onSave, saveLabel = '保存', selectedEvidenceRegionId, sourceKey, wasmUrl, worker = true }) {
     const [sourceUrl, setSourceUrl] = useState(null);
     const [loadError, setLoadError] = useState(null);
     const [saveState, setSaveState] = useState('idle');
     const [retryCount, setRetryCount] = useState(0);
     const [registry, setRegistry] = useState(null);
+    const [, refreshCollaborationHistory] = useState(0);
     const [mobilePageNavigationOpen, setMobilePageNavigationOpen] = useState(false);
     const pdfRootRef = useRef(null);
     const searchInputRef = useRef(null);
     const mobilePageNavigationId = useId();
     const mobilePageNavigationToggleRef = useRef(null);
     const mobilePageNavigationCloseRef = useRef(null);
-    const controller = usePdfViewerController(registry);
+    const collaborationProjectionRef = useRef(void 0);
+    const collaborationHistory = collaboration ? {
+        canRedo: collaborationProjectionRef.current?.binding.canRedo() ?? false,
+        canUndo: collaborationProjectionRef.current?.binding.canUndo() ?? false,
+        redo: ()=>collaborationProjectionRef.current?.binding.redo(),
+        undo: ()=>collaborationProjectionRef.current?.binding.undo()
+    } : void 0;
+    const controller = usePdfViewerController(registry, collaborationHistory);
     const annotation = usePdfAnnotationController(registry);
     const viewerReady = controller.state.ready && controller.state.documentOpen;
     const mobilePageNavigationModal = usePdfMobilePageNavigationModal();
     const mobilePageNavigationModalOpen = mobilePageNavigationOpen && mobilePageNavigationModal;
+    const editable = collaboration ? 'edit' === collaboration.mode : Boolean(onSave);
+    const collaborationRef = useRef(collaboration);
+    if (collaborationRef.current !== collaboration) throw new Error('PdfViewer collaboration sessions cannot be replaced while mounted. Remount the viewer for another shared PDF.');
     const closeMobilePageNavigation = useCallback(()=>{
         setMobilePageNavigationOpen(false);
     }, []);
@@ -1902,7 +2771,9 @@ function PdfViewer({ fileName = 'document.pdf', loadSource, onSave, saveLabel =
         setSourceUrl(null);
         setLoadError(null);
         setMobilePageNavigationOpen(false);
-        loadSource().then((source)=>{
+        loadSource().then(async (source)=>{
+            if (disposed) return;
+            if (collaboration) await assertPdfCollaborationBlob(collaboration, source);
             if (disposed) return;
             objectUrl = URL.createObjectURL('application/pdf' === source.type ? source : new Blob([
                 source
@@ -1918,6 +2789,7 @@ function PdfViewer({ fileName = 'document.pdf', loadSource, onSave, saveLabel =
             if (objectUrl) URL.revokeObjectURL(objectUrl);
         };
     }, [
+        collaboration,
         loadSource,
         retryCount,
         sourceKey
@@ -1927,6 +2799,69 @@ function PdfViewer({ fileName = 'document.pdf', loadSource, onSave, saveLabel =
     }, [
         controller.state.error
     ]);
+    useEffect(()=>{
+        if (!collaboration || !viewerReady) return;
+        if (controller.state.totalPages < 1) return;
+        const expectedPages = readWorkPdfSourcePageCount(collaboration);
+        if (controller.state.totalPages !== expectedPages) {
+            setRegistry(null);
+            setLoadError(`The loaded PDF has ${controller.state.totalPages} pages, but collaboration artifact '${collaboration.artifactId}' requires ${expectedPages}.`);
+        }
+    }, [
+        collaboration,
+        controller.state.totalPages,
+        viewerReady
+    ]);
+    useEffect(()=>{
+        if (!registry || !collaboration || !viewerReady) return;
+        if (controller.state.totalPages < 1) return;
+        const expectedPages = readWorkPdfSourcePageCount(collaboration);
+        if (controller.state.totalPages !== expectedPages) return;
+        const projection = createWorkPdfCollaborationProjection(registry, collaboration);
+        collaborationProjectionRef.current = projection;
+        const handleProjectionError = (error)=>{
+            if (collaborationProjectionRef.current !== projection) return;
+            collaborationProjectionRef.current = void 0;
+            setRegistry(null);
+            setLoadError(pdfErrorMessage(error));
+        };
+        const unsubscribeError = projection.subscribeError(handleProjectionError);
+        projection.ready.catch(handleProjectionError);
+        const unsubscribeHistory = projection.binding.subscribeHistory(()=>refreshCollaborationHistory((value)=>value + 1));
+        refreshCollaborationHistory((value)=>value + 1);
+        return ()=>{
+            unsubscribeError();
+            unsubscribeHistory();
+            if (collaborationProjectionRef.current === projection) collaborationProjectionRef.current = void 0;
+            projection.destroy();
+        };
+    }, [
+        collaboration,
+        controller.state.totalPages,
+        registry,
+        viewerReady
+    ]);
+    useEffect(()=>{
+        if (!collaboration || !onCollaborationChange) return;
+        const handleUpdate = ()=>{
+            const projection = collaborationProjectionRef.current;
+            if (!projection) return;
+            queueMicrotask(()=>{
+                if (collaborationProjectionRef.current === projection) onCollaborationChange(projection.binding.content());
+            });
+        };
+        collaboration.document.on('update', handleUpdate);
+        return ()=>collaboration.document.off('update', handleUpdate);
+    }, [
+        collaboration,
+        onCollaborationChange
+    ]);
+    useEffect(()=>{
+        if (controller.state.currentPage > 0) onPageChange?.(controller.state.currentPage);
+    }, [
+        controller.state.currentPage,
+        onPageChange
+    ]);
     useEffect(()=>{
         if (!sourceUrl || viewerReady || loadError) return;
         const timeout = window.setTimeout(()=>{
@@ -1956,7 +2891,7 @@ function PdfViewer({ fileName = 'document.pdf', loadSource, onSave, saveLabel =
     const pdfExtensions = useMemo(createPdfEditorExtensions, []);
     const pdfEditor = useOfficeEditorRuntime({
         annotation,
-        editable: Boolean(onSave),
+        editable,
         focusSearch: ()=>{
             searchInputRef.current?.focus();
             searchInputRef.current?.select();
@@ -1968,6 +2903,33 @@ function PdfViewer({ fileName = 'document.pdf', loadSource, onSave, saveLabel =
         viewer: controller
     }, pdfExtensions);
     const pdfCommands = pdfEditor.commands;
+    const selectedAnnotationLocation = annotation.getSelectionLocation();
+    const pdfPresenceLocation = viewerReady && controller.state.currentPage > 0 ? {
+        kind: 'pdf',
+        pageIndex: selectedAnnotationLocation?.pageIndex ?? controller.state.currentPage - 1,
+        ...selectedAnnotationLocation ? {
+            annotationId: selectedAnnotationLocation.annotationId
+        } : {}
+    } : null;
+    useOfficePublishPresenceLocation(pdfPresenceLocation);
+    const navigateToPdfParticipant = useCallback((participant)=>{
+        const location = participant.location;
+        if (location?.kind !== 'pdf' || !viewerReady || location.pageIndex >= controller.state.totalPages) return false;
+        controller.goToPage(location.pageIndex + 1);
+        if (location.annotationId) annotation.locateAnnotation(location.pageIndex, location.annotationId);
+        requestAnimationFrame(()=>{
+            const target = pdfRootRef.current?.querySelector('.work-pdf-embed');
+            target?.focus({
+                preventScroll: true
+            });
+        });
+        return true;
+    }, [
+        annotation,
+        controller,
+        viewerReady
+    ]);
+    useOfficeCollaborationLocationNavigator(navigateToPdfParticipant);
     useOfficeEditorKeyboardShortcuts(pdfEditor, {
         capture: true,
         enabled: Boolean(sourceUrl),
@@ -2012,7 +2974,8 @@ function PdfViewer({ fileName = 'document.pdf', loadSource, onSave, saveLabel =
                 annotationState: annotation.state,
                 can: pdfEditor.can(),
                 commands: pdfCommands,
-                editable: Boolean(onSave),
+                editable: editable,
+                saveAvailable: editable && Boolean(onSave),
                 pageNavigation: viewerReady && registry && controller.state.totalPages > 0 ? {
                     controlsId: mobilePageNavigationId,
                     expanded: mobilePageNavigationOpen,
@@ -2050,8 +3013,11 @@ function PdfViewer({ fileName = 'document.pdf', loadSource, onSave, saveLabel =
                     }),
                     /*#__PURE__*/ jsxs("div", {
                         className: "work-pdf-embed",
+                        role: "application",
+                        "aria-label": "PDF 页面画布",
                         "aria-busy": !viewerReady,
                         "data-ready": viewerReady || void 0,
+                        tabIndex: 0,
                         children: [
                             /*#__PURE__*/ jsx(PDFViewer, {
                                 className: "work-pdf-native-viewer",
@@ -2061,6 +3027,7 @@ function PdfViewer({ fileName = 'document.pdf', loadSource, onSave, saveLabel =
                                 },
                                 config: {
                                     src: sourceUrl,
+                                    worker,
                                     wasmUrl: wasmUrl ?? new URL(PDFIUM_WASM_PATH, window.location.href).href,
                                     tabBar: 'never',
                                     theme: {
@@ -2102,7 +3069,7 @@ function PdfViewer({ fileName = 'document.pdf', loadSource, onSave, saveLabel =
                                         ui: null,
                                         signature: null
                                     },
-                                    disabledCategories: onSave ? void 0 : [
+                                    disabledCategories: editable ? void 0 : [
                                         'annotation',
                                         'redaction',
                                         'form',
@@ -2111,6 +3078,17 @@ function PdfViewer({ fileName = 'document.pdf', loadSource, onSave, saveLabel =
                                 },
                                 onReady: setRegistry
                             }, sourceUrl),
+                            viewerReady && controller.state.currentPage > 0 && /*#__PURE__*/ jsx(PdfCollaborationPresenceLayer, {
+                                pageIndex: controller.state.currentPage - 1
+                            }),
+                            evidenceOverlay && registry && viewerReady && /*#__PURE__*/ jsx(PdfEvidenceOverlayLayer, {
+                                currentPage: controller.state.currentPage,
+                                evidenceOverlay: evidenceOverlay,
+                                onEvidenceRegionSelect: onEvidenceRegionSelect,
+                                registry: registry,
+                                selectedEvidenceRegionId: selectedEvidenceRegionId,
+                                sourceKey: sourceKey
+                            }),
                             !viewerReady && /*#__PURE__*/ jsxs("div", {
                                 className: "work-pdf-loading",
                                 role: "status",
@@ -2133,6 +3111,20 @@ function pdfErrorMessage(error) {
     if (error instanceof Error && error.message) return error.message;
     return 'Unable to read this PDF file.';
 }
+async function assertPdfCollaborationBlob(session, source) {
+    const expected = readWorkOfficePdfCollaborationSource(session);
+    if (source.size !== expected.byteLength) throw new Error(`The loaded PDF source does not match collaboration artifact '${session.artifactId}'.`);
+    const subtle = globalThis.crypto?.subtle;
+    if (!subtle) throw new Error('SHA-256 PDF source verification is unavailable.');
+    const digest = new Uint8Array(await subtle.digest('SHA-256', await source.arrayBuffer()));
+    assertWorkOfficePdfCollaborationSource(session, {
+        ...expected,
+        sha256: Array.from(digest, (value)=>value.toString(16).padStart(2, '0')).join('')
+    });
+}
+function readWorkPdfSourcePageCount(session) {
+    return readWorkOfficePdfCollaborationSource(session).pageCount;
+}
 function usePdfMobilePageNavigationModal() {
     const [matches, setMatches] = useState(()=>pdfMediaQueryMatches(PDF_MOBILE_PAGE_NAVIGATION_QUERY));
     useEffect(()=>{