@a3s-lab/office 0.12.0 → 0.13.1

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 {};

package/dist/internal/features/work/work-spreadsheet-matrix-profile.d.ts

@@ -0,0 +1,64 @@
+import type { Cell, CellMatrix } from '@fortune-sheet/core';
+export declare const SPREADSHEET_SHOWN_COMMENT_CELLS_PROPERTY = "__a3sShownCommentCells";
+export interface SpreadsheetMatrixProfile {
+    columnCount: number;
+    formulaCells: readonly Readonly<{
+        column: number;
+        row: number;
+    }>[];
+    fortuneReady: boolean;
+    historyRoot: object;
+    historyState: object;
+    populatedCellCount: number;
+    protectionCellKey: string;
+    rowCount: number;
+    shownCommentCells: readonly Readonly<{
+        c: number;
+        r: number;
+    }>[];
+}
+export interface SpreadsheetMatrixCellChange {
+    column: number;
+    current: Cell | null | undefined;
+    previous: Cell | null | undefined;
+    row: number;
+}
+interface ImportedSpreadsheetMatrixOptions {
+    columnCount: number;
+    formulaCells: readonly Readonly<{
+        column: number;
+        row: number;
+    }>[];
+    fortuneReady: boolean;
+    populatedCellCount: number;
+    protectionCellKey: string;
+    rowCount: number;
+    shownCommentCells: readonly Readonly<{
+        c: number;
+        r: number;
+    }>[];
+}
+/**
+ * Freezes a package-owned import cell before it becomes controlled content.
+ * Fortune can then share the cell as an Immer base value without recursively
+ * freezing or cloning every populated cell during editor initialization.
+ */
+export declare function freezeImportedSpreadsheetCell(cell: Cell): Cell;
+/**
+ * Authenticates a normalized, package-owned matrix for clone-free projection.
+ * The registry is identity-based, so an edited or host-created matrix cannot
+ * accidentally inherit the optimization.
+ */
+export declare function registerImportedSpreadsheetMatrix(data: CellMatrix, options: ImportedSpreadsheetMatrixOptions): void;
+/**
+ * Carries import-time summaries across a bounded cell edit without rescanning
+ * the complete matrix. The source identity must have been authenticated by
+ * this package and must already be directly consumable by Fortune.
+ */
+export declare function registerDerivedSpreadsheetMatrix(data: CellMatrix, source: CellMatrix, changes: readonly SpreadsheetMatrixCellChange[]): boolean;
+export declare function spreadsheetMatrixProfile(data: CellMatrix | undefined): SpreadsheetMatrixProfile | undefined;
+export declare function attachSpreadsheetShownCommentCells(data: CellMatrix, cells: readonly Readonly<{
+    c: number;
+    r: number;
+}>[]): void;
+export {};

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

@@ -0,0 +1,6 @@
+import type { SpreadsheetPackageScanResult } from './work-spreadsheet-package-scan-worker-protocol';
+/**
+ * Decompresses and classifies worksheet XML away from the UI thread. A null
+ * result preserves the existing main-thread parser as a compatibility path.
+ */
+export declare function scanSpreadsheetPackageInWorker(bytes: ArrayBuffer, signal?: AbortSignal, onFastPathCandidate?: () => void): Promise<SpreadsheetPackageScanResult | null>;

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

@@ -0,0 +1,49 @@
+import type { CellMatrix } from '@fortune-sheet/core';
+import type { WorkBook } from 'xlsx';
+import type { SpreadsheetImportWorkbookMetadata } from './work-spreadsheet-import-worker-protocol';
+import type { PlainXlsxCellChunk } from './work-xlsx-plain-fast-path';
+import type { XlsxWorksheetXmlScan } from './work-xlsx-worksheet-scan';
+export interface SpreadsheetPackageScanWorkerRequest {
+    bytes: ArrayBuffer;
+    kind: 'scan';
+}
+export interface SpreadsheetPackageScanResult {
+    plainWorksheets: Record<string, SpreadsheetPlainWorksheet> | null;
+    workbook: WorkBook | null;
+    worksheets: Record<string, XlsxWorksheetXmlScan>;
+}
+export interface SpreadsheetPlainWorksheet {
+    columnCount: number;
+    data: CellMatrix;
+    populatedCellCount: number;
+    rowCount: number;
+}
+export type SpreadsheetPackageScanWorkerResponse = {
+    kind: 'workbook';
+    workbook: SpreadsheetImportWorkbookMetadata;
+} | {
+    columnCount: number;
+    kind: 'plain-worksheet-start';
+    name: string;
+    rowCount: number;
+} | {
+    columnCount: number;
+    dense: true;
+    kind: 'worksheet';
+    name: string;
+    populatedCellCount: number;
+    properties: Record<string, unknown>;
+    rowCount: number;
+} | {
+    chunk: PlainXlsxCellChunk;
+    kind: 'plain-cells';
+    name: string;
+} | {
+    kind: 'fast-path-rejected';
+} | {
+    fastPath: boolean;
+    kind: 'success';
+    worksheets: SpreadsheetPackageScanResult['worksheets'];
+} | {
+    kind: 'failure';
+};

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

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

package/dist/internal/features/work/work-xlsx-cell-borders.d.ts

@@ -0,0 +1,25 @@
+import type { Sheet } from '@fortune-sheet/core';
+export type XlsxCellBorderStyle = 'dashDot' | 'dashDotDot' | 'dashed' | 'dotted' | 'double' | 'hair' | 'medium' | 'mediumDashDot' | 'mediumDashDotDot' | 'mediumDashed' | 'slantDashDot' | 'thick' | 'thin';
+export interface XlsxCellBorderLine {
+    color: string;
+    style: XlsxCellBorderStyle;
+}
+export interface XlsxCellBorder {
+    bottom?: XlsxCellBorderLine | null;
+    diagonal?: XlsxCellBorderLine | null;
+    diagonalDown?: boolean;
+    diagonalUp?: boolean;
+    left?: XlsxCellBorderLine | null;
+    right?: XlsxCellBorderLine | null;
+    top?: XlsxCellBorderLine | null;
+}
+export interface XlsxPositionedCellBorder {
+    border?: XlsxCellBorder;
+    column: number;
+    row: number;
+}
+export declare function collectXlsxCellBorders(sheet: Sheet): ReadonlyMap<string, XlsxCellBorder>;
+export declare function fortuneBorderInfoFromXlsxCells(entries: readonly XlsxPositionedCellBorder[]): unknown[];
+export declare function xlsxCellBorderKey(row: number, column: number): string;
+export declare function xlsxCellBorderLineFromFortune(value: unknown): XlsxCellBorderLine | null | undefined;
+export declare function fortuneBorderStyle(style: XlsxCellBorderStyle): string;

package/dist/internal/features/work/work-xlsx-cell-style-writer.d.ts

@@ -0,0 +1,21 @@
+import type { Cell } from '@fortune-sheet/core';
+import type { XlsxCellBorder } from './work-xlsx-cell-borders';
+export declare class XlsxDirectCellStyleWriter {
+    private readonly styles;
+    private readonly fonts;
+    private readonly fills;
+    private readonly borders;
+    private readonly cellXfs;
+    private readonly generatedFonts;
+    private readonly generatedFills;
+    private readonly generatedBorders;
+    private readonly generatedStyles;
+    changed: boolean;
+    constructor(styles: Document);
+    styleId(baseStyleId: number, cell: Cell, border?: XlsxCellBorder): number;
+    private fontId;
+    private fillId;
+    private borderId;
+    private updateCounts;
+}
+export declare function hasXlsxDirectCellStyle(cell: Cell): boolean;

package/dist/internal/features/work/work-xlsx-cell-style-xml.d.ts

@@ -0,0 +1,17 @@
+import type { XlsxCellBorderLine } from './work-xlsx-cell-borders';
+export interface XlsxDirectAlignmentStyle {
+    horizontal?: 'center' | 'left' | 'right';
+    textRotation?: number;
+    vertical?: 'bottom' | 'center' | 'top';
+    wrapText?: boolean;
+}
+export declare function ensureXlsxStyleCollection(document: Document, name: string, anchors: readonly string[]): Element;
+export declare function defaultXlsxFill(document: Document, patternType: string): Element;
+export declare function defaultXlsxBorder(document: Document): Element;
+export declare function setXlsxBorderLine(document: Document, border: Element, name: 'bottom' | 'diagonal' | 'left' | 'right' | 'top', line: XlsxCellBorderLine | null): void;
+export declare function writeXlsxAlignment(document: Document, xf: Element, style: XlsxDirectAlignmentStyle): void;
+export declare function setXlsxValueChild(document: Document, parent: Element, name: string, value: string, order: readonly string[]): void;
+export declare function setXlsxColorChild(document: Document, parent: Element, color: string, order: readonly string[]): void;
+export declare function setXlsxToggleChild(document: Document, parent: Element, name: string, enabled: boolean, order: readonly string[]): void;
+export declare function setXlsxUnderlineChild(document: Document, parent: Element, enabled: boolean, order: readonly string[]): void;
+export declare function xlsxRgbColor(value: unknown): string | null;

package/dist/internal/features/work/work-xlsx-cell-styles.d.ts

@@ -0,0 +1,13 @@
+import type { Cell, Sheet } from '@fortune-sheet/core';
+import { type XlsxCellBorder } from './work-xlsx-cell-borders';
+import { type XlsxDirectCellStyleWriter } from './work-xlsx-cell-style-writer';
+export { XlsxDirectCellStyleWriter } from './work-xlsx-cell-style-writer';
+export interface XlsxDirectCellStyle {
+    border?: XlsxCellBorder;
+    column: number;
+    row: number;
+    style: Partial<Cell>;
+}
+export declare function readXlsxDirectCellStyles(worksheet: Document, styles: Document | null, theme?: Document | null): XlsxDirectCellStyle[];
+export declare function sheetHasDirectCellStyles(sheet: Sheet): boolean;
+export declare function writeXlsxDirectCellStyles(worksheet: Document, sheet: Sheet, styles: XlsxDirectCellStyleWriter): void;

package/dist/internal/features/work/work-xlsx-colors.d.ts

@@ -0,0 +1,6 @@
+export interface XlsxColorResolver {
+    indexed: readonly string[];
+    theme: readonly string[];
+}
+export declare function createXlsxColorResolver(styles: Document, theme: Document | null): XlsxColorResolver;
+export declare function resolveXlsxColor(element: Element | undefined, resolver: XlsxColorResolver): string | undefined;

package/dist/internal/features/work/work-xlsx-formula-diagnostics.d.ts

@@ -1,3 +1,5 @@
 import type { OoxmlPackage } from './work-ooxml-package';
 import type { WorkCompatibilityIssue } from './work-types';
-export declare function diagnoseXlsxFormulas(archive: OoxmlPackage): Promise<WorkCompatibilityIssue[]>;
+import { type XlsxFormulaFeatures } from './work-xlsx-formulas';
+import type { XlsxWorksheetXmlScan } from './work-xlsx-worksheet-scan';
+export declare function diagnoseXlsxFormulas(archive: OoxmlPackage, importedFeatures?: XlsxFormulaFeatures | null, worksheetScans?: Readonly<Record<string, XlsxWorksheetXmlScan>>): Promise<WorkCompatibilityIssue[]>;

package/dist/internal/features/work/work-xlsx-formulas.d.ts

@@ -2,6 +2,7 @@ import type { Cell } from '@fortune-sheet/core';
 import type { WorkSheet } from 'xlsx';
 import { OoxmlPackage } from './work-ooxml-package';
 import type { WorkSpreadsheetCalculationSettings, WorkSpreadsheetContent, WorkSpreadsheetFormulaMetadata, WorkSpreadsheetFormulaRange, WorkSpreadsheetSheet } from './work-types';
+import type { XlsxWorksheetXmlScan } from './work-xlsx-worksheet-scan';
 export interface XlsxFormulaCell {
     address: string;
     formula: string;
@@ -29,7 +30,7 @@ type XlsxFormulaCellObject = {
     D?: boolean;
 };
 export declare function readXlsxFormulaFeatures(buffer: ArrayBuffer): Promise<XlsxFormulaFeatures>;
-export declare function readXlsxFormulaFeaturesFromPackage(archive: OoxmlPackage): Promise<XlsxFormulaFeatures>;
+export declare function readXlsxFormulaFeaturesFromPackage(archive: OoxmlPackage, worksheetScans?: Readonly<Record<string, XlsxWorksheetXmlScan>>): Promise<XlsxFormulaFeatures>;
 export declare function createSpreadsheetFormulaMetadata(worksheet: WorkSheet, features: XlsxFormulaSheetFeatures | undefined): WorkSpreadsheetFormulaMetadata | undefined;
 export declare function createXlsxFormulaCell(cell: Cell, row: number, column: number, sheet: WorkSpreadsheetSheet): XlsxFormulaCellObject;
 export declare function createXlsxErrorCell(cell: Cell): {

package/dist/internal/features/work/work-xlsx-interop.d.ts

@@ -1,18 +1,21 @@
 import type { Sheet } from '@fortune-sheet/core';
 import { OoxmlPackage } from './work-ooxml-package';
-import { type FortuneConditionalFormatRule } from './work-xlsx-conditional-format';
-import { type XlsxProtectionFeatures } from './work-xlsx-protection';
-import { type XlsxManualPageBreaks } from './work-xlsx-page-breaks';
+import type { WorkSpreadsheetContent, WorkSpreadsheetDataValidationItem } from './work-types';
 import { type XlsxWorksheetChart } from './work-xlsx-charts';
+import { type XlsxDirectCellStyle } from './work-xlsx-cell-styles';
+import { type FortuneConditionalFormatRule } from './work-xlsx-conditional-format';
 import { type XlsxWorksheetImage } from './work-xlsx-images';
+import { type XlsxManualPageBreaks } from './work-xlsx-page-breaks';
 import { type XlsxPageSetup } from './work-xlsx-page-setup';
-import type { WorkSpreadsheetContent, WorkSpreadsheetDataValidationItem } from './work-types';
+import { type XlsxProtectionFeatures } from './work-xlsx-protection';
+import { type XlsxWorksheetXmlScan } from './work-xlsx-worksheet-scan';
 type FrozenPane = NonNullable<Sheet['frozen']>;
 export interface XlsxDataValidation {
     references: string[];
     item: FortuneDataValidationItem;
 }
 export interface XlsxSheetFeatures {
+    directCellStyles: XlsxDirectCellStyle[];
     frozen?: FrozenPane;
     validations: XlsxDataValidation[];
     conditionalFormats: FortuneConditionalFormatRule[];
@@ -24,6 +27,6 @@ export interface XlsxSheetFeatures {
 }
 export type FortuneDataValidationItem = WorkSpreadsheetDataValidationItem;
 export declare function readXlsxSheetFeatures(buffer: ArrayBuffer): Promise<Map<string, XlsxSheetFeatures>>;
-export declare function readXlsxSheetFeaturesFromPackage(archive: OoxmlPackage): Promise<Map<string, XlsxSheetFeatures>>;
+export declare function readXlsxSheetFeaturesFromPackage(archive: OoxmlPackage, worksheetScans?: Readonly<Record<string, XlsxWorksheetXmlScan>>): Promise<Map<string, XlsxSheetFeatures>>;
 export declare function patchXlsxSheetFeatures(buffer: ArrayBuffer, content: WorkSpreadsheetContent): Promise<ArrayBuffer>;
 export {};

package/dist/internal/features/work/work-xlsx-pivot-diagnostics.d.ts

@@ -1,3 +1,4 @@
 import type { OoxmlPackage } from './work-ooxml-package';
 import type { WorkCompatibilityIssue } from './work-types';
-export declare function diagnoseXlsxPivots(archive: OoxmlPackage): Promise<WorkCompatibilityIssue[]>;
+import { type XlsxPivotReadResult } from './work-xlsx-pivots';
+export declare function diagnoseXlsxPivots(archive: OoxmlPackage, importedInspection?: XlsxPivotReadResult | null): Promise<WorkCompatibilityIssue[]>;

package/dist/internal/features/work/work-xlsx-plain-fast-path.d.ts

@@ -0,0 +1,54 @@
+import type { SpreadsheetImportWorkbookMetadata } from './work-spreadsheet-import-worker-protocol';
+export declare const PLAIN_XLSX_COLUMN_BITS = 14;
+export declare const PLAIN_XLSX_COLUMN_MASK: number;
+export declare const PLAIN_XLSX_CELL_CHUNK_SIZE = 4096;
+export declare const PLAIN_XLSX_ROW_CHUNK_SIZE = 256;
+export declare const PLAIN_XLSX_CELL_NUMBER = 0;
+export declare const PLAIN_XLSX_CELL_BOOLEAN = 1;
+export declare const PLAIN_XLSX_CELL_ERROR = 2;
+export declare const PLAIN_XLSX_CELL_TEXT = 3;
+export interface PlainXlsxPackageParts {
+    contentTypes: string;
+    packagePaths: readonly string[];
+    rootRelationships: string;
+    workbook: string;
+    workbookRelationships: string;
+}
+export interface PlainXlsxWorkbookSheet {
+    name: string;
+    partPath: string;
+}
+export interface PlainXlsxWorkbookPlan {
+    sheets: PlainXlsxWorkbookSheet[];
+    workbook: SpreadsheetImportWorkbookMetadata;
+}
+export interface PlainXlsxCellChunk {
+    coordinates: Uint32Array;
+    kinds: Uint8Array;
+    numericValues: Float64Array;
+    startRow: number;
+    textValues: string[];
+}
+export interface PlainXlsxWorksheetResult {
+    columnCount: number;
+    populatedCellCount: number;
+    properties: Record<string, unknown>;
+    rowCount: number;
+}
+export interface PlainXlsxRangeExtent {
+    columnCount: number;
+    rowCount: number;
+}
+/**
+ * Authenticates the deliberately small OOXML subset handled by the fast
+ * worksheet parser. Any package part or workbook construct outside this
+ * closed set returns null and leaves SheetJS as the authority.
+ */
+export declare function createPlainXlsxWorkbookPlan(parts: PlainXlsxPackageParts): PlainXlsxWorkbookPlan | null;
+/**
+ * Parses primitive dense cells with a low-allocation cursor. Row chunks may be
+ * emitted provisionally; callers must use them only when the final result is
+ * non-null because a later unsupported element invalidates the whole sheet.
+ */
+export declare function streamPlainXlsxWorksheet(source: string, visit: (chunk: PlainXlsxCellChunk) => void, start?: (extent: PlainXlsxRangeExtent) => void): PlainXlsxWorksheetResult | null;
+export declare function plainXlsxRangeExtent(reference: string): PlainXlsxRangeExtent | null;

package/dist/internal/features/work/work-xlsx-style-gate.d.ts

@@ -0,0 +1 @@
+export declare function xlsxWorksheetRequiresSheetJsCellStyles(source: string): boolean;

package/dist/internal/features/work/work-xlsx-worksheet-scan.d.ts

@@ -0,0 +1,13 @@
+export interface XlsxWorksheetXmlScan {
+    hasDirectCellStyles: boolean;
+    hasDiagnosticFeatures: boolean;
+    hasFormulaFeatures: boolean;
+    hasImportedFeatures: boolean;
+    requiresSheetJsCellStyles: boolean;
+}
+/**
+ * Builds every worksheet gate in one pass over the decompressed XML. The
+ * scanner deliberately permits false positives because they only select the
+ * existing full parser path; a false negative could discard workbook state.
+ */
+export declare function scanXlsxWorksheetXml(source: string): XlsxWorksheetXmlScan;