web-doc 0.12.1 → 0.13.1

package/dist/edit/pdf/engine/document.d.ts

@@ -36,9 +36,9 @@ export declare class PdfEditDocument {
     get pageCount(): number;
     get pdfium(): Pdfium;
     /**
-     * Checks a batch against the current document. Operations are checked one
-     * after another against the state before the batch, which is exact for
-     * everything but a page count another operation of the batch changes.
+     * Preflights a batch against its starting document. Applying revalidates
+     * each operation against earlier changes in the batch; created-element
+     * references are checked once their targets exist.
      */
     validate(operations: readonly PdfOrUnknownOperation[]): OperationIssue[];
     /**

package/dist/edit/pdf/engine/document.js

@@ -87,6 +87,12 @@ const CREATING_OPERATIONS = new Set([
     "insertImage",
     "insertTable",
 ]);
+/** Operations that change page order, and with it the index a loaded page is kept by. */
+const PAGE_ORDER_OPERATIONS = new Set([
+    "insertPage",
+    "deletePage",
+    "movePage",
+]);
 function referenceOf(operation) {
     const target = operation.target;
     return typeof target === "string" ? parseReference(target) : undefined;
@@ -129,6 +135,8 @@ export class PdfEditDocument {
     #batches = 0;
     /** Browser faces of the document's fonts, by font program; see `textFont`. */
     #faces = new Map();
+    /** Pages the running batch changed, by index; see `#batch`. */
+    #written;
     constructor(pdfium, original, fonts = new FontLibrary(async () => {
         throw new Error("No font source is configured");
     }), limits = defaultResourceLimits, assets = new AssetStore(), compact = compactPdf) {
@@ -167,9 +175,9 @@ export class PdfEditDocument {
         return this.#pdfium;
     }
     /**
-     * Checks a batch against the current document. Operations are checked one
-     * after another against the state before the batch, which is exact for
-     * everything but a page count another operation of the batch changes.
+     * Preflights a batch against its starting document. Applying revalidates
+     * each operation against earlier changes in the batch; created-element
+     * references are checked once their targets exist.
      */
     validate(operations) {
         const issues = [];
@@ -205,6 +213,9 @@ export class PdfEditDocument {
      * the next batch number as their state id.
      */
     apply(input) {
+        return this.#batch(() => this.#apply(input));
+    }
+    #apply(input) {
         const batch = Array.isArray(input)
             ? { stateId: this.#batches + 1, operations: input }
             : input;
@@ -225,11 +236,13 @@ export class PdfEditDocument {
                 details: { signatures: this.#signatures, features: this.#features },
             });
         operations.forEach((raw, operationIndex) => {
+            if (PAGE_ORDER_OPERATIONS.has(raw.op))
+                this.#writeBack();
             const handler = handlers[raw.op];
             if (!handler)
                 throw new ViewerError("internal", `Unknown pdf operation ${raw.op}`);
             const context = this.#context(stateId, operationIndex);
-            const operation = this.#resolveReference(raw, operationIndex, createdByOperation, handler, context);
+            const operation = this.#resolveAndValidate(raw, operationIndex, createdByOperation, handler, context);
             const result = handler.apply(operation, context);
             createdIds.push(...result.createdIds);
             createdByOperation[operationIndex] = [...result.createdIds];
@@ -251,23 +264,23 @@ export class PdfEditDocument {
         };
     }
     /**
-     * Turns a `"$<n>"` target into the id operation `n` created, then runs the
-     * handler's own checks on the resolved operation: a reference that lands
-     * on an element the operation cannot act on fails the batch the same way
-     * validation would have.
+     * Resolves a `"$<n>"` target, then checks every operation against the
+     * current document. Earlier operations may have moved, resized or removed
+     * an ordinary target since the batch's initial preflight.
      */
-    #resolveReference(operation, operationIndex, createdByOperation, handler, context) {
+    #resolveAndValidate(operation, operationIndex, createdByOperation, handler, context) {
         const reference = referenceOf(operation);
-        if (reference === undefined)
-            return operation;
         const issues = [];
         const issue = issueCollector(operationIndex, issues);
-        const id = createdByOperation[reference]?.[0];
-        if (id === undefined) {
-            issue("/target", "unknown-target", `Operation ${reference} created no element for "$${reference}"`);
-            throw invalidOperationError(issues);
+        let resolved = operation;
+        if (reference !== undefined && "target" in operation) {
+            const id = createdByOperation[reference]?.[0];
+            if (id === undefined) {
+                issue("/target", "unknown-target", `Operation ${reference} created no element for "$${reference}"`);
+                throw invalidOperationError(issues);
+            }
+            resolved = { ...operation, target: id };
         }
-        const resolved = { ...operation, target: id };
         handler.validate(resolved, context, issue);
         if (issues.length > 0)
             throw invalidOperationError(issues);
@@ -693,28 +706,71 @@ export class PdfEditDocument {
             }
             : undefined;
     }
-    /** Loads a page, lets `use` change it, regenerates its content stream. */
+    /**
+     * Loads a page and lets `use` change it. The page stays loaded until the
+     * batch ends, so what the batch reads next sees the change; see `#batch`.
+     */
     #writePage(pageIndex, use) {
-        const { lib } = this.#pdfium;
-        const page = lib.FPDF_LoadPage(this.#document.handle, pageIndex);
-        if (!page)
-            throw new ViewerError("render-failed", "PDFium could not load the page", {
-                details: { pageIndex },
-            });
+        if (!this.#written)
+            return this.#batch(() => this.#writePage(pageIndex, use));
+        let page = this.#written.get(pageIndex);
+        if (page === undefined) {
+            page = this.#pdfium.lib.FPDF_LoadPage(this.#document.handle, pageIndex);
+            if (!page)
+                throw new ViewerError("render-failed", "PDFium could not load the page", { details: { pageIndex } });
+            this.#written.set(pageIndex, page);
+        }
+        // Objects are assigned before the change so appended ones follow them.
+        this.#objectsOf(pageIndex, page);
+        const result = use(page);
+        delete this.#pages[pageIndex].elements;
+        delete this.#pages[pageIndex].paragraphs;
+        return result;
+    }
+    /**
+     * Runs `run` with the pages it changes kept loaded, then regenerates each
+     * page's content stream once. PDFium rewrites a whole stream however
+     * little changed, which takes seconds on a page of thousands of objects,
+     * and object reads (text, bounds) need no regenerated content. A failing
+     * batch closes its pages unwritten: the caller restores the working copy.
+     */
+    #batch(run) {
+        if (this.#written)
+            return run();
+        const written = new Map();
+        this.#written = written;
         try {
-            // Objects are assigned before the change so appended ones follow them.
-            this.#objectsOf(pageIndex, page);
-            const result = use(page);
-            if (!lib.FPDFPage_GenerateContent(page))
-                throw new ViewerError("edit-failed", "PDFium could not rewrite the page", {
-                    details: { stage: "apply", pageIndex },
-                });
-            delete this.#pages[pageIndex].elements;
-            delete this.#pages[pageIndex].paragraphs;
+            const result = run();
+            this.#writeBack();
             return result;
         }
         finally {
-            lib.FPDF_ClosePage(page);
+            this.#written = undefined;
+            for (const [pageIndex, page] of written) {
+                this.#pdfium.lib.FPDF_ClosePage(page);
+                delete this.#pages[pageIndex]?.elements;
+                delete this.#pages[pageIndex]?.paragraphs;
+            }
+        }
+    }
+    /** Regenerates and closes the pages the running batch changed. */
+    #writeBack() {
+        const written = this.#written;
+        if (!written)
+            return;
+        const { lib } = this.#pdfium;
+        for (const [pageIndex, page] of written) {
+            written.delete(pageIndex);
+            try {
+                if (!lib.FPDFPage_GenerateContent(page))
+                    throw new ViewerError("edit-failed", "PDFium could not rewrite the page", { details: { stage: "apply", pageIndex } });
+            }
+            finally {
+                lib.FPDF_ClosePage(page);
+            }
+            // Elements are read again from the regenerated content.
+            delete this.#pages[pageIndex].elements;
+            delete this.#pages[pageIndex].paragraphs;
         }
     }
     #originalPages() {
@@ -888,12 +944,28 @@ export class PdfEditDocument {
             const records = this.#objectsOf(pageIndex, page);
             const { byObject, elements } = scanPage(this.#pdfium, page, textPage, pageIndex, geometry, records);
             const offsets = this.#charOffsets(page, textPage, byObject, new Map(elements.map((element) => [element.id, element.text ?? ""])));
-            return use({ page, textPage, geometry, byObject, elements, offsets });
+            // A text box lays its lines out in the rect its mark keeps; only
+            // fresh marks are still on the records.
+            const frames = new Map();
+            for (const record of records)
+                if (record.mark?.kind === "textBox" && !frames.has(record.id))
+                    frames.set(record.id, roundRect(record.mark.rect));
+            return use({
+                page,
+                textPage,
+                geometry,
+                byObject,
+                elements,
+                offsets,
+                frames,
+            });
         });
     }
     #withPage(pageIndex, use) {
         const { lib } = this.#pdfium;
-        const page = lib.FPDF_LoadPage(this.#document.handle, pageIndex);
+        // A page the running batch changed is read as it stands in memory.
+        const written = this.#written?.get(pageIndex);
+        const page = written ?? lib.FPDF_LoadPage(this.#document.handle, pageIndex);
         if (!page)
             throw new ViewerError("render-failed", "PDFium could not load the page", {
                 details: { pageIndex },
@@ -908,7 +980,8 @@ export class PdfEditDocument {
             }
         }
         finally {
-            lib.FPDF_ClosePage(page);
+            if (written === undefined)
+                lib.FPDF_ClosePage(page);
         }
     }
     *#matches(textPage, query, options) {

package/dist/edit/pdf/engine/layout.d.ts

@@ -12,6 +12,8 @@ export interface TextPageScan {
     readonly elements: readonly PdfElement[];
     /** Per character of the text page: its element and offset, when an object draws it. */
     readonly offsets: readonly (TextPosition | undefined)[];
+    /** Element id → the rectangle its text is laid out in, for text boxes. */
+    readonly frames?: ReadonlyMap<string, PageRect>;
 }
 /** The layout of one element, or `undefined` when it draws no text. */
 export declare function layoutOf(pdfium: Pdfium, scan: TextPageScan, element: PdfElement): TextLayout | undefined;

package/dist/edit/pdf/engine/layout.js

@@ -8,10 +8,12 @@ export function layoutOf(pdfium, scan, element) {
     if (!TEXT_KINDS.has(element.kind))
         return undefined;
     const glyphs = glyphsOf(pdfium, scan, (position) => position.elementId === element.id);
+    const lines = linesOf(pdfium, scan, glyphs);
     return {
         elementId: element.id,
         pageIndex: element.pageIndex,
-        lines: linesOf(pdfium, scan, glyphs),
+        frame: frameOf(scan, element, lines),
+        lines,
     };
 }
 /** The layouts of every text element of the page, in reading order, from one pass. */
@@ -30,14 +32,30 @@ export function layoutsOf(pdfium, scan) {
         const own = byElement.get(element.id);
         if (!own || !TEXT_KINDS.has(element.kind))
             continue;
+        const lines = linesOf(pdfium, scan, own);
         layouts.push({
             elementId: element.id,
             pageIndex: element.pageIndex,
-            lines: linesOf(pdfium, scan, own),
+            frame: frameOf(scan, element, lines),
+            lines,
         });
     }
     return layouts;
 }
+/**
+ * The box an element's text is laid out in: a paragraph's frame (its bounds
+ * already start at the pen and span its widest advance), a text box's own
+ * rect, else the union of the lines' advance boxes.
+ */
+function frameOf(scan, element, lines) {
+    if (element.kind === "paragraph")
+        return element.bounds;
+    const own = scan.frames?.get(element.id);
+    if (own)
+        return own;
+    const boxes = lines.flatMap((line) => line.advanceBounds ? [line.advanceBounds] : []);
+    return boxes.length > 0 ? roundRect(unionRects(boxes)) : element.bounds;
+}
 /** The caret position nearest to a page-space point, or none without text. */
 export function positionIn(pdfium, scan, point) {
     const glyphs = glyphsOf(pdfium, scan, () => true);
@@ -105,6 +123,7 @@ function glyphsOf(pdfium, scan, keep) {
             position,
             char: String.fromCodePoint(lib.FPDFText_GetUnicode(textPage, index)),
             box: roundRect(userRectToPage(geometry, left, bottom, right, top)),
+            loose: roundRect(userRectToPage(geometry, looseLeft, looseBottom, looseRight, looseTop)),
             advance: round(Math.abs(looseRight - looseLeft)),
             origin: roundPoint(userToPage(geometry, origin[0], origin[1])),
         });
@@ -136,11 +155,15 @@ function linesOf(pdfium, scan, glyphs) {
             },
             text: members.map((glyph) => glyph.char).join(""),
             bounds: roundRect(unionRects(members.map((glyph) => glyph.box))),
+            // PDFium's loose boxes run from each origin to origin plus advance,
+            // ascent to descent: their union is the line a text field must hold.
+            advanceBounds: roundRect(unionRects(members.map((glyph) => glyph.loose))),
             baseline: members[0].origin,
-            glyphs: members.map(({ position, box, advance }) => ({
+            glyphs: members.map(({ position, box, advance, origin }) => ({
                 offset: position.offset,
                 box,
                 advance,
+                origin,
             })),
             fontFamily: style.fontFamily,
             fontSize: style.fontSize,

package/dist/edit/pdf/engine/text-box.d.ts

@@ -68,4 +68,4 @@ export declare function placeUpright(pdfium: Pdfium, object: number, geometry: P
 export declare function setText(pdfium: Pdfium, object: number, text: string): void;
 export declare function parseColor(color: string): [number, number, number];
 export declare function resolveStyle(style: PdfTextBoxStyle): TextBoxSpec["style"];
-export declare function validateRect(rect: PageRect, geometry: PageGeometry, issue: Issue, path?: string): void;
+export declare function validateRect(rect: PageRect, geometry: PageGeometry, issue: Issue, path?: string, current?: PageRect): void;

package/dist/edit/pdf/engine/text-box.js

@@ -319,12 +319,27 @@ export function resolveStyle(style) {
 function definedFields(style) {
     return Object.fromEntries(Object.entries(style).filter(([, value]) => value !== undefined));
 }
-export function validateRect(rect, geometry, issue, path = "/rect") {
+export function validateRect(rect, geometry, issue, path = "/rect", current) {
     const size = displayedSize(geometry);
     const tolerance = 0.01;
-    if (rect.x < -tolerance ||
-        rect.y < -tolerance ||
-        rect.x + rect.width > size.width + tolerance ||
-        rect.y + rect.height > size.height + tolerance)
-        issue(path, "range", `The rectangle must lie within the ${size.width}×${size.height} pt page`);
+    // Imported objects may already bleed outside the visible crop. Transforms
+    // can keep or reduce that overflow; the page tolerance must not accumulate
+    // on their current edges and permit repeated small outward steps.
+    const left = Math.min(-tolerance, current?.x ?? 0);
+    const top = Math.min(-tolerance, current?.y ?? 0);
+    const right = Math.max(size.width + tolerance, current ? current.x + current.width : 0);
+    const bottom = Math.max(size.height + tolerance, current ? current.y + current.height : 0);
+    const missesPage = current !== undefined &&
+        (rect.x >= size.width ||
+            rect.y >= size.height ||
+            rect.x + rect.width <= 0 ||
+            rect.y + rect.height <= 0);
+    if (rect.x < left ||
+        rect.y < top ||
+        rect.x + rect.width > right ||
+        rect.y + rect.height > bottom ||
+        missesPage)
+        issue(path, "range", current
+            ? `The rectangle must preserve or reduce existing overflow and remain partly visible within the ${size.width}×${size.height} pt page`
+            : `The rectangle must lie within the ${size.width}×${size.height} pt page`);
 }

package/dist/edit/pdf/engine/transform.js

@@ -20,7 +20,7 @@ export const moveElement = {
             return;
         }
         const delta = moveDelta(operation, target.element.bounds);
-        validateRect(shifted(target.element.bounds, delta.dx, delta.dy), context.geometry(target.location.pageIndex), issue, operation.to ? "/to" : "/by");
+        validateRect(shifted(target.element.bounds, delta.dx, delta.dy), context.geometry(target.location.pageIndex), issue, operation.to ? "/to" : "/by", target.element.bounds);
     },
     apply(operation, context) {
         const { location, element } = anyTarget(operation.target, context);
@@ -61,7 +61,7 @@ export const resizeElement = {
             issue("/target", "unsupported-target", "Tables and imported paragraphs cannot be resized");
             return;
         }
-        validateRect(operation.rect, context.geometry(target.location.pageIndex), issue);
+        validateRect(operation.rect, context.geometry(target.location.pageIndex), issue, "/rect", target.element.bounds);
     },
     apply(operation, context) {
         const { location, element } = anyTarget(operation.target, context);

package/dist/edit/pdf/types.d.ts

@@ -255,6 +255,12 @@ export interface TextLayoutGlyph {
     readonly box: PageRect;
     /** Advance width along the baseline, in points. */
     readonly advance: number;
+    /**
+     * Pen position on the baseline where the glyph starts, in page space. The
+     * steps between neighbours are the advances the file draws with, character
+     * and word spacing and TJ kerning included.
+     */
+    readonly origin?: PagePoint;
 }
 /** One line of a text element: one PDFium text object, as the file stores it. */
 export interface TextLayoutLine {
@@ -263,6 +269,15 @@ export interface TextLayoutLine {
     readonly text: string;
     /** Union of the glyph boxes, in page space. */
     readonly bounds: PageRect;
+    /**
+     * The box the line's advances fill, the size a text field needs to hold the
+     * line unwrapped: from the first glyph's origin to the last glyph's origin
+     * plus its advance, and from the font's ascent to its descent at the line's
+     * size. It differs from `bounds` by the glyphs' side bearings, usually
+     * wider; in page space and axis-aligned like `bounds`, so it turns with the
+     * text.
+     */
+    readonly advanceBounds?: PageRect;
     /** Start of the baseline, in page space. */
     readonly baseline: PagePoint;
     readonly glyphs: readonly TextLayoutGlyph[];
@@ -305,10 +320,17 @@ export interface TextFont {
      */
     readonly missing?: "not-embedded" | "cid-keyed" | "type1" | "no-unicode" | "unreadable";
 }
-/** The drawn geometry of a `text`, `textBox` or `table` element. */
+/** The drawn geometry of a `text`, `textBox`, `paragraph` or `table` element. */
 export interface TextLayout {
     readonly elementId: string;
     readonly pageIndex: number;
+    /**
+     * The box the element's text is laid out in, in page space: a text box's or
+     * a paragraph's own rectangle, otherwise the union of its lines'
+     * `advanceBounds`. Place an inline text field here rather than on the ink
+     * `bounds`, which a browser's advance-based layout outgrows.
+     */
+    readonly frame?: PageRect;
     /** Lines in reading order: a text box's lines, a table's cells. */
     readonly lines: readonly TextLayoutLine[];
 }

package/dist/edit/session.js

@@ -6,6 +6,11 @@ import { buildToolSet, callTool as runTool } from "./ai/tools.js";
 import { assetIdOf, AssetStore, binaryFields, isAssetReference, } from "./assets.js";
 import { batchOf, EditHistory, modeOf } from "./history.js";
 import { assertBatchSize, checkOperations, freezeOperations, invalidOperationError, parseReference, } from "./operations.js";
+/**
+ * A state the engine would take at least this long to rebuild by replaying
+ * batches keeps its bytes, so undo, redo and recovery reopen it instead.
+ */
+const SLOW_REPLAY_MS = 1000;
 /**
  * The format-independent editing session: validation, history, revisions,
  * saving and the viewer refresh. Format modules wrap it to add typed methods.
@@ -26,6 +31,8 @@ export class EditSessionController {
     /** Materialized bytes of some committed states, by state id, so restores replay less. */
     #checkpoints = new Map();
     #checkpointBytes = 0;
+    /** Engine time each reachable state took to build from the state before it. */
+    #buildMs = new Map();
     /** Named checkpoints by id, in creation order. */
     #named = new Map();
     /** State ids named checkpoints pin, with how many name each; never evicted. */
@@ -106,10 +113,12 @@ export class EditSessionController {
                 });
             }
             const before = this.#history.pageCount;
-            const { change, shown } = await this.#transaction(signal, "apply", async () => {
+            const { change, shown, buildMs } = await this.#transaction(signal, "apply", async () => {
+                const started = performance.now();
                 const result = await this.#engine.apply(engineBatch, signal);
                 return {
                     change: result,
+                    buildMs: performance.now() - started,
                     shown: await this.#show(signal, this.#pagesOf(result.changedPages, result.reflowFrom)),
                 };
             });
@@ -126,7 +135,7 @@ export class EditSessionController {
                 pageCountBefore: before,
                 pageCountAfter: shown.pageCount,
             });
-            this.#commit("apply", shown.changedPages, shown);
+            this.#commit("apply", shown.changedPages, shown, buildMs);
             return this.#receipt(false, batch.length, change.createdIds, {
                 ...change,
                 changedPages: shown.changedPages,
@@ -293,8 +302,11 @@ export class EditSessionController {
                 return this.#noop();
             const before = this.#history.pageCount;
             const changedPages = allPages(Math.max(before, named.pageCount));
+            let buildMs = 0;
             const shown = await this.#transaction(signal, "apply", async () => {
+                const started = performance.now();
                 await this.#engine.restore(this.#targetFor(named.entries), signal);
+                buildMs = performance.now() - started;
                 return this.#show(signal, changedPages);
             });
             const diff = entryDiff(this.#history.entriesAt(this.#history.position), named.entries);
@@ -307,7 +319,7 @@ export class EditSessionController {
                 pageCountAfter: shown.pageCount,
                 base: { stateId: named.stateId, batches: named.batches },
             }, named.stateId);
-            this.#commit("restore", shown.changedPages, shown);
+            this.#commit("restore", shown.changedPages, shown, buildMs);
             return this.#receipt(false, 0, diff.created, {
                 removedIds: diff.removed,
                 changedPages: shown.changedPages,
@@ -509,10 +521,11 @@ export class EditSessionController {
             clearTimeout(timer);
         }
     }
-    #commit(reason, changedPages, shown) {
+    /** `buildMs`: the engine time the new state took, for an apply or a restore. */
+    #commit(reason, changedPages, shown, buildMs = 0) {
         this.#committedBytes = shown.bytes;
         if (reason === "apply" || reason === "restore")
-            this.#keepCheckpoint(shown.bytes);
+            this.#keepCheckpoint(shown.bytes, buildMs);
         else if (reason === "reset")
             this.#dropCheckpoints();
         this.#revision += 1;
@@ -595,8 +608,11 @@ export class EditSessionController {
             throw invalidOperationError(issues);
         return Object.freeze(result);
     }
-    /** Keeps every stride-th committed state's bytes within the memory budget. */
-    #keepCheckpoint(bytes) {
+    /**
+     * Keeps a committed state's bytes, within the memory budget, every
+     * stride-th state and whenever replaying to it would take SLOW_REPLAY_MS.
+     */
+    #keepCheckpoint(bytes, buildMs) {
         const stride = Math.max(1, Math.floor(this.#host.limits.maxEditHistory / 4));
         const stateId = this.#history.stateId;
         // Entries dropped by a new change after an undo can never be restored;
@@ -605,11 +621,32 @@ export class EditSessionController {
         for (const [id, kept] of this.#checkpoints)
             if (!reachable.has(id) && !this.#pinned.has(id))
                 this.#forgetCheckpoint(id, kept);
-        if (stateId === 0 ||
-            this.#checkpoints.has(stateId) ||
-            stateId % stride !== 0)
+        for (const id of this.#buildMs.keys())
+            if (!reachable.has(id))
+                this.#buildMs.delete(id);
+        if (stateId === 0 || this.#checkpoints.has(stateId))
             return;
-        this.#retain(stateId, bytes);
+        this.#buildMs.set(stateId, buildMs);
+        if (stateId % stride === 0 || this.#replayMs() >= SLOW_REPLAY_MS)
+            this.#retain(stateId, bytes);
+    }
+    /**
+     * The engine time a restore of the current state would spend replaying:
+     * what its entries took since the newest retained bytes, or since the
+     * original or a restore entry's rebuild.
+     */
+    #replayMs() {
+        const entries = this.#history.entriesAt(this.#history.position);
+        let total = 0;
+        for (let index = entries.length - 1; index >= 0; index -= 1) {
+            const entry = entries[index];
+            if (this.#checkpoints.has(entry.stateId))
+                break;
+            total += this.#buildMs.get(entry.stateId) ?? 0;
+            if (entry.base)
+                break;
+        }
+        return total;
     }
     /** Stores a state's bytes when the budget, less the pinned states, can hold them. */
     #retain(stateId, bytes) {

package/dist/workers/pdf-edit-worker.js

@@ -6759,10 +6759,12 @@ function layoutOf(pdfium, scan, element) {
     scan,
     (position) => position.elementId === element.id
   );
+  const lines = linesOf(pdfium, scan, glyphs);
   return {
     elementId: element.id,
     pageIndex: element.pageIndex,
-    lines: linesOf(pdfium, scan, glyphs)
+    frame: frameOf(scan, element, lines),
+    lines
   };
 }
 function layoutsOf(pdfium, scan) {
@@ -6777,14 +6779,25 @@ function layoutsOf(pdfium, scan) {
   for (const element of scan.elements) {
     const own = byElement.get(element.id);
     if (!own || !TEXT_KINDS.has(element.kind)) continue;
+    const lines = linesOf(pdfium, scan, own);
     layouts.push({
       elementId: element.id,
       pageIndex: element.pageIndex,
-      lines: linesOf(pdfium, scan, own)
+      frame: frameOf(scan, element, lines),
+      lines
     });
   }
   return layouts;
 }
+function frameOf(scan, element, lines) {
+  if (element.kind === "paragraph") return element.bounds;
+  const own = scan.frames?.get(element.id);
+  if (own) return own;
+  const boxes = lines.flatMap(
+    (line) => line.advanceBounds ? [line.advanceBounds] : []
+  );
+  return boxes.length > 0 ? roundRect(unionRects(boxes)) : element.bounds;
+}
 function positionIn(pdfium, scan, point) {
   const glyphs = glyphsOf(pdfium, scan, () => true);
   if (glyphs.length === 0) return void 0;
@@ -6859,6 +6872,9 @@ function glyphsOf(pdfium, scan, keep) {
       position,
       char: String.fromCodePoint(lib.FPDFText_GetUnicode(textPage, index)),
       box: roundRect(userRectToPage(geometry, left, bottom, right, top)),
+      loose: roundRect(
+        userRectToPage(geometry, looseLeft, looseBottom, looseRight, looseTop)
+      ),
       advance: round(Math.abs(looseRight - looseLeft)),
       origin: roundPoint(userToPage(geometry, origin[0], origin[1]))
     });
@@ -6886,11 +6902,15 @@ function linesOf(pdfium, scan, glyphs) {
       },
       text: members.map((glyph) => glyph.char).join(""),
       bounds: roundRect(unionRects(members.map((glyph) => glyph.box))),
+      // PDFium's loose boxes run from each origin to origin plus advance,
+      // ascent to descent: their union is the line a text field must hold.
+      advanceBounds: roundRect(unionRects(members.map((glyph) => glyph.loose))),
       baseline: members[0].origin,
-      glyphs: members.map(({ position, box, advance: advance2 }) => ({
+      glyphs: members.map(({ position, box, advance: advance2, origin }) => ({
         offset: position.offset,
         box,
-        advance: advance2
+        advance: advance2,
+        origin
       })),
       fontFamily: style.fontFamily,
       fontSize: style.fontSize,
@@ -9069,14 +9089,25 @@ function definedFields(style) {
     Object.entries(style).filter(([, value]) => value !== void 0)
   );
 }
-function validateRect(rect, geometry, issue, path = "/rect") {
+function validateRect(rect, geometry, issue, path = "/rect", current) {
   const size = displayedSize(geometry);
   const tolerance = 0.01;
-  if (rect.x < -tolerance || rect.y < -tolerance || rect.x + rect.width > size.width + tolerance || rect.y + rect.height > size.height + tolerance)
+  const left = Math.min(-tolerance, current?.x ?? 0);
+  const top = Math.min(-tolerance, current?.y ?? 0);
+  const right = Math.max(
+    size.width + tolerance,
+    current ? current.x + current.width : 0
+  );
+  const bottom = Math.max(
+    size.height + tolerance,
+    current ? current.y + current.height : 0
+  );
+  const missesPage = current !== void 0 && (rect.x >= size.width || rect.y >= size.height || rect.x + rect.width <= 0 || rect.y + rect.height <= 0);
+  if (rect.x < left || rect.y < top || rect.x + rect.width > right || rect.y + rect.height > bottom || missesPage)
     issue(
       path,
       "range",
-      `The rectangle must lie within the ${size.width}\xD7${size.height} pt page`
+      current ? `The rectangle must preserve or reduce existing overflow and remain partly visible within the ${size.width}\xD7${size.height} pt page` : `The rectangle must lie within the ${size.width}\xD7${size.height} pt page`
     );
 }
 
@@ -10277,7 +10308,8 @@ var moveElement = {
       shifted(target.element.bounds, delta.dx, delta.dy),
       context.geometry(target.location.pageIndex),
       issue,
-      operation2.to ? "/to" : "/by"
+      operation2.to ? "/to" : "/by",
+      target.element.bounds
     );
   },
   apply(operation2, context) {
@@ -10330,7 +10362,9 @@ var resizeElement = {
     validateRect(
       operation2.rect,
       context.geometry(target.location.pageIndex),
-      issue
+      issue,
+      "/rect",
+      target.element.bounds
     );
   },
   apply(operation2, context) {
@@ -11422,6 +11456,11 @@ var CREATING_OPERATIONS = /* @__PURE__ */ new Set([
   "insertImage",
   "insertTable"
 ]);
+var PAGE_ORDER_OPERATIONS = /* @__PURE__ */ new Set([
+  "insertPage",
+  "deletePage",
+  "movePage"
+]);
 function referenceOf(operation2) {
   const target = operation2.target;
   return typeof target === "string" ? parseReference(target) : void 0;
@@ -11464,6 +11503,8 @@ var PdfEditDocument = class {
   #batches = 0;
   /** Browser faces of the document's fonts, by font program; see `textFont`. */
   #faces = /* @__PURE__ */ new Map();
+  /** Pages the running batch changed, by index; see `#batch`. */
+  #written;
   constructor(pdfium, original, fonts = new FontLibrary(async () => {
     throw new Error("No font source is configured");
   }), limits = defaultResourceLimits, assets = new AssetStore(), compact = compactPdf) {
@@ -11506,9 +11547,9 @@ var PdfEditDocument = class {
     return this.#pdfium;
   }
   /**
-   * Checks a batch against the current document. Operations are checked one
-   * after another against the state before the batch, which is exact for
-   * everything but a page count another operation of the batch changes.
+   * Preflights a batch against its starting document. Applying revalidates
+   * each operation against earlier changes in the batch; created-element
+   * references are checked once their targets exist.
    */
   validate(operations) {
     const issues = [];
@@ -11545,6 +11586,9 @@ var PdfEditDocument = class {
    * the next batch number as their state id.
    */
   apply(input) {
+    return this.#batch(() => this.#apply(input));
+  }
+  #apply(input) {
     const batch = Array.isArray(input) ? { stateId: this.#batches + 1, operations: input } : input;
     const { stateId, operations } = batch;
     const createdIds = [];
@@ -11560,11 +11604,12 @@ var PdfEditDocument = class {
         details: { signatures: this.#signatures, features: this.#features }
       });
     operations.forEach((raw, operationIndex) => {
+      if (PAGE_ORDER_OPERATIONS.has(raw.op)) this.#writeBack();
       const handler = handlers[raw.op];
       if (!handler)
         throw new ViewerError("internal", `Unknown pdf operation ${raw.op}`);
       const context = this.#context(stateId, operationIndex);
-      const operation2 = this.#resolveReference(
+      const operation2 = this.#resolveAndValidate(
         raw,
         operationIndex,
         createdByOperation,
@@ -11591,26 +11636,27 @@ var PdfEditDocument = class {
     };
   }
   /**
-   * Turns a `"$<n>"` target into the id operation `n` created, then runs the
-   * handler's own checks on the resolved operation: a reference that lands
-   * on an element the operation cannot act on fails the batch the same way
-   * validation would have.
+   * Resolves a `"$<n>"` target, then checks every operation against the
+   * current document. Earlier operations may have moved, resized or removed
+   * an ordinary target since the batch's initial preflight.
    */
-  #resolveReference(operation2, operationIndex, createdByOperation, handler, context) {
+  #resolveAndValidate(operation2, operationIndex, createdByOperation, handler, context) {
     const reference = referenceOf(operation2);
-    if (reference === void 0) return operation2;
     const issues = [];
     const issue = issueCollector(operationIndex, issues);
-    const id = createdByOperation[reference]?.[0];
-    if (id === void 0) {
-      issue(
-        "/target",
-        "unknown-target",
-        `Operation ${reference} created no element for "$${reference}"`
-      );
-      throw invalidOperationError(issues);
+    let resolved = operation2;
+    if (reference !== void 0 && "target" in operation2) {
+      const id = createdByOperation[reference]?.[0];
+      if (id === void 0) {
+        issue(
+          "/target",
+          "unknown-target",
+          `Operation ${reference} created no element for "$${reference}"`
+        );
+        throw invalidOperationError(issues);
+      }
+      resolved = { ...operation2, target: id };
     }
-    const resolved = { ...operation2, target: id };
     handler.validate(resolved, context, issue);
     if (issues.length > 0) throw invalidOperationError(issues);
     return resolved;
@@ -12030,30 +12076,73 @@ var PdfEditDocument = class {
       record: { ...first, id, mark: paragraph.spec }
     } : void 0;
   }
-  /** Loads a page, lets `use` change it, regenerates its content stream. */
+  /**
+   * Loads a page and lets `use` change it. The page stays loaded until the
+   * batch ends, so what the batch reads next sees the change; see `#batch`.
+   */
   #writePage(pageIndex, use) {
-    const { lib } = this.#pdfium;
-    const page = lib.FPDF_LoadPage(this.#document.handle, pageIndex);
-    if (!page)
-      throw new ViewerError("render-failed", "PDFium could not load the page", {
-        details: { pageIndex }
-      });
-    try {
-      this.#objectsOf(pageIndex, page);
-      const result3 = use(page);
-      if (!lib.FPDFPage_GenerateContent(page))
+    if (!this.#written)
+      return this.#batch(() => this.#writePage(pageIndex, use));
+    let page = this.#written.get(pageIndex);
+    if (page === void 0) {
+      page = this.#pdfium.lib.FPDF_LoadPage(this.#document.handle, pageIndex);
+      if (!page)
         throw new ViewerError(
-          "edit-failed",
-          "PDFium could not rewrite the page",
-          {
-            details: { stage: "apply", pageIndex }
-          }
+          "render-failed",
+          "PDFium could not load the page",
+          { details: { pageIndex } }
         );
-      delete this.#pages[pageIndex].elements;
-      delete this.#pages[pageIndex].paragraphs;
+      this.#written.set(pageIndex, page);
+    }
+    this.#objectsOf(pageIndex, page);
+    const result3 = use(page);
+    delete this.#pages[pageIndex].elements;
+    delete this.#pages[pageIndex].paragraphs;
+    return result3;
+  }
+  /**
+   * Runs `run` with the pages it changes kept loaded, then regenerates each
+   * page's content stream once. PDFium rewrites a whole stream however
+   * little changed, which takes seconds on a page of thousands of objects,
+   * and object reads (text, bounds) need no regenerated content. A failing
+   * batch closes its pages unwritten: the caller restores the working copy.
+   */
+  #batch(run2) {
+    if (this.#written) return run2();
+    const written = /* @__PURE__ */ new Map();
+    this.#written = written;
+    try {
+      const result3 = run2();
+      this.#writeBack();
       return result3;
     } finally {
-      lib.FPDF_ClosePage(page);
+      this.#written = void 0;
+      for (const [pageIndex, page] of written) {
+        this.#pdfium.lib.FPDF_ClosePage(page);
+        delete this.#pages[pageIndex]?.elements;
+        delete this.#pages[pageIndex]?.paragraphs;
+      }
+    }
+  }
+  /** Regenerates and closes the pages the running batch changed. */
+  #writeBack() {
+    const written = this.#written;
+    if (!written) return;
+    const { lib } = this.#pdfium;
+    for (const [pageIndex, page] of written) {
+      written.delete(pageIndex);
+      try {
+        if (!lib.FPDFPage_GenerateContent(page))
+          throw new ViewerError(
+            "edit-failed",
+            "PDFium could not rewrite the page",
+            { details: { stage: "apply", pageIndex } }
+          );
+      } finally {
+        lib.FPDF_ClosePage(page);
+      }
+      delete this.#pages[pageIndex].elements;
+      delete this.#pages[pageIndex].paragraphs;
     }
   }
   #originalPages() {
@@ -12244,12 +12333,25 @@ var PdfEditDocument = class {
         byObject,
         new Map(elements.map((element) => [element.id, element.text ?? ""]))
       );
-      return use({ page, textPage, geometry, byObject, elements, offsets });
+      const frames = /* @__PURE__ */ new Map();
+      for (const record of records)
+        if (record.mark?.kind === "textBox" && !frames.has(record.id))
+          frames.set(record.id, roundRect(record.mark.rect));
+      return use({
+        page,
+        textPage,
+        geometry,
+        byObject,
+        elements,
+        offsets,
+        frames
+      });
     });
   }
   #withPage(pageIndex, use) {
     const { lib } = this.#pdfium;
-    const page = lib.FPDF_LoadPage(this.#document.handle, pageIndex);
+    const written = this.#written?.get(pageIndex);
+    const page = written ?? lib.FPDF_LoadPage(this.#document.handle, pageIndex);
     if (!page)
       throw new ViewerError("render-failed", "PDFium could not load the page", {
         details: { pageIndex }
@@ -12262,7 +12364,7 @@ var PdfEditDocument = class {
         lib.FPDFText_ClosePage(textPage);
       }
     } finally {
-      lib.FPDF_ClosePage(page);
+      if (written === void 0) lib.FPDF_ClosePage(page);
     }
   }
   *#matches(textPage, query, options) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "web-doc",
-  "version": "0.12.1",
+  "version": "0.13.1",
   "description": "web-doc — embeddable browser-only document viewer with Rust/WASM adapters (a fork of Zrimo)",
   "keywords": [
     "document-viewer",