web-doc 0.6.1 → 0.7.0

package/dist/edit/sessions.d.ts

@@ -0,0 +1,8 @@
+import type { DocxEditSession } from "./docx/types.js";
+import type { PdfEditSession } from "./pdf/types.js";
+import type { PptxEditSession } from "./pptx/types.js";
+/**
+ * The session of the loaded document, discriminated by `format`. Format
+ * modules add their member as they ship.
+ */
+export type EditSession = PdfEditSession | PptxEditSession | DocxEditSession;

package/dist/edit/sessions.js

@@ -0,0 +1 @@
+export {};

package/dist/edit/types.d.ts

@@ -0,0 +1,276 @@
+import type { ViewerWarning } from "../contracts.js";
+/** Formats an edit session can be started for. */
+export type EditableFormat = "pdf" | "pptx" | "docx";
+export interface EditOptions {
+    readonly signal?: AbortSignal;
+    /** Reserved: recorded with changes where a format keeps authorship (tracked changes). */
+    readonly author?: string;
+}
+/** A plain JSON object; each format defines its concrete operation union. */
+export interface EditOperation {
+    readonly op: string;
+}
+/**
+ * Binary payload: bytes, a base64 string for pure-JSON transports, or an
+ * `asset:` reference returned by `addAsset()`.
+ */
+export type BinaryData = Uint8Array | string;
+/** A colour as a format accepts it; PDF takes the string form only. */
+export type EditColor = ColorString | ThemeColor;
+/** `#RRGGBB` or `#RRGGBBAA`, or "auto" where a format has automatic colours. */
+export type ColorString = string;
+/** A theme slot with optional modifiers, for OOXML; keeps the theme link. */
+export interface ThemeColor {
+    readonly theme: string;
+    readonly mods?: Readonly<Record<string, number>>;
+}
+export type JsonSchema = Readonly<Record<string, unknown>>;
+export interface OperationSchemaSet {
+    readonly format: EditableFormat;
+    /** Raised whenever an operation's shape changes incompatibly. */
+    readonly version: number;
+    /** One JSON Schema (draft 2020-12) per operation name. */
+    readonly operations: Readonly<Record<string, JsonSchema>>;
+}
+/**
+ * A point in page space: the units of `DocumentInfo.pageSizes` at zoom 1
+ * (points for PDF, CSS pixels for DOCX and PPTX), origin at the top-left of
+ * the page as displayed, `y` growing downwards, page rotation applied.
+ */
+export interface PagePoint {
+    readonly x: number;
+    readonly y: number;
+}
+/** A rectangle in page space; see `PagePoint`. */
+export interface PageRect {
+    readonly x: number;
+    readonly y: number;
+    readonly width: number;
+    readonly height: number;
+}
+export interface PageHit {
+    readonly pageIndex: number;
+    readonly point: PagePoint;
+}
+/** Rectangle in client (CSS pixel) coordinates, like `getBoundingClientRect()`. */
+export interface ViewportRect {
+    readonly left: number;
+    readonly top: number;
+    readonly width: number;
+    readonly height: number;
+}
+export interface EditElement {
+    /** Opaque, stable for the lifetime of the session, never reused for another element. */
+    readonly id: string;
+    /** Format-specific kind, for example "text", "image", "shape", "table". */
+    readonly kind: string;
+    /** Page of the element, or of its first fragment. */
+    readonly pageIndex: number;
+    /** Axis-aligned bounds in page space, or those of the first fragment. */
+    readonly bounds: PageRect;
+    /** Clockwise rotation in degrees, when the element is rotated. */
+    readonly rotation?: number;
+    /** Untransformed frame for formats that keep one (OOXML shapes); `bounds` stays the AABB. */
+    readonly frame?: ElementFrame;
+    /** Every piece of an element that spans pages; absent when it has one. */
+    readonly fragments?: readonly ElementFragment[];
+    /** Where the element lives in a flow document; absent for the page body. */
+    readonly story?: ElementStory;
+    readonly text?: string;
+    readonly parentId?: string;
+    /** Names of the operations that accept this element as their target. */
+    readonly operations: readonly string[];
+}
+export interface ElementFragment {
+    readonly pageIndex: number;
+    readonly bounds: PageRect;
+}
+export interface ElementFrame extends PageRect {
+    readonly rotation: number;
+    readonly flipH: boolean;
+    readonly flipV: boolean;
+}
+export type ElementStory = {
+    readonly kind: "body";
+} | {
+    readonly kind: "header" | "footer";
+    readonly scope: string;
+} | {
+    readonly kind: "footnote" | "endnote" | "comment";
+    readonly id: string;
+} | {
+    readonly kind: "notes" | "layout" | "master";
+    readonly id: string;
+};
+/**
+ * A place in an element's text, in UTF-16 code units of `EditElement.text`.
+ * A tab, a break, an inline image and a field each count as one placeholder
+ * character.
+ */
+export interface TextPosition {
+    readonly elementId: string;
+    readonly offset: number;
+}
+/** Half-open; may span elements in reading order. */
+export interface TextRange {
+    readonly start: TextPosition;
+    readonly end: TextPosition;
+}
+export interface ElementQuery {
+    readonly pageIndex?: number;
+    readonly kinds?: readonly string[];
+    /** Only elements with a fragment whose bounds intersect this rectangle; requires `pageIndex`. */
+    readonly intersects?: PageRect;
+}
+export interface ReadOptions {
+    readonly signal?: AbortSignal;
+}
+export interface EditFindOptions extends ReadOptions {
+    readonly caseSensitive?: boolean;
+    /** Inclusive 0-based page range. */
+    readonly pageRange?: readonly [number, number];
+    readonly maxResults?: number;
+}
+export interface TextTarget {
+    /** Page of the first rectangle. */
+    readonly pageIndex: number;
+    readonly text: string;
+    readonly rects: readonly PageRect[];
+    /** Elements that contain the matched text, in reading order. */
+    readonly elementIds: readonly string[];
+    /** The match as text ranges, one per element it touches, in reading order. */
+    readonly ranges: readonly TextRange[];
+}
+/** Every read says which state it describes. */
+export interface ReadEnvelope {
+    readonly sessionId: string;
+    readonly revision: number;
+}
+export interface ReadResult<T> extends ReadEnvelope {
+    readonly items: readonly T[];
+}
+export interface ReadItem<T> extends ReadEnvelope {
+    readonly item: T | undefined;
+}
+export interface EditState {
+    /** Unique per session; stamped on receipts, read results and events. */
+    readonly sessionId: string;
+    /** Starts at 0 and grows by one with every applied change (apply, undo, redo, reset). */
+    readonly revision: number;
+    /** True while the content differs from the state last given to `markSaved()`, or from the original. */
+    readonly dirty: boolean;
+    readonly canUndo: boolean;
+    readonly canRedo: boolean;
+    readonly pageCount: number;
+}
+export interface ApplyOptions {
+    /** Rejects the call with `edit-conflict` unless `state.revision` equals this value. */
+    readonly expectedRevision?: number;
+    /** 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. */
+    readonly timestamp?: string;
+    readonly signal?: AbortSignal;
+}
+export interface HistoryOptions {
+    readonly expectedRevision?: number;
+    readonly expectedSessionId?: string;
+    readonly signal?: AbortSignal;
+}
+export interface SaveOptions {
+    readonly signal?: AbortSignal;
+}
+/** What `save()` returns: the bytes and the token that names their state. */
+export interface SavedDocument {
+    readonly bytes: Uint8Array;
+    /** Pass it to `markSaved()` once the bytes are persisted. */
+    readonly stateToken: string;
+    readonly sessionId: string;
+    readonly revision: number;
+    /**
+     * What the bytes do not guarantee: `privacy-not-guaranteed` when a PDF full
+     * save could not be compacted and deleted content may remain recoverable.
+     * Empty for a save that holds every guarantee.
+     */
+    readonly warnings: readonly ViewerWarning[];
+}
+export interface AssetOptions {
+    readonly mimeType?: string;
+    readonly signal?: AbortSignal;
+}
+export interface EditReceipt {
+    readonly sessionId: string;
+    /** `state.revision` after the call; unchanged for a dry run or a no-op. */
+    readonly revision: number;
+    readonly dryRun: boolean;
+    readonly operationCount: number;
+    /** Ids of the elements the batch created, in operation order. */
+    readonly createdIds: readonly string[];
+    /** Ids that no longer exist after the call, including every element of a deleted page. */
+    readonly removedIds: readonly string[];
+    /** Old id → new id, when a format has to rename an element; absent for formats that never do. */
+    readonly remappedIds?: Readonly<Record<string, string>>;
+    /** Page indexes in the resulting document whose content may have changed; a superset. */
+    readonly changedPages: readonly number[];
+    readonly pageCount: number;
+    readonly warnings: readonly ViewerWarning[];
+}
+/** One problem found while validating a batch. */
+export interface OperationIssue {
+    readonly operationIndex: number;
+    /** JSON Pointer into the operation, for example "/style/color". */
+    readonly path: string;
+    /** Stable machine code, for example "required", "type", "range", "unknown-operation", "unknown-target". */
+    readonly code: string;
+    readonly message: string;
+}
+export interface EditSessionBase<TOperation extends EditOperation, TElement extends EditElement> {
+    readonly format: EditableFormat;
+    /** Unique per session; stamped on state, receipts, read results and events. */
+    readonly sessionId: string;
+    /** Frozen snapshot, replaced (never mutated) on every state change. */
+    readonly state: EditState;
+    /** JSON Schemas of every operation this session accepts. */
+    readonly schemas: OperationSchemaSet;
+    apply(operations: readonly TOperation[], options?: ApplyOptions): Promise<EditReceipt>;
+    /** `apply()` for callers that hold operations as plain JSON; identical behaviour. */
+    applyJson(operations: readonly EditOperation[], options?: ApplyOptions): Promise<EditReceipt>;
+    undo(options?: HistoryOptions): Promise<EditReceipt>;
+    redo(options?: HistoryOptions): Promise<EditReceipt>;
+    /** Drops every change and returns to the original bytes. Cannot be undone. */
+    reset(options?: HistoryOptions): Promise<EditReceipt>;
+    /** Bytes of the current state. Pure: changes neither the state nor `dirty`. */
+    save(options?: SaveOptions): Promise<SavedDocument>;
+    /** Tells the session the host has persisted the state named by `stateToken`. */
+    markSaved(stateToken: string): void;
+    /** Registers binary data once; returns an `asset:` reference usable in operations. */
+    addAsset(data: Uint8Array, options?: AssetOptions): Promise<string>;
+    getElements(query?: ElementQuery, options?: ReadOptions): Promise<ReadResult<TElement>>;
+    getElement(id: string, options?: ReadOptions): Promise<ReadItem<TElement>>;
+    elementsAt(pageIndex: number, point: PagePoint, options?: ReadOptions): Promise<ReadResult<TElement>>;
+    findText(query: string, options?: EditFindOptions): Promise<ReadResult<TextTarget>>;
+}
+export interface EditStateChange extends EditState {
+    readonly active: boolean;
+    readonly format?: EditableFormat;
+}
+export type DocumentChangeReason = "apply" | "undo" | "redo" | "reset";
+export interface DocumentChange {
+    readonly sessionId: string;
+    readonly revision: number;
+    readonly reason: DocumentChangeReason;
+    /** May over-approximate; for flow formats every page from the first affected one. */
+    readonly changedPages: readonly number[];
+    readonly pageCount: number;
+}
+/** The viewport has laid out and painted the pages of `revision`; geometry helpers are current. */
+export interface LayoutChange {
+    readonly sessionId: string;
+    readonly revision: number;
+    /** Pages painted since the previous `layoutchange`. */
+    readonly pages: readonly number[];
+}

package/dist/edit/types.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,31 @@
+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 { EditElement, EditFindOptions, EditOperation, ElementQuery, OperationIssue, OperationSchemaSet, PagePoint, TextTarget } from "./types.js";
+export declare abstract class WorkerEngineClient implements EditEngine {
+    #private;
+    abstract readonly schemas: OperationSchemaSet;
+    protected readonly rpc: WorkerRpcClient;
+    protected readonly context: EditEngineContext;
+    constructor(rpc: WorkerRpcClient, context: EditEngineContext);
+    validate(operations: readonly EditOperation[], signal: AbortSignal): 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. */
+    materialize(purposeOrSignal?: "show" | "save" | AbortSignal, options?: MaterializeOptions, signal?: AbortSignal): Promise<Uint8Array>;
+    materializeDocument(purposeOrSignal?: "show" | "save" | AbortSignal, options?: MaterializeOptions, signal?: AbortSignal): Promise<MaterializedDocument>;
+    restore(input: RestoreTarget | readonly (readonly EditOperation[])[], signal: AbortSignal): Promise<void>;
+    putAsset(id: string, data: Uint8Array, signal: AbortSignal): Promise<void>;
+    getElements(query: ElementQuery, signal: AbortSignal): Promise<readonly EditElement[]>;
+    getElement(id: string, signal: AbortSignal): Promise<EditElement | undefined>;
+    elementsAt(pageIndex: number, point: PagePoint, signal: AbortSignal): Promise<readonly EditElement[]>;
+    findText(query: string, options: EditFindOptions, signal: AbortSignal): Promise<readonly TextTarget[]>;
+    dispose(): Promise<void>;
+    protected request<T>(operation: EditWorkerOperation, payload: unknown, signal: AbortSignal | undefined, transfer?: Transferable[]): Promise<T>;
+}
+/** How long disposal waits for the worker's answer before terminating it. */
+export declare const DISPOSE_GRACE_MS = 1000;
+/** `value` resolved against `base`, else the packaged fallback. */
+export declare function resolveAssetUrl(value: string | URL | undefined, base: URL | undefined, fallback: URL): URL;
+/** A URL next to this module; data-driven so bundlers leave the package-owned directory alone. */
+export declare function packageRelativeUrl(path: string, from: string): URL;

package/dist/edit/worker-engine.js

@@ -0,0 +1,91 @@
+/*
+ * The main-thread side of an edit engine that lives in a worker: every core
+ * engine call is one request over the worker RPC. Format clients extend it
+ * with how their worker starts and with their own reads.
+ */
+export class WorkerEngineClient {
+    rpc;
+    context;
+    /** Highest state id seen, for batches passed as plain arrays. */
+    #stateId = 0;
+    constructor(rpc, context) {
+        this.rpc = rpc;
+        this.context = context;
+    }
+    validate(operations, signal) {
+        return this.request("edit-validate", { operations }, signal);
+    }
+    /** Plain operation arrays, as the unit tests pass them, become the next batch. */
+    apply(input, signal) {
+        const batch = Array.isArray(input)
+            ? { stateId: ++this.#stateId, operations: input }
+            : input;
+        this.#stateId = Math.max(this.#stateId, batch.stateId);
+        return this.request("edit-apply", { batch }, signal);
+    }
+    /** A bare signal, as the unit tests pass it, asks for the shown form. */
+    async materialize(purposeOrSignal = "show", options = {}, signal = new AbortController().signal) {
+        return (await this.materializeDocument(purposeOrSignal, options, signal))
+            .bytes;
+    }
+    async materializeDocument(purposeOrSignal = "show", options = {}, signal = new AbortController().signal) {
+        const purpose = purposeOrSignal instanceof AbortSignal ? "show" : purposeOrSignal;
+        const own = purposeOrSignal instanceof AbortSignal ? purposeOrSignal : signal;
+        const result = await this.request("edit-materialize", { purpose, options }, own);
+        return { bytes: new Uint8Array(result.data), warnings: result.warnings };
+    }
+    restore(input, signal) {
+        const target = Array.isArray(input)
+            ? {
+                batches: input.map((operations, index) => ({ stateId: index + 1, operations })),
+            }
+            : input;
+        const base = target.base?.slice().buffer;
+        return this.request("edit-restore", { batches: target.batches, ...(base ? { base } : {}) }, signal, base ? [base] : undefined);
+    }
+    putAsset(id, data, signal) {
+        const buffer = data.slice().buffer;
+        return this.request("edit-put-asset", { id, data: buffer }, signal, [
+            buffer,
+        ]);
+    }
+    getElements(query, signal) {
+        return this.request("edit-elements", { query }, signal);
+    }
+    getElement(id, signal) {
+        return this.request("edit-element", { id }, signal);
+    }
+    elementsAt(pageIndex, point, signal) {
+        return this.request("edit-elements-at", { pageIndex, point }, signal);
+    }
+    findText(query, options, signal) {
+        return this.request("edit-find-text", { query, options }, signal);
+    }
+    async dispose() {
+        // A healthy worker answers at once; a dead one never would, and nothing
+        // is lost by terminating it without an answer.
+        const request = this.request("edit-dispose", undefined, undefined).catch(() => undefined);
+        await Promise.race([
+            request,
+            new Promise((resolve) => setTimeout(resolve, DISPOSE_GRACE_MS)),
+        ]);
+        this.rpc.destroy();
+    }
+    request(operation, payload, signal, transfer) {
+        return this.rpc.request(operation, payload, {
+            ...(signal ? { signal } : {}),
+            ...(transfer ? { transfer } : {}),
+            timeoutMs: this.context.limits.maxOperationMs,
+        });
+    }
+}
+/** How long disposal waits for the worker's answer before terminating it. */
+export const DISPOSE_GRACE_MS = 1000;
+/** `value` resolved against `base`, else the packaged fallback. */
+export function resolveAssetUrl(value, base, fallback) {
+    return value === undefined ? fallback : new URL(value, base);
+}
+/** A URL next to this module; data-driven so bundlers leave the package-owned directory alone. */
+export function packageRelativeUrl(path, from) {
+    return new URL(path, from);
+}

package/dist/fonts/THIRD_PARTY_NOTICES.md

@@ -6,5 +6,8 @@ The WOFF2 files in this directory are modified/subset builds of Noto Sans and No
 - Noto Sans CJK sources: `notofonts/noto-cjk` commit `f8d157532fbfaeda587e826d4cd5b21a49186f7c`.
 - License: SIL Open Font License 1.1; see `OFL-1.1.txt`.
 - Modified font family used by the viewer: `Zrimo Noto`.
+- `noto-sans-latin-cyrillic.ttf` is the same Latin/Cyrillic subset saved as an
+  uncompressed TrueType file; the PDF editor embeds it into documents whose
+  text the standard fonts cannot encode.
 
 No proprietary Microsoft font is included.

package/dist/fonts/manifest.json

@@ -2,7 +2,7 @@
   "schemaVersion": 1,
   "family": "Zrimo Noto",
   "generated": "2026-07-16",
-  "tooling": "fonttools pyftsubset with all layout features, then woff2_compress",
+  "tooling": "fonttools pyftsubset with all layout features, then woff2_compress; the .ttf is the Latin/Cyrillic subset saved uncompressed with fonttools for embedding into PDFs",
   "license": "OFL-1.1",
   "sources": {
     "noto-fonts": "https://github.com/notofonts/noto-fonts/tree/ffebf8c1ee449e544955a7e813c54f9b73848eac",
@@ -78,6 +78,11 @@
       "file": "noto-sans-korean.woff2",
       "bytes": 1110144,
       "sha256": "077e4178230f7cc0e7bd9a5ccdb5ad24f89692bb64f5d421b2095a69b4b9243a"
+    },
+    {
+      "file": "noto-sans-latin-cyrillic.ttf",
+      "bytes": 218796,
+      "sha256": "6a23e5413988b4b523ceb4aa81a1de85dad21336868997f52eb6d42159345262"
     }
   ]
 }

package/dist/fonts.d.ts

@@ -13,6 +13,8 @@ export interface FontManagerOptions {
 export declare class FontManager {
     #private;
     constructor(options: FontManagerOptions);
+    /** Fonts the host registered, as given. */
+    get registered(): readonly RegisteredFont[];
     ensureRuns(runs: readonly TextRun[], reportWarning: (warning: ViewerWarning) => void, signal?: AbortSignal): Promise<void>;
     destroy(): Promise<void>;
 }

package/dist/fonts.js

@@ -20,6 +20,10 @@ export class FontManager {
             fonts: globalThis.document?.fonts,
         };
     }
+    /** Fonts the host registered, as given. */
+    get registered() {
+        return this.#registered;
+    }
     async ensureRuns(runs, reportWarning, signal) {
         // PDF.js owns embedded/subset/standard-font loading for both its canvas and
         // text layer. Resolving those generated families through the viewer's Noto

package/dist/headless.d.ts

@@ -1,4 +1,8 @@
 export * from "./contracts.js";
+export * from "./edit/types.js";
+export * from "./edit/sessions.js";
+export * from "./edit/pdf/types.js";
+export * from "./edit/pptx/types.js";
 export * from "./client.js";
 export * from "./viewer.js";
 export * from "./detect.js";

package/dist/headless.js

@@ -1,4 +1,8 @@
 export * from "./contracts.js";
+export * from "./edit/types.js";
+export * from "./edit/sessions.js";
+export * from "./edit/pdf/types.js";
+export * from "./edit/pptx/types.js";
 export * from "./client.js";
 export * from "./viewer.js";
 export * from "./detect.js";

package/dist/index.d.ts

@@ -1,4 +1,9 @@
 export * from "./contracts.js";
+export * from "./edit/types.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";

package/dist/index.js

@@ -1,4 +1,9 @@
 export * from "./contracts.js";
+export * from "./edit/types.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";

package/dist/limits.js

@@ -10,6 +10,9 @@ export const defaultResourceLimits = Object.freeze({
     maxDocumentUnits: 100_000,
     maxConcurrentRenders: 2,
     maxOperationMs: 30_000,
+    maxEditOperations: 500,
+    maxEditHistory: 200,
+    maxEditCheckpointBytes: 64 * 1024 * 1024,
 });
 export function resolveLimits(base = {}, override = {}) {
     const result = { ...defaultResourceLimits, ...base, ...override };

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

@@ -0,0 +1 @@
+export {};

package/dist/ooxml-edit-worker.js

@@ -0,0 +1,8 @@
+import { createOoxmlEditHandler } from "./edit/pptx/handler.js";
+import { attachWorkerEndpoint } from "./worker-endpoint.js";
+/*
+ * Module worker that owns one OOXML package for one edit session: the ZIP
+ * container, the scanned parts and the overlay of changes. It needs no
+ * WebAssembly; inflation uses the platform DecompressionStream.
+ */
+attachWorkerEndpoint(self, createOoxmlEditHandler());

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

@@ -0,0 +1 @@
+export {};

package/dist/pdf-edit-worker.js

@@ -0,0 +1,35 @@
+import { createPdfEditHandler } from "./edit/pdf/engine/handler.js";
+import { Pdfium } from "./edit/pdf/engine/pdfium.js";
+import { attachWorkerEndpoint } from "./worker-endpoint.js";
+/*
+ * Module worker that owns a PDFium instance for one edit session. The WASM is
+ * fetched from the URL the main thread resolved, so hosting the assets
+ * elsewhere (assetBaseUrl) needs no change here.
+ */
+async function fetchBytes(url) {
+    const response = await fetch(url);
+    if (!response.ok)
+        throw new Error(`Fetching ${url} failed with HTTP ${response.status}`);
+    return new Uint8Array(await response.arrayBuffer());
+}
+attachWorkerEndpoint(self, createPdfEditHandler({
+    loadPdfium: async (wasmUrl) => Pdfium.load(await fetchBytes(wasmUrl)),
+    fetchBytes,
+    decodeImage: async (bytes, mimeType) => {
+        const bitmap = await createImageBitmap(new Blob([new Uint8Array(bytes)], { type: mimeType }));
+        try {
+            const canvas = new OffscreenCanvas(bitmap.width, bitmap.height);
+            const context = canvas.getContext("2d");
+            context.drawImage(bitmap, 0, 0);
+            const { data } = context.getImageData(0, 0, bitmap.width, bitmap.height);
+            return {
+                width: bitmap.width,
+                height: bitmap.height,
+                rgba: new Uint8Array(data.buffer),
+            };
+        }
+        finally {
+            bitmap.close();
+        }
+    },
+}));

package/dist/spreadsheet-viewport.d.ts

@@ -22,6 +22,11 @@ export declare class SpreadsheetViewport {
     #private;
     constructor(container: HTMLElement, host: ViewportHost);
     setDocument(info: DocumentInfo | undefined): void;
+    /** Sheets are not editable yet, so new content is treated as a new document. */
+    replaceDocument(info: DocumentInfo, _changedPages?: readonly number[], _revision?: number): void;
+    /** Sheet geometry is cell-addressed; page-space helpers do not apply. */
+    pageToClient(): undefined;
+    clientToPage(): undefined;
     update(): void;
     panBy(deltaX: number, deltaY: number): void;
     /** Sheet matches are cell-addressed; the sheet viewport scrolls per cell already. */

package/dist/spreadsheet-viewport.js

@@ -203,6 +203,17 @@ export class SpreadsheetViewport {
         this.#root.scrollTo({ left: 0, top: 0 });
         this.schedule();
     }
+    /** Sheets are not editable yet, so new content is treated as a new document. */
+    replaceDocument(info, _changedPages, _revision) {
+        this.setDocument(info);
+    }
+    /** Sheet geometry is cell-addressed; page-space helpers do not apply. */
+    pageToClient() {
+        return undefined;
+    }
+    clientToPage() {
+        return undefined;
+    }
     update() {
         if (!this.#info)
             return;

package/dist/ui.js

@@ -120,6 +120,13 @@ export class BasicViewerUi {
             if (!this.#thumbnailPanel.hidden)
                 void this.#renderThumbnails();
             this.#renderSheetTabs();
+        }), viewer.on("documentchange", () => {
+            // Edited content: counters, tabs and thumbnails follow the new document.
+            this.#info = viewer.getDocumentInfo();
+            this.#renderSheetTabs();
+            this.#syncState(viewer.state);
+            if (!this.#thumbnailPanel.hidden)
+                void this.#renderThumbnails();
         }));
         this.root.addEventListener("keydown", this.#onKeyDown);
         document.addEventListener("fullscreenchange", this.#onFullscreenChange);

package/dist/viewer.d.ts

@@ -1,4 +1,6 @@
 import type { CellRange, CellSelection, DocumentInfo, DocumentSource, FitMode, HeadlessRenderOptions, OpenDocumentOptions, ResourceLimits, SearchOptions, SearchResult, SpreadsheetViewportRange, TextSelection, TextSelectionRange, ThumbnailRenderOptions, ViewerApi, ViewerEventListener, ViewerEventMap, ViewerFetch, ViewerLogger, ViewerOptions, ViewerState } from "./contracts.js";
+import type { EditOptions, PageHit, PageRect, ViewportRect } from "./edit/types.js";
+import type { EditSession } from "./edit/sessions.js";
 import type { AdapterRegistry } from "./registry.js";
 import type { FontManager } from "./fonts.js";
 import { RenderScheduler } from "./render-scheduler.js";
@@ -47,6 +49,10 @@ export declare class DocumentViewer implements ViewerApi {
     copySelection(): Promise<string>;
     getOriginalBytes(): Uint8Array | undefined;
     downloadOriginal(fileName?: string): Blob;
+    edit(options?: EditOptions): Promise<EditSession>;
+    getEditSession(): EditSession | undefined;
+    pageToClient(pageIndex: number, rect: PageRect): ViewportRect | undefined;
+    clientToPage(clientX: number, clientY: number): PageHit | undefined;
     on<K extends keyof ViewerEventMap>(type: K, listener: ViewerEventListener<K>): () => void;
     destroy(): Promise<void>;
 }