@betteroffice/docx 0.4.0 → 0.4.2

package/dist/{index-CHy6_Yuo.d.mts → index-DzZVJC8-.d.mts}

@@ -1,8 +1,10 @@
 import { C as ColorValue } from './formatting-gqLFeJ9X.mjs';
 import { Document, CompatibilityFlags } from './types/document.mjs';
-import { a0 as DocxEditSuggestion, a1 as DocxEditFailure, a2 as DocxEditFailureCode, a3 as DocxReadParagraphsRequest, a4 as DocxReadParagraphsResult, a5 as DocxFindTextRequest, a6 as DocxFindTextResult, a7 as DocxEditRequest, a8 as DocxValidationResult, a9 as DocxEditResult, aa as DocxTextTarget, ab as DocxEditRefusal, a as DocxExportOptions, H as DocxExportResult, c as DocxStructuredContent, b as DocxMarkdownContent, d as DocxPageExportOptions, f as DocxPagedStructuredContent, i as DocxLayoutMap, g as DocxSnapshotLayoutMap, D as DocxExportFailure, V as DocxParagraphHeading, m as DocxContentControlsOptions, w as DocxContentControlsResult, l as DocxContentControlQuery } from './pagedExport---0Dlmzo.mjs';
-import { R as RetainedFrame } from './frameDelta-ByU7HBuB.mjs';
+import { a0 as DocxEditSuggestion, a1 as DocxEditFailure, a2 as DocxEditFailureCode, a3 as DocxTextRange, a4 as DocxReadParagraphsRequest, a5 as DocxReadParagraphsResult, a6 as DocxFindTextRequest, a7 as DocxFindTextResult, a8 as DocxEditRequest, a9 as DocxValidationResult, aa as DocxEditResult, ab as DocxTextTarget, ac as DocxEditRefusal, a as DocxExportOptions, H as DocxExportResult, c as DocxStructuredContent, b as DocxMarkdownContent, d as DocxPageExportOptions, f as DocxPagedStructuredContent, i as DocxLayoutMap, g as DocxSnapshotLayoutMap, D as DocxExportFailure, V as DocxParagraphHeading, m as DocxContentControlsOptions, w as DocxContentControlsResult, l as DocxContentControlQuery } from './pagedExport-BmSlEhoP.mjs';
+import { R as RetainedFrame } from './frameDelta-CLeO7K5z.mjs';
 import { a as WasmModuleMemory } from './loadWasmAsset-Cr95TImt.mjs';
+import { PointPosition } from './plugin-api/index.mjs';
+import { B as BlockContent, e as Comment } from './content-DSb-6a9T.mjs';
 import { R as RepackOptions } from './rezip-Bxiq4Z_R.mjs';
 
 type CollaborationUpdateOrigin = 'local' | 'remote';
@@ -108,6 +110,19 @@ interface RustParagraphIds {
         part: string;
         paraIds: Array<[number, string]>;
     }>;
+    /**
+     * Story parts written as their source bytes with only some paragraphs
+     * re-serialized: those whose `sourceOrdinal` is in `changed`, or whose
+     * written comments, revisions, notes or relationships differ from their
+     * source. `paragraphs` lists every `sourceOrdinal` the model holds for the
+     * part, `sha256` the source part it addresses.
+     */
+    splicedParts?: Array<{
+        part: string;
+        sha256: string;
+        paragraphs: number[];
+        changed: number[];
+    }>;
 }
 
 /**
@@ -239,8 +254,18 @@ type DocxParagraphAnchorResult = {
     status: 'unsupported';
     reason: 'foreign-session' | 'foreign-package' | 'no-source-package';
 };
-/** The paragraph IDs a session save applies, as the package writer's `paragraphIds`. @internal */
-type DocxParagraphSavePlan = RustParagraphIds;
+/**
+ * The paragraph IDs a session save applies, as the package writer's
+ * `paragraphIds`, with each spliced part's paragraphs as `[ordinal, session key]`. @internal
+ */
+interface DocxParagraphSavePlan extends Omit<RustParagraphIds, 'splicedParts'> {
+    splicedParts?: Array<{
+        part: string;
+        sha256: string;
+        paragraphs: Array<[number, string]>;
+        changed: number[];
+    }>;
+}
 
 /**
  * Host proposals: tracked changes a host proposes by paragraph anchor and search, grouped by the
@@ -292,6 +317,18 @@ interface DocxProposalSnapshot {
     previewVersion: number;
     proposals: readonly DocxProposalRecord[];
 }
+/** @internal */
+interface DocxProposalRegistryState {
+    previewVersion: number;
+    entries: {
+        record: DocxProposalRecord;
+        key: string;
+        suggest: {
+            author: string;
+            date: string;
+        };
+    }[];
+}
 type DocxProposalFailure = Omit<DocxEditFailure, 'code'> & {
     code: DocxEditFailureCode | 'stale-preview' | 'unknown-proposal' | 'proposal-id-conflict';
     proposalId?: string;
@@ -367,9 +404,270 @@ declare function residentCaretDeviceRect(rect: Pick<YrsResidentCaretRect, 'x' |
 };
 declare function residentCaretSnapshotForFrame(snapshot: YrsResidentCaretSnapshot, frame: RetainedFrame): YrsResidentCaretSnapshot | null;
 
+type PositionReader = Pick<YrsSession, 'hasStory' | 'storySegments'>;
+type YrsLocProjection = Pick<YrsPositionProjection, 'positionForLoc'>;
+type YrsPositionOutline = Record<string, {
+    contentStart: number;
+    size: number;
+    paragraphs: Array<{
+        paraId: string;
+        displayStart: number;
+        length: number;
+        leading: number;
+    }>;
+}>;
+declare function createYrsLocProjectionFromOutline(outline: YrsPositionOutline): YrsLocProjection;
+/** @internal */
+interface YrsProjectedNode {
+    kind: string;
+    start: number;
+    nodeSize: number;
+    attrs: Record<string, unknown>;
+    story: string;
+}
+/** @internal */
+interface YrsProjectedTable extends YrsProjectedNode {
+    kind: 'table';
+    tableIndex: number;
+    widthsTwips: number[];
+    rowCount: number;
+    cells: YrsProjectedCell[];
+}
+/** @internal */
+interface YrsProjectedCell {
+    row: number;
+    column: number;
+    rowspan: number;
+    colspan: number;
+    story: string;
+    start: number;
+    contentStart: number;
+    nodeSize: number;
+    attrs: Record<string, unknown>;
+}
+/** @internal */
+interface YrsPointerProjectionTarget {
+    story: string;
+    displayPosition: number;
+    cell?: YrsCellLoc;
+}
+/** @internal */
+interface YrsStorySegmentSource {
+    segments(story: string): YrsStorySegment[];
+}
+/** @internal */
+declare function createYrsPositionProjection(session: PositionReader, rootStory: string, source?: YrsStorySegmentSource): YrsPositionProjection | null;
+/** @internal */
+declare function projectYrsDisplayPosition(position: number | PointPosition, getProjection: (rootStory: string) => YrsPositionProjection | null): YrsPointerProjectionTarget | null;
+/** @internal */
+declare class YrsPositionProjection {
+    readonly rootStory: string;
+    private readonly stories;
+    private readonly nodes;
+    private readonly tables;
+    private readonly source;
+    private readonly paragraphsById;
+    constructor(session: Pick<YrsSession, 'storySegments'>, rootStory: string, source?: YrsStorySegmentSource);
+    get size(): number;
+    nodeAt(position: number): YrsProjectedNode | null;
+    tableAtPosition(position: number): YrsProjectedTable | null;
+    tableAtStart(start: number): YrsProjectedTable | null;
+    tableStartForLoc(at: YrsCellLoc): number | null;
+    cellPosition(tableStart: number, row: number, column: number): number | null;
+    targetAt(position: number): YrsPointerProjectionTarget;
+    positionForLoc(loc: YrsLoc): number | null;
+    /** First paragraph for each paraId. */
+    private paragraphIndex;
+    bookmarkPosition(name: string): number | null;
+    private buildStory;
+    private inputPositionAt;
+    private buildTable;
+}
+/** @internal */
+declare function yrsLocToProjectedDisplayPosition(reader: Pick<YrsSession, 'hasStory' | 'paragraphSpans'>, projectionFor: (rootStory: string) => YrsLocProjection | null, loc: YrsLoc, activeRootStory?: string, inputMap?: (story: string) => YrsInputPositionMap | null): number | null;
+
+/** @internal */
+interface ResidentSearchMatch {
+    story: string;
+    paraId: string;
+    start: number;
+    displayFrom: number;
+    displayTo: number;
+}
+/** @internal */
+interface ResidentSearchResult {
+    matches: ResidentSearchMatch[];
+    carried: number;
+}
+
+/** @internal */
+interface AnchorResolutionFailure {
+    ok: false;
+    failure: {
+        code: 'stale-version' | 'missing-target' | 'ambiguous-target' | 'layout-unavailable' | 'unsupported' | 'unknown-proposal';
+        message: string;
+    };
+}
+/** @internal */
+type AnchorReader = Pick<YrsSession, 'resolveParagraphAnchor' | 'hasStory' | 'paragraphSpans' | 'storySegments' | 'findText' | 'listRevisions'>;
+/** @internal */
+type ProposalGeometryReader = AnchorReader & Pick<YrsSession, 'storyIds' | 'paragraphs' | 'paragraphIdCount' | 'locateParagraph' | 'version'> & {
+    proposalRevisions?(ids: readonly string[]): readonly ProposalGeometryRevision[];
+    positionOutline?(root: string): YrsPositionOutline | null;
+};
+/** @internal */
+type ProposalGeometryRevision = Pick<ReturnType<AnchorReader['listRevisions']>[number], 'revisionId' | 'kind' | 'story' | 'range'>;
+/** @internal */
+type AnchorGeometryTarget = {
+    kind: 'proposal';
+    id: string;
+} | {
+    kind: 'revision';
+    revisionId: string;
+} | {
+    kind: 'paragraph';
+    paragraph: DocxParagraphAnchor;
+} | {
+    kind: 'search';
+    paragraph: DocxParagraphAnchor;
+    text: string;
+    occurrence?: DocxOccurrence;
+} | {
+    kind: 'range';
+    version: string;
+    range: DocxTextRange;
+};
+/** @internal */
+interface RawAnchorRange {
+    start: YrsLoc;
+    end: YrsLoc;
+}
+type AnchorResolution = {
+    ok: true;
+    ranges: RawAnchorRange[];
+    paragraph: YrsLoc;
+} | AnchorResolutionFailure;
+/** @internal */
+declare function anchorFailure(code: AnchorResolutionFailure['failure']['code'], message: string): AnchorResolutionFailure;
+/** @internal */
+declare function isBodyStory(story: string): boolean;
+/** @internal */
+declare function textRangeToRaw(segments: readonly YrsStorySegment[], range: DocxTextRange): {
+    ok: true;
+    range: RawAnchorRange;
+} | AnchorResolutionFailure;
+/** @internal */
+declare function hiddenRanges(session: AnchorReader, version: string, snapshot: DocxProposalSnapshot | null, revisions?: readonly ProposalGeometryRevision[]): RawAnchorRange[];
+/** @internal */
+declare function resolveAnchorTarget(session: AnchorReader, target: AnchorGeometryTarget, version: string, snapshot?: DocxProposalSnapshot | null, proposalRevisions?: readonly ProposalGeometryRevision[]): AnchorResolution;
+/** @internal */
+interface ProposalDisplayTarget {
+    ranges: {
+        from: number;
+        to: number;
+    }[];
+    paragraph: number | null;
+}
+/** @internal */
+type ProposalGeometryTarget = ({
+    ok: true;
+} & ProposalDisplayTarget) | AnchorResolutionFailure;
+/** @internal */
+interface ProposalGeometryMirror {
+    version: string;
+    previewVersion: number;
+    proposals: string;
+    targets: Record<string, ProposalGeometryTarget>;
+    navigationTargets?: Record<string, ReturnType<typeof resolveNavigationTarget>>;
+    hidden: {
+        from: number;
+        to: number;
+    }[];
+}
+/** @internal */
+declare function proposalSetIdentity(snapshot: DocxProposalSnapshot): string;
+/** @internal */
+declare function computeProposalGeometryMirror(reader: ProposalGeometryReader, snapshot: DocxProposalSnapshot, includeNavigationTargets?: boolean): ProposalGeometryMirror;
+/** @internal */
+declare function resolveMirroredNavigationTarget(mirror: ProposalGeometryMirror | null, snapshot: DocxProposalSnapshot, story: string, paraId: string): ReturnType<typeof resolveNavigationTarget> | null;
+/** @internal */
+declare function resolveNavigationTarget(reader: ProposalGeometryReader, story: string, paraId: string): {
+    loc: YrsLoc;
+    position: number;
+} | 'missing-target' | 'ambiguous-target' | 'unsupported';
+
+/** @internal */
+type ResidentProposalOperation = {
+    kind: 'propose';
+    request: DocxProposalRequest;
+} | {
+    kind: 'setStates';
+    request: DocxProposalStateRequest;
+} | {
+    kind: 'withdraw';
+    request: DocxProposalWithdrawRequest;
+} | {
+    kind: 'snapshot';
+};
+/** @internal */
+interface ResidentProposalResponse {
+    result?: DocxProposalResult;
+    mirror: {
+        version: string;
+        proposals: DocxProposalRegistryState;
+    };
+    changedStories: string[];
+    updates: ArrayBuffer[];
+    stateVector: ArrayBuffer;
+    geometry: ProposalGeometryMirror;
+    fontRequirements?: {
+        layoutInput: string;
+        requirementsJson: string;
+    };
+}
+/** @internal */
+type ResidentDocumentRead = {
+    kind: 'paragraphIdentities';
+} | {
+    kind: 'resolveParagraphAnchors';
+    anchors: DocxParagraphAnchor[];
+} | {
+    kind: 'readParagraphs';
+    request: DocxReadParagraphsRequest;
+} | {
+    kind: 'searchText';
+    query: string;
+    caseSensitive: boolean;
+    carry?: YrsStickyPosition | null;
+} | {
+    kind: 'stickyAnchors';
+    locs: YrsLoc[];
+    version: string;
+} | {
+    kind: 'navigationTarget';
+    story: string;
+    paraId: string;
+};
+/** @internal */
+interface ResidentDocumentReadValues {
+    paragraphIdentities: DocxParagraphIdentitySnapshot;
+    resolveParagraphAnchors: {
+        results: DocxParagraphAnchorResult[];
+    };
+    readParagraphs: DocxReadParagraphsResult;
+    navigationTarget: ReturnType<typeof resolveNavigationTarget>;
+    searchText: ResidentSearchResult;
+    stickyAnchors: Array<YrsStickyPosition | null>;
+}
+/** @internal */
+type ResidentEngineWorkerHostModule = {
+    type: 'editModule';
+    module: WebAssembly.Module | null;
+};
 type ResidentEngineWorkerRequest = {
     id: number;
     type: 'warm';
+    hostModule?: true;
 } | {
     id: number;
     type: 'bootstrap';
@@ -404,6 +702,11 @@ type ResidentEngineWorkerRequest = {
     generation?: string;
     /** The most the worker's editing core may allocate at once. */
     heapLimitBytes?: number;
+    /**
+     * Opens a display-only preview of the first `previewBlocks` body blocks instead. A later
+     * `open` of the whole document replaces it.
+     */
+    previewBlocks?: number;
 } | {
     id: number;
     type: 'fontRequirements';
@@ -411,6 +714,17 @@ type ResidentEngineWorkerRequest = {
 } | {
     id: number;
     type: 'encodeState';
+} | {
+    id: number;
+    type: 'revisionCount';
+} | {
+    id: number;
+    type: 'proposal';
+    operation: ResidentProposalOperation;
+} | {
+    id: number;
+    type: 'documentRead';
+    read: ResidentDocumentRead;
 } | {
     id: number;
     type: 'sync';
@@ -426,12 +740,23 @@ type ResidentEngineWorkerRequest = {
     layoutExtras?: string;
     displayWindow?: [number, number];
     retainBuiltPages?: boolean;
+    provisionalPages?: number;
 } | {
     id: number;
     type: 'buildPages';
     pages: number[];
     expectedFrameEpoch: number;
     paintCaret: boolean;
+    background?: boolean;
+} | {
+    id: number;
+    type: 'releasePages';
+    pages: Array<{
+        index: number;
+        pageId: string;
+    }>;
+    expectedFrameEpoch: number;
+    paintCaret: boolean;
 } | {
     id: number;
     type: 'completeLayout';
@@ -498,6 +823,9 @@ type ResidentEngineWorkerResponse = ({
     id: number;
     ok: true;
     frame?: ArrayBuffer;
+    pageFrames?: ArrayBuffer[];
+    pageBuildSuperseded?: boolean;
+    superseded?: true;
     updates?: ArrayBuffer[];
     engineMs?: number;
     workerTotalMs?: number;
@@ -520,10 +848,24 @@ type ResidentEngineWorkerResponse = ({
     layoutProvisional?: boolean;
     /** An `open` reply: the opened package's host metadata JSON. */
     hostJson?: string;
+    /** An `open` reply: the package cannot open as a preview; nothing was opened. */
+    previewRefused?: boolean;
     /** A `fontRequirements` reply. */
     requirementsJson?: string;
     /** An `encodeState` reply: the document state as one yrs v1 update. */
     state?: ArrayBuffer;
+    revisionCount?: number;
+    /** @internal */
+    proposals?: DocxProposalRegistryState;
+    /** @internal */
+    version?: string;
+    /** @internal */
+    proposal?: ResidentProposalResponse;
+    /** @internal */
+    read?: {
+        version: string;
+        value: unknown;
+    };
 } | {
     id: number;
     ok: false;
@@ -538,8 +880,14 @@ type ResidentEngineWorkerResponse = ({
     memory?: WasmModuleMemory[];
 };
 
+/** @internal */
+interface ResidentProposalReply extends Omit<ResidentProposalResponse, 'updates' | 'stateVector'> {
+    updates: Uint8Array[];
+    stateVector: Uint8Array;
+}
 interface ResidentEngineWorkerFrame {
     frame: Uint8Array;
+    pageFrames?: Uint8Array[];
     updates: Uint8Array[];
     engineMs: number;
     workerTotalMs: number;
@@ -564,7 +912,7 @@ interface ResidentEngineWorkerLayoutOptions {
     layoutExtras?: string;
     /** The host state vector the snapshot brings the worker to. */
     stateVector?: Uint8Array;
-    /** Bootstrap only: lay out just the body's first pages before replying. */
+    /** Lay out just the body's first pages before replying. */
     provisionalPages?: number;
     /** Bootstrap only: lay out the document {@link ResidentEngineWorkerClient.open} opened. */
     opened?: boolean;
@@ -599,7 +947,7 @@ interface ResidentEngineWorkerPort {
     onmessage: ((event: MessageEvent<ResidentEngineWorkerResponse>) => void) | null;
     onerror: ((event: ErrorEvent) => void) | null;
     onmessageerror: ((event: MessageEvent) => void) | null;
-    postMessage(message: ResidentEngineWorkerRequest, transfer?: Transferable[]): void;
+    postMessage(message: ResidentEngineWorkerRequest | ResidentEngineWorkerHostModule, transfer?: Transferable[]): void;
     terminate(): void;
 }
 /** Dedicated-worker owner for resident input, pagination, and FrameDelta output. */
@@ -617,13 +965,17 @@ declare class ResidentEngineWorkerClient {
     /** Set once `open` is sent, with the heap limit it opened under. */
     private openedHeapLimit;
     private bootstraps;
+    /** The font-requirements read still in flight, shared while nothing was posted after it. */
+    private fontRead;
     /** Id of the last snapshot request sent; replies to earlier requests must
      * not replace the state it recorded. */
     private lastSnapshotId;
     private keepSurfaces;
+    private bootstrapWaiters;
     private lastMemory;
     private answeredFrameEpoch;
     private retainBuiltPages;
+    private failureListener;
     constructor(worker?: ResidentEngineWorkerPort);
     isReady(): boolean;
     /** @internal */
@@ -635,7 +987,9 @@ declare class ResidentEngineWorkerClient {
     answeredFrame(): number;
     /** @internal */
     setRetainBuiltPages(retain: boolean): void;
-    /** @internal Whether a frame request other than `buildPages` awaits its reply. */
+    /** @internal Called once when the worker fails, whether or not a request was waiting; not on `destroy`. */
+    onFailure(listener: ((error: Error) => void) | null): void;
+    /** @internal Whether foreground document or frame work awaits its reply. */
     frameRequestPending(): boolean;
     /** The worker replica's last reported yrs state vector (null before any). */
     remoteStateVector(): Uint8Array | null;
@@ -643,6 +997,8 @@ declare class ResidentEngineWorkerClient {
     syncedFontsRevision(): number | null;
     /** A bootstrap was sent; later snapshots go as syncs queued behind it. */
     bootstrapSent(): boolean;
+    /** Resolves once a bootstrap is sent, at once when one was. */
+    whenBootstrapSent(): Promise<void>;
     /**
      * Starts over with another document in the same worker: the next request
      * is a bootstrap, which keeps the page surfaces already attached so the
@@ -659,10 +1015,35 @@ declare class ResidentEngineWorkerClient {
         generation?: string;
         heapLimitBytes?: number;
     }): Promise<ResidentEngineWorkerOpened>;
+    /**
+     * Opens a display-only preview of the first `blocks` body blocks of a DOCX in the worker, or
+     * resolves null when the package cannot open as a preview. Its first layout is a bootstrap
+     * with `opened`; {@link rebootstrap} then lets {@link open} replace it with the whole document.
+     * A copy of `bytes` is transferred.
+     */
+    openPreview(bytes: Uint8Array, blocks: number, options?: {
+        heapLimitBytes?: number;
+    }): Promise<ResidentEngineWorkerOpened | null>;
     /** The font requirements of a region layout request, read from the opened document. */
     fontRequirements(layoutInput: string): Promise<string>;
+    /** @internal */
+    proposal(operation: ResidentProposalOperation): Promise<ResidentProposalReply>;
+    /** @internal */
+    documentRead<K extends ResidentDocumentRead['kind']>(read: ResidentDocumentRead & {
+        kind: K;
+    }): Promise<{
+        version: string;
+        value: ResidentDocumentReadValues[K];
+    }>;
+    /** @internal */
+    handOver(): Promise<{
+        state: Uint8Array;
+        version: string;
+        proposals: DocxProposalRegistryState;
+    }>;
     /** The worker's whole document state as one yrs v1 update. */
     encodeState(): Promise<Uint8Array>;
+    revisionCount(): Promise<number>;
     warm(): Promise<void>;
     bootstrap(snapshot: YrsResidentWorkerSnapshot, extras: string, options?: ResidentEngineWorkerLayoutOptions & ResidentEngineWorkerSnapshotOptions): Promise<ResidentEngineWorkerFrame>;
     sync(snapshot: YrsResidentWorkerSnapshot, extras: string, expectedFrameEpoch: number, paintCaret?: boolean, options?: ResidentEngineWorkerLayoutOptions & ResidentEngineWorkerSnapshotOptions): Promise<ResidentEngineWorkerFrame>;
@@ -674,6 +1055,14 @@ declare class ResidentEngineWorkerClient {
     buildFrame(extras: string, expectedFrameEpoch: number, paintCaret?: boolean, displayWindow?: [number, number]): Promise<ResidentEngineWorkerFrame>;
     /** Build unbuilt display pages; the reply frame carries them. */
     buildPages(pages: number[], expectedFrameEpoch: number, paintCaret?: boolean): Promise<ResidentEngineWorkerFrame>;
+    /** @internal */
+    buildPages(pages: number[], expectedFrameEpoch: number, paintCaret: boolean, background: boolean): Promise<ResidentEngineWorkerFrame | null>;
+    releasePages(pages: Array<{
+        index: number;
+        pageId: string;
+    }>, expectedFrameEpoch: number, paintCaret?: boolean): Promise<ResidentEngineWorkerFrame | {
+        superseded: true;
+    }>;
     applyInput(text: string, selection: YrsSelection, expectedFrameEpoch: number, profile?: boolean, paintCaret?: boolean, displayWindow?: [number, number]): Promise<ResidentEngineWorkerApplyResult | {
         applied: false;
     }>;
@@ -743,6 +1132,12 @@ declare function documentToYrs(session: YrsSession, document: Document, options?
 
 /** yrs-to-OOXML save projection. */
 
+/**
+ * `blocks` with paragraphs of their own, in table cells too, each still the
+ * session paragraph it was projected from: a save edits these, not the
+ * projection the next one reuses. @internal
+ */
+declare function ownProjectedParagraphs(blocks: readonly BlockContent[]): BlockContent[];
 /**
  * Rebuild all yrs-owned editable stories into the serializer-facing Document
  * while preserving every package part the editor does not own.
@@ -795,11 +1190,13 @@ declare function captureSessionSave(session: YrsSession): DocxSessionSave;
 /**
  * Writes `document`, projected from `session` when `capture` was taken, and
  * records the Word paragraph IDs the bytes hold as saved. `patches` selects
- * the planned parts written as `originalBuffer`'s bytes with IDs patched in;
- * it selects none unless `originalBuffer` is the session's source package.
+ * the planned parts written as `originalBuffer`'s bytes with IDs patched in,
+ * and `splices` the story parts written as its bytes with only the
+ * paragraphs that need it re-serialized; each selects none unless
+ * `originalBuffer` is the session's source package.
  * @internal
  */
-declare function writeSessionSave(session: YrsSession, document: Document, capture: DocxSessionSave, originalBuffer: ArrayBuffer, options?: RepackOptions, patches?: (part: string) => boolean): Promise<DocxSavedDocument>;
+declare function writeSessionSave(session: YrsSession, document: Document, capture: DocxSessionSave, originalBuffer: ArrayBuffer, options?: RepackOptions, patches?: (part: string) => boolean, skipMutations?: boolean, splices?: (part: string) => boolean): Promise<DocxSavedDocument>;
 /**
  * Saves a session opened from DOCX bytes and reports each saved paragraph's
  * persisted anchor, read from the same projection the bytes are written
@@ -815,6 +1212,21 @@ declare function writeSessionSave(session: YrsSession, document: Document, captu
  */
 declare function saveYrsDocx(session: YrsSession, options?: RepackOptions): Promise<DocxSavedDocument>;
 
+/** @internal */
+declare function editorSaveKeys(document: Document, comments?: readonly Comment[]): {
+    metadata: string;
+    comments: string;
+    commentIds: number[];
+};
+
+/** Engine operations the package runs on sessions it creates itself; not public API. */
+
+/** Returns the session's opened source package when available. @internal */
+declare function sessionSourcePackage(session: YrsSession): {
+    buffer: ArrayBuffer;
+    keys: ReturnType<typeof editorSaveKeys>;
+} | null;
+
 interface YrsDocxHost {
     document: Document;
     referencedFonts: string[];
@@ -825,6 +1237,8 @@ interface YrsDocxHost {
      * preview's cover only its own first pages.
      */
     unusedScriptFonts?: string[];
+    /** A preview whose cut holds the whole body. */
+    wholeBody?: true;
     embeddedFonts: Map<string, ArrayBuffer>;
     fontTableRelationshipsXml?: string;
 }
@@ -1298,6 +1712,8 @@ type YrsResidentFontRegistration = Uint8Array | {
     family: string;
 };
 interface YrsResidentWorkerSnapshot {
+    /** @internal */
+    workerAuthoritative?: true;
     clientId: number;
     /** Full document state, or a state-vector diff when the caller supplied
      * the worker's known vector — both apply through the same merge path. */
@@ -1500,6 +1916,11 @@ interface YrsMediaSource {
     bytes: Uint8Array;
     mimeType: string;
 }
+/** @internal */
+interface YrsWorkerDocumentMirror {
+    version: string;
+    proposals: DocxProposalRegistryState;
+}
 interface YrsSession extends CollaborationReplica {
     /** The yrs client id this replica writes with. */
     readonly clientId: number;
@@ -1555,8 +1976,12 @@ interface YrsSession extends CollaborationReplica {
     setDisplayWindow(start: number, end: number): void;
     /** Keep every previously built page while windowed builds are on. @internal */
     setDisplayRetainBuiltPages(retain: boolean): void;
+    /** @internal */
+    setWindowedIncrementalBuilds(enabled: boolean): void;
     /** Build the listed unbuilt pages into a FrameDelta v1. @internal */
     buildDisplayPagesFrame(pages: readonly number[], expectedFrameEpoch: number): Uint8Array;
+    /** Release built pages; null means the request was superseded. @internal */
+    releaseDisplayPagesFrame(pages: number[], expectedFrameEpoch: number): Uint8Array | null;
     /** Make the next frame a full one, for a host taking over from another engine; no-op once destroyed. */
     resetFrameBase(): void;
     /** Caret geometry from the current resident display frame. */
@@ -1619,6 +2044,11 @@ interface YrsSession extends CollaborationReplica {
     openDocxPreview(bytes: Uint8Array, blocks: number): YrsDocxHost | null;
     /** Opened by {@link openDocxPreview}: its document refuses every change. @internal */
     isDisplayOnly(): boolean;
+    /**
+     * Marks this empty session as showing a preview another engine opened: it refuses every
+     * change, and {@link openDocxPreview} can still load the preview here. @internal
+     */
+    markDisplayOnly(): void;
     /**
      * Marks whether the document is a preview's, as a replica of one is: its
      * layouts render NUMPAGES empty. @internal
@@ -1668,6 +2098,8 @@ interface YrsSession extends CollaborationReplica {
     applyUpdate(update: Uint8Array): CollaborationTextInsertion | null;
     /** Apply a same-user worker update under the local undo origin. @internal */
     applyLocalUpdate(update: Uint8Array): void;
+    /** Adopt another replica's host batch outside undo history. @internal */
+    applyHostUpdate(update: Uint8Array, stories?: readonly string[]): void;
     /**
      * Subscribes to every committed transaction's v1 update (local AND
      * applied-remote). Returns an unsubscribe function.
@@ -1802,7 +2234,10 @@ interface YrsSession extends CollaborationReplica {
      * promotes an editor-only paragraph they author into.
      */
     applyRawOps(story: string, ops: readonly YrsRawOp[]): void;
-    /** Applies seed raw operations with deterministic item ordering. */
+    /**
+     * Applies seed raw operations with deterministic item ordering. A
+     * `setComment` for a comment already seeded adds its ranges to it.
+     */
     applySeedRawOps(story: string, ops: readonly YrsRawOp[]): void;
     /** Sets one paragraph property (any JSON value). `paraId` is reserved. */
     setParagraphAttr(paraId: string, key: string, value: unknown): void;
@@ -1873,6 +2308,8 @@ interface YrsSession extends CollaborationReplica {
     tablePayload(story: string, tableIndex: number): Record<string, unknown> | null;
     /** A paragraph's story span (start unit, pilcrow index). */
     locateParagraph(story: string, paraId: string): YrsParagraphSpan;
+    /** How many paragraphs of `story` carry `paraId`: 0, 1, or 2 for two or more. */
+    paragraphIdCount(story: string, paraId: string): number;
     /**
      * Session, persisted and source anchors of every paragraph, including the
      * source package's paragraphs outside the stories, and the Word paragraph ID
@@ -1950,6 +2387,10 @@ interface YrsSession extends CollaborationReplica {
     withdrawProposals(request: DocxProposalWithdrawRequest): DocxProposalResult;
     /** The proposals in the order they were made. */
     getProposals(): DocxProposalSnapshot;
+    /** @internal */
+    mirrorWorkerDocument(mirror: YrsWorkerDocumentMirror | null): void;
+    /** @internal */
+    workerDocumentMirrored(): boolean;
     /** Listens for new proposals, decisions and a forgotten registry. Returns the unsubscribe. */
     onProposalChange(listener: (snapshot: DocxProposalSnapshot) => void): () => void;
     /**
@@ -2023,4 +2464,4 @@ declare function decodeDocxHostJson(json: string, source: Uint8Array): YrsDocxHo
  */
 declare function createYrsSession(options?: CreateYrsSessionOptions): Promise<YrsSession>;
 
-export { type DocxSourceStory as $, type DocxParagraphIdDiagnostic as A, type DocxParagraphIdOrigin as B, type CollaborationReplica as C, type DocxOccurrence as D, type DocxParagraphIdRefusal as E, type DocxParagraphIdentity as F, type DocxParagraphIdentityReceipt as G, type DocxParagraphIdentitySnapshot as H, type DocxParagraphOrigin as I, type DocxParagraphRef as J, type DocxParagraphSavePlan as K, type DocxPersistedParagraphAnchor as L, type DocxProposalFailure as M, type DocxProposalInput as N, type DocxProposalRecord as O, type DocxProposalRequest as P, type DocxProposalResult as Q, type DocxProposalSnapshot as R, type DocxProposalState as S, type DocxProposalStateRequest as T, type DocxProposalWithdrawRequest as U, type DocxSavedDocument as V, type DocxSavedParagraph as W, type DocxSessionParagraphAnchor as X, type YrsSession as Y, type DocxSessionSave as Z, type DocxSourceParagraphAnchor as _, type YrsRenderEnv as a, type YrsWatermark as a$, type ResidentCaretPaintStyle as a0, type ResidentEngineOffscreenPage as a1, type ResidentEngineWorkerApplyResult as a2, ResidentEngineWorkerClient as a3, type ResidentEngineWorkerFrame as a4, type ResidentEngineWorkerOpened as a5, ResidentWorkerFailureError as a6, ResidentWorkerOutOfMemoryError as a7, type YrsAuthor as a8, type YrsCellBorder as a9, type YrsRegionLayoutProgress as aA, type YrsReplaceReceipt as aB, type YrsResidentCaretRect as aC, type YrsResidentCaretSnapshot as aD, type YrsResidentFontRegistration as aE, type YrsResidentWorkerSnapshot as aF, type YrsResidentWorkerSyncOptions as aG, type YrsResolveReceipt as aH, type YrsResolvedCommentAnchor as aI, type YrsRevisionReceipt as aJ, type YrsRunMark as aK, type YrsSelectionContext as aL, type YrsSelectionText as aM, type YrsSplitReceipt as aN, type YrsStickyPosition as aO, type YrsStoryRange as aP, type YrsStorySeed as aQ, type YrsStorySegment as aR, type YrsTableLoc as aS, type YrsTableRange as aT, type YrsTableReceipt as aU, type YrsTargetEditResult as aV, type YrsTextColor as aW, type YrsTextMatch as aX, type YrsTextSearchOptions as aY, type YrsTriState as aZ, type YrsUndoCaptureMode as a_, type YrsCellBorders as aa, type YrsCellLoc as ab, type YrsChangeTarget as ac, type YrsCommentInfo as ad, type YrsCommentReceipt as ae, type YrsContentControlValue as af, type YrsDocxHost as ag, type YrsEngineApplyProfile as ah, type YrsHyperlinkAttrs as ai, type YrsImageGeometry as aj, type YrsInlineFormatDelta as ak, type YrsInputParagraphSeed as al, type YrsInputParagraphSpan as am, type YrsInputPositionMap as an, type YrsMediaSource as ao, type YrsNumberingProperties as ap, type YrsOpeningOptions as aq, type YrsParaOffset as ar, type YrsParagraph as as, type YrsParagraphAttrs as at, type YrsParagraphLength as au, type YrsParagraphReceipt as av, type YrsParagraphSeed as aw, type YrsParagraphSpan as ax, type YrsParagraphTabStop as ay, type YrsRawOp as az, type CollaborationTransport as b, canUseResidentEngineWorker as b0, captureSessionSave as b1, compareYrsLocs as b2, createYrsInputPositionMap as b3, createYrsSession as b4, decodeDocxHostJson as b5, displayPositionToYrsLoc as b6, documentToYrs as b7, preloadDocxEngine as b8, preloadResidentEngineWorker as b9, prepareDocxBytes as ba, preparedDocxDigest as bb, proposalRevisionPreview as bc, residentCaretDeviceRect as bd, residentCaretSnapshotForFrame as be, retainPreloadedResidentEngineWorker as bf, sameYrsSelection as bg, saveYrsDocx as bh, takePreloadedResidentEngineWorker as bi, writeSessionSave as bj, yrsLocToDisplayPosition as bk, yrsToDocument as bl, type CollaborationProviderOptions as c, type CollaborationStatus as d, type CollaborationPeer as e, type CollaborationCursor as f, type CollaborationPeerListener as g, type CollaborationStatusListener as h, type CollaborationErrorListener as i, type YrsSelection as j, type CollaborationAwarenessState as k, CollaborationError as l, type CollaborationErrorCode as m, type CollaborationPresence as n, type CollaborationResolvedUser as o, type CollaborationStatusChange as p, type CollaborationTextInsertion as q, type CollaborationTransportEvent as r, type CollaborationUpdateOrigin as s, type CollaborationUser as t, type YrsLoc as u, type YrsRevisionInfo as v, type CreateYrsSessionOptions as w, type DocxParagraphAnchor as x, type DocxParagraphAnchorResult as y, type DocxParagraphIdAssignment as z };
+export { type DocxSavedDocument as $, type AnchorGeometryTarget as A, type DocxParagraphAnchor as B, type CollaborationReplica as C, type DocxOccurrence as D, type DocxParagraphAnchorResult as E, type DocxParagraphIdAssignment as F, type DocxParagraphIdDiagnostic as G, type DocxParagraphIdOrigin as H, type DocxParagraphIdRefusal as I, type DocxParagraphIdentity as J, type DocxParagraphIdentityReceipt as K, type DocxParagraphIdentitySnapshot as L, type DocxParagraphOrigin as M, type DocxParagraphRef as N, type DocxParagraphSavePlan as O, type DocxPersistedParagraphAnchor as P, type DocxProposalFailure as Q, type DocxProposalInput as R, type DocxProposalRecord as S, type DocxProposalRegistryState as T, type DocxProposalRequest as U, type DocxProposalResult as V, type DocxProposalSnapshot as W, type DocxProposalState as X, type YrsSession as Y, type DocxProposalStateRequest as Z, type DocxProposalWithdrawRequest as _, type YrsRenderEnv as a, type YrsResolvedCommentAnchor as a$, type DocxSavedParagraph as a0, type DocxSessionParagraphAnchor as a1, type DocxSessionSave as a2, type DocxSourceParagraphAnchor as a3, type DocxSourceStory as a4, type ProposalDisplayTarget as a5, type ProposalGeometryMirror as a6, type ProposalGeometryReader as a7, type ProposalGeometryRevision as a8, type ProposalGeometryTarget as a9, type YrsLocProjection as aA, type YrsMediaSource as aB, type YrsNumberingProperties as aC, type YrsOpeningOptions as aD, type YrsParaOffset as aE, type YrsParagraph as aF, type YrsParagraphAttrs as aG, type YrsParagraphLength as aH, type YrsParagraphReceipt as aI, type YrsParagraphSeed as aJ, type YrsParagraphSpan as aK, type YrsParagraphTabStop as aL, type YrsPointerProjectionTarget as aM, type YrsPositionOutline as aN, YrsPositionProjection as aO, type YrsProjectedCell as aP, type YrsProjectedNode as aQ, type YrsProjectedTable as aR, type YrsRawOp as aS, type YrsRegionLayoutProgress as aT, type YrsReplaceReceipt as aU, type YrsResidentCaretRect as aV, type YrsResidentCaretSnapshot as aW, type YrsResidentFontRegistration as aX, type YrsResidentWorkerSnapshot as aY, type YrsResidentWorkerSyncOptions as aZ, type YrsResolveReceipt as a_, type RawAnchorRange as aa, type ResidentCaretPaintStyle as ab, type ResidentEngineOffscreenPage as ac, type ResidentEngineWorkerApplyResult as ad, ResidentEngineWorkerClient as ae, type ResidentEngineWorkerFrame as af, type ResidentEngineWorkerOpened as ag, type ResidentProposalReply as ah, ResidentWorkerFailureError as ai, ResidentWorkerOutOfMemoryError as aj, type YrsAuthor as ak, type YrsCellBorder as al, type YrsCellBorders as am, type YrsCellLoc as an, type YrsChangeTarget as ao, type YrsCommentInfo as ap, type YrsCommentReceipt as aq, type YrsContentControlValue as ar, type YrsDocxHost as as, type YrsEngineApplyProfile as at, type YrsHyperlinkAttrs as au, type YrsImageGeometry as av, type YrsInlineFormatDelta as aw, type YrsInputParagraphSeed as ax, type YrsInputParagraphSpan as ay, type YrsInputPositionMap as az, type CollaborationTransport as b, type YrsRevisionReceipt as b0, type YrsRunMark as b1, type YrsSelectionContext as b2, type YrsSelectionText as b3, type YrsSplitReceipt as b4, type YrsStickyPosition as b5, type YrsStoryRange as b6, type YrsStorySeed as b7, type YrsStorySegmentSource as b8, type YrsTableLoc as b9, preloadDocxEngine as bA, preloadResidentEngineWorker as bB, prepareDocxBytes as bC, preparedDocxDigest as bD, projectYrsDisplayPosition as bE, proposalRevisionPreview as bF, proposalSetIdentity as bG, residentCaretDeviceRect as bH, residentCaretSnapshotForFrame as bI, resolveAnchorTarget as bJ, resolveMirroredNavigationTarget as bK, resolveNavigationTarget as bL, retainPreloadedResidentEngineWorker as bM, sameYrsSelection as bN, saveYrsDocx as bO, sessionSourcePackage as bP, takePreloadedResidentEngineWorker as bQ, textRangeToRaw as bR, writeSessionSave as bS, yrsLocToDisplayPosition as bT, yrsLocToProjectedDisplayPosition as bU, yrsToDocument as bV, type YrsTableRange as ba, type YrsTableReceipt as bb, type YrsTargetEditResult as bc, type YrsTextColor as bd, type YrsTextMatch as be, type YrsTextSearchOptions as bf, type YrsTriState as bg, type YrsUndoCaptureMode as bh, type YrsWatermark as bi, type YrsWorkerDocumentMirror as bj, anchorFailure as bk, canUseResidentEngineWorker as bl, captureSessionSave as bm, compareYrsLocs as bn, computeProposalGeometryMirror as bo, createYrsInputPositionMap as bp, createYrsLocProjectionFromOutline as bq, createYrsPositionProjection as br, createYrsSession as bs, decodeDocxHostJson as bt, displayPositionToYrsLoc as bu, documentToYrs as bv, editorSaveKeys as bw, hiddenRanges as bx, isBodyStory as by, ownProjectedParagraphs as bz, type CollaborationProviderOptions as c, type CollaborationStatus as d, type CollaborationPeer as e, type CollaborationCursor as f, type CollaborationPeerListener as g, type CollaborationStatusListener as h, type CollaborationErrorListener as i, type YrsSelection as j, type CollaborationAwarenessState as k, CollaborationError as l, type CollaborationErrorCode as m, type CollaborationPresence as n, type CollaborationResolvedUser as o, type CollaborationStatusChange as p, type CollaborationTextInsertion as q, type CollaborationTransportEvent as r, type CollaborationUpdateOrigin as s, type CollaborationUser as t, type YrsLoc as u, type YrsStorySegment as v, type YrsRevisionInfo as w, type AnchorReader as x, type AnchorResolutionFailure as y, type CreateYrsSessionOptions as z };