web-doc 0.6.2 → 0.8.0

package/THIRD_PARTY_NOTICES.md

@@ -2,13 +2,22 @@
 
 The release artifact contains or depends on the following principal components. The generated SPDX SBOM in `artifacts/sbom.spdx.json` is the complete machine-readable inventory for the pinned lockfiles.
 
-- [`@silurus/ooxml`](https://github.com/yukiyokotani/office-open-xml-viewer) — MIT; modern Office parsing/rendering.
+- [`@silurus/ooxml`](https://github.com/yukiyokotani/office-open-xml-viewer) — MIT; modern Office parsing/rendering (0.88.0 for DOCX, XLSX and PPTX). The package ships its own `THIRD_PARTY_NOTICES.md` for what the engine bundles; its optional region-map renderer carries a public-domain Natural Earth dataset and its optional math bundle MathJax, neither of which Zrimo imports.
 - [`office_oxide`](https://github.com/yfedoseev/office_oxide) — MIT OR Apache-2.0; compound-file handling, Office IR/writer utilities and legacy XLS/PPT conversion.
 - [`Fuse.js`](https://github.com/krisk/Fuse) — Apache-2.0; fuzzy matching behind the opt-in `search()` fallback.
 - [`pdfjs-dist` / Mozilla PDF.js](https://github.com/mozilla/pdf.js) — Apache-2.0; browser PDF parsing,
   font/CMap handling, canvas rendering, and text extraction. The packaged
   standard-font, ICC, CMap, OpenJPEG, JBIG2, and QCMS assets retain the license
   files distributed with PDF.js under `dist/assets/pdfjs/`.
+- [`@embedpdf/pdfium`](https://github.com/embedpdf/embed-pdf-viewer/tree/main/packages/pdfium) — MIT
+  per the license file and `package.json` of the pinned 2.15.1 tarball (the
+  upstream repository moved to Apache-2.0 on 2026-07-20); loaded only by the
+  PDF edit worker. It bundles [PDFium](https://pdfium.googlesource.com/pdfium/)
+  compiled to WebAssembly — BSD-3-Clause, see `LICENSE.pdfium` in that package —
+  together with the third-party libraries PDFium builds in, such as FreeType
+  (FreeType License), OpenJPEG (BSD-2-Clause), libpng (libpng License), zlib
+  (Zlib License) and Anti-Grain Geometry 2.3, whose notices ship with the
+  PDFium source tree.
 - [`core-js`](https://github.com/zloirock/core-js) compatibility modules embedded in the PDF.js legacy browser build —
   MIT; polyfills required by the supported browser matrix, including the PDF
   worker realm.
@@ -17,5 +26,28 @@ The release artifact contains or depends on the following principal components.
 - [`wasm-bindgen`](https://github.com/wasm-bindgen/wasm-bindgen) — MIT OR Apache-2.0; browser bindings for project-owned Rust/WASM modules.
 - [`zip`](https://github.com/zip-rs/zip2) — MIT; bounded in-memory ZIP/OOXML package manipulation.
 - [Serde](https://github.com/serde-rs/serde), [`serde_json`](https://github.com/serde-rs/json) and [`thiserror`](https://github.com/dtolnay/thiserror) — MIT OR Apache-2.0; serialization and structured Rust errors.
+- [GenOffice](https://github.com/genspark-ai/genoffice) — Apache-2.0; the
+  selection-to-object matching ladder of the PDF overlay primitives (rectangle
+  overlap, then a single containing object, then a text match after NFKC
+  folding) follows the technique of its `apps/pdf/src/main/text-edit.ts`, and
+  the PPTX text editing of `packages/viewer/src/edit/pptx/` follows its
+  published ideas of tracing edited runs to their source so formatting
+  survives, rebuilding only the paragraphs an edit touches, keeping
+  `a:bodyPr` and `a:lstStyle`, and dropping a stale autofit scale. The DOCX
+  editing of `packages/viewer/src/edit/docx/` follows its published ideas of
+  a flat block index over the original bytes with the raw paragraph and run
+  properties kept, property merges that keep the original bytes where a
+  value does not change and place new children in schema order, and
+  section properties that an edited paragraph never duplicates. The AI
+  tooling of `packages/viewer/src/edit/ai/` follows its published ideas of
+  a numbered document skeleton the model reads first with full content
+  pulled on demand within a character budget, writes made only through a
+  small validated tool set with a dry run, index addressing guarded by an
+  optimistic "document seen" check, a per-turn snapshot to roll back, and
+  Word tracked changes authored by the AI as the review channel. The
+  implementations in `packages/viewer/src/edit/pdf/selection.ts`,
+  `packages/viewer/src/edit/pptx/`, `packages/viewer/src/edit/docx/` and
+  `packages/viewer/src/edit/ai/` are web-doc's own; no GenOffice code is
+  included.
 - [Noto Sans](https://github.com/notofonts/noto-fonts) and [Noto Sans CJK](https://github.com/notofonts/noto-cjk) subset fonts — SIL Open Font License 1.1. The font manifest, complete OFL text, pinned source commits and SHA-256 hashes are included in `dist/fonts/`.
   No Microsoft proprietary font or copyleft runtime component is bundled. Transitive notices and license expressions are verified by `npm run licenses`.

package/dist/adapters/docx-images.d.ts

@@ -2,10 +2,16 @@
  * Word draws an inline picture at its declared extent even when that is wider
  * than the text area, so a generated document that embeds a 21-inch chart on
  * a 6.5-inch column shows a clipped picture. A viewer has no margin to spill
- * into, so before the page layout runs the oversized inline pictures are
- * scaled down to fit the section's content box, aspect ratio preserved.
- * Anchored (floating) pictures keep their geometry: their position is part of
- * the author's layout.
+ * into, so the oversized inline pictures are scaled down to fit the section's
+ * content box, aspect ratio preserved. Anchored (floating) pictures keep
+ * their geometry: their position is part of the author's layout.
+ *
+ * @deprecated The viewer no longer calls this helper: since `@silurus/ooxml`
+ * 0.88 lays a document out inside `load()`, adjusting the parsed model
+ * changes nothing on the page. The fitting now happens in the XML before the
+ * engine reads it (`prepareDocxForDisplay`). The helper stays exported for
+ * hosts that applied it to their own `main`-mode models and is removed in
+ * the next major version.
  */
 export interface DocxSectionGeometry {
     readonly pageWidth: number;
@@ -22,5 +28,8 @@ export interface DocxModelLike {
 /**
  * Shrink every inline picture that would not fit its section's content box.
  * Mutates the model in place and returns how many pictures were scaled.
+ *
+ * @deprecated See the module note: the viewer fits pictures in the XML
+ * pre-pass instead; this helper is removed in the next major version.
  */
 export declare function fitInlineImagesToPage(model: DocxModelLike): number;

package/dist/adapters/docx-images.js

@@ -1,6 +1,9 @@
 /**
  * Shrink every inline picture that would not fit its section's content box.
  * Mutates the model in place and returns how many pictures were scaled.
+ *
+ * @deprecated See the module note: the viewer fits pictures in the XML
+ * pre-pass instead; this helper is removed in the next major version.
  */
 export function fitInlineImagesToPage(model) {
     let scaled = 0;

package/dist/adapters/docx-paragraphs.d.ts

@@ -0,0 +1,65 @@
+export type DocxStory = "body" | "header" | "footer" | "footnote" | "endnote" | "textbox";
+export interface DocxRunSource {
+    readonly story: DocxStory | string;
+    readonly storyInstance: string;
+    readonly path: readonly number[];
+}
+export interface DocxModelParagraph {
+    readonly type: "paragraph";
+    readonly paragraphId?: string;
+    readonly bookmarks?: readonly string[];
+    readonly runs?: readonly DocxModelRun[];
+}
+export interface DocxModelRun {
+    readonly type?: string;
+    /** The blocks a text box shape holds. */
+    readonly textBoxContent?: readonly DocxModelBlock[];
+}
+export interface DocxModelTable {
+    readonly type: "table";
+    readonly rows: readonly {
+        readonly cells: readonly {
+            readonly content: readonly DocxModelBlock[];
+        }[];
+    }[];
+}
+export interface DocxModelHeaderFooter {
+    readonly body: readonly DocxModelBlock[];
+}
+export interface DocxModelHeadersFooters {
+    readonly default?: DocxModelHeaderFooter | null;
+    readonly first?: DocxModelHeaderFooter | null;
+    readonly even?: DocxModelHeaderFooter | null;
+}
+export interface DocxModelSectionBreak {
+    readonly type: "sectionBreak";
+    readonly headers?: DocxModelHeadersFooters;
+    readonly footers?: DocxModelHeadersFooters;
+}
+export interface DocxModelPageBreak {
+    readonly type: "pageBreak";
+}
+export type DocxModelBlock = DocxModelParagraph | DocxModelTable | DocxModelSectionBreak | DocxModelPageBreak | {
+    readonly type: string;
+};
+export interface DocxModelNote {
+    readonly id: string;
+    readonly content: readonly DocxModelBlock[];
+}
+/** The part of the engine's document model the bridge walks. */
+export interface DocxModelDocument {
+    readonly body: readonly DocxModelBlock[];
+    readonly headers?: DocxModelHeadersFooters;
+    readonly footers?: DocxModelHeadersFooters;
+    readonly footnotes?: readonly DocxModelNote[];
+    readonly endnotes?: readonly DocxModelNote[];
+}
+/** Resolves a run's source to the id of its `w:p`, or `undefined`. */
+export type DocxParagraphIdResolver = (source: DocxRunSource | undefined) => string | undefined;
+/**
+ * A resolver over one document model. Results are cached per source, so a
+ * page's runs (many per paragraph) cost one walk per paragraph.
+ */
+export declare function createDocxParagraphIdResolver(model: DocxModelDocument | undefined): DocxParagraphIdResolver;
+/** The id a model paragraph carries: its own `paragraphId` or its bookmark. */
+export declare function paragraphIdOf(paragraph: DocxModelParagraph): string | undefined;

package/dist/adapters/docx-paragraphs.js

@@ -0,0 +1,165 @@
+/*
+ * The paragraph bridge for DOCX text runs. The renderer lays out from its
+ * own model and tags every run with a `source`: the story it came from
+ * (`body`, a header or footer, a note, a text box), the story instance and
+ * the path of block indices that leads to the paragraph (a table adds its
+ * row and cell indices, the last entry is the run index). The display
+ * pre-pass marks every `w:p` of the file with a hidden `_wd<id>` bookmark,
+ * and the engine keeps bookmark names on its model paragraphs, so a run's
+ * source leads to a model paragraph whose bookmark names its `w:p`.
+ *
+ * Instance names follow the engine: `body` for the body, `default`, `first`
+ * or `even` for the document's headers and footers and `section:<i>:<kind>`
+ * for those a section break carries (`i` being the break's index in the
+ * body), the note id for footnotes and endnotes, and for a text box the
+ * `story:instance:path` key of the shape run that holds it.
+ */
+/** The name prefix of the pre-pass bookmarks that carry paragraph ids. */
+const BOOKMARK_PREFIX = "_wd";
+const HEADER_KINDS = ["default", "first", "even"];
+/**
+ * A resolver over one document model. Results are cached per source, so a
+ * page's runs (many per paragraph) cost one walk per paragraph.
+ */
+export function createDocxParagraphIdResolver(model) {
+    if (!model || !Array.isArray(model.body))
+        return () => undefined;
+    const cache = new Map();
+    return (source) => {
+        if (!source || !Array.isArray(source.path))
+            return undefined;
+        const key = `${source.story}\u0000${source.storyInstance}\u0000${source.path.join(",")}`;
+        if (cache.has(key))
+            return cache.get(key);
+        let id;
+        try {
+            const container = containerOf(model, source.story, source.storyInstance);
+            const located = container && paragraphAt(container, source.path);
+            id = located && paragraphIdAt(located.blocks, located.index);
+        }
+        catch {
+            id = undefined;
+        }
+        cache.set(key, id);
+        return id;
+    };
+}
+/** The id a model paragraph carries: its own `paragraphId` or its bookmark. */
+export function paragraphIdOf(paragraph) {
+    if (typeof paragraph.paragraphId === "string" && paragraph.paragraphId)
+        return paragraph.paragraphId;
+    for (const name of paragraph.bookmarks ?? [])
+        if (typeof name === "string" && name.startsWith(BOOKMARK_PREFIX))
+            return name.slice(BOOKMARK_PREFIX.length);
+    return undefined;
+}
+function containerOf(model, story, instance) {
+    switch (story) {
+        case "body":
+            return model.body;
+        case "header":
+        case "footer":
+            return headerFooterBody(model, story, instance);
+        case "footnote":
+            return model.footnotes?.find((note) => note.id === instance)?.content;
+        case "endnote":
+            return model.endnotes?.find((note) => note.id === instance)?.content;
+        case "textbox":
+            return textBoxContent(model, instance);
+        default:
+            return undefined;
+    }
+}
+function headerFooterBody(model, story, instance) {
+    const kindOf = (value) => HEADER_KINDS.find((kind) => kind === value);
+    const sectionMatch = /^section:(\d+):([a-z]+)$/.exec(instance);
+    if (sectionMatch) {
+        const block = model.body[Number(sectionMatch[1])];
+        const kind = kindOf(sectionMatch[2]);
+        if (!block || block.type !== "sectionBreak" || !kind)
+            return undefined;
+        const set = block[story === "header" ? "headers" : "footers"];
+        return set?.[kind]?.body;
+    }
+    const kind = kindOf(instance);
+    if (!kind)
+        return undefined;
+    const set = story === "header" ? model.headers : model.footers;
+    return set?.[kind]?.body;
+}
+/**
+ * A text box's instance is the `story:instance:path` key of the shape run
+ * that holds it; the path's last entry is that run's index in its paragraph.
+ */
+function textBoxContent(model, instance) {
+    const first = instance.indexOf(":");
+    const last = instance.lastIndexOf(":");
+    if (first < 0 || last <= first)
+        return undefined;
+    const story = instance.slice(0, first);
+    const hostInstance = instance.slice(first + 1, last);
+    const path = instance
+        .slice(last + 1)
+        .split(".")
+        .map((entry) => Number(entry));
+    if (path.length === 0 || path.some((entry) => !Number.isInteger(entry)))
+        return undefined;
+    const container = containerOf(model, story, hostInstance);
+    const located = container && paragraphAt(container, path);
+    const runIndex = located?.rest[0];
+    if (!located || runIndex === undefined)
+        return undefined;
+    const run = located.paragraph.runs?.[runIndex];
+    return Array.isArray(run?.textBoxContent) ? run.textBoxContent : undefined;
+}
+/** Follows a source path through blocks and table cells to its paragraph. */
+function paragraphAt(container, path) {
+    let blocks = container;
+    let at = 0;
+    while (at < path.length) {
+        const index = path[at];
+        const node = blocks[index];
+        if (!node)
+            return undefined;
+        if (node.type === "paragraph")
+            return {
+                blocks,
+                index,
+                paragraph: node,
+                rest: path.slice(at + 1),
+            };
+        if (node.type !== "table")
+            return undefined;
+        const cell = node.rows[path[at + 1] ?? -1]?.cells[path[at + 2] ?? -1];
+        if (!cell || !Array.isArray(cell.content))
+            return undefined;
+        blocks = cell.content;
+        at += 3;
+    }
+    return undefined;
+}
+/**
+ * The id of the paragraph at `index`. The engine splits a paragraph that
+ * holds a page break into two model paragraphs around a hoisted page break,
+ * and only the first keeps the bookmark, so an unmarked paragraph right
+ * after a page break takes the id of the paragraph before that break.
+ * Any other unmarked paragraph has no id: guessing would name the wrong
+ * `w:p`.
+ */
+function paragraphIdAt(blocks, index) {
+    let at = index;
+    for (;;) {
+        const node = blocks[at];
+        if (!node || node.type !== "paragraph")
+            return undefined;
+        const id = paragraphIdOf(node);
+        if (id !== undefined)
+            return id;
+        if (at >= 2 &&
+            blocks[at - 1]?.type === "pageBreak" &&
+            blocks[at - 2]?.type === "paragraph")
+            at -= 2;
+        else
+            return undefined;
+    }
+}

package/dist/adapters/docx-prepass.d.ts

@@ -0,0 +1,17 @@
+import type { ResourceLimits } from "../contracts.js";
+export { generatedParagraphId, PARAGRAPH_BOOKMARK_PREFIX, } from "../edit/docx/ids.js";
+export interface DocxPrepassResult {
+    /** The bytes to render; the input when nothing had to change. */
+    readonly bytes: Uint8Array;
+    /** Inline pictures scaled down. */
+    readonly scaledImages: number;
+    /** Paragraphs marked with an id bookmark. */
+    readonly markedParagraphs: number;
+    /** Of those, paragraphs whose id was generated (no `w14:paraId` in the file). */
+    readonly generatedIds: number;
+}
+/**
+ * Prepares DOCX bytes for display. A document the package layer cannot
+ * open or scan is returned as it is: the renderer reports its own errors.
+ */
+export declare function prepareDocxForDisplay(bytes: Uint8Array, limits: ResourceLimits, signal?: AbortSignal): Promise<DocxPrepassResult>;

package/dist/adapters/docx-prepass.js

@@ -0,0 +1,230 @@
+import { assignParagraphIds, collectIds, newIdState, OFFICE_RELATIONSHIPS, PARAGRAPH_BOOKMARK_PREFIX, STORY_RELATIONSHIP_TYPES, W_NS, } from "../edit/docx/ids.js";
+import { OoxmlPackage } from "../edit/ooxml/package.js";
+import { patches } from "../edit/ooxml/patch.js";
+export { generatedParagraphId, PARAGRAPH_BOOKMARK_PREFIX, } from "../edit/docx/ids.js";
+/*
+ * The DOCX display pre-pass: what the renderer should see instead of the
+ * file as stored, written as patches of the XML parts through the package
+ * layer and never into what an editor saves.
+ *
+ * 1. Oversized inline pictures are scaled down to their section's content
+ *    box, aspect ratio kept, as Word's own layout would not: Word draws a
+ *    21-inch picture on a 6.5-inch column clipped, a viewer has no margin
+ *    to spill into. Anchored pictures keep their geometry.
+ * 2. Every paragraph is marked with a hidden bookmark that carries its id —
+ *    the file's own `w14:paraId` when it has one, else a deterministic id
+ *    from its position — because the renderer keeps bookmark names on its
+ *    model paragraphs but does not read `w14:paraId`. An editor that walks
+ *    the same paragraphs in the same order computes the same ids from the
+ *    original bytes.
+ */
+const WP_NS = "http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing";
+const A_NS = "http://schemas.openxmlformats.org/drawingml/2006/main";
+/** EMU per twentieth of a point, the unit of page sizes and margins. */
+const EMU_PER_TWIP = 635;
+/** US Letter with one-inch margins, Word's default when a section says nothing. */
+const DEFAULT_SECTION = {
+    pageWidth: 12240,
+    pageHeight: 15840,
+    marginLeft: 1440,
+    marginRight: 1440,
+    marginTop: 1440,
+    marginBottom: 1440,
+};
+/**
+ * Prepares DOCX bytes for display. A document the package layer cannot
+ * open or scan is returned as it is: the renderer reports its own errors.
+ */
+export async function prepareDocxForDisplay(bytes, limits, signal) {
+    const unchanged = {
+        bytes,
+        scaledImages: 0,
+        markedParagraphs: 0,
+        generatedIds: 0,
+    };
+    let pkg;
+    try {
+        pkg = await OoxmlPackage.open(bytes, {
+            limits,
+            ...(signal ? { signal } : {}),
+        });
+    }
+    catch {
+        return unchanged;
+    }
+    try {
+        const root = await pkg.relationships("/", signal);
+        const main = root.byType(`${OFFICE_RELATIONSHIPS}officeDocument`)[0]
+            ?.targetPart;
+        if (!main || !pkg.has(main))
+            return unchanged;
+        const transaction = pkg.transaction();
+        let scaledImages = 0;
+        let markedParagraphs = 0;
+        let generatedIds = 0;
+        const counted = (marked, generated) => {
+            markedParagraphs += marked;
+            generatedIds += generated;
+        };
+        const document = await pkg.xml(main, signal);
+        const relationships = await pkg.relationships(main, signal);
+        const stories = [];
+        for (const type of STORY_RELATIONSHIP_TYPES)
+            for (const item of relationships.byType(type))
+                if (item.targetPart && pkg.has(item.targetPart))
+                    stories.push(await pkg.xml(item.targetPart, signal));
+        // Ids are unique across the document: every part is read before any is marked.
+        const state = newIdState();
+        for (const part of [document, ...stories])
+            collectIds(part, state);
+        const documentPatches = [
+            ...fitInlinePictures(document, (count) => (scaledImages += count)),
+        ];
+        documentPatches.push(...paragraphIdPatches(document, state, counted));
+        if (documentPatches.length > 0)
+            transaction.patch(document, documentPatches);
+        for (const part of stories) {
+            const items = paragraphIdPatches(part, state, counted);
+            if (items.length > 0)
+                transaction.patch(part, items);
+        }
+        if (scaledImages === 0 && markedParagraphs === 0)
+            return unchanged;
+        await transaction.commit(signal);
+        return {
+            bytes: await pkg.save({}, signal),
+            scaledImages,
+            markedParagraphs,
+            generatedIds,
+        };
+    }
+    catch {
+        return unchanged;
+    }
+}
+function sectionGeometry(part, sectPr) {
+    const read = (node, name, fallback) => {
+        const value = node ? Number(part.attribute(node, name) ?? NaN) : NaN;
+        return Number.isFinite(value) && value >= 0 ? value : fallback;
+    };
+    const pgSz = sectPr?.children.find((child) => child.local === "pgSz" && child.namespace === W_NS);
+    const pgMar = sectPr?.children.find((child) => child.local === "pgMar" && child.namespace === W_NS);
+    return {
+        pageWidth: read(pgSz, "w:w", DEFAULT_SECTION.pageWidth),
+        pageHeight: read(pgSz, "w:h", DEFAULT_SECTION.pageHeight),
+        marginLeft: read(pgMar, "w:left", DEFAULT_SECTION.marginLeft),
+        marginRight: read(pgMar, "w:right", DEFAULT_SECTION.marginRight),
+        marginTop: read(pgMar, "w:top", DEFAULT_SECTION.marginTop),
+        marginBottom: read(pgMar, "w:bottom", DEFAULT_SECTION.marginBottom),
+    };
+}
+/** Patches that scale the oversized inline pictures of the body, section by section. */
+function fitInlinePictures(part, count) {
+    const body = part.root.children.find((child) => child.local === "body" && child.namespace === W_NS);
+    if (!body)
+        return [];
+    const items = [];
+    // A w:sectPr closes the section that ends at it: the geometry of a run of
+    // body elements is known once the paragraph carrying the break, or the
+    // body's own w:sectPr, is reached.
+    let pending = [];
+    const flush = (sectPr) => {
+        const geometry = sectionGeometry(part, sectPr);
+        for (const element of pending)
+            items.push(...fitPicturesUnder(part, element, geometry, count));
+        pending = [];
+    };
+    let bodySectPr;
+    for (const element of body.children) {
+        if (element.namespace === W_NS && element.local === "sectPr") {
+            bodySectPr = element;
+            continue;
+        }
+        pending.push(element);
+        const sectPr = element.namespace === W_NS && element.local === "p"
+            ? element.children
+                .find((child) => child.local === "pPr" && child.namespace === W_NS)
+                ?.children.find((child) => child.local === "sectPr" && child.namespace === W_NS)
+            : undefined;
+        if (sectPr)
+            flush(sectPr);
+    }
+    flush(bodySectPr);
+    return items;
+}
+function fitPicturesUnder(part, element, geometry, count) {
+    const contentWidth = (geometry.pageWidth - geometry.marginLeft - geometry.marginRight) *
+        EMU_PER_TWIP;
+    const contentHeight = (geometry.pageHeight - geometry.marginTop - geometry.marginBottom) *
+        EMU_PER_TWIP;
+    if (!(contentWidth > 0 && contentHeight > 0))
+        return [];
+    const items = [];
+    for (const inline of part.findAll("inline", element)) {
+        if (inline.namespace !== WP_NS)
+            continue;
+        const extent = inline.children.find((child) => child.local === "extent" && child.namespace === WP_NS);
+        if (!extent)
+            continue;
+        const cx = Number(part.attribute(extent, "cx") ?? NaN);
+        const cy = Number(part.attribute(extent, "cy") ?? NaN);
+        if (!(cx > 0 && cy > 0))
+            continue;
+        const scale = Math.min(1, contentWidth / cx, contentHeight / cy);
+        if (scale >= 1)
+            continue;
+        const width = String(Math.round(cx * scale));
+        const height = String(Math.round(cy * scale));
+        items.push(patches.setAttribute(part, extent, "cx", width), patches.setAttribute(part, extent, "cy", height));
+        // The picture's own transform repeats the extent; keep both in step.
+        const ext = part
+            .findAll("ext", inline)
+            .find((candidate) => candidate.namespace === A_NS &&
+            candidate.parent?.local === "xfrm" &&
+            part.attribute(candidate, "cx") === String(cx) &&
+            part.attribute(candidate, "cy") === String(cy));
+        if (ext)
+            items.push(patches.setAttribute(part, ext, "cx", width), patches.setAttribute(part, ext, "cy", height));
+        count(1);
+    }
+    return items;
+}
+/**
+ * Patches that mark every `w:p` of a part with a hidden bookmark carrying
+ * its id: `_wd` plus the file's `w14:paraId`, or a generated id for a
+ * paragraph without one, unique across the document's story parts. The
+ * bookmark pair goes right after `w:pPr`, where the schema allows it, with
+ * ids above any the document already uses.
+ */
+function paragraphIdPatches(part, state, count) {
+    const paragraphs = assignParagraphIds(part, state);
+    if (paragraphs.length === 0)
+        return [];
+    const items = [];
+    let generated = 0;
+    for (const { paragraph, id, authored } of paragraphs) {
+        if (!authored)
+            generated += 1;
+        const name = `${PARAGRAPH_BOOKMARK_PREFIX}${id}`;
+        const start = `<w:bookmarkStart w:id="${state.bookmarkId}" w:name="${name}"/>`;
+        const end = `<w:bookmarkEnd w:id="${state.bookmarkId}"/>`;
+        state.bookmarkId += 1;
+        const pPr = paragraph.children.find((child) => child.local === "pPr" && child.namespace === W_NS);
+        if (pPr)
+            items.push(patches.insertAfter(part, pPr, start), patches.insertAfter(part, pPr, end));
+        else if (paragraph.selfClosing) {
+            // `<w:p …/>` opened around the bookmarks, as one element.
+            const xml = part.text.slice(paragraph.start, paragraph.end);
+            items.push(patches.replaceElement(part, paragraph, `${xml.slice(0, -2)}>${start}${end}</w:p>`));
+        }
+        else if (paragraph.children.length === 0) {
+            const xml = part.text.slice(paragraph.start, paragraph.end);
+            const open = paragraph.contentStart - paragraph.start;
+            items.push(patches.replaceElement(part, paragraph, `${xml.slice(0, open)}${start}${end}${xml.slice(open)}`));
+        }
+        else
+            items.push(patches.insertBefore(part, paragraph.children[0], start), patches.insertBefore(part, paragraph.children[0], end));
+    }
+    count(paragraphs.length, generated);
+    return items;
+}

package/dist/adapters/office.d.ts

@@ -1,11 +1,15 @@
 import type { AdapterOpenContext, DocumentAdapter, DocumentFormat, DocumentInfo, HyperlinkTarget, RenderViewport, SpreadsheetSheetInfo, TextRun, ViewerWarning } from "../contracts.js";
-import { type DocxModelLike } from "./docx-images.js";
+import type { EditEngineProvider } from "../edit/engine.js";
+import type { OoxmlEditProviderOptions } from "../edit/ooxml/worker.js";
+import { type DocxModelDocument, type DocxParagraphIdResolver, type DocxRunSource } from "./docx-paragraphs.js";
 declare const LEGACY_FORMATS: readonly ["doc", "xls", "ppt"];
 type LegacyFormat = (typeof LEGACY_FORMATS)[number];
 interface EngineLoadOptions {
     readonly useGoogleFonts: false;
     readonly maxZipEntryBytes: number;
     readonly mode: "main";
+    /** Presentations: lay slides out in the background after the first ones. */
+    readonly progressiveLayout?: boolean;
 }
 interface EngineHyperlink {
     readonly kind: "external" | "internal";
@@ -21,6 +25,10 @@ interface DocxRun {
     readonly h: number;
     readonly fontSize: number;
     readonly font: string;
+    /** The `w14:paraId` of the run's paragraph, when the engine reads one. */
+    readonly paragraphId?: string;
+    /** Where the run came from in the engine's model; the paragraph bridge. */
+    readonly source?: DocxRunSource;
     readonly letterSpacingPx?: number;
     readonly transform?: string;
     readonly eastAsianVert?: boolean;
@@ -28,10 +36,11 @@ interface DocxRun {
 }
 interface DocxBackend {
     readonly pageCount: number;
-    /** Render mode; the parsed model is only reachable in `main` mode. */
-    readonly mode?: "main" | "worker";
-    /** Parsed document model (main mode). Read lazily by the page layout. */
-    readonly document?: DocxModelLike;
+    /**
+     * The parsed model (`main` mode). Read once at open for the paragraph
+     * bridge: its paragraphs keep the pre-pass bookmarks that name each `w:p`.
+     */
+    readonly document?: DocxModelDocument;
     pageSize(pageIndex: number): {
         widthPt: number;
         heightPt: number;
@@ -178,12 +187,16 @@ export interface LegacyConversionOptions {
 export interface OfficeAdapterOptions {
     readonly engines?: OfficeEngineLoaders;
     readonly legacy?: LegacyConversionOptions;
+    /** Where the OOXML edit worker is served from; the package's own by default. */
+    readonly edit?: OoxmlEditProviderOptions;
 }
 interface DocumentHandle {
     readonly kind: "document";
     readonly format: DocumentFormat;
     readonly backend: DocxBackend;
     readonly warnings: readonly ViewerWarning[];
+    /** Maps a run's source to the id of its `w:p` (cached per paragraph). */
+    readonly paragraphIdOf: DocxParagraphIdResolver;
 }
 interface PresentationHandle {
     readonly kind: "presentation";
@@ -203,9 +216,22 @@ type OfficeHandle = DocumentHandle | PresentationHandle | SpreadsheetHandle;
 export declare class OfficeDocumentAdapter implements DocumentAdapter<OfficeHandle> {
     #private;
     readonly id = "office";
+    /**
+     * PPTX and DOCX editing on the OOXML package layer. The worker and the
+     * engine client are imported on the first `edit()`; viewing never loads
+     * them.
+     */
+    readonly edit: EditEngineProvider;
     readonly formats: readonly ["docx", "docm", "xlsx", "xlsm", "pptx", "pptm", "ppsx", "doc", "xls", "ppt"];
     constructor(options?: OfficeAdapterOptions);
     open(input: Uint8Array, context: AdapterOpenContext): Promise<OfficeHandle>;
+    /**
+     * Edited bytes open as a fresh document (the engine owns no reusable
+     * state); a presentation lays its slides out progressively so the slide
+     * on screen paints without waiting for the whole deck — Firefox takes
+     * seconds for a 500-slide preflight. The viewer closes `previous`.
+     */
+    reopen(_previous: OfficeHandle, data: Uint8Array, context: AdapterOpenContext): Promise<OfficeHandle>;
     getInfo(handle: OfficeHandle): Promise<DocumentInfo>;
     render(handle: OfficeHandle, target: HTMLCanvasElement | OffscreenCanvas, viewport: RenderViewport, signal?: AbortSignal): Promise<void>;
     getTextMap(handle: OfficeHandle, pageIndex: number, signal?: AbortSignal): Promise<readonly TextRun[]>;