web-doc 0.8.0 → 0.9.0

package/dist/edit/ai/tools.js

@@ -580,7 +580,9 @@ function describeOperation(format, pages, operation, id) {
         case "moveSlide":
             return `Moved ${pages} ${Number(fields.from) + 1} to ${Number(fields.to) + 1}`;
         case "rotatePage":
-            return `Rotated ${pages} ${Number(fields.pageIndex) + 1} to ${String(fields.rotation)}°`;
+            return fields.by === undefined
+                ? `Rotated ${pages} ${Number(fields.pageIndex) + 1} to ${String(fields.rotation)}°`
+                : `Turned ${pages} ${Number(fields.pageIndex) + 1} by ${String(fields.by)}°`;
         default:
             return `Applied ${operation.op}${target === "the element" ? "" : ` to ${target}`}${tag}`;
     }

package/dist/edit/docx/elements.js

@@ -81,10 +81,28 @@ function paragraphElement(model, record, base) {
         id: record.elementId,
         kind: "paragraph",
         text: record.text.text,
-        ...(record.table ? { parentId: record.table.elementId } : {}),
+        ...(record.table
+            ? { parentId: record.table.elementId, ...cellOf(record.table, record) }
+            : {}),
         textStyle: resolveTextStyle(model.styles, record.pPr, first?.rPr),
         paragraphStyle: resolveParagraphStyle(model.styles, record.pPr),
         ...(record.readOnlyReason ? { readOnlyReason: record.readOnlyReason } : {}),
         operations: operationsOf("paragraph", record.readOnlyReason !== undefined),
     };
 }
+/** Where each paragraph of a table sits, read once per table. */
+const CELLS = new WeakMap();
+/** The cell of a table that holds a paragraph, when the table lists it. */
+function cellOf(table, record) {
+    let cells = CELLS.get(table);
+    if (!cells) {
+        cells = new Map();
+        for (const [row, cellsOfRow] of table.rows.entries())
+            for (const [column, cell] of cellsOfRow.entries())
+                for (const paragraph of cell.paragraphs)
+                    cells.set(paragraph, { row, column });
+        CELLS.set(table, cells);
+    }
+    const cell = cells.get(record);
+    return cell ? { cell } : {};
+}

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

@@ -54,6 +54,14 @@ export interface DocxElement extends EditElement {
     readonly textStyle?: DocxTextStyle;
     /** Present for a paragraph. */
     readonly paragraphStyle?: DocxParagraphStyle;
+    /**
+     * Present for a paragraph in a table cell: the cell's row and its place in
+     * the row, both from 0. Paragraphs move only among those of the same cell.
+     */
+    readonly cell?: {
+        readonly row: number;
+        readonly column: number;
+    };
     /** Present for a table: cell text by row. */
     readonly table?: {
         readonly rows: readonly (readonly string[])[];

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

@@ -535,8 +535,11 @@ export class PdfEditDocument {
             },
             // Ids name the state the batch leads to, the operation and the item,
             // so replaying the history reproduces them and an undone id is never
-            // handed out again.
-            newId: (pageIndex, suffix = "") => `${this.#pages[pageIndex].key}:n${stateId}.${operationIndex}.${created++}${suffix}`,
+            // handed out again. A file saved by an earlier session carries the ids
+            // that session numbered from 1 as well, so one already on the page
+            // gets the first free `~n` instead (ACTION-886); the saved objects are
+            // part of the base, so a replay meets them and picks the same id.
+            newId: (pageIndex, suffix = "") => `${this.#unusedId(pageIndex, `${this.#pages[pageIndex].key}:n${stateId}.${operationIndex}.${created++}`)}${suffix}`,
             withPage: (pageIndex, use) => this.#writePage(pageIndex, use),
             appendObjects: (pageIndex, records) => {
                 const page = this.#pages[pageIndex];
@@ -686,10 +689,52 @@ export class PdfEditDocument {
             }
         }
         record.objects = objects.map((object, index) => object.mark && stale.has(object.id)
-            ? { id: `${record.key}:o${index}`, type: object.type }
+            ? {
+                id: `${record.key}:o${index}`,
+                type: object.type,
+                staleMarkId: object.id,
+            }
             : object);
         return record.objects;
     }
+    /**
+     * `id`, or its first free `~n` when an object saved by an earlier session
+     * has it already. Only ids a session numbered (`<key>:n…`) can collide, so
+     * only those are gathered; the objects are read without the page's text.
+     */
+    #unusedId(pageIndex, id) {
+        const record = this.#pages[pageIndex];
+        const objects = record.objects ?? this.#loadObjects(pageIndex);
+        const numbered = `${record.key}:n`;
+        const taken = new Set();
+        for (const object of objects) {
+            if (object.id.startsWith(numbered))
+                taken.add(object.id);
+            if (object.staleMarkId?.startsWith(numbered))
+                taken.add(object.staleMarkId);
+        }
+        if (!taken.has(id))
+            return id;
+        let suffix = 1;
+        while (taken.has(`${id}~${suffix}`))
+            suffix += 1;
+        return `${id}~${suffix}`;
+    }
+    /** A page's objects, loading the page alone when they are not known yet. */
+    #loadObjects(pageIndex) {
+        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 {
+            return this.#objectsOf(pageIndex, page);
+        }
+        finally {
+            lib.FPDF_ClosePage(page);
+        }
+    }
     /** Marks from other sessions keep their id only if it cannot collide with ours. */
     #ownMark(mark, pageKey) {
         return mark.id.startsWith(`${pageKey}:`)

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

@@ -21,6 +21,12 @@ export interface ObjectRecord {
     readonly id: string;
     readonly type: number;
     readonly mark?: MarkParams;
+    /**
+     * The id a mark the file still carries names, on an object listed as plain
+     * because the mark failed its check: a new id must not take it, or saving
+     * would join the new object to this one.
+     */
+    readonly staleMarkId?: string;
 }
 /**
  * Reads the objects of a loaded page in drawing order and turns them into

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

@@ -110,7 +110,13 @@ export class FontLibrary {
             return undefined;
         if (this.#fallback && this.#covers(this.#fallback, request.text))
             return undefined;
-        const bad = firstNonWinAnsi(request.text) ?? firstUncovered(request.text, this);
+        // Name the character that actually stops the text: the first one the
+        // fallback lacks when it was tried, else the first the standard fonts
+        // cannot encode. Naming the first Cyrillic letter for a dash the
+        // fallback lacked sent people after the wrong character (ACTION-879).
+        const bad = this.#fallback
+            ? this.#firstMissing(this.#fallback, request.text)
+            : firstNonWinAnsi(request.text);
         return {
             path: "/text",
             code: "font-unavailable",
@@ -175,6 +181,10 @@ export class FontLibrary {
         return candidates.sort((a, b) => score(b.font) - score(a.font))[0];
     }
     #covers(bytes, text) {
+        return this.#firstMissing(bytes, text) === undefined;
+    }
+    /** The first character of `text` the font has no glyph for; layout handles line breaks and spaces. */
+    #firstMissing(bytes, text) {
         let coverage = this.#coverage.get(bytes);
         if (!coverage) {
             coverage = parseCmap(bytes);
@@ -185,9 +195,9 @@ export class FontLibrary {
             if (code === 0x0a || code === 0x20)
                 continue;
             if (!coverage.has(code))
-                return false;
+                return character;
         }
-        return true;
+        return undefined;
     }
     #load(pdfium, document, bytes) {
         let handles = this.#handles.get(document);
@@ -242,13 +252,6 @@ function isBold(font) {
 function isItalic(font) {
     return font.style !== "normal";
 }
-function firstUncovered(text, library) {
-    void library;
-    for (const character of text)
-        if (character !== "\n" && character !== " ")
-            return character;
-    return undefined;
-}
 /** The code points a TrueType font maps to glyphs, from its cmap table. */
 /**
  * Whether glyphs of a TrueType font have outline data: a subset font can keep

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

@@ -74,11 +74,19 @@ export const rotatePage = {
     validate(operation, context, issue) {
         if (operation.pageIndex >= context.pageCount)
             issue("/pageIndex", "unknown-target", `No page ${operation.pageIndex}`);
+        // A field given as undefined counts as absent, as it does everywhere else.
+        if ((operation.rotation === undefined) === (operation.by === undefined))
+            issue("", "one-of", "Give exactly one of `rotation` and `by`");
     },
     apply(operation, context) {
         const { lib } = context.pdfium;
         context.withPage(operation.pageIndex, (page) => {
-            lib.FPDFPage_SetRotation(page, operation.rotation / 90);
+            // A turn reads the angle the page has now, so it composes with what
+            // the file was saved with and with turns earlier in the history.
+            const quarters = operation.by !== undefined
+                ? (lib.FPDFPage_GetRotation(page) + operation.by / 90) % 4
+                : operation.rotation / 90;
+            lib.FPDFPage_SetRotation(page, quarters);
         });
         context.invalidatePage(operation.pageIndex);
         return {

package/dist/edit/pdf/schemas.js

@@ -170,10 +170,13 @@ export const pdfOperationSchemas = Object.freeze({
             from: { type: "integer", minimum: 0 },
             to: { type: "integer", minimum: 0 },
         }, ["from", "to"]),
+        // Exactly one of `rotation` (absolute) and `by` (a turn from the current
+        // angle); the handler reports a batch that gives both or neither.
         rotatePage: operation("rotatePage", {
             pageIndex: { type: "integer", minimum: 0 },
             rotation: { enum: [0, 90, 180, 270] },
-        }, ["pageIndex", "rotation"]),
+            by: { enum: [90, 180, 270] },
+        }, ["pageIndex"]),
         insertShape: operation("insertShape", {
             pageIndex: { type: "integer", minimum: 0 },
             shape: { enum: ["rectangle", "ellipse", "line"] },

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

@@ -192,12 +192,24 @@ export interface SetShapeStyleOperation {
     /** A new fill, `null` to remove it, or absent to keep it. */
     readonly fill?: PdfFill | null;
 }
-export interface RotatePageOperation {
+/**
+ * Sets a page's rotation, or turns it from where it stands: a host offering
+ * "rotate" does not need to know the angle a file was saved with, and a
+ * replay of the history turns from the same angle again.
+ */
+export type RotatePageOperation = {
     readonly op: "rotatePage";
     readonly pageIndex: number;
     /** Absolute clockwise rotation in degrees. */
     readonly rotation: 0 | 90 | 180 | 270;
-}
+    readonly by?: never;
+} | {
+    readonly op: "rotatePage";
+    readonly pageIndex: number;
+    /** Clockwise turn in degrees from the page's current rotation. */
+    readonly by: 90 | 180 | 270;
+    readonly rotation?: never;
+};
 /** The PDF operation union; operations are added as they ship. */
 export type PdfOperation = InsertTextBoxOperation | ReplaceTextOperation | SetTextStyleOperation | ResizeElementOperation | MoveElementOperation | DeleteElementOperation | InsertPageOperation | DeletePageOperation | MovePageOperation | RotatePageOperation | InsertShapeOperation | SetShapeStyleOperation | InsertImageOperation | InsertTableOperation | SetTableCellOperation;
 export interface PdfSaveOptions extends SaveOptions {
@@ -321,7 +333,7 @@ export interface PdfEditSession extends EditSessionBase<PdfOperation, PdfElement
     deletePage(fields: Fields<DeletePageOperation>, options?: ApplyOptions): Promise<EditReceipt>;
     /** Reorders pages. */
     movePage(fields: Fields<MovePageOperation>, options?: ApplyOptions): Promise<EditReceipt>;
-    /** Sets a page's rotation. */
+    /** Sets a page's rotation, or turns it from the one it has. */
     rotatePage(fields: Fields<RotatePageOperation>, options?: ApplyOptions): Promise<EditReceipt>;
     /** Draws a rectangle, ellipse or line as a path object. */
     insertShape(fields: Fields<InsertShapeOperation>, options?: ApplyOptions): Promise<EditReceipt>;

package/dist/fonts/THIRD_PARTY_NOTICES.md

@@ -6,8 +6,11 @@ The WOFF2 files in this directory are modified/subset builds of Noto Sans and No
 - Noto Sans CJK sources: `notofonts/noto-cjk` commit `f8d157532fbfaeda587e826d4cd5b21a49186f7c`.
 - License: SIL Open Font License 1.1; see `OFL-1.1.txt`.
 - Modified font family used by the viewer: `Zrimo Noto`.
-- `noto-sans-latin-cyrillic.ttf` is the same Latin/Cyrillic subset saved as an
-  uncompressed TrueType file; the PDF editor embeds it into documents whose
-  text the standard fonts cannot encode.
+- `noto-sans-latin-cyrillic.ttf` is the same Latin/Cyrillic subset plus Noto
+  Sans's General Punctuation, Superscripts and Subscripts, Currency Symbols,
+  Letterlike Symbols and Number Forms (ranges in `manifest.json`; the Arrows
+  and Mathematical Operators ranges are requested too, but Noto Sans has no
+  glyphs there), saved as an uncompressed TrueType file; the PDF editor embeds it into
+  documents whose text the standard fonts cannot encode.
 
 No proprietary Microsoft font is included.

package/dist/fonts/manifest.json

@@ -1,8 +1,8 @@
 {
   "schemaVersion": 1,
   "family": "Zrimo Noto",
-  "generated": "2026-07-16",
-  "tooling": "fonttools pyftsubset with all layout features, then woff2_compress; the .ttf is the Latin/Cyrillic subset saved uncompressed with fonttools for embedding into PDFs",
+  "generated": "2026-10-02",
+  "tooling": "fonttools pyftsubset with all layout features, then woff2_compress; the .ttf is the Latin/Cyrillic subset saved uncompressed with fonttools for embedding into PDFs, from hinted/ttf/NotoSans/NotoSans-Regular.ttf with U+0000,U+000D,U+0020-007E,U+00A0-024F,U+0300-036F,U+0400-052F,U+1E00-1EFF plus General Punctuation, Superscripts and Subscripts, Currency Symbols, Letterlike Symbols, Number Forms, Arrows, Mathematical Operators, U+25CC and U+FFFD (U+2000-206F,U+2070-209F,U+20A0-20CF,U+2100-214F,U+2150-218F,U+2190-21FF,U+2200-22FF,U+25CC,U+FFFD) so text typed with dashes, quotes, currency signs and the numero sign can be embedded; Noto Sans has no glyphs in the Arrows and Mathematical Operators ranges, so those two add none",
   "license": "OFL-1.1",
   "sources": {
     "noto-fonts": "https://github.com/notofonts/noto-fonts/tree/ffebf8c1ee449e544955a7e813c54f9b73848eac",
@@ -81,8 +81,8 @@
     },
     {
       "file": "noto-sans-latin-cyrillic.ttf",
-      "bytes": 218796,
-      "sha256": "6a23e5413988b4b523ceb4aa81a1de85dad21336868997f52eb6d42159345262"
+      "bytes": 260552,
+      "sha256": "94094981da300fdb704d64cb91354360d37bf69b26f8584da7d44fdc2e0bdc84"
     }
   ]
 }

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

@@ -3300,13 +3300,27 @@ function paragraphElement(model, record, base) {
     id: record.elementId,
     kind: "paragraph",
     text: record.text.text,
-    ...record.table ? { parentId: record.table.elementId } : {},
+    ...record.table ? { parentId: record.table.elementId, ...cellOf(record.table, record) } : {},
     textStyle: resolveTextStyle(model.styles, record.pPr, first?.rPr),
     paragraphStyle: resolveParagraphStyle(model.styles, record.pPr),
     ...record.readOnlyReason ? { readOnlyReason: record.readOnlyReason } : {},
     operations: operationsOf("paragraph", record.readOnlyReason !== void 0)
   };
 }
+var CELLS = /* @__PURE__ */ new WeakMap();
+function cellOf(table, record) {
+  let cells = CELLS.get(table);
+  if (!cells) {
+    cells = /* @__PURE__ */ new Map();
+    for (const [row, cellsOfRow] of table.rows.entries())
+      for (const [column, cell2] of cellsOfRow.entries())
+        for (const paragraph of cell2.paragraphs)
+          cells.set(paragraph, { row, column });
+    CELLS.set(table, cells);
+  }
+  const cell = cells.get(record);
+  return cell ? { cell } : {};
+}
 
 // src/edit/docx/write.ts
 var MC_NS = "http://schemas.openxmlformats.org/markup-compatibility/2006";

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

@@ -5850,13 +5850,16 @@ var pdfOperationSchemas = Object.freeze({
       },
       ["from", "to"]
     ),
+    // Exactly one of `rotation` (absolute) and `by` (a turn from the current
+    // angle); the handler reports a batch that gives both or neither.
     rotatePage: operation(
       "rotatePage",
       {
         pageIndex: { type: "integer", minimum: 0 },
-        rotation: { enum: [0, 90, 180, 270] }
+        rotation: { enum: [0, 90, 180, 270] },
+        by: { enum: [90, 180, 270] }
       },
-      ["pageIndex", "rotation"]
+      ["pageIndex"]
     ),
     insertShape: operation(
       "insertShape",
@@ -6897,7 +6900,7 @@ var FontLibrary = class {
     if (this.#coveringRegistered(request)) return void 0;
     if (this.#fallback && this.#covers(this.#fallback, request.text))
       return void 0;
-    const bad = firstNonWinAnsi(request.text) ?? firstUncovered(request.text, this);
+    const bad = this.#fallback ? this.#firstMissing(this.#fallback, request.text) : firstNonWinAnsi(request.text);
     return {
       path: "/text",
       code: "font-unavailable",
@@ -6955,6 +6958,10 @@ var FontLibrary = class {
     return candidates.sort((a, b) => score(b.font) - score(a.font))[0];
   }
   #covers(bytes, text) {
+    return this.#firstMissing(bytes, text) === void 0;
+  }
+  /** The first character of `text` the font has no glyph for; layout handles line breaks and spaces. */
+  #firstMissing(bytes, text) {
     let coverage = this.#coverage.get(bytes);
     if (!coverage) {
       coverage = parseCmap(bytes);
@@ -6963,9 +6970,9 @@ var FontLibrary = class {
     for (const character of text) {
       const code = character.codePointAt(0);
       if (code === 10 || code === 32) continue;
-      if (!coverage.has(code)) return false;
+      if (!coverage.has(code)) return character;
     }
-    return true;
+    return void 0;
   }
   #load(pdfium, document2, bytes) {
     let handles = this.#handles.get(document2);
@@ -7017,12 +7024,6 @@ function isBold(font) {
 function isItalic(font) {
   return font.style !== "normal";
 }
-function firstUncovered(text, library) {
-  void library;
-  for (const character of text)
-    if (character !== "\n" && character !== " ") return character;
-  return void 0;
-}
 function glyphOutlines(view, tables) {
   const head = tables.get("head");
   const maxp = tables.get("maxp");
@@ -8663,11 +8664,14 @@ var rotatePage = {
   validate(operation2, context, issue) {
     if (operation2.pageIndex >= context.pageCount)
       issue("/pageIndex", "unknown-target", `No page ${operation2.pageIndex}`);
+    if (operation2.rotation === void 0 === (operation2.by === void 0))
+      issue("", "one-of", "Give exactly one of `rotation` and `by`");
   },
   apply(operation2, context) {
     const { lib } = context.pdfium;
     context.withPage(operation2.pageIndex, (page) => {
-      lib.FPDFPage_SetRotation(page, operation2.rotation / 90);
+      const quarters = operation2.by !== void 0 ? (lib.FPDFPage_GetRotation(page) + operation2.by / 90) % 4 : operation2.rotation / 90;
+      lib.FPDFPage_SetRotation(page, quarters);
     });
     context.invalidatePage(operation2.pageIndex);
     return {
@@ -10043,8 +10047,11 @@ var PdfEditDocument = class {
       },
       // Ids name the state the batch leads to, the operation and the item,
       // so replaying the history reproduces them and an undone id is never
-      // handed out again.
-      newId: (pageIndex, suffix = "") => `${this.#pages[pageIndex].key}:n${stateId}.${operationIndex}.${created++}${suffix}`,
+      // handed out again. A file saved by an earlier session carries the ids
+      // that session numbered from 1 as well, so one already on the page
+      // gets the first free `~n` instead (ACTION-886); the saved objects are
+      // part of the base, so a replay meets them and picks the same id.
+      newId: (pageIndex, suffix = "") => `${this.#unusedId(pageIndex, `${this.#pages[pageIndex].key}:n${stateId}.${operationIndex}.${created++}`)}${suffix}`,
       withPage: (pageIndex, use) => this.#writePage(pageIndex, use),
       appendObjects: (pageIndex, records) => {
         const page = this.#pages[pageIndex];
@@ -10200,10 +10207,48 @@ var PdfEditDocument = class {
       }
     }
     record.objects = objects.map(
-      (object, index) => object.mark && stale.has(object.id) ? { id: `${record.key}:o${index}`, type: object.type } : object
+      (object, index) => object.mark && stale.has(object.id) ? {
+        id: `${record.key}:o${index}`,
+        type: object.type,
+        staleMarkId: object.id
+      } : object
     );
     return record.objects;
   }
+  /**
+   * `id`, or its first free `~n` when an object saved by an earlier session
+   * has it already. Only ids a session numbered (`<key>:n…`) can collide, so
+   * only those are gathered; the objects are read without the page's text.
+   */
+  #unusedId(pageIndex, id) {
+    const record = this.#pages[pageIndex];
+    const objects = record.objects ?? this.#loadObjects(pageIndex);
+    const numbered = `${record.key}:n`;
+    const taken = /* @__PURE__ */ new Set();
+    for (const object of objects) {
+      if (object.id.startsWith(numbered)) taken.add(object.id);
+      if (object.staleMarkId?.startsWith(numbered))
+        taken.add(object.staleMarkId);
+    }
+    if (!taken.has(id)) return id;
+    let suffix = 1;
+    while (taken.has(`${id}~${suffix}`)) suffix += 1;
+    return `${id}~${suffix}`;
+  }
+  /** A page's objects, loading the page alone when they are not known yet. */
+  #loadObjects(pageIndex) {
+    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 {
+      return this.#objectsOf(pageIndex, page);
+    } finally {
+      lib.FPDF_ClosePage(page);
+    }
+  }
   /** Marks from other sessions keep their id only if it cannot collide with ours. */
   #ownMark(mark, pageKey) {
     return mark.id.startsWith(`${pageKey}:`) ? mark : { ...mark, id: `${pageKey}:${mark.id}` };

package/package.json

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