@rightkit/document-core 0.1.1 → 0.2.0

package/dist/documents/pdf/usePdfOcr.js

@@ -1,337 +0,0 @@
-import { useCallback, useEffect, useRef, useState } from "react";
-import { isBackendUnavailable, isProbablyScannedPage, isTextlessPage, ocrBackendMissing, ocrPage, renderPageToPng, } from "./pdfOcr.js";
-import { viewportRotation } from "./pdfShared.js";
-import { logError, logPerf } from "../../state/diagnostics.js";
-function errorMessage(error) {
-    if (error instanceof Error && error.message)
-        return error.message;
-    return typeof error === "string" ? error : String(error);
-}
-export function usePdfOcr({ documentId, pdfDoc, pdfRef, current, rotation, setPageText, invalidatePageText, rehighlight, }) {
-    const [scannedPages, setScannedPages] = useState(new Map());
-    const [pageStates, setPageStates] = useState(new Map());
-    const [linesByPage, setLinesByPage] = useState(new Map());
-    const [currentPageScanned, setCurrentPageScanned] = useState(false);
-    const [documentState, setDocumentState] = useState({
-        status: "idle",
-        completed: 0,
-        total: 0,
-        scanned: 0,
-        skipped: 0,
-        failed: 0,
-    });
-    const generationRef = useRef(0);
-    const scanRequestRef = useRef(0);
-    const pageRunRef = useRef(new Map());
-    const documentRunRef = useRef(null);
-    const previousRotationRef = useRef(rotation);
-    const linesByPageRef = useRef(linesByPage);
-    const scannedPagesRef = useRef(scannedPages);
-    const pageStatesRef = useRef(pageStates);
-    const documentStateRef = useRef(documentState);
-    linesByPageRef.current = linesByPage;
-    scannedPagesRef.current = scannedPages;
-    pageStatesRef.current = pageStates;
-    documentStateRef.current = documentState;
-    // documentId is the lifecycle boundary; reset OCR state when it changes.
-    // biome-ignore lint/correctness/useExhaustiveDependencies: documentId intentionally marks document lifecycle.
-    useEffect(() => {
-        generationRef.current += 1;
-        scanRequestRef.current += 1;
-        pageRunRef.current.clear();
-        documentRunRef.current = null;
-        setScannedPages(new Map());
-        setPageStates(new Map());
-        setLinesByPage(new Map());
-        setCurrentPageScanned(false);
-        setDocumentState({
-            status: "idle",
-            completed: 0,
-            total: 0,
-            scanned: 0,
-            skipped: 0,
-            failed: 0,
-        });
-        return () => {
-            generationRef.current += 1;
-            scanRequestRef.current += 1;
-            pageRunRef.current.clear();
-            documentRunRef.current = null;
-        };
-    }, [documentId]);
-    // Geometry from a previous rotation is no longer valid. Do not transform it: the backend's
-    // normalized coordinates describe the raster orientation, so recognition must run again.
-    useEffect(() => {
-        if (previousRotationRef.current === rotation)
-            return;
-        previousRotationRef.current = rotation;
-        generationRef.current += 1;
-        scanRequestRef.current += 1;
-        pageRunRef.current.clear();
-        documentRunRef.current = null;
-        const recognizedPages = [...linesByPageRef.current.keys()];
-        for (const page of recognizedPages)
-            invalidatePageText(page);
-        if (recognizedPages.length > 0) {
-            setLinesByPage((previous) => {
-                const next = new Map(previous);
-                for (const page of recognizedPages)
-                    next.delete(page);
-                return next;
-            });
-        }
-        setPageStates((previous) => {
-            const next = new Map(previous);
-            for (const [page, state] of next) {
-                if (state.status === "done" || state.status === "running") {
-                    next.set(page, { status: "idle" });
-                }
-            }
-            return next;
-        });
-        setDocumentState({ status: "idle", completed: 0, total: 0, scanned: 0, skipped: 0, failed: 0 });
-    }, [invalidatePageText, rotation]);
-    // Browsing detection reads only streamed text. Image/operator inspection is deferred until an
-    // explicit OCR request, so opening/changing pages never decodes a page just to show a button.
-    useEffect(() => {
-        if (!pdfDoc || current < 1 || current > pdfDoc.numPages) {
-            setCurrentPageScanned(false);
-            return;
-        }
-        const known = scannedPagesRef.current.get(current);
-        if (known !== undefined) {
-            setCurrentPageScanned(known);
-            return;
-        }
-        const request = ++scanRequestRef.current;
-        let cancelled = false;
-        void pdfDoc
-            .getPage(current)
-            .then((page) => isTextlessPage(page))
-            .then((textless) => {
-            if (cancelled || request !== scanRequestRef.current)
-                return;
-            setScannedPages((previous) => {
-                const next = new Map(previous);
-                next.set(current, textless);
-                return next;
-            });
-            setCurrentPageScanned(textless);
-        })
-            .catch(() => {
-            if (!cancelled && request === scanRequestRef.current)
-                setCurrentPageScanned(false);
-        });
-        return () => {
-            cancelled = true;
-        };
-    }, [current, pdfDoc]);
-    const setState = useCallback((page, state) => {
-        setPageStates((previous) => {
-            const next = new Map(previous);
-            next.set(page, state);
-            return next;
-        });
-    }, []);
-    const isCurrentGeneration = useCallback((generation, pdf) => generation === generationRef.current && pdfRef.current === pdf, [pdfRef]);
-    const recognizePage = useCallback(async (pageNumber, pdf, generation, pageOverride) => {
-        const startedAt = performance.now();
-        setState(pageNumber, { status: "running" });
-        try {
-            const page = pageOverride ?? (await pdf.getPage(pageNumber));
-            if (!isCurrentGeneration(generation, pdf))
-                return "cancelled";
-            const png = await renderPageToPng(page, 300, viewportRotation(page.rotate, rotation));
-            if (!isCurrentGeneration(generation, pdf))
-                return "cancelled";
-            const lines = await ocrPage(new Uint8Array(await png.arrayBuffer()));
-            if (!isCurrentGeneration(generation, pdf))
-                return "cancelled";
-            setLinesByPage((previous) => new Map(previous).set(pageNumber, lines));
-            setState(pageNumber, { status: "done" });
-            setPageText(pageNumber, lines.map((line) => line.text).join(" "));
-            logPerf("pdf:ocr-page", startedAt);
-            rehighlight();
-            return "done";
-        }
-        catch (error) {
-            if (!isCurrentGeneration(generation, pdf))
-                return "cancelled";
-            setState(pageNumber, { status: "error", error: errorMessage(error) });
-            logError("pdf:ocr-page-failed");
-            return "failed";
-        }
-    }, [isCurrentGeneration, rehighlight, rotation, setPageText, setState]);
-    const recognizeCurrentPage = useCallback(async (inspectEligibility = false) => {
-        const pageNumber = current;
-        const pdf = pdfRef.current ?? pdfDoc;
-        if (!pdf ||
-            (!currentPageScanned && !inspectEligibility) ||
-            pageStatesRef.current.get(pageNumber)?.status === "running" ||
-            pageRunRef.current.size > 0 ||
-            documentRunRef.current !== null) {
-            return;
-        }
-        const generation = generationRef.current;
-        pageRunRef.current.set(pageNumber, generation);
-        setState(pageNumber, { status: "running" });
-        try {
-            const page = await pdf.getPage(pageNumber);
-            if (!isCurrentGeneration(generation, pdf))
-                return;
-            const scanned = await isProbablyScannedPage(page);
-            if (!isCurrentGeneration(generation, pdf))
-                return;
-            setScannedPages((previous) => new Map(previous).set(pageNumber, scanned));
-            setCurrentPageScanned(scanned);
-            if (!scanned) {
-                setState(pageNumber, { status: "idle" });
-                return;
-            }
-            await recognizePage(pageNumber, pdf, generation, page);
-        }
-        catch {
-            if (!isCurrentGeneration(generation, pdf))
-                return;
-            setState(pageNumber, { status: "error", error: "Unable to inspect page for OCR." });
-            logError("pdf:ocr-page-failed");
-        }
-        finally {
-            if (pageRunRef.current.get(pageNumber) === generation)
-                pageRunRef.current.delete(pageNumber);
-        }
-    }, [current, currentPageScanned, isCurrentGeneration, pdfDoc, pdfRef, recognizePage, setState]);
-    const recognizeDocument = useCallback(async () => {
-        const pdf = pdfRef.current ?? pdfDoc;
-        if (!pdf ||
-            documentStateRef.current.status === "running" ||
-            documentRunRef.current !== null ||
-            pageRunRef.current.size > 0) {
-            return;
-        }
-        const generation = generationRef.current;
-        const total = pdf.numPages;
-        documentRunRef.current = generation;
-        setDocumentState({
-            status: "running",
-            completed: 0,
-            total,
-            scanned: 0,
-            skipped: 0,
-            failed: 0,
-            currentPage: 1,
-        });
-        const startedAt = performance.now();
-        let failedCount = 0;
-        try {
-            for (let pageNumber = 1; pageNumber <= total; pageNumber += 1) {
-                if (!isCurrentGeneration(generation, pdf))
-                    return;
-                const previous = pageStatesRef.current.get(pageNumber);
-                try {
-                    const page = await pdf.getPage(pageNumber);
-                    const scanned = await isProbablyScannedPage(page);
-                    if (!isCurrentGeneration(generation, pdf))
-                        return;
-                    setScannedPages((pages) => new Map(pages).set(pageNumber, scanned));
-                    if (scanned) {
-                        setDocumentState((state) => ({
-                            ...state,
-                            scanned: state.scanned + 1,
-                            currentPage: pageNumber,
-                        }));
-                    }
-                    if (!scanned || previous?.status === "done") {
-                        setDocumentState((state) => ({
-                            ...state,
-                            completed: state.completed + 1,
-                            skipped: state.skipped + 1,
-                            currentPage: pageNumber,
-                        }));
-                        continue;
-                    }
-                    const outcome = await recognizePage(pageNumber, pdf, generation, page);
-                    if (outcome === "cancelled")
-                        return;
-                    if (outcome === "failed")
-                        failedCount += 1;
-                    setDocumentState((state) => ({
-                        ...state,
-                        completed: state.completed + 1,
-                        failed: state.failed + (outcome === "failed" ? 1 : 0),
-                        currentPage: pageNumber,
-                    }));
-                }
-                catch {
-                    if (!isCurrentGeneration(generation, pdf))
-                        return;
-                    failedCount += 1;
-                    setState(pageNumber, { status: "error", error: "Unable to inspect page for OCR." });
-                    logError("pdf:ocr-page-failed");
-                    setDocumentState((state) => ({
-                        ...state,
-                        completed: state.completed + 1,
-                        failed: state.failed + 1,
-                        currentPage: pageNumber,
-                    }));
-                }
-            }
-            if (!isCurrentGeneration(generation, pdf))
-                return;
-            setDocumentState((state) => ({ ...state, status: failedCount > 0 ? "error" : "done" }));
-            logPerf("pdf:ocr-document", startedAt);
-        }
-        catch {
-            if (isCurrentGeneration(generation, pdf)) {
-                setDocumentState((state) => ({ ...state, status: "error" }));
-                setState(current, {
-                    status: "error",
-                    error: "Text recognition is unavailable. Try again.",
-                });
-            }
-        }
-        finally {
-            if (documentRunRef.current === generation)
-                documentRunRef.current = null;
-        }
-    }, [current, isCurrentGeneration, pdfDoc, pdfRef, recognizePage, setState]);
-    // State updates commit the OCR layer after recognition returns. Re-run once the lines are
-    // mounted so a query that was already committed can mark the newly-rendered spans.
-    useEffect(() => {
-        if (linesByPage.size > 0)
-            rehighlight();
-    }, [linesByPage, rehighlight]);
-    // Ask the backend only once a scanned page is in view, which is the first moment OCR would be
-    // offered: on macOS the probe runs a recognition canary that is costly on a cold model cache.
-    // Until it answers, and whenever it cannot answer, OCR stays offered.
-    const [ocrMissing, setOcrMissing] = useState(false);
-    useEffect(() => {
-        if (!currentPageScanned)
-            return;
-        let cancelled = false;
-        void ocrBackendMissing().then((missing) => {
-            if (!cancelled && missing)
-                setOcrMissing(true);
-        });
-        return () => {
-            cancelled = true;
-        };
-    }, [currentPageScanned]);
-    const currentPageState = pageStates.get(current) ?? { status: "idle" };
-    const currentError = currentPageState.status === "error" ? currentPageState.error : undefined;
-    return {
-        // The backend probe decides whether OCR is offered at all; PdfToolbar hides the controls when
-        // it is false. Recognition failures on the requested page are still reported from that page.
-        ocrAvailable: !ocrMissing,
-        availabilityResolved: true,
-        currentPageScanned,
-        currentPageState,
-        currentError,
-        currentErrorIsBackendUnavailable: currentError ? isBackendUnavailable(currentError) : false,
-        linesByPage,
-        pageStates,
-        recognizeCurrentPage,
-        documentOcrState: documentState,
-        recognizeDocument,
-    };
-}

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

@@ -1,28 +0,0 @@
-import { type MutableRefObject } from "react";
-import * as pdfjs from "pdfjs-dist";
-import type { PDFDocumentProxy } from "pdfjs-dist";
-import type { usePdfEditSession } from "./usePdfEditSession.js";
-interface PdfPreviewRecomposeDeps {
-    documentPath: string;
-    editSession: ReturnType<typeof usePdfEditSession>;
-    /** Best-known document_sha256 (§5.1) — populated from every inspected page graph. */
-    sourceShaRef: MutableRefObject<string | null>;
-    /** Guards against concurrent publishes racing: a superseded call discards its own task. */
-    previewSeqRef: MutableRefObject<number>;
-    previewLoadingTaskRef: MutableRefObject<ReturnType<typeof pdfjs.getDocument> | null>;
-    previewDocRef: MutableRefObject<PDFDocumentProxy | null>;
-    previewPagesRef: MutableRefObject<Set<number>>;
-    renderedRef: MutableRefObject<Map<number, () => void>>;
-    /** Indirection to the per-page renderer so this path never grows renderPage's dep list. */
-    renderPageRef: MutableRefObject<(n: number) => Promise<void>>;
-}
-/**
- * §9.4 in-memory candidate preview: recompose the candidate document from the committed-but-unsaved
- * source commands and re-render each affected page on every source-history mutation (commit, undo,
- * redo — anything that calls `editSession.publish()`). Extracted from PdfViewer verbatim — no
- * behavior change.
- */
-export declare function usePdfPreviewRecompose({ documentPath, editSession, sourceShaRef, previewSeqRef, previewLoadingTaskRef, previewDocRef, previewPagesRef, renderedRef, renderPageRef, }: PdfPreviewRecomposeDeps): {
-    invalidatePreview: () => void;
-};
-export {};

package/dist/documents/pdf/usePdfPreviewRecompose.js

@@ -1,256 +0,0 @@
-import { useCallback, useEffect, useRef } from "react";
-import * as pdfjs from "pdfjs-dist";
-import { pdfDocumentInit, pdfWasmUrl } from "@rightkit/pdf-ui";
-import { recomposePdfPreview } from "./pdfSave.js";
-import { composePdfPreview } from "../../state/tauriBridge.js";
-import { logError } from "../../state/diagnostics.js";
-import { acquireResource } from "../../app/resourceCensus.js";
-/**
- * §9.4 in-memory candidate preview: recompose the candidate document from the committed-but-unsaved
- * source commands and re-render each affected page on every source-history mutation (commit, undo,
- * redo — anything that calls `editSession.publish()`). Extracted from PdfViewer verbatim — no
- * behavior change.
- */
-export function usePdfPreviewRecompose({ documentPath, editSession, sourceShaRef, previewSeqRef, previewLoadingTaskRef, previewDocRef, previewPagesRef, renderedRef, renderPageRef, }) {
-    const onPublish = editSession.onPublish;
-    // Mirrors editSession.session.sourceCommands on every render. `publish()` (from commitDraft, or
-    // from the addCommands `post` above on undo/redo) fires SYNCHRONOUSLY inside the same call that
-    // just invoked `setSession`, i.e. before React has re-rendered — so a listener reading
-    // `editSession.session` directly would see the state from BEFORE this mutation. Deferring the
-    // read to a microtask (below) lets React's synchronous end-of-event-handler flush happen first,
-    // by which point this ref (updated every render, during the render itself) is current.
-    const sourceCommandsRef = useRef(editSession.session.sourceCommands);
-    sourceCommandsRef.current = editSession.session.sourceCommands;
-    // A publish can leave work queued behind React's render, while pdf.js can keep a loading task
-    // alive long after its caller has gone away. Keep hook lifetime separate from the shared preview
-    // sequence so document switches & unmounts invalidate both queued work & in-flight loads.
-    const mountedRef = useRef(false);
-    const lifecycleRef = useRef(0);
-    const queueEpochRef = useRef(0);
-    const publishEpochRef = useRef(0);
-    const pendingLoadingTaskRef = useRef(null);
-    const retirementBarrierRef = useRef(null);
-    const deferredResumeRef = useRef(null);
-    const resumeWatcherRef = useRef(null);
-    const handleRecomposePreviewRef = useRef(null);
-    const destroyedLoadingTasksRef = useRef(new WeakSet());
-    const taskDestroyPromisesRef = useRef(new WeakMap());
-    const taskOwnershipRef = useRef(new WeakMap());
-    const ensureDestroyLoadingTask = useCallback((task) => {
-        const existing = taskDestroyPromisesRef.current.get(task);
-        if (existing)
-            return existing;
-        const ownership = taskOwnershipRef.current.get(task);
-        const destroyPromise = (async () => {
-            try {
-                if (!task.destroyed)
-                    await task.destroy();
-            }
-            catch {
-                // Destruction is best-effort during unmount/path replacement.
-            }
-            finally {
-                ownership?.document?.();
-                ownership?.worker();
-                destroyedLoadingTasksRef.current.add(task);
-            }
-        })();
-        taskDestroyPromisesRef.current.set(task, destroyPromise);
-        return destroyPromise;
-    }, []);
-    const waitForDestroy = useCallback(async (task) => {
-        if (!task)
-            return true;
-        const destroyPromise = ensureDestroyLoadingTask(task);
-        let timeout;
-        const completed = await Promise.race([
-            destroyPromise.then(() => true),
-            new Promise((resolve) => {
-                timeout = window.setTimeout(() => resolve(false), 500);
-            }),
-        ]);
-        if (timeout !== undefined)
-            window.clearTimeout(timeout);
-        return completed;
-    }, [ensureDestroyLoadingTask]);
-    const beginRetirement = useCallback((task) => {
-        const promise = ensureDestroyLoadingTask(task);
-        retirementBarrierRef.current = { task, promise };
-        void promise.then(() => {
-            if (retirementBarrierRef.current?.task === task)
-                retirementBarrierRef.current = null;
-        });
-        return promise;
-    }, [ensureDestroyLoadingTask]);
-    const deferUntilRetirement = useCallback((lifecycle, publishEpoch, queueEpoch) => {
-        const barrier = retirementBarrierRef.current;
-        if (!barrier)
-            return;
-        deferredResumeRef.current = { lifecycle, publishEpoch, queueEpoch };
-        if (resumeWatcherRef.current === barrier.promise)
-            return;
-        const watcher = barrier.promise.then(() => {
-            if (resumeWatcherRef.current === watcher)
-                resumeWatcherRef.current = null;
-            const deferred = deferredResumeRef.current;
-            deferredResumeRef.current = null;
-            if (deferred &&
-                mountedRef.current &&
-                lifecycleRef.current === deferred.lifecycle &&
-                publishEpochRef.current === deferred.publishEpoch &&
-                queueEpochRef.current === deferred.queueEpoch)
-                void handleRecomposePreviewRef.current?.(deferred.lifecycle, deferred.publishEpoch);
-        });
-        resumeWatcherRef.current = watcher;
-    }, []);
-    // biome-ignore lint/correctness/useExhaustiveDependencies: refs arrive as stable hook params
-    const clearPreview = useCallback(() => {
-        previewSeqRef.current += 1;
-        const pending = pendingLoadingTaskRef.current;
-        pendingLoadingTaskRef.current = null;
-        const published = previewLoadingTaskRef.current;
-        previewLoadingTaskRef.current = null;
-        previewDocRef.current = null;
-        previewPagesRef.current = new Set();
-        if (pending) {
-            const pendingRetirement = beginRetirement(pending);
-            if (published && published !== pending)
-                void pendingRetirement.then(() => beginRetirement(published));
-        }
-        else if (published)
-            beginRetirement(published);
-    }, [beginRetirement]);
-    // biome-ignore lint/correctness/useExhaustiveDependencies: refs arrive as stable hook params
-    const handleRecomposePreview = useCallback(async (lifecycle, publishEpoch = publishEpochRef.current) => {
-        const isCurrent = () => mountedRef.current &&
-            lifecycleRef.current === lifecycle &&
-            publishEpochRef.current === publishEpoch;
-        if (!isCurrent())
-            return;
-        const sha = sourceShaRef.current;
-        if (!sha)
-            return; // nothing inspected yet — no possible edits either
-        const seq = ++previewSeqRef.current;
-        const queueEpoch = queueEpochRef.current;
-        const barrier = retirementBarrierRef.current;
-        if (barrier) {
-            const reaped = await waitForDestroy(barrier.task);
-            if (!reaped) {
-                deferUntilRetirement(lifecycle, publishEpoch, queueEpoch);
-                return;
-            }
-        }
-        const previousPending = pendingLoadingTaskRef.current;
-        pendingLoadingTaskRef.current = null;
-        if (previousPending) {
-            beginRetirement(previousPending);
-            const reaped = await waitForDestroy(previousPending);
-            if (!reaped) {
-                deferUntilRetirement(lifecycle, publishEpoch, queueEpoch);
-                return;
-            }
-            retirementBarrierRef.current = null;
-            if (!isCurrent() || previewSeqRef.current !== seq)
-                return;
-        }
-        let task = null;
-        try {
-            const composed = await recomposePdfPreview({ composePdfPreview }, documentPath, sha, sourceCommandsRef.current);
-            if (!isCurrent() || previewSeqRef.current !== seq)
-                return; // superseded while composing
-            task = pdfjs.getDocument(pdfDocumentInit(composed.candidateBytes.slice(), { wasmUrl: pdfWasmUrl() }));
-            taskOwnershipRef.current.set(task, {
-                worker: acquireResource({
-                    kind: "pdf-preview-worker",
-                    documentPath,
-                    format: "pdf",
-                }),
-                document: null,
-            });
-            pendingLoadingTaskRef.current = task;
-            const doc = await task.promise;
-            if (!isCurrent() || previewSeqRef.current !== seq) {
-                if (pendingLoadingTaskRef.current === task)
-                    pendingLoadingTaskRef.current = null;
-                beginRetirement(task);
-                const reaped = await waitForDestroy(task); // superseded while loading — this call's own task
-                if (!reaped)
-                    deferUntilRetirement(lifecycle, publishEpoch, queueEpoch);
-                return;
-            }
-            if (pendingLoadingTaskRef.current === task)
-                pendingLoadingTaskRef.current = null;
-            const ownership = taskOwnershipRef.current.get(task);
-            if (ownership && !ownership.document) {
-                ownership.document = acquireResource({
-                    kind: "pdf-preview-document",
-                    documentPath,
-                    format: "pdf",
-                });
-            }
-            const previousPublished = previewLoadingTaskRef.current;
-            // An undo can remove the last command, making the new candidate's affected-pages list
-            // empty. Re-render pages from the previous candidate too, so those slots switch back to
-            // the on-disk document instead of retaining stale edited pixels.
-            const pagesToRender = new Set([...previewPagesRef.current, ...composed.affectedPages]);
-            if (!isCurrent() || previewSeqRef.current !== seq) {
-                beginRetirement(task);
-                return;
-            }
-            previewLoadingTaskRef.current = task;
-            previewDocRef.current = doc;
-            previewPagesRef.current = new Set(composed.affectedPages);
-            if (previousPublished && previousPublished !== task)
-                beginRetirement(previousPublished);
-            for (const n of pagesToRender) {
-                renderedRef.current.get(n)?.();
-                void renderPageRef.current(n);
-            }
-        }
-        catch {
-            if (pendingLoadingTaskRef.current === task)
-                pendingLoadingTaskRef.current = null;
-            if (task)
-                beginRetirement(task);
-            if (isCurrent() && previewSeqRef.current === seq) {
-                logError("pdf-editor:preview");
-            }
-        }
-    }, [beginRetirement, deferUntilRetirement, documentPath, waitForDestroy]);
-    handleRecomposePreviewRef.current = handleRecomposePreview;
-    useEffect(() => {
-        mountedRef.current = true;
-        const lifecycle = ++lifecycleRef.current;
-        const unsubscribe = onPublish(() => {
-            const queueEpoch = queueEpochRef.current;
-            const publishEpoch = ++publishEpochRef.current;
-            queueMicrotask(() => {
-                if (mountedRef.current &&
-                    lifecycleRef.current === lifecycle &&
-                    queueEpochRef.current === queueEpoch &&
-                    publishEpochRef.current === publishEpoch) {
-                    void handleRecomposePreview(lifecycle, publishEpoch);
-                }
-            });
-        });
-        return () => {
-            unsubscribe();
-            mountedRef.current = false;
-            lifecycleRef.current += 1;
-            clearPreview();
-        };
-    }, [clearPreview, handleRecomposePreview, onPublish]);
-    // Save commits invalidate queued/in-flight candidate work without destroying the currently
-    // published preview. If reload fails, that preview remains visible as last-known-good evidence;
-    // a successful reload clears it after the fresh document is installed. Later source publishes
-    // remain valid because lifecycleRef is deliberately left untouched.
-    const invalidatePreview = useCallback(() => {
-        queueEpochRef.current += 1;
-        previewSeqRef.current += 1;
-        const pending = pendingLoadingTaskRef.current;
-        pendingLoadingTaskRef.current = null;
-        if (pending)
-            beginRetirement(pending);
-    }, [beginRetirement, previewSeqRef]);
-    return { invalidatePreview };
-}