@a3s-lab/office 0.11.0 → 0.13.0

package/dist/internal/features/work/editors/use-document-pagination.d.ts

@@ -52,6 +52,11 @@ export interface UseDocumentPaginationValue {
 export declare function useDocumentPagination({ editor, documentRevision, enabled, layoutKey, page, selectionVersion, wasmUrl, layoutFonts, loadedLayoutFontIds, }: UseDocumentPaginationOptions): UseDocumentPaginationValue;
 export declare function createDocumentFieldPaginationContextResolver(pagination: DocumentPaginationResult): WorkDocumentFieldContextResolver;
 export declare function documentResizeObservationPositions(blocks: readonly MeasuredDocumentLayoutBlock[]): ReadonlyMap<HTMLElement, number>;
+export declare function documentResizeObservationTargets(editorDom: HTMLElement, blocks: readonly MeasuredDocumentLayoutBlock[]): {
+    observedBlockCount: number;
+    positions: ReadonlyMap<HTMLElement, number>;
+    scope: 'blocks' | 'document';
+};
 export declare function documentPaginationPageDescriptors(layout: OfficeKernelLayoutResult, blocks: readonly MeasuredDocumentLayoutBlock[], documentNode?: ProseMirrorNode): DocumentPaginationPageDescriptor[];
 export declare function deriveDocumentPaginationPageDescriptors(layout: OfficeKernelLayoutResult, blocks: readonly MeasuredDocumentLayoutBlock[], documentNode?: ProseMirrorNode, previousPages?: readonly DocumentPaginationPageDescriptor[], requestedReusedPageCount?: number): DocumentPaginationPageDescriptorDerivation;
 export declare function pageForPosition(pagination: DocumentPaginationResult, position: number): number;

package/dist/internal/features/work/editors/use-presentation-design-commands.d.ts

@@ -1,3 +1,4 @@
+import { type WorkPresentationDesignContent } from '../work-presentation-layouts';
 import type { WorkPresentationContent, WorkPresentationLayout, WorkPresentationMaster, WorkSlide, WorkSlideElement } from '../work-types';
 import type { PresentationDesignMode } from './presentation-editor-types';
 export interface PresentationDesignCommands {
@@ -18,7 +19,7 @@ export interface PresentationDesignCommands {
 export declare function usePresentationDesignCommands({ activeElements, activeTargetId, designContent, designMode, designOpen, onChange, onClearSelection, onCloseComments, onEditElement, onSetDesignMode, onSetDesignOpen, selectedLayout, selectedMaster, selectedSlide, }: {
     activeElements: readonly WorkSlideElement[];
     activeTargetId: string | undefined;
-    designContent: WorkPresentationContent;
+    designContent: WorkPresentationDesignContent;
     designMode: PresentationDesignMode;
     designOpen: boolean;
     onChange: (content: WorkPresentationContent) => void;

package/dist/internal/features/work/editors/use-spreadsheet-collaboration.d.ts

@@ -8,7 +8,7 @@ export interface SpreadsheetCollaborationHistory {
     undo: () => boolean;
 }
 export interface SpreadsheetCollaborationViewController {
-    activateSheet: (sheetId: string) => void;
+    activateSheet: (sheetId: string) => boolean;
     select: (sheetId: string, selection: Selection) => void;
     setZoom: (sheetId: string, zoomRatio: number) => void;
 }
@@ -21,6 +21,7 @@ export declare function useSpreadsheetCollaboration({ initialContent, onChange,
     content: WorkSpreadsheetContent;
     history: SpreadsheetCollaborationHistory;
     onChange: (next: WorkSpreadsheetContent) => void;
+    onDerivedChange: (next: WorkSpreadsheetContent) => void;
     readOnly: boolean;
     view: SpreadsheetCollaborationViewController;
 };

package/dist/internal/features/work/editors/use-spreadsheet-workbook-sync.d.ts

@@ -7,4 +7,5 @@ export interface SpreadsheetWorkbookSyncController {
     recordOperations: (operations: readonly Op[]) => void;
     takeOperations: () => Op[];
 }
-export declare function useSpreadsheetWorkbookSync(content: WorkSpreadsheetContent): SpreadsheetWorkbookSyncController;
+export type SpreadsheetExternalWorkbookSynchronizer = (previous: WorkSpreadsheetContent, next: WorkSpreadsheetContent) => boolean;
+export declare function useSpreadsheetWorkbookSync(content: WorkSpreadsheetContent, synchronizeExternalWorkbook?: SpreadsheetExternalWorkbookSynchronizer): SpreadsheetWorkbookSyncController;

package/dist/internal/features/work/spreadsheet-history-value.d.ts

@@ -0,0 +1 @@
+export declare function sameSpreadsheetHistoryValue(left: unknown, right: unknown): boolean;

package/dist/internal/features/work/spreadsheet-sparse.d.ts

@@ -0,0 +1,10 @@
+import type { CellMatrix, Sheet } from '@fortune-sheet/core';
+export interface SpreadsheetGridSize {
+    rowCount: number;
+    columnCount: number;
+}
+export declare function sparseArrayIndexes(values: readonly unknown[] | undefined): number[];
+export declare function sparseArrayEntries<T>(values: readonly T[] | undefined): Array<[number, T]>;
+export declare function sparseMatrixColumnCount(matrix: CellMatrix | undefined): number;
+export declare function spreadsheetGridSize(sheet: Pick<Sheet, 'column' | 'data' | 'row'> | undefined): SpreadsheetGridSize | null;
+export declare function cloneSparseMatrix(source: CellMatrix | undefined): CellMatrix;

package/dist/internal/features/work/work-document-chunk-geometry.d.ts

@@ -0,0 +1,28 @@
+import type { Node as ProseMirrorNode } from '@tiptap/pm/model';
+export interface DocumentChunkGeometry {
+    containerId?: string;
+    end: number;
+    from: number;
+    id: string;
+    paginationExtraHeight: number;
+    start: number;
+    to: number;
+}
+export interface DocumentChunkPosition {
+    ancestorIds: readonly string[];
+    from: number;
+    to: number;
+}
+export declare function documentChunkViewportRange(geometry: readonly {
+    end: number;
+    start: number;
+}[], viewportTop: number, viewportBottom: number): {
+    end: number;
+    start: number;
+};
+export declare function documentChunkGeometry(document: ProseMirrorNode, breaks: readonly {
+    position: number;
+    spacerHeight: number;
+}[]): DocumentChunkGeometry[];
+export declare function documentChunkPositions(document: ProseMirrorNode): ReadonlyMap<string, DocumentChunkPosition>;
+export declare function documentChunkId(node: ProseMirrorNode): string;

package/dist/internal/features/work/work-document-chunk-node.d.ts

@@ -0,0 +1,23 @@
+import type { Editor } from '@tiptap/core';
+import { Node } from '@tiptap/core';
+import { type EditorState, type Transaction } from '@tiptap/pm/state';
+import type { WorkDocumentContent, WorkDocumentNode } from './work-types';
+interface DocumentChunkOptions {
+    getContent: () => WorkDocumentContent | null;
+    trustInitialIntegrityFeatures: boolean;
+}
+export interface DocumentChunkHydrationMeta {
+    ids: readonly string[];
+}
+export interface DocumentChunkVisibleIdsMeta {
+    visibleIds: readonly string[];
+}
+export declare const DOCUMENT_CHUNK_PAGINATION_META = "documentChunkPaginationGeometry";
+export declare const DOCUMENT_CHUNK_VISIBLE_IDS_META = "documentChunkVisibleIds";
+export declare const DOCUMENT_CHUNK_HYDRATION_META = "documentChunkLazyHydration";
+export { documentChunkViewportRange } from './work-document-chunk-geometry';
+export declare const DocumentChunk: Node<DocumentChunkOptions, any>;
+export declare function documentLazyChunkContentForEditor(editor: Editor, chunkId: string): readonly WorkDocumentNode[] | null;
+export declare function documentTransactionsOnlyHydrateChunks(transactions: readonly Transaction[]): boolean;
+export declare function selectedDocumentChunkId(state: Pick<EditorState, 'doc' | 'selection'>): string | null;
+export declare function documentChunkMountedIds(state: EditorState): readonly string[] | null;

package/dist/internal/features/work/work-document-extensions.d.ts

@@ -9,5 +9,6 @@ export interface WorkDocumentExtensionOptions {
     onContentChange?: (content: WorkDocumentContent) => void;
     onTrackingChange?: (enabled: boolean) => void;
     rotateTrackedTextIdentities?: () => boolean;
+    trustInitialIntegrityFeatures?: boolean;
 }
 export declare function createWorkDocumentExtensions(options?: WorkDocumentExtensionOptions): Extensions;

package/dist/internal/features/work/work-document-file-io.d.ts

@@ -1,4 +1,5 @@
+import type { WorkFileImportContext } from './work-file-import';
 import type { WorkArtifact } from './work-types';
-export declare function importWorkDocumentFile(file: File, extension: string): Promise<WorkArtifact>;
+export declare function importWorkDocumentFile(file: File, extension: string, context?: WorkFileImportContext): Promise<WorkArtifact>;
 export declare function exportWorkDocumentArtifact(artifact: WorkArtifact): Promise<void>;
 export declare function createWorkDocumentBlob(artifact: WorkArtifact): Promise<Blob>;

package/dist/internal/features/work/work-document-html-fingerprint.d.ts

@@ -0,0 +1,15 @@
+export interface DocumentHtmlFingerprintSegment {
+    hash: number;
+    length: number;
+    power: number;
+}
+/**
+ * Hashes one HTML segment with a polynomial that can be combined without
+ * rescanning unchanged prefixes and suffixes.
+ */
+export declare function createDocumentHtmlFingerprintSegment(source: string, from?: number, to?: number): DocumentHtmlFingerprintSegment;
+export declare function combineDocumentHtmlFingerprintSegments(segments: Iterable<DocumentHtmlFingerprintSegment>): DocumentHtmlFingerprintSegment;
+export declare function documentHtmlFingerprintForSegment(segment: DocumentHtmlFingerprintSegment): string;
+export declare function documentHtmlFingerprint(html: string): string;
+/** Accepts fingerprints written before composable document hashing shipped. */
+export declare function documentHtmlFingerprintMatches(html: string, candidate: string): boolean;

package/dist/internal/features/work/work-document-import-worker-client.d.ts

@@ -0,0 +1,13 @@
+import { type LargeSimpleDocxParseOptions, type LargeSimpleDocxParseResult } from './work-docx-large-document-import';
+export type LargeSimpleDocxWorkerAttempt = {
+    result: LargeSimpleDocxParseResult;
+    status: 'accepted';
+} | {
+    status: 'ineligible';
+};
+/**
+ * Streams a parser-authenticated giant DOCX from a dedicated Worker. Null
+ * means the Worker path failed and the caller should use the synchronous
+ * parser; an explicit ineligible result must continue to the rich importer.
+ */
+export declare function parseLargeSimpleDocxInWorker(xmlBytes: ArrayBuffer, options?: LargeSimpleDocxParseOptions, signal?: AbortSignal): Promise<LargeSimpleDocxWorkerAttempt | null>;

package/dist/internal/features/work/work-document-import-worker-protocol.d.ts

@@ -0,0 +1,36 @@
+import type { LargeSimpleDocxParseOptions, LargeSimpleDocxStreamResult } from './work-docx-large-document-parser';
+export declare const DOCUMENT_IMPORT_PARAGRAPH_BATCH_SIZE = 2048;
+export declare const DOCUMENT_IMPORT_TABLE_ROW_BATCH_SIZE = 2048;
+export interface DocumentImportWorkerRequest {
+    kind: 'parse';
+    options: LargeSimpleDocxParseOptions;
+    xmlBytes: ArrayBuffer;
+}
+export interface DocumentImportWorkerTimings {
+    contentMs: number;
+    eligibilityMs: number;
+    envelopeMs: number;
+    parseMs: number;
+    xmlMs: number;
+}
+export type DocumentImportWorkerResponse = {
+    kind: 'failure';
+} | {
+    kind: 'ineligible';
+} | {
+    kind: 'paragraphs';
+    texts: string[];
+} | {
+    kind: 'table-start';
+} | {
+    cellParagraphCounts: Uint32Array;
+    kind: 'table-rows';
+    rowCellCounts: Uint32Array;
+    texts: string[];
+} | {
+    kind: 'table-end';
+} | {
+    kind: 'success';
+    streamed: LargeSimpleDocxStreamResult;
+    timings: DocumentImportWorkerTimings;
+};

package/dist/internal/features/work/work-document-import.worker.d.ts

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

package/dist/internal/features/work/work-document-incremental-layout.d.ts

@@ -13,5 +13,5 @@ export interface IncrementalDocumentLayoutPlan {
 export declare function planIncrementalDocumentLayout(previous: {
     blocks: readonly PositionedOfficeKernelLayoutBlock[];
     layout: OfficeKernelLayoutResult;
-} | null, next: readonly PositionedOfficeKernelLayoutBlock[], dirtyFrom: number): IncrementalDocumentLayoutPlan;
+} | null, next: readonly PositionedOfficeKernelLayoutBlock[], dirtyFrom: number, reusedPrefixBlockCount?: number): IncrementalDocumentLayoutPlan;
 export declare function mergeIncrementalDocumentLayout(previous: OfficeKernelLayoutResult, partial: OfficeKernelLayoutResult): OfficeKernelLayoutResult;

package/dist/internal/features/work/work-document-integrity-index.d.ts

@@ -0,0 +1,14 @@
+import type { Node as ProseMirrorNode } from '@tiptap/pm/model';
+export declare const DOCUMENT_INTEGRITY_BOOKMARK: number;
+export declare const DOCUMENT_INTEGRITY_FIELD: number;
+export declare const DOCUMENT_INTEGRITY_IMAGE: number;
+export declare const DOCUMENT_INTEGRITY_NOTE: number;
+export declare const DOCUMENT_INTEGRITY_PARAGRAPH_IDENTITY: number;
+export declare const DOCUMENT_INTEGRITY_TABLE_ROW_IDENTITY: number;
+export type DocumentIntegrityFeature = typeof DOCUMENT_INTEGRITY_BOOKMARK | typeof DOCUMENT_INTEGRITY_FIELD | typeof DOCUMENT_INTEGRITY_IMAGE | typeof DOCUMENT_INTEGRITY_NOTE | typeof DOCUMENT_INTEGRITY_PARAGRAPH_IDENTITY | typeof DOCUMENT_INTEGRITY_TABLE_ROW_IDENTITY;
+export declare function documentHasIntegrityFeature(document: ProseMirrorNode, feature: DocumentIntegrityFeature): boolean;
+/**
+ * Seeds only parser-authenticated chunk hints. Edited chunks are new
+ * ProseMirror nodes and therefore fall back to a real subtree scan.
+ */
+export declare function primeDocumentIntegrityFeatures(document: ProseMirrorNode): void;

package/dist/internal/features/work/work-document-lazy-block.d.ts

@@ -0,0 +1,3 @@
+import { Node } from '@tiptap/core';
+/** Internal equal-size placeholder used only by the large DOCX editor source. */
+export declare const DocumentLazyBlock: Node<any, any>;

package/dist/internal/features/work/work-document-lazy-html.d.ts

@@ -0,0 +1,21 @@
+import type { WorkDocumentNode } from './work-types';
+export type DocumentLazyHtmlTablePart = 'complete' | 'first' | 'middle' | 'last';
+export interface DocumentLazyHtmlRange {
+    from: number;
+    id: string;
+    tablePart: DocumentLazyHtmlTablePart | null;
+    to: number;
+}
+export interface DocumentLazyHtmlProjection {
+    html: string;
+    orderedRanges: DocumentLazyHtmlRange[];
+    ranges: ReadonlyMap<string, DocumentLazyHtmlRange>;
+}
+/**
+ * Indexes canonical HTML without copying its chunk strings. This projection is
+ * available only for the parser-authenticated paragraph/table subset.
+ */
+export declare function createDocumentLazyHtmlProjection(html: string, root: WorkDocumentNode): DocumentLazyHtmlProjection | null;
+export declare function patchDocumentLazyHtmlProjection(projection: DocumentLazyHtmlProjection, replacements: ReadonlyMap<string, string>): string | null;
+export declare function documentLazyHtmlProjectionFingerprint(projection: DocumentLazyHtmlProjection): string | null;
+export declare function documentLazyHtmlChunkFragment(html: string, tablePart: DocumentLazyHtmlTablePart | null): string | null;

package/dist/internal/features/work/work-document-lazy-model.d.ts

@@ -0,0 +1,29 @@
+import type { WorkDocumentModel, WorkDocumentNode } from './work-types';
+import { type DocumentLazyHtmlProjection } from './work-document-lazy-html';
+export declare const DOCUMENT_LAZY_BLOCK_NODE = "documentLazyBlock";
+export declare const DOCUMENT_LAZY_INITIAL_CHUNK_COUNT = 2;
+export declare const DOCUMENT_LAZY_POSITION_BOUNDARY = "\uFFFC";
+export interface PreparedLazyDocumentEditorSource {
+    lazyChunkCount: number;
+    payloads: ReadonlyMap<string, readonly WorkDocumentNode[]>;
+    root: WorkDocumentNode;
+}
+/**
+ * Builds a compact editor-only projection for parser-authenticated plain DOCX
+ * models. Every lazy leaf retains the exact node size and text offsets of its
+ * complete subtree, while the canonical WorkDocumentModel remains untouched.
+ */
+export declare function prepareLazyDocumentEditorSource(model: WorkDocumentModel, allowCreate: boolean, html?: string): PreparedLazyDocumentEditorSource | null;
+export declare function documentLazyHtmlProjection(model: WorkDocumentModel | null | undefined): DocumentLazyHtmlProjection | null;
+export declare function invalidateDocumentLazyHtmlProjection(model: WorkDocumentModel | null | undefined): void;
+export declare function documentLazyChunkContent(model: WorkDocumentModel | null | undefined, chunkId: string): readonly WorkDocumentNode[] | null;
+/**
+ * Replaces editor-only lazy blocks with their canonical structured payloads.
+ * Hydrated leaves update the payload registry so subsequent remounts retain
+ * user edits without forcing every untouched subtree through ProseMirror.
+ */
+export declare function materializeLazyDocumentEditorRoot(root: WorkDocumentNode, model: WorkDocumentModel | null | undefined): WorkDocumentNode;
+/** Keeps the process-local lazy payload registry across controlled revisions. */
+export declare function transferLazyDocumentModelState(previous: WorkDocumentModel | null | undefined, next: WorkDocumentModel): void;
+export declare function documentNodeUsesLazyPayload(node: WorkDocumentNode): boolean;
+export declare function simpleDocumentNodeSize(node: WorkDocumentNode): number | null;

package/dist/internal/features/work/work-document-lazy-pagination-measurement.d.ts

@@ -0,0 +1,3 @@
+import type { MeasuredDocumentLayoutBlock } from './work-document-pagination-types';
+import type { WorkDocumentNode } from './work-types';
+export declare function estimateLazyDocumentLayoutBlocks(nodes: readonly WorkDocumentNode[], element: HTMLElement, chunkId: string, firstPosition: number): MeasuredDocumentLayoutBlock[];

package/dist/internal/features/work/work-document-lazy-preview.d.ts

@@ -0,0 +1,21 @@
+import type { WorkDocumentNode } from './work-types';
+export interface DocumentLazyPreviewLease {
+    nodes: readonly HTMLElement[];
+    shape: string;
+    spacer: HTMLElement;
+}
+export interface DocumentLazyPreviewPool {
+    available: Map<string, DocumentLazyPreviewLease[]>;
+    size: number;
+}
+export declare function createDocumentLazyPreviewPool(): DocumentLazyPreviewPool;
+/**
+ * Mounts a compact preview while recycling its element tree across chunks with
+ * the same schema shape. Text and logical positions are rebound in place, so a
+ * long scroll does not leave tens of thousands of detached nodes for V8 to
+ * reclaim.
+ */
+export declare function mountDocumentLazyPreview(pool: DocumentLazyPreviewPool, dom: HTMLElement, content: readonly WorkDocumentNode[], firstPosition: number, paginationExtraHeight: number): DocumentLazyPreviewLease;
+export declare function releaseDocumentLazyPreview(pool: DocumentLazyPreviewPool, dom: HTMLElement, lease: DocumentLazyPreviewLease | null): void;
+export declare function updateDocumentLazyPreviewSpacer(lease: DocumentLazyPreviewLease | null, height: number): void;
+export declare function documentLazyPreviewPointerPosition(event: Event, fallback: number): number | null;

package/dist/internal/features/work/work-document-lazy-update.d.ts

@@ -0,0 +1,14 @@
+import type { Node as ProseMirrorNode } from '@tiptap/pm/model';
+import type { WorkDocumentModel, WorkDocumentNode } from './work-types';
+export interface MaterializedLazyDocumentUpdate {
+    html: string | null;
+    htmlFingerprint: string | null;
+    root: WorkDocumentNode;
+}
+/**
+ * Materializes the complete controlled model and patches canonical HTML from
+ * small changed chunks when the transaction only edits plain text.
+ */
+export declare function materializeLazyDocumentUpdate(previousDocument: ProseMirrorNode, nextDocument: ProseMirrorNode, compactRoot: WorkDocumentNode, model: WorkDocumentModel): MaterializedLazyDocumentUpdate;
+/** Carries cached document statistics across a parser-authenticated text edit. */
+export declare function transferLazyDocumentTextStatistics(previousDocument: ProseMirrorNode, nextDocument: ProseMirrorNode): boolean;

package/dist/internal/features/work/work-document-model.d.ts

@@ -1,5 +1,22 @@
 import type { WorkDocumentContent, WorkDocumentModel, WorkDocumentNode } from './work-types';
+export { documentHtmlFingerprint } from './work-document-html-fingerprint';
+interface SchemaValidatedDocumentModelOptions {
+    initialIntegrityFeatures?: number;
+    previous?: WorkDocumentModel | null;
+}
 export declare function createWorkDocumentModel(html: string, root: WorkDocumentNode, previous?: WorkDocumentModel | null): WorkDocumentModel;
+/**
+ * Creates a model for a root assembled by a schema-constrained parser. The
+ * trust record is process-local and is lost across cloning or persistence, so
+ * external snapshots still receive the complete structural validation.
+ */
+export declare function createSchemaValidatedWorkDocumentModel(html: string, root: WorkDocumentNode, options?: SchemaValidatedDocumentModelOptions): WorkDocumentModel;
+/**
+ * Records a root emitted by the live TipTap schema without rescanning up to two
+ * million JSON nodes on the next controlled render.
+ */
+export declare function createSchemaDerivedWorkDocumentModel(html: string, root: WorkDocumentNode, previous?: WorkDocumentModel | null, htmlFingerprint?: string): WorkDocumentModel;
+export declare function documentModelHasTrustedInitialIntegrityFeatures(model: WorkDocumentModel | null): boolean;
 export declare function documentModelForContent(content: WorkDocumentContent): WorkDocumentModel | null;
 export declare function documentModelForHtml(candidate: unknown, html: string): WorkDocumentModel | null;
 export interface WorkDocumentEditorInput {
@@ -8,5 +25,4 @@ export interface WorkDocumentEditorInput {
     sourceKey: string;
     revision: number;
 }
-export declare function resolveWorkDocumentEditorInput(content: WorkDocumentContent, fallbackHtml: string): WorkDocumentEditorInput;
-export declare function documentHtmlFingerprint(html: string): string;
+export declare function resolveWorkDocumentEditorInput(content: WorkDocumentContent, fallbackHtml: string, validatedModel?: WorkDocumentModel | null): WorkDocumentEditorInput;

package/dist/internal/features/work/work-document-page-surface-registry.d.ts

@@ -0,0 +1,16 @@
+import type { WorkSpreadsheetPaperSize } from './work-types';
+export interface RegisteredDocumentPageSurfaceFrame {
+    height: number;
+    left: number;
+    orientation: 'landscape' | 'portrait';
+    pageHeightPoints: number;
+    pageIndex: number;
+    pageSize: WorkSpreadsheetPaperSize;
+    pageWidthPoints: number;
+    top: number;
+    width: number;
+}
+type DocumentPageSurfaceProvider = () => readonly RegisteredDocumentPageSurfaceFrame[];
+export declare function registerDocumentPageSurfaceGeometry(element: HTMLElement, provider: DocumentPageSurfaceProvider): () => void;
+export declare function documentPageSurfaceGeometryForElement(element: HTMLElement): readonly RegisteredDocumentPageSurfaceFrame[] | null;
+export {};

package/dist/internal/features/work/work-document-pagination-dom.d.ts

@@ -4,6 +4,7 @@ import type { OfficeKernelLayoutBlock } from '../../kernel/office-kernel-protoco
 import type { MeasuredDocumentLayoutBlock } from './work-document-pagination-types';
 import type { WorkDocumentSectionLayout } from './work-types';
 export declare function reusableDocumentLayoutBlocks(previous: readonly MeasuredDocumentLayoutBlock[], blockId: string, element: HTMLElement, nodeTo: number, dirtyFrom: number): MeasuredDocumentLayoutBlock[];
+export declare function reusableDocumentChunkLayoutBlocks(previous: readonly MeasuredDocumentLayoutBlock[], element: HTMLElement, chunkFrom: number, chunkTo: number, dirtyFrom: number): MeasuredDocumentLayoutBlock[];
 export declare function isDocumentListNode(node: ProseMirrorNode): boolean;
 export declare function documentListChildId(listId: string, itemIndex: number, node: ProseMirrorNode, childIndex: number, nestedList?: boolean): string;
 export declare function verticalBlockStart(style: CSSStyleDeclaration): number;

package/dist/internal/features/work/work-document-pagination-types.d.ts

@@ -86,6 +86,7 @@ export interface DocumentPaginationSnapshot {
     pageStyles: OfficeKernelPageStyle[];
     measuredBlockCount: number;
     reusedBlockCount: number;
+    reusedPrefixBlockCount: number;
     unsupportedLayout: boolean;
 }
 export interface DocumentTextLayoutCollection {

package/dist/internal/features/work/work-document-pagination.d.ts

@@ -1,7 +1,7 @@
 import { Extension } from '@tiptap/core';
 import type { DocumentPaginationVisualBreak } from './work-document-pagination-types';
 export { createDocumentLineFragments, createShapedDocumentLineFragments, findDocumentLineStartOffset, } from './work-document-line-measurement';
-export { reusableDocumentLayoutBlocks } from './work-document-pagination-dom';
+export { reusableDocumentChunkLayoutBlocks, reusableDocumentLayoutBlocks, } from './work-document-pagination-dom';
 export { documentPageBodyHeight, documentPageMetrics, documentPaginationSurfaceHeight, measureDocumentLayoutBlocks, measureDocumentLayoutBlocksIncrementally, } from './work-document-pagination-measurement';
 export type { IncrementalDocumentLayoutMeasurementOptions } from './work-document-pagination-measurement';
 export type { DocumentPaginationSection, DocumentPaginationSnapshot, DocumentPaginationVisualBreak, DocumentPaginationVisualPageChrome, DocumentTableCellBoundary, DocumentTableCellFragmentMeasurement, DocumentTableCellPageBreak, DocumentTablePaginationBreak, DocumentTableRowFragmentPlan, DocumentTextLayoutCollection, MeasuredDocumentLayoutBlock, } from './work-document-pagination-types';

package/dist/internal/features/work/work-document-text-statistics.d.ts

@@ -0,0 +1,25 @@
+import type { Editor } from '@tiptap/core';
+import type { Node as ProseMirrorNode } from '@tiptap/pm/model';
+export interface DocumentTextStatistics {
+    characterCountWithSpaces: number;
+    characterCountWithoutSpaces: number;
+    paragraphCount: number;
+    wordCount: number;
+}
+export declare function documentWordCount(value: string): number;
+/**
+ * Counts a document once per immutable ProseMirror root. Selection, pagination,
+ * and viewport transactions retain the same root and therefore stay O(1).
+ */
+export declare function documentTextStatistics(editor: Pick<Editor, 'getText' | 'state'>): DocumentTextStatistics;
+/** Keeps logical statistics unchanged across equal-size lazy hydration. */
+export declare function transferDocumentTextStatistics(previous: ProseMirrorNode, next: ProseMirrorNode): void;
+/**
+ * Applies text-only subtree deltas to an already cached document total. Large
+ * lazy documents edit one hydrated chunk at a time, so recounting every
+ * placeholder tape would make a local keystroke O(document size).
+ */
+export declare function transferChangedDocumentTextStatistics(previous: ProseMirrorNode, next: ProseMirrorNode, changes: readonly {
+    after: ProseMirrorNode;
+    before: ProseMirrorNode;
+}[]): boolean;

package/dist/internal/features/work/work-document-windowing.d.ts

@@ -0,0 +1,23 @@
+import type { WorkDocumentNode } from './work-types';
+export declare const DOCUMENT_WINDOW_BLOCK_SIZE = 128;
+export declare const DOCUMENT_WINDOW_BLOCK_THRESHOLD = 2048;
+export declare const DOCUMENT_TABLE_WINDOW_ROW_SIZE = 16;
+export declare const DOCUMENT_TABLE_WINDOW_ROW_THRESHOLD = 512;
+export interface DocumentWindowingOptions {
+    blockSize: number;
+    blockThreshold: number;
+    tableRowSize: number;
+    tableRowThreshold: number;
+    trustedIntegrityFeatures?: number;
+}
+/**
+ * Adds stable semantic chunks to large section bodies. The complete
+ * ProseMirror model remains in memory, while the chunk node view can omit
+ * descendants outside the visible viewport without changing positions.
+ */
+export declare function windowDocumentModel(root: WorkDocumentNode, requested?: Partial<DocumentWindowingOptions>): WorkDocumentNode;
+/** Restores the canonical schema used by controlled HTML and DOCX export. */
+export declare function materializeWindowedDocumentModel(root: WorkDocumentNode): WorkDocumentNode;
+export declare function documentModelUsesWindowing(root: WorkDocumentNode): boolean;
+export declare function estimateDocumentNodeHeight(node: WorkDocumentNode): number;
+export declare function estimateDocumentTableRowHeight(row: WorkDocumentNode): number;

package/dist/internal/features/work/work-docx-import.d.ts

@@ -21,6 +21,7 @@ import { type ImportedDocxParagraphTabStopMarkers } from './work-docx-tab-stop-i
 import { type ImportedDocxTableCellMarkers } from './work-docx-table-cell-import';
 import { type ImportedDocxTableRowMarkers } from './work-docx-table-row-import';
 import { type ImportedDocxTableSizingMarkers } from './work-docx-table-sizing-import';
+import { OoxmlPackage } from './work-ooxml-package';
 import type { WorkDocumentContent, WorkDocumentSectionLayout } from './work-types';
 type ImportedDocumentLayout = Omit<WorkDocumentContent, 'type' | 'html'>;
 export interface PreparedDocxImport {
@@ -56,7 +57,7 @@ export interface PreparedDocxImport {
     bibliography?: WorkDocumentContent['bibliography'];
     trackChanges: boolean;
 }
-export declare function prepareDocxImport(buffer: ArrayBuffer): Promise<PreparedDocxImport>;
+export declare function prepareDocxImport(buffer: ArrayBuffer, sourcePackage?: OoxmlPackage): Promise<PreparedDocxImport>;
 export declare function applyDocxSectionsToHtml(html: string, sections: PreparedDocxImport['sections'], captionMarkers?: ImportedDocxCaptionMarkers, bookmarkMarkers?: ImportedDocxBookmarkMarkers, changeMarkers?: ImportedDocxChangeMarkers, commentMarkers?: ImportedDocxCommentMarkers, fieldMarkers?: ImportedDocxFieldMarkers, equationMarkers?: ImportedDocxEquationMarkers, citationMarkers?: ImportedDocxCitationMarkers, listMarkers?: ImportedDocxListMarkers, imageLayoutMarkers?: ImportedDocxImageLayoutMarkers, paragraphIdentityMarkers?: ImportedDocxParagraphIdentityMarkers, paragraphFormattingChangeMarkers?: ImportedDocxParagraphFormattingChangeMarkers, paragraphAlignmentMarkers?: ImportedDocxParagraphAlignmentMarkers, runFormattingMarkers?: ImportedDocxRunFormattingMarkers, paragraphDirectionMarkers?: ImportedDocxParagraphDirectionMarkers, paragraphIndentMarkers?: ImportedDocxParagraphIndentMarkers, paragraphSpacingMarkers?: ImportedDocxParagraphSpacingMarkers, paragraphBorderMarkers?: ImportedDocxParagraphBorderMarkers, paragraphShadingMarkers?: ImportedDocxParagraphShadingMarkers, paragraphPaginationMarkers?: ImportedDocxParagraphPaginationMarkers, bibliography?: WorkDocumentContent['bibliography'], tabStopMarkers?: ImportedDocxParagraphTabStopMarkers, tableCellMarkers?: ImportedDocxTableCellMarkers, tableRowMarkers?: ImportedDocxTableRowMarkers, tableSizingMarkers?: ImportedDocxTableSizingMarkers): string;
 export declare function readDocxLayout(buffer: ArrayBuffer): Promise<ImportedDocumentLayout>;
 export {};

package/dist/internal/features/work/work-docx-large-document-import.d.ts

@@ -0,0 +1,35 @@
+import { type LargeSimpleDocxParseOptions, type LargeSimpleDocxStreamResult, type LargeSimpleDocxTableRow } from './work-docx-large-document-parser';
+import type { OoxmlPackage } from './work-ooxml-package';
+import type { WorkCompatibilityReport, WorkDocumentContent, WorkDocumentNode, WorkDocumentSectionLayout } from './work-types';
+export { LARGE_SIMPLE_DOCX_MINIMUM_LOGICAL_BLOCKS, simpleDocxXmlIsEligibleForLargeImport, streamLargeSimpleDocxDocumentXml, } from './work-docx-large-document-parser';
+export type { LargeSimpleDocxParseOptions, LargeSimpleDocxStreamResult, LargeSimpleDocxStreamSink, } from './work-docx-large-document-parser';
+export interface LargeSimpleDocxParseResult {
+    html: string;
+    layout: WorkDocumentSectionLayout;
+    logicalBlockCount: number;
+    paragraphCount: number;
+    root: WorkDocumentNode;
+    tableRowCount: number;
+}
+export declare function parseLargeSimpleDocxPackage(archive: OoxmlPackage, options?: LargeSimpleDocxParseOptions): Promise<LargeSimpleDocxParseResult | null>;
+export declare function largeSimpleDocxPackageIsCandidate(archive: OoxmlPackage): boolean;
+/**
+ * A deliberately narrow fast path for huge, plain WordprocessingML bodies.
+ * Any rich feature routes to the complete Mammoth plus OOXML marker pipeline.
+ */
+export declare function parseLargeSimpleDocxDocumentXml(source: string, options?: LargeSimpleDocxParseOptions): LargeSimpleDocxParseResult | null;
+export declare function createLargeSimpleDocxParseResult(streamed: LargeSimpleDocxStreamResult, blocks: WorkDocumentNode[], html: string[], options?: LargeSimpleDocxParseOptions): LargeSimpleDocxParseResult;
+export declare function createLargeSimpleDocxTable(rows: WorkDocumentNode[], htmlRows: string[]): {
+    html: string;
+    node: WorkDocumentNode;
+};
+export declare function createLargeSimpleDocxParagraph(text: string): {
+    html: string;
+    node: WorkDocumentNode;
+};
+export declare function createLargeSimpleDocxTableRow(row: LargeSimpleDocxTableRow): {
+    html: string;
+    node: WorkDocumentNode;
+};
+export declare function largeSimpleDocxContent(result: LargeSimpleDocxParseResult): WorkDocumentContent;
+export declare function largeSimpleDocxCompatibilityReport(file: File, result: LargeSimpleDocxParseResult): WorkCompatibilityReport;

package/dist/internal/features/work/work-docx-large-document-parser.d.ts

@@ -0,0 +1,29 @@
+import type { DocumentWindowingOptions } from './work-document-windowing';
+import type { WorkDocumentSectionLayout } from './work-types';
+export declare const LARGE_SIMPLE_DOCX_MINIMUM_LOGICAL_BLOCKS = 20000;
+export interface LargeSimpleDocxParseOptions {
+    minimumLogicalBlocks?: number;
+    windowing?: Partial<DocumentWindowingOptions>;
+}
+export interface LargeSimpleDocxStreamResult {
+    layout: WorkDocumentSectionLayout;
+    logicalBlockCount: number;
+    paragraphCount: number;
+    tableRowCount: number;
+}
+export interface LargeSimpleDocxStreamSink {
+    paragraph: (text: string) => void;
+    tableEnd: () => void;
+    tableRow: (row: LargeSimpleDocxTableRow) => void;
+    tableStart: () => void;
+}
+export interface LargeSimpleDocxTableRow {
+    cellParagraphCounts: readonly number[];
+    texts: readonly string[];
+}
+/**
+ * Parses logical blocks into a sink so a Worker can stream bounded batches
+ * instead of structured-cloning one complete 100,000-row object graph.
+ */
+export declare function streamLargeSimpleDocxDocumentXml(source: string, options: LargeSimpleDocxParseOptions, sink: LargeSimpleDocxStreamSink): LargeSimpleDocxStreamResult | null;
+export declare function simpleDocxXmlIsEligibleForLargeImport(source: string, minimumLogicalBlocks?: number): boolean;

package/dist/internal/features/work/work-file-data.d.ts

@@ -1 +1,7 @@
-export declare function materializeWorkFile(file: File): Promise<File>;
+import { WorkFileImportController } from './work-file-import';
+export interface MaterializedWorkFile {
+    bytes: ArrayBuffer;
+    file: File;
+}
+export declare function materializeWorkFile(file: File, controller?: WorkFileImportController): Promise<File>;
+export declare function materializeWorkFileSource(file: File, controller: WorkFileImportController): Promise<MaterializedWorkFile>;

package/dist/internal/features/work/work-file-import.d.ts

@@ -0,0 +1,33 @@
+export type WorkFileImportStage = 'reading' | 'parsing' | 'analyzing' | 'finalizing';
+export interface WorkFileImportProgress {
+    stage: WorkFileImportStage;
+    stageProgress: number;
+    progress: number;
+    bytesRead: number;
+    totalBytes: number;
+}
+export interface WorkFileImportOptions {
+    /** Reuses a host-reserved identity so an editor shell can mount in parallel. */
+    artifactId?: string;
+    /** Reuses host-reserved worksheet identities during a spreadsheet import. */
+    spreadsheetSheetIds?: readonly string[];
+    signal?: AbortSignal;
+    onProgress?: (progress: WorkFileImportProgress) => void;
+}
+export interface WorkFileImportContext {
+    bytes: ArrayBuffer;
+    controller: WorkFileImportController;
+    spreadsheetSheetIds?: readonly string[];
+}
+export declare class WorkFileImportController {
+    private readonly options;
+    readonly totalBytes: number;
+    private progress;
+    constructor(options: WorkFileImportOptions, totalBytes: number);
+    get signal(): AbortSignal | undefined;
+    throwIfAborted(): void;
+    report(stage: WorkFileImportStage, stageProgress: number, bytesRead?: number): void;
+    checkpoint(stage: WorkFileImportStage, stageProgress: number): Promise<void>;
+    yieldToMainThread(): Promise<void>;
+    complete(): void;
+}

package/dist/internal/features/work/work-file-io.d.ts

@@ -1,8 +1,9 @@
-export { WORK_IMPORT_ACCEPT } from './work-file-contract';
+import { type WorkFileImportOptions } from './work-file-import';
 import { type WorkPresentationExportOptions } from './work-presentation-file-io';
-import { type WorkArtifact, type WorkArtifactKind } from './work-types';
+import { type WorkArtifact } from './work-types';
+export { WORK_IMPORT_ACCEPT } from './work-file-contract';
 export type WorkArtifactExportOptions = WorkPresentationExportOptions;
-export declare function importWorkFile(file: File): Promise<WorkArtifact>;
+export declare function importWorkFile(file: File, options?: WorkFileImportOptions): Promise<WorkArtifact>;
 export declare function exportWorkArtifact(artifact: WorkArtifact, options?: WorkArtifactExportOptions): Promise<void>;
 export declare function createWorkArtifactBlob(artifact: WorkArtifact, options?: WorkArtifactExportOptions): Promise<Blob>;
-export declare function workKindForFile(file: File): WorkArtifactKind | null;
+export { workKindForFile } from './work-file-kind';

package/dist/internal/features/work/work-file-kind.d.ts

@@ -0,0 +1,5 @@
+import type { WorkArtifactKind } from './work-types';
+export declare const WORK_SUPPORTED_FILE_EXTENSIONS: readonly string[];
+export declare function workFileExtension(fileName: string): string;
+export declare function workKindForFileName(fileName: string): WorkArtifactKind | null;
+export declare function workKindForFile(file: Pick<File, 'name'>): WorkArtifactKind | null;