@beyondwork/docx-react-component 1.0.101 → 1.0.103

package/src/runtime/formatting/document-lookup.ts

@@ -26,6 +26,7 @@ import type {
   TableNode,
   TextMark,
   TextNode,
+  Mutable,
 } from "../../model/canonical-document.ts";
 
 export interface FoundParagraph {
@@ -165,7 +166,7 @@ export function canonicalMarksToRunFormatting(
   marks: readonly TextMark[] | undefined,
 ): CanonicalRunFormatting | undefined {
   if (!marks || marks.length === 0) return undefined;
-  const direct: CanonicalRunFormatting = {};
+  const direct: Mutable<CanonicalRunFormatting> = {};
   for (const mark of marks) {
     switch (mark.type) {
       case "bold":
@@ -190,7 +191,7 @@ export function canonicalMarksToRunFormatting(
         direct.smallCaps = true;
         break;
       case "fontFamily":
-        direct.fontFamily = mark.val;
+        (direct as Mutable<typeof direct>).fontFamily = mark.val;
         direct.fontFamilyAscii = mark.val;
         break;
       case "fontSize":

package/src/runtime/formatting/formatting-context.ts

@@ -44,6 +44,7 @@ import type {
   RevisionRecord,
   TableNode,
   TableStyleConditionalRegion,
+  Mutable,
 } from "../../model/canonical-document.ts";
 import type { FieldPageGraph, FieldResolver, ResolvedField } from "./field/resolver.ts";
 import { createFieldResolver } from "./field/resolver.ts";
@@ -68,6 +69,13 @@ import type {
   EffectiveParagraphFormatting,
   EffectiveRunFormatting,
 } from "./formatting-types.ts";
+import {
+  collectFieldLayoutInputs,
+  toFieldLayoutInput,
+  toNumberingLayoutInput,
+  type FieldLayoutInput,
+  type NumberingLayoutInput,
+} from "./layout-inputs.ts";
 
 /**
  * Direct-text-mark direct formatting. Mirrors (and replaces) the
@@ -242,6 +250,16 @@ export interface FormattingContext {
     options?: { advance?: boolean; emitGeometry?: boolean },
   ): NumberingResolution | null;
 
+  /**
+   * PE2 layout-ready numbering input. Normalizes the existing prefix result
+   * into marker/text-column/tab-stop fields L04 can measure without
+   * reinterpreting numbering semantics.
+   */
+  resolveNumberingLayoutInput(
+    para: ParagraphNode,
+    options?: { advance?: boolean; emitGeometry?: boolean },
+  ): NumberingLayoutInput | undefined;
+
   /**
    * Per-paragraph numbering-marker rPr cascade (ECMA-376 §17.9).
    * Mirrors `resolveNumberingMarkerRunFormatting` with the layer's
@@ -318,6 +336,12 @@ export interface FormattingContext {
    *  context has no page-graph (so the resolver was never built). */
   resolveField(entry: FieldRegistryEntry): ResolvedField | undefined;
 
+  /** Resolve one registered field into the PE2 field-layout input shape. */
+  resolveFieldLayoutInput(entry: FieldRegistryEntry): FieldLayoutInput;
+
+  /** Resolve every field/TOC registry entry into PE2 field-layout inputs. */
+  collectFieldLayoutInputs(): readonly FieldLayoutInput[];
+
   /** Resolve the effective font family for a run following
    *  ECMA-376 §17.3.2.26 precedence + theme-minor fallback. */
   resolveFontFamily(input: RunResolveInput, themeMinorFont?: string): string | undefined;
@@ -489,6 +513,13 @@ class FormattingContextImpl implements FormattingContext {
     return this.numbering.resolveDetailed(effectiveNumbering, para);
   }
 
+  resolveNumberingLayoutInput(
+    para: ParagraphNode,
+    options: { advance?: boolean; emitGeometry?: boolean } = {},
+  ): NumberingLayoutInput | undefined {
+    return toNumberingLayoutInput(this.resolveParagraphNumbering(para, options));
+  }
+
   resolveNumberingMarkerRunFormatting(
     paragraphStyleId: string | undefined,
     levelRunProperties: CanonicalRunFormatting | undefined,
@@ -599,6 +630,16 @@ class FormattingContextImpl implements FormattingContext {
     return this.field.resolve(entry);
   }
 
+  resolveFieldLayoutInput(entry: FieldRegistryEntry): FieldLayoutInput {
+    return toFieldLayoutInput(entry, this.resolveField(entry));
+  }
+
+  collectFieldLayoutInputs(): readonly FieldLayoutInput[] {
+    return collectFieldLayoutInputs(this.doc.fieldRegistry, (entry) =>
+      this.resolveField(entry),
+    );
+  }
+
   resolveFontFamily(
     input: RunResolveInput,
     themeMinorFont?: string,
@@ -635,7 +676,7 @@ class FormattingContextImpl implements FormattingContext {
     // Walk each tier in priority-ascending order, recording which tier
     // last set each field. Highest-priority writer wins — same order
     // as `resolveEffectiveRunFormatting` but with provenance tracked.
-    const properties: { [K in keyof CanonicalRunFormatting]?: RunResolvedProperty } = {};
+    const properties: { -readonly [K in keyof CanonicalRunFormatting]?: RunResolvedProperty } = {};
     const applyTier = (
       tierRecord: CanonicalRunFormatting | undefined,
       source: RunResolvedProperty["source"],
@@ -755,25 +796,25 @@ function buildDirectRunFormattingFromProjected(
   projected: ProjectedRunMarks | undefined,
 ): CanonicalRunFormatting | undefined {
   if (!projected) return undefined;
-  const direct: CanonicalRunFormatting = {};
+  const direct: Mutable<CanonicalRunFormatting> = {};
   const marks = projected.marks;
   if (marks) {
-    if (marks.includes("bold")) direct.bold = true;
-    if (marks.includes("italic")) direct.italic = true;
-    if (marks.includes("underline")) direct.underline = "single";
-    if (marks.includes("strikethrough")) direct.strikethrough = true;
-    if (marks.includes("doubleStrikethrough")) direct.doubleStrikethrough = true;
-    if (marks.includes("vanish")) direct.vanish = true;
-    if (marks.includes("allCaps")) direct.allCaps = true;
+    if (marks.includes("bold")) (direct as Mutable<typeof direct>).bold = true;
+    if (marks.includes("italic")) (direct as Mutable<typeof direct>).italic = true;
+    if (marks.includes("underline")) (direct as Mutable<typeof direct>).underline = "single";
+    if (marks.includes("strikethrough")) (direct as Mutable<typeof direct>).strikethrough = true;
+    if (marks.includes("doubleStrikethrough")) (direct as Mutable<typeof direct>).doubleStrikethrough = true;
+    if (marks.includes("vanish")) (direct as Mutable<typeof direct>).vanish = true;
+    if (marks.includes("allCaps")) (direct as Mutable<typeof direct>).allCaps = true;
     if (marks.includes("smallCaps")) direct.smallCaps = true;
   }
   const markAttrs = projected.markAttrs;
   if (markAttrs) {
     if (markAttrs.fontFamily) {
-      direct.fontFamily = markAttrs.fontFamily;
+      (direct as Mutable<typeof direct>).fontFamily = markAttrs.fontFamily;
       direct.fontFamilyAscii = markAttrs.fontFamily;
     }
-    if (typeof markAttrs.fontSize === "number") {
+    if (typeof (markAttrs as Mutable<typeof markAttrs>).fontSize === "number") {
       direct.fontSizeHalfPoints = markAttrs.fontSize;
     }
     if (markAttrs.textColor) {
@@ -789,20 +830,20 @@ function buildDirectRunFormattingFromProjected(
 function extractDirectParagraphFormatting(
   para: ParagraphNode,
 ): CanonicalParagraphFormatting {
-  const direct: CanonicalParagraphFormatting = {};
-  if (para.alignment !== undefined) direct.alignment = para.alignment;
-  if (para.spacing !== undefined) direct.spacing = para.spacing;
-  if (para.contextualSpacing !== undefined) direct.contextualSpacing = para.contextualSpacing;
-  if (para.indentation !== undefined) direct.indentation = para.indentation;
-  if (para.tabStops !== undefined) direct.tabStops = para.tabStops;
-  if (para.keepNext !== undefined) direct.keepNext = para.keepNext;
-  if (para.keepLines !== undefined) direct.keepLines = para.keepLines;
-  if (para.outlineLevel !== undefined) direct.outlineLevel = para.outlineLevel;
-  if (para.pageBreakBefore !== undefined) direct.pageBreakBefore = para.pageBreakBefore;
-  if (para.widowControl !== undefined) direct.widowControl = para.widowControl;
-  if (para.borders !== undefined) direct.borders = para.borders;
-  if (para.shading !== undefined) direct.shading = para.shading;
-  if (para.bidi !== undefined) direct.bidi = para.bidi;
+  const direct: Mutable<CanonicalParagraphFormatting> = {};
+  if (para.alignment !== undefined) (direct as Mutable<typeof direct>).alignment = para.alignment;
+  if (para.spacing !== undefined) (direct as Mutable<typeof direct>).spacing = para.spacing;
+  if (para.contextualSpacing !== undefined) (direct as Mutable<typeof direct>).contextualSpacing = para.contextualSpacing;
+  if (para.indentation !== undefined) (direct as Mutable<typeof direct>).indentation = para.indentation;
+  if (para.tabStops !== undefined) (direct as Mutable<typeof direct>).tabStops = para.tabStops;
+  if (para.keepNext !== undefined) (direct as Mutable<typeof direct>).keepNext = para.keepNext;
+  if (para.keepLines !== undefined) (direct as Mutable<typeof direct>).keepLines = para.keepLines;
+  if (para.outlineLevel !== undefined) (direct as Mutable<typeof direct>).outlineLevel = para.outlineLevel;
+  if (para.pageBreakBefore !== undefined) (direct as Mutable<typeof direct>).pageBreakBefore = para.pageBreakBefore;
+  if (para.widowControl !== undefined) (direct as Mutable<typeof direct>).widowControl = para.widowControl;
+  if (para.borders !== undefined) (direct as Mutable<typeof direct>).borders = para.borders;
+  if (para.shading !== undefined) (direct as Mutable<typeof direct>).shading = para.shading;
+  if (para.bidi !== undefined) (direct as Mutable<typeof direct>).bidi = para.bidi;
   if (para.suppressLineNumbers !== undefined) direct.suppressLineNumbers = para.suppressLineNumbers;
   return direct;
 }

package/src/runtime/formatting/index.ts

@@ -103,6 +103,24 @@ export { formatPageNumber } from "./field/page-number-format.ts";
 
 export { rebuildFieldRegistry } from "./field/registry.ts";
 
+// ── PE2 layout-ready formatting inputs ───────────────────────────────────
+export {
+  buildEffectiveLayoutFormatting,
+  buildRevisionLayoutPosture,
+  collectFieldLayoutInputs,
+  createStructuralHash,
+  normalizeNumberingMarkerSuffix,
+  toFieldLayoutInput,
+  toLayoutTabStops,
+  toNumberingLayoutInput,
+  type EffectiveLayoutFormatting,
+  type FieldLayoutInput,
+  type LayoutMarkerSuffix,
+  type LayoutTabStopInput,
+  type NumberingLayoutInput,
+  type RevisionLayoutPosture,
+} from "./layout-inputs.ts";
+
 // ── Debug projector (Slice 3) ─────────────────────────────────────────────
 export {
   buildFormattingDebugEntry,

package/src/runtime/formatting/layout-inputs.ts

@@ -0,0 +1,256 @@
+import type {
+  CanonicalParagraphFormatting,
+  CanonicalRunFormatting,
+  FieldFamily,
+  FieldRefreshStatus,
+  FieldRegistry,
+  FieldRegistryEntry,
+  TabStop,
+} from "../../model/canonical-document.ts";
+import type { ResolvedField } from "./field/resolver.ts";
+import type {
+  EffectiveParagraphFormatting,
+  EffectiveRunFormatting,
+  EffectiveTableFormatting,
+  RevisionDisplayFlags,
+} from "./formatting-types.ts";
+import type { NumberingPrefixResult } from "./numbering/prefix.ts";
+
+export type LayoutMarkerSuffix = "tab" | "space" | "none";
+
+export interface LayoutTabStopInput {
+  readonly positionTwips: number;
+  readonly align: TabStop["align"];
+  readonly leader?: TabStop["leader"];
+  readonly source: "paragraph" | "numbering" | "toc";
+}
+
+export interface NumberingLayoutInput {
+  readonly markerText: string | null;
+  readonly markerRunFormatting?: CanonicalRunFormatting;
+  readonly markerSuffix: LayoutMarkerSuffix;
+  readonly markerLaneStartTwips?: number;
+  readonly markerLaneWidthTwips?: number;
+  readonly textColumnStartTwips?: number;
+  readonly hangingTwips?: number;
+  readonly associatedTabStops: readonly LayoutTabStopInput[];
+  readonly level: number;
+  readonly format: string;
+  readonly startAt: number;
+  readonly isLegalNumbering?: boolean;
+  readonly pictureBulletMediaId?: string;
+}
+
+export interface FieldLayoutInput {
+  readonly fieldId: string;
+  readonly fieldIndex: number;
+  readonly family: FieldFamily;
+  readonly instruction: string;
+  readonly cachedText: string;
+  readonly switches?: FieldRegistryEntry["switches"];
+  readonly targetBookmark?: string;
+  readonly refreshState: FieldRefreshStatus | "unresolved";
+  readonly resolvedText?: string;
+  readonly asHyperlink?: boolean;
+  readonly tocRegionId?: string;
+  readonly tocEntryCount?: number;
+}
+
+export interface RevisionLayoutPosture {
+  readonly mode: "clean" | "simple" | "all" | "original" | "no-markup";
+  readonly affectsMeasuredText: boolean;
+  readonly hiddenRevisionIds: readonly string[];
+  readonly visibleRevisionIds: readonly string[];
+}
+
+export interface EffectiveLayoutFormatting {
+  readonly paragraph?: EffectiveParagraphFormatting;
+  readonly runs: readonly EffectiveRunFormatting[];
+  readonly table?: EffectiveTableFormatting;
+  readonly cell?: {
+    readonly paragraph: CanonicalParagraphFormatting;
+    readonly run: CanonicalRunFormatting;
+  };
+  readonly numbering?: NumberingLayoutInput;
+  readonly tabs: readonly LayoutTabStopInput[];
+  readonly compatFlags: readonly string[];
+  readonly revisionPosture?: RevisionLayoutPosture;
+  readonly structuralHash: string;
+}
+
+export function normalizeNumberingMarkerSuffix(
+  suffix: NumberingPrefixResult["suffix"] | undefined,
+): LayoutMarkerSuffix {
+  if (suffix === "tab" || suffix === "space") return suffix;
+  return "none";
+}
+
+export function toLayoutTabStops(
+  tabStops: readonly TabStop[] | undefined,
+  source: LayoutTabStopInput["source"],
+): readonly LayoutTabStopInput[] {
+  if (!tabStops || tabStops.length === 0) return [];
+  return tabStops
+    .map((tabStop) => ({
+      positionTwips: tabStop.position,
+      align: tabStop.align,
+      ...(tabStop.leader ? { leader: tabStop.leader } : {}),
+      source,
+    }))
+    .sort((a, b) => a.positionTwips - b.positionTwips);
+}
+
+export function toNumberingLayoutInput(
+  numbering: NumberingPrefixResult | null | undefined,
+): NumberingLayoutInput | undefined {
+  if (!numbering) return undefined;
+  const markerLane = numbering.geometry.markerLane;
+  const textColumn = numbering.geometry.textColumn;
+  const hangingTwips =
+    textColumn?.hanging ??
+    numbering.geometry.indentation?.hanging ??
+    (typeof numbering.geometry.indentation?.firstLine === "number" &&
+    numbering.geometry.indentation.firstLine < 0
+      ? Math.abs(numbering.geometry.indentation.firstLine)
+      : undefined);
+
+  return {
+    markerText: numbering.text,
+    ...(numbering.markerRunProperties
+      ? { markerRunFormatting: numbering.markerRunProperties }
+      : {}),
+    markerSuffix: normalizeNumberingMarkerSuffix(numbering.suffix),
+    ...(markerLane ? { markerLaneStartTwips: markerLane.start } : {}),
+    ...(markerLane ? { markerLaneWidthTwips: markerLane.width } : {}),
+    ...(textColumn ? { textColumnStartTwips: textColumn.start } : {}),
+    ...(hangingTwips !== undefined ? { hangingTwips } : {}),
+    associatedTabStops: toLayoutTabStops(numbering.geometry.tabStops, "numbering"),
+    level: numbering.level,
+    format: numbering.format,
+    startAt: numbering.startAt,
+    ...(numbering.isLegalNumbering ? { isLegalNumbering: true } : {}),
+    ...(numbering.picBulletMediaId
+      ? { pictureBulletMediaId: numbering.picBulletMediaId }
+      : {}),
+  };
+}
+
+export function toFieldLayoutInput(
+  entry: FieldRegistryEntry,
+  resolved?: ResolvedField,
+): FieldLayoutInput {
+  return {
+    fieldId: `field-${entry.fieldIndex}`,
+    fieldIndex: entry.fieldIndex,
+    family: entry.fieldFamily,
+    instruction: entry.instruction,
+    cachedText: entry.displayText,
+    ...(entry.switches ? { switches: entry.switches } : {}),
+    ...(entry.fieldTarget ? { targetBookmark: entry.fieldTarget } : {}),
+    refreshState: resolved?.refreshStatus ?? entry.refreshStatus ?? "unresolved",
+    ...(resolved?.displayText !== undefined ? { resolvedText: resolved.displayText } : {}),
+    ...(resolved?.asHyperlink ? { asHyperlink: true } : {}),
+  };
+}
+
+export function collectFieldLayoutInputs(
+  registry: FieldRegistry | undefined,
+  resolve?: (entry: FieldRegistryEntry) => ResolvedField | undefined,
+): readonly FieldLayoutInput[] {
+  if (!registry) return [];
+  const inputs: FieldLayoutInput[] = [];
+  const entries = [...registry.supported, ...registry.preserveOnly];
+  for (const entry of entries) {
+    inputs.push(toFieldLayoutInput(entry, resolve?.(entry)));
+  }
+  for (const region of registry.tocRegions ?? []) {
+    const source = registry.supported.find(
+      (entry) => entry.fieldIndex === region.sourceFieldIndex,
+    );
+    if (!source) continue;
+    inputs.push({
+      ...toFieldLayoutInput(source, resolve?.(source)),
+      fieldId: `toc-${region.tocId}`,
+      family: "TOC",
+      instruction: region.instruction.raw,
+      cachedText: region.cachedEntries.map((entry) => entry.displayText).join("\n"),
+      refreshState: region.status === "current" ? "current" : "stale",
+      tocRegionId: region.tocId,
+      tocEntryCount: region.cachedEntries.length + region.generatedEntries.length,
+    });
+  }
+  return inputs;
+}
+
+export function buildRevisionLayoutPosture(
+  mode: RevisionLayoutPosture["mode"],
+  displays: readonly RevisionDisplayFlags[] = [],
+): RevisionLayoutPosture {
+  const hiddenRevisionIds = displays
+    .filter((display) => display.hidden === true)
+    .map((display) => display.revisionId);
+  const visibleRevisionIds = displays
+    .filter((display) => display.hidden !== true)
+    .map((display) => display.revisionId);
+  return {
+    mode,
+    affectsMeasuredText: hiddenRevisionIds.length > 0,
+    hiddenRevisionIds,
+    visibleRevisionIds,
+  };
+}
+
+export function buildEffectiveLayoutFormatting(input: {
+  readonly paragraph?: EffectiveParagraphFormatting;
+  readonly runs?: readonly EffectiveRunFormatting[];
+  readonly table?: EffectiveTableFormatting;
+  readonly cell?: {
+    readonly paragraph: CanonicalParagraphFormatting;
+    readonly run: CanonicalRunFormatting;
+  };
+  readonly numbering?: NumberingLayoutInput;
+  readonly tabs?: readonly LayoutTabStopInput[];
+  readonly compatFlags?: readonly string[];
+  readonly revisionPosture?: RevisionLayoutPosture;
+}): EffectiveLayoutFormatting {
+  const withoutHash = {
+    ...(input.paragraph ? { paragraph: input.paragraph } : {}),
+    runs: input.runs ?? [],
+    ...(input.table ? { table: input.table } : {}),
+    ...(input.cell ? { cell: input.cell } : {}),
+    ...(input.numbering ? { numbering: input.numbering } : {}),
+    tabs: input.tabs ?? [],
+    compatFlags: input.compatFlags ?? [],
+    ...(input.revisionPosture ? { revisionPosture: input.revisionPosture } : {}),
+  };
+  return {
+    ...withoutHash,
+    structuralHash: createStructuralHash(withoutHash),
+  };
+}
+
+export function createStructuralHash(value: unknown): string {
+  const stable = stableStringify(value);
+  let hash = 0x811c9dc5;
+  for (let i = 0; i < stable.length; i += 1) {
+    hash ^= stable.charCodeAt(i);
+    hash = Math.imul(hash, 0x01000193);
+  }
+  return `fnv1a32:${(hash >>> 0).toString(16).padStart(8, "0")}`;
+}
+
+function stableStringify(value: unknown): string {
+  if (value === null || typeof value !== "object") {
+    return JSON.stringify(value);
+  }
+  if (Array.isArray(value)) {
+    return `[${value.map((entry) => stableStringify(entry)).join(",")}]`;
+  }
+  const record = value as Record<string, unknown>;
+  const keys = Object.keys(record)
+    .filter((key) => record[key] !== undefined)
+    .sort();
+  return `{${keys
+    .map((key) => `${JSON.stringify(key)}:${stableStringify(record[key])}`)
+    .join(",")}}`;
+}

package/src/runtime/formatting/numbering/geometry.ts

@@ -8,6 +8,7 @@ import type {
   ParagraphNode,
   ParagraphSpacing,
   TabStop,
+  Mutable,
 } from "../../../model/canonical-document.ts";
 
 export const DEFAULT_NUMBERING_START_AT = 1;
@@ -52,7 +53,7 @@ export interface ResolvedNumberingDefinitionSet {
 }
 
 export function resolveNumberingDefinitionSet(
-  catalog: NumberingCatalog,
+  catalog: Mutable<NumberingCatalog>,
   numbering: ParagraphNode["numbering"] | undefined,
   paragraph?: Pick<ParagraphNode, "spacing" | "indentation" | "tabStops">,
 ): ResolvedNumberingDefinitionSet | null {
@@ -145,7 +146,7 @@ function mergeLevelDefinition(
   };
 }
 
-function withDefaultStartAt(level: NumberingLevelDefinition): NumberingLevelDefinition {
+function withDefaultStartAt(level: Mutable<NumberingLevelDefinition>): NumberingLevelDefinition {
   return {
     ...level,
     startAt: level.startAt ?? DEFAULT_NUMBERING_START_AT,
@@ -156,7 +157,7 @@ function withDefaultStartAt(level: NumberingLevelDefinition): NumberingLevelDefi
 }
 
 function cloneLevelParagraphGeometry(
-  geometry: NumberingLevelParagraphGeometry,
+  geometry: Mutable<NumberingLevelParagraphGeometry>,
 ): NumberingLevelParagraphGeometry {
   return {
     ...(geometry.justification ? { justification: geometry.justification } : {}),
@@ -244,7 +245,7 @@ function mergeParagraphSpacing(
     return undefined;
   }
 
-  const spacing: ParagraphSpacing = {
+  const spacing: Mutable<ParagraphSpacing> = {
     ...(base ?? {}),
     ...(override ?? {}),
   };
@@ -260,24 +261,24 @@ function mergeParagraphIndentation(
     return undefined;
   }
 
-  const out: ParagraphIndentation = {};
+  const out: Mutable<ParagraphIndentation> = {};
 
   const left = override?.left ?? base?.left;
-  if (left !== undefined) out.left = left;
+  if (left !== undefined) (out as Mutable<typeof out>).left = left;
 
   const right = override?.right ?? base?.right;
-  if (right !== undefined) out.right = right;
+  if (right !== undefined) (out as Mutable<typeof out>).right = right;
 
   // ECMA-376 §17.3.1.12: firstLine and hanging are mutually exclusive on a single
   // w:ind element. When override specifies either, it wins exclusively.
   const overrideTouchesFLorH =
     override?.firstLine !== undefined || override?.hanging !== undefined;
   if (overrideTouchesFLorH) {
-    if (override?.hanging !== undefined) out.hanging = override.hanging;
-    else if (override?.firstLine !== undefined) out.firstLine = override.firstLine;
+    if (override?.hanging !== undefined) (out as Mutable<typeof out>).hanging = override.hanging;
+    else if (override?.firstLine !== undefined) (out as Mutable<typeof out>).firstLine = override.firstLine;
   } else {
-    if (base?.hanging !== undefined) out.hanging = base.hanging;
-    else if (base?.firstLine !== undefined) out.firstLine = base.firstLine;
+    if (base?.hanging !== undefined) (out as Mutable<typeof out>).hanging = base.hanging;
+    else if (base?.firstLine !== undefined) (out as Mutable<typeof out>).firstLine = base.firstLine;
   }
 
   return Object.keys(out).length > 0 ? out : undefined;
@@ -333,7 +334,7 @@ function deriveTextColumn(
   };
 }
 
-function resolveHangingWidth(indentation: ParagraphIndentation): number | undefined {
+function resolveHangingWidth(indentation: Mutable<ParagraphIndentation>): number | undefined {
   if (indentation.hanging !== undefined) {
     return indentation.hanging;
   }

package/src/runtime/formatting/style-cascade.ts

@@ -28,6 +28,7 @@ import type {
   StylesCatalog,
   TableStyleConditionalRegion,
   TableStyleDefinition,
+  Mutable,
 } from "../../model/canonical-document.ts";
 import {
   resolveCharacterStyleChain,
@@ -51,7 +52,7 @@ export function mergeParagraph(
   over: CanonicalParagraphFormatting | undefined,
 ): CanonicalParagraphFormatting | undefined {
   if (!base && !over) return undefined;
-  const merged: CanonicalParagraphFormatting = { ...(base ?? {}), ...(over ?? {}) };
+  const merged: Mutable<CanonicalParagraphFormatting> = { ...(base ?? {}), ...(over ?? {}) };
   if (base?.spacing || over?.spacing) {
     merged.spacing = { ...(base?.spacing ?? {}), ...(over?.spacing ?? {}) };
   }

package/src/runtime/formatting/table-style-resolver.ts

@@ -10,6 +10,7 @@ import type {
   TableStyleDefinition,
   TableStyleFormatting,
   TableWidth,
+  Mutable,
 } from "../../model/canonical-document.ts";
 
 export interface ResolvedTableCellStyle {
@@ -58,7 +59,7 @@ export interface ResolvedTableStyleResolution {
   }>;
 }
 
-const DEFAULT_EFFECTIVE_TABLE_LOOK: TableLook = {
+const DEFAULT_EFFECTIVE_TABLE_LOOK: Mutable<TableLook> = {
   val: "04A0",
   firstRow: true,
   lastRow: false,
@@ -80,7 +81,7 @@ const CONDITIONAL_REGION_ORDER: TableStyleConditionalRegion[] = [
 ];
 
 export function resolveTableStyleResolution(
-  table: TableNode,
+  table: Mutable<TableNode>,
   tableStyles: Record<string, TableStyleDefinition>,
 ): ResolvedTableStyleResolution {
   const resolvedStyle = table.styleId ? resolveTableStyleDefinition(table.styleId, tableStyles) : {};
@@ -266,7 +267,7 @@ function decodeTableLookMask(val: string | undefined): TableLook | undefined {
 function getActiveRowRegions(
   rowIndex: number,
   rowCount: number,
-  effectiveTblLook: TableLook,
+  effectiveTblLook: Mutable<TableLook>,
 ): TableStyleConditionalRegion[] {
   const active = new Set<TableStyleConditionalRegion>();
 
@@ -294,7 +295,7 @@ function getActiveCellRegions(
   startColumn: number,
   endColumn: number,
   columnCount: number,
-  effectiveTblLook: TableLook,
+  effectiveTblLook: Mutable<TableLook>,
 ): TableStyleConditionalRegion[] {
   const active = new Set<TableStyleConditionalRegion>(rowRegions);
 
@@ -343,7 +344,7 @@ function mergeWholeStyleFormatting(
     return undefined;
   }
 
-  const merged: TableStyleFormatting = {};
+  const merged: Mutable<TableStyleFormatting> = {};
   const table = mergeTableFormatting(base?.table, override?.table);
   const row = mergeRowFormatting(base?.row, override?.row);
   const cell = mergeCellFormatting(base?.cell, override?.cell);
@@ -429,14 +430,14 @@ function mergeBorderMap<T extends TableBorders | TableCellBorders>(
   }
 
   const sides = ["top", "left", "bottom", "right", "insideH", "insideV"] as const;
-  const merged = {} as T;
+  const merged = {} as Mutable<T>;
   for (const side of sides) {
     const spec = mergePlainObject(base?.[side], override?.[side]) as BorderSpec | undefined;
     if (spec) {
       merged[side] = spec as T[typeof side];
     }
   }
-  return Object.keys(merged).length > 0 ? merged : undefined;
+  return Object.keys(merged).length > 0 ? (merged as T) : undefined;
 }
 
 function mergePlainObject<T extends object>(base: T | undefined, override: T | undefined): T | undefined {