@a3s-lab/office 0.12.0 → 0.13.0

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-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-import.d.ts

@@ -7,12 +7,17 @@ export interface WorkFileImportProgress {
     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;

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

@@ -1,9 +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, 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;

package/dist/internal/features/work/work-office-diagnostics.d.ts

@@ -1,10 +1,19 @@
 import type { WorkBook } from 'xlsx';
 import { OoxmlPackage } from './work-ooxml-package';
+import { type SpreadsheetWorksheetCompatibilitySummary } from './work-spreadsheet-compatibility-summary';
 import type { WorkCompatibilityReport } from './work-types';
+import type { XlsxFormulaFeatures } from './work-xlsx-formulas';
+import type { XlsxPivotReadResult } from './work-xlsx-pivots';
+import type { XlsxWorksheetXmlScan } from './work-xlsx-worksheet-scan';
 interface ConversionMessage {
     type: string;
     message: string;
 }
+export interface SpreadsheetCompatibilityImportMetadata {
+    formulaFeatures?: XlsxFormulaFeatures | null;
+    pivotFeatures?: XlsxPivotReadResult | null;
+    worksheetScans?: Readonly<Record<string, XlsxWorksheetXmlScan>>;
+}
 export declare function analyzeDocxCompatibility(file: File, messages: ConversionMessage[], sourcePackage?: OoxmlPackage | null): Promise<WorkCompatibilityReport>;
-export declare function analyzeSpreadsheetCompatibility(file: File, extension: string, workbook: WorkBook, sourcePackage?: OoxmlPackage | null): Promise<WorkCompatibilityReport | null>;
+export declare function analyzeSpreadsheetCompatibility(file: File, extension: string, workbook: WorkBook, sourcePackage?: OoxmlPackage | null, worksheetSummaries?: ReadonlyMap<string, SpreadsheetWorksheetCompatibilitySummary>, importedMetadata?: SpreadsheetCompatibilityImportMetadata): Promise<WorkCompatibilityReport | null>;
 export {};

package/dist/internal/features/work/work-ooxml-package.d.ts

@@ -6,6 +6,7 @@ export interface OoxmlRelationship {
 }
 export declare class OoxmlPackage {
     private readonly zip;
+    private readonly textCache;
     private constructor();
     static load(buffer: ArrayBuffer): Promise<OoxmlPackage>;
     has(partPath: string): boolean;
@@ -16,6 +17,13 @@ export declare class OoxmlPackage {
     relationships(sourcePart: string): Promise<Map<string, OoxmlRelationship>>;
 }
 export declare function parseXml(source: string, label?: string): Document;
+/**
+ * Checks raw XML for selected element names before paying the cost of a full
+ * DOM tree. False positives are safe because they only select the slower
+ * parser path; the tag boundary prevents cell values and longer tag names
+ * from selecting it accidentally.
+ */
+export declare function xmlContainsAnyElement(source: string, localNames: readonly string[]): boolean;
 export declare function attribute(element: Element, name: string): string | null;
 export declare function xmlNamespacePrefix(element: Element, namespace: string | null): string | null;
 export declare function directChildren(parent: ParentNode, localName?: string): Element[];

package/dist/internal/features/work/work-presentation-layouts.d.ts

@@ -8,6 +8,12 @@ export interface WorkPresentationSlideView {
     master?: WorkPresentationMaster;
     layout?: WorkPresentationLayout;
 }
-export declare function withPresentationDesign(content: WorkPresentationContent): WorkPresentationContent;
+export type WorkPresentationDesignContent = WorkPresentationContent & {
+    layouts: WorkPresentationLayout[];
+    masters: WorkPresentationMaster[];
+};
+export declare function withPresentationDesign(content: WorkPresentationContent): WorkPresentationDesignContent;
+export declare function withPresentationDesignMetadata(content: WorkPresentationContent): WorkPresentationDesignContent;
 export declare function presentationSlideView(content: WorkPresentationContent, slide: WorkSlide): WorkPresentationSlideView;
+export declare function presentationSlideViewFromDesign(designContent: WorkPresentationDesignContent, slide: WorkSlide): WorkPresentationSlideView;
 export declare function applyPresentationLayout(content: WorkPresentationContent, slideId: string, layoutId: string): WorkPresentationContent;

package/dist/internal/features/work/work-repository.d.ts

@@ -1,6 +1,7 @@
 import type { WorkArtifact } from './work-types';
 export declare function rememberWorkSourceBlob(artifactId: string, source: Blob): void;
 export declare function forgetWorkSourceBlob(artifactId: string): void;
+export declare function moveWorkSourceBlob(sourceArtifactId: string, targetArtifactId: string): void;
 export declare function readWorkSourceBlob(artifact: WorkArtifact): Promise<Blob>;
 export declare function readVerifiedWorkSourceBytes(artifact: WorkArtifact): Promise<ArrayBuffer>;
 export declare function workSourceFingerprint(bytes: ArrayBuffer): Promise<string>;

package/dist/internal/features/work/work-spreadsheet-compatibility-summary.d.ts

@@ -0,0 +1,10 @@
+import type { CellObject } from 'xlsx';
+export interface SpreadsheetWorksheetCompatibilitySummary {
+    hasArrayFormulas: boolean;
+    hasComments: boolean;
+    hasCommentThreads: boolean;
+    hasLinks: boolean;
+    hasRichText: boolean;
+}
+export declare function emptySpreadsheetWorksheetCompatibilitySummary(): SpreadsheetWorksheetCompatibilitySummary;
+export declare function updateSpreadsheetWorksheetCompatibilitySummary(summary: SpreadsheetWorksheetCompatibilitySummary, cell: CellObject): void;

package/dist/internal/features/work/work-spreadsheet-file-export.d.ts

@@ -0,0 +1,2 @@
+import type { WorkArtifact } from './work-types';
+export declare function createWorkSpreadsheetBlob(artifact: WorkArtifact): Promise<Blob>;

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

@@ -0,0 +1,3 @@
+import type { WorkFileImportContext } from './work-file-import';
+import type { WorkArtifact } from './work-types';
+export declare function importWorkSpreadsheetFile(file: File, extension: string, context: WorkFileImportContext): Promise<WorkArtifact>;

package/dist/internal/features/work/work-spreadsheet-import-diagnostics.d.ts

@@ -0,0 +1,2 @@
+export declare function spreadsheetImportNow(): number;
+export declare function recordSpreadsheetImportMeasure(name: string, start: number, end: number, detail?: Record<string, unknown>): void;

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

@@ -0,0 +1,6 @@
+import type { ParsingOptions, WorkBook } from 'xlsx';
+/**
+ * Parses a workbook away from the UI thread when a dedicated Worker can be
+ * created. A null result asks the caller to use the synchronous fallback.
+ */
+export declare function readSpreadsheetWorkbookInWorker(bytes: ArrayBuffer, options: ParsingOptions, signal?: AbortSignal): Promise<WorkBook | null>;

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

@@ -0,0 +1,32 @@
+import type { CellObject, ParsingOptions, WorkBook } from 'xlsx';
+export declare const SPREADSHEET_IMPORT_ROW_CHUNK_SIZE = 512;
+export declare const SPREADSHEET_IMPORT_CELL_CHUNK_SIZE = 8192;
+export interface SpreadsheetImportWorkerRequest {
+    bytes: ArrayBuffer;
+    kind: 'parse';
+    options: ParsingOptions;
+}
+export type SpreadsheetImportWorkbookMetadata = Omit<WorkBook, 'Sheets'>;
+export type SpreadsheetImportDenseRow = Array<CellObject | undefined>;
+export type SpreadsheetImportWorkerResponse = {
+    kind: 'workbook';
+    workbook: SpreadsheetImportWorkbookMetadata;
+} | {
+    dense: boolean;
+    kind: 'worksheet';
+    name: string;
+    properties: Record<string, unknown>;
+} | {
+    kind: 'rows';
+    name: string;
+    rows: Array<SpreadsheetImportDenseRow | undefined>;
+    startRow: number;
+} | {
+    cells: Array<[address: string, cell: CellObject]>;
+    kind: 'cells';
+    name: string;
+} | {
+    kind: 'success';
+} | {
+    kind: 'failure';
+};

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

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