@a3s-lab/office 0.2.2 → 0.4.0

package/dist/internal/kernel/office-kernel-protocol.d.ts

@@ -16,9 +16,14 @@ export interface OfficeKernelPageMetrics {
     footerHeight: number;
     pageGap: number;
 }
+export interface OfficeKernelPageStyle {
+    id: string;
+    page: OfficeKernelPageMetrics;
+}
 export interface OfficeKernelLayoutBlock {
     id: string;
     height: number;
+    pageStyleId?: string;
     breakBefore?: boolean;
     breakAfter?: boolean;
     keepTogether?: boolean;
@@ -38,6 +43,7 @@ export interface OfficeKernelLayoutRequest {
     documentRevision: number;
     startPageIndex: number;
     page: OfficeKernelPageMetrics;
+    pageStyles?: OfficeKernelPageStyle[];
     blocks: OfficeKernelLayoutBlock[];
 }
 export interface OfficeKernelLayoutPlacement {
@@ -48,6 +54,7 @@ export interface OfficeKernelLayoutPlacement {
 }
 export interface OfficeKernelLayoutPage {
     index: number;
+    page: OfficeKernelPageMetrics;
     usedHeight: number;
     availableHeight: number;
     placements: OfficeKernelLayoutPlacement[];

package/dist/internal/kernel/office-kernel-version.d.ts

@@ -1 +1 @@
-export declare const OFFICE_KERNEL_PROTOCOL_VERSION: 15;
+export declare const OFFICE_KERNEL_PROTOCOL_VERSION: 16;

package/dist/office-kernel.worker.js

@@ -13052,29 +13052,36 @@
     })();
     (()=>{
         const MAX_LAYOUT_BLOCKS = 10000;
+        const MAX_LAYOUT_PAGE_STYLES = MAX_LAYOUT_BLOCKS;
         const MAX_LAYOUT_EXTENT = 1000000;
         const MAX_LAYOUT_PAGE_INDEX = 1000000;
         function layoutOfficeDocumentInJavaScript(request) {
             validateLayoutRequest(request);
-            const availableHeight = Math.max(1, request.page.height - request.page.marginTop - request.page.marginBottom);
+            const pageStyles = new Map((request.pageStyles ?? []).map(({ id, page })=>[
+                    id,
+                    page
+                ]));
+            const firstPage = pageMetricsForBlock(request.blocks[0], request.page, pageStyles);
             const pages = [
-                emptyPage(request.startPageIndex, availableHeight)
+                emptyPage(request.startPageIndex, firstPage)
             ];
             let index = 0;
             while(index < request.blocks.length){
                 const block = request.blocks[index];
+                const page = pageMetricsForBlock(block, request.page, pageStyles);
+                ensurePageMetrics(pages, page);
                 if (void 0 !== block.flowCount) {
                     const end = index + block.flowCount;
-                    layoutFlow(request.blocks.slice(index, end), request.blocks.slice(end), pages, availableHeight, end < request.blocks.length);
+                    layoutFlow(request.blocks.slice(index, end), request.blocks.slice(end), pages, page, request.page, pageStyles, end < request.blocks.length);
                     index = end;
                 } else {
-                    layoutSingleBlock(block, request.blocks.slice(index + 1), pages, availableHeight, index + 1 < request.blocks.length);
+                    layoutSingleBlock(block, request.blocks.slice(index + 1), pages, page, request.page, pageStyles, index + 1 < request.blocks.length);
                     index += 1;
                 }
             }
             if (pages.length > 1 && pages.at(-1)?.placements.length === 0) pages.pop();
             return {
-                protocol: 15,
+                protocol: 16,
                 kind: 'layoutResult',
                 requestId: request.requestId,
                 revision: request.revision,
@@ -13082,66 +13089,76 @@
                 startPageIndex: request.startPageIndex,
                 engine: "javascript",
                 pages,
-                breaks: layoutBreaks(pages, request)
+                breaks: layoutBreaks(pages)
             };
         }
         function validateLayoutRequest(request) {
-            if (15 !== request.protocol) throw kernelError('office.kernel.protocol_unsupported', `Office kernel protocol ${request.protocol} is unsupported.`);
+            if (16 !== request.protocol) throw kernelError('office.kernel.protocol_unsupported', `Office kernel protocol ${request.protocol} is unsupported.`);
             if ('layout' !== request.kind) throw kernelError('office.kernel.request_kind_invalid', 'The Office kernel only accepts layout requests at this boundary.');
             if (!Number.isSafeInteger(request.requestId) || request.requestId < 0 || !Number.isSafeInteger(request.revision) || request.revision < 0 || !Number.isSafeInteger(request.documentRevision) || request.documentRevision < 0 || !Number.isSafeInteger(request.startPageIndex) || request.startPageIndex < 0) throw kernelError('office.kernel.revision_invalid', 'Request, layout, and document revisions must be non-negative safe integers.');
             if (request.startPageIndex > MAX_LAYOUT_PAGE_INDEX) throw kernelError('office.kernel.page_index_invalid', `startPageIndex may not exceed ${MAX_LAYOUT_PAGE_INDEX}.`);
             if (request.blocks.length > MAX_LAYOUT_BLOCKS) throw kernelError('office.kernel.block_limit_exceeded', `A layout request may contain at most ${MAX_LAYOUT_BLOCKS} blocks.`);
-            for (const [name, value] of Object.entries(request.page))validateExtent(`page.${name}`, value);
-            if (request.page.width <= request.page.marginLeft + request.page.marginRight) throw kernelError('office.kernel.page_width_invalid', 'Page width must be greater than its horizontal margins.');
-            if (request.page.height <= request.page.marginTop + request.page.marginBottom) throw kernelError('office.kernel.page_height_invalid', 'Page height must leave a positive body area.');
+            validatePageMetrics('page', request.page);
+            const pageStyles = request.pageStyles ?? [];
+            if (pageStyles.length > MAX_LAYOUT_PAGE_STYLES) throw kernelError('office.kernel.page_style_limit_exceeded', `A layout request may contain at most ${MAX_LAYOUT_PAGE_STYLES} page styles.`);
+            const pageStyleIds = new Set();
+            for (const style of pageStyles){
+                if (!style.id.trim() || style.id.length > 256) throw kernelError('office.kernel.page_style_id_invalid', 'Every page style requires a non-empty ID of at most 256 bytes.');
+                if (pageStyleIds.has(style.id)) throw kernelError('office.kernel.page_style_id_duplicate', `Page style ID '${style.id}' is duplicated.`);
+                pageStyleIds.add(style.id);
+                validatePageMetrics(`pageStyles.${style.id}.page`, style.page);
+            }
             const blockIds = new Set();
             for (const block of request.blocks){
                 if (!block.id.trim() || block.id.length > 256) throw kernelError('office.kernel.block_id_invalid', 'Every layout block requires a non-empty ID of at most 256 bytes.');
                 if (blockIds.has(block.id)) throw kernelError('office.kernel.block_id_duplicate', `Layout block ID '${block.id}' is duplicated.`);
                 blockIds.add(block.id);
+                if (void 0 !== block.pageStyleId && (!block.pageStyleId.trim() || block.pageStyleId.length > 256 || !pageStyleIds.has(block.pageStyleId))) throw kernelError('office.kernel.page_style_reference_invalid', `Layout block '${block.id}' references an unknown page style.`);
                 validateExtent('block.height', block.height);
                 validateFlowMetadata(block);
             }
             validateFlowSequences(request.blocks);
         }
-        function layoutSingleBlock(block, next, pages, availableHeight, hasMoreBlocks) {
+        function layoutSingleBlock(block, next, pages, page, defaultPage, pageStyles, hasMoreBlocks) {
+            const availableHeight = pageBodyHeight(page);
             let current = pages.at(-1);
             let currentHasContent = current.placements.length > 0;
             if (block.breakBefore && currentHasContent) {
-                current = emptyPage(nextPageIndex(pages), availableHeight);
+                current = emptyPage(nextPageIndex(pages), page);
                 pages.push(current);
                 currentHasContent = false;
             }
             const remaining = Math.max(0, availableHeight - current.usedHeight);
-            const nextHeight = nextBlockPreviewHeight(next);
+            const nextHeight = nextBlockPreviewHeight(next, page, defaultPage, pageStyles);
             const groupedHeight = block.height + (block.keepWithNext ? nextHeight : 0);
             const shouldAdvance = currentHasContent && (block.height > remaining || (block.keepTogether || block.keepWithNext) && groupedHeight <= availableHeight && groupedHeight > remaining);
             if (shouldAdvance) {
-                current = emptyPage(nextPageIndex(pages), availableHeight);
+                current = emptyPage(nextPageIndex(pages), page);
                 pages.push(current);
             }
             placeFragment(block, current, availableHeight);
-            if (block.breakAfter && hasMoreBlocks) pages.push(emptyPage(nextPageIndex(pages), availableHeight));
+            if (block.breakAfter && hasMoreBlocks) pages.push(emptyPage(nextPageIndex(pages), page));
         }
-        function layoutFlow(blocks, next, pages, availableHeight, hasMoreBlocks) {
+        function layoutFlow(blocks, next, pages, page, defaultPage, pageStyles, hasMoreBlocks) {
+            const availableHeight = pageBodyHeight(page);
             const first = blocks[0];
             const last = blocks.at(-1);
-            if (first.breakBefore && pages.at(-1)?.placements.length) pages.push(emptyPage(nextPageIndex(pages), availableHeight));
+            if (first.breakBefore && pages.at(-1)?.placements.length) pages.push(emptyPage(nextPageIndex(pages), page));
             const totalHeight = fragmentHeight(blocks, 0, blocks.length);
-            const nextHeight = last.keepWithNext ? nextBlockPreviewHeight(next) : 0;
+            const nextHeight = last.keepWithNext ? nextBlockPreviewHeight(next, page, defaultPage, pageStyles) : 0;
             let current = pages.at(-1);
             const repeatHeaderCount = first.repeatHeaderCount ?? 0;
             const repeatHeaderHeight = first.repeatHeaderHeight ?? 0;
             const groupedHeight = totalHeight + nextHeight;
             if (first.keepTogether && current.placements.length && groupedHeight <= availableHeight && groupedHeight > Math.max(0, availableHeight - current.usedHeight)) {
-                current = emptyPage(nextPageIndex(pages), availableHeight);
+                current = emptyPage(nextPageIndex(pages), page);
                 pages.push(current);
             }
             if (repeatHeaderCount > 0 && repeatHeaderCount < blocks.length) {
                 const leadingHeight = fragmentHeight(blocks, 0, repeatHeaderCount + 1);
                 const remainingHeight = Math.max(0, availableHeight - current.usedHeight);
                 if (current.placements.length > 0 && leadingHeight <= availableHeight && leadingHeight > remainingHeight) {
-                    current = emptyPage(nextPageIndex(pages), availableHeight);
+                    current = emptyPage(nextPageIndex(pages), page);
                     pages.push(current);
                 }
             }
@@ -13155,7 +13172,7 @@
                 const remainingFragments = blocks.length - cursor;
                 const remainingFlowHeight = fragmentHeight(blocks, cursor, blocks.length);
                 if (nextHeight > 0 && currentHasContent && remainingFlowHeight <= remainingHeight && remainingFlowHeight + nextHeight > remainingHeight && remainingFlowHeight + nextHeight <= availableHeight) {
-                    pages.push(emptyPage(nextPageIndex(pages), availableHeight));
+                    pages.push(emptyPage(nextPageIndex(pages), page));
                     continue;
                 }
                 let fitting = fragmentsFitting(blocks, cursor, blocks.length, remainingHeight);
@@ -13166,7 +13183,7 @@
                 }
                 if (0 === fitting) {
                     if (currentHasContent) {
-                        pages.push(emptyPage(nextPageIndex(pages), availableHeight));
+                        pages.push(emptyPage(nextPageIndex(pages), page));
                         continue;
                     }
                     fitting = 1;
@@ -13174,19 +13191,20 @@
                 if (remainingFragments > minimum) fitting = Math.min(fitting, remainingFragments - minimum);
                 const minimumHere = Math.min(minimum, remainingFragments);
                 if (fitting < minimumHere && currentHasContent) {
-                    pages.push(emptyPage(nextPageIndex(pages), availableHeight));
+                    pages.push(emptyPage(nextPageIndex(pages), page));
                     continue;
                 }
                 fitting = Math.max(1, fitting);
                 placeFragments(blocks, cursor, cursor + fitting, current, availableHeight);
                 cursor += fitting;
-                if (cursor < blocks.length) pages.push(emptyPage(nextPageIndex(pages), availableHeight));
+                if (cursor < blocks.length) pages.push(emptyPage(nextPageIndex(pages), page));
             }
-            if (last.breakAfter && hasMoreBlocks) pages.push(emptyPage(nextPageIndex(pages), availableHeight));
+            if (last.breakAfter && hasMoreBlocks) pages.push(emptyPage(nextPageIndex(pages), page));
         }
-        function nextBlockPreviewHeight(blocks) {
+        function nextBlockPreviewHeight(blocks, currentPage, defaultPage, pageStyles) {
             const first = blocks[0];
             if (!first || first.breakBefore) return 0;
+            if (!pageMetricsEqual(currentPage, pageMetricsForBlock(first, defaultPage, pageStyles))) return 0;
             const count = Math.min(2, first.flowCount ?? 1);
             return fragmentHeight(blocks, 0, count);
         }
@@ -13259,25 +13277,28 @@
                 const flow = blocks.slice(index, index + count);
                 if (flow.length !== count) throw kernelError('office.kernel.flow_sequence_invalid', 'A layout flow must contain its declared number of fragments.');
                 flow.forEach((fragment, flowIndex)=>{
-                    if (fragment.flowId !== block.flowId || fragment.flowIndex !== flowIndex || fragment.flowCount !== count || fragment.minimumFragmentsPerPage !== block.minimumFragmentsPerPage || fragment.repeatHeaderCount !== repeatHeaderCount || fragment.repeatHeaderHeight !== repeatHeaderHeight) throw kernelError('office.kernel.flow_sequence_invalid', 'Layout flow fragments must be consecutive and consistently indexed.');
+                    if (fragment.flowId !== block.flowId || fragment.flowIndex !== flowIndex || fragment.flowCount !== count || fragment.minimumFragmentsPerPage !== block.minimumFragmentsPerPage || fragment.repeatHeaderCount !== repeatHeaderCount || fragment.repeatHeaderHeight !== repeatHeaderHeight || fragment.pageStyleId !== block.pageStyleId) throw kernelError('office.kernel.flow_sequence_invalid', 'Layout flow fragments must be consecutive and consistently indexed.');
                     if (flowIndex > 0 && fragment.breakBefore) throw kernelError('office.kernel.flow_break_invalid', 'Only the first flow fragment may request breakBefore.');
                     if (flowIndex + 1 < count && fragment.breakAfter) throw kernelError('office.kernel.flow_break_invalid', 'Only the last flow fragment may request breakAfter.');
                 });
                 index += count;
             }
         }
-        function emptyPage(index, availableHeight) {
+        function emptyPage(index, page) {
             return {
                 index,
+                page: {
+                    ...page
+                },
                 usedHeight: 0,
-                availableHeight,
+                availableHeight: pageBodyHeight(page),
                 placements: []
             };
         }
         function nextPageIndex(pages) {
             return (pages.at(-1)?.index ?? -1) + 1;
         }
-        function layoutBreaks(pages, request) {
+        function layoutBreaks(pages) {
             return pages.slice(1).flatMap((page, localIndex)=>{
                 const beforeBlockId = page.placements[0]?.blockId;
                 const previous = pages[localIndex];
@@ -13288,11 +13309,37 @@
                         beforeBlockId,
                         pageIndex: page.index,
                         remainingBodyHeight,
-                        spacerHeight: remainingBodyHeight + request.page.marginBottom + request.page.pageGap + request.page.marginTop
+                        spacerHeight: remainingBodyHeight + previous.page.marginBottom + previous.page.pageGap + page.page.marginTop
                     }
                 ];
             });
         }
+        function ensurePageMetrics(pages, page) {
+            const current = pages.at(-1);
+            if (pageMetricsEqual(current.page, page)) return;
+            if (0 === current.placements.length && 0 === current.usedHeight) {
+                current.page = {
+                    ...page
+                };
+                current.availableHeight = pageBodyHeight(page);
+                return;
+            }
+            pages.push(emptyPage(nextPageIndex(pages), page));
+        }
+        function pageMetricsForBlock(block, defaultPage, pageStyles) {
+            return block?.pageStyleId ? pageStyles.get(block.pageStyleId) ?? defaultPage : defaultPage;
+        }
+        function pageBodyHeight(page) {
+            return Math.max(1, page.height - page.marginTop - page.marginBottom);
+        }
+        function pageMetricsEqual(left, right) {
+            return left.width === right.width && left.height === right.height && left.marginTop === right.marginTop && left.marginRight === right.marginRight && left.marginBottom === right.marginBottom && left.marginLeft === right.marginLeft && left.headerHeight === right.headerHeight && left.footerHeight === right.footerHeight && left.pageGap === right.pageGap;
+        }
+        function validatePageMetrics(name, page) {
+            for (const [property, value] of Object.entries(page))validateExtent(`${name}.${property}`, value);
+            if (page.width <= page.marginLeft + page.marginRight) throw kernelError('office.kernel.page_width_invalid', 'Page width must be greater than its horizontal margins.');
+            if (page.height <= page.marginTop + page.marginBottom) throw kernelError('office.kernel.page_height_invalid', 'Page height must leave a positive body area.');
+        }
         function validateExtent(name, value) {
             if (!Number.isFinite(value) || value < 0 || value > MAX_LAYOUT_EXTENT) throw kernelError('office.kernel.extent_invalid', `${name} must be a finite non-negative number.`);
         }
@@ -13314,7 +13361,7 @@
                 guides: []
             } : snapPresentationElement(request.elements, operation.movingElementId, operation.mode, operation.thresholdX, operation.thresholdY);
             return {
-                protocol: 15,
+                protocol: 16,
                 kind: 'presentationGeometryResult',
                 requestId: request.requestId,
                 revision: request.revision,
@@ -13462,7 +13509,7 @@
             return Math.min(Math.max(value, 0), Math.max(0, maximum));
         }
         function validatePresentationGeometryRequest(request) {
-            if (15 !== request.protocol) throw office_kernel_presentation_fallback_kernelError('office.kernel.protocol_unsupported', `Office kernel protocol ${request.protocol} is unsupported.`);
+            if (16 !== request.protocol) throw office_kernel_presentation_fallback_kernelError('office.kernel.protocol_unsupported', `Office kernel protocol ${request.protocol} is unsupported.`);
             if ('presentationGeometry' !== request.kind) throw office_kernel_presentation_fallback_kernelError('office.kernel.request_kind_invalid', 'The presentation geometry kernel received an invalid request kind.');
             for (const [name, value] of [
                 [
@@ -13853,7 +13900,7 @@
         const MAX_SPREADSHEET_IDENTIFIER_BYTES = 256;
         const MAX_UNSIGNED_32_BIT_INTEGER = 4294967295;
         function validateSpreadsheetCalculationRequest(request) {
-            if (15 !== request.protocol) throw office_kernel_spreadsheet_fallback_validation_kernelError('office.kernel.protocol_unsupported', `Office kernel protocol ${request.protocol} is unsupported.`);
+            if (16 !== request.protocol) throw office_kernel_spreadsheet_fallback_validation_kernelError('office.kernel.protocol_unsupported', `Office kernel protocol ${request.protocol} is unsupported.`);
             if ('spreadsheetCalculation' !== request.kind) throw office_kernel_spreadsheet_fallback_validation_kernelError('office.kernel.request_kind_invalid', 'The Spreadsheet kernel only accepts calculation requests.');
             if (!unsigned32BitInteger(request.requestId) || !unsigned32BitInteger(request.revision) || !nonNegativeSafeInteger(request.documentRevision)) throw office_kernel_spreadsheet_fallback_validation_kernelError('office.kernel.revision_invalid', 'Request, calculation, and document revisions must be non-negative safe integers.');
             if (request.sheets.length > MAX_SPREADSHEET_SHEETS) throw office_kernel_spreadsheet_fallback_validation_kernelError('office.kernel.spreadsheet.sheet_limit_exceeded', `A Spreadsheet calculation request may contain at most ${MAX_SPREADSHEET_SHEETS} sheets.`);
@@ -14016,7 +14063,7 @@
                     ] : [];
                 });
                 return {
-                    protocol: 15,
+                    protocol: 16,
                     kind: 'spreadsheetCalculationResult',
                     requestId: this.request.requestId,
                     revision: this.request.revision,
@@ -14313,7 +14360,7 @@
         }
         function layoutOfficeTextInJavaScript(request) {
             return {
-                protocol: 15,
+                protocol: 16,
                 kind: 'textLayoutResult',
                 requestId: request.requestId,
                 revision: request.revision,
@@ -14326,7 +14373,7 @@
         function isOfficeKernelResponse(value) {
             if (!value || 'object' != typeof value) return false;
             const candidate = value;
-            if (15 !== candidate.protocol || 'layoutResult' !== candidate.kind && 'presentationGeometryResult' !== candidate.kind && 'spreadsheetCalculationResult' !== candidate.kind && 'spreadsheetSessionCalculationResult' !== candidate.kind && 'textLayoutResult' !== candidate.kind && 'error' !== candidate.kind) return false;
+            if (16 !== candidate.protocol || 'layoutResult' !== candidate.kind && 'presentationGeometryResult' !== candidate.kind && 'spreadsheetCalculationResult' !== candidate.kind && 'spreadsheetSessionCalculationResult' !== candidate.kind && 'textLayoutResult' !== candidate.kind && 'error' !== candidate.kind) return false;
             if (!isNonNegativeInteger(candidate.requestId) || !isNonNegativeInteger(candidate.revision) || !isNonNegativeInteger(candidate.documentRevision) || 'wasm' !== candidate.engine && "javascript" !== candidate.engine) return false;
             if ('error' === candidate.kind) {
                 const error = candidate.error;
@@ -14372,7 +14419,12 @@
         function isLayoutPage(value) {
             if (!value || 'object' != typeof value) return false;
             const page = value;
-            return isNonNegativeInteger(page.index) && isNonNegativeNumber(page.usedHeight) && isNonNegativeNumber(page.availableHeight) && Array.isArray(page.placements) && page.placements.every(isLayoutPlacement);
+            return isNonNegativeInteger(page.index) && isPageMetrics(page.page) && isNonNegativeNumber(page.usedHeight) && isNonNegativeNumber(page.availableHeight) && Array.isArray(page.placements) && page.placements.every(isLayoutPlacement);
+        }
+        function isPageMetrics(value) {
+            if (!value || 'object' != typeof value) return false;
+            const page = value;
+            return isPositiveNumber(page.width) && isPositiveNumber(page.height) && isNonNegativeNumber(page.marginTop) && isNonNegativeNumber(page.marginRight) && isNonNegativeNumber(page.marginBottom) && isNonNegativeNumber(page.marginLeft) && isNonNegativeNumber(page.headerHeight) && isNonNegativeNumber(page.footerHeight) && isNonNegativeNumber(page.pageGap) && Number(page.width) > Number(page.marginLeft) + Number(page.marginRight) && Number(page.height) > Number(page.marginTop) + Number(page.marginBottom);
         }
         function isLayoutPlacement(value) {
             if (!value || 'object' != typeof value) return false;
@@ -14441,7 +14493,7 @@
                 response = wasm ? layoutWithWasm(wasm, request) : layoutOfficeDocumentInJavaScript(request);
             } catch (error) {
                 response = {
-                    protocol: 15,
+                    protocol: 16,
                     kind: 'error',
                     requestId: request.requestId,
                     revision: request.revision,
@@ -14530,7 +14582,7 @@
                 source = await WebAssembly.instantiate(await response.arrayBuffer(), {});
             }
             const exports = source.instance.exports;
-            if (!(exports.memory instanceof WebAssembly.Memory) || 15 !== exports.office_kernel_abi_version() || 'function' != typeof exports.office_kernel_presentation_geometry || 'function' != typeof exports.office_kernel_register_font || 'function' != typeof exports.office_kernel_spreadsheet_calculation || 'function' != typeof exports.office_kernel_spreadsheet_session_calculation || 'function' != typeof exports.office_kernel_text_layout) throw new Error('Office kernel WebAssembly ABI is incompatible.');
+            if (!(exports.memory instanceof WebAssembly.Memory) || 16 !== exports.office_kernel_abi_version() || 'function' != typeof exports.office_kernel_presentation_geometry || 'function' != typeof exports.office_kernel_register_font || 'function' != typeof exports.office_kernel_spreadsheet_calculation || 'function' != typeof exports.office_kernel_spreadsheet_session_calculation || 'function' != typeof exports.office_kernel_text_layout) throw new Error('Office kernel WebAssembly ABI is incompatible.');
             return exports;
         }
         function registerFontWithWasm(wasm, id, data) {
@@ -14589,7 +14641,7 @@
         }
         function errorResponse(request, error) {
             return {
-                protocol: 15,
+                protocol: 16,
                 kind: 'error',
                 requestId: request.requestId,
                 revision: request.revision,

package/dist/react.d.ts

@@ -1,6 +1,8 @@
+import type { WorkOfficeCollaborationPresence } from './internal/collaboration/office-collaboration-presence';
 import type { DocumentEditorProps as InternalDocumentEditorProps } from './internal/features/work/editors/document-editor';
 import type { MarkdownEditorProps as InternalMarkdownEditorProps } from './internal/features/work/editors/markdown-editor';
 import type { PdfViewerProps as InternalPdfViewerProps } from './internal/features/work/editors/pdf-viewer';
+export { PDF_EVIDENCE_COORDINATE_BASIS, type PdfEvidenceBounds, type PdfEvidenceOverlay, type PdfEvidencePage, type PdfEvidenceRegion, type PdfEvidenceRegionLocation, } from './internal/features/work/editors/pdf-evidence-contract';
 import type { PresentationEditorProps as InternalPresentationEditorProps } from './internal/features/work/editors/presentation-editor';
 import type { SpreadsheetEditorProps as InternalSpreadsheetEditorProps } from './internal/features/work/editors/spreadsheet-editor';
 import type { WorkOfficeFileAction } from './internal/features/work/editors/work-office-chrome';
@@ -27,25 +29,29 @@ export interface DocumentLayoutFont {
     style?: 'normal' | 'italic';
 }
 export declare const defaultDocumentLayoutFonts: readonly DocumentLayoutFont[];
-export type { WorkOfficeFileAction as OfficeFileAction };
-export type { OfficeSurfaceProps, OfficeTheme };
-export interface DocumentEditorProps extends Omit<InternalDocumentEditorProps, 'layoutFonts' | 'preview'>, OfficeSurfaceProps {
+export type { OfficeSurfaceProps, OfficeTheme, WorkOfficeFileAction as OfficeFileAction, };
+interface OfficeCollaborationSurfaceProps {
+    /** Host-owned Awareness projection paired with the editor collaboration session. */
+    presence?: WorkOfficeCollaborationPresence;
+}
+export interface DocumentEditorProps extends Omit<InternalDocumentEditorProps, 'defaultRibbonCollapsed' | 'layoutFonts' | 'preview'>, OfficeSurfaceProps, OfficeCollaborationSurfaceProps {
     preview?: boolean;
+    defaultRibbonCollapsed?: boolean;
     layoutFonts?: readonly DocumentLayoutFont[];
 }
-export declare function DocumentEditor({ className, kernelWasmUrl, layoutFonts, preview, style, theme, ...editorProps }: DocumentEditorProps): import("react").JSX.Element;
-export interface MarkdownEditorProps extends Omit<InternalMarkdownEditorProps, 'preview'>, OfficeSurfaceProps {
+export declare function DocumentEditor({ className, defaultRibbonCollapsed, kernelWasmUrl, layoutFonts, presence, preview, style, theme, ...editorProps }: DocumentEditorProps): import("react").JSX.Element;
+export interface MarkdownEditorProps extends Omit<InternalMarkdownEditorProps, 'preview'>, OfficeSurfaceProps, OfficeCollaborationSurfaceProps {
     preview?: boolean;
 }
-export declare function MarkdownEditor({ className, preview, style, theme, ...editorProps }: MarkdownEditorProps): import("react").JSX.Element;
-export interface SpreadsheetEditorProps extends Omit<InternalSpreadsheetEditorProps, 'preview'>, OfficeSurfaceProps {
+export declare function MarkdownEditor({ className, presence, preview, style, theme, ...editorProps }: MarkdownEditorProps): import("react").JSX.Element;
+export interface SpreadsheetEditorProps extends Omit<InternalSpreadsheetEditorProps, 'preview'>, OfficeSurfaceProps, OfficeCollaborationSurfaceProps {
     preview?: boolean;
 }
-export declare function SpreadsheetEditor({ className, kernelWasmUrl, preview, style, theme, ...editorProps }: SpreadsheetEditorProps): import("react").JSX.Element;
-export interface PresentationEditorProps extends Omit<InternalPresentationEditorProps, 'preview'>, OfficeSurfaceProps {
+export declare function SpreadsheetEditor({ className, kernelWasmUrl, presence, preview, style, theme, ...editorProps }: SpreadsheetEditorProps): import("react").JSX.Element;
+export interface PresentationEditorProps extends Omit<InternalPresentationEditorProps, 'preview'>, OfficeSurfaceProps, OfficeCollaborationSurfaceProps {
     preview?: boolean;
 }
-export declare function PresentationEditor({ className, kernelWasmUrl, preview, style, theme, ...editorProps }: PresentationEditorProps): import("react").JSX.Element;
-export interface PdfViewerProps extends InternalPdfViewerProps, OfficeSurfaceProps {
+export declare function PresentationEditor({ className, kernelWasmUrl, presence, preview, style, theme, ...editorProps }: PresentationEditorProps): import("react").JSX.Element;
+export interface PdfViewerProps extends InternalPdfViewerProps, OfficeSurfaceProps, OfficeCollaborationSurfaceProps {
 }
-export declare function PdfViewer({ className, style, theme, wasmUrl, ...viewerProps }: PdfViewerProps): import("react").JSX.Element;
+export declare function PdfViewer({ className, presence, style, theme, wasmUrl, ...viewerProps }: PdfViewerProps): import("react").JSX.Element;

package/dist/react.js

@@ -1 +1 @@
-export { DocumentEditor, MarkdownEditor, PdfViewer, PresentationEditor, SpreadsheetEditor, defaultDocumentArabicLayoutFontUrl, defaultDocumentHebrewLayoutFontUrl, defaultDocumentLatinLayoutFontUrl, defaultDocumentLayoutFontUrl, defaultDocumentLayoutFonts, defaultOfficeKernelWasmUrl, defaultPdfiumWasmUrl, preloadOfficeEditor } from "./432.js";
+export { DocumentEditor, MarkdownEditor, PDF_EVIDENCE_COORDINATE_BASIS, PdfViewer, PresentationEditor, SpreadsheetEditor, defaultDocumentArabicLayoutFontUrl, defaultDocumentHebrewLayoutFontUrl, defaultDocumentLatinLayoutFontUrl, defaultDocumentLayoutFontUrl, defaultDocumentLayoutFonts, defaultOfficeKernelWasmUrl, defaultPdfiumWasmUrl, preloadOfficeEditor } from "./432.js";