oasis-editor 0.0.145 → 0.0.147

package/dist/core/commands/table/tableCommandUtils.d.ts

@@ -1,4 +1,4 @@
-import { EditorBlockNode, EditorDocument, EditorEditingZone, EditorState, EditorTableNode, TableLocation, EditorRevisionMetadata } from '../../model.js';
+import { EditorBlockNode, EditorDocument, EditorEditingZone, EditorState, EditorTableNode, TableLocation, TablePathSegment, EditorRevisionMetadata } from '../../model.js';
 
 export type StylePatchValue<T, K extends keyof T> = T[K] | null;
 export interface ActiveTableLocation {
@@ -14,4 +14,10 @@ export declare function updateTablesInBlocks(blocks: EditorBlockNode[], updateTa
 export declare function updateNestedTablesInBlocks(blocks: EditorBlockNode[], updateTable: (table: EditorTableNode) => EditorTableNode): EditorBlockNode[];
 export declare function getBlocksForZone(document: EditorDocument, sectionIndex: number, zone: EditorEditingZone): EditorBlockNode[] | undefined;
 export declare function resolveActiveTableLocation(state: EditorState): ActiveTableLocation | null;
+/**
+ * Applies `updateTable` to exactly the table identified by `tablePath`.
+ * Ancestor tables/cells are copied only along the target path, preserving
+ * structural sharing for every unrelated block and cell.
+ */
+export declare function updateTableAtPath(blocks: EditorBlockNode[], tablePath: readonly TablePathSegment[], updateTable: (table: EditorTableNode) => EditorTableNode): EditorBlockNode[];
 export declare function updateActiveTableBlocks(state: EditorState, updateTable: (table: EditorTableNode) => EditorTableNode): EditorState;

package/dist/core/editorState/nodeFactories.d.ts

@@ -18,7 +18,7 @@ export declare function createEditorParagraphFromRuns(runs: Array<{
     image?: EditorImageRunData;
     textBox?: EditorTextBoxData;
 }>): EditorParagraphNode;
-export declare function createEditorTableCell(paragraphs: EditorParagraphNode[], colSpan?: number, options?: {
+export declare function createEditorTableCell(blocks: EditorBlockNode[], colSpan?: number, options?: {
     rowSpan?: number;
     vMerge?: "restart" | "continue";
 }): EditorTableCellNode;

package/dist/core/model/documentIndex.d.ts

@@ -1,4 +1,4 @@
-import { EditorParagraphNode } from './types/nodes.js';
+import { EditorBlockNode, EditorParagraphNode, EditorTableCellNode, EditorTableNode } from './types/nodes.js';
 import { EditorDocument } from './types/document.js';
 import { EditorEditingZone } from './types/selection.js';
 
@@ -9,11 +9,33 @@ export interface EditorParagraphLocation {
     /** When `zone === "footnote"`, identifies which footnote owns the paragraph. */
     footnoteId?: string;
 }
+/**
+ * One table hop from a block story into a cell. `tableBlockIndex` is relative
+ * to the story that contains that table: a section/header/footer story for the
+ * first hop, then the parent cell's `blocks` array for every nested hop.
+ */
+export interface TablePathSegment {
+    tableBlockIndex: number;
+    rowIndex: number;
+    cellIndex: number;
+}
 export interface TableLocation {
+    /** Top-level table block index. Retained for legacy one-level consumers. */
     blockIndex: number;
+    /** Top-level row index. Retained for legacy one-level consumers. */
     rowIndex: number;
+    /** Top-level cell index. Retained for legacy one-level consumers. */
     cellIndex: number;
+    /** Paragraph block index inside the innermost cell story. */
     paragraphIndex: number;
+    /** Complete outer-to-inner path. One entry means a legacy direct table. */
+    tablePath: TablePathSegment[];
+}
+export interface ResolvedTablePath {
+    table: EditorTableNode;
+    cell: EditorTableCellNode;
+    segment: TablePathSegment;
+    depth: number;
 }
 export interface DocumentParagraphIndexEntry {
     paragraph: EditorParagraphNode;
@@ -26,7 +48,8 @@ export declare class DocumentIndexBuilder {
     constructor(document: EditorDocument);
     build(): Map<string, DocumentParagraphIndexEntry>;
     private indexZone;
-    private indexBlock;
+    private indexTable;
+    private indexTopLevelBlock;
     private recordParagraph;
     private indexFootnotes;
 }
@@ -53,6 +76,16 @@ export declare function getDocumentParagraphsCanonical(document: EditorDocument)
 export declare function getDocumentParagraphs(document: EditorDocument): EditorParagraphNode[];
 export declare function getParagraphById(document: EditorDocument, paragraphId: string): EditorParagraphNode | undefined;
 export declare function findParagraphLocation(document: EditorDocument, paragraphId: string): EditorParagraphLocation | null;
+/** Returns the complete path, including nested tables. */
+export declare function findParagraphTablePathLocation(document: EditorDocument, paragraphId: string, activeSectionIndex?: number): (TableLocation & {
+    zone: EditorEditingZone;
+}) | null;
+/**
+ * Legacy one-level lookup. Nested table paragraphs intentionally return null so
+ * older merge/split callers cannot accidentally mutate the outer table.
+ */
 export declare function findParagraphTableLocation(document: EditorDocument, paragraphId: string, activeSectionIndex?: number): (TableLocation & {
     zone: EditorEditingZone;
 }) | null;
+/** Resolve every table/cell hop from a zone block story. */
+export declare function resolveTablePath(blocks: EditorBlockNode[], tablePath: readonly TablePathSegment[]): ResolvedTablePath[] | null;

package/dist/core/model/index.d.ts

@@ -29,8 +29,8 @@ export type { StyleMerger, Mergeable } from './styleResolution.js';
 export { resolveImageSrc } from './assets.js';
 export { normalizePageSettings, getDocumentPageSettings, getPageContentWidth, getPageColumnRects, getPageHeaderZoneTop, getPageBodyTop, getPageFooterReferenceTop, getPageBodyBottom, getPageHeaderZoneHeight, getPageFooterZoneTop, getPageFooterZoneHeight, getPageContentHeight, } from './pageGeometry.js';
 export { getDocumentSections, getDocumentSectionsCanonical, } from './documentSections.js';
-export { DocumentIndexBuilder, getDocumentParagraphIndex, getDocumentParagraphs, getDocumentParagraphsCanonical, getParagraphById, findParagraphLocation, findParagraphTableLocation, WeakMapDocumentIndexCache, } from './documentIndex.js';
-export type { EditorParagraphLocation, TableLocation, DocumentParagraphIndexEntry, DocumentIndexCache, } from './documentIndex.js';
+export { DocumentIndexBuilder, getDocumentParagraphIndex, getDocumentParagraphs, getDocumentParagraphsCanonical, getParagraphById, findParagraphLocation, findParagraphTableLocation, findParagraphTablePathLocation, resolveTablePath, WeakMapDocumentIndexCache, } from './documentIndex.js';
+export type { EditorParagraphLocation, TableLocation, TablePathSegment, DocumentParagraphIndexEntry, DocumentIndexCache, } from './documentIndex.js';
 export { getBlockParagraphs, collectSectionParagraphs, } from './paragraphWalker.js';
 export { buildListLabels, resolveListLabel } from './listNumbering.js';
 export { getActiveSectionIndex, getActiveZone, getEditableBlocksForZone, tryGetEditableBlocksForZone, getActiveSectionBlocks, getParagraphs, } from './editingZones.js';

package/dist/core/model/types/docxSourcePackage.d.ts

@@ -43,4 +43,11 @@ export interface EditorDocxSourcePackage {
     rootRelationships: EditorOpcRelationship[];
     parts: Record<string, EditorOpcPart>;
     diagnostics?: EditorDocxDiagnostic[];
+    /**
+     * Hashes of the canonical Oasis rebuild immediately after import, keyed by
+     * conventional rebuilt part path. During source-backed export an equal hash
+     * proves that the modeled semantic domain did not change, allowing the exact
+     * source part bytes to remain untouched instead of being reserialized.
+     */
+    rebuiltPartHashes?: Record<string, string>;
 }

package/dist/core/model/types/nodes.d.ts

@@ -290,7 +290,8 @@ export interface EditorParagraphNode {
 }
 export interface EditorTableCellNode {
     id: string;
-    blocks: EditorParagraphNode[];
+    /** Ordered block story inside the cell; Word permits paragraphs and tables. */
+    blocks: EditorBlockNode[];
     colSpan?: number;
     rowSpan?: number;
     vMerge?: "restart" | "continue";

package/dist/export/docx/docxNumbering.d.ts

@@ -4,7 +4,10 @@ import { NumberingContext, NumberingDefinition } from './docxTypes.js';
 /**
  * Walks the document (including headers/footers and nested content) collecting
  * list paragraphs into abstract numbering definitions and a per-paragraph
- * numId/level map. Extracted from exportEditorDocumentToDocx (S2).
+ * numId/level map. Imported list identities are retained whenever possible so
+ * source-backed export can key granular numbering preservation by stable OOXML
+ * ids. New ids are allocated above the source package's maximum to avoid
+ * colliding with source-only definitions that still need preservation.
  */
 export declare function buildNumberingContext(document: EditorDocument): NumberingContext;
 export declare function buildNumberingXml(definitions: NumberingDefinition[]): string;

package/dist/export/docx/endnotesXml.d.ts

@@ -2,17 +2,14 @@ import { EditorBlockNode, EditorDocument, EditorEndnote, EditorNamedStyle } from
 import { DocContext, ExportBuildState, NumberingContext } from './docxTypes.js';
 
 export interface ReferencedEndnote {
-    /** Local editor id. */
     endnoteId: string;
-    /** DOCX numeric id used in `w:endnoteReference w:id="N"` and `w:endnote w:id="N"`. */
     docxId: number;
-    /** Endnote body. */
     endnote: EditorEndnote;
 }
 /**
  * Walks the document in reading order and returns one entry per distinct
- * endnote id that is actually referenced by an inline run. Unreferenced
- * endnotes in the registry are skipped.
+ * referenced endnote. Imported positive `w:id` values are retained when
+ * unique; new/conflicting notes are allocated above every imported id.
  */
 export declare function collectReferencedEndnotesForExport(document: EditorDocument): ReferencedEndnote[];
 export declare function buildEndnoteIdMap(referenced: ReferencedEndnote[]): Map<string, number>;

package/dist/export/docx/footnotesXml.d.ts

@@ -2,39 +2,21 @@ import { EditorBlockNode, EditorDocument, EditorFootnote, EditorNamedStyle } fro
 import { DocContext, ExportBuildState, NumberingContext } from './docxTypes.js';
 
 export interface ReferencedFootnote {
-    /** Local editor id. */
     footnoteId: string;
-    /** DOCX numeric id used in `w:footnoteReference w:id="N"` and `w:footnote w:id="N"`. */
     docxId: number;
-    /** Footnote body. */
     footnote: EditorFootnote;
 }
 /**
  * Walks the document in reading order and returns one entry per distinct
- * footnote id that is actually referenced by an inline run. Unreferenced
- * footnotes in the registry are skipped.
- *
- * Returns an empty list when the document has no footnotes.
+ * referenced footnote. Imported positive `w:id` values are retained when
+ * unique; new/conflicting notes are allocated above every imported id.
  */
 export declare function collectReferencedFootnotesForExport(document: EditorDocument): ReferencedFootnote[];
 export declare function buildFootnoteIdMap(referenced: ReferencedFootnote[]): Map<string, number>;
-/**
- * Serialize the footnote bodies into the `<w:footnotes>` part XML, including
- * the conventional special entries (`separator` and `continuationSeparator`).
- *
- * `bodyContext` is the parent `DocContext`. We need it only to share the
- * footnoteIdMap; image/hyperlink relationships specific to the footnotes
- * part are returned via `partContext` (separate rels file).
- */
 export interface FootnotesPartResult {
     xml: string;
     partContext: DocContext;
 }
-export declare function buildFootnotesXml(document: EditorDocument, referenced: ReferencedFootnote[], numberingContext: NumberingContext, state: ExportBuildState, buildContext: (blocks: EditorBlockNode[]) => DocContext, styles: Record<string, EditorNamedStyle> | undefined, footnoteIdMap: Map<string, number>): FootnotesPartResult;
-/**
- * Convenience: figure out if the document has at least one referenced
- * footnote — used by callers to decide whether to emit the part at all.
- */
+export declare function buildFootnotesXml(_document: EditorDocument, referenced: ReferencedFootnote[], _numberingContext: NumberingContext, _state: ExportBuildState, buildContext: (blocks: EditorBlockNode[]) => DocContext, styles: Record<string, EditorNamedStyle> | undefined, footnoteIdMap: Map<string, number>): FootnotesPartResult;
 export declare function hasReferencedFootnotes(document: EditorDocument): boolean;
-/** Re-export to keep the public surface small. */
 export type { DocContext, NumberingContext, ExportBuildState };

package/dist/export/docx/noteDocxIds.d.ts

@@ -0,0 +1,9 @@
+export interface NoteWithDocxIdHint {
+    docxId?: number;
+}
+/**
+ * Allocates real footnote/endnote ids while keeping imported identities stable.
+ * New or conflicting ids are placed above every imported id in the registry so
+ * source-backed entry preservation cannot collide with a source-only note.
+ */
+export declare function createSourceAwareNoteDocxIdAllocator<T extends NoteWithDocxIdHint>(items: Record<string, T>): (note: T) => number;

package/dist/export/docx/opc/commentEntrySourcePatcher.d.ts

@@ -0,0 +1,5 @@
+import { default as JSZip } from 'jszip';
+import { EditorDocxSourcePackage } from '../../../core/model.js';
+
+export declare function mergeCommentEntriesOoxmlSource(sourceXml: string, rebuiltXml: string): string;
+export declare function patchRebuiltCommentEntriesFromSource(sourcePackage: EditorDocxSourcePackage, rebuilt: JSZip): Promise<boolean>;

package/dist/export/docx/opc/commentsExtendedSourcePatcher.d.ts

@@ -0,0 +1,5 @@
+import { default as JSZip } from 'jszip';
+import { EditorDocxSourcePackage } from '../../../core/model.js';
+
+export declare function mergeCommentsExtendedOoxmlSource(sourceCommentsXml: string, sourceExtendedXml: string, rebuiltCommentsXml: string, rebuiltExtendedXml: string): string;
+export declare function patchRebuiltCommentsExtendedFromSource(sourcePackage: EditorDocxSourcePackage, rebuilt: JSZip): Promise<boolean>;

package/dist/export/docx/opc/documentRootSourcePatcher.d.ts

@@ -0,0 +1,5 @@
+import { default as JSZip } from 'jszip';
+import { EditorDocxSourcePackage } from '../../../core/model.js';
+
+export declare function mergeDocumentRootAndBodyExtensionsFromSource(sourceXml: string, rebuiltXml: string): string;
+export declare function patchRebuiltDocumentRootFromSource(sourcePackage: EditorDocxSourcePackage, rebuilt: JSZip): Promise<boolean>;

package/dist/export/docx/opc/extensionMarkupMerge.d.ts

@@ -0,0 +1,9 @@
+import { Element as XmlElement } from '@xmldom/xmldom';
+
+/**
+ * Recursively carries extension-namespace markup through a generated Word
+ * subtree. WordprocessingML attributes/children that disappeared from the
+ * generated form are never restored, so preservation cannot undo an editor
+ * deletion or overwrite canonical modeled semantics.
+ */
+export declare function mergeNestedExtensionMarkup(source: XmlElement, generated: XmlElement): void;

package/dist/export/docx/opc/headerFooterRootSourcePatcher.d.ts

@@ -0,0 +1,11 @@
+import { default as JSZip } from 'jszip';
+import { EditorDocxSourcePackage } from '../../../core/model.js';
+
+/**
+ * Preserves root namespace/compatibility attributes and opaque extension
+ * children in changed header/footer parts before the existing source-path
+ * patcher relocates those parts back to their original relationship targets.
+ * Pairing uses the same stable section/kind/type/occurrence identity as the
+ * path-preservation layer and is disabled when section topology diverges.
+ */
+export declare function patchRebuiltHeaderFooterRootsFromSource(sourcePackage: EditorDocxSourcePackage, rebuilt: JSZip): Promise<boolean>;

package/dist/export/docx/opc/headerFooterSourcePatcher.d.ts

@@ -0,0 +1,9 @@
+import { EditorDocument } from '../../../core/model.js';
+
+/**
+ * Prepares collection-valued header/footer relationships before the general
+ * source-package merge. Pairing uses section index and reference type, source
+ * paths and r:ids are restored, unchanged parts are omitted so their original
+ * bytes survive, and explicit removals are filtered from the source snapshot.
+ */
+export declare function patchRebuiltDocxWithHeaderFooterSourcePaths(document: EditorDocument, rebuiltBuffer: ArrayBuffer): Promise<ArrayBuffer>;

package/dist/export/docx/opc/headerFooterStoryReferences.d.ts

@@ -0,0 +1,14 @@
+export type HeaderFooterStoryKind = "header" | "footer";
+export interface HeaderFooterStoryReference {
+    kind: HeaderFooterStoryKind;
+    type: string;
+    occurrence: number;
+    relationshipId: string;
+}
+/**
+ * Reads active section header/footer references without assuming `w` or `r`
+ * prefix spellings. The semantic identity is namespace URI + local name; the
+ * relationship id is intentionally read by local name so Transitional, Strict
+ * and producer-chosen relationship prefixes all remain discoverable.
+ */
+export declare function collectHeaderFooterStoryReferences(xml: string): HeaderFooterStoryReference[];

package/dist/export/docx/opc/noteEntrySourcePatcher.d.ts

@@ -0,0 +1,4 @@
+import { default as JSZip } from 'jszip';
+import { EditorDocument, EditorDocxSourcePackage } from '../../../core/model.js';
+
+export declare function patchRebuiltNoteEntriesFromSource(document: EditorDocument, sourcePackage: EditorDocxSourcePackage, rebuilt: JSZip): Promise<boolean>;

package/dist/export/docx/opc/numberingSourcePatcher.d.ts

@@ -0,0 +1,5 @@
+import { default as JSZip } from 'jszip';
+import { EditorDocxSourcePackage } from '../../../core/model.js';
+
+export declare function mergeNumberingOoxmlSource(sourceXml: string, rebuiltXml: string): string;
+export declare function patchRebuiltNumberingFromSource(sourcePackage: EditorDocxSourcePackage, rebuilt: JSZip): Promise<boolean>;

package/dist/export/docx/opc/rebuiltPartHashes.d.ts

@@ -0,0 +1,5 @@
+import { EditorDocument } from '../../../core/model.js';
+
+export declare function hashDocxPartBytes(bytes: Uint8Array): string;
+export declare function hashRebuiltDocxParts(buffer: ArrayBuffer): Promise<Record<string, string>>;
+export declare function captureRebuiltDocxPartHashes(document: EditorDocument): Promise<Record<string, string>>;

package/dist/export/docx/opc/relatedStoryRootSourcePatcher.d.ts

@@ -0,0 +1,11 @@
+import { default as JSZip } from 'jszip';
+import { EditorDocxSourcePackage } from '../../../core/model.js';
+
+/**
+ * Preserves compatibility attributes, namespaces and non-Word extension
+ * children at the roots of secondary WordprocessingML stories. Note/comment
+ * entries themselves remain owned by their semantic serializers; this layer
+ * intentionally does not resurrect a deleted `w:footnote`, `w:endnote` or
+ * `w:comment`.
+ */
+export declare function patchRebuiltRelatedStoryRootsFromSource(sourcePackage: EditorDocxSourcePackage, rebuilt: JSZip): Promise<boolean>;

package/dist/export/docx/opc/sectionPropertiesSourcePatcher.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Overlays source-only document/section markup onto a rebuilt document.xml.
+ *
+ * The rebuilt document remains authoritative for the OOXML surface Oasis
+ * models. Unknown root attributes, unknown sectPr attributes/children, and
+ * producer-specific extensions are retained as long as section topology is
+ * unchanged. Relationship/content-type preservation is handled by the outer
+ * source-package patcher.
+ */
+export declare function mergeRebuiltDocumentSectionPropertiesFromSource(sourceXml: string, rebuiltXml: string): string;

package/dist/export/docx/opc/sourceBackedDocxPatcher.d.ts

@@ -0,0 +1,4 @@
+import { EditorDocument } from '../../../core/model.js';
+
+/** Applies all source-aware prepatches before the generic OPC overlay. */
+export declare function patchRebuiltDocxPreservingSource(document: EditorDocument, rebuiltBuffer: ArrayBuffer): Promise<ArrayBuffer>;

package/dist/export/docx/opc/sourceOnlySingletonFilter.d.ts

@@ -0,0 +1,19 @@
+import { default as JSZip } from 'jszip';
+
+export interface RebuiltSingletonPresence {
+    settings: boolean;
+    styles: boolean;
+    fontTable: boolean;
+}
+/**
+ * When the ordinary exporter omitted a modeled singleton but the source-aware
+ * prepatch restored it for preservation, strip modeled semantics before the
+ * OPC merge. This prevents an explicit "delete the last setting/style/font"
+ * edit from being undone while still retaining unsupported source markup.
+ *
+ * Numbering is intentionally not filtered here: unused numbering definitions
+ * have no document-visible effect once all numPr references are gone, and
+ * preserving them avoids needless loss until source ID stabilization lets us
+ * merge active numbering graphs safely.
+ */
+export declare function filterSourceOnlyWordSingletons(rebuilt: JSZip, originallyPresent: RebuiltSingletonPresence): Promise<boolean>;

package/dist/export/docx/opc/sourcePackagePatcher.d.ts

@@ -1,8 +1,12 @@
 import { EditorDocument } from '../../../core/model.js';
 
 /**
- * Clones the imported package and overlays the freshly rebuilt Oasis parts.
- * Unknown source parts remain untouched. Content types and relationship parts
- * are merged instead of blindly replaced so unrelated package features survive.
+ * Clones the imported package and overlays only changed freshly rebuilt Oasis
+ * parts. Unknown source parts remain untouched. Content types and relationship
+ * parts are merged instead of blindly replaced so unrelated package features
+ * survive. Relationship-discovered source paths remain authoritative: rebuilt
+ * parts are relocated to those paths and their internal targets are rebased.
+ * Modeled singleton parts present in the import baseline but absent from the
+ * current rebuild are treated as explicit deletions rather than resurrected.
  */
 export declare function patchRebuiltDocxWithSourcePackage(document: EditorDocument, rebuiltBuffer: ArrayBuffer): Promise<ArrayBuffer>;

package/dist/export/docx/opc/styleParagraphPropertiesSourcePatcher.d.ts

@@ -0,0 +1,5 @@
+import { default as JSZip } from 'jszip';
+import { EditorDocxSourcePackage } from '../../../core/model.js';
+
+export declare function mergeStyleParagraphPropertiesOoxmlSource(sourceXml: string, rebuiltXml: string): string;
+export declare function patchRebuiltStyleParagraphPropertiesFromSource(sourcePackage: EditorDocxSourcePackage, rebuilt: JSZip): Promise<boolean>;

package/dist/export/docx/opc/styleRunPropertiesSourcePatcher.d.ts

@@ -0,0 +1,5 @@
+import { default as JSZip } from 'jszip';
+import { EditorDocxSourcePackage } from '../../../core/model.js';
+
+export declare function mergeStyleRunPropertiesOoxmlSource(sourceXml: string, rebuiltXml: string): string;
+export declare function patchRebuiltStyleRunPropertiesFromSource(sourcePackage: EditorDocxSourcePackage, rebuilt: JSZip): Promise<boolean>;

package/dist/export/docx/opc/styleTablePropertiesSourcePatcher.d.ts

@@ -0,0 +1,5 @@
+import { default as JSZip } from 'jszip';
+import { EditorDocxSourcePackage } from '../../../core/model.js';
+
+export declare function mergeTableStylePropertiesOoxmlSource(sourceXml: string, rebuiltXml: string): string;
+export declare function patchRebuiltTableStylePropertiesFromSource(sourcePackage: EditorDocxSourcePackage, rebuilt: JSZip): Promise<boolean>;

package/dist/export/docx/opc/universalContainerPatcher.d.ts

@@ -0,0 +1 @@
+export declare function preserveNamespacesAndMc(sourceXml: string, rebuiltXml: string): string;

package/dist/export/docx/opc/wordPartRootSourcePatcher.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Preserves root-level producer/extension markup for a rewritten Word part.
+ *
+ * Word-namespace children are deliberately left to the semantic story model:
+ * copying them here could resurrect a paragraph/table/content control that the
+ * user intentionally removed. Non-Word children are opaque extension markup;
+ * preserving them is safe because Oasis does not currently expose semantic
+ * deletion/editing for those nodes. Namespace declarations and compatibility
+ * attributes on the root are preserved as well.
+ */
+export declare function mergeWordPartRootExtensionsFromSource(sourceXml: string, rebuiltXml: string, expectedRootLocalName: string): string;
+/**
+ * Extends root preservation to unsupported WordprocessingML flow wrappers in a
+ * story (`customXml`, revision wrappers, `altChunk`, future Word children).
+ *
+ * The wrapper is restored only when its source gap is unambiguous: preferably
+ * through the next original paragraph's `w14:paraId` or SDT id, otherwise via
+ * an unchanged p/tbl/sdt topology. This keeps non-structural edits lossless
+ * without using raw child indexes after structural changes.
+ */
+export declare function mergeWordStoryRootAndFlowFromSource(sourceXml: string, rebuiltXml: string, expectedRootLocalName: string, modeledChildNames?: ReadonlySet<string>): string;

package/dist/export/docx/opc/wordSingletonSourcePatcher.d.ts

@@ -0,0 +1,14 @@
+import { default as JSZip } from 'jszip';
+import { EditorDocxSourcePackage } from '../../../core/model.js';
+
+/**
+ * Prepares rewritten Word singleton parts before the generic OPC overlay.
+ *
+ * - If Oasis did not rebuild a source singleton, keep the source part instead
+ *   of interpreting omission as deletion.
+ * - If Oasis rebuilt a safely keyable singleton, merge source-only markup while
+ *   leaving generated modeled values authoritative.
+ *
+ * Relationship and content-type paths are remapped later by sourcePackagePatcher.
+ */
+export declare function patchRebuiltWordSingletonsFromSource(sourcePackage: EditorDocxSourcePackage, rebuilt: JSZip): Promise<boolean>;

package/dist/export/docx/tableSourcePropertiesXml.d.ts

@@ -0,0 +1,13 @@
+import { EditorTableCellNode, EditorTableNode, EditorTableRowNode } from '../../core/model.js';
+
+/** Source-aware merge for a standalone `w:tblPr` such as a table style. */
+export declare function mergeTablePropertiesXmlSource(sourceXml: string, generatedXml: string): string;
+/** Source-aware merge for a standalone `w:trPr` such as `w:tblStylePr`. */
+export declare function mergeTableRowPropertiesXmlSource(sourceXml: string, generatedXml: string): string;
+/** Source-aware merge for a standalone `w:tcPr` such as `w:tblStylePr`. */
+export declare function mergeTableCellPropertiesXmlSource(sourceXml: string, generatedXml: string): string;
+export declare function mergeTablePropertiesOoxmlSource(table: EditorTableNode, generatedXml: string): string;
+export declare function mergeTableGridOoxmlSource(table: EditorTableNode, generatedXml: string): string;
+export declare function mergeTableRowPropertyExceptionsOoxmlSource(row: EditorTableRowNode, generatedXml: string): string;
+export declare function mergeTableRowPropertiesOoxmlSource(row: EditorTableRowNode, generatedXml: string): string;
+export declare function mergeTableCellPropertiesOoxmlSource(cell: EditorTableCellNode, generatedXml: string): string;

package/dist/export/docx/tableSourceXml.d.ts

@@ -0,0 +1,10 @@
+import { EditorTableNode } from '../../core/model.js';
+import { SerializeTableParagraphXml } from './tableXml.js';
+
+/**
+ * Serializes a table canonically and then overlays source-backed table, row and
+ * cell property containers. Text/content stays authoritative from the editor;
+ * source attributes, extension children and unknown property children survive
+ * while relationship-bearing fragments continue to use the conservative path.
+ */
+export declare function serializeTableXmlPreservingSource(table: EditorTableNode, serializeParagraphXml: SerializeTableParagraphXml): string;

package/dist/export/docx/tableXml.d.ts

@@ -1,6 +1,8 @@
-import { EditorParagraphNode, EditorTableCellNode, EditorTableNode, EditorTableRowStyle } from '../../core/model.js';
+import { EditorBlockNode, EditorTableCellNode, EditorTableNode, EditorTableRowStyle } from '../../core/model.js';
 
-export type SerializeTableParagraphXml = (paragraph: EditorParagraphNode, cell: EditorTableCellNode) => string;
+export type SerializeTableBlockXml = (block: EditorBlockNode, cell: EditorTableCellNode) => string;
+/** @deprecated Use {@link SerializeTableBlockXml}; retained for source compatibility. */
+export type SerializeTableParagraphXml = SerializeTableBlockXml;
 export declare function serializeTableCellStyleXml(style: EditorTableCellNode["style"]): string;
 /**
  * Serializes the core row style properties into `<w:trPr>` inner XML.
@@ -8,4 +10,4 @@ export declare function serializeTableCellStyleXml(style: EditorTableCellNode["s
  * Returns the full `<w:trPr>...</w:trPr>` element, or `""` when empty.
  */
 export declare function serializeTableRowStyleXml(style: EditorTableRowStyle | undefined): string;
-export declare function serializeTableXml(table: EditorTableNode, serializeParagraphXml: SerializeTableParagraphXml): string;
+export declare function serializeTableXml(table: EditorTableNode, serializeBlockXml: SerializeTableBlockXml): string;

package/dist/export/docx/text/sourceParagraphPropertiesXml.d.ts

@@ -1,5 +1,13 @@
 import { EditorParagraphNode } from '../../../core/model.js';
 
+/**
+ * Generic source-aware merge for a standalone `w:pPr` container. Generated
+ * modeled properties remain authoritative while source-only attributes and
+ * children are retained in source-relative order. This is shared by paragraph
+ * nodes and style property containers so both paths use the same modeled
+ * vocabulary and deletion semantics.
+ */
+export declare function mergeParagraphPropertiesXmlSource(sourceXml: string, generatedXml: string): string;
 /**
  * Preserves source-only `w:pPr` children while keeping the freshly generated
  * paragraph properties authoritative. Unknown children are inserted before the

package/dist/export/docx/text/sourceRunPropertiesXml.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Reuses the run serializer's canonical modeled-property vocabulary for a
+ * standalone style `w:rPr`. Unknown Word children are handled by the existing
+ * run merge; extension attributes/children nested inside modeled descendants
+ * are then layered back without restoring missing Word semantics.
+ */
+export declare function mergeRunPropertiesXmlSource(sourceXml: string, generatedXml: string): string;

package/dist/import/docx/opc/sourcePackage.d.ts

@@ -1,4 +1,5 @@
 import { EditorDocument, EditorDocxSourcePackage } from '../../../core/model.js';
 
 export declare function captureDocxSourcePackage(buffer: ArrayBuffer): Promise<EditorDocxSourcePackage>;
+export declare function attachDocxRebuiltPartBaseline(document: EditorDocument, sourcePackage: EditorDocxSourcePackage): Promise<void>;
 export declare function attachDocxSourcePackage(document: EditorDocument, buffer: ArrayBuffer): Promise<EditorDocument>;