@beyondwork/docx-react-component 1.0.109 → 1.0.111

package/src/runtime/geometry/adjacent-geometry-intake.ts

@@ -20,20 +20,116 @@ export interface AdjacentGeometryTwipsRect {
   readonly heightTwips?: number;
 }
 
+export interface AdjacentGeometryFramePxRect {
+  readonly leftPx: number;
+  readonly topPx: number;
+  readonly widthPx: number;
+  readonly heightPx: number;
+  readonly coordinateSpace: "frame-px";
+}
+
+export interface AdjacentGeometryFramePxPoint {
+  readonly xPx: number;
+  readonly yPx: number;
+  readonly coordinateSpace: "frame-px";
+}
+
 export interface AdjacentGeometryPageSpan {
   readonly startPage?: number | null;
   readonly endPage?: number | null;
 }
 
+export type AdjacentGeometryPageIndexStatus =
+  | "matches-runtime"
+  | "differs-from-runtime"
+  | "runtime-missing"
+  | "word-page-missing";
+
+export interface AdjacentGeometryL04FrameProjection {
+  readonly pageIndex?: number;
+  readonly pageId?: string;
+  readonly frameId?: string;
+  readonly frameCompleteness?: string;
+  readonly physicalBoundsTwips?: AdjacentGeometryTwipsRect;
+  readonly framePixelScale?: AdjacentGeometryFramePixelScale;
+  readonly markerLane?: AdjacentGeometryTwipsRect;
+  readonly textColumn?: AdjacentGeometryTwipsRect;
+  readonly fieldStartAnchorTwips?: {
+    readonly x?: number;
+    readonly y?: number;
+  };
+  readonly fieldEndAnchorTwips?: {
+    readonly x?: number;
+    readonly y?: number;
+  };
+  readonly coordinateSpace: "l04-frame-twips";
+  readonly precision: "word-page-local-calibration";
+  readonly status:
+    | "projected-l04-frame"
+    | "page-index-differs-from-runtime"
+    | "runtime-page-missing"
+    | "word-page-missing"
+    | "missing-l04-page-frame"
+    | "missing-word-page-local-geometry";
+}
+
+export interface AdjacentGeometryFramePixelScale {
+  readonly source: "runtime-render-frame-page-rect";
+  readonly pageIndex: number;
+  readonly pageId?: string;
+  readonly frameId?: string;
+  readonly renderFrameRevision?: number;
+  readonly renderPageFrame: AdjacentGeometryFramePxRect;
+  readonly physicalBoundsTwips: AdjacentGeometryTwipsRect;
+  readonly pxPerTwipX: number;
+  readonly pxPerTwipY: number;
+  readonly zoomPxPerTwip?: number;
+}
+
+export interface AdjacentGeometryFramePixelProjection {
+  readonly pageIndex?: number;
+  readonly pageId?: string;
+  readonly frameId?: string;
+  readonly scale?: AdjacentGeometryFramePixelScale;
+  readonly markerLane?: AdjacentGeometryFramePxRect;
+  readonly textColumn?: AdjacentGeometryFramePxRect;
+  readonly fieldStartAnchorPx?: AdjacentGeometryFramePxPoint;
+  readonly fieldEndAnchorPx?: AdjacentGeometryFramePxPoint;
+  readonly fieldResultRangePx?: AdjacentGeometryFramePxRect;
+  readonly coordinateSpace: "frame-px";
+  readonly precision: "word-page-local-calibration";
+  readonly status:
+    | "projected-frame-pixels"
+    | "awaiting-l04-frame-projection"
+    | "missing-frame-pixel-scale"
+    | "missing-l04-frame-rect"
+    | "missing-l04-field-anchor";
+}
+
+interface AdjacentGeometryPageFrame {
+  readonly pageId?: string;
+  readonly pageIndex: number;
+  readonly frameId?: string;
+  readonly completeness?: string;
+  readonly physicalBoundsTwips?: AdjacentGeometryTwipsRect;
+  readonly framePixelScale?: AdjacentGeometryFramePixelScale;
+}
+
 export interface AdjacentGeometryPageLocalNumberingGeometry {
   readonly wordPage?: number;
+  readonly normalizedWordPageIndex?: number;
   readonly runtimePageIndex?: number;
+  readonly pageIndexStatus: AdjacentGeometryPageIndexStatus;
   readonly runtimeFragmentId?: string;
   readonly markerLane?: AdjacentGeometryTwipsRect;
   readonly textColumn?: AdjacentGeometryTwipsRect;
+  readonly l04FrameProjection: AdjacentGeometryL04FrameProjection;
+  readonly framePixelProjection: AdjacentGeometryFramePixelProjection;
+  readonly compositorReady: boolean;
   readonly coordinateSpace: "word-page-twips";
   readonly precision: "word-page-local-calibration";
   readonly normalizationStatus:
+    | "l04-frame-twips-projected"
     | "word-page-local-awaiting-l04-frame-projection"
     | "missing-word-page-local-lane";
 }
@@ -56,9 +152,13 @@ export interface AdjacentGeometryPageLocalFieldGeometry {
     readonly x?: number;
     readonly y?: number;
   };
+  readonly l04FrameProjection: AdjacentGeometryL04FrameProjection;
+  readonly framePixelProjection: AdjacentGeometryFramePixelProjection;
+  readonly compositorReady: boolean;
   readonly coordinateSpace: "word-page-twips";
   readonly precision: "word-page-local-calibration";
   readonly normalizationStatus:
+    | "l04-frame-twips-projected"
     | "word-page-local-awaiting-l04-frame-projection"
     | "missing-word-placement";
 }
@@ -69,6 +169,9 @@ export interface AdjacentGeometryNumberingRowSummary {
   readonly canonicalBlockId?: string;
   readonly runtimeBlockId?: string;
   readonly runtimeFragmentId?: string;
+  readonly runtimeNumberingId?: string;
+  readonly layoutObjectId?: string;
+  readonly runtimeJoinSource: "adjacent-live" | "l04-numbering-readback";
   readonly runtimePageIndex?: number;
   readonly sourceParagraphPath?: string;
   readonly canonicalNumberingInstanceId?: string;
@@ -94,6 +197,7 @@ export interface AdjacentGeometryNumberingRowSummary {
     readonly heightTwips?: number;
   };
   readonly pageLocalGeometry: AdjacentGeometryPageLocalNumberingGeometry;
+  readonly compositorReady: boolean;
   readonly rangeMappingMethod?: string;
   readonly coordinateSpace: "screen-px";
   readonly precision: "screen-space-approximate";
@@ -116,6 +220,7 @@ export interface AdjacentGeometryFieldRegionRowSummary {
     readonly endPage?: number | null;
   };
   readonly pageLocalGeometry: AdjacentGeometryPageLocalFieldGeometry;
+  readonly compositorReady: boolean;
   readonly instructionFamily?: string;
   readonly resultLineRectCount: number;
   readonly wordPlacement?: {
@@ -141,6 +246,7 @@ export interface AdjacentGeometryDocumentSummary {
   readonly docId: string;
   readonly numberingRows: number;
   readonly numberingRowsWithRuntimeFragment: number;
+  readonly numberingRowsJoinedFromL04Readback: number;
   readonly numberingParagraphLineRects: number;
   readonly numberingTextOnlyLineRects: number;
   readonly numberingRawMarkerRectRows: number;
@@ -150,6 +256,13 @@ export interface AdjacentGeometryDocumentSummary {
   readonly numberingRowsWithUiaCapture: number;
   readonly numberingRowsWithPageLocalMarkerLane: number;
   readonly numberingRowsWithPageLocalTextColumn: number;
+  readonly numberingRowsWithRuntimePageMatch: number;
+  readonly numberingUiaRowsWithRuntimePageMatch: number;
+  readonly numberingRowsWithL04FrameProjection: number;
+  readonly numberingUiaRowsWithL04FrameProjection: number;
+  readonly numberingRowsWithFramePixelProjection: number;
+  readonly numberingUiaRowsWithFramePixelProjection: number;
+  readonly numberingCompositorReadyRows: number;
   readonly fieldRegionRows: number;
   readonly fieldRegionRowsWithRuntimeId: number;
   readonly fieldRegionResultLineRects: number;
@@ -157,10 +270,15 @@ export interface AdjacentGeometryDocumentSummary {
   readonly fieldRegionRowsWithWordPlacement: number;
   readonly fieldRegionRowsWithRuntimePageMatch: number;
   readonly fieldRegionRowsWithRuntimePageContainment: number;
+  readonly fieldRegionRowsWithL04FrameProjection: number;
+  readonly fieldRegionUiaRowsWithL04FrameProjection: number;
+  readonly fieldRegionRowsWithFramePixelProjection: number;
+  readonly fieldRegionUiaRowsWithFramePixelProjection: number;
+  readonly fieldRegionCompositorReadyRows: number;
 }
 
 export interface AdjacentGeometryIntakeSummary {
-  readonly schemaVersion: "layer-05-adjacent-geometry-intake/v0";
+  readonly schemaVersion: "layer-05-adjacent-geometry-intake/v2";
   readonly generatedAtUtc: string;
   readonly sourceRuns: {
     readonly adjacentLiveWordJoins: string;
@@ -170,6 +288,7 @@ export interface AdjacentGeometryIntakeSummary {
   readonly totals: {
     readonly numberingRows: number;
     readonly numberingRowsWithRuntimeFragment: number;
+    readonly numberingRowsJoinedFromL04Readback: number;
     readonly numberingParagraphLineRects: number;
     readonly numberingTextOnlyLineRects: number;
     readonly numberingRawMarkerRectRows: number;
@@ -179,6 +298,13 @@ export interface AdjacentGeometryIntakeSummary {
     readonly numberingRowsWithUiaCapture: number;
     readonly numberingRowsWithPageLocalMarkerLane: number;
     readonly numberingRowsWithPageLocalTextColumn: number;
+    readonly numberingRowsWithRuntimePageMatch: number;
+    readonly numberingUiaRowsWithRuntimePageMatch: number;
+    readonly numberingRowsWithL04FrameProjection: number;
+    readonly numberingUiaRowsWithL04FrameProjection: number;
+    readonly numberingRowsWithFramePixelProjection: number;
+    readonly numberingUiaRowsWithFramePixelProjection: number;
+    readonly numberingCompositorReadyRows: number;
     readonly fieldRegionRows: number;
     readonly fieldRegionRowsWithRuntimeId: number;
     readonly fieldRegionResultLineRects: number;
@@ -186,6 +312,11 @@ export interface AdjacentGeometryIntakeSummary {
     readonly fieldRegionRowsWithWordPlacement: number;
     readonly fieldRegionRowsWithRuntimePageMatch: number;
     readonly fieldRegionRowsWithRuntimePageContainment: number;
+    readonly fieldRegionRowsWithL04FrameProjection: number;
+    readonly fieldRegionUiaRowsWithL04FrameProjection: number;
+    readonly fieldRegionRowsWithFramePixelProjection: number;
+    readonly fieldRegionUiaRowsWithFramePixelProjection: number;
+    readonly fieldRegionCompositorReadyRows: number;
   };
   readonly routing: {
     readonly routedTo: "L05";
@@ -198,7 +329,12 @@ export interface AdjacentGeometryIntakeSummary {
     readonly coordinateSpace: "word-page-twips";
     readonly precision: "word-page-local-calibration";
     readonly requiredUpstreamFact: "L04 frame-to-pixel projection";
-    readonly compositorReady: false;
+    readonly l04FrameProjectionCoordinateSpace: "l04-frame-twips";
+    readonly l04FrameProjectionPrecision: "word-page-local-calibration";
+    readonly framePixelCoordinateSpace: "frame-px";
+    readonly framePixelPrecision: "word-page-local-calibration";
+    readonly scaleSource: "runtime-render-frame-page-rect";
+    readonly compositorReady: boolean;
   };
   readonly documents: readonly AdjacentGeometryDocumentSummary[];
   readonly numberingRows: readonly AdjacentGeometryNumberingRowSummary[];
@@ -210,16 +346,23 @@ export function summarizeAdjacentGeometryIntake(input: {
   readonly sourceRuns: AdjacentGeometryIntakeSummary["sourceRuns"];
   readonly numberingArtifact: unknown;
   readonly numberingLiveJoinArtifacts: readonly unknown[];
+  readonly numberingRuntimeReadbackArtifacts?: readonly unknown[];
   readonly fieldRegionRuntimeReadback: unknown;
   readonly fieldRegionLiveJoinArtifacts: readonly unknown[];
 }): AdjacentGeometryIntakeSummary {
+  const pageFramesByDocId = collectPageFramesByDocId(
+    input.numberingRuntimeReadbackArtifacts ?? [],
+  );
   const numberingRows = summarizeNumberingRows(
     input.numberingArtifact,
     input.numberingLiveJoinArtifacts,
+    input.numberingRuntimeReadbackArtifacts ?? [],
+    pageFramesByDocId,
   );
   const fieldRegionRows = summarizeFieldRegionRows(
     input.fieldRegionRuntimeReadback,
     input.fieldRegionLiveJoinArtifacts,
+    pageFramesByDocId,
   );
   const docIds = [
     ...new Set([
@@ -228,7 +371,7 @@ export function summarizeAdjacentGeometryIntake(input: {
     ]),
   ].sort();
   return {
-    schemaVersion: "layer-05-adjacent-geometry-intake/v0",
+    schemaVersion: "layer-05-adjacent-geometry-intake/v2",
     generatedAtUtc: input.generatedAtUtc,
     sourceRuns: input.sourceRuns,
     totals: {
@@ -236,6 +379,9 @@ export function summarizeAdjacentGeometryIntake(input: {
       numberingRowsWithRuntimeFragment: numberingRows.filter(
         (row) => row.runtimeFragmentId !== undefined,
       ).length,
+      numberingRowsJoinedFromL04Readback: numberingRows.filter(
+        (row) => row.runtimeJoinSource === "l04-numbering-readback",
+      ).length,
       numberingParagraphLineRects: sum(
         numberingRows,
         (row) => row.paragraphLineRectCount,
@@ -258,6 +404,28 @@ export function summarizeAdjacentGeometryIntake(input: {
       numberingRowsWithPageLocalTextColumn: numberingRows.filter(
         (row) => row.pageLocalGeometry.textColumn !== undefined,
       ).length,
+      numberingRowsWithRuntimePageMatch: numberingRows.filter(
+        (row) => row.pageLocalGeometry.pageIndexStatus === "matches-runtime",
+      ).length,
+      numberingUiaRowsWithRuntimePageMatch: numberingRows.filter(
+        (row) =>
+          hasNumberingUiaCapture(row) &&
+          row.pageLocalGeometry.pageIndexStatus === "matches-runtime",
+      ).length,
+      numberingRowsWithL04FrameProjection: numberingRows.filter(hasL04FrameProjection)
+        .length,
+      numberingUiaRowsWithL04FrameProjection: numberingRows.filter(
+        (row) => hasNumberingUiaCapture(row) && hasL04FrameProjection(row),
+      ).length,
+      numberingRowsWithFramePixelProjection: numberingRows.filter(
+        hasFramePixelProjection,
+      ).length,
+      numberingUiaRowsWithFramePixelProjection: numberingRows.filter(
+        (row) => hasNumberingUiaCapture(row) && hasFramePixelProjection(row),
+      ).length,
+      numberingCompositorReadyRows: numberingRows.filter(
+        (row) => row.pageLocalGeometry.compositorReady,
+      ).length,
       fieldRegionRows: fieldRegionRows.length,
       fieldRegionRowsWithRuntimeId: fieldRegionRows.filter(
         (row) => row.runtimeFieldRegionId !== undefined,
@@ -278,6 +446,21 @@ export function summarizeAdjacentGeometryIntake(input: {
       fieldRegionRowsWithRuntimePageContainment: fieldRegionRows.filter(
         (row) => row.pageLocalGeometry.pageSpanStatus === "contained-in-runtime",
       ).length,
+      fieldRegionRowsWithL04FrameProjection: fieldRegionRows.filter(
+        hasL04FrameProjection,
+      ).length,
+      fieldRegionUiaRowsWithL04FrameProjection: fieldRegionRows.filter(
+        (row) => row.resultLineRectCount > 0 && hasL04FrameProjection(row),
+      ).length,
+      fieldRegionRowsWithFramePixelProjection: fieldRegionRows.filter(
+        hasFramePixelProjection,
+      ).length,
+      fieldRegionUiaRowsWithFramePixelProjection: fieldRegionRows.filter(
+        (row) => row.resultLineRectCount > 0 && hasFramePixelProjection(row),
+      ).length,
+      fieldRegionCompositorReadyRows: fieldRegionRows.filter(
+        (row) => row.pageLocalGeometry.compositorReady,
+      ).length,
     },
     routing: {
       routedTo: "L05",
@@ -290,7 +473,14 @@ export function summarizeAdjacentGeometryIntake(input: {
       coordinateSpace: "word-page-twips",
       precision: "word-page-local-calibration",
       requiredUpstreamFact: "L04 frame-to-pixel projection",
-      compositorReady: false,
+      l04FrameProjectionCoordinateSpace: "l04-frame-twips",
+      l04FrameProjectionPrecision: "word-page-local-calibration",
+      framePixelCoordinateSpace: "frame-px",
+      framePixelPrecision: "word-page-local-calibration",
+      scaleSource: "runtime-render-frame-page-rect",
+      compositorReady:
+        numberingRows.some((row) => row.pageLocalGeometry.compositorReady) ||
+        fieldRegionRows.some((row) => row.pageLocalGeometry.compositorReady),
     },
     documents: docIds.map((docId) =>
       summarizeDocument(
@@ -307,6 +497,8 @@ export function summarizeAdjacentGeometryIntake(input: {
 function summarizeNumberingRows(
   artifact: unknown,
   liveJoinArtifacts: readonly unknown[],
+  runtimeReadbackArtifacts: readonly unknown[],
+  pageFramesByDocId: ReadonlyMap<string, ReadonlyMap<number, AdjacentGeometryPageFrame>>,
 ): readonly AdjacentGeometryNumberingRowSummary[] {
   const uiaRowsByKey = new Map<string, Record<string, unknown>>();
   for (const raw of array(record(artifact).rows)) {
@@ -322,8 +514,16 @@ function summarizeNumberingRows(
   const liveRows = liveJoinArtifacts.flatMap((artifact) =>
     array(record(artifact).numberingRows).map(record),
   );
+  const runtimeReadbacksByKey = collectNumberingRuntimeReadbacks(
+    runtimeReadbackArtifacts,
+  );
   const rows = liveRows.length > 0
-    ? liveRows.filter((row) => stringValue(row.runtimeFragmentId) !== undefined)
+    ? liveRows.filter((row) => {
+        if (stringValue(row.runtimeFragmentId) !== undefined) return true;
+        return (
+          numberingRuntimeReadbackForRow(row, runtimeReadbacksByKey) !== undefined
+        );
+      })
     : array(record(artifact).rows).map(record);
 
   return rows
@@ -338,6 +538,10 @@ function summarizeNumberingRows(
       const uiaRow =
         uiaRowsByKey.get(numberingKey(docId, wordParagraphOrdinalGlobal) ?? "") ??
         {};
+      const runtimeReadback = numberingRuntimeReadbackForRow(
+        row,
+        runtimeReadbacksByKey,
+      );
       const uiaTargetJoin = record(uiaRow.targetJoin);
       const paragraphLineRects = chooseRects(
         uiaRow.paragraphLineRects,
@@ -350,28 +554,63 @@ function summarizeNumberingRows(
       const rawMarkerRects = chooseRawArray(uiaRow.markerRects, row.markerRects);
       const markerRects = chooseRects(uiaRow.markerRects, row.markerRects);
       const markerLane =
-        normalizeTwipsRect(row.markerLane) ?? normalizeTwipsRect(uiaTargetJoin.markerLane);
+        normalizeTwipsRect(row.markerLane) ??
+        normalizeTwipsRect(runtimeReadback?.markerLane) ??
+        normalizeTwipsRect(uiaTargetJoin.markerLane);
       const textColumn =
-        normalizeTwipsRect(row.textColumn) ?? normalizeTwipsRect(uiaTargetJoin.textColumn);
+        normalizeTwipsRect(row.textColumn) ??
+        normalizeTwipsRect(runtimeReadback?.textColumn) ??
+        normalizeTwipsRect(uiaTargetJoin.textColumn);
       const runtimeFragmentId =
-        stringValue(row.runtimeFragmentId) ?? stringValue(uiaTargetJoin.runtimeFragmentId);
+        stringValue(row.runtimeFragmentId) ??
+        stringValue(runtimeReadback?.runtimeFragmentId) ??
+        stringValue(uiaTargetJoin.runtimeFragmentId);
+      const runtimeJoinSource: AdjacentGeometryNumberingRowSummary["runtimeJoinSource"] =
+        stringValue(row.runtimeFragmentId) !== undefined
+          ? "adjacent-live"
+          : "l04-numbering-readback";
       const runtimePageIndex =
-        numberValue(row.runtimePageIndex) ?? numberValue(uiaTargetJoin.runtimePageIndex);
+        numberValue(row.runtimePageIndex) ??
+        numberValue(runtimeReadback?.pageIndex) ??
+        numberValue(uiaTargetJoin.runtimePageIndex);
       const wordStartPage =
         numberValue(record(row.pageSpan).startPage) ??
         numberValue(row.wordStartPage) ??
         numberValue(uiaRow.wordStartPage);
+      const normalizedWordPageIndex =
+        wordStartPage === undefined ? undefined : wordStartPage - 1;
+      const pageIndexStatus = classifyPageIndex(
+        normalizedWordPageIndex,
+        runtimePageIndex,
+      );
+      const l04FrameProjection = projectNumberingToL04Frame({
+        docId,
+        normalizedWordPageIndex,
+        runtimePageIndex,
+        pageIndexStatus,
+        markerLane,
+        textColumn,
+        pageFramesByDocId,
+      });
+      const framePixelProjection = projectNumberingToFramePixels(l04FrameProjection);
       const pageLocalGeometry: AdjacentGeometryPageLocalNumberingGeometry = {
         wordPage: wordStartPage,
+        normalizedWordPageIndex,
         runtimePageIndex,
+        pageIndexStatus,
         runtimeFragmentId,
         markerLane,
         textColumn,
+        l04FrameProjection,
+        framePixelProjection,
+        compositorReady: framePixelProjection.status === "projected-frame-pixels",
         coordinateSpace: "word-page-twips",
         precision: "word-page-local-calibration",
         normalizationStatus:
-          markerLane || textColumn
-            ? "word-page-local-awaiting-l04-frame-projection"
+          l04FrameProjection.status === "projected-l04-frame"
+            ? "l04-frame-twips-projected"
+            : markerLane || textColumn
+              ? "word-page-local-awaiting-l04-frame-projection"
             : "missing-word-page-local-lane",
       };
       return {
@@ -380,11 +619,20 @@ function summarizeNumberingRows(
         canonicalBlockId:
           stringValue(row.canonicalBlockId) ?? stringValue(uiaTargetJoin.canonicalBlockId),
         runtimeBlockId:
-          stringValue(row.runtimeBlockId) ?? stringValue(uiaTargetJoin.runtimeBlockId),
+          stringValue(row.runtimeBlockId) ??
+          stringValue(runtimeReadback?.numberingSourceBlockId) ??
+          stringValue(runtimeReadback?.sourceBlockId) ??
+          stringValue(uiaTargetJoin.runtimeBlockId),
         runtimeFragmentId,
+        runtimeNumberingId:
+          stringValue(runtimeReadback?.runtimeNumberingId) ??
+          stringValue(record(row.runtimeJoinAttempt).runtimeNumberingId),
+        layoutObjectId: stringValue(runtimeReadback?.layoutObjectId),
+        runtimeJoinSource,
         runtimePageIndex,
         sourceParagraphPath:
           stringValue(row.sourceParagraphPath) ??
+          stringValue(runtimeReadback?.sourceBlockPath) ??
           stringValue(uiaTargetJoin.sourceParagraphPath),
         canonicalNumberingInstanceId:
           stringValue(row.canonicalNumberingInstanceId) ??
@@ -403,6 +651,7 @@ function summarizeNumberingRows(
         markerLane,
         textColumn,
         pageLocalGeometry,
+        compositorReady: pageLocalGeometry.compositorReady,
         rangeMappingMethod:
           stringValue(uiaRow.rangeMappingMethod) ?? stringValue(row.rangeMappingMethod),
         coordinateSpace: "screen-px" as const,
@@ -423,6 +672,7 @@ function summarizeNumberingRows(
 function summarizeFieldRegionRows(
   runtimeReadback: unknown,
   liveJoinArtifacts: readonly unknown[],
+  pageFramesByDocId: ReadonlyMap<string, ReadonlyMap<number, AdjacentGeometryPageFrame>>,
 ): readonly AdjacentGeometryFieldRegionRowSummary[] {
   const liveJoinByOrdinalKey = new Map<string, Record<string, unknown>>();
   const uniqueLiveJoinRows: Record<string, unknown>[] = [];
@@ -500,18 +750,33 @@ function summarizeFieldRegionRows(
       const wordPlacement = normalizeWordPlacement(
         record(readbackRow.wordResultPlacement),
       );
+      const pageSpanStatus = classifyPageSpan(normalizedWordPageIndexSpan, runtimePageSpan);
+      const l04FrameProjection = projectFieldToL04Frame({
+        docId,
+        normalizedWordPageIndexSpan,
+        runtimePageSpan,
+        pageSpanStatus,
+        wordPlacement,
+        pageFramesByDocId,
+      });
+      const framePixelProjection = projectFieldToFramePixels(l04FrameProjection);
       const pageLocalGeometry: AdjacentGeometryPageLocalFieldGeometry = {
         expectedPageSpan,
         normalizedWordPageIndexSpan,
         runtimePageSpan,
-        pageSpanStatus: classifyPageSpan(normalizedWordPageIndexSpan, runtimePageSpan),
+        pageSpanStatus,
         startAnchorTwips: wordPlacement?.startXYTwips,
         endAnchorTwips: wordPlacement?.endXYTwips,
+        l04FrameProjection,
+        framePixelProjection,
+        compositorReady: framePixelProjection.status === "projected-frame-pixels",
         coordinateSpace: "word-page-twips",
         precision: "word-page-local-calibration",
         normalizationStatus:
-          wordPlacement?.startXYTwips || wordPlacement?.endXYTwips
-            ? "word-page-local-awaiting-l04-frame-projection"
+          l04FrameProjection.status === "projected-l04-frame"
+            ? "l04-frame-twips-projected"
+            : wordPlacement?.startXYTwips || wordPlacement?.endXYTwips
+              ? "word-page-local-awaiting-l04-frame-projection"
             : "missing-word-placement",
       };
       return {
@@ -534,6 +799,7 @@ function summarizeFieldRegionRows(
         runtimePageSpan,
         expectedPageSpan,
         pageLocalGeometry,
+        compositorReady: pageLocalGeometry.compositorReady,
         instructionFamily:
           stringValue(liveJoin.instructionFamily) ??
           stringValue(targetJoin.instructionFamily),
@@ -562,6 +828,9 @@ function summarizeDocument(
     numberingRowsWithRuntimeFragment: numberingRows.filter(
       (row) => row.runtimeFragmentId !== undefined,
     ).length,
+    numberingRowsJoinedFromL04Readback: numberingRows.filter(
+      (row) => row.runtimeJoinSource === "l04-numbering-readback",
+    ).length,
     numberingParagraphLineRects: sum(
       numberingRows,
       (row) => row.paragraphLineRectCount,
@@ -584,6 +853,27 @@ function summarizeDocument(
     numberingRowsWithPageLocalTextColumn: numberingRows.filter(
       (row) => row.pageLocalGeometry.textColumn !== undefined,
     ).length,
+    numberingRowsWithRuntimePageMatch: numberingRows.filter(
+      (row) => row.pageLocalGeometry.pageIndexStatus === "matches-runtime",
+    ).length,
+    numberingUiaRowsWithRuntimePageMatch: numberingRows.filter(
+      (row) =>
+        hasNumberingUiaCapture(row) &&
+        row.pageLocalGeometry.pageIndexStatus === "matches-runtime",
+    ).length,
+    numberingRowsWithL04FrameProjection: numberingRows.filter(hasL04FrameProjection)
+      .length,
+    numberingUiaRowsWithL04FrameProjection: numberingRows.filter(
+      (row) => hasNumberingUiaCapture(row) && hasL04FrameProjection(row),
+    ).length,
+    numberingRowsWithFramePixelProjection: numberingRows.filter(
+      hasFramePixelProjection,
+    ).length,
+    numberingUiaRowsWithFramePixelProjection: numberingRows.filter(
+      (row) => hasNumberingUiaCapture(row) && hasFramePixelProjection(row),
+    ).length,
+    numberingCompositorReadyRows: numberingRows.filter((row) => row.compositorReady)
+      .length,
     fieldRegionRows: fieldRegionRows.length,
     fieldRegionRowsWithRuntimeId: fieldRegionRows.filter(
       (row) => row.runtimeFieldRegionId !== undefined,
@@ -604,9 +894,35 @@ function summarizeDocument(
     fieldRegionRowsWithRuntimePageContainment: fieldRegionRows.filter(
       (row) => row.pageLocalGeometry.pageSpanStatus === "contained-in-runtime",
     ).length,
+    fieldRegionRowsWithL04FrameProjection: fieldRegionRows.filter(
+      hasL04FrameProjection,
+    ).length,
+    fieldRegionUiaRowsWithL04FrameProjection: fieldRegionRows.filter(
+      (row) => row.resultLineRectCount > 0 && hasL04FrameProjection(row),
+    ).length,
+    fieldRegionRowsWithFramePixelProjection: fieldRegionRows.filter(
+      hasFramePixelProjection,
+    ).length,
+    fieldRegionUiaRowsWithFramePixelProjection: fieldRegionRows.filter(
+      (row) => row.resultLineRectCount > 0 && hasFramePixelProjection(row),
+    ).length,
+    fieldRegionCompositorReadyRows: fieldRegionRows.filter((row) => row.compositorReady)
+      .length,
   };
 }
 
+function hasL04FrameProjection(
+  row: AdjacentGeometryNumberingRowSummary | AdjacentGeometryFieldRegionRowSummary,
+): boolean {
+  return row.pageLocalGeometry.l04FrameProjection.status === "projected-l04-frame";
+}
+
+function hasFramePixelProjection(
+  row: AdjacentGeometryNumberingRowSummary | AdjacentGeometryFieldRegionRowSummary,
+): boolean {
+  return row.pageLocalGeometry.framePixelProjection.status === "projected-frame-pixels";
+}
+
 function hasNumberingUiaCapture(row: AdjacentGeometryNumberingRowSummary): boolean {
   return (
     row.paragraphLineRectCount > 0 ||
@@ -615,6 +931,462 @@ function hasNumberingUiaCapture(row: AdjacentGeometryNumberingRowSummary): boole
   );
 }
 
+function collectPageFramesByDocId(
+  artifacts: readonly unknown[],
+): Map<string, Map<number, AdjacentGeometryPageFrame>> {
+  const byDocId = new Map<string, Map<number, AdjacentGeometryPageFrame>>();
+  for (const artifact of artifacts) {
+    const artifactRecord = record(artifact);
+    const docId = stringValue(artifactRecord.docId);
+    if (!docId) continue;
+    for (const raw of array(artifactRecord.pages)) {
+      const page = record(raw);
+      const pageIndex = numberValue(page.pageIndex);
+      if (pageIndex === undefined) continue;
+      const frame = record(page.frame);
+      const physicalBoundsTwips = normalizeTwipsRect(frame.physicalBoundsTwips);
+      const renderFrame = record(page.renderFrame);
+      const renderPageFrame = normalizeFramePxRect(renderFrame.frame);
+      const renderFrameRevision = numberValue(renderFrame.revision);
+      const zoomPxPerTwip =
+        numberValue(record(page.renderZoom).pxPerTwip) ??
+        numberValue(renderFrame.zoomPxPerTwip);
+      const frameId = stringValue(frame.frameId);
+      const pageFrame: AdjacentGeometryPageFrame = {
+        pageId: stringValue(page.pageId),
+        pageIndex,
+        frameId,
+        completeness: stringValue(frame.completeness),
+        physicalBoundsTwips,
+        framePixelScale: buildFramePixelScale({
+          pageIndex,
+          pageId: stringValue(page.pageId),
+          frameId,
+          physicalBoundsTwips,
+          renderPageFrame,
+          renderFrameRevision,
+          zoomPxPerTwip,
+        }),
+      };
+      let docFrames = byDocId.get(docId);
+      if (!docFrames) {
+        docFrames = new Map<number, AdjacentGeometryPageFrame>();
+        byDocId.set(docId, docFrames);
+      }
+      if (!docFrames.has(pageIndex)) docFrames.set(pageIndex, pageFrame);
+    }
+  }
+  return byDocId;
+}
+
+function buildFramePixelScale(input: {
+  readonly pageIndex: number;
+  readonly pageId?: string;
+  readonly frameId?: string;
+  readonly physicalBoundsTwips?: AdjacentGeometryTwipsRect;
+  readonly renderPageFrame?: AdjacentGeometryFramePxRect;
+  readonly renderFrameRevision?: number;
+  readonly zoomPxPerTwip?: number;
+}): AdjacentGeometryFramePixelScale | undefined {
+  const physicalBounds = input.physicalBoundsTwips;
+  const renderPageFrame = input.renderPageFrame;
+  if (!physicalBounds || !renderPageFrame) return undefined;
+  if (
+    physicalBounds.xTwips === undefined ||
+    physicalBounds.yTwips === undefined ||
+    physicalBounds.widthTwips === undefined ||
+    physicalBounds.heightTwips === undefined ||
+    physicalBounds.widthTwips <= 0 ||
+    physicalBounds.heightTwips <= 0
+  ) {
+    return undefined;
+  }
+  const pxPerTwipX = renderPageFrame.widthPx / physicalBounds.widthTwips;
+  const pxPerTwipY = renderPageFrame.heightPx / physicalBounds.heightTwips;
+  if (!isFinitePositive(pxPerTwipX) || !isFinitePositive(pxPerTwipY)) {
+    return undefined;
+  }
+  return {
+    source: "runtime-render-frame-page-rect",
+    pageIndex: input.pageIndex,
+    pageId: input.pageId,
+    frameId: input.frameId,
+    renderFrameRevision: input.renderFrameRevision,
+    renderPageFrame,
+    physicalBoundsTwips: physicalBounds,
+    pxPerTwipX,
+    pxPerTwipY,
+    zoomPxPerTwip:
+      input.zoomPxPerTwip === undefined ? undefined : roundNumber(input.zoomPxPerTwip),
+  };
+}
+
+function collectNumberingRuntimeReadbacks(
+  artifacts: readonly unknown[],
+): Map<string, Record<string, unknown>> {
+  const byKey = new Map<string, Record<string, unknown>>();
+  for (const artifact of artifacts) {
+    const artifactRecord = record(artifact);
+    const docId = stringValue(artifactRecord.docId);
+    for (const raw of array(artifactRecord.numberingFragments)) {
+      const row = record(raw);
+      const key = numberingRuntimeReadbackKey(
+        docId ?? stringValue(row.docId),
+        stringValue(row.numberingKey) ?? stringValue(row.runtimeNumberingId),
+        stringValue(row.numberingInstanceId),
+        numberValue(row.level),
+      );
+      if (key && !byKey.has(key)) byKey.set(key, row);
+    }
+  }
+  return byKey;
+}
+
+function numberingRuntimeReadbackForRow(
+  row: Record<string, unknown>,
+  runtimeReadbacksByKey: ReadonlyMap<string, Record<string, unknown>>,
+): Record<string, unknown> | undefined {
+  const key = numberingRuntimeReadbackKey(
+    stringValue(row.docId),
+    stringValue(record(row.canonicalJoinAttempt).numberingKey),
+    stringValue(row.canonicalNumberingInstanceId),
+    numberValue(row.canonicalLevel),
+  );
+  return key ? runtimeReadbacksByKey.get(key) : undefined;
+}
+
+function projectNumberingToL04Frame(input: {
+  readonly docId: string;
+  readonly normalizedWordPageIndex: number | undefined;
+  readonly runtimePageIndex: number | undefined;
+  readonly pageIndexStatus: AdjacentGeometryPageIndexStatus;
+  readonly markerLane: AdjacentGeometryTwipsRect | undefined;
+  readonly textColumn: AdjacentGeometryTwipsRect | undefined;
+  readonly pageFramesByDocId: ReadonlyMap<string, ReadonlyMap<number, AdjacentGeometryPageFrame>>;
+}): AdjacentGeometryL04FrameProjection {
+  if (input.pageIndexStatus === "word-page-missing") {
+    return baseFrameProjection("word-page-missing");
+  }
+  if (input.pageIndexStatus === "runtime-missing") {
+    return baseFrameProjection("runtime-page-missing", input.normalizedWordPageIndex);
+  }
+  if (input.pageIndexStatus === "differs-from-runtime") {
+    return baseFrameProjection(
+      "page-index-differs-from-runtime",
+      input.normalizedWordPageIndex,
+    );
+  }
+  if (!input.markerLane && !input.textColumn) {
+    return baseFrameProjection(
+      "missing-word-page-local-geometry",
+      input.normalizedWordPageIndex,
+    );
+  }
+  const frame = pageFrameFor(input.pageFramesByDocId, input.docId, input.runtimePageIndex);
+  if (!frame?.physicalBoundsTwips) {
+    return baseFrameProjection("missing-l04-page-frame", input.runtimePageIndex);
+  }
+  return {
+    pageIndex: input.runtimePageIndex,
+    pageId: frame.pageId,
+    frameId: frame.frameId,
+    frameCompleteness: frame.completeness,
+    physicalBoundsTwips: frame.physicalBoundsTwips,
+    framePixelScale: frame.framePixelScale,
+    markerLane: addFrameOrigin(input.markerLane, frame.physicalBoundsTwips),
+    textColumn: addFrameOrigin(input.textColumn, frame.physicalBoundsTwips),
+    coordinateSpace: "l04-frame-twips",
+    precision: "word-page-local-calibration",
+    status: "projected-l04-frame",
+  };
+}
+
+function projectFieldToL04Frame(input: {
+  readonly docId: string;
+  readonly normalizedWordPageIndexSpan: AdjacentGeometryPageSpan | undefined;
+  readonly runtimePageSpan: AdjacentGeometryPageSpan | undefined;
+  readonly pageSpanStatus: AdjacentGeometryPageLocalFieldGeometry["pageSpanStatus"];
+  readonly wordPlacement:
+    | AdjacentGeometryFieldRegionRowSummary["wordPlacement"]
+    | undefined;
+  readonly pageFramesByDocId: ReadonlyMap<string, ReadonlyMap<number, AdjacentGeometryPageFrame>>;
+}): AdjacentGeometryL04FrameProjection {
+  const normalizedStart = input.normalizedWordPageIndexSpan?.startPage;
+  if (normalizedStart == null) return baseFrameProjection("word-page-missing");
+  if (!input.runtimePageSpan || input.runtimePageSpan.startPage == null) {
+    return baseFrameProjection("runtime-page-missing", normalizedStart);
+  }
+  if (
+    input.pageSpanStatus !== "matches-runtime" &&
+    input.pageSpanStatus !== "contained-in-runtime"
+  ) {
+    return baseFrameProjection("page-index-differs-from-runtime", normalizedStart);
+  }
+  if (!input.wordPlacement?.startXYTwips && !input.wordPlacement?.endXYTwips) {
+    return baseFrameProjection("missing-word-page-local-geometry", normalizedStart);
+  }
+  const frame = pageFrameFor(
+    input.pageFramesByDocId,
+    input.docId,
+    input.runtimePageSpan.startPage,
+  );
+  if (!frame?.physicalBoundsTwips) {
+    return baseFrameProjection("missing-l04-page-frame", input.runtimePageSpan.startPage);
+  }
+  return {
+    pageIndex: input.runtimePageSpan.startPage,
+    pageId: frame.pageId,
+    frameId: frame.frameId,
+    frameCompleteness: frame.completeness,
+    physicalBoundsTwips: frame.physicalBoundsTwips,
+    framePixelScale: frame.framePixelScale,
+    fieldStartAnchorTwips: addFrameOriginToPoint(
+      input.wordPlacement.startXYTwips,
+      frame.physicalBoundsTwips,
+    ),
+    fieldEndAnchorTwips: addFrameOriginToPoint(
+      input.wordPlacement.endXYTwips,
+      frame.physicalBoundsTwips,
+    ),
+    coordinateSpace: "l04-frame-twips",
+    precision: "word-page-local-calibration",
+    status: "projected-l04-frame",
+  };
+}
+
+function projectNumberingToFramePixels(
+  projection: AdjacentGeometryL04FrameProjection,
+): AdjacentGeometryFramePixelProjection {
+  if (projection.status !== "projected-l04-frame") {
+    return baseFramePixelProjection("awaiting-l04-frame-projection", projection);
+  }
+  const scale = projectionScale(projection);
+  if (!scale) return baseFramePixelProjection("missing-frame-pixel-scale", projection);
+  const markerLane = l04FrameTwipsRectToFramePx(projection.markerLane, scale);
+  const textColumn = l04FrameTwipsRectToFramePx(projection.textColumn, scale);
+  if (!markerLane) {
+    return baseFramePixelProjection("missing-l04-frame-rect", projection, scale);
+  }
+  return {
+    pageIndex: projection.pageIndex,
+    pageId: projection.pageId,
+    frameId: projection.frameId,
+    scale,
+    markerLane,
+    textColumn,
+    coordinateSpace: "frame-px",
+    precision: "word-page-local-calibration",
+    status: "projected-frame-pixels",
+  };
+}
+
+function projectFieldToFramePixels(
+  projection: AdjacentGeometryL04FrameProjection,
+): AdjacentGeometryFramePixelProjection {
+  if (projection.status !== "projected-l04-frame") {
+    return baseFramePixelProjection("awaiting-l04-frame-projection", projection);
+  }
+  const scale = projectionScale(projection);
+  if (!scale) return baseFramePixelProjection("missing-frame-pixel-scale", projection);
+  const fieldStartAnchorPx = l04FrameTwipsPointToFramePx(
+    projection.fieldStartAnchorTwips,
+    scale,
+  );
+  const fieldEndAnchorPx = l04FrameTwipsPointToFramePx(
+    projection.fieldEndAnchorTwips,
+    scale,
+  );
+  if (!fieldStartAnchorPx || !fieldEndAnchorPx) {
+    return baseFramePixelProjection("missing-l04-field-anchor", projection, scale);
+  }
+  return {
+    pageIndex: projection.pageIndex,
+    pageId: projection.pageId,
+    frameId: projection.frameId,
+    scale,
+    fieldStartAnchorPx,
+    fieldEndAnchorPx,
+    fieldResultRangePx: rangeRectFromPoints(fieldStartAnchorPx, fieldEndAnchorPx),
+    coordinateSpace: "frame-px",
+    precision: "word-page-local-calibration",
+    status: "projected-frame-pixels",
+  };
+}
+
+function baseFrameProjection(
+  status: AdjacentGeometryL04FrameProjection["status"],
+  pageIndex?: number,
+): AdjacentGeometryL04FrameProjection {
+  return {
+    pageIndex,
+    coordinateSpace: "l04-frame-twips",
+    precision: "word-page-local-calibration",
+    status,
+  };
+}
+
+function baseFramePixelProjection(
+  status: AdjacentGeometryFramePixelProjection["status"],
+  projection: AdjacentGeometryL04FrameProjection,
+  scale?: AdjacentGeometryFramePixelScale,
+): AdjacentGeometryFramePixelProjection {
+  return {
+    pageIndex: projection.pageIndex,
+    pageId: projection.pageId,
+    frameId: projection.frameId,
+    scale,
+    coordinateSpace: "frame-px",
+    precision: "word-page-local-calibration",
+    status,
+  };
+}
+
+function pageFrameFor(
+  pageFramesByDocId: ReadonlyMap<string, ReadonlyMap<number, AdjacentGeometryPageFrame>>,
+  docId: string,
+  pageIndex: number | undefined,
+): AdjacentGeometryPageFrame | undefined {
+  return pageIndex === undefined ? undefined : pageFramesByDocId.get(docId)?.get(pageIndex);
+}
+
+function projectionScale(
+  projection: AdjacentGeometryL04FrameProjection,
+): AdjacentGeometryFramePixelScale | undefined {
+  return projection.framePixelScale;
+}
+
+function addFrameOrigin(
+  rect: AdjacentGeometryTwipsRect | undefined,
+  frame: AdjacentGeometryTwipsRect,
+): AdjacentGeometryTwipsRect | undefined {
+  if (!rect) return undefined;
+  return {
+    xTwips:
+      rect.xTwips === undefined || frame.xTwips === undefined
+        ? rect.xTwips
+        : rect.xTwips + frame.xTwips,
+    yTwips:
+      rect.yTwips === undefined || frame.yTwips === undefined
+        ? rect.yTwips
+        : rect.yTwips + frame.yTwips,
+    widthTwips: rect.widthTwips,
+    heightTwips: rect.heightTwips,
+  };
+}
+
+function addFrameOriginToPoint(
+  point: { readonly x?: number; readonly y?: number } | undefined,
+  frame: AdjacentGeometryTwipsRect,
+): { readonly x?: number; readonly y?: number } | undefined {
+  if (!point) return undefined;
+  return {
+    x:
+      point.x === undefined || frame.xTwips === undefined
+        ? point.x
+        : point.x + frame.xTwips,
+    y:
+      point.y === undefined || frame.yTwips === undefined
+        ? point.y
+        : point.y + frame.yTwips,
+  };
+}
+
+function l04FrameTwipsRectToFramePx(
+  rect: AdjacentGeometryTwipsRect | undefined,
+  scale: AdjacentGeometryFramePixelScale,
+): AdjacentGeometryFramePxRect | undefined {
+  if (
+    !rect ||
+    rect.xTwips === undefined ||
+    rect.yTwips === undefined ||
+    rect.widthTwips === undefined ||
+    rect.heightTwips === undefined ||
+    scale.physicalBoundsTwips.xTwips === undefined ||
+    scale.physicalBoundsTwips.yTwips === undefined
+  ) {
+    return undefined;
+  }
+  return {
+    leftPx: roundNumber(
+      scale.renderPageFrame.leftPx +
+        (rect.xTwips - scale.physicalBoundsTwips.xTwips) * scale.pxPerTwipX,
+    ),
+    topPx: roundNumber(
+      scale.renderPageFrame.topPx +
+        (rect.yTwips - scale.physicalBoundsTwips.yTwips) * scale.pxPerTwipY,
+    ),
+    widthPx: roundNumber(Math.max(0, rect.widthTwips * scale.pxPerTwipX)),
+    heightPx: roundNumber(Math.max(0, rect.heightTwips * scale.pxPerTwipY)),
+    coordinateSpace: "frame-px",
+  };
+}
+
+function l04FrameTwipsPointToFramePx(
+  point: { readonly x?: number; readonly y?: number } | undefined,
+  scale: AdjacentGeometryFramePixelScale,
+): AdjacentGeometryFramePxPoint | undefined {
+  if (
+    !point ||
+    point.x === undefined ||
+    point.y === undefined ||
+    scale.physicalBoundsTwips.xTwips === undefined ||
+    scale.physicalBoundsTwips.yTwips === undefined
+  ) {
+    return undefined;
+  }
+  return {
+    xPx: roundNumber(
+      scale.renderPageFrame.leftPx +
+        (point.x - scale.physicalBoundsTwips.xTwips) * scale.pxPerTwipX,
+    ),
+    yPx: roundNumber(
+      scale.renderPageFrame.topPx +
+        (point.y - scale.physicalBoundsTwips.yTwips) * scale.pxPerTwipY,
+    ),
+    coordinateSpace: "frame-px",
+  };
+}
+
+function rangeRectFromPoints(
+  start: AdjacentGeometryFramePxPoint,
+  end: AdjacentGeometryFramePxPoint,
+): AdjacentGeometryFramePxRect {
+  const leftPx = Math.min(start.xPx, end.xPx);
+  const topPx = Math.min(start.yPx, end.yPx);
+  return {
+    leftPx,
+    topPx,
+    widthPx: roundNumber(Math.abs(end.xPx - start.xPx)),
+    heightPx: roundNumber(Math.abs(end.yPx - start.yPx)),
+    coordinateSpace: "frame-px",
+  };
+}
+
+function classifyPageIndex(
+  normalizedWordPageIndex: number | undefined,
+  runtimePageIndex: number | undefined,
+): AdjacentGeometryPageIndexStatus {
+  if (normalizedWordPageIndex === undefined) return "word-page-missing";
+  if (runtimePageIndex === undefined) return "runtime-missing";
+  return normalizedWordPageIndex === runtimePageIndex
+    ? "matches-runtime"
+    : "differs-from-runtime";
+}
+
+function numberingRuntimeReadbackKey(
+  docId: string | undefined,
+  numberingKeyValue: string | undefined,
+  numberingInstanceId: string | undefined,
+  level: number | undefined,
+): string | undefined {
+  return docId &&
+    numberingKeyValue &&
+    numberingInstanceId &&
+    level !== undefined
+    ? `${docId}\0${numberingKeyValue}\0${numberingInstanceId}\0${level}`
+    : undefined;
+}
+
 function normalizeRects(raw: unknown): readonly AdjacentGeometryRect[] {
   if (Array.isArray(raw)) return raw.map(normalizeRect).filter(isRect);
   const maybeRect = normalizeRect(raw);
@@ -661,6 +1433,31 @@ function normalizeRect(raw: unknown): AdjacentGeometryRect | undefined {
   };
 }
 
+function normalizeFramePxRect(
+  raw: unknown,
+): AdjacentGeometryFramePxRect | undefined {
+  const rect = record(raw);
+  const leftPx = numberValue(rect.leftPx);
+  const topPx = numberValue(rect.topPx);
+  const widthPx = numberValue(rect.widthPx);
+  const heightPx = numberValue(rect.heightPx);
+  if (
+    leftPx === undefined ||
+    topPx === undefined ||
+    widthPx === undefined ||
+    heightPx === undefined
+  ) {
+    return undefined;
+  }
+  return {
+    leftPx: roundNumber(leftPx),
+    topPx: roundNumber(topPx),
+    widthPx: roundNumber(widthPx),
+    heightPx: roundNumber(heightPx),
+    coordinateSpace: "frame-px",
+  };
+}
+
 function normalizeTwipsRect(raw: unknown):
   | {
       readonly xTwips?: number;
@@ -819,6 +1616,14 @@ function numberValue(value: unknown): number | undefined {
   return typeof value === "number" && Number.isFinite(value) ? value : undefined;
 }
 
+function isFinitePositive(value: number): boolean {
+  return Number.isFinite(value) && value > 0;
+}
+
+function roundNumber(value: number): number {
+  return Number.parseFloat(value.toFixed(6));
+}
+
 function nullableNumberValue(value: unknown): number | null | undefined {
   return value === null ? null : numberValue(value);
 }