web-doc 0.10.0 → 0.12.0

package/dist/edit/pdf/range-map.js

@@ -10,17 +10,23 @@ export function mapRangeThrough(range, records) {
     return { start: start.position, end: end.position };
 }
 function carry(position, records) {
-    const carried = { position, gone: false };
+    const carried = { position, gone: false, migrations: [] };
     for (const record of records) {
         const forward = record.kind === "apply" || record.kind === "redo";
-        const operations = forward
-            ? record.operations
-            : [...record.operations].reverse();
-        for (const operation of operations) {
-            if (forward)
+        const indexed = record.operations.map((operation, index) => ({
+            operation,
+            index,
+        }));
+        for (const { operation, index } of forward ? indexed : indexed.reverse()) {
+            const migrations = (record.textAnchorMigrations ?? []).filter((migration) => migration.operationIndex === index);
+            if (forward) {
+                migrateForward(carried, migrations);
                 applyForward(carried, operation);
-            else
+            }
+            else {
                 applyBackward(carried, operation);
+                migrateBackward(carried, migrations);
+            }
         }
         const { receipt } = record;
         const id = carried.position.elementId;
@@ -34,6 +40,30 @@ function carry(position, records) {
     }
     return carried;
 }
+function migrateForward(carried, migrations) {
+    const migration = migrations.find((entry) => entry.sourceElementId === carried.position.elementId);
+    if (!migration || carried.gone)
+        return;
+    carried.migrations.push(migration);
+    carried.position = {
+        elementId: migration.targetElementId,
+        offset: migration.targetOffset +
+            Math.min(carried.position.offset, migration.sourceLength),
+    };
+}
+function migrateBackward(carried, migrations) {
+    const previous = carried.migrations.at(-1);
+    if (!previous ||
+        carried.position.elementId !== previous.targetElementId ||
+        !migrations.some((entry) => entry.sourceElementId === previous.sourceElementId &&
+            entry.targetElementId === previous.targetElementId))
+        return;
+    carried.migrations.pop();
+    carried.position = {
+        elementId: previous.sourceElementId,
+        offset: Math.max(0, Math.min(previous.sourceLength, carried.position.offset - previous.targetOffset)),
+    };
+}
 function applyForward(carried, operation) {
     const id = carried.position.elementId;
     if (operation.op === "deleteElement" && targetOf(operation) === id) {
@@ -84,7 +114,7 @@ function applyBackward(carried, operation) {
     };
 }
 function asReplace(operation, elementId) {
-    if (operation.op !== "replaceText")
+    if (operation.op !== "replaceText" && operation.op !== "replaceParagraphText")
         return undefined;
     const candidate = operation;
     if (candidate.target !== elementId || typeof candidate.text !== "string")

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

@@ -9,3 +9,5 @@ export declare const tableMarkSchema: JsonSchema;
 /** The mark on a table's text objects: the id alone. */
 export declare const tableMemberMarkSchema: JsonSchema;
 export declare const textBoxMarkSchema: JsonSchema;
+/** Persisted native imported paragraph; no unvalidated layout inputs are trusted. */
+export declare const paragraphMarkSchema: JsonSchema;

package/dist/edit/pdf/schemas.js

@@ -143,6 +143,11 @@ export const pdfOperationSchemas = Object.freeze({
             target: { $ref: "#/$defs/target" },
             style: { $ref: "#/$defs/textBoxStyle" },
         }, ["target", "style"]),
+        replaceParagraphText: operation("replaceParagraphText", {
+            target: { $ref: "#/$defs/target" },
+            text: { type: "string", maxLength: 20000 },
+            range: { $ref: "#/$defs/textRange" },
+        }, ["target", "text"]),
         resizeElement: operation("resizeElement", {
             target: { $ref: "#/$defs/target" },
             rect: { $ref: "#/$defs/rect" },
@@ -292,3 +297,35 @@ export const textBoxMarkSchema = {
     },
     $defs: definitions,
 };
+/** Persisted native imported paragraph; no unvalidated layout inputs are trusted. */
+export const paragraphMarkSchema = {
+    type: "object",
+    required: ["kind", "id", "rect", "text", "lines", "style", "baselineOffset"],
+    additionalProperties: false,
+    properties: {
+        kind: { const: "paragraph" },
+        id: { $ref: "#/$defs/target" },
+        rect: { $ref: "#/$defs/rect" },
+        text: { type: "string", maxLength: 20000 },
+        baselineOffset: { type: "number", minimum: 0, maximum: 2 },
+        lines: {
+            type: "array",
+            maxItems: 20000,
+            items: { type: "string", maxLength: 20000 },
+        },
+        style: {
+            type: "object",
+            required: [
+                "fontFamily",
+                "fontSize",
+                "bold",
+                "italic",
+                "color",
+                "lineHeight",
+            ],
+            additionalProperties: false,
+            properties: definitions.textBoxStyle.properties,
+        },
+    },
+    $defs: definitions,
+};

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, TextFont, TextLayout } from "./types.js";
+import type { DeleteElementOperation, DeletePageOperation, Fields, InsertImageOperation, InsertPageOperation, InsertShapeOperation, InsertTableOperation, InsertTextBoxOperation, MoveElementOperation, MovePageOperation, PdfEditSession, PdfElement, PdfOperation, PdfSaveOptions, PdfTextParagraph, ReplaceParagraphTextOperation, 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()`
@@ -38,6 +38,8 @@ export declare class PdfSession implements PdfEditSession {
     dropCheckpoint(id: string): void;
     get tools(): ToolSet;
     callTool(call: ToolCall, options?: ToolCallOptions): Promise<ToolResult>;
+    getTextParagraph(elementId: string, options?: ReadOptions): Promise<ReadItem<PdfTextParagraph>>;
+    replaceParagraphText(fields: Fields<ReplaceParagraphTextOperation>, options?: ApplyOptions): Promise<EditReceipt>;
     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>>;

package/dist/edit/pdf/session.js

@@ -66,22 +66,25 @@ export class PdfSession {
         if (receipt.dryRun || receipt.revision === last)
             return;
         this.#refreshGeometry(receipt);
-        let involved = operations;
+        let involved = {
+            operations,
+            textAnchorMigrations: receipt.textAnchorMigrations ?? [],
+        };
         switch (kind) {
             case "apply":
-                this.#applied.push(operations);
+                this.#applied.push(involved);
                 this.#undone = [];
                 break;
             case "undo":
-                involved = this.#applied.pop() ?? [];
+                involved = this.#applied.pop() ?? involved;
                 this.#undone.push(involved);
                 break;
             case "redo":
-                involved = this.#undone.pop() ?? [];
+                involved = this.#undone.pop() ?? involved;
                 this.#applied.push(involved);
                 break;
             case "reset":
-                involved = this.#applied.flat();
+                involved = combineBatches(this.#applied);
                 this.#applied = [];
                 this.#undone = [];
                 break;
@@ -95,7 +98,8 @@ export class PdfSession {
         this.#log.push({
             revision: receipt.revision,
             kind,
-            operations: involved,
+            operations: involved.operations,
+            textAnchorMigrations: involved.textAnchorMigrations,
             receipt,
         });
         if (this.#log.length > LOG_LIMIT)
@@ -195,6 +199,17 @@ export class PdfSession {
     callTool(call, options) {
         return runTool(this, this.tools, call, options);
     }
+    getTextParagraph(elementId, options) {
+        return this.#core.readItem(options, (engine, signal) => {
+            const reads = pdfReads(engine);
+            if (!reads.textParagraph)
+                throw new ViewerError("edit-unsupported", "This engine does not resolve PDF paragraphs");
+            return reads.textParagraph(elementId, signal);
+        });
+    }
+    replaceParagraphText(fields, options) {
+        return this.apply([{ op: "replaceParagraphText", ...fields }], options);
+    }
     getTextLayout(elementId, options) {
         return this.#core.readItem(options, (engine, signal) => pdfReads(engine).textLayout(elementId, signal));
     }
@@ -302,6 +317,20 @@ export class PdfSession {
 }
 /** How many committed calls `mapRange` can look back over. */
 const LOG_LIMIT = 512;
+/** Reset reverses all committed batches, retaining each migration's operation. */
+function combineBatches(batches) {
+    const operations = [];
+    const textAnchorMigrations = [];
+    for (const batch of batches) {
+        for (const migration of batch.textAnchorMigrations)
+            textAnchorMigrations.push({
+                ...migration,
+                operationIndex: operations.length + migration.operationIndex,
+            });
+        operations.push(...batch.operations);
+    }
+    return { operations, textAnchorMigrations };
+}
 /** The engine behind a PDF session answers the overlay reads; a stand-in may not. */
 function pdfReads(engine) {
     const reads = engine;

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

@@ -1,6 +1,6 @@
 import type { TextSelection } from "../../contracts.js";
 import type { ApplyOptions, BinaryData, EditElement, EditReceipt, EditSessionBase, PagePoint, PageRect, ReadItem, ReadOptions, ReadResult, SavedDocument, SaveOptions, TextPosition, TextRange } from "../types.js";
-export type PdfElementKind = "text" | "image" | "shape" | "textBox" | "table" | "other";
+export type PdfElementKind = "text" | "image" | "shape" | "textBox" | "paragraph" | "table" | "other";
 export type PdfTextAlign = "left" | "center" | "right";
 export interface PdfTextStyle {
     readonly fontFamily: string;
@@ -12,7 +12,7 @@ export interface PdfTextStyle {
     readonly color: string;
     /** Text boxes only. */
     readonly align?: PdfTextAlign;
-    /** Text boxes only; a multiple of the font size. */
+    /** Text boxes and paragraphs; a multiple of the font size. */
     readonly lineHeight?: number;
 }
 export interface PdfShapeStyle {
@@ -26,7 +26,9 @@ export interface PdfShapeStyle {
 }
 export interface PdfElement extends EditElement {
     readonly kind: PdfElementKind;
-    /** Present for `text` and `textBox`. */
+    /** Canonical native paragraph target, when this imported row belongs to one. */
+    readonly textEditingTarget?: string;
+    /** Present for `text`, `textBox` and `paragraph`. */
     readonly textStyle?: PdfTextStyle;
     /** Present for `shape` and `table`. */
     readonly shapeStyle?: PdfShapeStyle;
@@ -57,7 +59,7 @@ export interface InsertTextBoxOperation {
 }
 export interface ReplaceTextOperation {
     readonly op: "replaceText";
-    /** A `textBox` or `text` element. */
+    /** A `textBox`, `text` or `paragraph` element; supported fields depend on its capabilities. */
     readonly target: string;
     readonly text: string;
     /**
@@ -68,9 +70,33 @@ export interface ReplaceTextOperation {
      */
     readonly range?: TextRange;
 }
+/** A confidently resolved homogeneous paragraph of imported horizontal text. */
+export interface PdfTextParagraph {
+    readonly id: string;
+    readonly pageIndex: number;
+    readonly text: string;
+    readonly bounds: PageRect;
+    readonly textStyle: PdfTextStyle & {
+        readonly lineHeight: number;
+    };
+    readonly memberIds: readonly string[];
+    /** Half-open UTF-16 spans in the paragraph's logical text. */
+    readonly members: readonly {
+        readonly elementId: string;
+        readonly start: number;
+        readonly end: number;
+    }[];
+}
+export interface ReplaceParagraphTextOperation {
+    readonly op: "replaceParagraphText";
+    readonly target: string;
+    readonly text: string;
+    /** Both endpoints name the paragraph id, not an individual visual row. */
+    readonly range?: TextRange;
+}
 export interface SetTextStyleOperation {
     readonly op: "setTextStyle";
-    /** A `textBox` or `text` element. */
+    /** A `textBox`, `text`, or `paragraph` element. */
     readonly target: string;
     readonly style: PdfTextBoxStyle;
 }
@@ -211,7 +237,7 @@ export type RotatePageOperation = {
     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 type PdfOperation = InsertTextBoxOperation | ReplaceTextOperation | ReplaceParagraphTextOperation | SetTextStyleOperation | ResizeElementOperation | MoveElementOperation | DeleteElementOperation | InsertPageOperation | DeletePageOperation | MovePageOperation | RotatePageOperation | InsertShapeOperation | SetShapeStyleOperation | InsertImageOperation | InsertTableOperation | SetTableCellOperation;
 export interface PdfSaveOptions extends SaveOptions {
     /**
      * `full` rewrites the file, so deleted content is gone and the bytes do not
@@ -315,10 +341,14 @@ export type Fields<T extends PdfOperation> = T extends unknown ? Omit<T, "op"> :
 export interface PdfEditSession extends EditSessionBase<PdfOperation, PdfElement> {
     readonly format: "pdf";
     save(options?: PdfSaveOptions): Promise<SavedDocument>;
-    /** Lines, glyph boxes and styles of a `text`, `textBox` or `table` element. */
+    /** Resolves an imported row or a paragraph id; undefined when grouping is unsafe. */
+    getTextParagraph(elementId: string, options?: ReadOptions): Promise<ReadItem<PdfTextParagraph>>;
+    /** Reflows the complete paragraph as one atomic history change. */
+    replaceParagraphText(fields: Fields<ReplaceParagraphTextOperation>, options?: ApplyOptions): Promise<EditReceipt>;
+    /** Lines, glyph boxes and styles of a `text`, `textBox`, `paragraph` 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,
+     * The font a `text`, `textBox` or `paragraph` 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>>;

package/dist/edit/pptx/elements.d.ts

@@ -4,7 +4,8 @@ import { type Matrix, type PlacedFrame, type Xfrm } from "./geometry.js";
 import type { DeckModel, SlideRecord } from "./model.js";
 import { type StyleSource } from "./style.js";
 import { type TextModel } from "./text.js";
-import type { PptxElement, PptxPlaceholder } from "./types.js";
+import { type TextSpan } from "../range-style.js";
+import type { PptxElement, PptxPlaceholder, PptxTextStyle } from "./types.js";
 /** What the engine knows about one element beyond what it reports. */
 export interface ShapeRecord {
     readonly element: PptxElement;
@@ -28,6 +29,8 @@ export interface ShapeRecord {
     /** Inside the fallback branch of `mc:AlternateContent`. */
     readonly readOnly: boolean;
     readonly parent?: ShapeRecord;
+    /** The style a span of the shape's text shows: what every run it covers shares. */
+    readonly styleOf?: (span: TextSpan) => Partial<PptxTextStyle> | undefined;
 }
 export interface SlideElements {
     readonly slide: SlideRecord;

package/dist/edit/pptx/elements.js

@@ -1,6 +1,7 @@
 import { groupMatrix, IDENTITY, multiply, placeFrame, readXfrm, } from "./geometry.js";
 import { resolveTextStyle, readShapeStyle } from "./style.js";
 import { firstTextRun, readTableCells, readTextModel, } from "./text.js";
+import { runsCovering, sharedStyle } from "../range-style.js";
 /*
  * The elements of a slide, read from its XML: every child of the shape tree
  * with its frame (own, or inherited from the layout and master for a
@@ -236,6 +237,11 @@ function readRecord(context, node, parents, parent, readOnly, walk) {
         ...(text ? { text } : {}),
         readOnly,
         ...(parent ? { parent } : {}),
+        ...(text && txBody
+            ? {
+                styleOf: (span) => rangeStyleOf(context, placeholder, txBody, text, span),
+            }
+            : {}),
     };
 }
 function operationsFor(kind, hasText) {
@@ -285,6 +291,35 @@ export function listStylesOf(context, txBody, placeholder) {
         lists.push(defaults);
     return lists;
 }
+/**
+ * The style a span of a text body shows: each run it covers resolves through
+ * its paragraph and the inherited lists, and the properties they all share
+ * are kept. An empty paragraph reads its end-of-paragraph properties.
+ */
+function rangeStyleOf(context, placeholder, txBody, text, span) {
+    const lists = listStylesOf(context, txBody, placeholder);
+    const styleOf = (paragraph, rPr) => resolveTextStyle({
+        ...(rPr ? { rPr: { part: context.part, node: rPr } } : {}),
+        ...(paragraph.pPr
+            ? { pPr: { part: context.part, node: paragraph.pPr } }
+            : {}),
+        level: paragraph.level,
+        lists,
+        fonts: context.fonts,
+    });
+    const runs = text.paragraphs.flatMap((paragraph) => paragraph.runs.map((run) => ({
+        start: run.start,
+        end: run.end,
+        style: () => styleOf(paragraph, run.rPr),
+    })));
+    const covered = runsCovering(runs, span);
+    if (covered.length > 0)
+        return sharedStyle(covered.map((run) => run.style()));
+    const paragraph = text.paragraphs.find((candidate) => candidate.start <= span.start && span.start <= candidate.end) ?? text.paragraphs[0];
+    return paragraph
+        ? sharedStyle([styleOf(paragraph, paragraph.endParaRPr)])
+        : undefined;
+}
 function textStyleOf(context, placeholder, txBody, text) {
     const first = firstTextRun(text);
     const paragraph = first?.paragraph ?? text.paragraphs[0];

package/dist/edit/pptx/engine.d.ts

@@ -3,11 +3,13 @@ import type { EditEngine, EngineBatch, EngineChange, MaterializedDocument, Mater
 import { OoxmlPackage } from "../ooxml/package.js";
 import type { EditFindOptions, EditOperation, ElementQuery, OperationIssue, PagePoint, TextTarget } from "../types.js";
 import { DeckModel } from "./model.js";
-import type { PptxElement, PptxLayoutInfo, PptxSlideInfo } from "./types.js";
+import type { PptxElement, PptxLayoutInfo, PptxSlideInfo, PptxTextStyle } from "./types.js";
+import { type TextSpan } from "../range-style.js";
 /** The reads behind `getSlides` and `getLayouts`, beyond the core engine interface. */
 export interface PptxEngineReads {
     slides(signal: AbortSignal): Promise<readonly PptxSlideInfo[]>;
     layouts(signal: AbortSignal): Promise<readonly PptxLayoutInfo[]>;
+    textStyle(id: string, span: TextSpan | undefined, signal: AbortSignal): Promise<Partial<PptxTextStyle> | undefined>;
 }
 export declare class PptxEditEngine implements EditEngine, PptxEngineReads {
     #private;
@@ -32,6 +34,8 @@ export declare class PptxEditEngine implements EditEngine, PptxEngineReads {
     elementsAt(pageIndex: number, point: PagePoint, signal: AbortSignal): Promise<readonly PptxElement[]>;
     findText(query: string, options: EditFindOptions, signal: AbortSignal): Promise<readonly TextTarget[]>;
     slides(signal: AbortSignal): Promise<readonly PptxSlideInfo[]>;
+    /** The style a span of a shape's text shows; none for an element without text or a span past it. */
+    textStyle(id: string, span: TextSpan | undefined, signal: AbortSignal): Promise<Partial<PptxTextStyle> | undefined>;
     layouts(signal: AbortSignal): Promise<readonly PptxLayoutInfo[]>;
     dispose(): Promise<void>;
 }

package/dist/edit/pptx/engine.js

@@ -8,6 +8,7 @@ import { DeckModel } from "./model.js";
 import { pptxHandlers } from "./handlers.js";
 import { issueCollector, } from "./operations.js";
 import { pptxOperationSchemas } from "./schemas.js";
+import { spanFits } from "../range-style.js";
 const SLIDE_PART = /^\/ppt\/slides\/slide(\d+)\.xml$/i;
 const SLIDE_RELS = /^\/ppt\/slides\/_rels\/slide(\d+)\.xml\.rels$/i;
 export class PptxEditEngine {
@@ -357,6 +358,16 @@ export class PptxEditEngine {
             });
         return out;
     }
+    /** The style a span of a shape's text shows; none for an element without text or a span past it. */
+    async textStyle(id, span, signal) {
+        const record = await this.#locate(id, signal);
+        if (!record?.styleOf || !record.text)
+            return undefined;
+        const range = span ?? { start: 0, end: record.text.text.length };
+        if (!spanFits(range, record.text.text.length))
+            return undefined;
+        return record.styleOf(range);
+    }
     async layouts(signal) {
         const model = await this.model(signal);
         return model.layouts.map((layout) => ({

package/dist/edit/pptx/handler.js

@@ -88,6 +88,14 @@ export function createOoxmlEditHandler() {
                 return pptx().layouts(signal);
             case "edit-docx-revisions":
                 return docx().revisions(payload.id, signal);
+            case "edit-docx-text-style": {
+                const { id, span } = payload;
+                return docx().textStyle(id, span, signal);
+            }
+            case "edit-pptx-text-style": {
+                const { id, span } = payload;
+                return pptx().textStyle(id, span, signal);
+            }
             case "edit-dispose":
                 await state?.dispose();
                 state = undefined;

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

@@ -1,8 +1,9 @@
 import type { EditEngineContext } from "../engine.js";
 import { type OoxmlEditProviderOptions } from "../ooxml/worker.js";
 import { WorkerEngineClient } from "../worker-engine.js";
+import type { TextSpan } from "../range-style.js";
 import type { PptxEngineReads } from "./engine.js";
-import type { PptxLayoutInfo, PptxSlideInfo } from "./types.js";
+import type { PptxLayoutInfo, PptxSlideInfo, PptxTextStyle } from "./types.js";
 export type PptxEditProviderOptions = OoxmlEditProviderOptions;
 /**
  * Starts the OOXML edit worker for `original` as a PPTX engine. Loaded
@@ -14,4 +15,5 @@ export declare class PptxEditEngineClient extends WorkerEngineClient implements
     start(original: Uint8Array): Promise<void>;
     slides(signal: AbortSignal): Promise<readonly PptxSlideInfo[]>;
     layouts(signal: AbortSignal): Promise<readonly PptxLayoutInfo[]>;
+    textStyle(id: string, span: TextSpan | undefined, signal: AbortSignal): Promise<Partial<PptxTextStyle> | undefined>;
 }

package/dist/edit/pptx/provider.js

@@ -37,4 +37,7 @@ export class PptxEditEngineClient extends WorkerEngineClient {
     layouts(signal) {
         return this.request("edit-pptx-layouts", undefined, signal);
     }
+    textStyle(id, span, signal) {
+        return this.request("edit-pptx-text-style", { id, span }, signal);
+    }
 }

package/dist/edit/pptx/session.d.ts

@@ -1,7 +1,7 @@
 import type { DescribeOptions, DocumentDescription, EditCheckpoint, OutlineOptions, OutlineResult, TargetCandidate, TargetQuery, ToolCall, ToolCallOptions, ToolResult, ToolSet } from "../ai/types.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";
+import type { ApplyOptions, AssetOptions, EditFindOptions, EditOperation, EditReceipt, EditState, ElementQuery, HistoryOptions, OperationSchemaSet, PagePoint, ReadItem, ReadOptions, ReadResult, SavedDocument, TextRange, 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, PptxTextStyle } from "./types.js";
 /**
  * The PPTX session: the core session narrowed to PPTX operations and
  * elements, plus the slide and layout reads. Each typed method is `apply()`
@@ -42,6 +42,10 @@ export declare class PptxSession implements PptxEditSession {
     callTool(call: ToolCall, options?: ToolCallOptions): Promise<ToolResult>;
     getSlides(options?: ReadOptions): Promise<ReadResult<PptxSlideInfo>>;
     getLayouts(options?: ReadOptions): Promise<ReadResult<PptxLayoutInfo>>;
+    getTextStyle(fields: {
+        readonly target: string;
+        readonly range?: TextRange;
+    }, options?: ReadOptions): Promise<ReadItem<Partial<PptxTextStyle>>>;
     replaceText(fields: PptxFields<PptxReplaceTextOperation>, options?: ApplyOptions): Promise<EditReceipt>;
     setTextStyle(fields: PptxFields<PptxSetTextStyleOperation>, options?: ApplyOptions): Promise<EditReceipt>;
     setShapeStyle(fields: PptxFields<PptxSetShapeStyleOperation>, options?: ApplyOptions): Promise<EditReceipt>;

package/dist/edit/pptx/session.js

@@ -2,6 +2,7 @@ import { ViewerError } from "../../errors.js";
 import { readDescription, readOutline } from "../ai/outline.js";
 import { resolveTargets } from "../ai/targets.js";
 import { buildToolSet, callTool as runTool } from "../ai/tools.js";
+import { spanOnTarget } from "../range-style.js";
 /**
  * The PPTX session: the core session narrowed to PPTX operations and
  * elements, plus the slide and layout reads. Each typed method is `apply()`
@@ -118,6 +119,10 @@ export class PptxSession {
     getLayouts(options) {
         return this.#core.readItems(options, (engine, signal) => pptxReads(engine).layouts(signal));
     }
+    async getTextStyle(fields, options) {
+        const span = spanOnTarget(fields.target, fields.range);
+        return this.#core.readItem(options, (engine, signal) => pptxReads(engine).textStyle(fields.target, span, signal));
+    }
     replaceText(fields, options) {
         return this.apply([{ op: "replaceText", ...fields }], options);
     }
@@ -165,7 +170,8 @@ export class PptxSession {
 function pptxReads(engine) {
     const candidate = engine;
     if (typeof candidate.slides !== "function" ||
-        typeof candidate.layouts !== "function")
+        typeof candidate.layouts !== "function" ||
+        typeof candidate.textStyle !== "function")
         throw new ViewerError("edit-unsupported", "The engine does not provide the PPTX reads", { details: { format: "pptx", reason: "no-reads" } });
     return candidate;
 }

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

@@ -1,4 +1,4 @@
-import type { ApplyOptions, BinaryData, EditColor, EditElement, EditReceipt, EditSessionBase, PagePoint, PageRect, ReadOptions, ReadResult, SavedDocument, SaveOptions, TextRange } from "../types.js";
+import type { ApplyOptions, BinaryData, EditColor, EditElement, EditReceipt, EditSessionBase, PagePoint, PageRect, ReadItem, ReadOptions, ReadResult, SavedDocument, SaveOptions, TextRange } from "../types.js";
 export type PptxElementKind = "shape" | "image" | "table" | "connector" | "group" | "other";
 export type PptxTextAlign = "left" | "center" | "right" | "justify";
 /** The style of the first run with text, resolved through the placeholder chain and the theme. */
@@ -201,6 +201,16 @@ export interface PptxEditSession extends EditSessionBase<PptxOperation, PptxElem
     getSlides(options?: ReadOptions): Promise<ReadResult<PptxSlideInfo>>;
     /** Every layout of every master, for `insertSlide`. */
     getLayouts(options?: ReadOptions): Promise<ReadResult<PptxLayoutInfo>>;
+    /**
+     * The text style a range of a shape's text shows: each property every run
+     * it covers shares, a property they differ on left out. Without a range,
+     * the whole text; a collapsed range reads the run before it, whose style
+     * text typed there takes. `undefined` for an element without text.
+     */
+    getTextStyle(fields: {
+        readonly target: string;
+        readonly range?: TextRange;
+    }, options?: ReadOptions): Promise<ReadItem<Partial<PptxTextStyle>>>;
     /** Replaces the whole text of a shape, or the part a range covers. */
     replaceText(fields: PptxFields<PptxReplaceTextOperation>, options?: ApplyOptions): Promise<EditReceipt>;
     /** Changes run and paragraph properties; unspecified ones keep their bytes. */

package/dist/edit/range-style.d.ts

@@ -0,0 +1,24 @@
+import type { TextRange } from "./types.js";
+/** Half-open UTF-16 offsets in an element's text. */
+export interface TextSpan {
+    readonly start: number;
+    readonly end: number;
+}
+/**
+ * The span a range names on its target, or `undefined` for no range (the
+ * whole text). Both ends must lie on the target.
+ */
+export declare function spanOnTarget(target: string, range: TextRange | undefined): TextSpan | undefined;
+/**
+ * The runs a span covers. A collapsed span reads the run before it, whose
+ * style text typed there takes, or the first run after it at the very start.
+ */
+export declare function runsCovering<R extends TextSpan>(runs: readonly R[], span: TextSpan): R[];
+/**
+ * What every style has in common: a property two of them differ on, or one
+ * some leave out, is left out. Values compare as JSON, so a theme colour and
+ * its plain form differ.
+ */
+export declare function sharedStyle<T extends object>(styles: readonly T[]): Partial<T> | undefined;
+/** Whether a span lies inside a text of `length` code units. */
+export declare function spanFits(span: TextSpan, length: number): boolean;

package/dist/edit/range-style.js

@@ -0,0 +1,46 @@
+import { ViewerError } from "../errors.js";
+/**
+ * The span a range names on its target, or `undefined` for no range (the
+ * whole text). Both ends must lie on the target.
+ */
+export function spanOnTarget(target, range) {
+    if (!range)
+        return undefined;
+    if (range.start.elementId !== target || range.end.elementId !== target)
+        throw new ViewerError("invalid-operation", "Both ends of the range must lie on the target", { details: { target } });
+    return { start: range.start.offset, end: range.end.offset };
+}
+/**
+ * The runs a span covers. A collapsed span reads the run before it, whose
+ * style text typed there takes, or the first run after it at the very start.
+ */
+export function runsCovering(runs, span) {
+    if (span.start < span.end)
+        return runs.filter((run) => run.start < span.end && run.end > span.start);
+    const before = runs
+        .filter((run) => run.start < span.start && run.end >= span.start)
+        .at(-1);
+    const at = before ?? runs.find((run) => run.start >= span.start);
+    return at ? [at] : [];
+}
+/**
+ * What every style has in common: a property two of them differ on, or one
+ * some leave out, is left out. Values compare as JSON, so a theme colour and
+ * its plain form differ.
+ */
+export function sharedStyle(styles) {
+    const [first, ...rest] = styles;
+    if (!first)
+        return undefined;
+    const shared = {};
+    for (const key of Object.keys(first)) {
+        const value = JSON.stringify(first[key]);
+        if (rest.every((style) => key in style && JSON.stringify(style[key]) === value))
+            shared[key] = first[key];
+    }
+    return shared;
+}
+/** Whether a span lies inside a text of `length` code units. */
+export function spanFits(span, length) {
+    return span.start >= 0 && span.start <= span.end && span.end <= length;
+}

package/dist/edit/session.js

@@ -739,6 +739,11 @@ export class EditSessionController {
             ...(change.remappedIds
                 ? { remappedIds: Object.freeze({ ...change.remappedIds }) }
                 : {}),
+            ...(change.textAnchorMigrations?.length
+                ? {
+                    textAnchorMigrations: Object.freeze(change.textAnchorMigrations.map((migration) => Object.freeze({ ...migration }))),
+                }
+                : {}),
             changedPages: Object.freeze([...change.changedPages]),
             pageCount: change.pageCount,
             warnings: Object.freeze(change.warnings.map((warning) => Object.freeze({ ...warning }))),