web-doc 0.6.2 → 0.7.0

package/dist/viewer.js

@@ -1,3 +1,4 @@
+import { EditSessionController, } from "./edit/session.js";
 import { linkedAbortController } from "./abort.js";
 import { detectFormat } from "./detect.js";
 import { abortError, normalizeError, ViewerError } from "./errors.js";
@@ -28,6 +29,12 @@ export class DocumentViewer {
     #info;
     #original;
     #originalFileName;
+    #originalContentType;
+    /** Limits the current document was opened with; reused when it is reopened. */
+    #limits;
+    #session;
+    /** Shared by concurrent `edit()` calls while the engine starts. */
+    #sessionStart;
     #activeLoad;
     #activeSearch;
     #selection = null;
@@ -45,6 +52,7 @@ export class DocumentViewer {
     constructor(options, runtime) {
         this.#options = options;
         this.#runtime = runtime;
+        this.#limits = runtime.limits;
         this.#state = freezeState({
             status: "idle",
             pageIndex: 0,
@@ -77,6 +85,7 @@ export class DocumentViewer {
                 onTextSelection: (range) => void this.selectText(range),
                 onCellSelection: (selection) => this.#applyInteractiveCellSelection(selection),
                 getSelectionText: () => this.#getCachedSelectionText(),
+                onPainted: (pages, revision) => this.#onPainted(pages, revision),
             }, options);
         }
     }
@@ -151,31 +160,21 @@ export class DocumentViewer {
                 await adapter.close(handle);
                 throw abortError();
             }
-            if (!Number.isInteger(backendInfo.pageCount) ||
-                backendInfo.pageCount < 1 ||
-                backendInfo.pageCount > limits.maxDocumentUnits) {
+            let info;
+            try {
+                info = describeDocument(adapter, backendInfo, detection.format, limits);
+            }
+            catch (error) {
                 await adapter.close(handle);
-                throw new ViewerError("resource-limit", "Document unit count exceeds the configured limit", {
-                    details: {
-                        pageCount: backendInfo.pageCount,
-                        limit: limits.maxDocumentUnits,
-                    },
-                });
+                throw error;
             }
-            const info = immutableInfo({
-                ...backendInfo,
-                capabilities: {
-                    textSelection: Boolean(adapter.getTextMap),
-                    cellSelection: backendInfo.unit === "sheet",
-                    search: Boolean(adapter.getTextMap),
-                    thumbnails: backendInfo.unit !== "sheet",
-                },
-            });
             this.#adapter = adapter;
             this.#handle = handle;
             this.#info = info;
             this.#original = loaded.bytes;
             this.#originalFileName = fileName;
+            this.#originalContentType = contentType;
+            this.#limits = limits;
             this.#update({
                 status: "ready",
                 format: detection.format,
@@ -671,6 +670,45 @@ export class DocumentViewer {
         }
         return blob;
     }
+    async edit(options = {}) {
+        const { adapter, info } = this.#assertReady();
+        if (this.#session?.core.usable)
+            return this.#session.session;
+        if (this.#sessionStart)
+            return this.#sessionStart;
+        const format = editableFormat(adapter, info.format);
+        if (!format || !adapter.edit)
+            throw new ViewerError("edit-unsupported", "Editing is not available for this document", { details: { format: info.format, reason: "no-engine" } });
+        const start = this.#startSession(adapter.edit, format, options);
+        this.#sessionStart = start;
+        try {
+            return await start;
+        }
+        finally {
+            if (this.#sessionStart === start)
+                this.#sessionStart = undefined;
+        }
+    }
+    getEditSession() {
+        this.#assertAlive();
+        return this.#session?.session;
+    }
+    pageToClient(pageIndex, rect) {
+        this.#assertAlive();
+        if (this.#state.status !== "ready" ||
+            !Number.isInteger(pageIndex) ||
+            ![rect.x, rect.y, rect.width, rect.height].every(Number.isFinite))
+            return undefined;
+        return this.#viewport?.pageToClient(pageIndex, rect);
+    }
+    clientToPage(clientX, clientY) {
+        this.#assertAlive();
+        if (this.#state.status !== "ready" ||
+            !Number.isFinite(clientX) ||
+            !Number.isFinite(clientY))
+            return undefined;
+        return this.#viewport?.clientToPage(clientX, clientY);
+    }
     on(type, listener) {
         this.#assertAlive();
         const listeners = this.#listeners.get(type) ?? new Set();
@@ -700,6 +738,194 @@ export class DocumentViewer {
         this.#listeners.clear();
         this.#runtime.release(this);
     }
+    async #startSession(provider, format, options) {
+        const generation = this.#generation;
+        const operation = this.#startOperation(options.signal);
+        // A session that broke (failed recovery) makes way for a fresh engine.
+        const stale = this.#session;
+        this.#session = undefined;
+        if (stale)
+            await stale.core.end();
+        try {
+            const engine = await provider.load(this.#original.slice(), {
+                format,
+                limits: this.#limits,
+                fonts: this.#runtime.fonts.registered,
+                signal: operation.signal,
+                ...(this.#originalFileName ? { fileName: this.#originalFileName } : {}),
+                ...(this.#runtime.assetBaseUrl
+                    ? { assetBaseUrl: this.#runtime.assetBaseUrl }
+                    : {}),
+            });
+            if (generation !== this.#generation || operation.signal.aborted) {
+                await engine.dispose().catch(() => undefined);
+                throw abortError();
+            }
+            const host = {
+                format,
+                limits: this.#limits,
+                prepareDocument: (bytes, signal) => this.#prepareDocument(bytes, signal),
+                commitDocument: (prepared, changedPages) => this.#commitDocument(prepared, changedPages),
+                discardDocument: (prepared) => this.#discardDocument(prepared),
+                emit: (type, event) => this.#emit(type, event),
+                pageOf: (paragraphId) => {
+                    let first;
+                    for (const [pageIndex, runs] of this.#textMaps)
+                        if ((first === undefined || pageIndex < first) &&
+                            runs.some((run) => run.paragraphId === paragraphId))
+                            first = pageIndex;
+                    return first;
+                },
+            };
+            const core = new EditSessionController(engine, host, this.#original, this.#info.pageCount);
+            const session = provider.createSession(core, {
+                getTextRuns: (pageIndex, signal) => this.#getTextRuns(pageIndex, signal),
+                cachedPages: () => [...this.#textMaps.keys()],
+            });
+            this.#session = { core, session };
+            this.#emit("editstatechange", {
+                ...core.state,
+                active: true,
+                format,
+            });
+            return session;
+        }
+        catch (error) {
+            const normalized = normalizeError(error, "edit-failed");
+            throw normalized.code === "edit-failed" && !normalized.details
+                ? new ViewerError("edit-failed", normalized.message, {
+                    cause: error,
+                    details: { stage: "load" },
+                })
+                : normalized;
+        }
+        finally {
+            this.#finishOperation(operation);
+        }
+    }
+    /**
+     * Shows edited bytes as the current document: opens them through the
+     * adapter, swaps the handle, drops every cache derived from the old content
+     * and keeps the view where it was. Returns the new page count.
+     */
+    /**
+     * Phase one of showing edited bytes: opens them next to the current
+     * document. Everything that can fail or be aborted happens here.
+     */
+    async #prepareDocument(bytes, signal) {
+        const { adapter, handle, info } = this.#assertReady();
+        const generation = this.#generation;
+        enforceContainerLimits(bytes, info.format, this.#limits);
+        const context = {
+            format: info.format,
+            signal,
+            limits: this.#limits,
+            reportProgress: (progress) => this.#emit("progress", progress),
+            reportWarning: (warning) => this.#emit("warning", warning),
+            ...(this.#originalFileName ? { fileName: this.#originalFileName } : {}),
+            ...(this.#originalContentType
+                ? { contentType: this.#originalContentType }
+                : {}),
+            ...(this.#runtime.assetBaseUrl
+                ? { assetBaseUrl: this.#runtime.assetBaseUrl }
+                : {}),
+        };
+        const next = adapter.reopen
+            ? await adapter.reopen(handle, bytes, context)
+            : await adapter.open(bytes, context);
+        let nextInfo;
+        try {
+            if (generation !== this.#generation || signal.aborted)
+                throw abortError();
+            const backendInfo = await adapter.getInfo(next);
+            if (generation !== this.#generation || signal.aborted)
+                throw abortError();
+            nextInfo = describeDocument(adapter, backendInfo, info.format, this.#limits);
+        }
+        catch (error) {
+            await adapter.close(next);
+            throw error;
+        }
+        return {
+            pageCount: nextInfo.pageCount,
+            handle: next,
+            info: nextInfo,
+            generation,
+        };
+    }
+    /**
+     * Phase two: swaps the prepared document in. Synchronous and never throws
+     * for a preparation of the current document, so a session that reached
+     * this point always completes; the old handle is closed in the background.
+     */
+    #commitDocument(prepared, changedPages) {
+        if (prepared.generation !== this.#generation || !this.#handle) {
+            this.#discardDocument(prepared);
+            throw new ViewerError("lifecycle-error", "The document was replaced while an edit was being shown");
+        }
+        const { adapter, handle: previous } = this.#assertReady();
+        this.#handle = prepared.handle;
+        this.#info = prepared.info;
+        this.#invalidateContentCaches();
+        this.#update({
+            pageCount: prepared.info.pageCount,
+            pageIndex: Math.min(this.#state.pageIndex, prepared.info.pageCount - 1),
+        });
+        for (const warning of prepared.info.warnings ?? [])
+            this.#emit("warning", warning);
+        const revision = (this.#session?.core.state.revision ?? 0) + 1;
+        if (this.#viewport)
+            this.#viewport.replaceDocument(prepared.info, changedPages, revision);
+        else
+            // Headless: nothing paints, so geometry is "current" as soon as the
+            // session has emitted documentchange, which happens before the next
+            // macrotask.
+            setTimeout(() => this.#onPainted([...changedPages], revision), 0);
+        void Promise.resolve(adapter.close(previous)).catch((error) => this.#reportError(error));
+        return prepared.info.pageCount;
+    }
+    #discardDocument(prepared) {
+        void Promise.resolve(this.#adapter?.close(prepared.handle)).catch((error) => this.#reportError(error));
+    }
+    /** Painted pages of a content revision become a `layoutchange` while a session is active. */
+    #onPainted(pages, revision) {
+        const session = this.#session;
+        // The viewport reports only paints of its current content, so a revision
+        // the session has not committed yet is the only thing to drop.
+        if (!session || revision > session.core.state.revision)
+            return;
+        this.#emit("layoutchange", {
+            sessionId: session.core.sessionId,
+            revision,
+            pages: Object.freeze([...pages]),
+        });
+    }
+    #reportError(error) {
+        const report = globalThis
+            .reportError;
+        if (report)
+            report(error);
+        else
+            console.error(error);
+    }
+    /** Forgets everything derived from the document's content, not from its view. */
+    #invalidateContentCaches() {
+        this.#textMaps.clear();
+        this.#textMapBytes = 0;
+        // The worker keeps its index; a stale key makes the next search rebuild it.
+        this.#fuzzyIndexKey = undefined;
+        this.#activeSearch?.abort();
+        this.#activeSearch = undefined;
+        this.#searchGeneration += 1;
+        if (this.#searchResult) {
+            this.#searchResult = null;
+            this.#emit("searchchange", null);
+        }
+        if (this.#selection) {
+            this.#selection = null;
+            this.#emit("selectionchange", null);
+        }
+    }
     async #getTextRuns(pageIndex, signal) {
         const { adapter, handle, info } = this.#assertReady();
         assertPageIndex(pageIndex, info.pageCount);
@@ -779,6 +1005,11 @@ export class DocumentViewer {
         this.#update({ panX: x, panY: y });
     }
     async #closeDocument() {
+        const session = this.#session;
+        this.#session = undefined;
+        this.#sessionStart = undefined;
+        if (session)
+            await session.core.end();
         const adapter = this.#adapter;
         const handle = this.#handle;
         this.#adapter = undefined;
@@ -786,6 +1017,7 @@ export class DocumentViewer {
         this.#info = undefined;
         this.#original = undefined;
         this.#originalFileName = undefined;
+        this.#originalContentType = undefined;
         this.#activeSearch?.abort();
         this.#activeSearch = undefined;
         this.#searchResult = null;
@@ -856,9 +1088,51 @@ export class DocumentViewer {
     }
     #emit(type, event) {
         for (const listener of this.#listeners.get(type) ?? [])
-            listener(event);
+            try {
+                listener(event);
+            }
+            catch (error) {
+                // A listener's bug is its own; it never fails the call that emitted.
+                this.#reportError(error);
+            }
     }
 }
+/** The edit format of `format` when `adapter` can edit it. */
+/** The session format of a document format the adapter's provider edits. */
+function editableFormat(adapter, format) {
+    const formats = adapter.edit?.formats ?? [];
+    return formats.includes(format) ? SESSION_FORMATS[format] : undefined;
+}
+const SESSION_FORMATS = {
+    pdf: "pdf",
+    pptx: "pptx",
+    pptm: "pptx",
+    ppsx: "pptx",
+    docx: "docx",
+    docm: "docx",
+};
+/** Validates backend info and freezes it with the viewer's capability flags. */
+function describeDocument(adapter, backendInfo, format, limits) {
+    if (!Number.isInteger(backendInfo.pageCount) ||
+        backendInfo.pageCount < 1 ||
+        backendInfo.pageCount > limits.maxDocumentUnits)
+        throw new ViewerError("resource-limit", "Document unit count exceeds the configured limit", {
+            details: {
+                pageCount: backendInfo.pageCount,
+                limit: limits.maxDocumentUnits,
+            },
+        });
+    return immutableInfo({
+        ...backendInfo,
+        capabilities: {
+            textSelection: Boolean(adapter.getTextMap),
+            cellSelection: backendInfo.unit === "sheet",
+            search: Boolean(adapter.getTextMap),
+            thumbnails: backendInfo.unit !== "sheet",
+            editing: editableFormat(adapter, format) !== undefined,
+        },
+    });
+}
 function clampZoom(value) {
     if (!Number.isFinite(value))
         return 1;

package/dist/viewport.d.ts

@@ -1,4 +1,5 @@
 import type { CellRange, CellSelection, DocumentInfo, HeadlessRenderOptions, SearchMatch, TextRun, TextSelectionRange, ViewerState, SpreadsheetViewportRange } from "./contracts.js";
+import type { PageHit, PageRect, ViewportRect } from "./edit/types.js";
 export interface ViewportHost {
     readonly state: ViewerState;
     renderPage(pageIndex: number, target: HTMLCanvasElement, options: HeadlessRenderOptions): Promise<void>;
@@ -12,9 +13,15 @@ export interface ViewportHost {
     onTextSelection(range: TextSelectionRange): void;
     onCellSelection(selection: CellRange | CellSelection | null): void;
     getSelectionText(): string | undefined;
+    /** Pages whose paint for content revision `revision` just finished. */
+    onPainted(pages: readonly number[], revision: number): void;
 }
 interface ViewportStrategy {
     setDocument(info: DocumentInfo | undefined): void;
+    /** New content of the same document: keeps zoom and scroll, re-renders. */
+    replaceDocument(info: DocumentInfo, changedPages?: readonly number[], revision?: number): void;
+    pageToClient(pageIndex: number, rect: PageRect): ViewportRect | undefined;
+    clientToPage(clientX: number, clientY: number): PageHit | undefined;
     update(): void;
     panBy(deltaX: number, deltaY: number): void;
     goToPage(pageIndex: number): void;
@@ -30,6 +37,9 @@ export declare class AdaptiveViewport implements ViewportStrategy {
         readonly layout?: "continuous" | "single";
     });
     setDocument(info: DocumentInfo | undefined): void;
+    replaceDocument(info: DocumentInfo, changedPages?: readonly number[], revision?: number): void;
+    pageToClient(pageIndex: number, rect: PageRect): ViewportRect | undefined;
+    clientToPage(clientX: number, clientY: number): PageHit | undefined;
     update(): void;
     panBy(deltaX: number, deltaY: number): void;
     goToPage(pageIndex: number): void;
@@ -45,6 +55,9 @@ export declare class ViewerViewport {
         readonly layout?: "continuous" | "single";
     });
     setDocument(info: DocumentInfo | undefined): void;
+    replaceDocument(info: DocumentInfo, changedPages?: readonly number[], revision?: number): void;
+    pageToClient(pageIndex: number, rect: PageRect): ViewportRect | undefined;
+    clientToPage(clientX: number, clientY: number): PageHit | undefined;
     update(): void;
     panBy(deltaX: number, deltaY: number): void;
     goToPage(pageIndex: number): void;

package/dist/viewport.js

@@ -30,6 +30,19 @@ export class AdaptiveViewport {
         }
         this.#strategy.setDocument(info);
     }
+    replaceDocument(info, changedPages, revision) {
+        const nextKind = info.unit === "sheet" ? "sheet" : "page";
+        if (nextKind !== this.#kind)
+            this.setDocument(info);
+        else
+            this.#strategy.replaceDocument(info, changedPages, revision);
+    }
+    pageToClient(pageIndex, rect) {
+        return this.#strategy.pageToClient(pageIndex, rect);
+    }
+    clientToPage(clientX, clientY) {
+        return this.#strategy.clientToPage(clientX, clientY);
+    }
     update() {
         this.#strategy.update();
     }
@@ -70,6 +83,13 @@ export class ViewerViewport {
     #onSelectionChange = () => this.#handleSelectionChange();
     #pointers = new Map();
     #info;
+    /** Per page: grows when that page's content changed, so only it re-renders. */
+    #pageRevisions = [];
+    /** The session revision the shown content belongs to; 0 before any edit. */
+    #contentRevision = 0;
+    /** Pages painted since the last `onPainted`, keyed by content revision. */
+    #painted = new Map();
+    #paintedFlush = 0;
     #frame = 0;
     #resizeObserver;
     #destroyed = false;
@@ -126,11 +146,90 @@ export class ViewerViewport {
     }
     setDocument(info) {
         this.#info = info;
+        this.#pageRevisions = [];
+        this.#contentRevision = 0;
+        this.#painted.clear();
         this.#appliedZoom = this.#host.state.zoom;
         this.#root.scrollTo({ left: 0, top: 0 });
         this.#clearSlots();
         this.schedule();
     }
+    replaceDocument(info, changedPages, revision) {
+        const previous = this.#info;
+        this.#info = info;
+        this.#contentRevision = revision ?? this.#contentRevision + 1;
+        // Only pages whose content or size changed get a new render key; the
+        // others keep their bitmaps. A changed page count shifts everything
+        // from the first changed page on.
+        const countChanged = previous?.pageCount !== info.pageCount;
+        const from = changedPages === undefined
+            ? 0
+            : countChanged
+                ? Math.min(...changedPages, info.pageCount)
+                : Number.POSITIVE_INFINITY;
+        const changed = new Set(changedPages ?? []);
+        for (let pageIndex = 0; pageIndex < info.pageCount; pageIndex += 1) {
+            const size = info.pageSizes?.[pageIndex];
+            const before = previous?.pageSizes?.[pageIndex];
+            const resized = size?.width !== before?.width || size?.height !== before?.height;
+            if (pageIndex >= from || changed.has(pageIndex) || resized)
+                this.#pageRevisions[pageIndex] =
+                    (this.#pageRevisions[pageIndex] ?? 0) + 1;
+        }
+        // Slots stay mounted and repaint in place; the browser clamps the scroll
+        // position itself once the spacer takes the new document's height.
+        this.schedule();
+    }
+    pageToClient(pageIndex, rect) {
+        const page = this.#mountedPage(pageIndex);
+        if (!page)
+            return undefined;
+        return {
+            left: page.left + rect.x * page.scale,
+            top: page.top + rect.y * page.scale,
+            width: rect.width * page.scale,
+            height: rect.height * page.scale,
+        };
+    }
+    clientToPage(clientX, clientY) {
+        for (const pageIndex of this.#slots.keys()) {
+            const page = this.#mountedPage(pageIndex);
+            if (!page ||
+                clientX < page.left ||
+                clientX >= page.left + page.width ||
+                clientY < page.top ||
+                clientY >= page.top + page.height)
+                continue;
+            return {
+                pageIndex,
+                point: {
+                    x: (clientX - page.left) / page.scale,
+                    y: (clientY - page.top) / page.scale,
+                },
+            };
+        }
+        return undefined;
+    }
+    /**
+     * Client-space box of a mounted page and its page-space scale, read from
+     * the DOM so it matches what is painted rather than what is scheduled.
+     */
+    #mountedPage(pageIndex) {
+        const slot = this.#slots.get(pageIndex);
+        if (!slot || !this.#info)
+            return undefined;
+        const box = slot.root.getBoundingClientRect();
+        const natural = naturalPageSize(this.#info, pageIndex);
+        if (box.width <= 0 || box.height <= 0)
+            return undefined;
+        return {
+            left: box.left,
+            top: box.top,
+            width: box.width,
+            height: box.height,
+            scale: box.width / natural.width,
+        };
+    }
     update() {
         const zoom = this.#host.state.zoom;
         if (this.#info &&
@@ -198,6 +297,28 @@ export class ViewerViewport {
         const size = naturalPageSize(this.#info, this.#host.state.pageIndex);
         return Math.max(0.1, Math.min(8, (this.#root.clientWidth - 24) / size.width, (this.#root.clientHeight - 24) / size.height));
     }
+    /** Collects finished paints and reports them once per frame, newest content only. */
+    #markPainted(pageIndex, contentRevision) {
+        if (contentRevision !== this.#contentRevision)
+            return;
+        let pages = this.#painted.get(contentRevision);
+        if (!pages) {
+            pages = new Set();
+            this.#painted.clear();
+            this.#painted.set(contentRevision, pages);
+        }
+        pages.add(pageIndex);
+        if (this.#paintedFlush)
+            return;
+        this.#paintedFlush = requestAnimationFrame(() => {
+            this.#paintedFlush = 0;
+            const current = this.#painted.get(this.#contentRevision);
+            this.#painted.clear();
+            if (!current || current.size === 0 || this.#destroyed)
+                return;
+            this.#host.onPainted([...current].sort((a, b) => a - b), this.#contentRevision);
+        });
+    }
     schedule() {
         if (this.#destroyed || this.#frame)
             return;
@@ -212,6 +333,8 @@ export class ViewerViewport {
         this.#destroyed = true;
         if (this.#frame)
             cancelAnimationFrame(this.#frame);
+        if (this.#paintedFlush)
+            cancelAnimationFrame(this.#paintedFlush);
         if (this.#zoomSettleTimer)
             clearTimeout(this.#zoomSettleTimer);
         this.#resizeObserver?.disconnect();
@@ -266,7 +389,7 @@ export class ViewerViewport {
                 .getSearchMatches(pageIndex)
                 .map((match) => `${match.start}:${match.end}`)
                 .join(",");
-            const renderKey = `${state.zoom}:${window.devicePixelRatio || 1}:${highlights}`;
+            const renderKey = `${this.#pageRevisions[pageIndex] ?? 0}:${state.zoom}:${window.devicePixelRatio || 1}:${highlights}`;
             if (slot.renderKey === undefined ||
                 (!this.#zoomGestureActive && slot.renderKey !== renderKey)) {
                 slot.renderKey = renderKey;
@@ -320,6 +443,7 @@ export class ViewerViewport {
         slot.controller = controller;
         const generation = ++slot.generation;
         const zoom = this.#host.state.zoom;
+        const contentRevision = this.#contentRevision;
         try {
             let renderError;
             const rendering = this.#host
@@ -347,6 +471,7 @@ export class ViewerViewport {
             const cssHeight = slot.canvas.height / (window.devicePixelRatio || 1);
             slot.root.style.width = `${cssWidth}px`;
             slot.root.style.height = `${cssHeight}px`;
+            this.#markPainted(pageIndex, contentRevision);
         }
         catch (error) {
             if (!controller.signal.aborted) {

package/dist/worker-protocol.d.ts

@@ -1,5 +1,9 @@
 import type { DocumentFormat, DocumentInfo, ResourceLimits, TextRun, ViewerErrorData, ViewerProgress, ViewerWarning } from "./contracts.js";
-export type WorkerOperation = "init" | "open" | "get-info" | "render" | "get-text-map" | "close" | "destroy";
+import type { EditableFormat } from "./edit/types.js";
+export type DocumentWorkerOperation = "init" | "open" | "get-info" | "render" | "get-text-map" | "close" | "destroy";
+/** Operations of an edit engine worker; payloads mirror the engine interface. */
+export type EditWorkerOperation = "edit-init" | "edit-open" | "edit-validate" | "edit-apply" | "edit-materialize" | "edit-restore" | "edit-put-asset" | "edit-elements" | "edit-element" | "edit-elements-at" | "edit-find-text" | "edit-text-layout" | "edit-position-at" | "edit-range-rects" | "edit-render-without" | "edit-page-layout" | "edit-pptx-slides" | "edit-pptx-layouts" | "edit-dispose";
+export type WorkerOperation = DocumentWorkerOperation | EditWorkerOperation;
 export interface WorkerRequest {
     readonly kind: "request";
     readonly id: number;
@@ -44,5 +48,38 @@ export interface WorkerRenderPayload {
     readonly zoom: number;
     readonly devicePixelRatio: number;
 }
-export type WorkerOperationResult = DocumentInfo | readonly TextRun[] | ImageBitmap | ArrayBuffer | undefined;
+export interface EditWorkerInitPayload {
+    /** Where the worker fetches the engine's WebAssembly from. */
+    readonly wasmUrl: string;
+    /** TrueType font for text the standard PDF fonts cannot encode. */
+    readonly fallbackFontUrl?: string;
+}
+/** A host-registered font as the edit worker receives it. */
+export interface EditWorkerFont {
+    readonly family: string;
+    readonly weight: number;
+    readonly style: "normal" | "italic" | "oblique";
+    /** Font bytes, or an absolute URL the worker fetches on first use. */
+    readonly source: ArrayBuffer | string;
+}
+export interface EditWorkerOpenPayload {
+    readonly data: ArrayBuffer;
+    readonly limits: ResourceLimits;
+    /** The session format; a worker that serves several formats picks its engine by it. */
+    readonly format?: EditableFormat;
+    readonly fileName?: string;
+    readonly fonts?: readonly EditWorkerFont[];
+}
+/** A rendered page as the worker returns it; `data` is transferred, not copied. */
+export interface EditWorkerBitmap {
+    readonly pageIndex: number;
+    readonly scale: number;
+    readonly width: number;
+    readonly height: number;
+    readonly data: ArrayBuffer;
+}
+export interface EditWorkerOpenResult {
+    readonly pageCount: number;
+}
+export type WorkerOperationResult = DocumentInfo | readonly TextRun[] | ImageBitmap | ArrayBuffer | EditWorkerOpenResult | undefined;
 export declare function transferablesFor(value: unknown): Transferable[];