@beyondwork/docx-react-component 1.0.59 → 1.0.61

package/src/runtime/footnote-resolver.ts

@@ -1,6 +1,7 @@
 import type {
   BlockNode,
   CanonicalDocument,
+  DocumentSettings,
   EndnoteProperties,
   FootnoteCollection,
   FootnoteProperties,
@@ -15,14 +16,13 @@ export interface FootnoteResolver {
   getEndnoteCount(): number;
   /**
    * Resolve the effective `<w:footnotePr>` for a given section. Returns the
-   * section's typed properties when present, or `undefined` when the section
-   * has no override (callers should fall back to Word defaults). File-level
-   * defaults from `settings.xml` are not yet wired in — that's a later slice.
+   * section's typed properties when present, otherwise the settings-level
+   * default from `settings.xml` when available.
    */
   getFootnoteProperties(sectionIndex?: number): FootnoteProperties | undefined;
   /**
    * Resolve the effective `<w:endnotePr>` for a given section. Same semantics
-   * as `getFootnoteProperties` but reads `endnotePr` from the section list.
+   * as `getFootnoteProperties` but reads `endnotePr`.
    */
   getEndnoteProperties(sectionIndex?: number): EndnoteProperties | undefined;
   /**
@@ -70,6 +70,7 @@ export function createFootnoteResolver(
   collection: FootnoteCollection,
   sections?: readonly SectionProperties[],
   document?: CanonicalDocument,
+  settings?: DocumentSettings,
 ): FootnoteResolver {
   return {
     getContinuationSeparatorContent(kind) {
@@ -87,12 +88,20 @@ export function createFootnoteResolver(
       return Object.keys(collection.endnotes).length;
     },
     getFootnoteProperties(sectionIndex) {
-      if (sectionIndex === undefined || !sections) return undefined;
-      return sections[sectionIndex]?.footnotePr;
+      return resolveFootnoteLikeProperties(
+        sectionIndex,
+        sections,
+        settings?.footnotePr,
+        "footnotePr",
+      );
     },
     getEndnoteProperties(sectionIndex) {
-      if (sectionIndex === undefined || !sections) return undefined;
-      return sections[sectionIndex]?.endnotePr;
+      return resolveFootnoteLikeProperties(
+        sectionIndex,
+        sections,
+        settings?.endnotePr,
+        "endnotePr",
+      );
     },
     getEndnotesForSection(sectionIndex) {
       if (!sections || !document) return EMPTY_READONLY_STRING_ARRAY;
@@ -107,6 +116,21 @@ export function createFootnoteResolver(
 
 const EMPTY_READONLY_STRING_ARRAY: readonly string[] = Object.freeze([]);
 
+function resolveFootnoteLikeProperties<T extends FootnoteProperties | EndnoteProperties>(
+  sectionIndex: number | undefined,
+  sections: readonly SectionProperties[] | undefined,
+  defaultProps: T | undefined,
+  key: "footnotePr" | "endnotePr",
+): T | undefined {
+  if (sectionIndex !== undefined && sections) {
+    const sectionProps = sections[sectionIndex]?.[key];
+    if (sectionProps) {
+      return sectionProps as T;
+    }
+  }
+  return defaultProps;
+}
+
 /**
  * Walk the document's top-level block children and collect endnote IDs
  * referenced from the block range belonging to `targetSectionIndex`.

package/src/runtime/layout/layout-engine-version.ts

@@ -215,8 +215,14 @@
  *       CO3.8 `isStaleParaInd` heuristic with a broader `isDegenerateParaInd`
  *       guard (hanging===left → use level geometry) that fixes the APS
  *       Supply paragraph pattern. Cache envelopes from v22 invalidate.
+ *  24 — Merge from `main` after the non-SDT closeout. The layout measurement
+ *       and resolved-formatting stack changed in `measurement-backend-canvas`,
+ *       `measurement-backend-empirical`, `paginated-layout-engine`,
+ *       `resolved-formatting-document`, and `resolved-formatting-state`.
+ *       Persisted prerender/layout caches must invalidate so geometry derived
+ *       under v23 is never reused against the merged layout pipeline.
  */
-export const LAYOUT_ENGINE_VERSION = 23 as const;
+export const LAYOUT_ENGINE_VERSION = 24 as const;
 
 /**
  * Serialization schema version for the LayCache payload (the cache envelope

package/src/runtime/layout/measurement-backend-canvas.ts

@@ -188,7 +188,7 @@ export function createCanvasBackend(
         case "tab": {
           // Advance to the next tab stop (in twips).
           const avgCharWidth = formatting.averageCharWidthTwips;
-          const defaultTabInterval = 720;
+          const defaultTabInterval = formatting.defaultTabInterval;
           const position = currentLineWidth + formatting.indentLeft;
           let nextTab = Math.ceil((position + 1) / defaultTabInterval) * defaultTabInterval;
           for (const tab of formatting.tabStops) {

package/src/runtime/layout/measurement-backend-empirical.ts

@@ -187,7 +187,7 @@ function resolveTabAdvance(
   currentChars: number,
 ): number {
   const avgCharWidth = formatting.averageCharWidthTwips;
-  const defaultTabInterval = 720;
+  const defaultTabInterval = formatting.defaultTabInterval;
   const currentPosition = currentChars * avgCharWidth + formatting.indentLeft;
 
   if (formatting.tabStops.length === 0) {

package/src/runtime/layout/paginated-layout-engine.ts

@@ -197,6 +197,7 @@ export function buildPageStackWithSplits(
   mainSurface: EditorSurfaceSnapshot,
   measurementProvider?: LayoutMeasurementProvider,
 ): PageStackResultWithSplits {
+  const defaultTabInterval = document.subParts?.settings?.defaultTabStop ?? 720;
   const pages: DocumentPageSnapshot[] = [];
   const splitsByBlock = new Map<string, ParagraphLineSlice[]>();
   // P8.1b — aggregate note allocations and fragments across all sections,
@@ -270,6 +271,7 @@ export function buildPageStackWithSplits(
       document.subParts?.footnoteCollection,
       measurementProvider,
       cache,
+      defaultTabInterval,
     );
     const paginated = paginatedResult.pages;
 
@@ -795,6 +797,7 @@ function measureBlockHeight(
   columnWidth: number,
   measurementProvider?: LayoutMeasurementProvider,
   cache?: MeasurementCache,
+  defaultTabInterval = 720,
 ): number {
   if (!block) return 0;
 
@@ -804,7 +807,7 @@ function measureBlockHeight(
   const compute = (): number => {
     switch (block.kind) {
       case "paragraph": {
-        const formatting = resolveBlockFormatting(block);
+        const formatting = resolveBlockFormatting(block, defaultTabInterval);
         if (formatting) {
           // Provider path: sum per-line heights so canvas-backed measurements
           // that emit variable line heights (mixed inline font sizes, etc.)
@@ -837,14 +840,26 @@ function measureBlockHeight(
         return estimateBlockHeight(block, columnWidth);
       }
       case "table":
-        return measureTableHeight(block, columnWidth, measurementProvider, cache);
+        return measureTableHeight(
+          block,
+          columnWidth,
+          measurementProvider,
+          cache,
+          defaultTabInterval,
+        );
       case "sdt_block":
         return Math.max(
           MIN_BLOCK_HEIGHT_TWIPS,
           block.children.reduce(
             (total, child) =>
               total +
-              measureBlockHeight(child, columnWidth, measurementProvider, cache),
+              measureBlockHeight(
+                child,
+                columnWidth,
+                measurementProvider,
+                cache,
+                defaultTabInterval,
+              ),
             0,
           ),
         );
@@ -875,6 +890,7 @@ function measureTableHeight(
   columnWidth: number,
   measurementProvider?: LayoutMeasurementProvider,
   cache?: MeasurementCache,
+  defaultTabInterval = 720,
 ): number {
   const TABLE_ROW_PADDING_TWIPS = 120;
   let totalHeight = 0;
@@ -920,6 +936,7 @@ function measureTableHeight(
           cellWidth,
           measurementProvider,
           cache,
+          defaultTabInterval,
         );
       }
       contentHeight = Math.max(contentHeight, cellContentHeight + TABLE_ROW_PADDING_TWIPS);
@@ -1091,8 +1108,7 @@ function resolveTabAdvance(
   avgCharWidth: number,
   columnWidth: number,
 ): number {
-  // Default tab stops every 720 twips (0.5 inch)
-  const defaultTabInterval = 720;
+  const defaultTabInterval = formatting.defaultTabInterval;
   const currentPosition = currentChars * avgCharWidth + formatting.indentLeft;
 
   if (formatting.tabStops.length === 0) {
@@ -1156,6 +1172,7 @@ function paginateSectionBlocks(
   footnotes: FootnoteCollection | undefined,
   measurementProvider?: LayoutMeasurementProvider,
   cache?: MeasurementCache,
+  defaultTabInterval = 720,
 ): Omit<DocumentPageSnapshot, "pageIndex">[] {
   return paginateSectionBlocksWithSplits(
     section,
@@ -1164,6 +1181,7 @@ function paginateSectionBlocks(
     footnotes,
     measurementProvider,
     cache,
+    defaultTabInterval,
   ).pages;
 }
 
@@ -1174,6 +1192,7 @@ export function paginateSectionBlocksWithSplits(
   footnotes: FootnoteCollection | undefined,
   measurementProvider?: LayoutMeasurementProvider,
   cache?: MeasurementCache,
+  defaultTabInterval = 720,
 ): SectionPaginationResult {
   if (blocks.length === 0) {
     return {
@@ -1329,18 +1348,32 @@ export function paginateSectionBlocksWithSplits(
       const columnWidth =
         columnMetrics[Math.min(columnIndex, columnMetrics.length - 1)]?.width ??
         getUsableColumnWidth(layout);
-      const baseHeight = measureBlockHeight(block, columnWidth, measurementProvider, cache);
+      const baseHeight = measureBlockHeight(
+        block,
+        columnWidth,
+        measurementProvider,
+        cache,
+        defaultTabInterval,
+      );
 
       // keepNext: this paragraph must stay with the next one on the same page
       const keepWithNextHeight =
         block.kind === "paragraph" && block.keepNext
           ? baseHeight +
-            measureBlockHeight(blocks[index + 1], columnWidth, measurementProvider, cache)
+            measureBlockHeight(
+              blocks[index + 1],
+              columnWidth,
+              measurementProvider,
+              cache,
+              defaultTabInterval,
+            )
           : baseHeight;
 
       // keepLines: the entire paragraph must fit on one page.
       // If it doesn't fit and there's already content on this page, break before it.
-      const formatting = block.kind === "paragraph" ? resolveBlockFormatting(block) : null;
+      const formatting = block.kind === "paragraph"
+        ? resolveBlockFormatting(block, defaultTabInterval)
+        : null;
       const keepLinesActive = formatting?.keepLines ?? false;
 
       const noteHeight = estimateFootnoteReservation(block, footnotes, columnWidth, reservedNotes);

package/src/runtime/layout/resolved-formatting-document.ts

@@ -122,13 +122,14 @@ export function buildResolvedFormattingState(
   const usedFamilies = new Set<string>();
 
   const theme = document.subParts?.resolvedTheme;
-  collectFormatting(mainSurface.blocks, paragraphs, runs, usedFamilies, theme);
+  const tabs = buildTabSettings(document.subParts?.settings);
+  collectFormatting(mainSurface.blocks, paragraphs, runs, usedFamilies, theme, tabs.defaultTabInterval);
 
   return {
     paragraphs,
     runs,
     fonts: buildFontCatalog(usedFamilies, document.subParts),
-    tabs: buildTabSettings(),
+    tabs,
     numbering: buildNumberingGeometry(document.subParts),
     settings: buildDocumentSettings(document.subParts?.settings),
     revision: revisionCounter,
@@ -141,11 +142,12 @@ function collectFormatting(
   runs: Map<RunId, ResolvedRunFormatting>,
   usedFamilies: Set<string>,
   theme: ResolvedTheme | undefined,
+  defaultTabInterval: number,
 ): void {
   for (const block of blocks) {
     switch (block.kind) {
       case "paragraph": {
-        const formatting = resolveBlockFormatting(block);
+        const formatting = resolveBlockFormatting(block, defaultTabInterval);
         if (formatting) {
           paragraphs.set(block.blockId, formatting);
         }
@@ -163,12 +165,12 @@ function collectFormatting(
       case "table":
         for (const row of block.rows) {
           for (const cell of row.cells) {
-            collectFormatting(cell.content, paragraphs, runs, usedFamilies, theme);
+            collectFormatting(cell.content, paragraphs, runs, usedFamilies, theme, defaultTabInterval);
           }
         }
         break;
       case "sdt_block":
-        collectFormatting(block.children, paragraphs, runs, usedFamilies, theme);
+        collectFormatting(block.children, paragraphs, runs, usedFamilies, theme, defaultTabInterval);
         break;
     }
   }
@@ -244,11 +246,11 @@ function buildFontCatalog(
   };
 }
 
-function buildTabSettings(): ResolvedTabSettings {
-  // Current DocumentSettings model does not carry `defaultTabStop`.
-  // Word's default is 720 twips (0.5"); retain that until settings exposes one.
+function buildTabSettings(
+  settings: DocumentSettings | undefined,
+): ResolvedTabSettings {
   return {
-    defaultTabInterval: 720,
+    defaultTabInterval: settings?.defaultTabStop ?? 720,
   };
 }
 

package/src/runtime/layout/resolved-formatting-state.ts

@@ -100,6 +100,8 @@ export interface ResolvedParagraphFormatting {
   averageCharWidthTwips: number;
   /** Effective tab stops sorted by position. */
   tabStops: LayoutTabStop[];
+  /** Document default tab interval in twips. */
+  defaultTabInterval: number;
   /** Keep with next paragraph. */
   keepNext: boolean;
   /** Keep all lines of this paragraph on the same page. */
@@ -140,6 +142,7 @@ export interface ResolvedTableRowFormatting {
 
 export function resolveBlockFormatting(
   block: SurfaceBlockSnapshot,
+  defaultTabInterval = 720,
 ): ResolvedParagraphFormatting | null {
   if (block.kind !== "paragraph") {
     return null;
@@ -163,6 +166,7 @@ export function resolveBlockFormatting(
     fontSizeHalfPoints: fontInfo.fontSizeHalfPoints,
     averageCharWidthTwips: fontInfo.avgCharWidth,
     tabStops: resolveTabStops(block),
+    defaultTabInterval,
     keepNext: Boolean(block.keepNext ?? block.resolvedParagraphFormatting?.keepNext),
     keepLines: Boolean(block.keepLines ?? block.resolvedParagraphFormatting?.keepLines),
     pageBreakBefore: Boolean(block.pageBreakBefore ?? block.resolvedParagraphFormatting?.pageBreakBefore),

package/src/runtime/numbering-prefix.ts

@@ -144,8 +144,10 @@ function advanceSequence(
   currentLevel: number,
   levelDefinitions: Map<number, NumberingLevelDefinition>,
 ): void {
-  if (state.lastLevel !== null && currentLevel <= state.lastLevel) {
-    state.counters.length = currentLevel + 1;
+  for (let level = currentLevel + 1; level < state.counters.length; level += 1) {
+    if (shouldResetDeeperLevel(level, currentLevel, levelDefinitions)) {
+      state.counters[level] = undefined;
+    }
   }
 
   // Initialize any skipped parent levels so legal outline %1.%2.%3. patterns
@@ -163,6 +165,28 @@ function advanceSequence(
   state.lastLevel = currentLevel;
 }
 
+function shouldResetDeeperLevel(
+  level: number,
+  triggeringLevel: number,
+  levelDefinitions: Map<number, NumberingLevelDefinition>,
+): boolean {
+  const restartAfterLevel = levelDefinitions.get(level)?.restartAfterLevel;
+  if (restartAfterLevel === 0) {
+    return false;
+  }
+
+  const defaultRestartLevel = level - 1;
+  const restartIndex = restartAfterLevel !== undefined
+    ? restartAfterLevel - 1
+    : defaultRestartLevel;
+
+  if (restartIndex >= level) {
+    return triggeringLevel <= defaultRestartLevel;
+  }
+
+  return triggeringLevel <= restartIndex;
+}
+
 function getLevelStartAt(
   level: number,
   levelDefinitions: Map<number, NumberingLevelDefinition>,

package/src/runtime/query-scopes.ts

@@ -1,4 +1,5 @@
 import type {
+  EditorAnchorProjection,
   EditorStoryTarget,
   ScopeQueryFilter,
   ScopeQueryResult,
@@ -31,10 +32,97 @@ function storyTargetsEqual(a: EditorStoryTarget, b: EditorStoryTarget): boolean
 
 const MAIN_STORY: EditorStoryTarget = { kind: "main" };
 
+function workflowAnchorsEqual(
+  left: EditorAnchorProjection,
+  right: EditorAnchorProjection,
+): boolean {
+  if (left.kind !== right.kind) return false;
+  switch (left.kind) {
+    case "range":
+      return (
+        right.kind === "range" &&
+        left.from === right.from &&
+        left.to === right.to &&
+        left.assoc.start === right.assoc.start &&
+        left.assoc.end === right.assoc.end
+      );
+    case "node":
+      return right.kind === "node" && left.at === right.at;
+    case "detached":
+      return (
+        right.kind === "detached" &&
+        left.reason === right.reason &&
+        left.lastKnownRange.from === right.lastKnownRange.from &&
+        left.lastKnownRange.to === right.lastKnownRange.to
+      );
+    default:
+      return false;
+  }
+}
+
+function buildScopeIdCounts(overlay: WorkflowOverlay): Map<string, number> {
+  const counts = new Map<string, number>();
+  for (const scope of overlay.scopes) {
+    counts.set(scope.scopeId, (counts.get(scope.scopeId) ?? 0) + 1);
+  }
+  return counts;
+}
+
+function normalizeScopeAnchor(
+  scope: WorkflowScope,
+  scopeIdCounts: ReadonlyMap<string, number>,
+  locations: ReadonlyMap<string, { startPos?: number; endPos?: number }>,
+  markerBackedScopeIds: ReadonlySet<string>,
+): WorkflowScope {
+  if ((scopeIdCounts.get(scope.scopeId) ?? 0) !== 1) {
+    return scope;
+  }
+
+  const location = locations.get(scope.scopeId);
+  let nextAnchor: EditorAnchorProjection | null = null;
+  if (
+    location &&
+    location.startPos !== undefined &&
+    location.endPos !== undefined
+  ) {
+    nextAnchor = {
+      kind: "range",
+      from: Math.min(location.startPos, location.endPos),
+      to: Math.max(location.startPos, location.endPos),
+      assoc: { start: -1, end: 1 },
+    };
+  } else if (markerBackedScopeIds.has(scope.scopeId)) {
+    const lastKnownRange =
+      scope.anchor.kind === "range"
+        ? { from: scope.anchor.from, to: scope.anchor.to }
+        : scope.anchor.kind === "node"
+          ? { from: scope.anchor.at, to: scope.anchor.at }
+          : scope.anchor.lastKnownRange;
+    nextAnchor = {
+      kind: "detached",
+      reason:
+        location && (location.startPos !== undefined || location.endPos !== undefined)
+          ? "deleted"
+          : "invalidatedByStructureChange",
+      lastKnownRange,
+    };
+  } else {
+    return scope;
+  }
+
+  return workflowAnchorsEqual(scope.anchor, nextAnchor)
+    ? scope
+    : {
+        ...scope,
+        anchor: nextAnchor,
+      };
+}
+
 export interface ScopeQueryInputs {
   readonly overlay: WorkflowOverlay | null;
   readonly entries: readonly WorkflowMetadataEntry[];
   readonly document: Pick<CanonicalDocument, "content"> | CanonicalDocumentEnvelope;
+  readonly markerBackedScopeIds?: ReadonlySet<string>;
 }
 
 /**
@@ -53,9 +141,17 @@ export function projectScopeQueryResults(
   if (!overlay) return [];
   const includeHidden = options.includeHidden === true;
   const includeInvisible = options.includeInvisible === true;
+  const scopeIdCounts = buildScopeIdCounts(overlay);
+  const locations = collectScopeLocations(inputs.document);
+  const markerBackedScopeIds = inputs.markerBackedScopeIds ?? new Set<string>();
 
   const scopesById = new Map<string, WorkflowScope>();
-  for (const scope of overlay.scopes) scopesById.set(scope.scopeId, scope);
+  for (const scope of overlay.scopes) {
+    scopesById.set(
+      scope.scopeId,
+      normalizeScopeAnchor(scope, scopeIdCounts, locations, markerBackedScopeIds),
+    );
+  }
 
   const entriesByScope = new Map<string, WorkflowMetadataEntry[]>();
   for (const entry of inputs.entries) {
@@ -128,6 +224,8 @@ export function queryScopes(
   }
 
   const locations = collectScopeLocations(inputs.document);
+  const scopeIdCounts = buildScopeIdCounts(overlay);
+  const markerBackedScopeIds = inputs.markerBackedScopeIds ?? new Set<string>();
 
   const candidates: Array<{ scope: WorkflowScope; startPos: number }> = [];
   for (const scope of overlay.scopes) {
@@ -162,7 +260,10 @@ export function queryScopes(
     const loc = locations.get(scope.scopeId);
     const startPos =
       loc?.startPos ?? loc?.endPos ?? Number.POSITIVE_INFINITY;
-    candidates.push({ scope, startPos });
+    candidates.push({
+      scope: normalizeScopeAnchor(scope, scopeIdCounts, locations, markerBackedScopeIds),
+      startPos,
+    });
   }
 
   candidates.sort((a, b) => {