@a3s-lab/office 0.12.0 → 0.13.1

package/dist/internal/features/work/editors/spreadsheet-command-controller.d.ts

@@ -1,13 +1,18 @@
 import type { Cell, Selection, Sheet } from '@fortune-sheet/core';
+import { type SpreadsheetGridSize } from '../spreadsheet-sparse';
 import type { WorkSpreadsheetContent } from '../work-types';
 import { type OfficeEditorCanCommands, type OfficeEditorExtension } from './office-editor-extension';
 import { type SpreadsheetCellClearMode } from './spreadsheet-cell-clear';
+import type { SpreadsheetCellBorderFormat } from './spreadsheet-cell-border';
+import type { SpreadsheetCellStyleChoice } from './spreadsheet-cell-style';
+import type { SpreadsheetCellFillDirection } from './spreadsheet-cell-fill';
 import { type SpreadsheetCellMergeCommand } from './spreadsheet-cell-merge';
-import { type SpreadsheetFreezePanePreset } from './spreadsheet-freeze-panes';
 import type { SpreadsheetFormatPainterMode } from './spreadsheet-format-painter';
+import { type SpreadsheetFreezePanePreset } from './spreadsheet-freeze-panes';
 import { type SpreadsheetKeyboardSelection, type SpreadsheetSelectionMove, type SpreadsheetSelectionScope } from './spreadsheet-keyboard-navigation';
 import { type SpreadsheetSheetMoveDirection } from './spreadsheet-sheet-model';
 export interface SpreadsheetWorkbookCommandPort {
+    autoFillCell: (copyRange: SpreadsheetCommandRange, applyRange: SpreadsheetCommandRange, direction: SpreadsheetCellFillDirection) => void;
     batchCallApis: (apiCalls: Array<{
         name: string;
         args: unknown[];
@@ -22,9 +27,6 @@ export interface SpreadsheetWorkbookCommandPort {
     insertRowOrColumn: (type: SpreadsheetStructureAxis, index: number, count: number, direction: 'lefttop' | 'rightbottom', options?: {
         id?: string;
     }) => void;
-    deleteRowOrColumn: (type: SpreadsheetStructureAxis, start: number, end: number, options?: {
-        id?: string;
-    }) => void;
     hideRowOrColumn: (rowOrColumnInfo: string[], type: SpreadsheetStructureAxis) => void;
     showRowOrColumn: (rowOrColumnInfo: string[], type: SpreadsheetStructureAxis) => void;
     setCellValuesByRange: (values: unknown[][], range: SpreadsheetCommandRange, options?: {
@@ -103,6 +105,7 @@ export interface SpreadsheetEditorCommands {
     activateSheet: (sheetId: string) => boolean;
     activateFormatPainter: (mode: SpreadsheetFormatPainterMode) => boolean;
     addSheet: () => boolean;
+    applyCellStyle: (preset: SpreadsheetCellStyleChoice) => boolean;
     applyFormatPainter: (target: SpreadsheetCommandSelection) => boolean;
     cancelFormatPainter: () => boolean;
     clearSelectedCells: (mode?: SpreadsheetCellClearMode) => boolean;
@@ -111,6 +114,7 @@ export interface SpreadsheetEditorCommands {
     deleteSelectedStructure: (axis: SpreadsheetStructureAxis) => boolean;
     deleteSheet: (sheetId: string) => boolean;
     duplicateSheet: (sheetId: string) => boolean;
+    fillSelectedCells: (direction: SpreadsheetCellFillDirection) => boolean;
     hideSheet: (sheetId: string) => boolean;
     insertSelectedStructure: (axis: SpreadsheetStructureAxis, position: SpreadsheetStructureInsertPosition) => boolean;
     mergeSelectedCells: (command: SpreadsheetCellMergeCommand) => boolean;
@@ -123,6 +127,7 @@ export interface SpreadsheetEditorCommands {
     renameSheet: (sheetId: string, name: string) => boolean;
     redo: () => boolean;
     setCellFormat: (attribute: keyof Cell, value: unknown) => boolean;
+    setSelectedCellBorders: (format: SpreadsheetCellBorderFormat) => boolean;
     setFreezePanes: (preset: SpreadsheetFreezePanePreset) => boolean;
     setGridLines: (visible: boolean) => boolean;
     selectCellRange: (scope: SpreadsheetSelectionScope) => boolean;
@@ -149,6 +154,7 @@ export interface SpreadsheetCommandContext {
     history: SpreadsheetHistoryCommandPort | null;
     onChange: (content: WorkSpreadsheetContent) => void;
     selection: SpreadsheetCommandSelection | null;
+    targetSheetGridSize?: SpreadsheetGridSize | null;
     targetSheetId: string;
     toolbarCell: Cell | null;
     view: SpreadsheetViewCommandPort | null;

package/dist/internal/features/work/editors/spreadsheet-editor-ribbon.d.ts

@@ -1,12 +1,13 @@
 import type { Cell, Selection } from '@fortune-sheet/core';
 import type { WorkSpreadsheetContent } from '../work-types';
+import type { SpreadsheetResolvedCellBorders } from './spreadsheet-cell-border';
 import { type SpreadsheetRibbonTabId } from './spreadsheet-command-catalog';
 import type { SpreadsheetEditorCanCommands, SpreadsheetEditorCommands } from './spreadsheet-command-controller';
 import type { SpreadsheetFormatPainterMode } from './spreadsheet-format-painter';
 import type { SpreadsheetWorkbookPanelView } from './spreadsheet-workbook-panel';
 import { type WorkOfficeFileAction } from './work-office-chrome';
 export type { SpreadsheetRibbonTabId } from './spreadsheet-command-catalog';
-export declare function SpreadsheetEditorRibbon({ activeTab, autoFilterActive, can, commands, content, fileActions, findOpen, formatPainterMode, freezePanesActive, freezePanesSelection, gridLinesVisible, panelId, onOpenFind, onTabChange, onTogglePanel, panel, toolbarCell, }: {
+export declare function SpreadsheetEditorRibbon({ activeTab, autoFilterActive, can, commands, content, fileActions, findOpen, formatPainterMode, freezePanesActive, freezePanesSelection, gridLinesVisible, panelId, onOpenFind, onTabChange, onTogglePanel, panel, toolbarCell, toolbarCellBorders, }: {
     activeTab: SpreadsheetRibbonTabId;
     autoFilterActive?: boolean;
     can: SpreadsheetEditorCanCommands;
@@ -24,4 +25,5 @@ export declare function SpreadsheetEditorRibbon({ activeTab, autoFilterActive, c
     onTogglePanel: (panel: SpreadsheetWorkbookPanelView, trigger: HTMLButtonElement) => void;
     panel: SpreadsheetWorkbookPanelView | null;
     toolbarCell: Cell | null | undefined;
+    toolbarCellBorders?: SpreadsheetResolvedCellBorders;
 }): import("react").JSX.Element;

package/dist/internal/features/work/editors/spreadsheet-editor-support.d.ts

@@ -1,4 +1,4 @@
-import type { Cell, Selection } from '@fortune-sheet/core';
+import type { Cell, Op, Selection } from '@fortune-sheet/core';
 import type { WorkSpreadsheetContent } from '../work-types';
 import type { OfficeSelectOption } from './office-select';
 export interface SpreadsheetSelectionSummary {
@@ -21,9 +21,15 @@ export declare function spreadsheetFontSizeOptions(current: number | undefined):
 export declare function spreadsheetFontFamilyOptions(current: string | undefined): OfficeSelectOption[];
 export declare function spreadsheetSheetsWithFiniteSelections(sheets: WorkSpreadsheetContent['sheets']): WorkSpreadsheetContent['sheets'];
 export declare function spreadsheetSheetsForFortune(sheets: WorkSpreadsheetContent['sheets']): WorkSpreadsheetContent['sheets'];
-export declare function spreadsheetSheetsFromFortune(sheets: WorkSpreadsheetContent['sheets'], sourceSheets: WorkSpreadsheetContent['sheets']): WorkSpreadsheetContent['sheets'];
+export declare function spreadsheetSheetsFromFortune(sheets: WorkSpreadsheetContent['sheets'], sourceSheets: WorkSpreadsheetContent['sheets'], operations?: readonly Op[]): WorkSpreadsheetContent['sheets'];
 export declare function finiteSpreadsheetSelection(selection: Selection | undefined): Selection;
 export declare function sameSpreadsheetWorkbookState(changed: WorkSpreadsheetContent['sheets'], rendered: WorkSpreadsheetContent['sheets']): boolean;
+/**
+ * Answers the workbook equality check from Fortune's exact operation batch
+ * without walking unrelated matrix cells. A null result requires the legacy
+ * full comparison because the batch is missing or too broad to prove safely.
+ */
+export declare function sameSpreadsheetWorkbookStateAfterOperations(changed: WorkSpreadsheetContent['sheets'], rendered: WorkSpreadsheetContent['sheets'], operations: readonly Op[]): boolean | null;
 export declare function sameSpreadsheetHistoryContent(left: WorkSpreadsheetContent, right: WorkSpreadsheetContent): boolean;
 export declare function spreadsheetContentWithSelection(content: WorkSpreadsheetContent, sheetId: string, selection: Selection | null | undefined): WorkSpreadsheetContent;
 export declare function isSpreadsheetNativeTextUndoTarget(target: EventTarget | null): boolean;

package/dist/internal/features/work/editors/spreadsheet-home-format-ribbon.d.ts

@@ -0,0 +1,10 @@
+import type { Cell } from '@fortune-sheet/core';
+import type { SpreadsheetEditorCanCommands, SpreadsheetEditorCommands } from './spreadsheet-command-controller';
+interface SpreadsheetHomeFormatRibbonProps {
+    can: SpreadsheetEditorCanCommands;
+    commands: SpreadsheetEditorCommands;
+    toolbarCell: Cell | null | undefined;
+}
+export declare function SpreadsheetFontRibbonGroup({ can, commands, toolbarCell, }: SpreadsheetHomeFormatRibbonProps): import("react").JSX.Element;
+export declare function SpreadsheetNumberRibbonGroup({ can, commands, toolbarCell, }: SpreadsheetHomeFormatRibbonProps): import("react").JSX.Element;
+export {};

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

@@ -0,0 +1,10 @@
+import type { WorkbookInstance } from '@fortune-sheet/react';
+import type { WorkSpreadsheetContent } from '../work-types';
+type SpreadsheetWorkbookUpdateTarget = Pick<WorkbookInstance, 'updateSheet'>;
+/**
+ * Replaces only the data of an already-mounted, structurally simple workbook.
+ * Fortune keeps additional active-sheet state outside `luckysheetfile`, so
+ * richer workbook structures must continue through the remount path.
+ */
+export declare function synchronizeSpreadsheetWorkbookInPlace(workbook: SpreadsheetWorkbookUpdateTarget | null, previous: WorkSpreadsheetContent, next: WorkSpreadsheetContent, projectedSheets: WorkSpreadsheetContent['sheets'], preview: boolean): boolean;
+export {};

package/dist/internal/features/work/editors/spreadsheet-number-format.d.ts

@@ -1,6 +1,19 @@
 import type { Cell } from '@fortune-sheet/core';
-export type SpreadsheetNumberFormatPreset = 'general' | 'number' | 'percent' | 'custom';
-type SpreadsheetNumberFormatChoice = Exclude<SpreadsheetNumberFormatPreset, 'custom'>;
+export type SpreadsheetNumberFormatPreset = 'general' | 'number' | 'currency' | 'accounting' | 'percent' | 'date' | 'time' | 'scientific' | 'fraction' | 'text' | 'custom';
+export type SpreadsheetNumberFormatChoice = Exclude<SpreadsheetNumberFormatPreset, 'custom'>;
+export declare const spreadsheetNumberFormatPresetLabels: {
+    readonly general: "常规";
+    readonly number: "数字";
+    readonly currency: "货币";
+    readonly accounting: "会计专用";
+    readonly percent: "百分比";
+    readonly date: "短日期";
+    readonly time: "时间";
+    readonly scientific: "科学计数";
+    readonly fraction: "分数";
+    readonly text: "文本";
+    readonly custom: "自定义";
+};
 export declare function spreadsheetNumberFormatPreset(formatCode?: string): SpreadsheetNumberFormatPreset;
 export declare function spreadsheetNumberFormatCode(preset: SpreadsheetNumberFormatChoice): string;
 export declare function spreadsheetNumberFormatValue(formatCode: string, cell?: Cell | null): NonNullable<Cell['ct']> & {
@@ -8,4 +21,3 @@ export declare function spreadsheetNumberFormatValue(formatCode: string, cell?:
     t: string;
 };
 export declare function adjustSpreadsheetNumberFormat(formatCode: string | undefined, direction: -1 | 1): string;
-export {};

package/dist/internal/features/work/editors/spreadsheet-operation-projection.d.ts

@@ -0,0 +1,14 @@
+import type { Op } from '@fortune-sheet/core';
+import type { WorkSpreadsheetContent } from '../work-types';
+export declare const MAXIMUM_INCREMENTAL_SPREADSHEET_OPERATIONS = 10000;
+export interface SpreadsheetOperationProjection {
+    affectedCellCount: number;
+    sheets: WorkSpreadsheetContent['sheets'];
+}
+/**
+ * Reconciles a bounded Fortune operation batch against authenticated
+ * controlled matrices. Only the outer matrix and affected rows/cells are
+ * copied; structural or incomplete batches return null for the full-scan
+ * compatibility path.
+ */
+export declare function projectSpreadsheetSheetsFromFortuneOperations(sheets: WorkSpreadsheetContent['sheets'], sourceSheets: WorkSpreadsheetContent['sheets'], operations: readonly Op[]): SpreadsheetOperationProjection | null;

package/dist/internal/features/work/editors/spreadsheet-structure-selection.d.ts

@@ -0,0 +1,7 @@
+import type { SpreadsheetKeyboardSelection } from './spreadsheet-keyboard-navigation';
+/**
+ * Fortune clears its live selection after deleting rows or columns. Keep the
+ * user's selection on the structure that moved into the deleted range while
+ * clamping terminal deletions to the new grid boundary.
+ */
+export declare function spreadsheetSelectionAfterStructureDeletion(selection: SpreadsheetKeyboardSelection, axis: 'column' | 'row', extent: number, start: number, end: number): SpreadsheetKeyboardSelection;

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-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

@@ -1,5 +1,10 @@
-import type { CellMatrix } from '@fortune-sheet/core';
+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-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;