@docx-editor.dev/core 2.30.0 → 2.32.0

package/dist/{types-barrel-CA0xB8kH.d.ts → tree-op-types-C_S2niXW.d.ts}

@@ -1,27 +1,54 @@
-import { c as HistoryGroupOutcome } from './editor-scope-7o9xweiJ.js';
+import { H as HistoryGroupOutcome } from './editor-scope-B3L-1ALc.js';
 
 /**
- * How a tracked change is addressed: `@w:id`, `@w:author` and `@w:date` together, within a
- * part.
+ * Why a zip was refused at the trust boundary.
  *
- * All of them, always. `@w:id` is unique only within a part, so an id alone names two
- * revisions in any package with a header or a comments part — and it is not author-scoped
- * either, so `(part, id)` would merge two authors' distinct revisions. One logical revision is
- * also deliberately many elements sharing an id, as a tracked row insertion is, which no
- * uniqueness rule could express.
+ * `too-large` and `too-many-entries` are the zip-bomb guards; `bad-name` catches path traversal —
+ * an entry with `..` or a leading `/` is rejected rather than normalized.
  */
-interface RevisionAddress {
-    readonly id: string;
-    readonly author: string;
-    /** Absent when the file wrote no `@w:date`; part of the identity either way. */
-    readonly date?: string;
-}
-/** The author and timestamp a tracked edit is recorded under. */
-interface RevisionAttributionInput {
-    readonly author: string;
-    /** ISO-8601. Omitted writes no `@w:date`. */
-    readonly date?: string;
+type ZipRejection = 'too-many-entries' | 'too-large' | 'bad-name' | 'inflate-error';
+/** Archive caps: entry count, total decompressed bytes, and the decompression ratio. */
+interface ZipLimits {
+    readonly maxEntries: number;
+    /** Max total UNCOMPRESSED bytes across the archive. */
+    readonly maxTotalBytes: number;
+    /**
+     * Max ratio of the archive's total declared uncompressed bytes to the archive's own byte
+     * length (zip-bomb guard). Applies once that total exceeds 8 MiB, so a small archive is
+     * never refused for compressing well.
+     */
+    readonly maxRatio?: number;
 }
+/** The archive caps in force when a host configures none. Conservative and finite. */
+declare const DEFAULT_ZIP_LIMITS: ZipLimits;
+/** The read entries, or the typed refusal. Never throws — the bytes are untrusted. */
+type ZipReadResult = {
+    readonly ok: true;
+    readonly entries: ReadonlyMap<string, Uint8Array>;
+} | {
+    readonly ok: false;
+    readonly reason: ZipRejection;
+    readonly detail?: string;
+    readonly limit?: 'zip.maxTotalBytes' | 'zip.maxRatio';
+};
+/**
+ * Inflate a ZIP archive with bounds + OPC name normalization. Entry name, count, archive
+ * ratio, and total-uncompressed-size limits are enforced BEFORE each entry is decompressed
+ * (via fflate's pre-inflation filter), so a zip bomb or a traversal name is rejected without
+ * ever being inflated. Keys are canonical part names.
+ *
+ * The budgets count each entry's DECLARED sizes, and the declared size is also a hard cap on
+ * what the entry may produce: fflate inflates into a buffer of exactly `originalSize` bytes
+ * and never grows it, so an entry whose stream holds more than it declares is truncated (or
+ * refused as `inflate-error`), never expanded past its budget. A stored entry is copied at
+ * its compressed size, so the larger of its two declared sizes is what counts.
+ */
+declare function readZip(bytes: Uint8Array, limits?: ZipLimits): ZipReadResult;
+/** Deflate a set of canonical-part-name -> bytes into a ZIP archive. Every part name
+ *  is re-validated through the OPC normalization profile before writing, so a
+ *  traversal/encoded/normalized-alias name from an untrusted serialized model can
+ *  never be smuggled into a ZIP entry (write-side path-traversal guard). */
+declare function writeZip(entries: ReadonlyMap<string, Uint8Array>): Uint8Array;
 
 /**
  * One parsed XML node, preserving significant order, whitespace and raw lexical values.
@@ -83,108 +110,331 @@ declare function textContent(node: Extract<XmlNode, {
     type: 'element';
 }>): string;
 
-/** The WordprocessingML main namespace — the `w:` prefix in every `word/document.xml`. */
-declare const WML_NAMESPACE_URI = "http://schemas.openxmlformats.org/wordprocessingml/2006/main";
-/** The reserved `xml:` namespace, which carries `xml:space`. */
-declare const XML_NAMESPACE_URI = "http://www.w3.org/XML/1998/namespace";
-/** The reserved `xmlns:` namespace that namespace declarations themselves live in. */
-declare const XMLNS_NAMESPACE_URI = "http://www.w3.org/2000/xmlns/";
-/** The `w14` wordml-2010 extension namespace — `w14:paraId`/`w14:textId` live here. */
-declare const W14_NAMESPACE_URI = "http://schemas.microsoft.com/office/word/2010/wordml";
-declare const DRAWINGML_MAIN_NAMESPACE_URI = "http://schemas.openxmlformats.org/drawingml/2006/main";
-declare const WP_NAMESPACE_URI = "http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing";
-declare const PIC_NAMESPACE_URI = "http://schemas.openxmlformats.org/drawingml/2006/picture";
-/** The four content-position revision wrappers, which nest and carry runs. */
-declare function isContentRevisionKind(kind: OoxmlNode['kind']): kind is 'revisionInsert' | 'revisionDelete' | 'revisionMoveFrom' | 'revisionMoveTo';
-/** Move-range and comment-range boundary markers, which are empty and sit between runs. */
-declare function isRangeMarkerKind(kind: OoxmlNode['kind']): kind is 'moveFromRangeStart' | 'moveFromRangeEnd' | 'moveToRangeStart' | 'moveToRangeEnd' | 'commentRangeStart' | 'commentRangeEnd';
 /**
- * OOXML on/off toggle: on only when a same-namespace child is present and its `w:val`
- * (same namespace as the child) does not explicitly disable. Foreign-namespace siblings
- * with the same local name cannot turn the flag on.
+ * Why a part or relationship name was refused.
+ *
+ * Path traversal is the reason this exists: a name with `..` or a leading `/` is refused rather
+ * than normalized, because normalizing is how a crafted package reaches outside itself.
  */
-declare function readOnOffChild(parent: OoxmlNode, localName: string, namespaceUri?: string): boolean;
+type NameRejection = 'empty' | 'control-char' | 'backslash' | 'drive-or-unc' | 'encoded-separator' | 'encoded-dot' | 'bad-encoding' | 'empty-segment' | 'dot-segment' | 'unsafe-key' | 'segment-trailing-dot' | 'traversal-escape' | 'not-absolute-uri' | 'unsafe-scheme';
+/** A validated OPC name, or the typed reason it was refused. */
+type NameResult = {
+    readonly ok: true;
+    readonly partName: string;
+} | {
+    readonly ok: false;
+    readonly reason: NameRejection;
+};
+/**
+ * Normalize a ZIP entry name or OPC part name into a canonical part name
+ * (`/word/document.xml`). Accepts leading-slash and no-leading-slash inputs;
+ * rejects traversal, dot segments, and the attack surface. Duplicate detection
+ * folds ASCII case (OPC part-name equivalence).
+ */
+declare function normalizePartName(raw: string): NameResult;
+/**
+ * ASCII-only lowercase fold. OPC part-name/extension equivalence is US-ASCII
+ * case-insensitive; a locale `toLowerCase()` mis-folds e.g. Turkish `I`/`İ` and
+ * could let two "equivalent" part names evade duplicate detection.
+ */
+declare function asciiFold(s: string): string;
+/** Case-folded key for OPC part-name equivalence / duplicate detection. */
+declare function partNameKey(partName: string): string;
+/**
+ * Detect archive entries that collide after normalization (before inflation).
+ * Returns the case-folded keys that more than one raw name maps to.
+ */
+declare function detectDuplicateNames(rawNames: readonly string[]): {
+    readonly duplicates: readonly string[];
+    readonly rejected: readonly {
+        raw: string;
+        reason: NameRejection;
+    }[];
+};
+/**
+ * Resolve an internal relationship target against its owner part, without
+ * escaping the package root. `ownerPartName` is a canonical part name; the base
+ * is its containing folder. A leading "/" target is package-absolute. `.`/`..`
+ * segments resolve on a stack; popping above root is `traversal-escape`.
+ */
+declare function resolveInternalTarget(ownerPartName: string, rawTarget: string): NameResult;
+/**
+ * Validate an external-mode relationship target. It MUST be an absolute URI, is
+ * retained verbatim by the caller, and is NEVER owner-resolved or fetched here.
+ * Unsafe schemes (javascript/vbscript/data/file) are rejected for runtime sinks;
+ * the raw lexical form is still preserved separately by the authored record.
+ */
+declare function validateExternalTarget(raw: string): NameResult;
 
+/** OOXML image relationship type for embedded or linked media parts. */
+declare const IMAGE_RELATIONSHIP_TYPE = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/image";
 /**
- * A node's stable identity within its part.
+ * Whether a relationship points inside the package or out of it.
  *
- * Minted deterministically from the structural path at parse, then RETAINED through structural
- * sharing — the same bytes always produce the same ids, and an edit elsewhere in the document
- * does not renumber untouched nodes. Every tree op addresses nodes by these.
+ * The security-relevant distinction: an `External` target is retained VERBATIM and never
+ * owner-resolved or fetched, because auto-loading a file-supplied remote target is a zero-click
+ * external fetch.
  */
-type OoxmlNodeId = string;
+type TargetMode = 'Internal' | 'External';
 /**
- * One `xmlns:` declaration carried on a node.
- *
- * Preserved rather than normalized away: a document that binds `w14` at the root and a document
- * that binds it on a paragraph are different bytes, and re-emitting the wrong one is a fidelity
- * loss even though the semantics match.
+ * One authored relationship, with nothing materialized away: owner part, id, type, raw target
+ * lexical form, mode, and position.
  */
-interface OoxmlNamespaceBinding {
-    readonly prefix: string;
-    readonly namespaceUri: string;
-}
-interface OoxmlAttributeBase {
-    readonly namespaceUri: string;
-    readonly localName: string;
-    readonly prefix?: string;
-    readonly value: string;
-}
-/** `xml:space`, which decides whether a run's leading and trailing whitespace survives. */
-interface OoxmlXmlSpaceAttribute extends OoxmlAttributeBase {
-    readonly kind: 'xmlSpace';
-    readonly namespaceUri: typeof XML_NAMESPACE_URI;
-    readonly localName: 'space';
-    readonly prefix: 'xml';
-    readonly value: 'default' | 'preserve';
-}
-/** `w:val` — the attribute nearly every WordprocessingML property carries its value in. */
-interface OoxmlWmlValAttribute extends OoxmlAttributeBase {
-    readonly kind: 'wmlVal';
-    readonly namespaceUri: typeof WML_NAMESPACE_URI;
-    readonly localName: 'val';
+interface RelationshipRecord {
+    readonly ownerPart: string;
+    readonly id: string;
+    readonly type: string;
+    readonly rawTarget: string;
+    readonly targetMode: TargetMode;
+    readonly order: number;
 }
+/** Why a relationship set is invalid. Duplicate ids within one owner fail closed. */
+type RelationshipError = {
+    readonly code: 'duplicate-id';
+    readonly ownerPart: string;
+    readonly id: string;
+};
+/** The validated relationship set, or the conflict that rejected it. */
+type RelationshipSetResult = {
+    readonly ok: true;
+    readonly byOwner: ReadonlyMap<string, readonly RelationshipRecord[]>;
+} | {
+    readonly ok: false;
+    readonly error: RelationshipError;
+};
+/** Group relationships by owner in authored order; reject duplicate ids per owner. */
+declare function buildRelationshipSet(records: readonly RelationshipRecord[]): RelationshipSetResult;
 /**
- * Any attribute outside the typed vocabulary, carried verbatim.
+ * A relationship resolved to a part, or the reason it could not be.
  *
- * Where losslessness actually happens: an attribute this engine has no model for is preserved
- * exactly rather than dropped, so a save re-emits what the file said.
+ * External targets resolve to a refusal by design: they are never followed from a file.
  */
-interface OoxmlGenericExtensionAttribute extends OoxmlAttributeBase {
-    readonly kind: 'genericExtension';
-}
-/** Any attribute on any node: the two typed ones, plus the verbatim catch-all. */
-type OoxmlAttribute = OoxmlXmlSpaceAttribute | OoxmlWmlValAttribute | OoxmlGenericExtensionAttribute;
+type ResolvedRelationship = {
+    readonly mode: 'Internal';
+    readonly target: NameResult;
+    readonly raw: string;
+} | {
+    readonly mode: 'External';
+    readonly sinkSafe: NameResult;
+    readonly raw: string;
+};
 /**
- * Attributes a TYPED node may carry.
+ * Resolve a relationship to a runtime projection while the raw target stays
+ * authored. Internal -> owner-relative part name; External -> sink-safe
+ * validation only (never owner-resolved, never fetched). `raw` is always the
+ * verbatim authored target.
+ */
+declare function resolveRelationship(rec: RelationshipRecord): ResolvedRelationship;
+/**
+ * An image relationship resolved to package bytes, or why it was refused.
  *
- * Excludes `w:val` on purpose: a node the engine models keeps its value in typed fields, and
- * allowing a stray `w:val` alongside them would create two sources of truth for one property.
+ * External-mode image rels are refused rather than fetched — the no-zero-click-external-fetch
+ * rule applies to images exactly as it does to links.
  */
-type OoxmlKnownNodeAttribute = OoxmlXmlSpaceAttribute | OoxmlGenericExtensionAttribute;
-interface OoxmlElementBase<Children extends readonly OoxmlNode[] = readonly OoxmlNode[], Attributes extends readonly OoxmlAttribute[] = readonly OoxmlAttribute[]> {
-    readonly id: OoxmlNodeId;
-    readonly namespaceUri: string;
-    readonly localName: string;
-    /** Authored prefix retained as non-authoritative fidelity evidence. */
-    readonly prefix?: string;
-    /** Namespace declarations authored directly on this element, in source order. */
-    readonly namespaceBindings: readonly OoxmlNamespaceBinding[];
-    readonly attributes: Attributes;
-    readonly children: Children;
-}
-/** `w:document` — the root of a main document part. */
-interface OoxmlDocumentNode extends OoxmlElementBase<readonly (OoxmlBodyNode | OoxmlGenericElementNode)[], readonly OoxmlKnownNodeAttribute[]> {
-    readonly kind: 'document';
-    readonly namespaceUri: typeof WML_NAMESPACE_URI;
-    readonly localName: 'document';
-}
-/** `w:body` — the main story's block content. */
-interface OoxmlBodyNode extends OoxmlElementBase<readonly (OoxmlParagraphNode | OoxmlTableNode | OoxmlContentControlNode | OoxmlGenericElementNode)[], readonly OoxmlKnownNodeAttribute[]> {
-    readonly kind: 'body';
-    readonly namespaceUri: typeof WML_NAMESPACE_URI;
-    readonly localName: 'body';
-}
+type ImageRelationshipResolution = {
+    readonly mode: 'internal';
+    readonly partName: string;
+    readonly raw: string;
+} | {
+    readonly mode: 'external';
+    readonly sinkSafe: boolean;
+    readonly raw: string;
+} | {
+    readonly mode: 'missing';
+};
+/**
+ * Resolve an image relationship id from an owner part. Internal targets resolve
+ * owner-relative; external targets are never fetched; a missing id is `missing`.
+ */
+declare function resolveImageRelationship(records: readonly RelationshipRecord[] | undefined, ownerPart: string, relationshipId: string): ImageRelationshipResolution;
+
+/** One `<Default>`: a file extension mapped to a content type. */
+interface DefaultRecord {
+    readonly extension: string;
+    readonly contentType: string;
+    readonly order: number;
+}
+/** One `<Override>`: a specific part name mapped to a content type. Beats any Default. */
+interface OverrideRecord {
+    readonly partName: string;
+    readonly contentType: string;
+    readonly order: number;
+}
+/**
+ * The authored `[Content_Types].xml` records, in significant order.
+ *
+ * Retained rather than collapsed into a lookup, because the file's lexical form and ordering are
+ * part of what a lossless save re-emits.
+ */
+interface ContentTypeRecords {
+    readonly defaults: readonly DefaultRecord[];
+    readonly overrides: readonly OverrideRecord[];
+}
+/**
+ * Why content-type records could not be indexed.
+ *
+ * All fail CLOSED: conflicting Defaults on one extension, duplicate normalized Override names, or
+ * invalid MIME syntax are refused rather than resolved by picking one.
+ */
+type ContentTypeError = {
+    readonly code: 'invalid-mime';
+    readonly value: string;
+} | {
+    readonly code: 'conflicting-default';
+    readonly extension: string;
+} | {
+    readonly code: 'duplicate-override';
+    readonly partName: string;
+} | {
+    readonly code: 'invalid-override-name';
+    readonly partName: string;
+} | {
+    readonly code: 'too-many-records';
+    readonly limit: number;
+};
+/** Whether a string is syntactically a MIME type. Syntax only — no registry lookup. */
+declare function isValidMime(value: string): boolean;
+/** ASCII-case-insensitive extension key (leading dot removed; ASCII-only fold). */
+declare function extensionKey(extension: string): string;
+/** The resolved lookup: Override by case-folded part name, Default by case-insensitive extension. */
+interface ContentTypeIndex {
+    /** ext key -> single MIME (identical duplicates collapsed). */
+    readonly defaults: ReadonlyMap<string, string>;
+    /** case-folded part name -> MIME. */
+    readonly overrides: ReadonlyMap<string, string>;
+}
+/** The built index, or the conflict that made it impossible. */
+type IndexResult = {
+    readonly ok: true;
+    readonly index: ContentTypeIndex;
+} | {
+    readonly ok: false;
+    readonly error: ContentTypeError;
+};
+/**
+ * Build a resolved content-type index, failing closed on conflict/duplicate/MIME
+ * errors. `maxRecords` bounds the combined record count (N/N+1 gate).
+ */
+declare function buildContentTypeIndex(records: ContentTypeRecords, maxRecords?: number): IndexResult;
+/**
+ * A part's content type, or why it has none.
+ *
+ * An orphan record never determines a part's type — a Default with no matching part is preserved
+ * inertly rather than applied.
+ */
+type ResolveResult = {
+    readonly ok: true;
+    readonly contentType: string;
+    readonly source: 'override' | 'default';
+} | {
+    readonly ok: false;
+    readonly reason: 'unknown';
+};
+/** Resolve a part's content type: Override wins over Default; else unknown. */
+declare function resolveContentType(index: ContentTypeIndex, partName: string): ResolveResult;
+
+/** The WordprocessingML main namespace — the `w:` prefix in every `word/document.xml`. */
+declare const WML_NAMESPACE_URI = "http://schemas.openxmlformats.org/wordprocessingml/2006/main";
+/** The reserved `xml:` namespace, which carries `xml:space`. */
+declare const XML_NAMESPACE_URI = "http://www.w3.org/XML/1998/namespace";
+/** The reserved `xmlns:` namespace that namespace declarations themselves live in. */
+declare const XMLNS_NAMESPACE_URI = "http://www.w3.org/2000/xmlns/";
+/** The `w14` wordml-2010 extension namespace — `w14:paraId`/`w14:textId` live here. */
+declare const W14_NAMESPACE_URI = "http://schemas.microsoft.com/office/word/2010/wordml";
+declare const DRAWINGML_MAIN_NAMESPACE_URI = "http://schemas.openxmlformats.org/drawingml/2006/main";
+declare const WP_NAMESPACE_URI = "http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing";
+declare const PIC_NAMESPACE_URI = "http://schemas.openxmlformats.org/drawingml/2006/picture";
+/** The four content-position revision wrappers, which nest and carry runs. */
+declare function isContentRevisionKind(kind: OoxmlNode['kind']): kind is 'revisionInsert' | 'revisionDelete' | 'revisionMoveFrom' | 'revisionMoveTo';
+/** Move-range and comment-range boundary markers, which are empty and sit between runs. */
+declare function isRangeMarkerKind(kind: OoxmlNode['kind']): kind is 'moveFromRangeStart' | 'moveFromRangeEnd' | 'moveToRangeStart' | 'moveToRangeEnd' | 'commentRangeStart' | 'commentRangeEnd';
+/**
+ * OOXML on/off toggle: on only when a same-namespace child is present and its `w:val`
+ * (same namespace as the child) does not explicitly disable. Foreign-namespace siblings
+ * with the same local name cannot turn the flag on.
+ */
+declare function readOnOffChild(parent: OoxmlNode, localName: string, namespaceUri?: string): boolean;
+
+/**
+ * A node's stable identity within its part.
+ *
+ * Minted deterministically from the structural path at parse, then RETAINED through structural
+ * sharing — the same bytes always produce the same ids, and an edit elsewhere in the document
+ * does not renumber untouched nodes. Every tree op addresses nodes by these.
+ */
+type OoxmlNodeId = string;
+/**
+ * One `xmlns:` declaration carried on a node.
+ *
+ * Preserved rather than normalized away: a document that binds `w14` at the root and a document
+ * that binds it on a paragraph are different bytes, and re-emitting the wrong one is a fidelity
+ * loss even though the semantics match.
+ */
+interface OoxmlNamespaceBinding {
+    readonly prefix: string;
+    readonly namespaceUri: string;
+}
+interface OoxmlAttributeBase {
+    readonly namespaceUri: string;
+    readonly localName: string;
+    readonly prefix?: string;
+    readonly value: string;
+}
+/** `xml:space`, which decides whether a run's leading and trailing whitespace survives. */
+interface OoxmlXmlSpaceAttribute extends OoxmlAttributeBase {
+    readonly kind: 'xmlSpace';
+    readonly namespaceUri: typeof XML_NAMESPACE_URI;
+    readonly localName: 'space';
+    readonly prefix: 'xml';
+    readonly value: 'default' | 'preserve';
+}
+/** `w:val` — the attribute nearly every WordprocessingML property carries its value in. */
+interface OoxmlWmlValAttribute extends OoxmlAttributeBase {
+    readonly kind: 'wmlVal';
+    readonly namespaceUri: typeof WML_NAMESPACE_URI;
+    readonly localName: 'val';
+}
+/**
+ * Any attribute outside the typed vocabulary, carried verbatim.
+ *
+ * Where losslessness actually happens: an attribute this engine has no model for is preserved
+ * exactly rather than dropped, so a save re-emits what the file said.
+ */
+interface OoxmlGenericExtensionAttribute extends OoxmlAttributeBase {
+    readonly kind: 'genericExtension';
+}
+/** Any attribute on any node: the two typed ones, plus the verbatim catch-all. */
+type OoxmlAttribute = OoxmlXmlSpaceAttribute | OoxmlWmlValAttribute | OoxmlGenericExtensionAttribute;
+/**
+ * Attributes a TYPED node may carry.
+ *
+ * Excludes `w:val` on purpose: a node the engine models keeps its value in typed fields, and
+ * allowing a stray `w:val` alongside them would create two sources of truth for one property.
+ */
+type OoxmlKnownNodeAttribute = OoxmlXmlSpaceAttribute | OoxmlGenericExtensionAttribute;
+interface OoxmlElementBase<Children extends readonly OoxmlNode[] = readonly OoxmlNode[], Attributes extends readonly OoxmlAttribute[] = readonly OoxmlAttribute[]> {
+    readonly id: OoxmlNodeId;
+    readonly namespaceUri: string;
+    readonly localName: string;
+    /** Authored prefix retained as non-authoritative fidelity evidence. */
+    readonly prefix?: string;
+    /** Namespace declarations authored directly on this element, in source order. */
+    readonly namespaceBindings: readonly OoxmlNamespaceBinding[];
+    readonly attributes: Attributes;
+    readonly children: Children;
+}
+/** `w:document` — the root of a main document part. */
+interface OoxmlDocumentNode extends OoxmlElementBase<readonly (OoxmlBodyNode | OoxmlGenericElementNode)[], readonly OoxmlKnownNodeAttribute[]> {
+    readonly kind: 'document';
+    readonly namespaceUri: typeof WML_NAMESPACE_URI;
+    readonly localName: 'document';
+}
+/** `w:body` — the main story's block content. */
+interface OoxmlBodyNode extends OoxmlElementBase<readonly (OoxmlParagraphNode | OoxmlTableNode | OoxmlContentControlNode | OoxmlGenericElementNode)[], readonly OoxmlKnownNodeAttribute[]> {
+    readonly kind: 'body';
+    readonly namespaceUri: typeof WML_NAMESPACE_URI;
+    readonly localName: 'body';
+}
 interface OoxmlTableNode extends OoxmlElementBase<readonly (OoxmlTablePropertiesNode | OoxmlTableGridNode | OoxmlTableRowNode | OoxmlContentControlNode | OoxmlGenericElementNode)[], readonly OoxmlKnownNodeAttribute[]> {
     readonly kind: 'table';
     readonly namespaceUri: typeof WML_NAMESPACE_URI;
@@ -894,322 +1144,23 @@ type OoxmlInvariantResult = {
  */
 declare function readOoxmlPart(xml: string, metadata: OoxmlPartMetadata, limits?: XmlLimits): OoxmlReadResult;
 
-type AutomationTableMutation = {
-    readonly kind: 'insertRows';
-    readonly rowId: string;
-    readonly location: 'before' | 'after';
-    readonly count: number;
-    readonly values?: readonly (readonly string[])[];
-} | {
-    readonly kind: 'values';
-    readonly values: readonly (readonly string[])[];
-} | {
-    readonly kind: 'addRows' | 'addColumns';
-    readonly location: 'start' | 'end';
-    readonly count: number;
-    readonly values?: readonly (readonly string[])[];
-} | {
-    readonly kind: 'deleteRows' | 'deleteColumns';
-    readonly index: number;
-    readonly count: number;
-} | {
-    readonly kind: 'delete';
-} | {
-    readonly kind: 'properties';
-    readonly styleId?: string;
-    readonly headerRowCount?: number;
-} | {
-    readonly kind: 'cell';
-    readonly cellId: string;
-    readonly value?: string;
-    readonly columnWidth?: number;
-    readonly shadingColor?: string;
-    readonly verticalAlignment?: 'Top' | 'Center' | 'Bottom';
-};
-
-/** Select one declared entry of a legacy Word dropdown form field. */
-interface SetLegacyDropdownOp {
-    readonly op: 'setLegacyDropdown';
-    readonly paragraphId: string;
-    readonly fieldNodeId: string;
-    readonly selectedIndex: number;
-}
-
-interface SetFieldCodeOp {
-    readonly op: 'setFieldCode';
-    readonly paragraphId: string;
-    readonly fieldNodeId: string;
-    readonly code: string;
+/** Plain text fitted to a floating shape box, painted with one fill and an optional outline. */
+interface LegacyTextArtProjection {
+    readonly text: string;
+    readonly fontFamily: string;
+    readonly bold: boolean;
+    readonly italic: boolean;
+    /** `RRGGBB`, or null when the shape is not filled. */
+    readonly fillHex: string | null;
+    readonly fillAlpha: number;
+    /** `RRGGBB`, or null when the shape is not stroked. */
+    readonly strokeHex: string | null;
+    readonly strokeAlpha: number;
+    readonly strokeWidthPt: number;
+    /** Clockwise rotation about the box centre, in [0, 360). */
+    readonly rotationDegrees: number;
 }
 
-type InsertTextOp = {
-    readonly op: 'insertText';
-    readonly paragraphId: string;
-    /** Legacy text form identity for protected filling; never an inline wrapper owner. */
-    readonly textFormFieldId?: string;
-    readonly offset: number;
-    readonly text: string;
-    /**
-     * Write this as a TRACKED insertion, attributed here.
-     *
-     * On the op rather than on the store, so suggesting stays a decision the surface makes
-     * per edit and the write vocabulary stays explicit — a global "everything is tracked
-     * now" flag is exactly what `DocEdits` refuses, because it makes the meaning of an op
-     * depend on state the op does not carry.
-     */
-    readonly revision?: RevisionAttributionInput;
-    /**
-     * When set, the text belongs INSIDE this content control, whatever sits at the offset.
-     *
-     * A boundary offset is owned by the run that starts there, which at a control's trailing
-     * edge is the run after the control — so an offset alone cannot say "append to this field",
-     * the way it cannot say which run of a field result to format (see `targetRunIds`). A
-     * caller that names the control gets the text in the control; one that does not gets the
-     * plain offset rule, which is what a keystroke beside a field means.
-     */
-    readonly inside?: string;
-    /**
-     * Which side of a run BOUNDARY the text joins. Default `'left'` — Word's typing rule:
-     * the next character takes the formatting of the character before the caret.
-     *
-     * `'right'` is for a caller that is not typing but placing text inside the run that
-     * STARTS at the offset — the hyperlink editor rewriting a link's display text, where
-     * landing left of the boundary would put the new text outside the link. Ignored when
-     * the offset falls strictly inside a run, which has no boundary to choose.
-     */
-    readonly bias?: 'left' | 'right';
-};
-type DeleteTextOp = {
-    readonly op: 'deleteText';
-    readonly paragraphId: string;
-    /** Legacy text form identity for protected filling; never an inline wrapper owner. */
-    readonly textFormFieldId?: string;
-    readonly start: number;
-    readonly end: number;
-    /** Write this as a TRACKED deletion — the characters stay, wrapped in `w:del`. */
-    readonly revision?: RevisionAttributionInput;
-};
-
-/** Editable legacy text input types. Other authored types remain inert. */
-type TextFormFieldType = 'regular' | 'number' | 'date';
-/** Options stored in the legacy field definition. Zero means unlimited length. */
-interface TextFormFieldOptions {
-    readonly type: TextFormFieldType;
-    readonly maxLength: number;
-    readonly format: string;
-    readonly enabled: boolean;
-}
-/** Supported format choices for legacy text input fields. @public */
-declare const TEXT_FORM_FORMATS: {
-    readonly regular: readonly ['', 'Uppercase', 'Lowercase', 'First capital', 'Title case'];
-    readonly number: readonly ['', '0', '0.00', '#,##0', '#,##0.00', '0%', '0.00%'];
-    readonly date: readonly ['', 'M/d/yyyy', 'MM/dd/yyyy', 'd/M/yyyy', 'dd/MM/yyyy', 'yyyy-MM-dd', 'd MMMM yyyy', 'MMMM d, yyyy'];
-};
-
-/** A legacy text input in the shared paragraph offset space. */
-interface TextFormFieldRange {
-    readonly fieldNodeId: string;
-    readonly start: number;
-    readonly end: number;
-    readonly enabled: boolean;
-    readonly defaultText: string;
-    readonly type: string;
-    readonly maxLength: number;
-    readonly format: string;
-    readonly chromeIds: readonly string[];
-}
-/** Uses the field parser and offset index; never introduces another inline walk. */
-declare function textFormFieldsOf(paragraph: OoxmlParagraphNode): readonly TextFormFieldRange[];
-/** Options edit for an existing legacy text form. */
-interface SetTextFormFieldDefaultOp {
-    readonly op: 'setTextFormFieldDefault';
-    /** Regional conventions for new date input; defaults to en-US. */
-    readonly locale?: string;
-    readonly paragraphId: string;
-    readonly fieldNodeId: string;
-    readonly text: string;
-    readonly options?: TextFormFieldOptions;
-}
-/** Validate and format the existing result when a user finishes filling a field. */
-interface CommitTextFormFieldOp {
-    readonly op: 'commitTextFormField';
-    /** Regional conventions for new date input; defaults to en-US. */
-    readonly locale?: string;
-    readonly paragraphId: string;
-    readonly fieldNodeId: string;
-}
-
-/** One FORMCHECKBOX in the shared paragraph offset space. */
-interface LegacyCheckboxFieldRange {
-    /** The begin `w:fldChar` node: what the op addresses. */
-    readonly fieldNodeId: string;
-    readonly start: number;
-    readonly end: number;
-    readonly checked: boolean;
-    /** `w:enabled` under `w:ffData`; a disabled field renders but refuses the toggle. */
-    readonly enabled: boolean;
-}
-/** Flip a FORMCHECKBOX's state; the only write into `w:ffData` a checkbox permits. */
-interface SetLegacyCheckboxOp {
-    readonly op: 'setLegacyCheckbox';
-    readonly paragraphId: string;
-    readonly fieldNodeId: string;
-    readonly checked: boolean;
-}
-/** Every FORMCHECKBOX in a paragraph, in document order; uses the shared field parser. */
-declare function legacyCheckboxFieldsOf(paragraph: OoxmlParagraphNode): readonly LegacyCheckboxFieldRange[];
-
-/** Replace a building block gallery control's content with one block's body. */
-interface InsertBuildingBlockOp {
-    readonly op: 'insertBuildingBlock';
-    readonly controlId: string;
-    /** `w:docPartPr/w:name` of the picked block, for the journal and the host. */
-    readonly name: string;
-    /**
-     * Self-contained `w:docPartBody` children, cloned with fresh ids at apply.
-     * Resource, style, field, bookmark, note and revision references return `unsupported`.
-     */
-    readonly blocks: readonly OoxmlNode[];
-}
-
-/**
- * Why a part or relationship name was refused.
- *
- * Path traversal is the reason this exists: a name with `..` or a leading `/` is refused rather
- * than normalized, because normalizing is how a crafted package reaches outside itself.
- */
-type NameRejection = 'empty' | 'control-char' | 'backslash' | 'drive-or-unc' | 'encoded-separator' | 'encoded-dot' | 'bad-encoding' | 'empty-segment' | 'dot-segment' | 'unsafe-key' | 'segment-trailing-dot' | 'traversal-escape' | 'not-absolute-uri' | 'unsafe-scheme';
-/** A validated OPC name, or the typed reason it was refused. */
-type NameResult = {
-    readonly ok: true;
-    readonly partName: string;
-} | {
-    readonly ok: false;
-    readonly reason: NameRejection;
-};
-/**
- * Normalize a ZIP entry name or OPC part name into a canonical part name
- * (`/word/document.xml`). Accepts leading-slash and no-leading-slash inputs;
- * rejects traversal, dot segments, and the attack surface. Duplicate detection
- * folds ASCII case (OPC part-name equivalence).
- */
-declare function normalizePartName(raw: string): NameResult;
-/**
- * ASCII-only lowercase fold. OPC part-name/extension equivalence is US-ASCII
- * case-insensitive; a locale `toLowerCase()` mis-folds e.g. Turkish `I`/`İ` and
- * could let two "equivalent" part names evade duplicate detection.
- */
-declare function asciiFold(s: string): string;
-/** Case-folded key for OPC part-name equivalence / duplicate detection. */
-declare function partNameKey(partName: string): string;
-/**
- * Detect archive entries that collide after normalization (before inflation).
- * Returns the case-folded keys that more than one raw name maps to.
- */
-declare function detectDuplicateNames(rawNames: readonly string[]): {
-    readonly duplicates: readonly string[];
-    readonly rejected: readonly {
-        raw: string;
-        reason: NameRejection;
-    }[];
-};
-/**
- * Resolve an internal relationship target against its owner part, without
- * escaping the package root. `ownerPartName` is a canonical part name; the base
- * is its containing folder. A leading "/" target is package-absolute. `.`/`..`
- * segments resolve on a stack; popping above root is `traversal-escape`.
- */
-declare function resolveInternalTarget(ownerPartName: string, rawTarget: string): NameResult;
-/**
- * Validate an external-mode relationship target. It MUST be an absolute URI, is
- * retained verbatim by the caller, and is NEVER owner-resolved or fetched here.
- * Unsafe schemes (javascript/vbscript/data/file) are rejected for runtime sinks;
- * the raw lexical form is still preserved separately by the authored record.
- */
-declare function validateExternalTarget(raw: string): NameResult;
-
-/** OOXML image relationship type for embedded or linked media parts. */
-declare const IMAGE_RELATIONSHIP_TYPE = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/image";
-/**
- * Whether a relationship points inside the package or out of it.
- *
- * The security-relevant distinction: an `External` target is retained VERBATIM and never
- * owner-resolved or fetched, because auto-loading a file-supplied remote target is a zero-click
- * external fetch.
- */
-type TargetMode = 'Internal' | 'External';
-/**
- * One authored relationship, with nothing materialized away: owner part, id, type, raw target
- * lexical form, mode, and position.
- */
-interface RelationshipRecord {
-    readonly ownerPart: string;
-    readonly id: string;
-    readonly type: string;
-    readonly rawTarget: string;
-    readonly targetMode: TargetMode;
-    readonly order: number;
-}
-/** Why a relationship set is invalid. Duplicate ids within one owner fail closed. */
-type RelationshipError = {
-    readonly code: 'duplicate-id';
-    readonly ownerPart: string;
-    readonly id: string;
-};
-/** The validated relationship set, or the conflict that rejected it. */
-type RelationshipSetResult = {
-    readonly ok: true;
-    readonly byOwner: ReadonlyMap<string, readonly RelationshipRecord[]>;
-} | {
-    readonly ok: false;
-    readonly error: RelationshipError;
-};
-/** Group relationships by owner in authored order; reject duplicate ids per owner. */
-declare function buildRelationshipSet(records: readonly RelationshipRecord[]): RelationshipSetResult;
-/**
- * A relationship resolved to a part, or the reason it could not be.
- *
- * External targets resolve to a refusal by design: they are never followed from a file.
- */
-type ResolvedRelationship = {
-    readonly mode: 'Internal';
-    readonly target: NameResult;
-    readonly raw: string;
-} | {
-    readonly mode: 'External';
-    readonly sinkSafe: NameResult;
-    readonly raw: string;
-};
-/**
- * Resolve a relationship to a runtime projection while the raw target stays
- * authored. Internal -> owner-relative part name; External -> sink-safe
- * validation only (never owner-resolved, never fetched). `raw` is always the
- * verbatim authored target.
- */
-declare function resolveRelationship(rec: RelationshipRecord): ResolvedRelationship;
-/**
- * An image relationship resolved to package bytes, or why it was refused.
- *
- * External-mode image rels are refused rather than fetched — the no-zero-click-external-fetch
- * rule applies to images exactly as it does to links.
- */
-type ImageRelationshipResolution = {
-    readonly mode: 'internal';
-    readonly partName: string;
-    readonly raw: string;
-} | {
-    readonly mode: 'external';
-    readonly sinkSafe: boolean;
-    readonly raw: string;
-} | {
-    readonly mode: 'missing';
-};
-/**
- * Resolve an image relationship id from an owner part. Internal targets resolve
- * owner-relative; external targets are never fetched; a missing id is `missing`.
- */
-declare function resolveImageRelationship(records: readonly RelationshipRecord[] | undefined, ownerPart: string, relationshipId: string): ImageRelationshipResolution;
-
 type ShapeSchemeColorResolver = (scheme: string) => string | null;
 type ShapeStyleMatrixResolver = (kind: 'fill' | 'line', index: number) => OoxmlElement | null;
 /**
@@ -1267,6 +1218,9 @@ interface VectorShapeComponent {
     readonly strokeHex: string | null;
     readonly strokeAlpha: number;
     readonly strokeWidthEmu: number;
+    /** Authored line ends and joins, inherited from the selected theme line when absent. */
+    readonly strokeCap?: 'butt' | 'round' | 'square';
+    readonly strokeJoin?: 'round' | 'bevel';
     /**
      * The outline sits inside the closed geometry (`a:ln algn="in"`): painters draw it at twice
      * its width clipped to the path, so the authored width stays inside the shape and adds no
@@ -1466,150 +1420,412 @@ interface GroupPictureProjection {
         cx: number;
         cy: number;
     }>;
-    /** Canonical node id of the `pic:pic` member. The vector projection skips it. */
-    readonly memberNodeId: string;
-    /**
-     * Whether the group is the chosen branch of a run-level `mc:AlternateContent`. Layout then
-     * drops the whole group when the picture resource fails, as the projection drops other
-     * MC payloads it cannot draw.
-     */
-    readonly alternateContent: boolean;
+    /** Canonical node id of the `pic:pic` member. The vector projection skips it. */
+    readonly memberNodeId: string;
+    /**
+     * Whether the group is the chosen branch of a run-level `mc:AlternateContent`. Layout then
+     * drops the whole group when the picture resource fails, as the projection drops other
+     * MC payloads it cannot draw.
+     */
+    readonly alternateContent: boolean;
+}
+
+/**
+ * Whether a drawing sits in the text flow or is positioned against a frame.
+ *
+ * The distinction that decides everything downstream: an inline drawing occupies a character
+ * position, while an anchored one has offsets relative to a page, margin or column.
+ */
+type DrawingKind = 'inline' | 'anchored';
+/** Nine Word wrap menu targets (inline plus eight floating modes). @public */
+type ImageWrapTarget = 'inline' | 'square' | 'squareLeft' | 'squareRight' | 'tight' | 'through' | 'topAndBottom' | 'behind' | 'inFront';
+/** Every text-wrap mode a drawing may be set to, including `inline`. */
+declare const IMAGE_WRAP_TARGETS: readonly ImageWrapTarget[];
+type DrawingWrapElement = 'none' | 'square' | 'tight' | 'through' | 'topAndBottom';
+type DrawingHorizontalReferenceFrame = 'character' | 'column' | 'insideMargin' | 'leftMargin' | 'margin' | 'outsideMargin' | 'page' | 'rightMargin';
+type DrawingVerticalReferenceFrame = 'bottomMargin' | 'insideMargin' | 'line' | 'margin' | 'outsideMargin' | 'page' | 'paragraph' | 'topMargin';
+/** `a:srcRect` — how much of each edge of the source image is cropped away, as fractions. */
+interface SourceCrop {
+    readonly left: number;
+    readonly top: number;
+    readonly right: number;
+    readonly bottom: number;
+}
+interface DrawingTransform {
+    readonly rotationDegrees: number;
+    readonly flipHorizontal: boolean;
+    readonly flipVertical: boolean;
+    /** Source `a:off` in EMU; defaults to origin when absent. */
+    readonly offsetEmu: Readonly<{
+        x: number;
+        y: number;
+    }>;
+    /** Source `a:ext` in EMU; zero falls back to `wp:extent` at geometry time. */
+    readonly extentEmu: Readonly<{
+        cx: number;
+        cy: number;
+    }>;
 }
-
 /**
- * Why a zip was refused at the trust boundary.
+ * What a drawing refuses: selection, movement, resizing, aspect change.
  *
- * `too-large` and `too-many-entries` are the zip-bomb guards; `bad-name` catches path traversal —
- * an entry with `..` or a leading `/` is rejected rather than normalized.
+ * Read and honoured rather than advisory — chrome that offered a handle the store will refuse
+ * would promise an edit that cannot happen.
  */
-type ZipRejection = 'too-many-entries' | 'too-large' | 'bad-name' | 'inflate-error';
-/** Archive caps: entry count, total decompressed bytes, and the decompression ratio. */
-interface ZipLimits {
-    readonly maxEntries: number;
-    /** Max total UNCOMPRESSED bytes across the archive. */
-    readonly maxTotalBytes: number;
-    /**
-     * Max ratio of the archive's total declared uncompressed bytes to the archive's own byte
-     * length (zip-bomb guard). Applies once that total exceeds 8 MiB, so a small archive is
-     * never refused for compressing well.
-     */
-    readonly maxRatio?: number;
+interface DrawingLocks {
+    readonly select: boolean;
+    readonly move: boolean;
+    readonly resize: boolean;
+    readonly changeAspect: boolean;
+}
+interface DrawingLocksInput {
+    readonly select?: boolean;
+    readonly move?: boolean;
+    readonly resize?: boolean;
+    readonly changeAspect?: boolean;
 }
-/** The archive caps in force when a host configures none. Conservative and finite. */
-declare const DEFAULT_ZIP_LIMITS: ZipLimits;
-/** The read entries, or the typed refusal. Never throws — the bytes are untrusted. */
-type ZipReadResult = {
-    readonly ok: true;
-    readonly entries: ReadonlyMap<string, Uint8Array>;
-} | {
-    readonly ok: false;
-    readonly reason: ZipRejection;
-    readonly detail?: string;
-    readonly limit?: 'zip.maxTotalBytes' | 'zip.maxRatio';
-};
 /**
- * Inflate a ZIP archive with bounds + OPC name normalization. Entry name, count, archive
- * ratio, and total-uncompressed-size limits are enforced BEFORE each entry is decompressed
- * (via fflate's pre-inflation filter), so a zip bomb or a traversal name is rejected without
- * ever being inflated. Keys are canonical part names.
+ * An anchored drawing's position: offsets, and the frames they are relative to.
  *
- * The budgets count each entry's DECLARED sizes, and the declared size is also a hard cap on
- * what the entry may produce: fflate inflates into a buffer of exactly `originalSize` bytes
- * and never grows it, so an entry whose stream holds more than it declares is truncated (or
- * refused as `inflate-error`), never expanded past its budget. A stored entry is copied at
- * its compressed size, so the larger of its two declared sizes is what counts.
+ * The relative-to bases matter as much as the offsets. Writing an offset without preserving its
+ * base re-anchors the drawing against a different reference and moves it somewhere nobody asked.
  */
-declare function readZip(bytes: Uint8Array, limits?: ZipLimits): ZipReadResult;
-/** Deflate a set of canonical-part-name -> bytes into a ZIP archive. Every part name
- *  is re-validated through the OPC normalization profile before writing, so a
- *  traversal/encoded/normalized-alias name from an untrusted serialized model can
- *  never be smuggled into a ZIP entry (write-side path-traversal guard). */
-declare function writeZip(entries: ReadonlyMap<string, Uint8Array>): Uint8Array;
-
-/** One `<Default>`: a file extension mapped to a content type. */
-interface DefaultRecord {
-    readonly extension: string;
-    readonly contentType: string;
-    readonly order: number;
+interface DrawingPositionInput {
+    /**
+     * `'simple'` when `@simplePos="1"`: `horizontalEmu` / `verticalEmu` are authoritative
+     * `wp:simplePos` x/y. `'frame'` (default) uses positionH/V relative frames.
+     */
+    readonly mode?: 'frame' | 'simple';
+    readonly horizontalEmu?: number;
+    readonly verticalEmu?: number;
+    readonly relativeToH?: DrawingHorizontalReferenceFrame;
+    readonly relativeToV?: DrawingVerticalReferenceFrame;
 }
-/** One `<Override>`: a specific part name mapped to a content type. Beats any Default. */
-interface OverrideRecord {
-    readonly partName: string;
-    readonly contentType: string;
-    readonly order: number;
+interface DrawingProjection {
+    readonly drawingNodeId: string;
+    readonly ownerPartName: string;
+    readonly kind: DrawingKind;
+    readonly relationshipId: string | null;
+    readonly docPrId: number | null;
+    readonly name: string;
+    readonly title: string;
+    readonly description: string;
+    readonly hyperlinkHref: string | null;
+    readonly hidden: boolean;
+    readonly extentEmu: Readonly<{
+        cx: number;
+        cy: number;
+    }>;
+    readonly effectExtentEmu: Readonly<{
+        top: number;
+        right: number;
+        bottom: number;
+        left: number;
+    }>;
+    readonly inlineDistancesEmu: Readonly<{
+        top: number;
+        right: number;
+        bottom: number;
+        left: number;
+    }>;
+    readonly wrap: ImageWrapTarget;
+    readonly wrapGeometry: DrawingWrapProjection | null;
+    readonly position: DrawingPositionProjection | null;
+    readonly anchor: Readonly<{
+        simplePos: boolean;
+        relativeHeight: number;
+        behindDocument: boolean;
+        layoutInCell: boolean;
+        allowOverlap: boolean;
+    }> | null;
+    readonly picture: PictureProjection | null;
+    readonly vectorShape: VectorShapeProjection | null;
+    /** The picture member of a `wpg:wgp` group; `picture` stays null for a group. */
+    readonly groupPicture: GroupPictureProjection | null;
+    readonly textboxStory: TextboxStoryProjection | null;
+    /** Text box members of a `wpg:wgp` group, laid out read-only; absent when none has text. */
+    readonly groupTextboxes?: readonly GroupTextboxProjection[];
+    /** Read-only preview of the supported native VML subset; the canonical XML is untouched. */
+    readonly legacyGraphic?: LegacyGraphicProjection;
+    /** Floating VML text art (a text watermark), fitted to the box by layout. */
+    readonly textArt?: LegacyTextArtProjection;
+    readonly locks: DrawingLocks;
+    readonly effects: DrawingImageEffects;
+    readonly compatibilityBranchNodeId: string | null;
+    readonly diagnostics: readonly DrawingDiagnostic[];
+    /** Layout-only wrap area of an MC payload that cannot paint (`wrapFootprintProjection`). */
+    readonly footprintOnly?: true;
 }
-/**
- * The authored `[Content_Types].xml` records, in significant order.
- *
- * Retained rather than collapsed into a lookup, because the file's lexical form and ordering are
- * part of what a lossless save re-emits.
- */
-interface ContentTypeRecords {
-    readonly defaults: readonly DefaultRecord[];
-    readonly overrides: readonly OverrideRecord[];
+interface DrawingAccessibility {
+    /**
+     * The record takes part in layout only, for example the wrap area of a payload that cannot
+     * paint. Outputs must not paint, hit-test, select, link, or export it.
+     */
+    readonly hidden: boolean;
+    readonly decorative: boolean;
+    readonly label: string | null;
+}
+interface DrawingPositionProjection {
+    readonly simplePosition: Readonly<{
+        xEmu: number;
+        yEmu: number;
+    }>;
+    readonly horizontal: Readonly<{
+        relativeFrom: DrawingHorizontalReferenceFrame;
+        align: string | null;
+        offsetEmu: number | null;
+    }>;
+    readonly vertical: Readonly<{
+        relativeFrom: DrawingVerticalReferenceFrame;
+        align: string | null;
+        offsetEmu: number | null;
+    }>;
+}
+interface DrawingWrapProjection {
+    readonly element: DrawingWrapElement;
+    readonly textSide: 'bothSides' | 'left' | 'right' | 'largest';
+    readonly distancesEmu: Readonly<{
+        top: number;
+        right: number;
+        bottom: number;
+        left: number;
+    }>;
+    readonly polygon: readonly Readonly<{
+        x: number;
+        y: number;
+    }>[];
+}
+interface PictureProjection {
+    readonly embeddedRelationshipId: string | null;
+    readonly linkedRelationshipId: string | null;
+    readonly crop: SourceCrop;
+    readonly fillMode: 'stretch' | 'tile';
+    readonly transform: DrawingTransform;
+    readonly presetGeometry: string | null;
 }
 /**
- * Why content-type records could not be indexed.
+ * Project one `w:drawing` into the resolved shape layout and chrome read.
  *
- * All fail CLOSED: conflicting Defaults on one extension, duplicate normalized Override names, or
- * invalid MIME syntax are refused rather than resolved by picking one.
+ * Bounded throughout: extents, crops and nesting all come from a file. Returns a projection that
+ * reports `hidden` and its locks rather than throwing, so an unusable drawing degrades to
+ * something the surface can skip.
  */
-type ContentTypeError = {
-    readonly code: 'invalid-mime';
-    readonly value: string;
-} | {
-    readonly code: 'conflicting-default';
-    readonly extension: string;
-} | {
-    readonly code: 'duplicate-override';
-    readonly partName: string;
-} | {
-    readonly code: 'invalid-override-name';
-    readonly partName: string;
-} | {
-    readonly code: 'too-many-records';
-    readonly limit: number;
-};
-/** Whether a string is syntactically a MIME type. Syntax only — no registry lookup. */
-declare function isValidMime(value: string): boolean;
-/** ASCII-case-insensitive extension key (leading dot removed; ASCII-only fold). */
-declare function extensionKey(extension: string): string;
-/** The resolved lookup: Override by case-folded part name, Default by case-insensitive extension. */
-interface ContentTypeIndex {
-    /** ext key -> single MIME (identical duplicates collapsed). */
-    readonly defaults: ReadonlyMap<string, string>;
-    /** case-folded part name -> MIME. */
-    readonly overrides: ReadonlyMap<string, string>;
-}
-/** The built index, or the conflict that made it impossible. */
-type IndexResult = {
-    readonly ok: true;
-    readonly index: ContentTypeIndex;
-} | {
-    readonly ok: false;
-    readonly error: ContentTypeError;
-};
+declare function projectDrawing(drawing: OoxmlDrawingNode, context: Readonly<{
+    ownerPartName: string;
+    supportedMcRequires: ReadonlySet<string>;
+    limits: DrawingProjectionLimits;
+    namespaceScope?: ReadonlyMap<string, string>;
+    resolveRelationship?: RelationshipTargetResolver;
+    resolveSchemeColor?: ShapeSchemeColorResolver;
+    resolveStyleMatrixReference?: ShapeStyleMatrixResolver;
+}>): DrawingProjection | null;
+
+/** Opaque handle — bytes are reachable only through {@link mintValidatedImageBytes}. */
+interface ValidatedImageBytesHandle {
+    readonly registryId: number;
+    readonly resourceKey: string;
+    readonly contentId: string;
+    readonly generation: number;
+}
+
 /**
- * Build a resolved content-type index, failing closed on conflict/duplicate/MIME
- * errors. `maxRecords` bounds the combined record count (N/N+1 gate).
+ * The engine's trust-boundary caps: recursion depth, element counts, and the rest.
+ *
+ * A caller may LOWER any of these but never raise or disable one — an override of `Infinity`,
+ * zero, a negative or `NaN` clamps into `(0, ceiling]` rather than turning the limit off. These
+ * are security ceilings, not performance budgets.
+ */
+interface ResourceLimits {
+    /** Max nested-structure recursion (tables/shapes/SDT/groups). */
+    readonly maxRecursionDepth: number;
+    /** Max total parsed element count. */
+    readonly maxElementCount: number;
+    /** Max package part count. */
+    readonly maxPartCount: number;
+    /** Max total decompressed bytes (zip-bomb guard). */
+    readonly maxDecompressedBytes: number;
+    /** Max total compressed input bytes. */
+    readonly maxCompressedBytes: number;
+    /** Max decompressed:compressed ratio per entry. */
+    readonly maxCompressionRatio: number;
+    /** In-memory chunk budget for streaming/spooling. */
+    readonly maxChunkBytes: number;
+    /** Max pagination passes before non-convergence is declared. */
+    readonly maxPaginationPasses: number;
+    /** Max queued items in any bounded work queue. */
+    readonly maxQueueDepth: number;
+}
+/** Non-disableable hard ceilings: no resolved limit may exceed these. */
+declare const HARD_CEILINGS: ResourceLimits;
+/** Finite defaults, all <= their hard ceiling. */
+declare const DEFAULT_LIMITS: ResourceLimits;
+/**
+ * Resolve caller overrides into a frozen, always-finite limit set. Each value is
+ * `min(override>0 ? override : default, ceiling)`. Infinity/0/negative/NaN can
+ * never disable a limit — the hard ceiling always wins.
+ */
+declare function resolveLimits(overrides?: Partial<ResourceLimits>): ResourceLimits;
+/** Bounded image decode limits (typed-drawings-and-images task 4). */
+/** Trust-boundary caps specific to image decoding and embedding. */
+interface ImageResourceLimits {
+    readonly maxEncodedBytes: number;
+    readonly maxDecodedBytes: number;
+    readonly maxPixels: number;
+    readonly maxDimension: number;
+    readonly maxPolygonPoints: number;
+    readonly maxExternalRedirects: number;
+}
+/** Image caps nothing can raise past. A caller's override clamps into these. */
+declare const IMAGE_RESOURCE_HARD_CEILINGS: ImageResourceLimits;
+/** The image caps in force when a host configures none. Conservative and finite. */
+declare const DEFAULT_IMAGE_RESOURCE_LIMITS: ImageResourceLimits;
+/** Resolve caller overrides into frozen image limits; hard ceilings cannot be raised. */
+declare function resolveImageResourceLimits(overrides?: Partial<ImageResourceLimits>): ImageResourceLimits;
+
+/**
+ * Raster media the decode port measures and any authoring path may write.
+ *
+ * BMP and WebP are here for the same reason the other three are: an `<img>` decodes them
+ * natively, so they need a signature and a structural header and nothing else. BMP is what
+ * older documents carry; WebP is what current Word writes.
  */
-declare function buildContentTypeIndex(records: ContentTypeRecords, maxRecords?: number): IndexResult;
+type SupportedImageMime = 'image/png' | 'image/jpeg' | 'image/gif' | 'image/bmp' | 'image/webp';
 /**
- * A part's content type, or why it has none.
+ * Vector media painted straight from validated bytes. An `<img>` renders SVG in the
+ * browser's secure static mode — no script, no external subresource loads — so there is
+ * no decode step and no raster buffer sized by a file-supplied number.
+ */
+type VectorImageMime = 'image/svg+xml';
+/** Every mime the painter can hand to an `<img>`. */
+type RenderableImageMime = SupportedImageMime | VectorImageMime;
+/**
+ * Media kept in the package byte-for-byte that the painter cannot hand to an `<img>`.
+ * A decode port may rasterize it; without one it paints as a labelled placeholder.
+ */
+type PreservedImageMime = 'image/tiff' | 'image/x-emf' | 'image/x-wmf';
+/**
+ * What is known about one embedded image: validated, refused, or still decoding.
  *
- * An orphan record never determines a part's type — a Default with no matching part is preserved
- * inertly rather than applied.
+ * Content type is a CLAIM. Signature sniffing, structural header validation and the decode port
+ * are authoritative, and bytes that fail them never enter public state.
  */
-type ResolveResult = {
-    readonly ok: true;
-    readonly contentType: string;
-    readonly source: 'override' | 'default';
+type ImageResourceState = {
+    readonly kind: 'ready';
+    readonly partName: string;
+    readonly contentId: string;
+    readonly resourceKey: string;
+    readonly validatedHandle: ValidatedImageBytesHandle;
+    readonly mime: RenderableImageMime;
+    readonly pixelWidth: number;
+    readonly pixelHeight: number;
+    readonly dpiX: number;
+    readonly dpiY: number;
 } | {
-    readonly ok: false;
-    readonly reason: 'unknown';
+    readonly kind: 'unrenderable';
+    readonly partName: string | null;
+    readonly mime: RenderableImageMime | PreservedImageMime | 'unknown';
+    readonly reason: 'unsupported-format' | 'non-picture-graphic' | 'signature-mismatch' | 'decode-failed' | 'resource-limit';
+} | {
+    readonly kind: 'external';
+    readonly relationshipId: string;
+    readonly sinkSafe: boolean;
+} | {
+    readonly kind: 'missing';
+    readonly relationshipId: string;
+} | {
+    readonly kind: 'pending';
+    readonly resourceKey: string;
 };
-/** Resolve a part's content type: Override wins over Default; else unknown. */
-declare function resolveContentType(index: ContentTypeIndex, partName: string): ResolveResult;
+/**
+ * The injected image decoder.
+ *
+ * A port rather than a direct `Image`/`createImageBitmap` call, so a worker or server runtime
+ * supplies its own and the engine never reaches for a browser global.
+ */
+interface ImageDecodePort {
+    decode(bytes: Uint8Array, mime: SupportedImageMime, limits: ImageResourceLimits, 
+    /** Aborted when the owning lookup/session is disposed. */
+    signal?: AbortSignal): Promise<Readonly<{
+        pixelWidth: number;
+        pixelHeight: number;
+        dpiX: number;
+        dpiY: number;
+    }>>;
+    /**
+     * Optional conversion of media an `<img>` cannot render (EMF/WMF metafiles, TIFF) into a
+     * renderable raster. The returned bytes are untrusted and re-enter the full raster
+     * validation path (sniff, header, pixel caps, decode) before they can become a ready
+     * resource. A null return declines the format and keeps the labelled placeholder; so does
+     * a throw, as `decode-failed`.
+     */
+    convertPreserved?(bytes: Uint8Array, mime: PreservedImageMime, limits: ImageResourceLimits, 
+    /** Aborted when the owning lookup/session is disposed. */
+    signal?: AbortSignal): Promise<Readonly<{
+        bytes: Uint8Array;
+        mime: SupportedImageMime;
+    }> | null>;
+}
+/** Resolves a relationship id to a validated image resource, or reports why it could not. */
+interface ImageResourceLookup {
+    readonly resolveEmbedded: (ownerPartName: string, relationshipId: string) => Promise<ImageResourceState>;
+    readonly resolveLinked: (ownerPartName: string, relationshipId: string) => ImageResourceState;
+    readonly resolveForProjection: (projection: DrawingProjection) => Promise<ImageResourceState>;
+    readonly liveReferenceCount: (partName: string) => number;
+    readonly dispose: () => void;
+}
+/** Maximum prefix inspected for SVG root detection (exported for bounded-scan tests). */
+declare const MAX_SVG_SNIFF_BYTES = 512;
+/** A raster header that passed structural validation: its real MIME type and pixel extent. */
+interface ValidatedRasterHeader {
+    readonly pixelWidth: number;
+    readonly pixelHeight: number;
+    /** Horizontal physical density when bounded header metadata supplies it. */
+    readonly dpiX?: number;
+    /** Vertical physical density when bounded header metadata supplies it. */
+    readonly dpiY?: number;
+}
+/** Bounded scan for an `<svg` document root (optional `<?xml` prolog only). */
+declare function hasBoundedSvgRoot(bytes: Uint8Array): boolean;
+/** Signature sniffing — authoritative over declared content type. */
+declare function sniffImageMime(bytes: Uint8Array): RenderableImageMime | PreservedImageMime | 'unknown';
+/** Structural PNG IHDR validation before decode. */
+declare function validatePngHeader(bytes: Uint8Array): ValidatedRasterHeader | null;
+/** Structural GIF logical screen descriptor validation before decode. */
+declare function validateGifHeader(bytes: Uint8Array): ValidatedRasterHeader | null;
+/** Bounded JPEG marker scan through the first supported SOF marker. */
+declare function validateJpegHeader(bytes: Uint8Array): ValidatedRasterHeader | null;
+/**
+ * Intrinsic size of an SVG, resolved the way a browser sizes one: absolute `width`/`height`
+ * first, then `viewBox` for the missing axis or ratio, then the CSS 300x150 default.
+ *
+ * This is metadata for insert and reset-to-natural-size only. Layout uses the authored
+ * `wp:extent` and the browser rasterizes into that box, so nothing here sizes an allocation
+ * and an out-of-range value is clamped rather than refused.
+ */
+declare function resolveSvgIntrinsicSize(bytes: Uint8Array, limits: ImageResourceLimits): ValidatedRasterHeader | null;
+/**
+ * Validate a raster image's header structurally and report its real MIME type and extent.
+ *
+ * Content type is a CLAIM; this is what makes it a fact. A file declaring `image/png` over JPEG
+ * bytes is caught here rather than at decode.
+ */
+declare function validateRasterHeader(bytes: Uint8Array, mime: SupportedImageMime): ValidatedRasterHeader | null;
+/** Package-wide live drawing references to a media part name. */
+declare function liveDrawingReferenceCount(pkg: OoxmlPackage, partName: string): number;
+/** How the image cache decodes, and what it will spend doing so. */
+interface CreateImageResourceCacheOptions {
+    readonly limits?: Partial<ImageResourceLimits>;
+    readonly decodePort: ImageDecodePort;
+}
+/**
+ * Derived cache for one immutable package snapshot. Registry identity is
+ * `(package snapshot, decodePort object, normalized limits)` — the first caller
+ * never imposes its decoder or limits on later callers with different options.
+ */
+declare function imageResourceLookupFor(pkg: OoxmlPackage, options: CreateImageResourceCacheOptions): ImageResourceLookup;
+/** @deprecated Prefer {@link imageResourceLookupFor} — registry binds cache to package identity. */
+/** Build the per-document image cache. Validated bytes only; refusals are remembered too. */
+declare function createImageResourceCache(initialPkg: OoxmlPackage, options: CreateImageResourceCacheOptions): ImageResourceLookup;
 
 /** Caps applied while loading a package: zip, XML, part count and relationship count. */
 interface OoxmlPackageLimits {
@@ -1699,193 +1915,376 @@ declare function writeOoxmlPackage(pkg: OoxmlPackage): Uint8Array;
 /** Replace one part's tree, returning a new package. Pure, like the tree edits themselves. */
 declare function withPart(pkg: OoxmlPackage, part: OoxmlPart): OoxmlPackage;
 
-/**
- * Whether a drawing sits in the text flow or is positioned against a frame.
- *
- * The distinction that decides everything downstream: an inline drawing occupies a character
- * position, while an anchored one has offsets relative to a page, margin or column.
- */
-type DrawingKind = 'inline' | 'anchored';
-/** Nine Word wrap menu targets (inline plus eight floating modes). @public */
-type ImageWrapTarget = 'inline' | 'square' | 'squareLeft' | 'squareRight' | 'tight' | 'through' | 'topAndBottom' | 'behind' | 'inFront';
-/** Every text-wrap mode a drawing may be set to, including `inline`. */
-declare const IMAGE_WRAP_TARGETS: readonly ImageWrapTarget[];
-type DrawingWrapElement = 'none' | 'square' | 'tight' | 'through' | 'topAndBottom';
-type DrawingHorizontalReferenceFrame = 'character' | 'column' | 'insideMargin' | 'leftMargin' | 'margin' | 'outsideMargin' | 'page' | 'rightMargin';
-type DrawingVerticalReferenceFrame = 'bottomMargin' | 'insideMargin' | 'line' | 'margin' | 'outsideMargin' | 'page' | 'paragraph' | 'topMargin';
-/** `a:srcRect` — how much of each edge of the source image is cropped away, as fractions. */
-interface SourceCrop {
-    readonly left: number;
-    readonly top: number;
-    readonly right: number;
-    readonly bottom: number;
+/** A text watermark as the package stores it. */
+interface PackageTextWatermark {
+    readonly kind: 'text';
+    readonly text: string;
+    readonly fontFamily: string;
+    /** Null for Auto size, which fits the text to the shape box. */
+    readonly fontSizePt: number | null;
+    readonly bold: boolean;
+    readonly italic: boolean;
+    /** `RRGGBB`. */
+    readonly colorHex: string;
+    /** Fill opacity in [0, 1]; the dialog's Transparency is `1 - opacity`. */
+    readonly opacity: number;
+    readonly diagonal: boolean;
+    readonly widthPt: number;
+    readonly heightPt: number;
+}
+/** A picture watermark as the package stores it. */
+interface PackagePictureWatermark {
+    readonly kind: 'picture';
+    readonly washout: boolean;
+    readonly widthPt: number;
+    readonly heightPt: number;
+}
+/** One section's shape size, in points. */
+interface PackageWatermarkSize {
+    readonly widthPt: number;
+    readonly heightPt: number;
+}
+/**
+ * A write may size the shape per section, indexed like the body's sections: a header part
+ * takes the size of the first section that shows it, so a landscape section's watermark
+ * fits its own text area. A missing or unusable entry falls back to `widthPt`/`heightPt`.
+ */
+interface PackageWatermarkSectionSizes {
+    readonly sectionSizes?: readonly (PackageWatermarkSize | null)[];
+}
+/** A picture watermark write carries the image bytes. */
+type PackageWatermarkWrite = (PackageTextWatermark & PackageWatermarkSectionSizes) | (PackagePictureWatermark & PackageWatermarkSectionSizes & {
+    readonly image: {
+        readonly bytes: Uint8Array;
+        readonly mime: SupportedImageMime;
+    };
+});
+
+/**
+ * How a tracked change is addressed: `@w:id`, `@w:author` and `@w:date` together, within a
+ * part.
+ *
+ * All of them, always. `@w:id` is unique only within a part, so an id alone names two
+ * revisions in any package with a header or a comments part — and it is not author-scoped
+ * either, so `(part, id)` would merge two authors' distinct revisions. One logical revision is
+ * also deliberately many elements sharing an id, as a tracked row insertion is, which no
+ * uniqueness rule could express.
+ */
+interface RevisionAddress {
+    readonly id: string;
+    readonly author: string;
+    /** Absent when the file wrote no `@w:date`; part of the identity either way. */
+    readonly date?: string;
+}
+/** The author and timestamp a tracked edit is recorded under. */
+interface RevisionAttributionInput {
+    readonly author: string;
+    /** ISO-8601. Omitted writes no `@w:date`. */
+    readonly date?: string;
+}
+
+type AutomationTableMutation = {
+    readonly kind: 'insertRows';
+    readonly rowId: string;
+    readonly location: 'before' | 'after';
+    readonly count: number;
+    readonly values?: readonly (readonly string[])[];
+} | {
+    readonly kind: 'values';
+    readonly values: readonly (readonly string[])[];
+} | {
+    readonly kind: 'addRows' | 'addColumns';
+    readonly location: 'start' | 'end';
+    readonly count: number;
+    readonly values?: readonly (readonly string[])[];
+} | {
+    readonly kind: 'deleteRows' | 'deleteColumns';
+    readonly index: number;
+    readonly count: number;
+} | {
+    /** Merge the rectangle from one cell to another, by row and in-row cell index. */
+    readonly kind: 'mergeCells';
+    readonly topRow: number;
+    readonly firstCell: number;
+    readonly bottomRow: number;
+    readonly lastCell: number;
+} | {
+    readonly kind: 'splitCell';
+    readonly cellId: string;
+    readonly rowCount: number;
+    readonly columnCount: number;
+} | {
+    readonly kind: 'delete';
+} | {
+    readonly kind: 'properties';
+    readonly styleId?: string;
+    readonly headerRowCount?: number;
+} | {
+    readonly kind: 'cell';
+    readonly cellId: string;
+    readonly value?: string;
+    readonly columnWidth?: number;
+    readonly shadingColor?: string;
+    readonly verticalAlignment?: 'Top' | 'Center' | 'Bottom';
+};
+
+/** Select one declared entry of a legacy Word dropdown form field. */
+interface SetLegacyDropdownOp {
+    readonly op: 'setLegacyDropdown';
+    readonly paragraphId: string;
+    readonly fieldNodeId: string;
+    readonly selectedIndex: number;
+}
+
+interface SetFieldCodeOp {
+    readonly op: 'setFieldCode';
+    readonly paragraphId: string;
+    readonly fieldNodeId: string;
+    readonly code: string;
+}
+
+/**
+ * Insert an allowlisted page-number complex field at a UTF-16 offset.
+ *
+ * `PAGE_X_OF_Y` is PAGE + literal " of " + NUMPAGES in one undoable op. Non-page
+ * instructions are refused — never authored through this path.
+ */
+interface InsertPageFieldOp {
+    readonly op: 'insertPageField';
+    readonly paragraphId: string;
+    readonly offset: number;
+    readonly field: 'PAGE' | 'NUMPAGES' | 'SECTIONPAGES' | 'PAGE_X_OF_Y';
+    /**
+     * Write this as a TRACKED insertion, on the same terms as `insertText`.
+     *
+     * The whole field — every `w:fldChar`, the instruction, the `PAGE_X_OF_Y` literal —
+     * goes into ONE `w:ins`, because the field is one proposal: rejecting it must take
+     * the complete atom back, never leave a `begin` standing without its `end`.
+     */
+    readonly revision?: RevisionAttributionInput;
+}
+/**
+ * Insert one complex field with an empty cached result at a UTF-16 offset.
+ *
+ * The instruction must be one that `inertFieldInstruction` admits: a page number, a reference
+ * to a bookmark, note, or style, a sequence number, or a date. It is written as text and never
+ * evaluated. Every other instruction refuses with `invalidArgs`.
+ */
+interface InsertComplexFieldOp {
+    readonly op: 'insertComplexField';
+    readonly paragraphId: string;
+    readonly offset: number;
+    readonly instruction: string;
+    /** Write the whole field as ONE tracked insertion, on the same terms as `insertText`. */
+    readonly revision?: RevisionAttributionInput;
+}
+
+/** Set one field's cached result text. See the module comment for the placements. */
+interface SetFieldResultOp {
+    readonly op: 'setFieldResult';
+    readonly paragraphId: string;
+    /** The begin `w:fldChar`, or the `w:fldSimple` element. */
+    readonly fieldNodeId: string;
+    /** Plain text. A tab becomes `w:tab`; other control characters refuse. */
+    readonly text: string;
+    /**
+     * The author whose pending insertion holds the field. The result joins that insertion. The
+     * op mints no revision of its own.
+     */
+    readonly revision?: RevisionAttributionInput;
+}
+
+/** Insert one inline `m:oMath` and the plain runs beside it. */
+interface InsertEquationOp {
+    readonly op: 'insertEquation';
+    readonly paragraphId: string;
+    readonly offset: number;
+    /** Plain runs and exactly one inline `m:oMath`, in order. Receive fresh ids at apply. */
+    readonly nodes: readonly OoxmlNode[];
+    /** Model length of `nodes`: their text, plus one for the equation. */
+    readonly length: number;
+    /** Write the nodes as ONE tracked insertion, on the same terms as `insertText`. */
+    readonly revision?: RevisionAttributionInput;
+}
+
+type InsertTextOp = {
+    readonly op: 'insertText';
+    readonly paragraphId: string;
+    /** Legacy text form identity for protected filling; never an inline wrapper owner. */
+    readonly textFormFieldId?: string;
+    readonly offset: number;
+    readonly text: string;
+    /**
+     * Write this as a TRACKED insertion, attributed here.
+     *
+     * On the op rather than on the store, so suggesting stays a decision the surface makes
+     * per edit and the write vocabulary stays explicit — a global "everything is tracked
+     * now" flag is exactly what `DocEdits` refuses, because it makes the meaning of an op
+     * depend on state the op does not carry.
+     */
+    readonly revision?: RevisionAttributionInput;
+    /**
+     * When set, the text belongs INSIDE this content control, whatever sits at the offset.
+     *
+     * A boundary offset is owned by the run that starts there, which at a control's trailing
+     * edge is the run after the control — so an offset alone cannot say "append to this field",
+     * the way it cannot say which run of a field result to format (see `targetRunIds`). A
+     * caller that names the control gets the text in the control; one that does not gets the
+     * plain offset rule, which is what a keystroke beside a field means.
+     */
+    readonly inside?: string;
+    /**
+     * Which side of a run BOUNDARY the text joins. Default `'left'` — Word's typing rule:
+     * the next character takes the formatting of the character before the caret.
+     *
+     * `'right'` is for a caller that is not typing but placing text inside the run that
+     * STARTS at the offset — the hyperlink editor rewriting a link's display text, where
+     * landing left of the boundary would put the new text outside the link. Ignored when
+     * the offset falls strictly inside a run, which has no boundary to choose.
+     */
+    readonly bias?: 'left' | 'right';
+};
+type DeleteTextOp = {
+    readonly op: 'deleteText';
+    readonly paragraphId: string;
+    /** Legacy text form identity for protected filling; never an inline wrapper owner. */
+    readonly textFormFieldId?: string;
+    readonly start: number;
+    readonly end: number;
+    /** Write this as a TRACKED deletion — the characters stay, wrapped in `w:del`. */
+    readonly revision?: RevisionAttributionInput;
+};
+
+/** Editable legacy text input types. Other authored types remain inert. */
+type TextFormFieldType = 'regular' | 'number' | 'date';
+/** Options stored in the legacy field definition. Zero means unlimited length. */
+interface TextFormFieldOptions {
+    readonly type: TextFormFieldType;
+    readonly maxLength: number;
+    readonly format: string;
+    readonly enabled: boolean;
+}
+/** Supported format choices for legacy text input fields. @public */
+declare const TEXT_FORM_FORMATS: {
+    readonly regular: readonly ['', 'Uppercase', 'Lowercase', 'First capital', 'Title case'];
+    readonly number: readonly ['', '0', '0.00', '#,##0', '#,##0.00', '0%', '0.00%'];
+    readonly date: readonly ['', 'M/d/yyyy', 'MM/dd/yyyy', 'd/M/yyyy', 'dd/MM/yyyy', 'yyyy-MM-dd', 'd MMMM yyyy', 'MMMM d, yyyy'];
+};
+
+/** A legacy text input in the shared paragraph offset space. */
+interface TextFormFieldRange {
+    readonly fieldNodeId: string;
+    readonly start: number;
+    readonly end: number;
+    readonly enabled: boolean;
+    readonly defaultText: string;
+    readonly type: string;
+    readonly maxLength: number;
+    readonly format: string;
+    readonly chromeIds: readonly string[];
+}
+/** Uses the field parser and offset index; never introduces another inline walk. */
+declare function textFormFieldsOf(paragraph: OoxmlParagraphNode): readonly TextFormFieldRange[];
+/** Options edit for an existing legacy text form. */
+interface SetTextFormFieldDefaultOp {
+    readonly op: 'setTextFormFieldDefault';
+    /** Regional conventions for new date input; defaults to en-US. */
+    readonly locale?: string;
+    readonly paragraphId: string;
+    readonly fieldNodeId: string;
+    readonly text: string;
+    readonly options?: TextFormFieldOptions;
+}
+/** Validate and format the existing result when a user finishes filling a field. */
+interface CommitTextFormFieldOp {
+    readonly op: 'commitTextFormField';
+    /** Regional conventions for new date input; defaults to en-US. */
+    readonly locale?: string;
+    readonly paragraphId: string;
+    readonly fieldNodeId: string;
+}
+
+/** One FORMCHECKBOX in the shared paragraph offset space. */
+interface LegacyCheckboxFieldRange {
+    /** The begin `w:fldChar` node: what the op addresses. */
+    readonly fieldNodeId: string;
+    readonly start: number;
+    readonly end: number;
+    readonly checked: boolean;
+    /** `w:enabled` under `w:ffData`; a disabled field renders but refuses the toggle. */
+    readonly enabled: boolean;
+}
+/** Flip a FORMCHECKBOX's state; the only write into `w:ffData` a checkbox permits. */
+interface SetLegacyCheckboxOp {
+    readonly op: 'setLegacyCheckbox';
+    readonly paragraphId: string;
+    readonly fieldNodeId: string;
+    readonly checked: boolean;
+}
+/** Every FORMCHECKBOX in a paragraph, in document order; uses the shared field parser. */
+declare function legacyCheckboxFieldsOf(paragraph: OoxmlParagraphNode): readonly LegacyCheckboxFieldRange[];
+
+/** Replace a building block gallery control's content with one block's body. */
+interface InsertBuildingBlockOp {
+    readonly op: 'insertBuildingBlock';
+    readonly controlId: string;
+    /** `w:docPartPr/w:name` of the picked block, for the journal and the host. */
+    readonly name: string;
+    /**
+     * Self-contained `w:docPartBody` children, cloned with fresh ids at apply.
+     * Resource, style, field, bookmark, note and revision references return `unsupported`.
+     */
+    readonly blocks: readonly OoxmlNode[];
 }
-interface DrawingTransform {
-    readonly rotationDegrees: number;
-    readonly flipHorizontal: boolean;
-    readonly flipVertical: boolean;
-    /** Source `a:off` in EMU; defaults to origin when absent. */
-    readonly offsetEmu: Readonly<{
-        x: number;
-        y: number;
-    }>;
-    /** Source `a:ext` in EMU; zero falls back to `wp:extent` at geometry time. */
-    readonly extentEmu: Readonly<{
-        cx: number;
-        cy: number;
-    }>;
+
+/** A text position in the op's part. */
+interface BookmarkOpPosition {
+    readonly paragraphId: string;
+    readonly offset: number;
 }
 /**
- * What a drawing refuses: selection, movement, resizing, aspect change.
+ * Add a bookmark around `start`..`end`, or at one point when the two are equal.
  *
- * Read and honoured rather than advisory — chrome that offered a handle the store will refuse
- * would promise an edit that cannot happen.
+ * The name must pass `bookmarkNameProblem`. A bookmark the part already declares under the
+ * same name, compared without case, is removed in the same op.
  */
-interface DrawingLocks {
-    readonly select: boolean;
-    readonly move: boolean;
-    readonly resize: boolean;
-    readonly changeAspect: boolean;
-}
-interface DrawingLocksInput {
-    readonly select?: boolean;
-    readonly move?: boolean;
-    readonly resize?: boolean;
-    readonly changeAspect?: boolean;
+interface InsertBookmarkOp {
+    readonly op: 'insertBookmark';
+    readonly name: string;
+    readonly start: BookmarkOpPosition;
+    readonly end: BookmarkOpPosition;
 }
 /**
- * An anchored drawing's position: offsets, and the frames they are relative to.
+ * Remove every marker pair that declares this name, compared without case. The name is the
+ * one the file declares, so it is not held to the authoring rules.
  *
- * The relative-to bases matter as much as the offsets. Writing an offset without preserving its
- * base re-anchors the drawing against a different reference and moves it somewhere nobody asked.
+ * With `keepFirst`, remove only the copies: the pair `listBookmarks` answers for the name
+ * stays where it is. Refused when the part holds no copy. Two collaborators who both remove
+ * the copies remove the same nodes, so their edits converge on one bookmark.
  */
-interface DrawingPositionInput {
-    /**
-     * `'simple'` when `@simplePos="1"`: `horizontalEmu` / `verticalEmu` are authoritative
-     * `wp:simplePos` x/y. `'frame'` (default) uses positionH/V relative frames.
-     */
-    readonly mode?: 'frame' | 'simple';
-    readonly horizontalEmu?: number;
-    readonly verticalEmu?: number;
-    readonly relativeToH?: DrawingHorizontalReferenceFrame;
-    readonly relativeToV?: DrawingVerticalReferenceFrame;
-}
-interface DrawingProjection {
-    readonly drawingNodeId: string;
-    readonly ownerPartName: string;
-    readonly kind: DrawingKind;
-    readonly relationshipId: string | null;
-    readonly docPrId: number | null;
+interface DeleteBookmarkOp {
+    readonly op: 'deleteBookmark';
     readonly name: string;
-    readonly title: string;
-    readonly description: string;
-    readonly hyperlinkHref: string | null;
-    readonly hidden: boolean;
-    readonly extentEmu: Readonly<{
-        cx: number;
-        cy: number;
-    }>;
-    readonly effectExtentEmu: Readonly<{
-        top: number;
-        right: number;
-        bottom: number;
-        left: number;
-    }>;
-    readonly inlineDistancesEmu: Readonly<{
-        top: number;
-        right: number;
-        bottom: number;
-        left: number;
-    }>;
-    readonly wrap: ImageWrapTarget;
-    readonly wrapGeometry: DrawingWrapProjection | null;
-    readonly position: DrawingPositionProjection | null;
-    readonly anchor: Readonly<{
-        simplePos: boolean;
-        relativeHeight: number;
-        behindDocument: boolean;
-        layoutInCell: boolean;
-        allowOverlap: boolean;
-    }> | null;
-    readonly picture: PictureProjection | null;
-    readonly vectorShape: VectorShapeProjection | null;
-    /** The picture member of a `wpg:wgp` group; `picture` stays null for a group. */
-    readonly groupPicture: GroupPictureProjection | null;
-    readonly textboxStory: TextboxStoryProjection | null;
-    /** Text box members of a `wpg:wgp` group, laid out read-only; absent when none has text. */
-    readonly groupTextboxes?: readonly GroupTextboxProjection[];
-    /** Read-only preview of the supported native VML subset; the canonical XML is untouched. */
-    readonly legacyGraphic?: LegacyGraphicProjection;
-    readonly locks: DrawingLocks;
-    readonly effects: DrawingImageEffects;
-    readonly compatibilityBranchNodeId: string | null;
-    readonly diagnostics: readonly DrawingDiagnostic[];
-    /** Layout-only wrap area of an MC payload that cannot paint (`wrapFootprintProjection`). */
-    readonly footprintOnly?: true;
-}
-interface DrawingAccessibility {
-    /**
-     * The record takes part in layout only, for example the wrap area of a payload that cannot
-     * paint. Outputs must not paint, hit-test, select, link, or export it.
-     */
-    readonly hidden: boolean;
-    readonly decorative: boolean;
-    readonly label: string | null;
-}
-interface DrawingPositionProjection {
-    readonly simplePosition: Readonly<{
-        xEmu: number;
-        yEmu: number;
-    }>;
-    readonly horizontal: Readonly<{
-        relativeFrom: DrawingHorizontalReferenceFrame;
-        align: string | null;
-        offsetEmu: number | null;
-    }>;
-    readonly vertical: Readonly<{
-        relativeFrom: DrawingVerticalReferenceFrame;
-        align: string | null;
-        offsetEmu: number | null;
-    }>;
-}
-interface DrawingWrapProjection {
-    readonly element: DrawingWrapElement;
-    readonly textSide: 'bothSides' | 'left' | 'right' | 'largest';
-    readonly distancesEmu: Readonly<{
-        top: number;
-        right: number;
-        bottom: number;
-        left: number;
-    }>;
-    readonly polygon: readonly Readonly<{
-        x: number;
-        y: number;
-    }>[];
-}
-interface PictureProjection {
-    readonly embeddedRelationshipId: string | null;
-    readonly linkedRelationshipId: string | null;
-    readonly crop: SourceCrop;
-    readonly fillMode: 'stretch' | 'tile';
-    readonly transform: DrawingTransform;
-    readonly presetGeometry: string | null;
+    readonly keepFirst?: boolean;
+    /** @internal Limit a text deletion to one enclosed pair; explicit name deletion omits this. */
+    readonly pair?: {
+        readonly startNodeId: string;
+        readonly endNodeId: string;
+    };
 }
 /**
- * Project one `w:drawing` into the resolved shape layout and chrome read.
- *
- * Bounded throughout: extents, crops and nesting all come from a file. Returns a projection that
- * reports `hidden` and its locks rather than throwing, so an unusable drawing degrades to
- * something the surface can skip.
+ * The package with every bookmark of this name removed from one part, for moving a name out
+ * of another story inside the same transaction. The package is unchanged when that part does
+ * not declare the name. Protected markers refuse the whole package transaction.
  */
-declare function projectDrawing(drawing: OoxmlDrawingNode, context: Readonly<{
-    ownerPartName: string;
-    supportedMcRequires: ReadonlySet<string>;
-    limits: DrawingProjectionLimits;
-    namespaceScope?: ReadonlyMap<string, string>;
-    resolveRelationship?: RelationshipTargetResolver;
-    resolveSchemeColor?: ShapeSchemeColorResolver;
-    resolveStyleMatrixReference?: ShapeStyleMatrixResolver;
-}>): DrawingProjection | null;
+declare function withoutBookmarkInPart(pkg: OoxmlPackage, partName: string, name: string): OoxmlPackage;
+/**
+ * The `deleteBookmark` ops for the bookmarks an untracked deletion of `from`..`to` encloses,
+ * for a deletion that crosses paragraphs. `order` lists the part's paragraph ids in document
+ * order. A range bookmark goes when the deletion covers it edge to edge; a point bookmark goes
+ * when it is strictly inside. Applied before the text ops, so they find nothing left to drop.
+ */
+declare function enclosedBookmarkDeletions(part: OoxmlPart, from: BookmarkOpPosition, to: BookmarkOpPosition, order: readonly string[]): readonly DeleteBookmarkOp[];
 
 /** The `w15` namespace: `commentsExtended.xml` — thread parent and resolved state. */
 declare const W15_NAMESPACE_URI = "http://schemas.microsoft.com/office/word/2012/wordml";
@@ -2554,8 +2953,18 @@ interface RevisionBatchResult {
     /** All pending decisions in the addressed scope, including excluded and unsupported changes. */
     readonly remaining: number;
 }
-/** @internal Pure preflight; callers commit its operations through their normal write guards. */
-declare function planRevisionBatch(part: OoxmlPart, action: 'accept' | 'reject', keys?: readonly string[], scopeRoot?: OoxmlNode): {
+/**
+ * @internal Pure preflight; callers commit its operations through their normal write guards.
+ *
+ * `countRemaining: false` skips the exact count of the decisions left after the batch, and
+ * reports `remaining` as the decisions not resolved here. The exact count resolves the whole
+ * batch once more on a copy and lists what is left, which on a long reviewed document cost more
+ * than the plan itself, and a caller that reads only the operations or the skipped changes
+ * (a check, one decision, an editor that recounts its queue) paid it on every call.
+ */
+declare function planRevisionBatch(part: OoxmlPart, action: 'accept' | 'reject', keys?: readonly string[], scopeRoot?: OoxmlNode, options?: {
+    readonly countRemaining?: boolean;
+}): {
     ops: readonly TreeDocOp[];
     result: RevisionBatchResult;
 };
@@ -2864,8 +3273,9 @@ interface RunFormatting {
     /**
      * Line spacing at the selection, in the unit its rule implies — LINES for `multiple`,
      * points for `exact` and `atLeast`. The same vocabulary `setLineSpacing` takes, so a
-     * control can show what it reads and send back what it shows. Absent when the
-     * selection's paragraphs disagree or state no line spacing.
+     * control can show what it reads and send back what it shows. The effective value: a
+     * paragraph whose cascade states none reads as single spacing (`multiple`, 1). Absent
+     * when the selection's paragraphs disagree.
      */
     readonly lineSpacing?: {
         readonly rule: 'multiple' | 'exact' | 'atLeast';
@@ -3174,10 +3584,72 @@ interface Theme {
 }
 /** Theme colour slots (`accent1`, `dk1`, `lt2`, …) to hex. */
 type ThemeColorScheme = Readonly<Record<string, string>>;
-/** A watermark, which OOXML expresses as either text or an image — never both meaningfully. */
+/**
+ * A document watermark: text or a picture drawn behind the text of every page.
+ *
+ * Set `text` for a text watermark or `imageData` for a picture watermark, never both. Omitted
+ * options take the defaults in each field's description. The watermark goes into every header
+ * the document shows; a section with no header gets one.
+ *
+ * Text options apply only with `text`; `scale` and `washout` apply only with `imageData`.
+ * `setWatermark` refuses a mixed or out-of-range value with `invalidArgs` and a reason naming
+ * the field, and writes nothing.
+ *
+ * @example
+ * ```ts
+ * // A red, horizontal text watermark at 72pt.
+ * editor.exec({
+ *   type: 'setWatermark',
+ *   watermark: { text: 'CONFIDENTIAL', color: 'C00000', fontSizePt: 72, layout: 'horizontal' },
+ * });
+ * // A washed-out picture watermark at its natural size.
+ * editor.exec({ type: 'setWatermark', watermark: { imageData: pngBytes, scale: 1 } });
+ * ```
+ */
 interface Watermark {
+    /** The text of a text watermark, up to 256 characters on one line. */
     readonly text?: string;
+    /** The PNG, JPEG, GIF, BMP or WebP bytes of a picture watermark. */
     readonly imageData?: Uint8Array;
+    /** Text: the font family. Defaults to `Calibri`. */
+    readonly fontFamily?: string;
+    /** Text: the size in points, from 1 to 1000. Omitted or null is Auto, which fills the page. */
+    readonly fontSizePt?: number | null;
+    /** Text: bold. Defaults to false. */
+    readonly bold?: boolean;
+    /** Text: italic. Defaults to false. */
+    readonly italic?: boolean;
+    /** Text: the colour as `RRGGBB`. Defaults to `C0C0C0` (silver). */
+    readonly color?: string;
+    /** Text: transparency from 0 (opaque) to 1. Defaults to 0.5. */
+    readonly transparency?: number;
+    /** Text: the orientation. Defaults to `diagonal`. */
+    readonly layout?: WatermarkLayout;
+    /** Picture: a factor of the picture's natural size. Omitted or null is Auto, which fits the page. */
+    readonly scale?: number | null;
+    /** Picture: lighten the picture so text over it stays readable. Defaults to true. */
+    readonly washout?: boolean;
+}
+/** How a text watermark crosses the page. */
+type WatermarkLayout = 'diagonal' | 'horizontal';
+/**
+ * The watermark a document shows, as `Editor.getWatermark()` reads it.
+ *
+ * The text fields are present for a text watermark, `washout` for a picture watermark.
+ */
+interface WatermarkState {
+    readonly kind: 'text' | 'image';
+    readonly text?: string;
+    readonly fontFamily?: string;
+    /** Null for Auto size. */
+    readonly fontSizePt?: number | null;
+    readonly bold?: boolean;
+    readonly italic?: boolean;
+    /** `RRGGBB`. */
+    readonly color?: string;
+    readonly transparency?: number;
+    readonly layout?: WatermarkLayout;
+    readonly washout?: boolean;
 }
 /** A size in EMUs, the unit DrawingML stores extents in. 914400 EMU = 1 inch. */
 interface Extent {
@@ -3401,26 +3873,7 @@ type TreeDocOp = SetFieldCodeOp | {
     readonly offset: number;
     /** Write this as a TRACKED insertion, on the same terms as `insertText`. */
     readonly revision?: RevisionAttributionInput;
-} | {
-    /**
-     * Insert an allowlisted page-number complex field at a UTF-16 offset.
-     *
-     * `PAGE_X_OF_Y` is PAGE + literal " of " + NUMPAGES in one undoable op. Non-page
-     * instructions are refused — never authored through this path.
-     */
-    readonly op: 'insertPageField';
-    readonly paragraphId: string;
-    readonly offset: number;
-    readonly field: 'PAGE' | 'NUMPAGES' | 'SECTIONPAGES' | 'PAGE_X_OF_Y';
-    /**
-     * Write this as a TRACKED insertion, on the same terms as `insertText`.
-     *
-     * The whole field — every `w:fldChar`, the instruction, the `PAGE_X_OF_Y` literal —
-     * goes into ONE `w:ins`, because the field is one proposal: rejecting it must take
-     * the complete atom back, never leave a `begin` standing without its `end`.
-     */
-    readonly revision?: RevisionAttributionInput;
-} | {
+} | InsertPageFieldOp | InsertComplexFieldOp | SetFieldResultOp | InsertEquationOp | {
     /**
      * Move a numbered paragraph to another `w:numPr/w:ilvl`.
      *
@@ -3709,6 +4162,8 @@ type TreeDocOp = SetFieldCodeOp | {
         readonly xpath: string;
         readonly storeItemId: string;
     };
+    /** Propose the control as a tracked `w:ins`; rejecting removes it with its text. */
+    readonly revision?: RevisionAttributionInput;
 } | {
     /** Repeating-section item insert — unsupported at this layer (out of scope). */
     readonly op: 'addRepeatingSectionItem';
@@ -3783,6 +4238,18 @@ type TreeDocOp = SetFieldCodeOp | {
     readonly op: 'deleteTableColumn';
     readonly tableId: string;
     readonly gridColumnId: string;
+} | {
+    /** Merge cells covering one rectangle into its top-left cell, content in reading order. */
+    readonly op: 'mergeTableCells';
+    readonly tableId: string;
+    readonly cellIds: readonly string[];
+} | {
+    /** Split one cell into `rows` by `columns` equal cells; a one-row cell adds rows. */
+    readonly op: 'splitTableCell';
+    readonly tableId: string;
+    readonly cellId: string;
+    readonly rows: number;
+    readonly columns: number;
 } | {
     /**
      * Resize one internal divider between two adjacent canonical grid columns.
@@ -3907,6 +4374,10 @@ type TreeDocOp = SetFieldCodeOp | {
      */
     readonly op: 'setDocumentProtection';
     readonly enforce: boolean;
+} | {
+    /** Replace the watermark in every header a section shows; null removes it. Package-level. */
+    readonly op: 'setWatermark';
+    readonly watermark: PackageWatermarkWrite | null;
 } | {
     /**
      * Insert a footnote or endnote: body reference + notes-part body (+ create the
@@ -4110,7 +4581,7 @@ type TreeDocOp = SetFieldCodeOp | {
         readonly paragraphId: string;
         readonly pageNumberText: string;
     }[];
-} | SetTextFormFieldDefaultOp | CommitTextFormFieldOp | SetLegacyCheckboxOp | SetLegacyDropdownOp | InsertBuildingBlockOp | {
+} | SetTextFormFieldDefaultOp | CommitTextFormFieldOp | SetLegacyCheckboxOp | SetLegacyDropdownOp | InsertBuildingBlockOp | InsertBookmarkOp | DeleteBookmarkOp | {
     /**
      * Rewrite recognized fields' cached RESULT runs in place — between the `separate` and
      * `end` fldChars, or a `w:fldSimple`'s content. The instruction is never modified; a
@@ -4210,6 +4681,11 @@ type TreeOpRejection = 'unknown-op' | 'unknown-paragraph' | 'not-a-paragraph' |
  * pointing at a part nobody created, or a part with no declared content type.
  */
  | 'package-invariant'
+/**
+ * A package edit refused the package it was given, for example because an id or part name it
+ * expected to allocate is taken or a definition it addresses changed. Nothing was applied.
+ */
+ | 'package-changed'
 /** No revision in this part carries the addressed `(id, author, date)` triple. */
  | 'unknown-revision'
 /**
@@ -4217,7 +4693,13 @@ type TreeOpRejection = 'unknown-op' | 'unknown-paragraph' | 'not-a-paragraph' |
  * implemented. Refusing is deliberate: removing the markup alone would report the decision
  * applied while leaving the row, cell, or section it describes untouched.
  */
- | 'unsupported-revision' | 'tree-invariant'
+ | 'unsupported-revision'
+/**
+ * A tracked insertion would land inside a link, content control, or other container within
+ * another author's pending insertion. The container cannot split, and nested words would
+ * become part of that author's proposal.
+ */
+ | 'unsupported-revision:foreign-insertion' | 'tree-invariant'
 /** No content control in this part carries the addressed node id. */
  | 'unknown-content-control'
 /** The addressed node exists and is not a `w:sdt`. */
@@ -4247,8 +4729,18 @@ type TreeOpRejection = 'unknown-op' | 'unknown-paragraph' | 'not-a-paragraph' |
  * mapping cannot be trusted and the inserted row would not match it.
  */
  | 'row-hides-cell'
-/** Column edit refused because the table carries horizontal or vertical merges. */
+/** The table carries a legacy `w:hMerge`, which grid edits cannot place. */
  | 'table-has-merge'
+/** The cells to merge do not cover one rectangle, or cover only one cell. */
+ | 'cells-not-rectangle'
+/** A cell merged over several rows splits only into a divisor of them. */
+ | 'split-rows-not-divisor'
+/** The cells hold a tracked cell insertion, deletion, or merge. */
+ | 'cell-has-revision'
+/** The split cells would be narrower than the minimum column width. */
+ | 'cell-too-narrow'
+/** Without `w:tblGrid`, a cell splits only into a divisor of the columns it spans. */
+ | 'split-needs-grid'
 /** The addressed grid column id is missing or ambiguous without `w:tblGrid`. */
  | 'unknown-grid-column'
 /** The operation would exceed bounded table topology limits. */
@@ -4286,5 +4778,5 @@ type TreeOpResult = {
     readonly detail?: string;
 };
 
-export { IMAGE_WRAP_TARGETS as aL, TEXT_FORM_FORMATS as aM, ACCEPTED_PARAGRAPH_PROPERTIES as b2, ACCEPTED_RUN_PROPERTIES as b3, CONTENT_CONTROL_ID_MAX as b4, CONTENT_CONTROL_PROPERTY_ORDER as b5, MAX_CONTENT_CONTROL_NESTING as bA, OFFICE_RELATIONSHIP_NAMESPACE_URI as bD, OOXML_NODE_IDENTITY_RULES as bE, DEFAULT_OOXML_PACKAGE_LIMITS as bm, DEFAULT_ZIP_LIMITS as bn, HYPERLINK_RELATIONSHIP_TYPE as bq, IMAGE_RELATIONSHIP_TYPE as bt, MAX_CONTENT_CONTROLS_PER_PART as bz, hyperlinkAnchorOf as c$, allocateContentControlId as cF, asciiFold as cG, buildContentTypeIndex as cH, buildRelationshipSet as cI, childElements as cJ, commentAnchorsOfStory as cK, commentsOfPart as cL, contentControlContentChildren as cM, contentControlContentNodeOf as cN, contentControlEndPropertiesNodeOf as cO, contentControlLevelOf as cP, contentControlPropertiesNodeOf as cQ, contentControlPropertiesOf as cR, contentControlTextOf as cS, contentControlsIn as cT, detectDuplicateNames as cU, extensionKey as cV, findContentControl as cW, findElement as cX, firstReviewRange as cY, flattenContentControls as cZ, hasAnyComment as c_, TABLE_BORDER_STYLES as co, W15_NAMESPACE_URI as cu, WML_NAMESPACE_URI as cv, XMLNS_NAMESPACE_URI as cw, XML_NAMESPACE_URI as cx, hyperlinkRelationshipIdOf as d0, hyperlinkTargetOf as d1, isContentControlContentNode as d2, isContentControlNode as d3, isContentControlWrapper as d4, isContentRevisionKind as d5, isHyperlinkNode as d6, isRangeMarkerKind as d7, isValidMime as d8, legacyCheckboxFieldsOf as d9, withPart as dA, writeOoxmlPackage as dB, writeZip as dC, activeReviewItem as dE, reviewItemPositionRank as dF, reviewItemsAt as dG, reviewThreadRootOf as dH, lockForbidsEdit as da, lockForbidsRemoval as db, normalizePartName as dc, orderedContentControlProperties as dd, parseContentControlId as de, partNameKey as df, planRevisionAuthorChange as dg, planRevisionBatch as dh, projectDrawing as di, readOnOffChild as dj, readOoxmlPackage as dk, readOoxmlPart as dl, readXml as dm, readZip as dn, resolveContentControlLock as dp, resolveContentType as dq, resolveImageRelationship as dr, resolveInternalTarget as ds, resolveRelationship as dt, reviewItemKey as du, reviewItemRanges as dv, textContent as dw, textFormFieldsOf as dx, threadStateOfPart as dy, validateExternalTarget as dz };
-export type { DrawingVerticalReferenceFrame as $, ParagraphTabStop as A, Block as B, CommentRecord as C, DocxDocument as D, ExecResult as E, RevisionType as F, Section as G, HeaderFooterSet as H, InsertableContentControlType as I, SectionProperties as J, StyleDefinition as K, Theme as L, ThemeColorScheme as M, OoxmlNode as N, OoxmlPart as O, Paragraph as P, OoxmlPackage as Q, ReviewModelInput as R, StyleDefinitions as S, Table as T, OoxmlNodeId as U, OoxmlGenericElementNode as V, DocxDocumentJSON as W, DrawingHorizontalReferenceFrame as X, DrawingKind as Y, DrawingLocks as Z, DrawingPositionInput as _, ReviewItem as a, OoxmlHardBreakNode as a$, FontDefinition as a0, ImageWrapTarget as a1, NumberingRef as a2, PageMargins as a3, ParagraphDisagreements as a4, ParagraphFormatCommand as a5, Point as a6, Rect as a7, RevisionAuthorResult as a8, RevisionBatchResult as a9, OoxmlParagraphNode as aA, OoxmlNoteNode as aB, OoxmlContinuationSeparatorNode as aC, OoxmlEndnotesNode as aD, OoxmlFootnotesNode as aE, OoxmlNoteRefNode as aF, OoxmlNoteReferenceNode as aG, OoxmlSeparatorNode as aH, ImpactClass as aI, SourceCrop as aJ, TreeDocColorValue as aK, TextFormFieldRange as aN, TextFormFieldOptions as aO, DrawingTransform as aP, TableBorderStyle as aQ, DrawingAccessibility as aR, DrawingImageEffects as aS, VectorShapeProjection as aT, OoxmlDrawingNode as aU, OoxmlInvariantResult as aV, OoxmlFldCharNode as aW, OoxmlFldSimpleNode as aX, OoxmlInstrTextNode as aY, TreeOpResult as aZ, RelationshipRecord as a_, Run as aa, SelectionPin as ab, TableCell as ac, TableRow as ad, Unsubscribe as ae, Watermark as af, TreeDocOp as ag, OoxmlElement as ah, OoxmlContentControlNode as ai, OoxmlContentControlContentNode as aj, OoxmlPackageRejection as ak, DrawingProjection as al, OoxmlProperty as am, OoxmlPackageResult as an, OoxmlPackageLimits as ao, RevisionAuthorEntry as ap, RevisionAuthorSkipReason as aq, RevisionBatchEntry as ar, RevisionBatchSkipDetail as as, RevisionBatchSkipReason as at, RevisionSiteRefusal as au, TreeOpRejection as av, AutomationTableMutation as aw, RevisionAttributionInput as ax, OoxmlInvariantIssue as ay, DrawingTreeDocOp as az, ReviewRevisionItem as b, OoxmlHyperlinkNode as b$, OoxmlAttribute as b0, CommentThreadState as b1, CommentAnchor as b6, CommentPosition as b7, CommitTextFormFieldOp as b8, ContentControlCheckbox as b9, NameRejection as bB, NameResult as bC, OoxmlBodyNode as bF, OoxmlBookmarkEndNode as bG, OoxmlBookmarkStartNode as bH, OoxmlContentControlCalendarNode as bI, OoxmlContentControlCheckboxNode as bJ, OoxmlContentControlCheckedNode as bK, OoxmlContentControlCheckedStateNode as bL, OoxmlContentControlComboBoxNode as bM, OoxmlContentControlDataBindingNode as bN, OoxmlContentControlDateFormatNode as bO, OoxmlContentControlDateNode as bP, OoxmlContentControlDropDownListNode as bQ, OoxmlContentControlEndPropertiesNode as bR, OoxmlContentControlLidNode as bS, OoxmlContentControlListItemNode as bT, OoxmlContentControlPropertiesNode as bU, OoxmlContentControlStoreMappedDataAsNode as bV, OoxmlContentControlTextNode as bW, OoxmlContentControlUncheckedStateNode as bX, OoxmlDocumentNode as bY, OoxmlExternalTarget as bZ, OoxmlGenericExtensionAttribute as b_, ContentControlCheckboxState as ba, ContentControlDataBinding as bb, ContentControlDateFormat as bc, ContentControlEntry as bd, ContentControlKind as be, ContentControlLevel as bf, ContentControlListItem as bg, ContentControlLock as bh, ContentControlProperties as bi, ContentTypeError as bj, ContentTypeIndex as bk, ContentTypeRecords as bl, DefaultRecord as bo, DeleteTextOp as bp, HyperlinkKind as br, HyperlinkTarget as bs, ImageRelationshipResolution as bu, IndexResult as bv, InsertBuildingBlockOp as bw, InsertTextOp as bx, LegacyCheckboxFieldRange as by, ReviewCommentItem as c, OoxmlInvariantIssueCode as c0, OoxmlKnownNodeAttribute as c1, OoxmlNamespaceBinding as c2, OoxmlNodeIdentityRules as c3, OoxmlParagraphPropertiesNode as c4, OoxmlPartMetadata as c5, OoxmlReadRejection as c6, OoxmlReadResult as c7, OoxmlRunNode as c8, OoxmlRunPropertiesNode as c9, XmlRejection as cA, XmlResult as cB, ZipLimits as cC, ZipReadResult as cD, ZipRejection as cE, OoxmlTabNode as ca, OoxmlTextElementNode as cb, OoxmlTextNode as cc, OoxmlWmlValAttribute as cd, OoxmlXmlSpaceAttribute as ce, OverrideRecord as cf, RelationshipError as cg, RelationshipSetResult as ch, RelationshipTargetResolver as ci, ResolveResult as cj, ResolvedRelationship as ck, SetLegacyCheckboxOp as cl, SetLegacyDropdownOp as cm, SetTextFormFieldDefaultOp as cn, TabStopWrite as cp, TargetMode as cq, TextFormFieldType as cr, TreeDocOpKind as cs, TreeOpEffect as ct, XmlLimits as cy, XmlNode as cz, ReviewCustomItem as d, VectorShapeComponent as dD, ReviewPosition as e, ReviewRange as f, ReviewRevisionKind as g, RevisionAddress as h, ContentControlType as i, DocTarget as j, RunFormatting as k, Extent as l, ContainerRef as m, ContentControlFilter as n, DocRange as o, Revision as p, DocComment as q, ColorValue as r, ContentControl as s, DocAnchor as t, DocAnchorRange as u, DocLocation as v, DocumentBody as w, ExecErrorCode as x, IndentFormatting as y, ParagraphFlags as z };
+export { validateRasterHeader as a$, DEFAULT_IMAGE_RESOURCE_LIMITS as aV, IMAGE_WRAP_TARGETS as aW, TEXT_FORM_FORMATS as aX, resolveImageResourceLimits as aY, resolveSvgIntrinsicSize as aZ, sniffImageMime as a_, MAX_CONTENT_CONTROLS_PER_PART as b$, DEFAULT_LIMITS as bF, DEFAULT_OOXML_PACKAGE_LIMITS as bG, DEFAULT_ZIP_LIMITS as bH, HARD_CEILINGS as bL, HYPERLINK_RELATIONSHIP_TYPE as bM, IMAGE_RELATIONSHIP_TYPE as bP, IMAGE_RESOURCE_HARD_CEILINGS as bQ, ACCEPTED_PARAGRAPH_PROPERTIES as bj, ACCEPTED_RUN_PROPERTIES as bk, CONTENT_CONTROL_ID_MAX as bm, CONTENT_CONTROL_PROPERTY_ORDER as bn, XMLNS_NAMESPACE_URI as c$, MAX_CONTENT_CONTROL_NESTING as c0, MAX_SVG_SNIFF_BYTES as c1, OFFICE_RELATIONSHIP_NAMESPACE_URI as c4, OOXML_NODE_IDENTITY_RULES as c5, TABLE_BORDER_STYLES as cS, W15_NAMESPACE_URI as cZ, WML_NAMESPACE_URI as c_, resolveImageRelationship as d$, XML_NAMESPACE_URI as d0, allocateContentControlId as d8, asciiFold as d9, hyperlinkTargetOf as dA, imageResourceLookupFor as dB, isContentControlContentNode as dC, isContentControlNode as dD, isContentControlWrapper as dE, isContentRevisionKind as dF, isHyperlinkNode as dG, isRangeMarkerKind as dH, isValidMime as dI, legacyCheckboxFieldsOf as dJ, liveDrawingReferenceCount as dK, lockForbidsEdit as dL, lockForbidsRemoval as dM, normalizePartName as dN, orderedContentControlProperties as dO, parseContentControlId as dP, partNameKey as dQ, planRevisionAuthorChange as dR, planRevisionBatch as dS, projectDrawing as dT, readOnOffChild as dU, readOoxmlPackage as dV, readOoxmlPart as dW, readXml as dX, readZip as dY, resolveContentControlLock as dZ, resolveContentType as d_, buildContentTypeIndex as da, buildRelationshipSet as db, childElements as dc, commentAnchorsOfStory as dd, commentsOfPart as de, contentControlContentChildren as df, contentControlContentNodeOf as dg, contentControlEndPropertiesNodeOf as dh, contentControlLevelOf as di, contentControlPropertiesNodeOf as dj, contentControlPropertiesOf as dk, contentControlTextOf as dl, contentControlsIn as dm, createImageResourceCache as dn, detectDuplicateNames as dp, enclosedBookmarkDeletions as dq, extensionKey as dr, findContentControl as ds, findElement as dt, firstReviewRange as du, flattenContentControls as dv, hasAnyComment as dw, hasBoundedSvgRoot as dx, hyperlinkAnchorOf as dy, hyperlinkRelationshipIdOf as dz, resolveInternalTarget as e0, resolveLimits as e1, resolveRelationship as e2, reviewItemKey as e3, reviewItemRanges as e4, textContent as e5, textFormFieldsOf as e6, threadStateOfPart as e7, validateExternalTarget as e8, validateGifHeader as e9, validateJpegHeader as ea, validatePngHeader as eb, withPart as ec, withoutBookmarkInPart as ed, writeOoxmlPackage as ee, writeZip as ef, activeReviewItem as eh, reviewItemPositionRank as ei, reviewItemsAt as ej, reviewThreadRootOf as ek };
+export type { Table as $, ParagraphDisagreements as A, Block as B, CommentRecord as C, DocxDocument as D, ExecResult as E, ParagraphFlags as F, ParagraphTabStop as G, HeaderFooterSet as H, InsertableContentControlType as I, RevisionAuthorEntry as J, RevisionAuthorResult as K, RevisionAuthorSkipReason as L, RevisionBatchEntry as M, NumberingRef as N, OoxmlPart as O, PageMargins as P, RevisionBatchResult as Q, ReviewModelInput as R, StyleDefinitions as S, RevisionBatchSkipDetail as T, RevisionBatchSkipReason as U, RevisionSiteRefusal as V, RevisionType as W, Run as X, Section as Y, SectionProperties as Z, StyleDefinition as _, ReviewItem as a, TableCell as a0, TableRow as a1, Theme as a2, ThemeColorScheme as a3, OoxmlNode as a4, OoxmlPackage as a5, DocxDocumentJSON as a6, DrawingHorizontalReferenceFrame as a7, DrawingKind as a8, DrawingLocks as a9, OoxmlPackageResult as aA, OoxmlPackageRejection as aB, OoxmlNodeId as aC, OoxmlPackageLimits as aD, AutomationTableMutation as aE, RevisionAttributionInput as aF, TreeOpRejection as aG, PackageWatermarkWrite as aH, OoxmlInvariantIssue as aI, DrawingTreeDocOp as aJ, ImpactClass as aK, OoxmlParagraphNode as aL, OoxmlNoteNode as aM, OoxmlContinuationSeparatorNode as aN, OoxmlEndnotesNode as aO, OoxmlFootnotesNode as aP, OoxmlNoteRefNode as aQ, OoxmlNoteReferenceNode as aR, OoxmlSeparatorNode as aS, SourceCrop as aT, TreeDocColorValue as aU, DrawingPositionInput as aa, DrawingVerticalReferenceFrame as ab, FontDefinition as ac, ImageDecodePort as ad, ImageResourceLimits as ae, ImageResourceState as af, ImageWrapTarget as ag, ParagraphFormatCommand as ah, Point as ai, PreservedImageMime as aj, Rect as ak, RenderableImageMime as al, SelectionPin as am, SupportedImageMime as an, Unsubscribe as ao, ValidatedImageBytesHandle as ap, VectorImageMime as aq, Watermark as ar, WatermarkLayout as as, WatermarkState as at, TreeDocOp as au, OoxmlElement as av, OoxmlContentControlNode as aw, OoxmlGenericElementNode as ax, OoxmlContentControlContentNode as ay, OoxmlProperty as az, ReviewRevisionItem as b, TextFormFieldRange as b0, TextFormFieldOptions as b1, DrawingTransform as b2, TableBorderStyle as b3, DrawingAccessibility as b4, DrawingImageEffects as b5, VectorShapeProjection as b6, DrawingProjection as b7, OoxmlDrawingNode as b8, OoxmlInvariantResult as b9, ContentControlProperties as bA, ContentTypeError as bB, ContentTypeIndex as bC, ContentTypeRecords as bD, CreateImageResourceCacheOptions as bE, DefaultRecord as bI, DeleteBookmarkOp as bJ, DeleteTextOp as bK, HyperlinkKind as bN, HyperlinkTarget as bO, ImageRelationshipResolution as bR, ImageResourceLookup as bS, IndexResult as bT, InsertBookmarkOp as bU, InsertBuildingBlockOp as bV, InsertComplexFieldOp as bW, InsertEquationOp as bX, InsertPageFieldOp as bY, InsertTextOp as bZ, LegacyCheckboxFieldRange as b_, OoxmlFldCharNode as ba, OoxmlFldSimpleNode as bb, OoxmlInstrTextNode as bc, TreeOpResult as bd, RelationshipRecord as be, OoxmlHardBreakNode as bf, OoxmlAttribute as bg, ResourceLimits as bh, CommentThreadState as bi, BookmarkOpPosition as bl, CommentAnchor as bo, CommentPosition as bp, CommitTextFormFieldOp as bq, ContentControlCheckbox as br, ContentControlCheckboxState as bs, ContentControlDataBinding as bt, ContentControlDateFormat as bu, ContentControlEntry as bv, ContentControlKind as bw, ContentControlLevel as bx, ContentControlListItem as by, ContentControlLock as bz, ReviewCommentItem as c, NameRejection as c2, NameResult as c3, OoxmlBodyNode as c6, OoxmlBookmarkEndNode as c7, OoxmlBookmarkStartNode as c8, OoxmlContentControlCalendarNode as c9, OoxmlReadResult as cA, OoxmlRunNode as cB, OoxmlRunPropertiesNode as cC, OoxmlTabNode as cD, OoxmlTextElementNode as cE, OoxmlTextNode as cF, OoxmlWmlValAttribute as cG, OoxmlXmlSpaceAttribute as cH, OverrideRecord as cI, RelationshipError as cJ, RelationshipSetResult as cK, RelationshipTargetResolver as cL, ResolveResult as cM, ResolvedRelationship as cN, SetFieldResultOp as cO, SetLegacyCheckboxOp as cP, SetLegacyDropdownOp as cQ, SetTextFormFieldDefaultOp as cR, TabStopWrite as cT, TargetMode as cU, TextFormFieldType as cV, TreeDocOpKind as cW, TreeOpEffect as cX, ValidatedRasterHeader as cY, OoxmlContentControlCheckboxNode as ca, OoxmlContentControlCheckedNode as cb, OoxmlContentControlCheckedStateNode as cc, OoxmlContentControlComboBoxNode as cd, OoxmlContentControlDataBindingNode as ce, OoxmlContentControlDateFormatNode as cf, OoxmlContentControlDateNode as cg, OoxmlContentControlDropDownListNode as ch, OoxmlContentControlEndPropertiesNode as ci, OoxmlContentControlLidNode as cj, OoxmlContentControlListItemNode as ck, OoxmlContentControlPropertiesNode as cl, OoxmlContentControlStoreMappedDataAsNode as cm, OoxmlContentControlTextNode as cn, OoxmlContentControlUncheckedStateNode as co, OoxmlDocumentNode as cp, OoxmlExternalTarget as cq, OoxmlGenericExtensionAttribute as cr, OoxmlHyperlinkNode as cs, OoxmlInvariantIssueCode as ct, OoxmlKnownNodeAttribute as cu, OoxmlNamespaceBinding as cv, OoxmlNodeIdentityRules as cw, OoxmlParagraphPropertiesNode as cx, OoxmlPartMetadata as cy, OoxmlReadRejection as cz, ReviewCustomItem as d, XmlLimits as d1, XmlNode as d2, XmlRejection as d3, XmlResult as d4, ZipLimits as d5, ZipReadResult as d6, ZipRejection as d7, ReviewPosition as e, VectorShapeComponent as eg, ReviewRange as f, ReviewRevisionKind as g, RevisionAddress as h, ContentControlType as i, DocTarget as j, RunFormatting as k, Extent as l, ContainerRef as m, ContentControlFilter as n, DocRange as o, Revision as p, DocComment as q, ColorValue as r, ContentControl as s, DocAnchor as t, DocAnchorRange as u, DocLocation as v, DocumentBody as w, ExecErrorCode as x, IndentFormatting as y, Paragraph as z };