@univerjs/engine-render 1.0.0-insiders.20260813-7c9aa50 → 1.0.0

package/lib/types/components/docs/layout/block/column.d.ts

@@ -16,8 +16,23 @@
 import type { Nullable } from '@univerjs/core';
 import type { IDocumentSkeletonColumnGroup, IDocumentSkeletonPage } from '../../../../basics/i-document-skeleton-cached';
 import type { ISectionBreakConfig } from '../../../../basics/interfaces';
+import type { IDocumentLayoutColumnGroup } from '../../document-layout-presentation';
 import type { DataStreamTreeNode } from '../../view-model/data-stream-tree-node';
 import type { DocumentViewModel } from '../../view-model/document-view-model';
 import type { ILayoutContext } from '../tools';
+interface IColumnGroupLayoutColumn {
+    columnId: string;
+    left: number;
+    top: number;
+    width: number;
+}
+interface IColumnGroupLayout {
+    mode: 'horizontal' | 'stack';
+    width: number;
+    height: number;
+    columns: IColumnGroupLayoutColumn[];
+}
 export declare function createColumnGroupSkeleton(ctx: ILayoutContext, curPage: IDocumentSkeletonPage, viewModel: DocumentViewModel, columnGroupNode: DataStreamTreeNode, sectionBreakConfig: ISectionBreakConfig): Nullable<IDocumentSkeletonColumnGroup>;
 export declare function appendColumnGroupBlockLine(page: IDocumentSkeletonPage, columnGroup: IDocumentSkeletonColumnGroup): boolean;
+export declare function calculateColumnGroupLayout(source: IDocumentLayoutColumnGroup, availableWidth: number, columnHeights: number[]): IColumnGroupLayout;
+export {};

package/lib/types/components/docs/layout/block/paragraph/layout-ruler.d.ts

@@ -13,31 +13,40 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+import type { ITabStop } from '@univerjs/core';
 import type { IDocumentSkeletonColumn, IDocumentSkeletonDivide, IDocumentSkeletonDrawing, IDocumentSkeletonGlyph, IDocumentSkeletonLine, IDocumentSkeletonPage, IDocumentSkeletonSection, IDocumentSkeletonTable } from '../../../../../basics/i-document-skeleton-cached';
 import type { IParagraphConfig, IParagraphTableCache, ISectionBreakConfig } from '../../../../../basics/interfaces';
 import type { IFloatObject, ILayoutContext } from '../../tools';
 import { BooleanNumber, GridType, SpacingRule } from '@univerjs/core';
 import { BreakPointType } from '../../line-breaker/break';
-declare function isGlyphGroupBeyondDivideWidth(glyphGroup: IDocumentSkeletonGlyph[], offsetLeft: number, divideWidth: number, hangingPunctuation?: boolean): boolean;
-export declare function layoutParagraph(ctx: ILayoutContext, glyphGroup: IDocumentSkeletonGlyph[], pages: IDocumentSkeletonPage[], sectionBreakConfig: ISectionBreakConfig, paragraphConfig: IParagraphConfig, isParagraphFirstShapedText: boolean, breakPointType?: BreakPointType, renderBullet?: boolean): IDocumentSkeletonPage[];
-declare function _adjustExplicitTabStop(divide: IDocumentSkeletonDivide, followingGlyphs: IDocumentSkeletonGlyph[], paragraphConfig: IParagraphConfig): void;
+declare function isGlyphGroupBeyondDivideWidth(glyphGroup: IDocumentSkeletonGlyph[], offsetLeft: number, divideWidth: number, hangingPunctuation?: boolean, precedingGlyphs?: IDocumentSkeletonGlyph[], preserveWordSpacing?: boolean, lineWrapTolerance?: number, includeParagraphMark?: boolean, justifyWordSpacing?: boolean): boolean;
+export declare function layoutParagraph(ctx: ILayoutContext, glyphGroup: IDocumentSkeletonGlyph[], pages: IDocumentSkeletonPage[], sectionBreakConfig: ISectionBreakConfig, paragraphConfig: IParagraphConfig, isParagraphFirstShapedText: boolean, breakPointType?: BreakPointType, renderBullet?: boolean, startNewLine?: boolean): IDocumentSkeletonPage[];
+declare function _adjustExplicitTabStop(divide: IDocumentSkeletonDivide, followingGlyphs: IDocumentSkeletonGlyph[], paragraphConfig: IParagraphConfig, tabStops?: ITabStop[] | undefined): void;
+declare function __getWrapTablePosition(table: IDocumentSkeletonTable, column: IDocumentSkeletonColumn, lineTop: number, lineHeight: number, drawingAnchorTop?: number): {
+    left: number;
+    top: number;
+} | undefined;
 declare function __avoidFlowAffectingDrawingsForTable(table: IDocumentSkeletonTable, page: IDocumentSkeletonPage, column: IDocumentSkeletonColumn): void;
-declare function _updateAndPositionTable(ctx: ILayoutContext, lineTop: number, lineHeight: number, page: IDocumentSkeletonPage, column: IDocumentSkeletonColumn, section: IDocumentSkeletonSection, skeTablesInParagraph: IParagraphTableCache[], paragraphIndex: number, sectionBreakConfig: ISectionBreakConfig, drawingAnchorTop?: number): boolean;
+declare function __avoidNonOverlappingFloatingTables(table: IDocumentSkeletonTable, page: IDocumentSkeletonPage): void;
+declare function _updateAndPositionTable(ctx: ILayoutContext, lineTop: number, lineHeight: number, page: IDocumentSkeletonPage, pages: IDocumentSkeletonPage[], column: IDocumentSkeletonColumn, section: IDocumentSkeletonSection, skeTablesInParagraph: IParagraphTableCache[], paragraphIndex: number, sectionBreakConfig: ISectionBreakConfig, drawingAnchorTop?: number): boolean;
+export declare function isNonFlowFloatingAnchor(glyphGroup: IDocumentSkeletonGlyph[], paragraphNonInlineSkeDrawings?: Map<string, IDocumentSkeletonDrawing>): boolean;
 declare function _reLayoutCheck(ctx: ILayoutContext, floatObjects: IFloatObject[], column: IDocumentSkeletonColumn, paragraphIndex: number): void;
 export declare const __testing: {
     reLayoutCheck: typeof _reLayoutCheck;
+    getWrapTablePosition: typeof __getWrapTablePosition;
     avoidFlowAffectingDrawingsForTable: typeof __avoidFlowAffectingDrawingsForTable;
+    avoidNonOverlappingFloatingTables: typeof __avoidNonOverlappingFloatingTables;
     isGlyphGroupBeyondDivideWidth: typeof isGlyphGroupBeyondDivideWidth;
     checkPageBreak: typeof __checkPageBreak;
     updateAndPositionTable: typeof _updateAndPositionTable;
     adjustExplicitTabStop: typeof _adjustExplicitTabStop;
 };
-export declare function getLineHeightMetrics(glyphLineHeight: number, paragraphLineGapDefault: number, linePitch: number, gridType: GridType, lineSpacing: number, spacingRule: SpacingRule, snapToGrid: BooleanNumber, useWordStyleLineHeight?: boolean, scaleAutoLineSpacingByGlyphHeight?: boolean, normalLineHeight?: number, snapAutoLineSpacingToWholeGridLines?: boolean): {
+export declare function getLineHeightMetrics(glyphLineHeight: number, paragraphLineGapDefault: number, linePitch: number, gridType: GridType, lineSpacing: number, spacingRule: SpacingRule, snapToGrid: BooleanNumber, useWordStyleLineHeight?: boolean, scaleAutoLineSpacingByGlyphHeight?: boolean, normalLineHeight?: number, snapAutoLineSpacingToWholeGridLines?: boolean, drawingMLLineHeight?: number, topAlignExactLineSpacing?: boolean): {
     paddingTop: number;
     paddingBottom: number;
     contentHeight: number;
     lineSpacingApply: number;
 };
-export declare function updateInlineDrawingPosition(line: IDocumentSkeletonLine, paragraphInlineSkeDrawings?: Map<string, IDocumentSkeletonDrawing>, unitId?: string, blockAnchorTop?: number, paragraphNonInlineSkeDrawings?: Map<string, IDocumentSkeletonDrawing>): void;
+export declare function updateInlineDrawingPosition(line: IDocumentSkeletonLine, paragraphInlineSkeDrawings?: Map<string, IDocumentSkeletonDrawing>, unitId?: string, blockAnchorTop?: number, paragraphNonInlineSkeDrawings?: Map<string, IDocumentSkeletonDrawing>, documentCompatibilityPolicy?: IParagraphConfig['documentCompatibilityPolicy']): void;
 declare function __checkPageBreak(column: IDocumentSkeletonColumn): boolean;
 export {};

package/lib/types/components/docs/layout/block/paragraph/line-adjustment.d.ts

@@ -13,8 +13,8 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import type { ISectionBreakConfig } from '../../../../../basics';
 import type { IDocumentSkeletonPage } from '../../../../../basics/i-document-skeleton-cached';
+import type { ISectionBreakConfig } from '../../../../../basics/interfaces';
 import type { DataStreamTreeNode } from '../../../view-model/data-stream-tree-node';
 import type { DocumentViewModel } from '../../../view-model/document-view-model';
 export declare function lineAdjustment(pages: IDocumentSkeletonPage[], viewModel: DocumentViewModel, paragraphNode: DataStreamTreeNode, sectionBreakConfig: ISectionBreakConfig): void;

package/lib/types/components/docs/layout/block/paragraph/linebreaking.d.ts

@@ -20,4 +20,4 @@ import type { DataStreamTreeNode } from '../../../view-model/data-stream-tree-no
 import type { DocumentViewModel } from '../../../view-model/document-view-model';
 import type { ILayoutContext } from '../../tools';
 import type { IShapedText } from './shaping';
-export declare function lineBreaking(ctx: ILayoutContext, viewModel: DocumentViewModel, shapedTextList: IShapedText[], curPage: IDocumentSkeletonPage, paragraphNode: DataStreamTreeNode, sectionBreakConfig: ISectionBreakConfig, tableSkeleton: Nullable<IDocumentSkeletonTable>, tablePageBreakBefore?: boolean): IDocumentSkeletonPage[];
+export declare function lineBreaking(ctx: ILayoutContext, viewModel: DocumentViewModel, shapedTextList: IShapedText[], curPage: IDocumentSkeletonPage, paragraphNode: DataStreamTreeNode, sectionBreakConfig: ISectionBreakConfig, tableSkeleton: Nullable<IDocumentSkeletonTable>, tablePageBreakBefore?: boolean, nextParagraphNode?: DataStreamTreeNode): IDocumentSkeletonPage[];

package/lib/types/components/docs/layout/block/paragraph/paragraph-layout.d.ts

@@ -18,4 +18,4 @@ import type { ISectionBreakConfig } from '../../../../../basics/interfaces';
 import type { DataStreamTreeNode } from '../../../view-model/data-stream-tree-node';
 import type { DocumentViewModel } from '../../../view-model/document-view-model';
 import type { ILayoutContext } from '../../tools';
-export declare function dealWidthParagraph(ctx: ILayoutContext, viewModel: DocumentViewModel, paragraphNode: DataStreamTreeNode, curPage: IDocumentSkeletonPage, sectionBreakConfig: ISectionBreakConfig): IDocumentSkeletonPage[];
+export declare function dealWidthParagraph(ctx: ILayoutContext, viewModel: DocumentViewModel, paragraphNode: DataStreamTreeNode, curPage: IDocumentSkeletonPage, sectionBreakConfig: ISectionBreakConfig, nextParagraphNode?: DataStreamTreeNode): IDocumentSkeletonPage[];

package/lib/types/components/docs/layout/block/paragraph/shaping.d.ts

@@ -13,12 +13,15 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+import type { IParagraphStyle } from '@univerjs/core';
 import type { IDocumentSkeletonGlyph } from '../../../../../basics/i-document-skeleton-cached';
 import type { ISectionBreakConfig } from '../../../../../basics/interfaces';
 import type { DataStreamTreeNode } from '../../../view-model/data-stream-tree-node';
 import type { DocumentViewModel } from '../../../view-model/document-view-model';
 import type { ILayoutContext } from '../../tools';
+import { Lang } from '../../hyphenation/lang';
 import { BreakPointType } from '../../line-breaker/break';
+export declare function getHyphenationLanguage(ctx: ILayoutContext, content: string, paragraphStyle: IParagraphStyle, sectionBreakConfig: ISectionBreakConfig): Lang;
 export interface IShapedText {
     text: string;
     glyphs: IDocumentSkeletonGlyph[];

package/lib/types/components/docs/layout/block/section.d.ts

@@ -19,7 +19,13 @@ import type { ISectionBreakConfig } from '../../../../basics/interfaces';
 import type { DataStreamTreeNode } from '../../view-model/data-stream-tree-node';
 import type { DocumentViewModel } from '../../view-model/document-view-model';
 import type { ILayoutContext } from '../tools';
-export declare function dealWithSection(ctx: ILayoutContext, viewModel: DocumentViewModel, sectionNode: DataStreamTreeNode, curPage: IDocumentSkeletonPage, sectionBreakConfig: ISectionBreakConfig, layoutAnchor: Nullable<number>): {
+export interface IDealWithSectionOptions {
+    startParagraphIndex?: number;
+    maxParagraphs?: number;
+}
+export declare function dealWithSection(ctx: ILayoutContext, viewModel: DocumentViewModel, sectionNode: DataStreamTreeNode, curPage: IDocumentSkeletonPage, sectionBreakConfig: ISectionBreakConfig, layoutAnchor: Nullable<number>, options?: IDealWithSectionOptions): {
     pages: IDocumentSkeletonPage[];
     renderedBlockIdMap: Map<string, boolean>;
+    nextParagraphIndex: number;
+    complete: boolean;
 };

package/lib/types/components/docs/layout/block/table.d.ts

@@ -14,18 +14,74 @@
  * limitations under the License.
  */
 import type { INumberUnit, ITable, Nullable } from '@univerjs/core';
-import type { IDocumentSkeletonPage, IDocumentSkeletonTable, IParagraphList, ISectionBreakConfig } from '../../../../basics';
+import type { IDocumentSkeletonPage, IDocumentSkeletonRow, IDocumentSkeletonTable } from '../../../../basics/i-document-skeleton-cached';
+import type { ISectionBreakConfig } from '../../../../basics/interfaces';
 import type { DataStreamTreeNode } from '../../view-model/data-stream-tree-node';
 import type { DocumentViewModel } from '../../view-model/document-view-model';
+import type { DocumentFootnoteLayout } from '../footnote-layout';
+import type { ICellSkeletonBuildState } from '../model/page';
 import type { ILayoutContext } from '../tools';
 import { TableAlignmentType } from '@univerjs/core';
+export interface ITableSkeletonBuildState {
+    ctx: ILayoutContext;
+    curPage: IDocumentSkeletonPage;
+    viewModel: DocumentViewModel;
+    tableNode: DataStreamTreeNode;
+    sectionBreakConfig: ISectionBreakConfig;
+    table: ITable;
+    tableSkeleton: IDocumentSkeletonTable;
+    rowIndex: number;
+    rowTop: number;
+    tableWidth: number;
+    complete: boolean;
+    currentRowNode: Nullable<DataStreamTreeNode>;
+    currentRowSkeleton: Nullable<IDocumentSkeletonRow>;
+    currentColumnIndex: number;
+    currentRowLeft: number;
+    currentRowHeight: number;
+    mergedCellContentHeights: Map<string, number>;
+    currentCellBuild: Nullable<ICellSkeletonBuildState>;
+}
+export declare function startTableSkeletonBuild(ctx: ILayoutContext, curPage: IDocumentSkeletonPage, viewModel: DocumentViewModel, tableNode: DataStreamTreeNode, sectionBreakConfig: ISectionBreakConfig): Nullable<ITableSkeletonBuildState>;
+export declare function stepTableSkeletonBuild(state: ITableSkeletonBuildState): boolean;
+export declare function cachePrecomputedTableSkeleton(ctx: ILayoutContext, tableNode: DataStreamTreeNode, tableSkeleton: IDocumentSkeletonTable): void;
 export declare function createTableSkeleton(ctx: ILayoutContext, curPage: IDocumentSkeletonPage, viewModel: DocumentViewModel, tableNode: DataStreamTreeNode, sectionBreakConfig: ISectionBreakConfig): Nullable<IDocumentSkeletonTable>;
-export declare function rollbackListCache(listLevel: Map<string, IParagraphList[][]>, table: DataStreamTreeNode): void;
 export interface ISlicedTableSkeletonParams {
     skeTables: IDocumentSkeletonTable[];
     fromCurrentPage: boolean;
 }
+export interface ISlicedTableSkeletonBuildState {
+    ctx: ILayoutContext;
+    curPage: IDocumentSkeletonPage;
+    viewModel: DocumentViewModel;
+    tableNode: DataStreamTreeNode;
+    sectionBreakConfig: ISectionBreakConfig;
+    availableHeight: number;
+    table: ITable;
+    skeTables: IDocumentSkeletonTable[];
+    createCache: ICreateTableCache;
+    rowIndex: number;
+    columnIndex: number;
+    preparedCellPages: Map<number, IDocumentSkeletonPage[]>;
+    cellPageHeights?: number[];
+    pendingCellBuild: Nullable<ICellSkeletonBuildState>;
+    complete: boolean;
+    result: Nullable<ISlicedTableSkeletonParams>;
+}
+interface ICreateTableCache {
+    rowTop: number;
+    tableWidth: number;
+    remainHeight: number;
+    repeatRows: DataStreamTreeNode[];
+    repeatRowsHeight: number;
+    notes?: ReturnType<DocumentFootnoteLayout['createTablePagination']>;
+    fromCurrentPage?: boolean;
+}
+export declare function startTableSkeletonsBuild(ctx: ILayoutContext, curPage: IDocumentSkeletonPage, viewModel: DocumentViewModel, tableNode: DataStreamTreeNode, sectionBreakConfig: ISectionBreakConfig, availableHeight: number): Nullable<ISlicedTableSkeletonBuildState>;
+export declare function stepTableSkeletonsBuild(state: ISlicedTableSkeletonBuildState): boolean;
+export declare function cachePrecomputedSlicedTableSkeletons(ctx: ILayoutContext, tableNode: DataStreamTreeNode, availableHeight: number, result: ISlicedTableSkeletonParams): void;
 export declare function createTableSkeletons(ctx: ILayoutContext, curPage: IDocumentSkeletonPage, viewModel: DocumentViewModel, tableNode: DataStreamTreeNode, sectionBreakConfig: ISectionBreakConfig, availableHeight: number): ISlicedTableSkeletonParams;
+export declare function resolveTableLayoutColumns(table: ITable, availableWidth: number, traditional?: boolean): ITable;
 export declare function getTableLeft(pageWidth: number, tableWidth: number, align: TableAlignmentType, indent?: INumberUnit): number;
 export declare function getNullTableSkeleton(st: number, ed: number, table: ITable): IDocumentSkeletonTable;
 export declare function getTableSliceId(tableId: string, sliceIndex: number): string;
@@ -33,3 +89,4 @@ export declare function getTableIdAndSliceIndex(tableSliceId: string): {
     tableId: string;
     sliceIndex: number;
 };
+export {};

package/lib/types/components/docs/layout/doc-skeleton.d.ts

@@ -18,6 +18,8 @@ import type { IDocumentSkeletonCached, IDocumentSkeletonGlyph, IDocumentSkeleton
 import type { INodeInfo, INodePosition, INodeSearch } from '../../../basics/interfaces';
 import type { IViewportInfo, Vector2 } from '../../../basics/vector2';
 import type { DocumentViewModel } from '../view-model/document-view-model';
+import type { IDocumentLayoutGeometryPublication, IDocumentLayoutPagePublication } from './document-layout-publication';
+import type { DocumentLayoutReason, IDocumentLayoutApplyResult, IDocumentLayoutInvalidation, IDocumentLayoutPageRange, IDocumentLayoutProgress, IDocumentLayoutProtectedRange } from './document-layout-types';
 import type { IDocumentPaginationMetrics } from './tools';
 import { Skeleton } from '@univerjs/core';
 import { PageLayoutType } from '../../../basics/i-document-skeleton-cached';
@@ -28,6 +30,10 @@ export declare enum DocumentSkeletonState {
     READY = "ready",
     INVALID = "invalid"
 }
+export interface IDocumentCustomBlockPresentationRefreshResult {
+    didRefresh: boolean;
+    requiresLayout: boolean;
+}
 export interface IFindNodeRestrictions {
     strict: boolean;
     segmentId: string;
@@ -37,15 +43,34 @@ export declare class DocumentSkeleton extends Skeleton {
     private _docViewModel;
     private _dirty$;
     readonly dirty$: import("rxjs").Observable<boolean>;
+    private _layoutProgress$;
+    readonly layoutProgress$: import("rxjs").Observable<IDocumentLayoutProgress>;
+    private readonly _layoutPageMaterialized$;
+    readonly layoutPageMaterialized$: import("rxjs").Observable<void>;
     private _skeletonData;
     private _findLiquid;
     private _hyphen;
     private _languageDetector;
-    private _iteratorCount;
     private _initialWidth;
     private _paginationMetrics;
-    constructor(_docViewModel: DocumentViewModel, localeService: LocaleService);
-    static create(docViewModel: DocumentViewModel, localeService: LocaleService): DocumentSkeleton;
+    private _lastCompleteSkeletonData;
+    private _pendingInvalidationAnchor;
+    private _layoutGeneration;
+    private _activeLayout;
+    private _externalLayoutProgress;
+    private _externalProtectedPages;
+    private _externalProtectedContinuousLayout;
+    private _topLevelBlockSections;
+    private _topLevelBlocks;
+    private readonly _isolateIncrementalPublications;
+    private _modernPageWidth;
+    private _modernHorizontalMargin;
+    constructor(_docViewModel: DocumentViewModel, localeService: LocaleService, options?: {
+        isolateIncrementalPublications?: boolean;
+    });
+    static create(docViewModel: DocumentViewModel, localeService: LocaleService, options?: {
+        isolateIncrementalPublications?: boolean;
+    }): DocumentSkeleton;
     dispose(): void;
     getViewModel(): DocumentViewModel;
     /**
@@ -53,7 +78,70 @@ export declare class DocumentSkeleton extends Skeleton {
      * PS: This method has significant impact on performance.
      */
     calculate(bounds?: IViewportInfo): void;
+    startIncrementalLayout(options?: {
+        reason?: DocumentLayoutReason;
+        anchor?: number;
+        priorityAnchor?: number;
+        invalidation?: IDocumentLayoutInvalidation;
+        modernPageWidth?: number;
+        modernHorizontalMargin?: number;
+        bounds?: IViewportInfo;
+        reuseUnaffectedTail?: boolean;
+        /** The caller proved this edit only changes offset-preserving render metadata. */
+        allowMetadataOnlyStructuralTailReuse?: boolean;
+        preserveInteractionWindow?: boolean;
+        /** Cooperative schedulers wait for code-split dictionaries before publishing. */
+        waitForHyphenationPatterns?: boolean;
+    }): number;
+    private _prepareIncrementalLayoutStart;
+    private _preparePaginatedParagraphPrefix;
+    private _prepareContinuousPrefix;
+    private _findBodyPageIndex;
+    private _getTopLevelBlocks;
+    private _copySkeletonResources;
+    cancelIncrementalLayout(generation?: number): void;
+    stepIncrementalLayout(generation: number, budgetMs?: number, maxWorkUnits?: number): IDocumentLayoutProgress;
+    /**
+     * Publishes at most one page that a previous layout slice has already
+     * completed. It never advances shaping or pagination work.
+     */
+    publishIncrementalLayoutBacklog(generation: number): IDocumentLayoutProgress;
+    private _stepIncrementalLayout;
+    private _createPublishablePartialSkeleton;
+    private _createSharedPublishablePartialSkeleton;
+    private _findPublishablePriorityPageIndex;
+    private _finalizePaginatedPagesForPublication;
+    getLayoutProgress(): Nullable<IDocumentLayoutProgress>;
+    /**
+     * Opens a presentation barrier before an external executor starts layout.
+     * The Main interaction snapshot remains authoritative inside its protected
+     * page or block range while the external executor publishes a newer tail.
+     */
+    beginExternalLayout(options: {
+        reason: DocumentLayoutReason;
+        protectedRange?: IDocumentLayoutProtectedRange;
+    }): void;
+    cancelExternalLayout(): void;
+    /**
+     * Whether this skeleton owns a fully finalized layout that can be used as
+     * stable geometry while a later incremental generation is still running.
+     */
+    hasCompleteLayout(): boolean;
     getSkeletonData(): Nullable<IDocumentSkeletonCached>;
+    /** Invalidate measurements captured before the requested fonts finished loading. */
+    invalidateFontMetrics(fontStyles: readonly string[]): void;
+    /**
+     * Refreshes Custom Block viewport-only metrics without rebuilding document flow.
+     * Pure presentation metrics are published as one batch. Flow metrics are only
+     * replaced for compatible drawings; incompatible drawings retain their stable
+     * flow geometry while callers schedule a normal layout generation.
+     */
+    refreshCustomBlockPresentationViewports(): IDocumentCustomBlockPresentationRefreshResult;
+    applyLayoutPublication(publication: IDocumentLayoutGeometryPublication, progress: IDocumentLayoutProgress, materializedPageRange?: IDocumentLayoutPageRange): IDocumentLayoutApplyResult;
+    applyLayoutPagePublication(publication: IDocumentLayoutPagePublication, materializedPageRange: IDocumentLayoutPageRange): boolean;
+    private _compactMaterializedPages;
+    private _applyExternalLayoutResources;
+    private _resolveProtectedContinuousPublication;
     /**
      * Returns a cloned snapshot of the most recent layout's bounded pagination counters.
      * These diagnostics describe renderer work and are not part of the document model.
@@ -69,6 +157,7 @@ export declare class DocumentSkeleton extends Skeleton {
     findPositionByGlyph(glyph: IDocumentSkeletonGlyph, segmentPage: number): Nullable<INodeSearch>;
     findCharIndexByPosition(position: INodePosition): Nullable<number>;
     findNodePositionByCharIndex(charIndex: number, isBack?: boolean, segmentId?: string, segmentPIndex?: number): Nullable<INodePosition>;
+    findBodyPageIndexByCharIndex(charIndex: number): number;
     findNodeByCharIndex(charIndex: number, segmentId?: string, segmentPageIndex?: number): Nullable<IDocumentSkeletonGlyph>;
     findGlyphByPosition(position: Nullable<INodePosition>): IDocumentSkeletonGlyph | undefined;
     findEditAreaByCoord(coord: Vector2, pageLayoutType: PageLayoutType, pageMarginLeft: number, pageMarginTop: number): {
@@ -77,10 +166,28 @@ export declare class DocumentSkeleton extends Skeleton {
         page: Nullable<IDocumentSkeletonPage>;
     };
     findNodeByCoord(coord: Vector2, pageLayoutType: PageLayoutType, pageMarginLeft: number, pageMarginTop: number, restrictions?: IFindNodeRestrictions): Nullable<INodeInfo>;
+    private _findNodeByCoord;
     private _collectNearestNode;
+    private _getHitTestPageLayout;
+    private _collectNearestTableNode;
+    private _collectNearestColumnGroupNode;
+    private _collectNearestTextNode;
+    private _collectNearestInkNode;
     private _getNearestNode;
     private _getPageBoundingBox;
     private _translatePage;
+    private _getLayoutProgress;
+    private _tryConvergeUnaffectedTail;
+    private _isPriorityAnchorReady;
+    private _tryReuseInteractionPageTail;
+    private _prepareIncrementalHyphenation;
+    private _advanceIncrementalLayout;
+    private _resumeAfterSealedInteractionPage;
+    private _captureIncrementalParagraphCheckpoint;
+    private _restoreIncrementalParagraphCheckpoint;
+    private _initializeIncrementalSection;
+    private _restartDirtyIncrementalLayout;
+    private _finishIncrementalLayout;
     private _prepareLayoutContext;
     /**
      * \v COLUMN_BREAK
@@ -110,6 +217,7 @@ export declare class DocumentSkeleton extends Skeleton {
      * @returns view model: skeleton
      */
     private _createSkeleton;
+    private _createSkeletonPass;
     private _addNewSectionByContinuous;
     private _addNewSectionByNextColumn;
     private _restoreContinuousSection;

package/lib/types/components/docs/layout/document-layout-page-patch.d.ts

@@ -0,0 +1,104 @@
+/**
+ * Copyright 2023-present DreamNum Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import type { IDocDrawingBase, IDocumentData, ITable, ITableRow } from '@univerjs/core';
+import type { IDocumentSkeletonCached, IDocumentSkeletonColumn, IDocumentSkeletonColumnGroup, IDocumentSkeletonColumnGroupColumn, IDocumentSkeletonDivide, IDocumentSkeletonDrawing, IDocumentSkeletonGlyph, IDocumentSkeletonLine, IDocumentSkeletonNote, IDocumentSkeletonNoteDecoration, IDocumentSkeletonPage, IDocumentSkeletonRow, IDocumentSkeletonSection, IDocumentSkeletonTable } from '../../../basics/i-document-skeleton-cached';
+export type IDocumentSkeletonGlyphPatch = Omit<IDocumentSkeletonGlyph, 'parent'>;
+export interface IDocumentSkeletonDividePatch extends Omit<IDocumentSkeletonDivide, 'glyphGroup' | 'parent'> {
+    glyphGroup: IDocumentSkeletonGlyphPatch[];
+}
+export interface IDocumentSkeletonLinePatch extends Omit<IDocumentSkeletonLine, 'divides' | 'parent'> {
+    divides: IDocumentSkeletonDividePatch[];
+}
+export interface IDocumentSkeletonColumnPatch extends Omit<IDocumentSkeletonColumn, 'lines' | 'parent'> {
+    lines: IDocumentSkeletonLinePatch[];
+}
+export interface IDocumentSkeletonSectionPatch extends Omit<IDocumentSkeletonSection, 'columns' | 'parent'> {
+    columns: IDocumentSkeletonColumnPatch[];
+}
+export interface IDocumentSkeletonDrawingPatch extends Omit<IDocumentSkeletonDrawing, 'drawingOrigin'> {
+    drawingOrigin?: IDocDrawingBase;
+}
+export interface IDocumentSkeletonRowPatch extends Omit<IDocumentSkeletonRow, 'cells' | 'parent' | 'rowSource'> {
+    cells: IDocumentSkeletonPagePatch[];
+    rowSource?: ITableRow;
+    rowSourceIndex?: number;
+}
+export interface IDocumentSkeletonTablePatch extends Omit<IDocumentSkeletonTable, 'rows' | 'parent' | 'tableSource'> {
+    rows: IDocumentSkeletonRowPatch[];
+    tableSource?: ITable;
+    tableSourceId?: string;
+}
+export interface IDocumentSkeletonColumnGroupColumnPatch extends Omit<IDocumentSkeletonColumnGroupColumn, 'page' | 'parent'> {
+    page: IDocumentSkeletonPagePatch;
+}
+export interface IDocumentSkeletonColumnGroupPatch extends Omit<IDocumentSkeletonColumnGroup, 'columns' | 'parent'> {
+    columns: IDocumentSkeletonColumnGroupColumnPatch[];
+}
+export interface IDocumentSkeletonPagePatch extends Omit<IDocumentSkeletonPage, 'sections' | 'skeDrawings' | 'skeTables' | 'skeColumnGroups' | 'notes' | 'noteDecorations' | 'parent'> {
+    sections: IDocumentSkeletonSectionPatch[];
+    skeDrawings: Array<[string, IDocumentSkeletonDrawingPatch]>;
+    skeTables: Array<[string, IDocumentSkeletonTablePatch]>;
+    skeColumnGroups: Array<[string, IDocumentSkeletonColumnGroupPatch]>;
+    noteDecorations?: Array<Omit<IDocumentSkeletonNoteDecoration, 'page'> & {
+        page: IDocumentSkeletonPagePatch;
+    }>;
+    notes?: Array<Omit<IDocumentSkeletonNote, 'page' | 'parent'> & {
+        page: IDocumentSkeletonPagePatch;
+    }>;
+}
+export type IDocumentSkeletonPageGeometryPatch = Omit<IDocumentSkeletonPagePatch, 'sections' | 'skeDrawings' | 'skeTables' | 'skeColumnGroups' | 'notes' | 'noteDecorations'>;
+export type IDocumentSkeletonSectionGeometryPatch = Omit<IDocumentSkeletonSectionPatch, 'columns'>;
+export type IDocumentSkeletonColumnGeometryPatch = Omit<IDocumentSkeletonColumnPatch, 'lines'>;
+export interface IDocumentSkeletonContinuousFlowPatch {
+    sectionIndex: number;
+    section: IDocumentSkeletonSectionGeometryPatch;
+    columnIndex: number;
+    column: IDocumentSkeletonColumnGeometryPatch;
+    lineIndex: number;
+    lines: IDocumentSkeletonLinePatch[];
+    trailingColumns: IDocumentSkeletonColumnPatch[];
+    trailingSections: IDocumentSkeletonSectionPatch[];
+}
+export interface IDocumentSkeletonContinuousBlockPatch {
+    pageIndex: number;
+    page: IDocumentSkeletonPageGeometryPatch;
+    flow: IDocumentSkeletonContinuousFlowPatch;
+    skeDrawings: Array<[string, IDocumentSkeletonDrawingPatch]>;
+    skeTables: Array<[string, IDocumentSkeletonTablePatch]>;
+    skeColumnGroups: Array<[string, IDocumentSkeletonColumnGroupPatch]>;
+    previousHeight: number;
+    heightDelta: number;
+}
+export interface IDocumentSkeletonContinuousSnapshot {
+    height: number;
+    lineEnds: number[];
+}
+export declare function serializeDocumentSkeletonLine(source: IDocumentSkeletonLine): IDocumentSkeletonLinePatch;
+export declare function serializeDocumentSkeletonPage(source: IDocumentSkeletonPage, omitResourceSources?: boolean): IDocumentSkeletonPagePatch;
+export declare function hydrateDocumentSkeletonLine(source: IDocumentSkeletonLinePatch, parent: IDocumentSkeletonColumn): IDocumentSkeletonLine;
+export declare function hydrateDocumentSkeletonPage(source: IDocumentSkeletonPagePatch, parent?: IDocumentSkeletonCached | IDocumentSkeletonRow | IDocumentSkeletonColumnGroupColumn, snapshot?: IDocumentData): IDocumentSkeletonPage;
+export declare function hydrateDocumentSkeletonPagePlaceholder(source: IDocumentSkeletonPagePatch, parent?: IDocumentSkeletonCached): IDocumentSkeletonPage;
+export declare function hydrateDocumentSkeletonPageMaterializationPlaceholder(source: IDocumentSkeletonPagePatch, parent?: IDocumentSkeletonCached): IDocumentSkeletonPage;
+/**
+ * Serializes only the changed suffix of a continuous document's logical page.
+ * The boundary line is deliberately republished because paragraph spacing can
+ * alter it when the next block is appended.
+ */
+export declare function serializeDocumentSkeletonContinuousBlock(currentPage: IDocumentSkeletonPage, previousSnapshot: IDocumentSkeletonContinuousSnapshot | null, replacementOffset?: number, omitResourceSources?: boolean): {
+    block: IDocumentSkeletonContinuousBlockPatch;
+    snapshot: IDocumentSkeletonContinuousSnapshot;
+};
+export declare function applyDocumentSkeletonContinuousBlock(target: IDocumentSkeletonCached, patch: IDocumentSkeletonContinuousBlockPatch, snapshot?: IDocumentData): IDocumentSkeletonPage;

package/lib/types/components/docs/layout/document-layout-publication.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Copyright 2023-present DreamNum Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import type { IDocumentSkeletonDrawingAnchor, IParagraphList } from '../../../basics/i-document-skeleton-cached';
+import type { IDocumentSkeletonContinuousBlockPatch, IDocumentSkeletonPagePatch } from './document-layout-page-patch';
+export type IDocumentLayoutListLevelPublication = Array<[string, IParagraphList[][]]>;
+export type IDocumentLayoutDrawingAnchorPublication = Array<[
+    string,
+    Array<[number, Omit<IDocumentSkeletonDrawingAnchor, 'elements'>]>
+]>;
+export interface IDocumentLayoutPagePublication {
+    pageIndex: number;
+    page: IDocumentSkeletonPagePatch;
+}
+export interface IDocumentLayoutResourcePublication {
+    reset: boolean;
+    skeHeaders: Array<[string, Array<[number, IDocumentSkeletonPagePatch]>]>;
+    skeFooters: Array<[string, Array<[number, IDocumentSkeletonPagePatch]>]>;
+    skeListLevel: IDocumentLayoutListLevelPublication | null;
+    drawingAnchor: IDocumentLayoutDrawingAnchorPublication | null;
+}
+interface IDocumentLayoutGeometryPublicationBase {
+    left: number;
+    top: number;
+    st: number;
+    ed?: number;
+    resources: IDocumentLayoutResourcePublication;
+}
+export interface IDocumentLayoutPageGeometryPublication extends IDocumentLayoutGeometryPublicationBase {
+    kind: 'page';
+    pages: IDocumentLayoutPagePublication[];
+}
+export interface IDocumentLayoutBlockGeometryPublication extends IDocumentLayoutGeometryPublicationBase {
+    kind: 'block';
+    block: IDocumentSkeletonContinuousBlockPatch;
+}
+export type IDocumentLayoutGeometryPublication = IDocumentLayoutPageGeometryPublication | IDocumentLayoutBlockGeometryPublication;
+export {};

package/lib/types/components/docs/layout/document-layout-types.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Copyright 2023-present DreamNum Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export type DocumentLayoutMode = 'paginated' | 'continuous';
+export type DocumentLayoutReason = 'initial' | 'edit';
+export interface IDocumentLayoutInvalidation {
+    /** First offset changed in the pre-mutation document. */
+    oldStart: number;
+    /** Exclusive end of the changed range in the pre-mutation document. */
+    oldEnd: number;
+    /** Exclusive end of the changed range in the post-mutation document. */
+    newEnd: number;
+}
+export interface IDocumentLayoutProtectedPageRange {
+    mode: 'paginated';
+    startPageIndex: number;
+    endPageIndex: number;
+}
+export type IDocumentLayoutPageRange = Pick<IDocumentLayoutProtectedPageRange, 'startPageIndex' | 'endPageIndex'>;
+export interface IDocumentLayoutProtectedContinuousRange {
+    mode: 'continuous';
+    startOffset: number;
+    endOffset: number;
+}
+export type IDocumentLayoutProtectedRange = IDocumentLayoutProtectedPageRange | IDocumentLayoutProtectedContinuousRange;
+export interface IDocumentLayoutApplyResult {
+    didReplaceProtectedPages: boolean;
+}
+export interface IDocumentLayoutProgress {
+    generation: number;
+    publicationRevision: number;
+    didPublish: boolean;
+    /** The publication atomically replaced the page containing the edit anchor. */
+    didPublishAnchor: boolean;
+    publishedPageCount: number;
+    reason: DocumentLayoutReason;
+    mode: DocumentLayoutMode;
+    complete: boolean;
+    cancelled: boolean;
+    anchorReady: boolean;
+    laidOutThrough: number;
+    /** Last logical offset whose exit geometry cannot be changed by the next block. */
+    stableLaidOutThrough: number;
+    pageCount: number;
+    processedBlockCount: number;
+    totalBlockCount: number;
+    estimatedPageCount: number;
+    estimatedHeight: number;
+    elapsedTime: number;
+    maxBlockDuration: number;
+    /** Main has sealed the protected interaction page and should hand the remaining suffix to Worker. */
+    interactionWindowComplete?: boolean;
+}

package/lib/types/components/docs/layout/endnote-layout.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Copyright 2023-present DreamNum Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import type { IDocumentSkeletonPage } from '../../../basics/i-document-skeleton-cached';
+import type { ISectionBreakConfig } from '../../../basics/interfaces';
+import type { ILayoutContext } from './tools';
+/** Endnotes occupy document flow after a section or the final body section. */
+export declare class DocumentEndnoteLayout {
+    private readonly _ctx;
+    constructor(_ctx: ILayoutContext);
+    finishSection(pages: IDocumentSkeletonPage[], sectionIndex: number, config: ISectionBreakConfig): void;
+    private _layoutDecoration;
+}
+export declare function getEndnoteFlowBottom(page: IDocumentSkeletonPage): number;