@rightkit/document-core 0.1.1 → 0.2.0

package/dist/documents/pdf/usePdfDocumentLoader.js

@@ -1,243 +0,0 @@
-import { useCallback, useEffect, useRef, useState, } from "react";
-import * as pdfjs from "pdfjs-dist";
-import { acquireResource } from "../../app/resourceCensus.js";
-import { beginPdfBench, getPdfBenchLoadMode, markPdfBenchDocumentReady, markPdfBenchError, } from "./pdfBench.js";
-import { preparePdfLoading } from "./pdfBenchTransport.js";
-import { pdfWasmUrl } from "@rightkit/pdf-ui";
-/** Benchmark-only password injection; production & manual unlocks always use the prompt. */
-export function getPdfBenchPassword() {
-    if (!import.meta.env?.DEV || import.meta.env?.VITE_PDF_BENCH_AUTOPILOT !== "1")
-        return null;
-    const password = import.meta.env?.VITE_PDF_BENCH_PASSWORD;
-    return password ? password : null;
-}
-export function usePdfDocumentLoader({ documentPath, url, initialView, pdfRef, renderedRef, slotRefs, visibleRef, restoredRef, reportReadyRef, setCurrent, setScale, setRotation, setFitMode, }) {
-    const [pdfDoc, setPdfDoc] = useState(null);
-    const [numPages, setNumPages] = useState(0);
-    const [base, setBase] = useState(null);
-    const [pageSizes, setPageSizes] = useState(new Map());
-    const [error, setError] = useState(null);
-    const [renderErrors, setRenderErrors] = useState(new Map());
-    const [pwPrompt, setPwPrompt] = useState(null);
-    const [outline, setOutline] = useState(null);
-    // The pdf.js loading task currently backing `pdfDoc`/`pdfRef.current` — either this effect's own
-    // initial-load task, or a post-commit `replaceDocument` task (§10.3 reload after Save). Whichever
-    // task is here must only be destroyed once React has committed the DIFFERENT `pdfDoc` that
-    // superseded it (the promote effect below) — destroying a task while page layers still hold the
-    // document it produced is what previously crashed the viewer to its ErrorBoundary.
-    const activeTaskRef = useRef(null);
-    // Set by `replaceDocument`, consumed by the promote effect once `pdfDoc` actually changes.
-    const pendingReplacementTaskRef = useRef(null);
-    const replaceDocument = useCallback((doc, task) => {
-        pdfRef.current = doc;
-        pendingReplacementTaskRef.current = task;
-        setPdfDoc(doc);
-    }, [pdfRef]);
-    // Promotes a pending replacement to "active" — and disposes whatever it superseded — only after
-    // React has committed `pdfDoc` to the new document. Also runs (as a no-op) after the ordinary
-    // initial load's `setPdfDoc`, since `pendingReplacementTaskRef` is still null at that point.
-    // `pdfDoc` is the intentional trigger (the effect must run after React commits the new document),
-    // not a value read inside the effect body.
-    // biome-ignore lint/correctness/useExhaustiveDependencies: see comment above.
-    useEffect(() => {
-        const pending = pendingReplacementTaskRef.current;
-        if (!pending || pending === activeTaskRef.current)
-            return;
-        const stale = activeTaskRef.current;
-        activeTaskRef.current = pending;
-        pendingReplacementTaskRef.current = null;
-        if (stale)
-            void stale.destroy();
-    }, [pdfDoc]);
-    useEffect(() => {
-        if (!url)
-            return;
-        let cancelled = false;
-        let passwordCancelled = false;
-        renderedRef.current.forEach((cleanup) => cleanup());
-        renderedRef.current.clear();
-        slotRefs.current.clear();
-        visibleRef.current.clear();
-        pdfRef.current = null;
-        restoredRef.current = false;
-        reportReadyRef.current = false;
-        setError(null);
-        setRenderErrors(new Map());
-        setNumPages(0);
-        setBase(null);
-        setPageSizes(new Map());
-        setCurrent(1);
-        setPwPrompt(null);
-        setOutline(null);
-        setPdfDoc(null);
-        const controller = new AbortController();
-        let task = null;
-        let preparedLoad = null;
-        let loadedDoc = null;
-        // One document proxy + its worker per open PDF. Released in the effect cleanup below so a
-        // cold-unmounted PDF pane provably stops counting against resident cost.
-        let releaseDocumentCensus = null;
-        let releaseWorkerCensus = null;
-        let finalized = false;
-        const finalize = () => {
-            if (finalized)
-                return;
-            finalized = true;
-            controller.abort();
-            if (preparedLoad)
-                preparedLoad.dispose();
-            else if (task)
-                void task.destroy();
-            if (activeTaskRef.current === task)
-                activeTaskRef.current = null;
-            if (pendingReplacementTaskRef.current === task)
-                pendingReplacementTaskRef.current = null;
-            releaseDocumentCensus?.();
-            releaseDocumentCensus = null;
-            releaseWorkerCensus?.();
-            releaseWorkerCensus = null;
-            if (pdfRef.current && pdfRef.current === loadedDoc)
-                pdfRef.current = null;
-        };
-        const load = async () => {
-            const mode = getPdfBenchLoadMode();
-            await beginPdfBench(documentPath, pdfjs.version, mode);
-            if (cancelled) {
-                const error = new Error("PDF load cancelled");
-                error.name = "AbortError";
-                throw error;
-            }
-            preparedLoad = await preparePdfLoading({
-                url,
-                mode,
-                signal: controller.signal,
-                wasmUrl: pdfWasmUrl(),
-            });
-            task = preparedLoad.task;
-            releaseWorkerCensus = acquireResource({
-                kind: "pdf-worker",
-                documentPath,
-                format: "pdf",
-            });
-            task.onPassword = (updatePassword, reason) => {
-                const benchPassword = getPdfBenchPassword();
-                if (benchPassword) {
-                    updatePassword(benchPassword);
-                    return;
-                }
-                setPwPrompt({
-                    retry: reason === 2,
-                    onSubmit: (pw) => {
-                        setPwPrompt(null);
-                        updatePassword(pw);
-                    },
-                    onCancel: () => {
-                        passwordCancelled = true;
-                        setPwPrompt(null);
-                        setError("Password required to open this PDF.");
-                        finalize();
-                    },
-                });
-            };
-            return preparedLoad.promise;
-        };
-        load()
-            .then(async (doc) => {
-            if (cancelled || finalized)
-                return;
-            markPdfBenchDocumentReady(documentPath);
-            setPwPrompt(null);
-            loadedDoc = doc;
-            pdfRef.current = doc;
-            activeTaskRef.current = task;
-            releaseDocumentCensus = acquireResource({
-                kind: "pdf-document",
-                documentPath,
-                format: "pdf",
-            });
-            setPdfDoc(doc);
-            setNumPages(doc.numPages);
-            doc
-                .getOutline()
-                .then((o) => {
-                if (!cancelled && !finalized)
-                    setOutline(o ?? []);
-            })
-                .catch(() => {
-                if (!cancelled && !finalized)
-                    setOutline([]);
-            });
-            const first = await doc.getPage(1);
-            const v = first.getViewport({ scale: 1 });
-            if (!cancelled && !finalized) {
-                setBase({ w: v.width, h: v.height });
-                setRotation((((initialView?.rotation ?? 0) % 360) + 360) % 360);
-                if (initialView?.fit)
-                    setFitMode(initialView.fit);
-                else if (initialView?.scale) {
-                    setScale(initialView.scale);
-                    setFitMode(null);
-                }
-            }
-        })
-            .catch((e) => {
-            if (!cancelled && !passwordCancelled && e?.name !== "AbortError") {
-                finalize();
-                if (loadedDoc) {
-                    pdfRef.current = null;
-                    setPdfDoc(null);
-                    setNumPages(0);
-                }
-                markPdfBenchError(documentPath, e);
-                setError(String(e?.message ?? e));
-            }
-        });
-        return () => {
-            cancelled = true;
-            renderedRef.current.forEach((cleanup) => cleanup());
-            renderedRef.current.clear();
-            finalize();
-            // A post-commit `replaceDocument` call may have swapped in a newer task after the initial
-            // load above finished; dispose it too (and any not-yet-promoted pending one) so a document
-            // switch/unmount can't leak its pdf.js worker.
-            if (activeTaskRef.current && activeTaskRef.current !== task) {
-                void activeTaskRef.current.destroy();
-            }
-            if (pendingReplacementTaskRef.current &&
-                pendingReplacementTaskRef.current !== activeTaskRef.current) {
-                void pendingReplacementTaskRef.current.destroy();
-            }
-            pdfRef.current = null;
-        };
-    }, [
-        documentPath,
-        url,
-        slotRefs.current.clear,
-        setScale,
-        visibleRef.current.clear,
-        setRotation,
-        setFitMode,
-        setCurrent,
-        restoredRef,
-        reportReadyRef,
-        pdfRef,
-        renderedRef.current.forEach,
-        initialView?.scale,
-        renderedRef.current.clear,
-        initialView?.rotation,
-        initialView?.fit,
-    ]);
-    return {
-        pdfDoc,
-        numPages,
-        base,
-        pageSizes,
-        setPageSizes,
-        error,
-        renderErrors,
-        setRenderErrors,
-        pwPrompt,
-        outline,
-        replaceDocument,
-    };
-}

package/dist/documents/pdf/usePdfEditSession.d.ts

@@ -1,88 +0,0 @@
-import { type InspectPdfPage, type ListPdfFonts, type PdfEditCommand, type PdfEditSession, type PdfFontCatalogEntry, type PdfPageGraph, type PdfPoint, type PdfColor, type PdfRect, type PdfSelection, type PdfTextAppearance } from "./pdfEditModel.js";
-export type PdfEditSessionTool = PdfEditSession["tool"];
-/** Bridge functions this hook needs, injected so it can be unit-tested without the real
- *  `tauriBridge.ts` (§12: real bridge lands at Dispatch D2). */
-export interface PdfEditSessionBridge {
-    inspectPdfPage: InspectPdfPage;
-    listPdfFonts: ListPdfFonts;
-}
-export interface UsePdfEditSessionOptions {
-    bridge: PdfEditSessionBridge;
-    /** Authorized path passed to `inspectPdfPage` (§5.2). */
-    sourcePath: string;
-}
-export interface PdfEditSessionController {
-    session: PdfEditSession;
-    /** Mutable latest session snapshot for async save callbacks; avoids stale render closures. */
-    sessionRef: {
-        current: PdfEditSession;
-    };
-    dirty: boolean;
-    /** Enters Edit PDF mode (§3.2). Idempotent. */
-    enterEditMode: () => void;
-    /** §3.2 "Done": commits an active valid draft, then returns to View mode. Never saves. */
-    exitEditMode: () => void;
-    setTool: (tool: PdfEditSessionTool) => void;
-    /** Selecting a new target commits any active valid draft first (§3.2 "Clicking another page
-     *  target commits active valid draft, then selects target"). */
-    selectIsland: (selection: PdfSelection) => void;
-    clearSelection: () => void;
-    /** Seeds a `sourceEdit` draft from the current selection's island text/appearance. */
-    startSourceEditDraft: (params: {
-        id: string;
-        rect: PdfRect;
-        text: string;
-        appearance: PdfTextAppearance;
-        availableBounds: PdfRect;
-    }) => void;
-    /** Seeds an `addText` draft at a clicked PDF-space anchor (§6, `PdfAddText.anchor`). */
-    startAddTextDraft: (params: {
-        id: string;
-        page: number;
-        anchor: PdfPoint;
-        rect: PdfRect;
-        appearance: PdfTextAppearance;
-    }) => void;
-    /** Seeds a persisted OCR correction overlay from recognized line geometry. */
-    startOcrEditDraft: (params: {
-        id: string;
-        page: number;
-        lineId: string;
-        rect: PdfRect;
-        text: string;
-        appearance: PdfTextAppearance;
-        coverColor: PdfColor;
-    }) => void;
-    updateDraftText: (text: string) => void;
-    updateDraftAppearance: (appearance: PdfTextAppearance) => void;
-    /** External layout measurement sets this (§3.3); this hook does not measure text itself. */
-    setDraftOverflow: (overflow: boolean) => void;
-    /** §3.2 "Clicking outside active text commits valid draft" / Done / selecting elsewhere.
-     *  No-ops when there is no draft. A no-op (unchanged) `sourceEdit` draft commits nothing —
-     *  matches §6's dirty semantics: an identical before/after would not need a history command.
-     *  Returns the command that was applied, or null if nothing was committed. */
-    commitDraft: () => PdfEditCommand | null;
-    /** §3.2 Escape: "discards active draft without a history command." */
-    cancelDraft: () => void;
-    /** Applies `command` to `sourceCommands` and recomputes `sourceDigest`. Exposed directly (not
-     *  only via `commitDraft`) so an external pdf.js command-history wrapper
-     *  (`pushSourceCommand`, pdfEditor.ts) can drive apply/undo/redo through this same session. */
-    apply: (command: PdfEditCommand) => void;
-    /** Reverts the effect of `apply(command)` — removes the command by id. */
-    revert: (command: PdfEditCommand) => void;
-    /** Called after apply/revert reached through undo/redo (§9.4 in-memory preview recompose hook).
-     *  This hook does not call `compose_pdf_preview` itself — it only tracks a subscriber list so a
-     *  caller (PdfViewer) can react to every source-history mutation. */
-    onPublish: (listener: () => void) => () => void;
-    publish: () => void;
-    /** Marks the current `sourceDigest` as saved and clears `annotationDirty` — call only after
-     *  `commit_pdf_save` succeeds (§10.3: "checkpoints sourceDigest"). */
-    checkpoint: () => void;
-    setAnnotationDirty: (dirty: boolean) => void;
-    inspectPage: (page: number) => Promise<PdfPageGraph>;
-    listFonts: () => Promise<PdfFontCatalogEntry[]>;
-    /** Resets session state to a fresh document (e.g. after `commit_pdf_save` reloads the active
-     *  document, §10.3). Clears commands, selection, draft, and checkpoints to empty history. */
-    resetForDocument: () => void;
-}
-export declare function usePdfEditSession(options: UsePdfEditSessionOptions): PdfEditSessionController;

package/dist/documents/pdf/usePdfEditSession.js

@@ -1,341 +0,0 @@
-// Edit PDF mode session state (docs/PDF-EDITOR-NOW.md §3.2, §6, §12 "usePdfEditSession.ts").
-//
-// Owns mode/tool/selection/draft lifecycle, the ordered `sourceCommands` list, and digest/dirty
-// checkpoint tracking. Does not own pdf.js's `AnnotationEditorUIManager` command history (§6.2,
-// `pushSourceCommand` in pdfEditor.ts) or the real Tauri bridge (`tauriBridge.ts`, Dispatch D2) —
-// this hook accepts bridge functions as injected parameters (§12's "injected-bridge-function
-// pattern", typed in pdfEditModel.ts) so it is testable today against mocks. A caller that wires
-// pdf.js's shared history can drive it through `apply`/`revert`/`publish`, which together satisfy
-// pdfEditor.ts's `PdfSourceCommandSession<PdfEditCommand>` shape.
-//
-// No disk writes happen anywhere in this file (§3.2: "It never saves"). Save/checkpointing is
-// triggered externally via `checkpoint()` once `commit_pdf_save` (§10.3) succeeds.
-import { useCallback, useMemo, useRef, useState } from "react";
-import { computeSourceDigest, isSessionDirty, } from "./pdfEditModel.js";
-const INITIAL_TOOL = "selectText";
-function initialSession() {
-    const digest = computeSourceDigest([]);
-    return {
-        mode: "view",
-        tool: INITIAL_TOOL,
-        selection: null,
-        draft: null,
-        sourceCommands: [],
-        sourceDigest: digest,
-        savedSourceDigest: digest,
-        annotationDirty: false,
-    };
-}
-function draftIsNoOp(draft) {
-    if (draft.kind === "addText")
-        return draft.text.trim().length === 0;
-    const sameText = draft.text === draft.originalText;
-    const sameAppearance = !!draft.originalAppearance &&
-        draft.appearance.fontId === draft.originalAppearance.fontId &&
-        draft.appearance.sizePt === draft.originalAppearance.sizePt &&
-        draft.appearance.color.r === draft.originalAppearance.color.r &&
-        draft.appearance.color.g === draft.originalAppearance.color.g &&
-        draft.appearance.color.b === draft.originalAppearance.color.b &&
-        draft.appearance.color.alpha === draft.originalAppearance.color.alpha;
-    return sameText && sameAppearance;
-}
-function draftToCommand(draft) {
-    if (draft.kind === "sourceEdit") {
-        if (!draft.locator ||
-            !draft.originalText ||
-            !draft.originalAppearance ||
-            !draft.availableBounds) {
-            return null;
-        }
-        const command = {
-            kind: "replaceSourceText",
-            id: draft.id,
-            locator: draft.locator,
-            before: { text: draft.originalText, appearance: draft.originalAppearance },
-            after: { text: draft.text, appearance: draft.appearance },
-            availableBounds: draft.availableBounds,
-        };
-        return command;
-    }
-    if (draft.kind === "ocrEdit") {
-        if (!draft.lineId || !draft.coverColor)
-            return null;
-        return {
-            kind: "correctOcrText",
-            id: draft.id,
-            page: draft.page,
-            lineId: draft.lineId,
-            rect: draft.rect,
-            text: draft.text,
-            appearance: draft.appearance,
-            coverColor: draft.coverColor,
-            backgroundProof: "nearUniform",
-        };
-    }
-    if (!draft.anchor)
-        return null;
-    const command = {
-        kind: "addText",
-        id: draft.id,
-        page: draft.page,
-        anchor: draft.anchor,
-        text: draft.text,
-        appearance: draft.appearance,
-    };
-    return command;
-}
-export function usePdfEditSession(options) {
-    const { bridge, sourcePath } = options;
-    const [session, setSession] = useState(initialSession);
-    const sessionRef = useRef(session);
-    sessionRef.current = session;
-    const listenersRef = useRef(new Set());
-    const fontsCacheRef = useRef(null);
-    // Mirrors `session.draft`, refreshed every render, but ALSO nulled synchronously inside
-    // `commitDraftInternal`/`cancelDraft` themselves (not only via their `setSession` updaters). A
-    // caller (PdfViewer.tsx) can call `handleCommitDraft()` and then `selectIsland`/`exitEditMode`/an
-    // annotation-mode switch in the same synchronous event handler — each of which also commits
-    // internally — and React does not guarantee `session` (the render-closure value) reflects the
-    // first commit's `draft: null` before the second one reads it. Reading/nulling this ref instead
-    // means the second call sees the draft already cleared, instead of re-deriving and re-appending
-    // the same command a second time before React ever re-renders.
-    const draftRef = useRef(session.draft);
-    draftRef.current = session.draft;
-    // Mirrors `session.selection`, but is ALSO updated synchronously inside `selectIsland`/
-    // `clearSelection` (not only via their `setSession` updaters). `startSourceEditDraft` reads it
-    // instead of `session.selection`: PdfViewer calls `selectIsland(...)` and then
-    // `startSourceEditDraft(...)` in the same synchronous click handler, and React has not
-    // re-rendered between them, so the render-closure `session.selection` is still the pre-click
-    // value (null on a first click) — which made `startSourceEditDraft` bail and no editor open on
-    // the first click of an existing text run.
-    const selectionRef = useRef(session.selection);
-    selectionRef.current = session.selection;
-    const dirty = useMemo(() => isSessionDirty(session), [session]);
-    const publish = useCallback(() => {
-        for (const listener of listenersRef.current)
-            listener();
-    }, []);
-    const onPublish = useCallback((listener) => {
-        listenersRef.current.add(listener);
-        return () => {
-            listenersRef.current.delete(listener);
-        };
-    }, []);
-    const apply = useCallback((command) => {
-        setSession((prev) => {
-            const sourceCommands = [...prev.sourceCommands, command];
-            return { ...prev, sourceCommands, sourceDigest: computeSourceDigest(sourceCommands) };
-        });
-    }, []);
-    const revert = useCallback((command) => {
-        setSession((prev) => {
-            const index = prev.sourceCommands.findIndex((existing) => existing.id === command.id);
-            if (index === -1)
-                return prev;
-            const sourceCommands = prev.sourceCommands.slice();
-            sourceCommands.splice(index, 1);
-            return { ...prev, sourceCommands, sourceDigest: computeSourceDigest(sourceCommands) };
-        });
-    }, []);
-    const enterEditMode = useCallback(() => {
-        setSession((prev) => (prev.mode === "edit" ? prev : { ...prev, mode: "edit" }));
-    }, []);
-    // Reads `draftRef.current` (not `session.draft` from the render-time closure, and not from
-    // inside the `setSession` updater) so the command this returns is computed synchronously: React
-    // does not guarantee a functional `setSession` updater runs before this function returns, so a
-    // side effect set inside one cannot be relied on as this function's return value — and reading
-    // `session.draft` directly would go stale across two synchronous calls in the same handler (see
-    // `draftRef`'s doc comment above).
-    const commitDraftInternal = useCallback(() => {
-        const draft = draftRef.current;
-        if (!draft)
-            return null;
-        draftRef.current = null;
-        if (draftIsNoOp(draft)) {
-            const current = sessionRef.current;
-            if (current.draft)
-                sessionRef.current = { ...current, draft: null };
-            setSession((prev) => (prev.draft ? { ...prev, draft: null } : prev));
-            return null;
-        }
-        const command = draftToCommand(draft);
-        if (!command) {
-            const current = sessionRef.current;
-            if (current.draft)
-                sessionRef.current = { ...current, draft: null };
-            setSession((prev) => (prev.draft ? { ...prev, draft: null } : prev));
-            return null;
-        }
-        const current = sessionRef.current;
-        const sourceCommands = [...current.sourceCommands, command];
-        sessionRef.current = {
-            ...current,
-            draft: null,
-            sourceCommands,
-            sourceDigest: computeSourceDigest(sourceCommands),
-        };
-        setSession((prev) => {
-            const sourceCommands = [...prev.sourceCommands, command];
-            return {
-                ...prev,
-                draft: null,
-                sourceCommands,
-                sourceDigest: computeSourceDigest(sourceCommands),
-            };
-        });
-        return command;
-    }, []);
-    const commitDraft = useCallback(() => {
-        const command = commitDraftInternal();
-        if (command)
-            publish();
-        return command;
-    }, [commitDraftInternal, publish]);
-    const cancelDraft = useCallback(() => {
-        draftRef.current = null;
-        const current = sessionRef.current;
-        if (current.draft)
-            sessionRef.current = { ...current, draft: null };
-        setSession((prev) => (prev.draft ? { ...prev, draft: null } : prev));
-    }, []);
-    const exitEditMode = useCallback(() => {
-        commitDraftInternal();
-        setSession((prev) => ({ ...prev, mode: "view", draft: null }));
-    }, [commitDraftInternal]);
-    const setTool = useCallback((tool) => {
-        setSession((prev) => (prev.tool === tool ? prev : { ...prev, tool }));
-    }, []);
-    const selectIsland = useCallback((selection) => {
-        commitDraftInternal();
-        selectionRef.current = selection;
-        setSession((prev) => ({ ...prev, selection }));
-    }, [commitDraftInternal]);
-    const clearSelection = useCallback(() => {
-        selectionRef.current = null;
-        setSession((prev) => (prev.selection ? { ...prev, selection: null } : prev));
-    }, []);
-    const startSourceEditDraft = useCallback((params) => {
-        const selection = selectionRef.current;
-        if (!selection)
-            return;
-        const draft = {
-            kind: "sourceEdit",
-            id: params.id,
-            page: selection.page,
-            rect: params.rect,
-            text: params.text,
-            appearance: params.appearance,
-            locator: selection.locator,
-            originalText: params.text,
-            originalAppearance: params.appearance,
-            availableBounds: params.availableBounds,
-            anchor: null,
-            overflow: false,
-        };
-        setSession((prev) => ({ ...prev, draft }));
-    }, 
-    // Reads `selectionRef.current` (see its doc comment), not `session.selection`, so this callback
-    // needs no reactive dependency and stays stable across selection changes.
-    []);
-    const startAddTextDraft = useCallback((params) => {
-        const draft = {
-            kind: "addText",
-            id: params.id,
-            page: params.page,
-            rect: params.rect,
-            text: "",
-            appearance: params.appearance,
-            locator: null,
-            originalText: null,
-            originalAppearance: null,
-            availableBounds: null,
-            anchor: params.anchor,
-            overflow: false,
-        };
-        setSession((prev) => ({ ...prev, draft }));
-    }, []);
-    const startOcrEditDraft = useCallback((params) => {
-        const draft = {
-            kind: "ocrEdit",
-            id: params.id,
-            page: params.page,
-            rect: params.rect,
-            text: params.text,
-            appearance: params.appearance,
-            locator: null,
-            originalText: params.text,
-            originalAppearance: params.appearance,
-            availableBounds: params.rect,
-            anchor: null,
-            lineId: params.lineId,
-            coverColor: params.coverColor,
-            backgroundProof: "nearUniform",
-            overflow: false,
-        };
-        setSession((prev) => ({ ...prev, draft }));
-    }, []);
-    const updateDraftText = useCallback((text) => {
-        setSession((prev) => (prev.draft ? { ...prev, draft: { ...prev.draft, text } } : prev));
-    }, []);
-    const updateDraftAppearance = useCallback((appearance) => {
-        setSession((prev) => (prev.draft ? { ...prev, draft: { ...prev.draft, appearance } } : prev));
-    }, []);
-    const setDraftOverflow = useCallback((overflow) => {
-        setSession((prev) => prev.draft && prev.draft.overflow !== overflow
-            ? { ...prev, draft: { ...prev.draft, overflow } }
-            : prev);
-    }, []);
-    const checkpoint = useCallback(() => {
-        setSession((prev) => ({
-            ...prev,
-            savedSourceDigest: prev.sourceDigest,
-            annotationDirty: false,
-        }));
-    }, []);
-    const setAnnotationDirty = useCallback((next) => {
-        setSession((prev) => prev.annotationDirty === next ? prev : { ...prev, annotationDirty: next });
-    }, []);
-    const inspectPage = useCallback((page) => bridge.inspectPdfPage(sourcePath, page), [bridge, sourcePath]);
-    const listFonts = useCallback(() => {
-        if (!fontsCacheRef.current) {
-            fontsCacheRef.current = bridge.listPdfFonts().catch((error) => {
-                fontsCacheRef.current = null;
-                throw error;
-            });
-        }
-        return fontsCacheRef.current;
-    }, [bridge]);
-    const resetForDocument = useCallback(() => {
-        fontsCacheRef.current = null;
-        draftRef.current = null;
-        selectionRef.current = null;
-        setSession(initialSession());
-    }, []);
-    return {
-        session,
-        sessionRef,
-        dirty,
-        enterEditMode,
-        exitEditMode,
-        setTool,
-        selectIsland,
-        clearSelection,
-        startSourceEditDraft,
-        startAddTextDraft,
-        startOcrEditDraft,
-        updateDraftText,
-        updateDraftAppearance,
-        setDraftOverflow,
-        commitDraft,
-        cancelDraft,
-        apply,
-        revert,
-        onPublish,
-        publish,
-        checkpoint,
-        setAnnotationDirty,
-        inspectPage,
-        listFonts,
-        resetForDocument,
-    };
-}