@beyondwork/docx-react-component 1.0.110 → 1.0.111

package/src/runtime/geometry/caret-geometry.ts

@@ -34,9 +34,14 @@
  */
 
 import type { EditorStoryTarget } from "../../api/public-types";
+import type {
+  PublicLineRunAnchor,
+  PublicTwipsRect,
+} from "../layout/public-facet.ts";
 import type {
   RenderFrame,
   RenderFrameRect,
+  RenderLine,
   RenderStoryRegion,
 } from "../render/index.ts";
 import type {
@@ -58,6 +63,9 @@ export function resolveCaretGeometry(
   if (!frame) return null;
   if (!Number.isFinite(offset)) return null;
 
+  const projectedCaret = resolveProducerCaretGeometry(frame, offset, story);
+  if (projectedCaret) return projectedCaret;
+
   const anchorRect = frame.anchorIndex.byRuntimeOffset(offset, story);
   if (!anchorRect) return null;
 
@@ -113,12 +121,7 @@ export function resolveSelectionRects(
   if (lo === hi) {
     const caret = resolveCaretGeometry(frame, lo, range.story);
     if (!caret) return [];
-    // Caret rect position for a collapsed range is an exact anchor-index
-    // read. The placeholder-grade metadata on `CaretGeometry` (direction,
-    // baseline) applies to the caret as a whole, not to the rect's
-    // position, so make the rect precision explicit for downstream
-    // compositor consumers.
-    return [{ ...caret.rect, precision: "exact" }];
+    return [{ ...caret.rect, precision: caret.rect.precision ?? "exact" }];
   }
 
   const lineRects = resolveLineSelectionRects(frame, lo, hi, range.story);
@@ -178,7 +181,10 @@ function resolveLineSelectionRects(
               : blockFrom +
                 Math.floor((span * (i + 1)) / Math.max(1, lineCount));
           if (lineTo <= from || lineFrom >= to) continue;
-          rects.push(toGeometryRect(line.frame, "within-tolerance"));
+          rects.push(
+            resolveProducerSelectionRect(line, lineFrom, lineTo, from, to) ??
+              toGeometryRect(line.frame, "within-tolerance"),
+          );
         }
       }
     }
@@ -186,6 +192,212 @@ function resolveLineSelectionRects(
   return rects;
 }
 
+function resolveProducerCaretGeometry(
+  frame: RenderFrame,
+  offset: number,
+  story?: EditorStoryTarget,
+): CaretGeometry | null {
+  const located = findProducerLineForOffset(frame, offset, story);
+  if (!located) return null;
+  const { line, lineFrom, lineTo } = located;
+  const lineRectTwips = producerLineRectTwips(line);
+  if (!lineRectTwips) return null;
+  const contentRectTwips = producerLineContentRectTwips(line) ?? lineRectTwips;
+  const direction = producerLineDirection(line);
+  const span = Math.max(1, lineTo - lineFrom);
+  const ratio = clamp((offset - lineFrom) / span, 0, 1);
+  const inlineRatio = direction === "rtl" ? 1 - ratio : ratio;
+  const caretXTwips =
+    contentRectTwips.xTwips + contentRectTwips.widthTwips * inlineRatio;
+  const caretFrame = projectLineTwipsRect(line, lineRectTwips, {
+    xTwips: caretXTwips,
+    yTwips: lineRectTwips.yTwips,
+    widthTwips: 0,
+    heightTwips: lineRectTwips.heightTwips,
+  });
+  if (!caretFrame) return null;
+  const baseline =
+    line.line.baselinePageYTwips !== undefined
+      ? projectPageYToLineOffsetPx(
+          line,
+          lineRectTwips,
+          line.line.baselinePageYTwips,
+        )
+      : producerRunBaselinePageYTwips(line) !== undefined
+        ? projectPageYToLineOffsetPx(
+            line,
+            lineRectTwips,
+            producerRunBaselinePageYTwips(line)!,
+          )
+        : resolveBaselinePx(caretFrame);
+  return {
+    rect: {
+      ...toGeometryRect(caretFrame, "within-tolerance"),
+      widthPx: 0,
+    },
+    baseline,
+    height: caretFrame.heightPx,
+    direction,
+    precision: "within-tolerance",
+  };
+}
+
+function findProducerLineForOffset(
+  frame: RenderFrame,
+  offset: number,
+  story?: EditorStoryTarget,
+):
+  | {
+      line: RenderLine;
+      lineFrom: number;
+      lineTo: number;
+    }
+  | null {
+  if (!Array.isArray(frame.pages)) return null;
+  for (const page of frame.pages) {
+    for (const region of collectRegions(page.regions)) {
+      if (!storyMatches(region.storyTarget, story)) continue;
+      for (const block of region.blocks) {
+        const blockFrom = block.fragment.from;
+        const blockTo = block.fragment.to;
+        if (offset < blockFrom || offset > blockTo) continue;
+        if (block.lines.length === 0) continue;
+        const span = Math.max(1, blockTo - blockFrom);
+        const lineCount = block.lines.length;
+        for (let i = 0; i < lineCount; i += 1) {
+          const lineFrom =
+            blockFrom + Math.floor((span * i) / Math.max(1, lineCount));
+          const lineTo =
+            i === lineCount - 1
+              ? blockTo
+              : blockFrom +
+                Math.floor((span * (i + 1)) / Math.max(1, lineCount));
+          const contains =
+            i === lineCount - 1
+              ? offset >= lineFrom && offset <= lineTo
+              : offset >= lineFrom && offset < lineTo;
+          if (!contains) continue;
+          const line = block.lines[i]!;
+          if (!producerLineRectTwips(line)) continue;
+          return { line, lineFrom, lineTo };
+        }
+      }
+    }
+  }
+  return null;
+}
+
+function resolveProducerSelectionRect(
+  line: RenderLine,
+  lineFrom: number,
+  lineTo: number,
+  from: number,
+  to: number,
+): GeometryRect | null {
+  const lineRectTwips = producerLineRectTwips(line);
+  if (!lineRectTwips) return null;
+  const contentRectTwips = producerLineContentRectTwips(line) ?? lineRectTwips;
+  const span = Math.max(1, lineTo - lineFrom);
+  const startRatio = clamp((Math.max(from, lineFrom) - lineFrom) / span, 0, 1);
+  const endRatio = clamp((Math.min(to, lineTo) - lineFrom) / span, 0, 1);
+  if (endRatio <= startRatio) return null;
+  const direction = producerLineDirection(line);
+  const leftRatio = direction === "rtl" ? 1 - endRatio : startRatio;
+  const rightRatio = direction === "rtl" ? 1 - startRatio : endRatio;
+  const leftTwips =
+    contentRectTwips.xTwips + contentRectTwips.widthTwips * leftRatio;
+  const rightTwips =
+    contentRectTwips.xTwips + contentRectTwips.widthTwips * rightRatio;
+  const frameRect = projectLineTwipsRect(line, lineRectTwips, {
+    xTwips: leftTwips,
+    yTwips: contentRectTwips.yTwips,
+    widthTwips: Math.max(0, rightTwips - leftTwips),
+    heightTwips: contentRectTwips.heightTwips,
+  });
+  return frameRect ? toGeometryRect(frameRect, "within-tolerance") : null;
+}
+
+function producerLineRectTwips(line: RenderLine): PublicTwipsRect | undefined {
+  return line.line.rectTwips ?? line.line.runAnchors?.[0]?.lineRectTwips;
+}
+
+function producerLineContentRectTwips(
+  line: RenderLine,
+): PublicTwipsRect | undefined {
+  const anchors = line.line.runAnchors ?? [];
+  if (anchors.length === 0) return undefined;
+  return unionRunRectTwips(anchors);
+}
+
+function producerLineDirection(line: RenderLine): "ltr" | "rtl" {
+  return line.line.direction ?? line.line.runAnchors?.[0]?.direction ?? "ltr";
+}
+
+function producerRunBaselinePageYTwips(
+  line: RenderLine,
+): number | undefined {
+  return line.line.runAnchors?.[0]?.baselinePageYTwips;
+}
+
+function unionRunRectTwips(
+  anchors: readonly PublicLineRunAnchor[],
+): PublicTwipsRect | undefined {
+  let left = Number.POSITIVE_INFINITY;
+  let top = Number.POSITIVE_INFINITY;
+  let right = Number.NEGATIVE_INFINITY;
+  let bottom = Number.NEGATIVE_INFINITY;
+  for (const anchor of anchors) {
+    const rect = anchor.runRectTwips;
+    left = Math.min(left, rect.xTwips);
+    top = Math.min(top, rect.yTwips);
+    right = Math.max(right, rect.xTwips + rect.widthTwips);
+    bottom = Math.max(bottom, rect.yTwips + rect.heightTwips);
+  }
+  if (!Number.isFinite(left) || !Number.isFinite(top)) return undefined;
+  return {
+    xTwips: left,
+    yTwips: top,
+    widthTwips: Math.max(0, right - left),
+    heightTwips: Math.max(0, bottom - top),
+  };
+}
+
+function projectLineTwipsRect(
+  line: RenderLine,
+  lineRectTwips: PublicTwipsRect,
+  rect: PublicTwipsRect,
+): RenderFrameRect | null {
+  if (lineRectTwips.widthTwips <= 0 || lineRectTwips.heightTwips <= 0) {
+    return null;
+  }
+  const scaleX = line.frame.widthPx / lineRectTwips.widthTwips;
+  const scaleY = line.frame.heightPx / lineRectTwips.heightTwips;
+  return {
+    leftPx: line.frame.leftPx + (rect.xTwips - lineRectTwips.xTwips) * scaleX,
+    topPx: line.frame.topPx + (rect.yTwips - lineRectTwips.yTwips) * scaleY,
+    widthPx: rect.widthTwips * scaleX,
+    heightPx: rect.heightTwips * scaleY,
+  };
+}
+
+function projectPageYToLineOffsetPx(
+  line: RenderLine,
+  lineRectTwips: PublicTwipsRect,
+  pageYTwips: number,
+): number {
+  if (lineRectTwips.heightTwips <= 0) return resolveBaselinePx(line.frame);
+  const scaleY = line.frame.heightPx / lineRectTwips.heightTwips;
+  return clamp(
+    (pageYTwips - lineRectTwips.yTwips) * scaleY,
+    0,
+    line.frame.heightPx,
+  );
+}
+
+function clamp(value: number, min: number, max: number): number {
+  return Math.min(Math.max(value, min), max);
+}
+
 function collectRegions(
   regions: RenderFrame["pages"][number]["regions"],
 ): readonly RenderStoryRegion[] {

package/src/runtime/geometry/geometry-index.ts

@@ -27,6 +27,7 @@ import {
   type CanonicalTableCellLayoutInput,
   type CanonicalTableRowLayoutInput,
 } from "../../model/canonical-layout-inputs.ts";
+import type { PublicTwipsRect } from "../layout/public-facet.ts";
 import type {
   RenderFrame,
   RenderFrameRect,
@@ -1309,25 +1310,32 @@ function appendPageLocalObjectHandleEntries(input: {
       story.kind === "header" ? page.regions.header?.frame : page.regions.footer?.frame;
     if (!regionFrame) continue;
     for (const object of story.anchoredObjects) {
-      const objectFrame = pageLocalObjectFrame(
-        regionFrame,
-        object.extentTwips,
-        pxPerTwip,
+      const objectFrame = object.anchorRectTwips
+        ? pageLocalObjectAnchorFrame(page, object.anchorRectTwips)
+        : pageLocalObjectFrame(regionFrame, object.extentTwips, pxPerTwip);
+      const entryPrecision: GeometryPrecision = object.anchorRectTwips
+        ? "within-tolerance"
+        : "heuristic";
+      const entryStatus: GeometryRehydrationStatus = object.anchorRectTwips
+        ? "realized"
+        : "requires-rehydration";
+      const handleRects = buildObjectHandleRectsFromRect(
+        objectFrame,
+        entryPrecision,
       );
-      const handleRects = buildObjectHandleRectsFromRect(objectFrame, "heuristic");
       const sourceIdentity: GeometrySourceIdentity = {
         storyKey: story.storyKey,
         objectKey: object.objectId,
         objectKind: object.sourceType,
         editPosture: object.preserveOnly ? "preserve-only" : "editable",
-        joinKind: "block-scoped",
+        joinKind: object.anchorRectTwips ? "direct" : "block-scoped",
       };
       const existing = entries.get(object.objectId);
       if (existing) {
         appendUnique(existing.pageIds, page.page.pageId);
         existing.rects.push(...handleRects);
         appendDivergenceIds(existing, divergenceIdsByObjectId.get(object.objectId));
-        if (existing.precision !== "heuristic") {
+        if (existing.precision !== "heuristic" && entryPrecision === "heuristic") {
           existing.precision = "heuristic";
           existing.status = "requires-rehydration";
           existing.sourceIdentity = sourceIdentity;
@@ -1338,16 +1346,33 @@ function appendPageLocalObjectHandleEntries(input: {
         objectId: object.objectId,
         pageIds: [page.page.pageId],
         rects: [...handleRects],
-        status: "requires-rehydration",
-        precision: "heuristic",
+        status: entryStatus,
+        precision: entryPrecision,
         ...mutableLayoutDivergenceIds(divergenceIdsByObjectId.get(object.objectId)),
         sourceIdentity,
       });
-      recordPrecision(precision, "heuristic");
+      recordPrecision(precision, entryPrecision);
     }
   }
 }
 
+function pageLocalObjectAnchorFrame(
+  page: RenderPage,
+  rect: PublicTwipsRect,
+): RenderFrameRect {
+  const pageWidthTwips = page.page.layout.pageWidth;
+  const pageHeightTwips = page.page.layout.pageHeight;
+  const scaleX = pageWidthTwips > 0 ? page.frame.widthPx / pageWidthTwips : 1;
+  const scaleY =
+    pageHeightTwips > 0 ? page.frame.heightPx / pageHeightTwips : scaleX;
+  return {
+    leftPx: page.frame.leftPx + rect.xTwips * scaleX,
+    topPx: page.frame.topPx + rect.yTwips * scaleY,
+    widthPx: rect.widthTwips * scaleX,
+    heightPx: rect.heightTwips * scaleY,
+  };
+}
+
 function pageLocalObjectFrame(
   regionFrame: RenderFrameRect,
   extentTwips:

package/src/runtime/geometry/object-handles.ts

@@ -26,7 +26,12 @@
  *   index 8 — rotate anchor (20 px above the top-center handle)
  */
 
-import type { RenderFrame, RenderFrameRect } from "../render/index.ts";
+import type { PublicTwipsRect } from "../layout/public-facet.ts";
+import type {
+  RenderFrame,
+  RenderFrameRect,
+  RenderPage,
+} from "../render/index.ts";
 import type { GeometryPrecision, GeometryRect } from "./geometry-types.ts";
 
 const ROTATE_HANDLE_OFFSET_PX = 20;
@@ -36,6 +41,10 @@ export function resolveObjectHandles(
   objectId: string,
 ): readonly GeometryRect[] {
   if (!frame) return [];
+  const pageLocalBBox = resolvePageLocalObjectFrame(frame, objectId);
+  if (pageLocalBBox) {
+    return buildObjectHandleRectsFromRect(pageLocalBBox, "within-tolerance");
+  }
   const bbox = frame.anchorIndex.byObjectId(objectId);
   if (!bbox) return [];
   return buildObjectHandleRectsFromRect(bbox);
@@ -78,3 +87,35 @@ export function buildObjectHandleRectsFromRect(
     point(midX, topPx - ROTATE_HANDLE_OFFSET_PX), // 8 rotate
   ];
 }
+
+function resolvePageLocalObjectFrame(
+  frame: RenderFrame,
+  objectId: string,
+): RenderFrameRect | null {
+  if (!Array.isArray(frame.pages)) return null;
+  for (const page of frame.pages) {
+    for (const story of page.page.frame?.pageLocalStories ?? []) {
+      for (const object of story.anchoredObjects) {
+        if (object.objectId !== objectId || !object.anchorRectTwips) continue;
+        return projectPageTwipsRect(page, object.anchorRectTwips);
+      }
+    }
+  }
+  return null;
+}
+
+function projectPageTwipsRect(
+  page: RenderPage,
+  rect: PublicTwipsRect,
+): RenderFrameRect {
+  const pageWidthTwips = page.page.layout.pageWidth;
+  const pageHeightTwips = page.page.layout.pageHeight;
+  const scaleX = pageWidthTwips > 0 ? page.frame.widthPx / pageWidthTwips : 1;
+  const scaleY = pageHeightTwips > 0 ? page.frame.heightPx / pageHeightTwips : scaleX;
+  return {
+    leftPx: page.frame.leftPx + rect.xTwips * scaleX,
+    topPx: page.frame.topPx + rect.yTwips * scaleY,
+    widthPx: rect.widthTwips * scaleX,
+    heightPx: rect.heightTwips * scaleY,
+  };
+}

package/src/runtime/layout/index.ts

@@ -181,11 +181,14 @@ export {
   type PublicRegionKind,
   type PublicBlockFragment,
   type PublicLineBox,
+  type PublicLineRunAnchor,
   type PublicNoteAllocation,
   type PublicPageAnchor,
   type PublicPageFrame,
   type PublicPageLocalStoryInstance,
+  type PublicPagePaginationTelemetry,
   type PublicPageSpan,
+  type PublicPaginationTelemetry,
   type PublicSectionNode,
   type PublicResolvedPageStories,
   type PublicResolvedStoryField,

package/src/runtime/layout/inert-layout-facet.ts

@@ -10,6 +10,7 @@ import type {
   LayoutFacetEvent,
   PublicFieldDirtinessReport,
   PublicMeasurementFidelity,
+  PublicPaginationTelemetry,
   WordReviewEditorLayoutFacet,
 } from "./public-facet.ts";
 import { MARGIN_PRESET_CATALOG } from "./margin-preset-catalog.ts";
@@ -20,6 +21,17 @@ export function createInertLayoutFacet(): WordReviewEditorLayoutFacet {
     families: [],
     revision: 0,
   };
+  const emptyPaginationTelemetry: PublicPaginationTelemetry = {
+    revision: 0,
+    pageCount: 0,
+    materializedPageCount: 0,
+    unpaginatedPageCount: 0,
+    bodyFragmentCount: 0,
+    bodyBlockReferenceCount: 0,
+    averageBodyFragmentsPerMaterializedPage: 0,
+    averageBodyBlockReferencesPerMaterializedPage: 0,
+    pages: [],
+  };
   const fidelity: PublicMeasurementFidelity = "empirical";
   return {
     getPageCount: () => 0,
@@ -39,6 +51,7 @@ export function createInertLayoutFacet(): WordReviewEditorLayoutFacet {
     getStoryBlocksForRegion: () => [],
     getDocumentEndnoteBlocks: () => [],
     getFragmentsForPage: () => [],
+    getPaginationTelemetry: () => emptyPaginationTelemetry,
     getPageFormatCatalog: () => PAGE_FORMAT_CATALOG,
     getActivePageFormat: () => null,
     getMarginPresetCatalog: () => MARGIN_PRESET_CATALOG,

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

@@ -693,6 +693,7 @@ export function createLayoutEngine(
       pages,
       bodyFragmentsByPageIndex,
       pageStack.fragmentMeasurementsByPageIndex,
+      mainSurface,
     );
     // P8.1b — merge per-note fragments (regionKind: "footnote-area") into the
     // main fragments map so buildPageGraph sees them alongside body fragments.
@@ -881,6 +882,7 @@ export function createLayoutEngine(
       freshSnapshotsToRebuild,
       freshBodyFragmentsByPageIndex,
       freshResult.fragmentMeasurementsByPageIndex,
+      mainSurface,
     );
     // P8.1b — merge per-note fragments into the fresh fragments map.
     const freshFragmentsByPageIndex = new Map(freshBodyFragmentsByPageIndex);

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

@@ -1248,8 +1248,34 @@
  *   to v88. Cache envelopes from v87 invalidate because page graph
  *   materialization state, cache-key semantics, geometry projections, and
  *   surface preview shapes can change.
+ *
+ *  89 — Ship-side rollup: pe2 commit covering L04 pagination telemetry read
+ *   model — `WordReviewEditorLayoutFacet` now exposes
+ *   `getPaginationTelemetry()`, with per-page materialization, body-fragment
+ *   counts, body block-reference counts, line-box counts, and
+ *   materialized-page averages. Pagination output and cached graph payloads
+ *   are unchanged; cache envelopes from v88 invalidate because the public
+ *   layout facet interface grew a method used by viewport-window consumers.
+ *   The pe2 history-block bumped to v83 in isolation; ship-preview's rollup
+ *   advances to v89.
+ *
+ *  90 — Ship-side rollup: pe2 commit 2fcc15a10 ("feat(04): publish precision
+ *   producer layout facts") landed L04 precision producer facts — runtime
+ *   line boxes now carry page-local rects, baseline page coordinates,
+ *   paragraph direction, and per-run layout-estimate anchors with first/last
+ *   glyph bounds. Page-local anchored-object ledgers can carry
+ *   `anchorRectTwips` when canonical anchor metadata gives L04 a source/frame
+ *   placement. Pe2 commits a22c2e4ab ("feat(05): consume l04 producer
+ *   geometry facts") + 6e71ee2ad ("feat(05): publish frame-pixel adjacent
+ *   geometry") additionally brushed `src/runtime/geometry/**`, and pe2
+ *   commits 883e46bb7 + 8519112d0 ("fix(11): suppress table-internal page
+ *   chrome / anchors") brushed `src/runtime/layout/page-graph.ts` without
+ *   separate pe2 bumps. The pe2 history-block bumped to v84 in isolation;
+ *   ship-preview's rollup advances to v90. Pagination output is unchanged,
+ *   but public graph/read-model semantics grew for L05 exact caret/object
+ *   projection consumers and for L11 page-anchor suppression in tables.
  */
-export const LAYOUT_ENGINE_VERSION = 88 as const;
+export const LAYOUT_ENGINE_VERSION = 90 as const;
 
 /**
  * Serialization schema version for the LayCache envelope and cached payload
@@ -1290,5 +1316,9 @@ export const LAYOUT_ENGINE_VERSION = 88 as const;
  *       `numberingRows[]` for all numbered paragraphs represented by the
  *       fragment, including table/SDT-nested paragraphs. Pagination output is
  *       unchanged, but cached graph payload shape grows.
+ *   7 — L04 precision producer graph payload: line boxes carry page-local
+ *       rect/baseline/direction/run-anchor facts, and page-local anchored
+ *       object ledgers can carry source-anchor `anchorRectTwips`. Pagination
+ *       output is unchanged, but cached graph payload shape grows.
  */
-export const LAYCACHE_SCHEMA_VERSION = 6 as const;
+export const LAYCACHE_SCHEMA_VERSION = 7 as const;

package/src/runtime/layout/layout-facet-types.ts

@@ -42,11 +42,14 @@ export type {
   PublicRegionKind,
   PublicBlockFragment,
   PublicLineBox,
+  PublicLineRunAnchor,
   PublicNoteAllocation,
   PublicPageAnchor,
   PublicPageFrame,
   PublicPageLocalStoryInstance,
+  PublicPagePaginationTelemetry,
   PublicPageSpan,
+  PublicPaginationTelemetry,
   PublicSectionNode,
   PublicResolvedPageStories,
   PublicResolvedStoryField,

package/src/runtime/layout/page-graph.ts

@@ -77,6 +77,7 @@ export type {
   RuntimeFragmentLayoutObject,
   RuntimeBlockFragment,
   RuntimeLineBox,
+  RuntimeLineRunAnchor,
   RuntimeNoteAllocation,
   RuntimePageAnchor,
 } from "../../model/layout/page-graph-types.ts";
@@ -566,6 +567,7 @@ function buildPageLocalStoryInstance(
         kind: target.kind,
         variant: target.variant,
         relationshipId: target.relationshipId,
+        region,
       })
     : { objects: [], divergences: [] };
   const signature = buildPageLocalStorySignature({
@@ -621,6 +623,10 @@ function buildPageLocalStorySignature(input: {
         object.display,
         object.extentTwips?.widthTwips ?? "",
         object.extentTwips?.heightTwips ?? "",
+        object.anchorRectTwips?.xTwips ?? "",
+        object.anchorRectTwips?.yTwips ?? "",
+        object.anchorRectTwips?.widthTwips ?? "",
+        object.anchorRectTwips?.heightTwips ?? "",
         object.relationshipIds?.join(",") ?? "",
         object.mediaIds?.join(",") ?? "",
         object.wrapMode ?? "",
@@ -732,6 +738,7 @@ interface StoryObjectContext {
   kind: "header" | "footer";
   variant: RuntimePageLocalStoryInstance["variant"];
   relationshipId: string;
+  region?: RuntimePageRegion;
 }
 
 function collectStoryAnchoredObjects(
@@ -836,13 +843,20 @@ function collectStoryAnchoredObjects(
         const preserveHint = getDrawingFramePreserveHint(inline);
         const relationshipIds = collectDrawingRelationshipIds(inline);
         const display = inline.anchor.display;
+        const extentTwips = extentTwipsFromEmu(
+          inline.anchor.extent.widthEmu,
+          inline.anchor.extent.heightEmu,
+        );
         pushObject({
           objectId: getDrawingFrameObjectId(inline, context.storyKey, ordinal),
           sourceType: "drawing-frame",
           display,
-          extentTwips: extentTwipsFromEmu(
-            inline.anchor.extent.widthEmu,
-            inline.anchor.extent.heightEmu,
+          extentTwips,
+          anchorRectTwips: resolveObjectAnchorRectTwips(
+            context.region,
+            extentTwips,
+            inline.anchor.positionH,
+            inline.anchor.positionV,
           ),
           ...(relationshipIds.length > 0 ? { relationshipIds } : {}),
           ...(inline.content.type === "picture" && inline.content.mediaId
@@ -863,15 +877,22 @@ function collectStoryAnchoredObjects(
       case "wordart":
       case "vml_shape": {
         const preserveHint = inline.preserveOnlyObject;
+        const extentTwips = preserveHint?.extentEmu
+          ? extentTwipsFromEmu(
+              preserveHint.extentEmu.widthEmu,
+              preserveHint.extentEmu.heightEmu,
+            )
+          : undefined;
         pushObject({
           objectId: getPreserveOnlyObjectId(inline, context.storyKey, ordinal),
           sourceType: sourceTypeForInlineObject(inline.type),
           display: preserveHint?.display ?? "unknown",
-          ...(preserveHint?.extentEmu
+          ...(extentTwips
             ? {
-                extentTwips: extentTwipsFromEmu(
-                  preserveHint.extentEmu.widthEmu,
-                  preserveHint.extentEmu.heightEmu,
+                extentTwips,
+                anchorRectTwips: resolveObjectAnchorRectTwips(
+                  context.region,
+                  extentTwips,
                 ),
               }
             : {}),
@@ -986,6 +1007,59 @@ function extentTwipsFromEmu(
   };
 }
 
+function resolveObjectAnchorRectTwips(
+  region: RuntimePageRegion | undefined,
+  extentTwips: RuntimeStoryAnchoredObject["extentTwips"],
+  positionH?: { relativeFrom: string; align?: string; offset?: number },
+  positionV?: { relativeFrom: string; align?: string; offset?: number },
+): RuntimeTwipsRect | undefined {
+  if (!region?.rectTwips || !extentTwips) return undefined;
+  const regionRect = region.rectTwips;
+  const widthTwips = Math.max(0, extentTwips.widthTwips);
+  const heightTwips = Math.max(0, extentTwips.heightTwips);
+  return rect(
+    resolveAxisTwips(
+      regionRect.xTwips,
+      regionRect.widthTwips,
+      widthTwips,
+      positionH?.align,
+      positionH?.offset,
+    ),
+    resolveAxisTwips(
+      regionRect.yTwips,
+      regionRect.heightTwips,
+      heightTwips,
+      positionV?.align,
+      positionV?.offset,
+    ),
+    widthTwips,
+    heightTwips,
+  );
+}
+
+function resolveAxisTwips(
+  originTwips: number,
+  spanTwips: number,
+  objectSpanTwips: number,
+  align?: string,
+  offsetEmu?: number,
+): number {
+  if (offsetEmu !== undefined) {
+    return originTwips + Math.round(offsetEmu / EMUS_PER_TWIP);
+  }
+  switch (align) {
+    case "center":
+      return originTwips + Math.round((spanTwips - objectSpanTwips) / 2);
+    case "right":
+    case "bottom":
+      return originTwips + Math.max(0, spanTwips - objectSpanTwips);
+    case "left":
+    case "top":
+    default:
+      return originTwips;
+  }
+}
+
 function resolvePageInstanceFieldDisplayText(
   family: string,
   cachedDisplayText: string,