docxodus 12.1.0 → 12.3.0

package/dist/embed.iife.js

@@ -141,8 +141,15 @@ var Docxodus = (() => {
     DocxDiffFormatComparison: () => DocxDiffFormatComparison,
     DocxDiffRevisionGranularity: () => DocxDiffRevisionGranularity,
     DocxEditor: () => DocxEditor,
+    DocxHistoryArchive: () => DocxHistoryArchive,
+    DocxHistoryClient: () => DocxHistoryClient,
+    DocxHistoryDocument: () => DocxHistoryDocument,
+    DocxHistoryError: () => DocxHistoryError,
+    DocxHistoryReader: () => DocxHistoryReader,
     DocxSession: () => DocxSession,
     EmptyParagraphMode: () => EmptyParagraphMode,
+    HistoryCheckpoints: () => HistoryCheckpoints,
+    MAX_HISTORY_ARCHIVE_BYTES: () => MAX_HISTORY_ARCHIVE_BYTES,
     PaginationEngine: () => PaginationEngine,
     PaginationMode: () => PaginationMode,
     PlaceholderKinds: () => PlaceholderKinds,
@@ -166,6 +173,8 @@ var Docxodus = (() => {
     createBlankDocx: () => createBlankDocx,
     createEditor: () => createEditor,
     createExternalAnnotationSet: () => createExternalAnnotationSet,
+    createHistoryViewer: () => createHistoryViewer,
+    createMemoryHistoryStorage: () => createMemoryHistoryStorage,
     createRibbonEditor: () => createRibbonEditor,
     createUnavailablePageMap: () => createUnavailablePageMap,
     createViewer: () => createViewer,
@@ -199,15 +208,21 @@ var Docxodus = (() => {
     getVersion: () => getVersion,
     getWasmExports: () => getWasmExports,
     hasAnnotations: () => hasAnnotations,
+    historyControlError: () => historyControlError,
     initialize: () => initialize,
+    installHistoryStorageImports: () => installHistoryStorageImports,
     isDeletion: () => isDeletion,
     isFormatChange: () => isFormatChange,
     isInitialized: () => isInitialized,
     isInsertion: () => isInsertion,
     isMove: () => isMove,
+    mountHistoryControls: () => mountHistoryControls,
     mountRibbon: () => mountRibbon,
     navigateToPageCitation: () => navigateToPageCitation,
+    openDocxHistory: () => openDocxHistory,
+    openDocxHistoryArchive: () => openDocxHistoryArchive,
     openDocxSession: () => openDocxSession2,
+    openIndexedDbHistoryStore: () => openIndexedDbHistoryStore,
     paginateHtml: () => paginateHtml,
     parseSectionDimensions: () => parseSectionDimensions,
     projectAnnotationsOntoHtml: () => projectAnnotationsOntoHtml,
@@ -2161,6 +2176,872 @@ var Docxodus = (() => {
     return new DocxSession(handle, bridge);
   }
 
+  // src/history.ts
+  var MAX_HISTORY_ARCHIVE_BYTES = 64 * 1024 * 1024;
+  var DocxHistoryError = class extends Error {
+    constructor(code, message) {
+      super(message);
+      this.code = code;
+      this.name = "DocxHistoryError";
+    }
+  };
+  var adapters = /* @__PURE__ */ new Map();
+  var nextAdapter = 0;
+  function adapter(id) {
+    const store = adapters.get(id);
+    if (!store) throw new DocxHistoryError("Closed", "History storage adapter is closed.");
+    return store;
+  }
+  function toBase64(bytes) {
+    let binary = "";
+    for (let offset = 0; offset < bytes.length; offset += 32768)
+      binary += String.fromCharCode(...bytes.subarray(offset, offset + 32768));
+    return btoa(binary);
+  }
+  function fromBase64(encoded) {
+    const binary = atob(encoded);
+    return Uint8Array.from(binary, (c) => c.charCodeAt(0));
+  }
+  function installHistoryStorageImports(setModuleImports) {
+    setModuleImports("docxodus.history", {
+      readBlob: async (id, json) => {
+        const reference = JSON.parse(json);
+        const bytes = await adapter(id).readBlob(reference);
+        if (bytes === null) return "";
+        if (bytes.length !== reference.length) throw new DocxHistoryError("PayloadMismatch", "Stored blob length differs from its reference.");
+        return bytes.length === 0 ? "=" : toBase64(bytes);
+      },
+      putBlob: async (id, json, bytes) => adapter(id).putBlob(JSON.parse(json), bytes.slice()),
+      readHead: async (id, documentId) => JSON.stringify(await adapter(id).readHead(documentId)),
+      advanceHead: async (id, documentId, expected, state) => JSON.stringify(await adapter(id).advanceHead(documentId, JSON.parse(expected), JSON.parse(state))),
+      initializeHead: async (id, documentId, head) => {
+        const storage = adapter(id);
+        if (!storage.initializeHead) throw new DocxHistoryError("InitializationUnsupported", "Storage cannot import an exact head.");
+        return JSON.stringify(await storage.initializeHead(documentId, JSON.parse(head)));
+      }
+    });
+  }
+  var DocxHistoryClient = class {
+    constructor(bridge, storage) {
+      this.bridge = bridge;
+      this.closed = false;
+      if (nextAdapter >= 2147483647) throw new Error("History adapter identifiers exhausted.");
+      this.adapterId = ++nextAdapter;
+      adapters.set(this.adapterId, storage);
+      try {
+        this.handle = storage.initializeHead && bridge.OpenWithInitialization ? bridge.OpenWithInitialization(this.adapterId) : bridge.Open(this.adapterId);
+      } catch (error) {
+        adapters.delete(this.adapterId);
+        throw error;
+      }
+    }
+    close() {
+      if (this.closed) return;
+      this.bridge.Close(this.handle);
+      adapters.delete(this.adapterId);
+      this.closed = true;
+    }
+    /** Bind an identity without reading, creating a version, or taking ownership of this client. */
+    document(documentId) {
+      return new DocxHistoryDocument(documentId, (operation, fields, bytes) => this.call(operation, documentId, fields, bytes));
+    }
+    async exportHistoryArchive(documentId) {
+      return fromBase64((await this.call("exportArchive", documentId)).bytes);
+    }
+    async importHistoryArchive(bytes) {
+      checkArchiveSize(bytes);
+      return (await this.call("importArchive", "", {}, bytes)).import;
+    }
+    async read(documentId) {
+      return (await this.call("read", documentId)).view;
+    }
+    /** Host-triggered validated metadata tail; first join starts at the latest checkpoint. */
+    async readChangesSince(documentId, after, maxEntriesToScan = 1e4) {
+      return (await this.call("updates", documentId, { expectedHead: after, maxEntriesToScan })).update;
+    }
+    async readOperationsSince(documentId, after, maxEntriesToScan = 1e4) {
+      return (await this.call("operations", documentId, { expectedHead: after, maxEntriesToScan })).operationUpdate;
+    }
+    async getOperation(documentId, operationId) {
+      return (await this.call("getOperation", documentId, { operationId })).operation;
+    }
+    async exportOperationProposal(documentId, operationId) {
+      return fromBase64((await this.call("exportOperationProposal", documentId, { operationId })).bytes);
+    }
+    async compareVersions(documentId, beforeVersionId, afterVersionId) {
+      return fromBase64((await this.call("compare", documentId, { beforeVersionId, afterVersionId })).bytes);
+    }
+    async createVersion(documentId, expectedHead, bytes, metadata, requestId) {
+      return (await this.call("create", documentId, { expectedHead, metadata, requestId }, bytes)).view;
+    }
+    async listVersions(documentId, cursor = null, limit = 25) {
+      return (await this.call("list", documentId, { versionId: cursor, limit })).page;
+    }
+    async getVersion(documentId, versionId) {
+      return (await this.call("get", documentId, { versionId })).version;
+    }
+    async exportVersion(documentId, versionId) {
+      return fromBase64((await this.call("export", documentId, { versionId })).bytes);
+    }
+    async materialize(documentId, sequence, maxEntriesToScan = 1e4) {
+      return fromBase64((await this.call("materialize", documentId, { sequence, maxEntriesToScan })).bytes);
+    }
+    async replay(documentId, sequence, maxEntriesToScan = 1e4) {
+      return fromBase64((await this.call("replay", documentId, { sequence, maxEntriesToScan })).bytes);
+    }
+    async resolveSequenceAtTime(documentId, cutoff, maxEntriesToScan = 1e4) {
+      return (await this.call("resolveTime", documentId, { cutoff, maxEntriesToScan })).sequence;
+    }
+    async restoreVersion(documentId, expectedHead, versionId, metadata, requestId) {
+      return (await this.call("restore", documentId, { expectedHead, versionId, metadata, requestId })).view;
+    }
+    async call(operation, documentId, fields = {}, bytes = new Uint8Array()) {
+      if (this.closed) throw new DocxHistoryError("Closed", "History client is closed.");
+      return parseResult(await this.bridge.Invoke(
+        this.handle,
+        JSON.stringify({ schemaVersion: 1, operation, documentId, ...fields }),
+        bytes
+      ));
+    }
+  };
+  var DocxHistoryReader = class {
+    /** @internal Obtain through client.document() or openDocxHistoryArchive(). */
+    constructor(documentId, call) {
+      this.call = call;
+      this.#documentId = documentId;
+    }
+    #documentId;
+    get documentId() {
+      return this.#documentId;
+    }
+    async read() {
+      return (await this.call("read")).view;
+    }
+    async listVersions(cursor = null, limit = 25) {
+      return (await this.call("list", { versionId: cursor, limit })).page;
+    }
+    async getVersion(versionId) {
+      return (await this.call("get", { versionId })).version;
+    }
+    /** Omit versionId for latest; pass an ID to keep a UI operation pinned to a captured version. */
+    async exportDocx(versionId = null) {
+      return fromBase64((await this.call("exportDocx", { versionId })).bytes);
+    }
+    async exportHistoryArchive() {
+      return fromBase64((await this.call("exportArchive")).bytes);
+    }
+    async materialize(sequence, maxEntriesToScan = 1e4) {
+      return fromBase64((await this.call("materialize", { sequence, maxEntriesToScan })).bytes);
+    }
+    async replay(sequence, maxEntriesToScan = 1e4) {
+      return fromBase64((await this.call("replay", { sequence, maxEntriesToScan })).bytes);
+    }
+    async resolveSequenceAtTime(cutoff, maxEntriesToScan = 1e4) {
+      return (await this.call("resolveTime", { cutoff, maxEntriesToScan })).sequence;
+    }
+    async readChangesSince(after, maxEntriesToScan = 1e4) {
+      return (await this.call("updates", { expectedHead: after, maxEntriesToScan })).update;
+    }
+    async readOperationsSince(after, maxEntriesToScan = 1e4) {
+      return (await this.call("operations", { expectedHead: after, maxEntriesToScan })).operationUpdate;
+    }
+    async getOperation(operationId) {
+      return (await this.call("getOperation", { operationId })).operation;
+    }
+    async exportOperationProposal(operationId) {
+      return fromBase64((await this.call("exportOperationProposal", { operationId })).bytes);
+    }
+    /** Redlined DOCX through DocxCompare's existing accepted-input revision policy. */
+    async compareVersions(beforeVersionId, afterVersionId) {
+      return fromBase64((await this.call("compare", { beforeVersionId, afterVersionId })).bytes);
+    }
+  };
+  var DocxHistoryDocument = class extends DocxHistoryReader {
+    async createVersion(expectedHead, bytes, metadata, requestId) {
+      requireRequestId(requestId);
+      return (await this.call("create", { expectedHead, metadata, requestId }, bytes)).view;
+    }
+    async restoreVersion(expectedHead, versionId, metadata, requestId) {
+      requireRequestId(requestId);
+      return (await this.call("restore", { expectedHead, versionId, metadata, requestId })).view;
+    }
+  };
+  var DocxHistoryArchive = class _DocxHistoryArchive extends DocxHistoryReader {
+    constructor(bridge, handle, info) {
+      super(info.documentId, async (operation, fields = {}, bytes = new Uint8Array()) => {
+        if (this.closed) throw new DocxHistoryError("Closed", "History archive is closed.");
+        return parseResult(await bridge.Invoke(
+          handle,
+          JSON.stringify({ schemaVersion: 1, operation, documentId: this.documentId, ...fields }),
+          bytes
+        ));
+      });
+      this.bridge = bridge;
+      this.handle = handle;
+      this.info = info;
+      this.closed = false;
+    }
+    /** For custom loaders; normal callers use openDocxHistoryArchive(). */
+    static async open(bridge, bytes) {
+      checkArchiveSize(bytes);
+      if (!bridge.OpenArchive) throw new Error("This WASM build does not include portable history.");
+      const result = parseResult(await bridge.OpenArchive(bytes));
+      return new _DocxHistoryArchive(bridge, result.handle, result.archive);
+    }
+    close() {
+      if (this.closed) return;
+      this.bridge.Close(this.handle);
+      this.closed = true;
+    }
+  };
+  function parseResult(json) {
+    const result = JSON.parse(json);
+    if (!result.success) throw new DocxHistoryError(result.errorCode, result.message);
+    return result;
+  }
+  function checkArchiveSize(bytes) {
+    if (bytes.length > MAX_HISTORY_ARCHIVE_BYTES) throw new DocxHistoryError("ResourceLimit", "History archive exceeds 64 MiB.");
+  }
+  function requireRequestId(requestId) {
+    if (typeof requestId !== "string" || !requestId.trim()) throw new DocxHistoryError("InvalidRequest", "A durable requestId is required.");
+  }
+  function createMemoryHistoryStorage(maxBlobBytes = 256 * 1024 * 1024) {
+    if (!Number.isSafeInteger(maxBlobBytes) || maxBlobBytes <= 0) throw new RangeError("Invalid blob byte limit.");
+    const blobs = /* @__PURE__ */ new Map();
+    const heads = /* @__PURE__ */ new Map();
+    const copy = (value) => JSON.parse(JSON.stringify(value));
+    const key = (reference) => {
+      if (reference.digest.algorithm !== "SHA-256" || !/^[a-f0-9]{64}$/.test(reference.digest.value) || !Number.isSafeInteger(reference.length) || reference.length < 0 || reference.length > maxBlobBytes)
+        throw new DocxHistoryError("InvalidRequest", "Invalid blob reference or byte limit.");
+      return `${reference.digest.value}:${reference.length}`;
+    };
+    const equalReference = (a, b) => a.length === b.length && a.digest.algorithm === b.digest.algorithm && a.digest.value === b.digest.value;
+    const equalHead2 = (a, b) => a === null || b === null ? a === b : a.revision === b.revision && equalReference(a.state, b.state);
+    return {
+      async readBlob(reference) {
+        return blobs.get(key(reference))?.slice() ?? null;
+      },
+      async putBlob(reference, bytes) {
+        const blobKey = key(reference);
+        const captured = bytes.slice();
+        if (captured.length !== reference.length) throw new DocxHistoryError("PayloadMismatch", "Blob length mismatch.");
+        const digest = Array.from(
+          new Uint8Array(await crypto.subtle.digest("SHA-256", captured)),
+          (n) => n.toString(16).padStart(2, "0")
+        ).join("");
+        if (digest !== blobKey.split(":")[0]) throw new DocxHistoryError("PayloadMismatch", "Blob digest mismatch.");
+        if (!blobs.has(blobKey)) blobs.set(blobKey, captured);
+      },
+      async readHead(documentId) {
+        return copy(heads.get(documentId) ?? null);
+      },
+      async advanceHead(documentId, expected, state) {
+        key(state);
+        const current = heads.get(documentId) ?? null;
+        if (!equalHead2(current, expected)) return null;
+        const revision = BigInt(current?.revision ?? "0") + 1n;
+        if (revision > 9223372036854775807n) throw new RangeError("History revision exhausted.");
+        const head = { revision: String(revision), state: copy(state) };
+        heads.set(documentId, head);
+        return copy(head);
+      },
+      async initializeHead(documentId, head) {
+        key(head.state);
+        if (typeof head.revision !== "string" || !/^[1-9][0-9]*$/.test(head.revision) || BigInt(head.revision) > 9223372036854775807n)
+          throw new DocxHistoryError("InvalidRequest", "Imported head revision must be a positive Int64 string.");
+        const existing = heads.get(documentId);
+        if (existing) return { initialized: false, head: copy(existing) };
+        const captured = copy(head);
+        heads.set(documentId, captured);
+        return { initialized: true, head: copy(captured) };
+      }
+    };
+  }
+
+  // src/history-checkpoints.ts
+  var HistoryCheckpoints = class _HistoryCheckpoints {
+    constructor(document2, journal) {
+      this.document = document2;
+      this.journal = journal;
+      this.current = null;
+      this.request = null;
+      this.running = false;
+      this.stale = false;
+    }
+    /** Pass an already captured view when opening its exact version in an editor (for example, after import). */
+    static async open(document2, journal, view) {
+      const controls = new _HistoryCheckpoints(document2, journal);
+      controls.request = structuredClone(await journal.read());
+      if (controls.request && controls.request.documentId !== document2.documentId)
+        throw new DocxHistoryError("InvalidRequest", "The pending checkpoint belongs to another document.");
+      controls.current = view === void 0 ? await document2.read() : structuredClone(view);
+      if (controls.current && controls.current.state.documentId !== document2.documentId)
+        throw new DocxHistoryError("InvalidRequest", "The captured view belongs to another document.");
+      return controls;
+    }
+    get view() {
+      return structuredClone(this.current);
+    }
+    get hasPending() {
+      return this.request !== null;
+    }
+    get needsRefresh() {
+      return this.stale;
+    }
+    async refresh() {
+      return this.exclusive(async () => {
+        this.current = await this.document.read();
+        this.stale = false;
+        return this.view;
+      });
+    }
+    async save(bytes, metadata) {
+      return this.start({
+        kind: "save",
+        head: this.current?.head ?? null,
+        bytes,
+        id: crypto.randomUUID(),
+        documentId: this.document.documentId,
+        metadata
+      });
+    }
+    async restore(target, metadata) {
+      if (!this.current) throw new DocxHistoryError("NotFound", "Save a checkpoint before restoring a version.");
+      return this.start({
+        kind: "restore",
+        head: this.current.head,
+        target,
+        id: crypto.randomUUID(),
+        documentId: this.document.documentId,
+        metadata
+      });
+    }
+    async retry() {
+      return this.exclusive(async () => {
+        if (!this.request) throw new DocxHistoryError("InvalidRequest", "There is no pending checkpoint.");
+        return this.publish();
+      });
+    }
+    async start(request) {
+      return this.exclusive(async () => {
+        if (this.request) throw new DocxHistoryError("PendingRequest", "Retry the pending checkpoint first.");
+        if (this.stale) throw new DocxHistoryError("StaleHead", "Refresh history before saving again.");
+        this.request = structuredClone(request);
+        return this.publish();
+      });
+    }
+    async publish() {
+      const intended = this.request;
+      const request = await this.journal.put(structuredClone(intended));
+      this.request = structuredClone(request);
+      if (request.id !== intended.id)
+        throw new DocxHistoryError("PendingRequest", "Another tab has a pending checkpoint. Retry it before saving your draft.");
+      let view;
+      try {
+        view = request.kind === "save" ? await this.document.createVersion(request.head, request.bytes, request.metadata, request.id) : await this.document.restoreVersion(request.head, request.target, request.metadata, request.id);
+      } catch (error) {
+        if (error instanceof DocxHistoryError && error.code === "StaleHead") {
+          this.stale = true;
+          await this.journal.remove(request.id);
+          this.request = null;
+        }
+        throw error;
+      }
+      this.current = view;
+      await this.journal.remove(request.id);
+      this.request = null;
+      return this.view;
+    }
+    async exclusive(action) {
+      if (this.running) throw new DocxHistoryError("Busy", "A history command is still running.");
+      this.running = true;
+      try {
+        return await action();
+      } finally {
+        this.running = false;
+      }
+    }
+  };
+
+  // src/history-indexeddb.ts
+  async function openIndexedDbHistoryStore(name) {
+    const db = await new Promise((resolve, reject) => {
+      let blocked = false;
+      const request = indexedDB.open(name, 1);
+      request.onupgradeneeded = () => {
+        for (const store of ["blobs", "heads", "requests"]) request.result.createObjectStore(store);
+      };
+      request.onsuccess = () => {
+        if (blocked) request.result.close();
+        else resolve(request.result);
+      };
+      request.onerror = () => reject(request.error);
+      request.onblocked = () => {
+        blocked = true;
+        reject(new Error("Close other tabs using this history store, then try again."));
+      };
+    });
+    db.onversionchange = () => db.close();
+    function transaction(name2, mode, action) {
+      return new Promise((resolve, reject) => {
+        const tx = db.transaction(name2, mode);
+        let value;
+        tx.oncomplete = () => resolve(value);
+        tx.onabort = () => reject(tx.error ?? new Error("History storage transaction was aborted."));
+        try {
+          action(tx.objectStore(name2), (result) => {
+            value = result;
+          });
+        } catch (error) {
+          tx.abort();
+          reject(error);
+        }
+      });
+    }
+    const storage = {
+      readBlob(reference) {
+        const key = referenceKey(reference);
+        return transaction("blobs", "readonly", (store, result) => {
+          store.get(key).onsuccess = (event) => result(event.target.result ?? null);
+        });
+      },
+      async putBlob(reference, bytes) {
+        const key = referenceKey(reference);
+        const captured = bytes.slice();
+        if (captured.length !== reference.length) throw new DocxHistoryError("PayloadMismatch", "Stored document length does not match its reference.");
+        const hash = Array.from(
+          new Uint8Array(await crypto.subtle.digest("SHA-256", captured)),
+          (byte) => byte.toString(16).padStart(2, "0")
+        ).join("");
+        if (hash !== key.split(":")[0])
+          throw new DocxHistoryError("PayloadMismatch", "Stored document bytes do not match their reference.");
+        await transaction("blobs", "readwrite", (store, result) => {
+          store.put(captured, key);
+          result();
+        });
+      },
+      readHead(documentId) {
+        return transaction("heads", "readonly", (store, result) => {
+          store.get(documentId).onsuccess = (event) => result(event.target.result ?? null);
+        });
+      },
+      advanceHead(documentId, expected, state) {
+        referenceKey(state);
+        const captured = structuredClone({ expected, state });
+        if (expected) validateHead(expected);
+        const revision = BigInt(expected?.revision ?? "0") + 1n;
+        if (revision > 9223372036854775807n) throw new RangeError("History revision exhausted.");
+        return transaction("heads", "readwrite", (store, result) => {
+          store.get(documentId).onsuccess = (event) => {
+            const current = event.target.result ?? null;
+            if (!equalHead(current, captured.expected)) {
+              result(null);
+              return;
+            }
+            const head = { revision: String(revision), state: captured.state };
+            store.put(head, documentId);
+            result(head);
+          };
+        });
+      },
+      initializeHead(documentId, head) {
+        validateHead(head);
+        const captured = structuredClone(head);
+        return transaction("heads", "readwrite", (store, result) => {
+          store.get(documentId).onsuccess = (event) => {
+            const existing = event.target.result;
+            if (existing) {
+              result({ initialized: false, head: existing });
+              return;
+            }
+            store.put(captured, documentId);
+            result({ initialized: true, head: captured });
+          };
+        });
+      }
+    };
+    return {
+      storage,
+      journal(documentId) {
+        return {
+          read: () => transaction("requests", "readonly", (store, result) => {
+            store.get(documentId).onsuccess = (event) => result(event.target.result ?? null);
+          }),
+          put(request) {
+            if (request.documentId !== documentId) throw new Error("Checkpoint document identity does not match.");
+            const captured = structuredClone(request);
+            return transaction("requests", "readwrite", (store, result) => {
+              store.get(documentId).onsuccess = (event) => {
+                const existing = event.target.result;
+                if (existing) {
+                  result(existing);
+                  return;
+                }
+                store.put(captured, documentId);
+                result(captured);
+              };
+            });
+          },
+          remove(requestId) {
+            return transaction("requests", "readwrite", (store, result) => {
+              store.get(documentId).onsuccess = (event) => {
+                if (event.target.result?.id === requestId) store.delete(documentId);
+                result();
+              };
+            });
+          }
+        };
+      },
+      close: () => db.close()
+    };
+  }
+  function referenceKey(reference) {
+    if (reference.digest.algorithm !== "SHA-256" || !/^[a-f0-9]{64}$/.test(reference.digest.value) || !Number.isSafeInteger(reference.length) || reference.length < 0)
+      throw new DocxHistoryError("InvalidRequest", "Invalid history blob reference.");
+    return `${reference.digest.value}:${reference.length}`;
+  }
+  function validateHead(head) {
+    referenceKey(head.state);
+    if (typeof head.revision !== "string" || !/^[1-9][0-9]*$/.test(head.revision) || BigInt(head.revision) > 9223372036854775807n)
+      throw new DocxHistoryError("InvalidRequest", "Invalid history revision.");
+  }
+  function equalHead(a, b) {
+    return a === null || b === null ? a === b : a.revision === b.revision && a.state.length === b.state.length && a.state.digest.algorithm === b.state.digest.algorithm && a.state.digest.value === b.state.digest.value;
+  }
+
+  // src/history-controls.ts
+  function mountHistoryControls(container, options) {
+    const pageSize = options.pageSize ?? 25;
+    if (!Number.isInteger(pageSize) || pageSize < 1 || pageSize > 100) throw new RangeError("History page size must be 1\u2013100.");
+    if (options.checkpoints && options.checkpoints.document !== options.reader)
+      throw new Error("History controls and checkpoints must use the same document.");
+    return new HistoryPanel(container, options, pageSize);
+  }
+  var HistoryPanel = class {
+    constructor(container, options, pageSize) {
+      this.options = options;
+      this.pageSize = pageSize;
+      this.actions = /* @__PURE__ */ new Map();
+      this.events = new AbortController();
+      this.records = [];
+      this.next = null;
+      this.view = null;
+      this.active = null;
+      this.destroyed = false;
+      const doc = container.ownerDocument;
+      this.element = doc.createElement("section");
+      this.element.className = "dx-history";
+      this.element.setAttribute("aria-label", "Document history");
+      const style = doc.createElement("style");
+      style.textContent = HISTORY_CSS;
+      const title = doc.createElement("h2");
+      title.textContent = "Document history";
+      this.status = doc.createElement("p");
+      this.status.setAttribute("role", "status");
+      this.status.setAttribute("aria-live", "polite");
+      this.fieldset = doc.createElement("fieldset");
+      const legend = doc.createElement("legend");
+      legend.textContent = "Versions and checkpoints";
+      this.fieldset.append(legend);
+      this.element.append(style, title, this.status, this.fieldset);
+      container.append(this.element);
+      const note = doc.createElement("p");
+      note.textContent = options.checkpoints ? "Browse saved versions without changing your draft." : "Read-only history. Preview or download any saved version.";
+      this.fieldset.append(note);
+      this.button("refresh", "Refresh history", () => this.load(true));
+      this.button("latest", "Open latest", async () => this.preview(await options.reader.exportDocx(), "Latest saved version"));
+      this.versions = this.select("Version");
+      this.versions.size = 6;
+      this.detail = doc.createElement("p");
+      this.fieldset.append(this.detail);
+      this.versions.addEventListener("change", () => this.update(), { signal: this.events.signal });
+      this.button("preview", "Preview selected", async () => this.preview(await options.reader.exportDocx(this.selected().id), versionTitle(this.selected())));
+      this.button("download", "Download selected", async () => this.download(await options.reader.exportDocx(this.selected().id), `version-${this.selected().record.sequence}.docx`));
+      this.before = this.select("Compare from");
+      this.before.addEventListener("change", () => this.update(), { signal: this.events.signal });
+      const compareNote = doc.createElement("p");
+      compareNote.textContent = "Compare from this version to the selected version above.";
+      this.fieldset.append(compareNote);
+      this.button("compare", "Compare versions", async () => {
+        const before = this.records[Number(this.before.value)];
+        await this.preview(await options.reader.compareVersions(before.id, this.selected().id), "Comparison with tracked changes");
+      });
+      this.button("more", "Load older versions", async () => {
+        if (this.next) await this.page(this.next, false);
+      });
+      this.author = this.input("Your name", "text", options.author ?? "You");
+      this.label = this.input("Checkpoint name (optional)", "text");
+      this.author.parentElement.hidden = this.label.parentElement.hidden = !options.checkpoints;
+      this.button("save", "Save checkpoint", async () => {
+        const view = await options.checkpoints.save(await options.capture(), this.metadata());
+        await options.onCheckpoint?.(view, "save");
+        await this.load(false);
+        this.label.value = "";
+        this.status.textContent = "Checkpoint saved. Your draft remains open.";
+      });
+      this.button("restore", "Restore selected", async () => {
+        const version = this.selected();
+        if (!doc.defaultView?.confirm(`Restore ${versionTitle(version)} as a new checkpoint?
+
+Your current draft and all later versions will be kept.`)) {
+          this.status.textContent = "Restore canceled. Your draft and history are unchanged.";
+          return;
+        }
+        const view = await options.checkpoints.restore(version.id, this.metadata());
+        await options.onCheckpoint?.(view, "restore");
+        await this.load(false);
+        this.status.textContent = "Restored as a new checkpoint. Your draft and later versions are kept.";
+      });
+      const restoreNote = doc.createElement("p");
+      restoreNote.hidden = !options.checkpoints;
+      restoreNote.textContent = "Restore creates a new checkpoint. Open latest to preview it; your draft stays open.";
+      this.fieldset.append(restoreNote);
+      this.button("retry", "Retry checkpoint", async () => {
+        const view = await options.checkpoints.retry();
+        await options.onCheckpoint?.(view, "retry");
+        await this.load(false);
+        this.status.textContent = "Checkpoint recovered. Your draft remains open. Refresh history to check for newer versions.";
+      });
+      const sharing = this.disclosure("Download with history");
+      const sharingNote = doc.createElement("p");
+      sharingNote.textContent = "Includes retained drafts and collaboration proposals. Share this file only when you want to include that history. A DOCX download keeps existing Word comments and revisions, without external history.";
+      sharing.append(sharingNote);
+      this.button("archive", "Download .docxhistory", async () => this.download(await options.reader.exportHistoryArchive(), "docxhistory"), sharing);
+      const time = this.disclosure("Find a version by time");
+      const cutoff = this.input("Saved at or before (local time)", "datetime-local", "", time);
+      this.button("time", "Preview at time", async () => {
+        if (!cutoff.value) throw new DocxHistoryError("InvalidRequest", "Choose a date and time first.");
+        const sequence = await options.reader.resolveSequenceAtTime(new Date(cutoff.value).toISOString());
+        await this.preview(await options.reader.materialize(sequence), "Version at selected time");
+      }, time);
+      const activity = this.disclosure("Recorded collaboration");
+      const decisions = doc.createElement("ol");
+      let showOlderActivity = () => {
+      };
+      this.button("activity", "Load activity", async () => {
+        const { operations } = await options.reader.readOperationsSince(null);
+        const resolved = new Set(operations.filter((op) => op.record.status === "accepted").map((op) => op.input.request.resolves?.digest.value));
+        let shown = 0;
+        showOlderActivity = () => {
+          const page = operations.slice(Math.max(0, operations.length - shown - this.pageSize), operations.length - shown).reverse();
+          decisions.append(...page.map((op) => this.activityItem(op, resolved.has(op.id.digest.value))));
+          shown += page.length;
+          this.actions.get("activity-more").hidden = shown >= operations.length;
+        };
+        decisions.replaceChildren();
+        showOlderActivity();
+        this.status.textContent = operations.length ? "Recorded activity loaded." : "No recorded collaboration.";
+      }, activity);
+      activity.append(decisions);
+      this.button("activity-more", "Load older activity", async () => showOlderActivity(), activity);
+      this.actions.get("activity-more").hidden = true;
+      this.ready = this.run("Loading history", () => this.load(false));
+    }
+    refresh() {
+      return this.run("Loading history", () => this.load(true));
+    }
+    async destroy() {
+      this.destroyed = true;
+      this.events.abort();
+      this.element.remove();
+      await this.active?.catch(() => {
+      });
+    }
+    async load(refresh) {
+      this.view = this.options.checkpoints ? refresh ? await this.options.checkpoints.refresh() : this.options.checkpoints.view : await this.options.reader.read();
+      if (this.view) await this.page(this.view.version.id, true);
+      else {
+        this.records = [];
+        this.next = null;
+        this.versions.replaceChildren();
+        this.before.replaceChildren();
+      }
+      this.status.textContent = this.options.checkpoints?.hasPending ? "A checkpoint needs recovery. Retry it before saving more changes." : this.view ? "History loaded. Select a version to preview, download or restore." : "No checkpoints yet. Save your first checkpoint when you are ready.";
+    }
+    async page(cursor, reset) {
+      const page = await this.options.reader.listVersions(cursor, this.pageSize);
+      if (reset) {
+        this.records = [];
+        this.versions.replaceChildren();
+        this.before.replaceChildren();
+      }
+      const start2 = this.records.length;
+      this.records.push(...page.versions);
+      this.next = page.next;
+      for (let index = start2; index < this.records.length; index++) {
+        for (const select of [this.versions, this.before]) {
+          const option = select.ownerDocument.createElement("option");
+          option.value = String(index);
+          option.textContent = option.title = versionTitle(this.records[index]);
+          select.append(option);
+        }
+      }
+      if (reset) {
+        this.versions.value = "0";
+        this.before.value = this.records.length > 1 ? "1" : "0";
+      }
+    }
+    update() {
+      const hasVersion = this.records.length > 0;
+      const pending = this.options.checkpoints?.hasPending ?? false;
+      const stale = this.options.checkpoints?.needsRefresh ?? false;
+      for (const key of ["latest", "preview", "download", "archive", "time", "activity"]) this.actions.get(key).disabled = !hasVersion;
+      this.actions.get("more").hidden = !this.next;
+      this.actions.get("compare").disabled = !hasVersion || this.before.value === this.versions.value;
+      this.actions.get("save").hidden = !this.options.checkpoints || !this.options.capture;
+      this.actions.get("save").disabled = pending || stale;
+      this.actions.get("restore").hidden = !this.options.checkpoints;
+      this.actions.get("restore").disabled = !hasVersion || pending || stale;
+      this.actions.get("retry").hidden = !pending;
+      this.detail.textContent = hasVersion ? [
+        versionTitle(this.selected()),
+        this.selected().record.metadata.message,
+        this.selected().record.restoredFrom ? "Restored from an earlier version." : ""
+      ].filter(Boolean).join(" \u2014 ") : "";
+    }
+    selected() {
+      return this.records[Number(this.versions.value)];
+    }
+    activityItem(op, resolved) {
+      const doc = this.element.ownerDocument;
+      const item = doc.createElement("li");
+      const state = op.record.status === "accepted" ? "Accepted" : resolved ? "Conflict resolved" : "Conflict needs review";
+      const label = doc.createElement("p");
+      label.textContent = `${op.input.request.metadata.author} \xB7 ${state} \xB7 ${formatTime(op.input.request.metadata.createdAt)}`;
+      item.append(label);
+      const description = doc.createElement("p");
+      this.commandButton("View decision", async () => {
+        const decision = await this.options.reader.getOperation(op.id);
+        const { kind, metadata } = decision.input.request;
+        description.textContent = [
+          { text: "Text edit", package: "Document edit", discard: "Discarded proposal" }[kind],
+          metadata.label,
+          metadata.message,
+          decision.record.conflict
+        ].filter(Boolean).join(" \u2014 ");
+      }, item);
+      item.append(description);
+      this.commandButton("Download proposal", async () => {
+        await this.download(await this.options.reader.exportOperationProposal(op.id), `proposal-${op.record.revision}.docx`);
+      }, item);
+      return item;
+    }
+    metadata() {
+      return { author: this.author.value.trim() || "You", createdAt: (/* @__PURE__ */ new Date()).toISOString(), label: this.label.value.trim() || void 0 };
+    }
+    async preview(bytes, title) {
+      if (!this.destroyed) await this.options.preview(bytes, title);
+    }
+    async download(bytes, suffix) {
+      if (this.destroyed) return;
+      const stem = (this.options.documentName ?? "document").replace(/\.(docx|docxhistory)$/i, "");
+      const name = suffix === "docxhistory" ? `${stem}.docxhistory` : `${stem}-${suffix}`;
+      if (this.options.download) {
+        await this.options.download(bytes, name);
+        return;
+      }
+      const url = URL.createObjectURL(new Blob([bytes.slice()], { type: suffix === "docxhistory" ? "application/octet-stream" : "application/vnd.openxmlformats-officedocument.wordprocessingml.document" }));
+      const link = this.element.ownerDocument.createElement("a");
+      link.href = url;
+      link.download = name;
+      link.click();
+      setTimeout(() => URL.revokeObjectURL(url), 1e3);
+    }
+    async run(label, action) {
+      if (this.destroyed) throw new DocxHistoryError("Closed", "History controls are closed.");
+      if (this.active) throw new DocxHistoryError("Busy", "A history command is still running.");
+      this.fieldset.disabled = true;
+      this.element.setAttribute("aria-busy", "true");
+      this.status.textContent = `${label}\u2026`;
+      const work = Promise.resolve().then(action);
+      this.active = work;
+      try {
+        await work;
+        if (this.status.textContent === `${label}\u2026`) this.status.textContent = "Ready.";
+      } catch (error) {
+        if (!this.destroyed) this.status.textContent = historyControlError(error, this.options.checkpoints?.hasPending);
+        throw error;
+      } finally {
+        this.active = null;
+        if (!this.destroyed) {
+          this.fieldset.disabled = false;
+          this.element.setAttribute("aria-busy", "false");
+          this.update();
+        }
+      }
+    }
+    button(key, title, action, parent = this.fieldset) {
+      this.actions.set(key, this.commandButton(title, action, parent));
+    }
+    commandButton(title, action, parent) {
+      const button = parent.ownerDocument.createElement("button");
+      button.type = "button";
+      button.textContent = title;
+      button.addEventListener("click", () => {
+        void this.run(title, action).catch(() => {
+        });
+      }, { signal: this.events.signal });
+      parent.append(button);
+      return button;
+    }
+    select(title) {
+      const label = this.fieldset.ownerDocument.createElement("label");
+      label.textContent = title;
+      const select = label.ownerDocument.createElement("select");
+      select.setAttribute("aria-label", title);
+      label.append(select);
+      this.fieldset.append(label);
+      return select;
+    }
+    input(title, type, value = "", parent = this.fieldset) {
+      const label = parent.ownerDocument.createElement("label");
+      label.textContent = title;
+      const input = label.ownerDocument.createElement("input");
+      input.type = type;
+      input.value = value;
+      label.append(input);
+      parent.append(label);
+      return input;
+    }
+    disclosure(title) {
+      const details = this.fieldset.ownerDocument.createElement("details");
+      const summary = details.ownerDocument.createElement("summary");
+      summary.textContent = title;
+      details.append(summary);
+      this.fieldset.append(details);
+      return details;
+    }
+  };
+  function historyControlError(error, pending = false) {
+    const code = error instanceof DocxHistoryError ? error.code : "";
+    if (code === "StaleHead") return "A newer checkpoint exists. Your draft is safe. Refresh history, review the newer version, then save again.";
+    if (code === "ImportConflict") return "A different local history already exists. Open this file read-only to explore it.";
+    if (code === "InitializationUnsupported") return "This storage cannot import history. Open read-only or choose storage that supports importing.";
+    if (pending) return "The checkpoint could not be confirmed. Your draft is safe. Retry checkpoint to recover the original request.";
+    if (code === "ResourceLimit") return "This history file exceeds browser processing limits, which can apply even below 64 MiB. Your document is unchanged.";
+    if (code === "UnsupportedVersion") return "This history file uses an unsupported version. Open it with a newer app. Your document is unchanged.";
+    if (code === "InvalidManifest") return "This history file is damaged or incomplete. Choose another copy. Your document is unchanged.";
+    return `History could not be loaded. Your document is unchanged. ${error instanceof Error ? error.message : "Please try again."}`;
+  }
+  function versionTitle(version) {
+    const { metadata, sequence } = version.record;
+    return `${metadata.label || `Version ${BigInt(sequence) + 1n}`} \xB7 ${metadata.author} \xB7 ${formatTime(metadata.createdAt)}`;
+  }
+  function formatTime(value) {
+    const time = new Date(value);
+    return Number.isNaN(time.getTime()) ? value : time.toLocaleString();
+  }
+  var HISTORY_CSS = `
+.dx-history{font:14px/1.5 system-ui,sans-serif;color:#203047;background:#fff;border:1px solid #cbd5e1;border-radius:12px;padding:18px;min-width:0}
+.dx-history *{box-sizing:border-box}.dx-history h2{font-size:20px;margin:0 0 8px}.dx-history p{margin:8px 0;overflow-wrap:anywhere}
+.dx-history fieldset{border:0;padding:0;margin:0;min-width:0}.dx-history legend{position:absolute;width:1px;height:1px;overflow:hidden;clip-path:inset(50%)}
+.dx-history label{display:block;font-weight:600;margin:12px 0 6px}.dx-history input,.dx-history select{display:block;width:100%;max-width:100%;margin-top:4px;font:inherit;color:inherit;border:1px solid #94a3b8;border-radius:6px;padding:8px;background:#fff}
+.dx-history button{min-height:40px;margin:4px 6px 4px 0;padding:7px 12px;border:1px solid #94a3b8;border-radius:6px;background:#f8fafc;color:inherit;font:inherit;cursor:pointer}
+.dx-history button:disabled{opacity:.5;cursor:wait}.dx-history :focus-visible{outline:3px solid #2563eb;outline-offset:2px}.dx-history [hidden]{display:none}
+.dx-history details{margin-top:16px;border-top:1px solid #e2e8f0;padding-top:12px}.dx-history summary{cursor:pointer;font-weight:600;padding:4px 0}
+.dx-history [role=status]{min-height:42px}.dx-history ol{padding-left:22px}.dx-history option{padding:6px}
+`;
+
   // src/page-number-format.ts
   var ROMAN_ONES = ["", "i", "ii", "iii", "iv", "v", "vi", "vii", "viii", "ix"];
   var ROMAN_TENS = ["", "x", "xx", "xxx", "xl", "l", "lx", "lxx", "lxxx", "xc"];
@@ -5610,11 +6491,11 @@ var Docxodus = (() => {
           if (!this.partUriFor(which, "default")) this.seedStory(which, "default");
           if (!this.partUriFor(which, kind)) this.seedStory(which, kind);
         }
-        const res = parseResult(this.bridge.EnsureHeaderFooterVisible(this.handle, this.bodyAnchorId, kind));
+        const res = parseResult2(this.bridge.EnsureHeaderFooterVisible(this.handle, this.bodyAnchorId, kind));
         if (!res.success) return false;
       } else {
         if (!this.bridge.SetHeaderFooterKindEnabled) return false;
-        const res = parseResult(this.bridge.SetHeaderFooterKindEnabled(this.handle, this.bodyAnchorId, kind, false));
+        const res = parseResult2(this.bridge.SetHeaderFooterKindEnabled(this.handle, this.bodyAnchorId, kind, false));
         if (!res.success) return false;
         for (const which of ["header", "footer"]) {
           if (this.kinds[which] === kind) this.kinds[which] = "default";
@@ -5639,7 +6520,7 @@ var Docxodus = (() => {
      *  Deliberately a PLAIN field (no `\*` switch), exactly as Word inserts one, so it follows the
      *  section's page-number format — see {@link setPageNumbering}. */
     insertPageNumber(which, anchorId, field) {
-      const res = parseResult(this.bridge.InsertPageNumberField(this.handle, anchorId, field, ""));
+      const res = parseResult2(this.bridge.InsertPageNumberField(this.handle, anchorId, field, ""));
       if (!res.success) return false;
       this.refresh(which);
       return true;
@@ -5662,7 +6543,7 @@ var Docxodus = (() => {
     /** Set this section's page numbering (`w:pgNumType`) — Word's *Format Page Numbers…*. */
     setPageNumbering(op) {
       if (!this.bodyAnchorId) return false;
-      const res = parseResult(this.bridge.SetPageNumbering(this.handle, this.bodyAnchorId, JSON.stringify(op)));
+      const res = parseResult2(this.bridge.SetPageNumbering(this.handle, this.bodyAnchorId, JSON.stringify(op)));
       if (!res.success) return false;
       this.reloadSection();
       return true;
@@ -5674,7 +6555,7 @@ var Docxodus = (() => {
     /** Remove this section's page-numbering start/format. */
     clearPageNumbering() {
       if (!this.bodyAnchorId) return false;
-      const res = parseResult(this.bridge.ClearPageNumbering(this.handle, this.bodyAnchorId));
+      const res = parseResult2(this.bridge.ClearPageNumbering(this.handle, this.bodyAnchorId));
       if (!res.success) return false;
       this.reloadSection();
       return true;
@@ -5985,7 +6866,7 @@ var Docxodus = (() => {
     seedStory(which, kind) {
       if (!this.bodyAnchorId) return;
       const set = which === "header" ? this.bridge.SetHeaderText : this.bridge.SetFooterText;
-      const res = parseResult(set(this.handle, this.bodyAnchorId, kind, ""));
+      const res = parseResult2(set(this.handle, this.bodyAnchorId, kind, ""));
       if (!res.success) return;
       this.callbacks.refreshAnchorMap();
       this.sectionInfo = this.readSectionInfo(this.bodyAnchorId);
@@ -6141,7 +7022,7 @@ var Docxodus = (() => {
     const range = d.caretRangeFromPoint?.(x, y);
     return range ? { node: range.startContainer, offset: range.startOffset } : null;
   }
-  function parseResult(json) {
+  function parseResult2(json) {
     try {
       return JSON.parse(json);
     } catch {
@@ -8374,7 +9255,7 @@ span.comment-highlight.docx-comment-active { background: hsl(var(--docx-comment-
     };
   }
   var honeyPotFix = makeHoneyPotFix();
-  var adapter = makeAdapter({
+  var adapter2 = makeAdapter({
     typeKey: "element",
     defaultDropEffect: "move",
     mount: function mount(api2) {
@@ -8463,8 +9344,8 @@ span.comment-highlight.docx-comment-active { background: hsl(var(--docx-comment-
     },
     onPostDispatch: honeyPotFix.getOnPostDispatch()
   });
-  var dropTargetForElements = adapter.dropTarget;
-  var monitorForElements = adapter.monitor;
+  var dropTargetForElements = adapter2.dropTarget;
+  var monitorForElements = adapter2.monitor;
   function draggable(args) {
     if (true) {
       if (args.dragHandle && !args.element.contains(args.dragHandle)) {
@@ -8488,7 +9369,7 @@ span.comment-highlight.docx-comment-active { background: hsl(var(--docx-comment-
       // this is because you *must* have a draggable element to start a drag
       // but you _might_ not have any drop targets immediately
       // (You might create drop targets async)
-      adapter.registerUsage(),
+      adapter2.registerUsage(),
       addToRegistry(args),
       addAttribute(args.element, {
         attribute: "draggable",
@@ -9935,22 +10816,55 @@ span.comment-highlight.docx-comment-active { background: hsl(var(--docx-comment-
     const span = trimmedSpan(block, { start: Math.min(start2, end), length: Math.abs(end - start2) });
     return span.length > 0 ? span : null;
   }
-  function selectRange(el, start2, length) {
-    const sel = typeof window !== "undefined" ? window.getSelection() : null;
-    if (!sel || !el.isConnected) return;
-    el.focus();
-    const range = document.createRange();
+  function contentRangeIn(el, start2, length) {
+    if (!el.isConnected) return null;
+    const doc = el.ownerDocument;
+    const range = doc.createRange();
     const from = contentPositionIn(el, start2);
     const to = contentPositionIn(el, start2 + length);
     try {
       range.setStart(from.node, from.offset);
       range.setEnd(to.node, to.offset);
     } catch {
-      return;
+      return null;
     }
+    return range;
+  }
+  function selectRange(el, start2, length) {
+    const sel = typeof window !== "undefined" ? window.getSelection() : null;
+    if (!sel || !el.isConnected) return;
+    el.focus();
+    const range = contentRangeIn(el, start2, length);
+    if (!range) return;
     sel.removeAllRanges();
     sel.addRange(range);
   }
+  var FIND_HIGHLIGHT = "docxodus-find";
+  var FIND_HIGHLIGHT_ACTIVE = "docxodus-find-active";
+  var FIND_PAINT_LIMIT = 500;
+  var findHighlightStyledDocuments = /* @__PURE__ */ new WeakSet();
+  var findPaintOwner = null;
+  function ensureFindHighlightStyles(doc) {
+    if (findHighlightStyledDocuments.has(doc)) return;
+    findHighlightStyledDocuments.add(doc);
+    const style = doc.createElement("style");
+    style.dataset.docxodusFindHighlight = "true";
+    style.textContent = `
+::highlight(${FIND_HIGHLIGHT}) { background-color: rgba(15, 118, 110, .16); }
+::highlight(${FIND_HIGHLIGHT_ACTIVE}) { background-color: rgba(15, 118, 110, .38); }
+`;
+    (doc.head ?? doc.documentElement).appendChild(style);
+  }
+  function highlightRegistry() {
+    if (typeof CSS === "undefined") return null;
+    const registry = CSS.highlights;
+    const ctor = globalThis.Highlight;
+    return registry && typeof ctor === "function" ? registry : null;
+  }
+  function makeHighlight(ranges) {
+    const ctor = globalThis.Highlight;
+    return new ctor(...ranges);
+  }
   function inBorderWrapper(el) {
     const style = el.parentElement?.getAttribute("style") ?? "";
     return /border-(top|bottom|left|right):\s*(?!none)[^;]+/i.test(style);
@@ -10321,6 +11235,7 @@ span.comment-highlight.docx-comment-active { background: hsl(var(--docx-comment-
         document.removeEventListener("mouseup", this.onMouseUp, true);
       }
       this.clearDragSelection();
+      this.clearFindMatches();
       this.teardownBlockDrag();
       this.gutter?.dispose();
       this.gutter = null;
@@ -12719,15 +13634,65 @@ span.comment-highlight.docx-comment-active { background: hsl(var(--docx-comment-
       }
       return out;
     }
-    /** Select a match and scroll it into view. */
+    /**
+     * Select a match, focus its block and scroll it into view — the caret lands on the hit, so
+     * typing continues in the document. A find box that is still being typed into wants
+     * `showFindMatches` instead; this is the commit step (closing the bar, jumping in to edit).
+     */
     selectMatch(match) {
       if (!match.block.isConnected) return;
+      this.clearFindMatches();
       this.activeBlock = match.block;
       selectRange(match.block, match.start, match.length);
       match.block.scrollIntoView({ block: "center", behavior: "smooth" });
     }
-    /** Replace one match's text (formatting of the surrounding run is inherited). */
-    replaceMatch(match, replacement) {
+    /**
+     * Paint `matches` and scroll the one at `activeIndex` into view WITHOUT moving focus or the
+     * caret. This is what a find field calls on every keystroke: the document shows where the hits
+     * are and rides to the current one, while the keyboard stays in the search box.
+     *
+     * Falls back to the document selection where the CSS Custom Highlight API is missing — still
+     * without focusing the block, so the next character typed goes to the search field either way.
+     */
+    showFindMatches(matches, activeIndex) {
+      const active = matches[activeIndex];
+      this.clearFindMatches();
+      if (!active || !active.block.isConnected) return;
+      this.activeBlock = active.block;
+      const activeRange = contentRangeIn(active.block, active.start, active.length);
+      const registry = highlightRegistry();
+      if (registry && activeRange) {
+        ensureFindHighlightStyles(this.container.ownerDocument);
+        const rest = [];
+        for (let i = 0; i < matches.length && rest.length < FIND_PAINT_LIMIT; i++) {
+          if (i === activeIndex) continue;
+          const range = contentRangeIn(matches[i].block, matches[i].start, matches[i].length);
+          if (range) rest.push(range);
+        }
+        if (rest.length > 0) registry.set(FIND_HIGHLIGHT, makeHighlight(rest));
+        registry.set(FIND_HIGHLIGHT_ACTIVE, makeHighlight([activeRange]));
+        findPaintOwner = this;
+      } else if (activeRange) {
+        const sel = this.container.ownerDocument.defaultView?.getSelection();
+        sel?.removeAllRanges();
+        sel?.addRange(activeRange);
+      }
+      active.block.scrollIntoView({ block: "center", behavior: "smooth" });
+    }
+    /** Drop the find painting (closing the find bar, or committing a match to the caret). */
+    clearFindMatches() {
+      if (findPaintOwner !== this) return;
+      const registry = highlightRegistry();
+      registry?.delete(FIND_HIGHLIGHT);
+      registry?.delete(FIND_HIGHLIGHT_ACTIVE);
+      findPaintOwner = null;
+    }
+    /**
+     * Replace one match's text (formatting of the surrounding run is inherited). `focus: false`
+     * leaves the keyboard where it is — a Replace button pressed from the find bar must not drag
+     * the caret into the document mid-search.
+     */
+    replaceMatch(match, replacement, options = {}) {
       const block = match.block;
       if (this.closed || !block.isConnected) return false;
       const unid = block.getAttribute("data-anchor");
@@ -12748,7 +13713,7 @@ span.comment-highlight.docx-comment-active { background: hsl(var(--docx-comment-
       );
       if (!res.success) return false;
       const fresh = this.swapBlock(block, unid, res.modified?.[0]);
-      if (fresh) selectRange(fresh, span.start, replacement.length);
+      if (fresh && options.focus !== false) selectRange(fresh, span.start, replacement.length);
       return true;
     }
     /** Replace every occurrence; returns how many were replaced. */
@@ -12767,7 +13732,11 @@ span.comment-highlight.docx-comment-active { background: hsl(var(--docx-comment-
         for (const m of list.slice().sort((a, b) => b.start - a.start)) {
           if (!current.isConnected) break;
           const before = current;
-          if (this.replaceMatch({ block: current, start: m.start, length: m.length }, replacement)) {
+          if (this.replaceMatch(
+            { block: current, start: m.start, length: m.length },
+            replacement,
+            { focus: options.focus }
+          )) {
             count++;
             current = this.activeBlock && this.activeBlock !== before ? this.activeBlock : current;
           }
@@ -13449,7 +14418,7 @@ span.comment-highlight.docx-comment-active { background: hsl(var(--docx-comment-
   }
 
   // src/ribbon-chrome.ts
-  var RIBBON_STYLE_VERSION = "10";
+  var RIBBON_STYLE_VERSION = "11";
   var RIBBON_STYLE_ATTR = "data-docxodus-ribbon-styles";
   var COMMENT_GUTTER_WIDTH = 264;
   var RIBBON_CSS = `
@@ -13882,9 +14851,11 @@ span.comment-highlight.docx-comment-active { background: hsl(var(--docx-comment-
   background: linear-gradient(to top, var(--dxr-desk), transparent);
 }
 .dxr[data-chrome] .dxr-surface { position: relative; margin: 26px auto; padding: 0 16px 96px; }
-/* The comment gutter sits to the right of the sheet; the surface reserves its width so the
-   page shifts left rather than the bubbles covering it \u2014 Word's markup area. */
-.dxr[data-chrome="full"] .dxr-surface[data-comments="on"] { padding-right: calc(var(--dxr-gutter) + 8px); }
+/* Reserve the markup area only while a visible comment or draft needs it. The gutter owns
+   its empty/hidden state, so ordinary documents stay centered without disabling comments. */
+.dxr[data-chrome="full"] .dxr-surface[data-comments="on"]:has(> .docx-comment-gutter:not([data-empty]):not([hidden])) {
+  padding-right: calc(var(--dxr-gutter) + 8px);
+}
 .dxr-surface [contenteditable="true"]:focus {
   outline: 2px solid var(--dxr-accent);
   outline-offset: 2px;
@@ -15400,7 +16371,8 @@ span.comment-highlight.docx-comment-active { background: hsl(var(--docx-comment-
         comments: this.options.comments,
         commentAuthor: this.author
       });
-      this.require("save").disabled = false;
+      const saveButton = this.control("save");
+      if (saveButton) saveButton.disabled = false;
       this.require("ribbon").setAttribute("aria-disabled", "false");
       this.setState("ready");
       this.setStatus(`Rendered in ${Math.round(performance.now() - started)} ms`);
@@ -16035,11 +17007,18 @@ span.comment-highlight.docx-comment-active { background: hsl(var(--docx-comment-
         if (!this.live || !text.value) return;
         let count = 0;
         this.run("replace all", () => {
-          count = this.live.replaceAll(text.value, replace.value, { matchCase: matchCase.checked });
+          count = this.live.replaceAll(text.value, replace.value, {
+            matchCase: matchCase.checked,
+            focus: false
+          });
         });
         this.setStatus(`Replaced ${count} occurrence${count === 1 ? "" : "s"}`);
         this.refreshFind(true);
       });
+      for (const id of ["findprev", "findnext", "replaceone", "replaceall"]) {
+        const button = this.control(id);
+        if (button) this.keepSelection(button);
+      }
       bar.hidden = true;
     }
     openFindBar(withReplace) {
@@ -16050,28 +17029,44 @@ span.comment-highlight.docx-comment-active { background: hsl(var(--docx-comment-
       const text = this.require("findtext");
       text.focus();
       text.select();
-      this.refreshFind(false);
+      this.refreshFind(true);
     }
+    /**
+     * Close the bar and hand the current hit over to the caret: the document is where the user is
+     * going next, and Word leaves the insertion point on the match it stopped at. Until this runs
+     * the match is only PAINTED (see `showFindMatches`), so the search field keeps the keyboard for
+     * as long as the bar is open.
+     */
     closeFindBar() {
       const bar = this.control("findbar");
       if (bar) bar.hidden = true;
+      const match = this.findMatches[this.findIndex];
+      if (match) this.live?.selectMatch(match);
+      else this.live?.clearFindMatches();
       this.findMatches = [];
       this.findIndex = -1;
     }
-    refreshFind(select) {
+    /**
+     * Re-scan for the current query. `show` paints the hits and rides to the first one — it never
+     * focuses the document, so typing the second character of a query that already matched goes on
+     * refining the search instead of being typed into the document.
+     */
+    refreshFind(show) {
       const text = this.require("findtext");
       const matchCase = this.require("findcase").checked;
       this.findMatches = this.live && text.value ? this.live.find(text.value, { matchCase }) : [];
       this.findIndex = this.findMatches.length > 0 ? 0 : -1;
       this.updateFindCount();
-      if (select && this.findIndex >= 0) this.live?.selectMatch(this.findMatches[this.findIndex]);
+      if (!show) return;
+      if (this.findIndex >= 0) this.live?.showFindMatches(this.findMatches, this.findIndex);
+      else this.live?.clearFindMatches();
     }
     stepFind(direction) {
       if (!this.live) return;
       if (this.findMatches.length === 0) this.refreshFind(false);
       if (this.findMatches.length === 0) return;
       this.findIndex = (this.findIndex + direction + this.findMatches.length) % this.findMatches.length;
-      this.live.selectMatch(this.findMatches[this.findIndex]);
+      this.live.showFindMatches(this.findMatches, this.findIndex);
       this.updateFindCount();
     }
     replaceCurrent() {
@@ -16080,12 +17075,12 @@ span.comment-highlight.docx-comment-active { background: hsl(var(--docx-comment-
       const match = this.findMatches[this.findIndex];
       if (!match) return;
       const replacement = this.require("replacetext").value;
-      this.run("replace", () => this.live.replaceMatch(match, replacement));
+      this.run("replace", () => this.live.replaceMatch(match, replacement, { focus: false }));
       const keep = this.findIndex;
       this.refreshFind(false);
       if (this.findMatches.length > 0) {
         this.findIndex = Math.min(keep, this.findMatches.length - 1);
-        this.live.selectMatch(this.findMatches[this.findIndex]);
+        this.live.showFindMatches(this.findMatches, this.findIndex);
         this.updateFindCount();
       }
     }
@@ -16517,6 +17512,16 @@ span.comment-highlight.docx-comment-active { background: hsl(var(--docx-comment-
 
   // src/index.ts
   var import_meta = {};
+  function openDocxHistory(storage) {
+    const bridge = ensureInitialized().HistoryBridge;
+    if (!bridge) throw new Error("This WASM build does not include history bindings.");
+    return new DocxHistoryClient(bridge, storage);
+  }
+  function openDocxHistoryArchive(bytes) {
+    const bridge = ensureInitialized().HistoryBridge;
+    if (!bridge) throw new Error("This WASM build does not include history bindings.");
+    return DocxHistoryArchive.open(bridge, bytes);
+  }
   function openDocxSession2(bytes, settings) {
     const wasm = ensureInitialized();
     return openDocxSession(bytes, wasm, settings);
@@ -16571,14 +17576,16 @@ span.comment-highlight.docx-comment-active { background: hsl(var(--docx-comment-
         /* @vite-ignore */
         dotnetPath
       );
-      const { getAssemblyExports, getConfig } = await dotnet.withDiagnosticTracing(false).create();
+      const { getAssemblyExports, getConfig, setModuleImports } = await dotnet.withDiagnosticTracing(false).create();
+      installHistoryStorageImports(setModuleImports);
       const config = getConfig();
       const exports = await getAssemblyExports(config.mainAssemblyName);
       wasmExports = {
         DocumentConverter: exports.DocxodusWasm.DocumentConverter,
         DocumentComparer: exports.DocxodusWasm.DocumentComparer,
         DocxDiffBridge: exports.DocxodusWasm.DocxDiffBridge,
-        DocxSessionBridge: exports.DocxodusWasm.DocxSessionBridge
+        DocxSessionBridge: exports.DocxodusWasm.DocxSessionBridge,
+        HistoryBridge: exports.DocxodusWasm.HistoryBridge
       };
       return true;
     } catch {
@@ -17953,6 +18960,20 @@ ${parsed.documentElement.outerHTML}`;
     }
     throw new Error("Docxodus embed: unsupported document source");
   }
+  function scopedDocumentFragment(mount2, html) {
+    const parsed = new DOMParser().parseFromString(html, "text/html");
+    const fragment = document.createDocumentFragment();
+    parsed.querySelectorAll("style").forEach((sourceStyle) => {
+      const style = document.createElement("style");
+      style.textContent = sourceStyle.textContent;
+      scopeStyleElement(style, mount2.selector);
+      fragment.appendChild(style);
+    });
+    const body = document.createElement("template");
+    body.innerHTML = parsed.body.innerHTML;
+    fragment.appendChild(body.content);
+    return fragment;
+  }
   async function createViewer(container, source, options = {}) {
     const el = resolveContainer2(container);
     const { wasmBasePath: wasmBasePath2, ...conversion } = options;
@@ -17965,18 +18986,7 @@ ${parsed.documentElement.outerHTML}`;
         renderFootnotesAndEndnotes: true,
         ...opts
       });
-      const parsed = new DOMParser().parseFromString(lastHtml, "text/html");
-      const fragment = document.createDocumentFragment();
-      parsed.querySelectorAll("style").forEach((sourceStyle) => {
-        const style = document.createElement("style");
-        style.textContent = sourceStyle.textContent;
-        scopeStyleElement(style, mount2.selector);
-        fragment.appendChild(style);
-      });
-      const body = document.createElement("template");
-      body.innerHTML = parsed.body.innerHTML;
-      fragment.appendChild(body.content);
-      mount2.root.replaceChildren(fragment);
+      mount2.root.replaceChildren(scopedDocumentFragment(mount2, lastHtml));
     };
     await render(source, conversion);
     return {
@@ -17990,6 +19000,111 @@ ${parsed.documentElement.outerHTML}`;
       }
     };
   }
+  async function createHistoryViewer(container, history, documentId, options = {}) {
+    const el = resolveContainer2(container);
+    const { wasmBasePath: wasmBasePath2, maxEntriesToScan = 1e4, ...conversion } = options;
+    if (!Number.isSafeInteger(maxEntriesToScan) || maxEntriesToScan <= 0 || maxEntriesToScan > 2147483647)
+      throw new RangeError("Invalid history scan budget.");
+    await ensureWasm(wasmBasePath2);
+    const mount2 = createScopedMount(el);
+    let accepted = null;
+    let acceptedBytes = null;
+    let displayedBytes = null;
+    let shownSequence = "0";
+    let following = true;
+    let closed = false;
+    let html = "";
+    let queue = Promise.resolve();
+    const clone = (value) => JSON.parse(JSON.stringify(value));
+    const assertOpen = () => {
+      if (closed) throw new DocxHistoryError("Closed", "History viewer is destroyed.");
+    };
+    const enqueue = (action) => {
+      const result = queue.then(() => {
+        assertOpen();
+        return action();
+      });
+      queue = result.then(() => void 0, () => void 0);
+      return result;
+    };
+    const sameHead = (a, b) => a.revision === b.revision && a.state.length === b.state.length && a.state.digest.algorithm === b.state.digest.algorithm && a.state.digest.value === b.state.digest.value;
+    const paint = async (bytes, sequence) => {
+      const nextHtml = await convertDocxToHtml(bytes, { renderFootnotesAndEndnotes: true, ...conversion });
+      assertOpen();
+      const fragment = scopedDocumentFragment(mount2, nextHtml);
+      mount2.root.replaceChildren(fragment);
+      html = nextHtml;
+      displayedBytes = bytes;
+      shownSequence = sequence;
+    };
+    const refresh = async (resume = false) => {
+      const update = await history.readChangesSince(documentId, accepted?.view.head ?? null, maxEntriesToScan);
+      assertOpen();
+      const duplicate = accepted !== null && sameHead(accepted.view.head, update.view.head);
+      const bytes = duplicate ? acceptedBytes : await history.exportVersion(documentId, update.view.version.id);
+      assertOpen();
+      const wantLive = following || resume;
+      const changedContent = accepted === null || accepted.view.state.snapshot.contentDigest.value !== update.view.state.snapshot.contentDigest.value || accepted.view.state.epoch !== update.view.state.epoch;
+      if (wantLive && (changedContent || !following)) await paint(bytes, update.view.state.sequence);
+      else if (wantLive) {
+        displayedBytes = bytes;
+        shownSequence = update.view.state.sequence;
+      }
+      assertOpen();
+      accepted = update;
+      acceptedBytes = bytes;
+      if (wantLive) following = true;
+      return clone(update);
+    };
+    const showSequence = async (sequence) => {
+      const bytes = await history.materialize(documentId, sequence, maxEntriesToScan);
+      assertOpen();
+      await paint(bytes, sequence);
+      following = false;
+    };
+    const viewer = {
+      element: el,
+      get html() {
+        return html;
+      },
+      get head() {
+        assertOpen();
+        return clone(accepted.view.head);
+      },
+      get sequence() {
+        return shownSequence;
+      },
+      get following() {
+        return following;
+      },
+      refresh: () => enqueue(() => refresh()),
+      showSequence: (sequence) => enqueue(() => showSequence(sequence)),
+      showTime: (cutoff) => enqueue(async () => {
+        const sequence = await history.resolveSequenceAtTime(documentId, cutoff, maxEntriesToScan);
+        assertOpen();
+        await showSequence(sequence);
+      }),
+      resume: () => enqueue(() => refresh(true)),
+      exportDisplayed: () => {
+        assertOpen();
+        return displayedBytes.slice();
+      },
+      destroy: () => {
+        if (closed) return;
+        closed = true;
+        acceptedBytes = null;
+        displayedBytes = null;
+        mount2.root.remove();
+      }
+    };
+    try {
+      await viewer.refresh();
+      return viewer;
+    } catch (error) {
+      viewer.destroy();
+      throw error;
+    }
+  }
   async function createEditor(container, source, options = {}) {
     const el = resolveContainer2(container);
     const { wasmBasePath: wasmBasePath2, ...editorOptions } = options;