web-doc 0.7.0 → 0.8.0

package/dist/edit/session.js

@@ -1,7 +1,10 @@
 import { linkedAbortController } from "../abort.js";
 import { abortError, 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 { assetIdOf, AssetStore, binaryFields, isAssetReference, } from "./assets.js";
-import { EditHistory } from "./history.js";
+import { batchOf, EditHistory, modeOf } from "./history.js";
 import { assertBatchSize, checkOperations, freezeOperations, invalidOperationError, parseReference, } from "./operations.js";
 /**
  * The format-independent editing session: validation, history, revisions,
@@ -17,15 +20,20 @@ export class EditSessionController {
     #original;
     #originalPageCount;
     #ending = new AbortController();
-    sessionId = newSessionId();
+    sessionId = randomId();
     /** Bytes of the last committed state; what the viewer shows and what a broken session saves. */
     #committedBytes;
     /** Materialized bytes of some committed states, by state id, so restores replay less. */
     #checkpoints = new Map();
     #checkpointBytes = 0;
+    /** Named checkpoints by id, in creation order. */
+    #named = new Map();
+    /** State ids named checkpoints pin, with how many name each; never evicted. */
+    #pinned = new Map();
     /** Binary payloads of this session's batches, by content id. */
     #assets = new AssetStore();
     #state;
+    #tools;
     #queue = Promise.resolve();
     #revision = 0;
     #savedStateId = 0;
@@ -46,6 +54,9 @@ export class EditSessionController {
     get state() {
         return this.#state;
     }
+    get limits() {
+        return this.#host.limits;
+    }
     applyJson(operations, options = {}) {
         return this.apply(operations, options);
     }
@@ -58,6 +69,9 @@ export class EditSessionController {
         return this.#enqueue(options.signal, async (signal) => {
             this.#assertRevision(options);
             assertBatchSize(batch, this.#host.limits.maxEditOperations);
+            const modeIssues = checkChangeMode(this.format, options);
+            if (modeIssues.length > 0)
+                throw invalidOperationError(modeIssues);
             const shapeIssues = checkOperations(batch, this.schemas);
             if (shapeIssues.length > 0)
                 throw invalidOperationError(shapeIssues);
@@ -65,7 +79,8 @@ export class EditSessionController {
             if (referenceIssues.length > 0)
                 throw invalidOperationError(referenceIssues);
             const interned = await this.#intern(batch, signal);
-            const engineIssues = await this.#engine.validate(interned, signal);
+            const mode = modeOf(options);
+            const engineIssues = await this.#engine.validate(interned, signal, mode);
             throwIfAborted(signal);
             if (engineIssues.length > 0)
                 throw invalidOperationError(engineIssues);
@@ -74,6 +89,7 @@ export class EditSessionController {
             const engineBatch = {
                 stateId: this.#history.nextStateId,
                 operations: interned,
+                ...mode,
             };
             if (options.dryRun) {
                 const change = await this.#transaction(signal, "apply", async () => {
@@ -99,6 +115,7 @@ export class EditSessionController {
             });
             this.#history.push({
                 operations: interned,
+                ...mode,
                 ...(options.label === undefined ? {} : { label: options.label }),
                 createdIds: change.createdIds,
                 removedIds: change.removedIds,
@@ -230,6 +247,88 @@ export class EditSessionController {
         const { signal: own, ...engineOptions } = options;
         return this.#enqueue(own, async (signal) => this.#items(await this.#engine.findText(query, engineOptions, signal)));
     }
+    getOutline(options) {
+        return readOutline(this, this.#host.limits, options);
+    }
+    describe(options) {
+        return readDescription(this, this.#host.limits, options);
+    }
+    resolveTargets(query, options) {
+        return resolveTargets(this, query, options);
+    }
+    createCheckpoint(label) {
+        return this.#enqueue(undefined, async () => {
+            const limit = this.#host.limits.maxEditCheckpoints;
+            if (this.#named.size >= limit)
+                throw new ViewerError("resource-limit", "Too many edit checkpoints; drop one first", { details: { limit } });
+            const stateId = this.#history.stateId;
+            const checkpoint = Object.freeze({
+                id: randomId(),
+                ...(label === undefined ? {} : { label }),
+                revision: this.#revision,
+                createdAt: new Date().toISOString(),
+            });
+            const entries = this.#history.entriesAt(this.#history.position);
+            this.#named.set(checkpoint.id, {
+                checkpoint,
+                stateId,
+                pageCount: this.#history.pageCount,
+                entries,
+                batches: batchesFromOriginal(entries),
+            });
+            this.#pin(stateId, this.#committedBytes);
+            return checkpoint;
+        });
+    }
+    listCheckpoints() {
+        return Object.freeze([...this.#named.values()].map((named) => named.checkpoint));
+    }
+    restoreCheckpoint(id, options = {}) {
+        return this.#enqueue(options.signal, async (signal) => {
+            this.#assertRevision(options);
+            const named = this.#named.get(id);
+            if (!named)
+                throw new ViewerError("invalid-operation", `Unknown edit checkpoint ${id}`, { details: { checkpointId: id } });
+            if (named.stateId === this.#history.stateId)
+                return this.#noop();
+            const before = this.#history.pageCount;
+            const changedPages = allPages(Math.max(before, named.pageCount));
+            const shown = await this.#transaction(signal, "apply", async () => {
+                await this.#engine.restore(this.#targetFor(named.entries), signal);
+                return this.#show(signal, changedPages);
+            });
+            const diff = entryDiff(this.#history.entriesAt(this.#history.position), named.entries);
+            this.#history.push({
+                operations: [],
+                createdIds: diff.created,
+                removedIds: diff.removed,
+                changedPages: shown.changedPages,
+                pageCountBefore: before,
+                pageCountAfter: shown.pageCount,
+                base: { stateId: named.stateId, batches: named.batches },
+            }, named.stateId);
+            this.#commit("restore", shown.changedPages, shown);
+            return this.#receipt(false, 0, diff.created, {
+                removedIds: diff.removed,
+                changedPages: shown.changedPages,
+                pageCount: shown.pageCount,
+                warnings: [],
+            });
+        });
+    }
+    dropCheckpoint(id) {
+        const named = this.#named.get(id);
+        if (!named)
+            return;
+        this.#named.delete(id);
+        this.#unpin(named.stateId);
+    }
+    get tools() {
+        return (this.#tools ??= buildToolSet(this.format, this.schemas));
+    }
+    callTool(call, options) {
+        return runTool(this, this.tools, call, options);
+    }
     readItem(options, task) {
         return this.#enqueue(options?.signal, async (signal) => Object.freeze({
             sessionId: this.sessionId,
@@ -412,7 +511,7 @@ export class EditSessionController {
     }
     #commit(reason, changedPages, shown) {
         this.#committedBytes = shown.bytes;
-        if (reason === "apply")
+        if (reason === "apply" || reason === "restore")
             this.#keepCheckpoint(shown.bytes);
         else if (reason === "reset")
             this.#dropCheckpoints();
@@ -500,49 +599,107 @@ export class EditSessionController {
     #keepCheckpoint(bytes) {
         const stride = Math.max(1, Math.floor(this.#host.limits.maxEditHistory / 4));
         const stateId = this.#history.stateId;
-        // Entries dropped by a new change after an undo can never be restored.
-        const reachable = new Set(this.#history.stateIds);
+        // Entries dropped by a new change after an undo can never be restored;
+        // a pinned state stays whatever the history does.
+        const reachable = this.#reachable();
         for (const [id, kept] of this.#checkpoints)
-            if (!reachable.has(id))
+            if (!reachable.has(id) && !this.#pinned.has(id))
                 this.#forgetCheckpoint(id, kept);
-        if (stateId % stride !== 0)
+        if (stateId === 0 ||
+            this.#checkpoints.has(stateId) ||
+            stateId % stride !== 0)
             return;
+        this.#retain(stateId, bytes);
+    }
+    /** Stores a state's bytes when the budget, less the pinned states, can hold them. */
+    #retain(stateId, bytes) {
         const budget = this.#host.limits.maxEditCheckpointBytes;
         if (bytes.byteLength > budget)
             return;
-        const oldestFirst = [...this.#checkpoints.keys()].sort((a, b) => a - b);
+        const evictable = [...this.#checkpoints.keys()]
+            .filter((id) => !this.#pinned.has(id))
+            .sort((a, b) => a - b);
         while (this.#checkpointBytes + bytes.byteLength > budget &&
-            oldestFirst.length > 0) {
-            const id = oldestFirst.shift();
+            evictable.length > 0) {
+            const id = evictable.shift();
             this.#forgetCheckpoint(id, this.#checkpoints.get(id));
         }
+        if (this.#checkpointBytes + bytes.byteLength > budget)
+            return;
         this.#checkpoints.set(stateId, bytes);
         this.#checkpointBytes += bytes.byteLength;
     }
+    /**
+     * Pins a state for a named checkpoint: its bytes are kept while any
+     * checkpoint names it, or rebuilt by replay when the budget cannot hold
+     * them. The original (state 0) needs no bytes.
+     */
+    #pin(stateId, bytes) {
+        if (stateId === 0)
+            return;
+        this.#pinned.set(stateId, (this.#pinned.get(stateId) ?? 0) + 1);
+        if (!this.#checkpoints.has(stateId))
+            this.#retain(stateId, bytes);
+    }
+    #unpin(stateId) {
+        const count = this.#pinned.get(stateId);
+        if (!count)
+            return;
+        if (count > 1) {
+            this.#pinned.set(stateId, count - 1);
+            return;
+        }
+        this.#pinned.delete(stateId);
+        const kept = this.#checkpoints.get(stateId);
+        if (kept && !this.#reachable().has(stateId))
+            this.#forgetCheckpoint(stateId, kept);
+    }
+    /** State ids a replay may start from: every entry's, and the base of every restore. */
+    #reachable() {
+        const reachable = new Set();
+        for (const entry of this.#history.allEntries) {
+            reachable.add(entry.stateId);
+            if (entry.base)
+                reachable.add(entry.base.stateId);
+        }
+        return reachable;
+    }
     #forgetCheckpoint(id, bytes) {
         this.#checkpoints.delete(id);
         this.#checkpointBytes -= bytes.byteLength;
     }
+    /** After a reset nothing in the history is reachable; pinned states stay. */
     #dropCheckpoints() {
-        this.#checkpoints.clear();
-        this.#checkpointBytes = 0;
+        for (const [id, kept] of this.#checkpoints)
+            if (!this.#pinned.has(id))
+                this.#forgetCheckpoint(id, kept);
     }
     /**
      * The cheapest way to rebuild the state at `position`: the newest
-     * checkpoint at or before it, plus the batches after that checkpoint.
+     * retained bytes at or before it, plus the batches after them.
      */
     #restoreTarget(position = this.#history.position) {
-        const entries = this.#history.entriesAt(position);
-        let last = entries.length - 1;
-        while (last >= 0 && !this.#checkpoints.has(entries[last].stateId))
-            last -= 1;
-        const batches = entries.slice(last + 1).map((entry) => ({
-            stateId: entry.stateId,
-            operations: entry.operations,
-        }));
-        return last >= 0
-            ? { base: this.#checkpoints.get(entries[last].stateId), batches }
-            : { batches };
+        return this.#targetFor(this.#history.entriesAt(position));
+    }
+    /**
+     * Walks `entries` from the end: the first with retained bytes is the base;
+     * a restore entry without them starts from the original plus the batches
+     * that built its checkpoint.
+     */
+    #targetFor(entries) {
+        for (let index = entries.length - 1; index >= 0; index -= 1) {
+            const entry = entries[index];
+            const after = () => batchesOf(entries.slice(index + 1));
+            const retained = this.#checkpoints.get(entry.stateId);
+            if (retained)
+                return { base: retained, batches: after() };
+            // A restore entry carries its checkpoint's state id, so its bytes
+            // were just looked up; without them the checkpoint's batches rebuild
+            // it from the original.
+            if (entry.base)
+                return { batches: [...entry.base.batches, ...after()] };
+        }
+        return { batches: batchesOf(entries) };
     }
     #stateToken(stateId) {
         return `${this.sessionId}:${stateId}`;
@@ -667,6 +824,43 @@ function checkBatchReferences(operations) {
     });
     return issues;
 }
+/**
+ * Tracked changes exist in DOCX only and always name their author (decision
+ * 8 of the ai-edit module): the batch is refused before any engine work.
+ */
+function checkChangeMode(format, options) {
+    const issues = [];
+    // A timestamp is written into the file where a format records one, so
+    // it must be a date-time the file can hold whatever the mode.
+    if (options.timestamp !== undefined &&
+        (!DATE_TIME.test(options.timestamp) ||
+            Number.isNaN(Date.parse(options.timestamp))))
+        issues.push({
+            operationIndex: -1,
+            path: "/timestamp",
+            code: "invalid-value",
+            message: "The timestamp must be an ISO 8601 date-time",
+        });
+    if (options.changeMode !== "tracked")
+        return issues;
+    if (format !== "docx")
+        issues.push({
+            operationIndex: -1,
+            path: "",
+            code: "unsupported-change-mode",
+            message: `${format.toUpperCase()} has no tracked changes; apply directly and review with checkpoints`,
+        });
+    else if (!options.author || options.author.trim().length === 0)
+        issues.push({
+            operationIndex: -1,
+            path: "/author",
+            code: "required",
+            message: "Tracked changes name their author; pass ApplyOptions.author",
+        });
+    return issues;
+}
+/** ISO 8601 as `xsd:dateTime` takes it. */
+const DATE_TIME = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})?$/;
 /** The renderer owns the page count; an engine that disagrees is reported, not trusted. */
 function pageCountWarning(change, shown) {
     if (change.pageCount === undefined || change.pageCount === shown.pageCount)
@@ -679,8 +873,56 @@ function pageCountWarning(change, shown) {
         },
     ];
 }
-/** 128 random bits as URL-safe base64; unique across sessions and reloads. */
-function newSessionId() {
+/** The engine batches of entries that carry operations; restore entries carry none. */
+function batchesOf(entries) {
+    return entries.filter((entry) => entry.operations.length > 0).map(batchOf);
+}
+/** The batches from the original to the state after `entries`, through the last restore. */
+function batchesFromOriginal(entries) {
+    for (let index = entries.length - 1; index >= 0; index -= 1) {
+        const base = entries[index].base;
+        if (base)
+            return [...base.batches, ...batchesOf(entries.slice(index + 1))];
+    }
+    return batchesOf(entries);
+}
+/**
+ * The ids a move from the state after `current` to the state after `target`
+ * removes and creates: the entries past the common prefix are undone in
+ * reverse, then the target's are redone, each id netted out.
+ */
+function entryDiff(current, target) {
+    let common = 0;
+    while (common < current.length &&
+        common < target.length &&
+        current[common].stateId === target[common].stateId)
+        common += 1;
+    const created = new Set();
+    const removed = new Set();
+    const create = (id) => {
+        if (removed.has(id))
+            removed.delete(id);
+        else
+            created.add(id);
+    };
+    const remove = (id) => {
+        if (created.has(id))
+            created.delete(id);
+        else
+            removed.add(id);
+    };
+    for (const entry of current.slice(common).reverse()) {
+        entry.createdIds.forEach(remove);
+        entry.removedIds.forEach(create);
+    }
+    for (const entry of target.slice(common)) {
+        entry.removedIds.forEach(remove);
+        entry.createdIds.forEach(create);
+    }
+    return { created: [...created], removed: [...removed] };
+}
+/** 128 random bits as 22 URL-safe base64 characters; unique across sessions and reloads. */
+function randomId() {
     const bytes = globalThis.crypto.getRandomValues(new Uint8Array(16));
     let binary = "";
     for (const byte of bytes)

package/dist/edit/types.d.ts

@@ -1,4 +1,5 @@
 import type { ViewerWarning } from "../contracts.js";
+import type { EditSessionReads } from "./ai/types.js";
 /** Formats an edit session can be started for. */
 export type EditableFormat = "pdf" | "pptx" | "docx";
 export interface EditOptions {
@@ -163,16 +164,27 @@ export interface EditState {
     readonly canRedo: boolean;
     readonly pageCount: number;
 }
+/** How a batch is written: in place, or as tracked changes (DOCX) for a person to accept or reject. */
+export type ChangeMode = "direct" | "tracked";
 export interface ApplyOptions {
     /** Rejects the call with `edit-conflict` unless `state.revision` equals this value. */
     readonly expectedRevision?: number;
+    /**
+     * Default `direct`. `tracked` writes Word revisions (`w:ins`, `w:del`,
+     * `w:rPrChange`, `w:pPrChange`) with `author` and `timestamp`; refused
+     * with `unsupported-change-mode` by formats and operations without a
+     * tracked form, and with `required` at `/author` without an author.
+     */
+    readonly changeMode?: ChangeMode;
+    /** The `w:author` of tracked changes; required with `changeMode: "tracked"`. */
+    readonly author?: string;
     /** Rejects with `edit-conflict` unless it equals `sessionId`; for callers that outlive a session. */
     readonly expectedSessionId?: string;
     /** Validates and simulates the batch without changing anything. */
     readonly dryRun?: boolean;
     /** Free text stored with the history entry, for host UIs and audit logs. */
     readonly label?: string;
-    /** Reserved: ISO 8601 time a format records with the change; never generated by web-doc. */
+    /** ISO 8601 time a format records with the change (the `w:date` of a tracked change); never generated by web-doc. */
     readonly timestamp?: string;
     readonly signal?: AbortSignal;
 }
@@ -228,7 +240,7 @@ export interface OperationIssue {
     readonly code: string;
     readonly message: string;
 }
-export interface EditSessionBase<TOperation extends EditOperation, TElement extends EditElement> {
+export interface EditSessionBase<TOperation extends EditOperation, TElement extends EditElement> extends EditSessionReads {
     readonly format: EditableFormat;
     /** Unique per session; stamped on state, receipts, read results and events. */
     readonly sessionId: string;
@@ -258,7 +270,9 @@ export interface EditStateChange extends EditState {
     readonly active: boolean;
     readonly format?: EditableFormat;
 }
-export type DocumentChangeReason = "apply" | "undo" | "redo" | "reset";
+export type DocumentChangeReason = "apply" | "undo" | "redo" | "reset"
+/** `restoreCheckpoint()`: the content of a named checkpoint, as one history entry. */
+ | "restore";
 export interface DocumentChange {
     readonly sessionId: string;
     readonly revision: number;

package/dist/edit/worker-engine.d.ts

@@ -1,6 +1,6 @@
 import type { WorkerRpcClient } from "../worker-client.js";
 import type { EditWorkerOperation } from "../worker-protocol.js";
-import type { EditEngine, EditEngineContext, EngineBatch, EngineChange, MaterializedDocument, MaterializeOptions, RestoreTarget } from "./engine.js";
+import type { EditEngine, EditEngineContext, BatchMode, EngineBatch, EngineChange, MaterializedDocument, MaterializeOptions, RestoreTarget } from "./engine.js";
 import type { EditElement, EditFindOptions, EditOperation, ElementQuery, OperationIssue, OperationSchemaSet, PagePoint, TextTarget } from "./types.js";
 export declare abstract class WorkerEngineClient implements EditEngine {
     #private;
@@ -8,7 +8,7 @@ export declare abstract class WorkerEngineClient implements EditEngine {
     protected readonly rpc: WorkerRpcClient;
     protected readonly context: EditEngineContext;
     constructor(rpc: WorkerRpcClient, context: EditEngineContext);
-    validate(operations: readonly EditOperation[], signal: AbortSignal): Promise<readonly OperationIssue[]>;
+    validate(operations: readonly EditOperation[], signal: AbortSignal, mode?: BatchMode): Promise<readonly OperationIssue[]>;
     /** Plain operation arrays, as the unit tests pass them, become the next batch. */
     apply(input: EngineBatch | readonly EditOperation[], signal: AbortSignal): Promise<EngineChange>;
     /** A bare signal, as the unit tests pass it, asks for the shown form. */

package/dist/edit/worker-engine.js

@@ -12,8 +12,8 @@ export class WorkerEngineClient {
         this.rpc = rpc;
         this.context = context;
     }
-    validate(operations, signal) {
-        return this.request("edit-validate", { operations }, signal);
+    validate(operations, signal, mode = {}) {
+        return this.request("edit-validate", { operations, mode }, signal);
     }
     /** Plain operation arrays, as the unit tests pass them, become the next batch. */
     apply(input, signal) {

package/dist/fuzzy-alignment.d.ts

@@ -6,7 +6,14 @@
  * than a page × query traceback matrix. Equal-cost occurrences prefer the
  * earliest end, so an unmatched character after a passage cannot extend it.
  */
-export declare function alignFuzzyPassage(text: string, query: string, caseSensitive: boolean, maxScore: number): {
-    start: number;
-    end: number;
-} | undefined;
+/** The best contiguous alignment of a query in a text, with its edit cost. */
+export interface FuzzyPassage {
+    /** Offsets into the original text, in UTF-16 code units. */
+    readonly start: number;
+    readonly end: number;
+    /** Edits between the query and the passage; `cost / length` is the score Fuse bounds. */
+    readonly cost: number;
+    /** The normalized query's length. */
+    readonly length: number;
+}
+export declare function alignFuzzyPassage(text: string, query: string, caseSensitive: boolean, maxScore: number): FuzzyPassage | undefined;

package/dist/fuzzy-alignment.js

@@ -1,12 +1,4 @@
 import { normalizeSearchText, normalizeWithMap } from "./search-text.js";
-/**
- * Fuse's indices describe character masks, not a contiguous edit alignment.
- * Refine an accepted page with semi-global Levenshtein alignment: consume the
- * whole query, allowing free text before and after one occurrence. Tracking
- * the start alongside each cost needs O(query length) working memory rather
- * than a page × query traceback matrix. Equal-cost occurrences prefer the
- * earliest end, so an unmatched character after a passage cannot extend it.
- */
 export function alignFuzzyPassage(text, query, caseSensitive, maxScore) {
     const source = normalizeWithMap(text, caseSensitive);
     const pattern = normalizeSearchText(query, caseSensitive);
@@ -59,5 +51,7 @@ export function alignFuzzyPassage(text, query, caseSensitive, maxScore) {
         return undefined;
     const start = source.starts[bestStart];
     const end = source.ends[bestEnd - 1];
-    return start === undefined || end === undefined ? undefined : { start, end };
+    return start === undefined || end === undefined
+        ? undefined
+        : { start, end, cost: bestCost, length };
 }

package/dist/headless.d.ts

@@ -6,7 +6,7 @@ export * from "./edit/pptx/types.js";
 export * from "./client.js";
 export * from "./viewer.js";
 export * from "./detect.js";
-export * from "./errors.js";
+export { abortError, errorFromData, normalizeError, ViewerError, } from "./errors.js";
 export * from "./format.js";
 export * from "./limits.js";
 export * from "./interaction.js";

package/dist/headless.js

@@ -6,7 +6,10 @@ export * from "./edit/pptx/types.js";
 export * from "./client.js";
 export * from "./viewer.js";
 export * from "./detect.js";
-export * from "./errors.js";
+// Named on purpose: a bundler that inlines the lazily loaded edit engines
+// (esbuild without code splitting) initialises this module lazily, and a
+// star re-export would then hand a consumer an undefined class.
+export { abortError, errorFromData, normalizeError, ViewerError, } from "./errors.js";
 export * from "./format.js";
 export * from "./limits.js";
 export * from "./interaction.js";

package/dist/index.d.ts

@@ -1,12 +1,14 @@
 export * from "./contracts.js";
 export * from "./edit/types.js";
+export * from "./edit/ai/types.js";
+export { describeReceipt } from "./edit/ai/tools.js";
 export * from "./edit/sessions.js";
 export * from "./edit/pdf/types.js";
 export * from "./edit/pptx/types.js";
 export * from "./edit/docx/types.js";
 export * from "./client.js";
 export * from "./detect.js";
-export * from "./errors.js";
+export { abortError, errorFromData, normalizeError, ViewerError, } from "./errors.js";
 export * from "./format.js";
 export * from "./limits.js";
 export * from "./interaction.js";
@@ -23,7 +25,8 @@ export * from "./ui.js";
 export * from "./ui-styles.js";
 export * from "./registry.js";
 export * from "./viewer.js";
-export * from "./worker-client.js";
+export { WorkerRpcClient } from "./worker-client.js";
+export type { WorkerLike, WorkerRequestOptions } from "./worker-client.js";
 export * from "./worker-adapter.js";
 export * from "./worker-endpoint.js";
 export * from "./worker-protocol.js";

package/dist/index.js

@@ -1,12 +1,17 @@
 export * from "./contracts.js";
 export * from "./edit/types.js";
+export * from "./edit/ai/types.js";
+export { describeReceipt } from "./edit/ai/tools.js";
 export * from "./edit/sessions.js";
 export * from "./edit/pdf/types.js";
 export * from "./edit/pptx/types.js";
 export * from "./edit/docx/types.js";
 export * from "./client.js";
 export * from "./detect.js";
-export * from "./errors.js";
+// Named like the worker client below: the error class is reached from the
+// lazily loaded engines too and must not come out undefined in a consumer
+// bundle without code splitting.
+export { abortError, errorFromData, normalizeError, ViewerError, } from "./errors.js";
 export * from "./format.js";
 export * from "./limits.js";
 export * from "./interaction.js";
@@ -23,7 +28,11 @@ export * from "./ui.js";
 export * from "./ui-styles.js";
 export * from "./registry.js";
 export * from "./viewer.js";
-export * from "./worker-client.js";
+// Named on purpose: a bundler that inlines the lazily loaded edit engines
+// (esbuild without code splitting) initialises this module lazily, and a
+// star re-export would then hand a consumer an undefined class
+// (`scripts/consumer-bundle.test.mjs` guards every class and constant).
+export { WorkerRpcClient } from "./worker-client.js";
 export * from "./worker-adapter.js";
 export * from "./worker-endpoint.js";
 export * from "./worker-protocol.js";

package/dist/limits.js

@@ -13,6 +13,9 @@ export const defaultResourceLimits = Object.freeze({
     maxEditOperations: 500,
     maxEditHistory: 200,
     maxEditCheckpointBytes: 64 * 1024 * 1024,
+    maxOutlineNodes: 5000,
+    maxDescribeChars: 200_000,
+    maxEditCheckpoints: 20,
 });
 export function resolveLimits(base = {}, override = {}) {
     const result = { ...defaultResourceLimits, ...base, ...override };

package/dist/worker-protocol.d.ts

@@ -2,7 +2,7 @@ import type { DocumentFormat, DocumentInfo, ResourceLimits, TextRun, ViewerError
 import type { EditableFormat } from "./edit/types.js";
 export type DocumentWorkerOperation = "init" | "open" | "get-info" | "render" | "get-text-map" | "close" | "destroy";
 /** Operations of an edit engine worker; payloads mirror the engine interface. */
-export type EditWorkerOperation = "edit-init" | "edit-open" | "edit-validate" | "edit-apply" | "edit-materialize" | "edit-restore" | "edit-put-asset" | "edit-elements" | "edit-element" | "edit-elements-at" | "edit-find-text" | "edit-text-layout" | "edit-position-at" | "edit-range-rects" | "edit-render-without" | "edit-page-layout" | "edit-pptx-slides" | "edit-pptx-layouts" | "edit-dispose";
+export type EditWorkerOperation = "edit-init" | "edit-open" | "edit-validate" | "edit-apply" | "edit-materialize" | "edit-restore" | "edit-put-asset" | "edit-elements" | "edit-element" | "edit-elements-at" | "edit-find-text" | "edit-text-layout" | "edit-position-at" | "edit-range-rects" | "edit-render-without" | "edit-page-layout" | "edit-pptx-slides" | "edit-pptx-layouts" | "edit-docx-revisions" | "edit-dispose";
 export type WorkerOperation = DocumentWorkerOperation | EditWorkerOperation;
 export interface WorkerRequest {
     readonly kind: "request";

package/dist/workers/fuzzy-search-worker.js

@@ -1634,7 +1634,7 @@ function alignFuzzyPassage(text, query, caseSensitive, maxScore) {
   if (bestEnd <= bestStart || bestCost / length > maxScore) return void 0;
   const start = source.starts[bestStart];
   const end = source.ends[bestEnd - 1];
-  return start === void 0 || end === void 0 ? void 0 : { start, end };
+  return start === void 0 || end === void 0 ? void 0 : { start, end, cost: bestCost, length };
 }
 
 // src/fuzzy-search.ts