web-doc 0.8.0 → 0.10.0

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

@@ -0,0 +1,317 @@
+import { cffWithSafeName } from "./cff.js";
+/*
+ * Fonts a browser loads with `FontFace`. A PDF's CFF program gets a minimal
+ * OpenType font around it: the CFF table as the PDF holds it, a Unicode cmap,
+ * and the tables a font loader requires (head, hhea, hmtx, maxp, name, OS/2,
+ * post), filled from what the CFF says. A PDF's TrueType program keeps its
+ * tables; subsetting tools leave out the OS/2, name and post tables and pack
+ * tables off four-byte boundaries, which browsers refuse, so those tables are
+ * added and the file laid out again. Nothing in a program's tables changes.
+ */
+const SFNT_TRUETYPE = 0x00010000;
+const SFNT_CFF = 0x4f54544f; // "OTTO"
+/**
+ * The OpenType file, or `undefined` when no glyph has a code point or the
+ * program's name cannot be made one a browser accepts.
+ */
+export function cffOpenType(program, font, unicode) {
+    const safe = cffWithSafeName(program);
+    if (unicode.size === 0 || !safe)
+        return undefined;
+    const em = font.unitsPerEm;
+    const [xMin, yMin, xMax, yMax] = fontBox(font.bbox, em);
+    const glyphCount = font.widths.length;
+    const widths = font.widths.map((width) => Math.max(0, Math.min(0xffff, Math.round(width))));
+    const codes = [...unicode.keys()].sort((a, b) => a - b);
+    const tables = new Map([
+        ["CFF ", safe],
+        ["OS/2", os2(em, widths, codes, yMin, yMax)],
+        ["cmap", cmap(unicode, codes)],
+        ["head", head(em, xMin, yMin, xMax, yMax)],
+        ["hhea", hhea(widths, glyphCount, xMin, yMin, xMax, yMax)],
+        ["hmtx", concat(widths.map((width) => bytes(u16(width), i16(0))))],
+        ["maxp", bytes(u32(0x00005000), u16(glyphCount))],
+        ["name", names(postScriptName(font.name))],
+        ["post", post(em)],
+    ]);
+    return assemble(tables, SFNT_CFF);
+}
+/**
+ * The font box in int16 font units, in order; a font without one, which CFF
+ * allows, gets a box of the usual proportions so its line has a height.
+ */
+function fontBox(box, em) {
+    const clamp = (value) => Math.max(-0x8000, Math.min(0x7fff, Math.round(value)));
+    const [x0 = 0, y0 = 0, x1 = 0, y1 = 0] = box.map(clamp);
+    if (y1 <= y0)
+        return [0, clamp(-em * 0.2), clamp(em), clamp(em * 0.8)];
+    return [Math.min(x0, x1), y0, Math.max(x0, x1), y1];
+}
+/**
+ * An embedded TrueType or OpenType program with the OS/2, name and post
+ * tables it lacks, laid out on four-byte boundaries; `undefined` when its
+ * table directory or core tables are broken.
+ */
+export function completeSfnt(program, fontName) {
+    const tables = sfntTables(program);
+    const headTable = tables?.get("head");
+    const hheaTable = tables?.get("hhea");
+    const maxpTable = tables?.get("maxp");
+    const hmtxTable = tables?.get("hmtx");
+    if (!tables ||
+        !tables.has("cmap") ||
+        !headTable ||
+        headTable.length < 54 ||
+        !hheaTable ||
+        hheaTable.length < 36 ||
+        !maxpTable ||
+        maxpTable.length < 6 ||
+        !hmtxTable)
+        return undefined;
+    const view = (table) => new DataView(table.buffer, table.byteOffset, table.byteLength);
+    const headView = view(headTable);
+    const em = headView.getUint16(18);
+    const yMin = headView.getInt16(38);
+    const yMax = headView.getInt16(42);
+    // The adjustment is the file's, so it is worked out again.
+    const ownHead = headTable.slice();
+    ownHead.fill(0, 8, 12);
+    tables.set("head", ownHead);
+    if (!tables.has("OS/2")) {
+        const metrics = view(hheaTable).getUint16(34);
+        const widths = Array.from({ length: Math.min(metrics, hmtxTable.length >> 2) }, (_, glyph) => view(hmtxTable).getUint16(glyph * 4));
+        tables.set("OS/2", os2(em, widths, [], yMin, yMax));
+    }
+    if (!tables.has("name"))
+        tables.set("name", names(postScriptName(fontName)));
+    if (!tables.has("post"))
+        tables.set("post", post(em));
+    const version = view(program).getUint32(0);
+    return assemble(tables, version === SFNT_CFF ? SFNT_CFF : SFNT_TRUETYPE);
+}
+/** The sfnt file maps Unicode: a cmap subtable for platform 0, or for Windows Unicode BMP or full repertoire. */
+export function hasUnicodeCmap(program) {
+    const table = sfntTables(program)?.get("cmap");
+    if (!table || table.length < 4)
+        return false;
+    const view = new DataView(table.buffer, table.byteOffset, table.byteLength);
+    const count = Math.min(view.getUint16(2), (table.length - 4) >> 3);
+    for (let index = 0; index < count; index += 1) {
+        const platform = view.getUint16(4 + index * 8);
+        const encoding = view.getUint16(6 + index * 8);
+        if (platform === 0 ||
+            (platform === 3 && (encoding === 1 || encoding === 10)))
+            return true;
+    }
+    return false;
+}
+/** The tables of an sfnt file by tag, or `undefined` when its directory is broken. */
+function sfntTables(program) {
+    if (program.length < 12)
+        return undefined;
+    const view = new DataView(program.buffer, program.byteOffset, program.byteLength);
+    const count = view.getUint16(4);
+    if (count === 0 || 12 + count * 16 > program.length)
+        return undefined;
+    const tables = new Map();
+    for (let index = 0; index < count; index += 1) {
+        const record = 12 + index * 16;
+        const tag = String.fromCharCode(...program.subarray(record, record + 4));
+        const offset = view.getUint32(record + 8);
+        const length = view.getUint32(record + 12);
+        if (tables.has(tag) || offset + length > program.length)
+            return undefined;
+        tables.set(tag, program.subarray(offset, offset + length));
+    }
+    return tables;
+}
+/** The PostScript name without a subset tag, in the characters a name table takes. */
+function postScriptName(name) {
+    return (name
+        .replace(/^[A-Z]{6}\+/, "")
+        .replace(/[^\x21-\x7e]|[[\](){}<>/%]/g, "")
+        .slice(0, 63) || "Embedded");
+}
+function post(em) {
+    // Version 3: no glyph names.
+    return bytes(u32(0x00030000), u32(0), i16(-Math.round(em / 10)), i16(Math.round(em / 20)), u32(0), u32(0), u32(0), u32(0), u32(0));
+}
+function head(em, xMin, yMin, xMax, yMax) {
+    return bytes(u32(0x00010000), u32(0x00010000), u32(0), // checkSumAdjustment, set once the font is assembled
+    u32(0x5f0f3cf5), u16(0x000b), u16(em), u32(0), u32(0), u32(0), u32(0), i16(xMin), i16(yMin), i16(xMax), i16(yMax), u16(0), u16(8), i16(2), i16(0), i16(0));
+}
+function hhea(widths, glyphCount, xMin, yMin, xMax, yMax) {
+    return bytes(u32(0x00010000), i16(yMax), i16(yMin), i16(0), u16(widths.reduce((most, width) => Math.max(most, width), 0)), i16(xMin), i16(0), i16(xMax), i16(1), i16(0), i16(0), i16(0), i16(0), i16(0), i16(0), i16(0), u16(glyphCount));
+}
+function os2(em, widths, codes, yMin, yMax) {
+    const scaled = (fraction) => Math.round(em * fraction);
+    const drawn = widths.filter((width) => width > 0);
+    const average = drawn.length
+        ? Math.round(drawn.reduce((sum, width) => sum + width, 0) / drawn.length)
+        : 0;
+    return bytes(u16(4), i16(average), u16(400), u16(5), u16(0), i16(scaled(0.65)), i16(scaled(0.6)), i16(0), i16(scaled(0.075)), i16(scaled(0.65)), i16(scaled(0.6)), i16(0), i16(scaled(0.35)), i16(scaled(0.05)), i16(scaled(0.25)), i16(0), new Array(10).fill(0), u32(0), u32(0), u32(0), u32(0), [0x57, 0x44, 0x4f, 0x43], // "WDOC"
+    u16(0x0040), // regular
+    u16(Math.min(codes[0] ?? 0x20, 0xffff)), u16(Math.min(codes.at(-1) ?? 0xffff, 0xffff)), i16(yMax), i16(yMin), i16(0), u16(Math.max(0, yMax)), u16(Math.max(0, -yMin)), u32(1), u32(0), i16(scaled(0.5)), i16(scaled(0.7)), u16(0), u16(32), u16(0));
+}
+/**
+ * Format 4 for the BMP, and format 12 as well when a code point lies beyond
+ * it or the BMP takes more segments than format 4 holds. Records are in
+ * platform and encoding order, as the specification requires.
+ */
+function cmap(unicode, codes) {
+    const basic = codes.filter((code) => code <= 0xffff);
+    const format4 = cmapFormat4(unicode, basic);
+    const format12 = !format4 || codes.length > basic.length
+        ? cmapFormat12(unicode, codes)
+        : undefined;
+    const subtables = [
+        ...(format4 ? [{ platform: 0, encoding: 3, data: format4 }] : []),
+        ...(format12 ? [{ platform: 0, encoding: 4, data: format12 }] : []),
+        ...(format4 ? [{ platform: 3, encoding: 1, data: format4 }] : []),
+        ...(format12 ? [{ platform: 3, encoding: 10, data: format12 }] : []),
+    ];
+    // Subtables shared by two records are written once.
+    const unique = [...new Set(subtables.map((subtable) => subtable.data))];
+    const headerSize = 4 + subtables.length * 8;
+    const offsets = new Map();
+    let offset = headerSize;
+    for (const data of unique) {
+        offsets.set(data, offset);
+        offset += data.length;
+    }
+    return concat([
+        bytes(u16(0), u16(subtables.length)),
+        ...subtables.map(({ platform, encoding, data }) => bytes(u16(platform), u16(encoding), u32(offsets.get(data)))),
+        ...unique,
+    ]);
+}
+/** `undefined` when the segments overflow the subtable's 16-bit length. */
+function cmapFormat4(unicode, codes) {
+    // Runs of consecutive code points on consecutive glyphs share one delta.
+    const segments = [];
+    for (const code of codes) {
+        const glyph = unicode.get(code);
+        const last = segments.at(-1);
+        if (last &&
+            code === last.end + 1 &&
+            glyph === last.glyph + (code - last.start))
+            last.end = code;
+        else
+            segments.push({ start: code, end: code, glyph });
+    }
+    segments.push({ start: 0xffff, end: 0xffff, glyph: 0 });
+    const count = segments.length;
+    if (16 + count * 8 > 0xffff)
+        return undefined;
+    const searchRange = 2 * 2 ** Math.floor(Math.log2(count));
+    const delta = (segment) => segment.start === 0xffff ? 1 : (segment.glyph - segment.start) & 0xffff;
+    return bytes(u16(4), u16(16 + count * 8), u16(0), u16(count * 2), u16(searchRange), u16(Math.floor(Math.log2(count))), u16(count * 2 - searchRange), segments.flatMap((segment) => u16(segment.end)), u16(0), segments.flatMap((segment) => u16(segment.start)), segments.flatMap((segment) => u16(delta(segment))), segments.flatMap(() => u16(0)));
+}
+function cmapFormat12(unicode, codes) {
+    const groups = [];
+    for (const code of codes) {
+        const glyph = unicode.get(code);
+        const last = groups.at(-1);
+        if (last &&
+            code === last.end + 1 &&
+            glyph === last.glyph + (code - last.start))
+            last.end = code;
+        else
+            groups.push({ start: code, end: code, glyph });
+    }
+    return bytes(u16(12), u16(0), u32(16 + groups.length * 12), u32(0), u32(groups.length), groups.flatMap((group) => [
+        ...u32(group.start),
+        ...u32(group.end),
+        ...u32(group.glyph),
+    ]));
+}
+function names(postScript) {
+    const records = [
+        [1, postScript],
+        [2, "Regular"],
+        [3, `${postScript}-web-doc`],
+        [4, postScript],
+        [5, "Version 1.0"],
+        [6, postScript],
+    ];
+    const strings = records.map(([, text]) => [...text].flatMap((character) => u16(character.charCodeAt(0))));
+    let offset = 0;
+    const entries = records.map(([id], index) => {
+        const entry = [
+            ...u16(3),
+            ...u16(1),
+            ...u16(0x0409),
+            ...u16(id),
+            ...u16(strings[index].length),
+            ...u16(offset),
+        ];
+        offset += strings[index].length;
+        return entry;
+    });
+    return bytes(u16(0), u16(records.length), u16(6 + records.length * 12), entries.flat(), strings.flat());
+}
+/** The table directory, the tables padded to four bytes, and the head checksum adjustment. */
+function assemble(tables, version) {
+    const tags = [...tables.keys()].sort();
+    const count = tags.length;
+    const selector = Math.floor(Math.log2(count));
+    const headerSize = 12 + count * 16;
+    let offset = headerSize;
+    const placed = tags.map((tag) => {
+        const data = tables.get(tag);
+        const at = offset;
+        offset += (data.length + 3) & ~3;
+        return { tag, data, at };
+    });
+    const font = new Uint8Array(offset);
+    font.set(bytes(u32(version), u16(count), u16(2 ** selector * 16), u16(selector), u16(count * 16 - 2 ** selector * 16), placed.flatMap(({ tag, data, at }) => [
+        ...[...tag].map((character) => character.charCodeAt(0)),
+        ...u32(checksum(data)),
+        ...u32(at),
+        ...u32(data.length),
+    ])));
+    for (const { data, at } of placed)
+        font.set(data, at);
+    const head = placed.find((table) => table.tag === "head");
+    const adjustment = (0xb1b0afba - checksum(font)) >>> 0;
+    font.set(u32(adjustment), head.at + 8);
+    return font;
+}
+function checksum(data) {
+    let sum = 0;
+    for (let offset = 0; offset < data.length; offset += 4)
+        sum =
+            (sum +
+                (((data[offset] ?? 0) << 24) |
+                    ((data[offset + 1] ?? 0) << 16) |
+                    ((data[offset + 2] ?? 0) << 8) |
+                    (data[offset + 3] ?? 0))) >>>
+                0;
+    return sum;
+}
+function u16(value) {
+    return [(value >> 8) & 0xff, value & 0xff];
+}
+function i16(value) {
+    return u16(value < 0 ? value + 0x10000 : value);
+}
+function u32(value) {
+    return [
+        (value >>> 24) & 0xff,
+        (value >>> 16) & 0xff,
+        (value >>> 8) & 0xff,
+        value & 0xff,
+    ];
+}
+function bytes(...parts) {
+    return concat(parts.map((part) => Uint8Array.from(part)));
+}
+function concat(parts) {
+    const out = new Uint8Array(parts.reduce((sum, part) => sum + part.length, 0));
+    let offset = 0;
+    for (const part of parts) {
+        out.set(part, offset);
+        offset += part.length;
+    }
+    return out;
+}

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/engine/text-font.d.ts

@@ -0,0 +1,4 @@
+import type { TextFont } from "../types.js";
+import type { Pdfium } from "./pdfium.js";
+export type TextFace = Omit<TextFont, "elementId">;
+export declare function textFaceOf(pdfium: Pdfium, object: number, cache: Map<string, TextFace>): TextFace;

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

@@ -0,0 +1,81 @@
+import { glyphUnicode, readCff } from "./cff.js";
+import { textStyle } from "./elements.js";
+import { cffOpenType, completeSfnt, hasUnicodeCmap } from "./opentype.js";
+export function textFaceOf(pdfium, object, cache) {
+    const { lib } = pdfium;
+    const font = lib.FPDFTextObj_GetFont(object);
+    const family = textStyle(pdfium, object).fontFamily;
+    const baseName = pdfium.readUtf8String((buffer, bytes) => lib.FPDFFont_GetBaseFontName(font, buffer, bytes));
+    if (!lib.FPDFFont_GetIsEmbedded(font))
+        return { key: `name:${baseName}`, family, missing: "not-embedded" };
+    // A Type 3 font is embedded as drawings, with no program to read.
+    const program = fontProgram(pdfium, font);
+    if (!program)
+        return { key: `embedded:${baseName}`, family, missing: "unreadable" };
+    const key = `${baseName}#${fnv1a(program).toString(16)}`;
+    const known = cache.get(key);
+    if (known)
+        return { ...known, family };
+    const face = { key, family, ...faceOf(program, baseName) };
+    cache.set(key, face);
+    return face;
+}
+function faceOf(program, baseName) {
+    const tag = String.fromCharCode(...program.subarray(0, 4));
+    const truetype = tag === "true" ||
+        (program[0] === 0 &&
+            program[1] === 1 &&
+            program[2] === 0 &&
+            program[3] === 0);
+    if (truetype || tag === "OTTO") {
+        if (!hasUnicodeCmap(program))
+            return { missing: "no-unicode" };
+        const data = completeSfnt(program, baseName);
+        return data
+            ? { face: { data, format: truetype ? "truetype" : "opentype" } }
+            : { missing: "unreadable" };
+    }
+    // Type 1 programs start with "%!" in clear text, or with a PFB segment.
+    if (tag.startsWith("%!") || program[0] === 0x80)
+        return { missing: "type1" };
+    const cff = readCff(program);
+    if (!cff)
+        return { missing: "unreadable" };
+    if (cff.cid)
+        return { missing: "cid-keyed" };
+    const unicode = new Map();
+    cff.glyphNames.forEach((name, glyph) => {
+        const code = glyphUnicode(name);
+        if (code !== undefined && !unicode.has(code))
+            unicode.set(code, glyph);
+    });
+    const data = cffOpenType(program, cff, unicode);
+    return data
+        ? { face: { data, format: "opentype" } }
+        : { missing: "no-unicode" };
+}
+/** The font program a PDF font object embeds, or `undefined` for a font it does not embed. */
+function fontProgram(pdfium, font) {
+    const { lib } = pdfium;
+    const size = pdfium.readNumbers(1, "i32", ([out]) => lib.FPDFFont_GetFontData(font, 0, 0, out))?.[0];
+    if (!size)
+        return undefined;
+    const buffer = pdfium.malloc(size);
+    const out = pdfium.malloc(4);
+    try {
+        return lib.FPDFFont_GetFontData(font, buffer, size, out)
+            ? pdfium.readBytes(buffer, size)
+            : undefined;
+    }
+    finally {
+        pdfium.free(out);
+        pdfium.free(buffer);
+    }
+}
+/** FNV-1a over the program: a cheap, stable key for one font. */
+function fnv1a(bytes) {
+    let hash = 0x811c9dc5;
+    for (const byte of bytes)
+        hash = Math.imul(hash ^ byte, 0x01000193);
+    return hash >>> 0;
+}

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

@@ -2,10 +2,11 @@ import { type WorkerLike } from "../../worker-client.js";
 import type { EditEngineContext } from "../engine.js";
 import type { PagePoint, PageRect, TextPosition, TextRange } from "../types.js";
 import { WorkerEngineClient } from "../worker-engine.js";
-import type { PageBitmap, PageLayout, TextLayout } from "./types.js";
+import type { PageBitmap, PageLayout, TextFont, TextLayout } from "./types.js";
 /** The reads behind the overlay primitives, beyond the core engine interface. */
 export interface PdfEngineReads {
     textLayout(id: string, signal: AbortSignal): Promise<TextLayout | undefined>;
+    textFont(id: string, signal: AbortSignal): Promise<TextFont | undefined>;
     positionAt(pageIndex: number, point: PagePoint, signal: AbortSignal): Promise<TextPosition | undefined>;
     rangeRects(range: TextRange, signal: AbortSignal): Promise<readonly PageRect[]>;
     renderWithout(pageIndex: number, elementIds: readonly string[], scale: number, signal: AbortSignal): Promise<PageBitmap>;
@@ -28,6 +29,7 @@ export declare class PdfEditEngineClient extends WorkerEngineClient implements P
     readonly schemas: import("../types.js").OperationSchemaSet;
     start(original: Uint8Array, options: PdfEditProviderOptions): Promise<void>;
     textLayout(id: string, signal: AbortSignal): Promise<TextLayout | undefined>;
+    textFont(id: string, signal: AbortSignal): Promise<TextFont | undefined>;
     positionAt(pageIndex: number, point: PagePoint, signal: AbortSignal): Promise<TextPosition | undefined>;
     rangeRects(range: TextRange, signal: AbortSignal): Promise<readonly PageRect[]>;
     renderWithout(pageIndex: number, elementIds: readonly string[], scale: number, signal: AbortSignal): Promise<PageBitmap>;

package/dist/edit/pdf/provider.js

@@ -53,6 +53,9 @@ export class PdfEditEngineClient extends WorkerEngineClient {
     textLayout(id, signal) {
         return this.request("edit-text-layout", { id }, signal);
     }
+    textFont(id, signal) {
+        return this.request("edit-text-font", { id }, signal);
+    }
     positionAt(pageIndex, point, signal) {
         return this.request("edit-position-at", { pageIndex, point }, signal);
     }

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/session.d.ts

@@ -2,7 +2,7 @@ import type { TextSelection } from "../../contracts.js";
 import type { DescribeOptions, DocumentDescription, EditCheckpoint, OutlineOptions, OutlineResult, TargetCandidate, TargetQuery, ToolCall, ToolCallOptions, ToolResult, ToolSet } from "../ai/types.js";
 import type { EditSessionCore } from "../engine.js";
 import type { ApplyOptions, AssetOptions, EditFindOptions, EditOperation, EditReceipt, EditState, ElementQuery, HistoryOptions, OperationSchemaSet, PagePoint, PageRect, ReadItem, ReadOptions, ReadResult, SavedDocument, TextPosition, TextRange, TextTarget } from "../types.js";
-import type { DeleteElementOperation, DeletePageOperation, Fields, InsertImageOperation, InsertPageOperation, InsertShapeOperation, InsertTableOperation, InsertTextBoxOperation, MoveElementOperation, MovePageOperation, PdfEditSession, PdfElement, PdfOperation, PdfSaveOptions, ReplaceTextOperation, ResizeElementOperation, RotatePageOperation, SetShapeStyleOperation, SetTableCellOperation, PageBitmap, PageLayout, RenderOptions, SetTextStyleOperation, TextLayout } from "./types.js";
+import type { DeleteElementOperation, DeletePageOperation, Fields, InsertImageOperation, InsertPageOperation, InsertShapeOperation, InsertTableOperation, InsertTextBoxOperation, MoveElementOperation, MovePageOperation, PdfEditSession, PdfElement, PdfOperation, PdfSaveOptions, ReplaceTextOperation, ResizeElementOperation, RotatePageOperation, SetShapeStyleOperation, SetTableCellOperation, PageBitmap, PageLayout, RenderOptions, SetTextStyleOperation, TextFont, TextLayout } from "./types.js";
 /**
  * The PDF session: the core session narrowed to PDF operations and elements.
  * Typed methods are added here as their operations ship; each is `apply()`
@@ -39,6 +39,7 @@ export declare class PdfSession implements PdfEditSession {
     get tools(): ToolSet;
     callTool(call: ToolCall, options?: ToolCallOptions): Promise<ToolResult>;
     getTextLayout(elementId: string, options?: ReadOptions): Promise<ReadItem<TextLayout>>;
+    getTextFont(elementId: string, options?: ReadOptions): Promise<ReadItem<TextFont>>;
     positionAt(pageIndex: number, point: PagePoint, options?: ReadOptions): Promise<ReadItem<TextPosition>>;
     rangeRects(range: TextRange, options?: ReadOptions): Promise<ReadResult<PageRect>>;
     getPageLayout(pageIndex: number, options?: ReadOptions): Promise<ReadItem<PageLayout>>;

package/dist/edit/pdf/session.js

@@ -198,6 +198,9 @@ export class PdfSession {
     getTextLayout(elementId, options) {
         return this.#core.readItem(options, (engine, signal) => pdfReads(engine).textLayout(elementId, signal));
     }
+    getTextFont(elementId, options) {
+        return this.#core.readItem(options, (engine, signal) => pdfReads(engine).textFont(elementId, signal));
+    }
     positionAt(pageIndex, point, options) {
         return this.#core.readItem(options, (engine, signal) => pdfReads(engine).positionAt(pageIndex, point, signal));
     }

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 {
@@ -232,6 +244,41 @@ export interface TextLayoutLine {
     readonly fontSize: number;
     readonly color: string;
 }
+/**
+ * The font a PDF text element is drawn in, as a browser can load it: a host
+ * typing over the element shows the text in the document's own glyphs and
+ * metrics. Exactly one of `face` and `missing` is set.
+ */
+export interface TextFont {
+    readonly elementId: string;
+    /** The same for every element drawn in this font, so a host loads each face once. */
+    readonly key: string;
+    /** The family the file declares, as `textStyle.fontFamily` reports it. */
+    readonly family: string;
+    /**
+     * An OpenType or TrueType file for `FontFace`: a TrueType program with
+     * the OS/2, name and post tables a subset left out added, or a CFF program
+     * wrapped as OpenType with a Unicode cmap built from its glyph names (Adobe
+     * Glyph List names, `uniXXXX` and `uXXXX`). The program's own glyphs and
+     * widths are kept. Subset fonts hold only the glyphs the file uses, often
+     * not even a space, which the file places by positioning instead; a browser
+     * draws other characters in a fallback face. The file declares a
+     * regular face: its glyphs already carry the weight and slant, so load it
+     * with the default descriptors and do not ask the browser for bold or
+     * italic on top.
+     */
+    readonly face?: {
+        readonly data: Uint8Array;
+        readonly format: "opentype" | "truetype";
+    };
+    /**
+     * Why there is no face: the font is not embedded (a host shows it by name,
+     * as PDF readers do), or it is embedded in a form no browser loads: a
+     * CID-keyed CFF font, a Type 1 or Type 3 font, a font whose glyphs have no
+     * code points, or a program this reader cannot read.
+     */
+    readonly missing?: "not-embedded" | "cid-keyed" | "type1" | "no-unicode" | "unreadable";
+}
 /** The drawn geometry of a `text`, `textBox` or `table` element. */
 export interface TextLayout {
     readonly elementId: string;
@@ -270,6 +317,11 @@ export interface PdfEditSession extends EditSessionBase<PdfOperation, PdfElement
     save(options?: PdfSaveOptions): Promise<SavedDocument>;
     /** Lines, glyph boxes and styles of a `text`, `textBox` or `table` element. */
     getTextLayout(elementId: string, options?: ReadOptions): Promise<ReadItem<TextLayout>>;
+    /**
+     * The font a `text` or `textBox` element is drawn in, as a browser loads it,
+     * or why it cannot be loaded; see `TextFont`.
+     */
+    getTextFont(elementId: string, options?: ReadOptions): Promise<ReadItem<TextFont>>;
     /** The text position nearest to a page-space point; none on a page without text. */
     positionAt(pageIndex: number, point: PagePoint, options?: ReadOptions): Promise<ReadItem<TextPosition>>;
     /** The rectangles a range covers, one per line fragment, in reading order. */
@@ -321,7 +373,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/edit/pptx/session.d.ts

@@ -1,5 +1,5 @@
 import type { DescribeOptions, DocumentDescription, EditCheckpoint, OutlineOptions, OutlineResult, TargetCandidate, TargetQuery, ToolCall, ToolCallOptions, ToolResult, ToolSet } from "../ai/types.js";
-import type { EditSessionCore } from "../engine.js";
+import type { EditSessionAccess, EditSessionCore } from "../engine.js";
 import type { ApplyOptions, AssetOptions, EditFindOptions, EditOperation, EditReceipt, EditState, ElementQuery, HistoryOptions, OperationSchemaSet, PagePoint, ReadItem, ReadOptions, ReadResult, SavedDocument, TextTarget } from "../types.js";
 import type { PptxDeleteElementOperation, PptxDeleteSlideOperation, PptxDuplicateSlideOperation, PptxEditSession, PptxElement, PptxFields, PptxInsertImageOperation, PptxInsertSlideOperation, PptxInsertTableOperation, PptxInsertTextBoxOperation, PptxLayoutInfo, PptxMoveElementOperation, PptxMoveSlideOperation, PptxOperation, PptxReplaceTextOperation, PptxResizeElementOperation, PptxSaveOptions, PptxSetShapeStyleOperation, PptxSetTableCellOperation, PptxSetTextStyleOperation, PptxSlideInfo } from "./types.js";
 /**
@@ -10,7 +10,7 @@ import type { PptxDeleteElementOperation, PptxDeleteSlideOperation, PptxDuplicat
 export declare class PptxSession implements PptxEditSession {
     #private;
     readonly format: "pptx";
-    constructor(core: EditSessionCore);
+    constructor(core: EditSessionCore, access?: EditSessionAccess);
     get sessionId(): string;
     get state(): EditState;
     get schemas(): OperationSchemaSet;
@@ -24,6 +24,11 @@ export declare class PptxSession implements PptxEditSession {
     addAsset(data: Uint8Array, options?: AssetOptions): Promise<string>;
     getElements(query?: ElementQuery, options?: ReadOptions): Promise<ReadResult<PptxElement>>;
     getElement(id: string, options?: ReadOptions): Promise<ReadItem<PptxElement>>;
+    /**
+     * The elements under a point, top-most first: those whose frame holds it,
+     * and before them a shape whose text is painted there past its frame, as
+     * text wrapped below a short box is.
+     */
     elementsAt(pageIndex: number, point: PagePoint, options?: ReadOptions): Promise<ReadResult<PptxElement>>;
     findText(query: string, options?: EditFindOptions): Promise<ReadResult<TextTarget>>;
     getOutline(options?: OutlineOptions): Promise<OutlineResult>;