@beyondwork/docx-react-component 1.0.104 → 1.0.106

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

@@ -1791,6 +1791,16 @@ export function paginateSectionBlocksWithSplits(
         to: refRange.blockTo,
         heightTwips: heightTwips + FOOTNOTE_REFERENCE_RESERVATION_TWIPS,
         kind: "whole",
+        layoutObject: {
+          objectId: `footnote-body:${fragmentId}`,
+          kind: "footnote-body",
+          sourceBlockId: `note-body-${noteKind}-${noteId}`,
+          paginationRole: "whole",
+          measuredExtentTwips: {
+            heightTwips: heightTwips + FOOTNOTE_REFERENCE_RESERVATION_TWIPS,
+            widthTwips: effectiveColumnWidth,
+          },
+        },
       };
 
       allocations.push(allocation);

package/src/runtime/layout/project-block-fragments.ts

@@ -126,6 +126,14 @@ export function projectSurfaceBlocksToPageFragments(
     if (pageIndex === null) continue;
 
     const columnIndex = columnIndexFor(pageIndex, block.blockId);
+    const heightTwips = measuredHeightFor(
+      pageIndex,
+      block.blockId,
+      estimateBlockHeightFromSpan(block),
+    );
+    const widthTwips = fragmentMeasurementsByPageIndex
+      ?.get(pageIndex)
+      ?.get(block.blockId)?.widthTwips;
     const fragment: FragmentWithoutPageId = {
       fragmentId: `fragment-${block.blockId}`,
       blockId: block.blockId,
@@ -133,13 +141,16 @@ export function projectSurfaceBlocksToPageFragments(
       regionKind: "body",
       from: block.from,
       to: block.to,
-      heightTwips: measuredHeightFor(
-        pageIndex,
-        block.blockId,
-        estimateBlockHeightFromSpan(block),
-      ),
+      heightTwips,
       ...deriveStyleMetadata(block),
       kind: "whole",
+      layoutObject: buildFragmentLayoutObject({
+        block,
+        fragmentId: `fragment-${block.blockId}`,
+        heightTwips,
+        widthTwips,
+        paginationRole: "whole",
+      }),
       ...(columnIndex !== undefined ? { columnIndex } : {}),
     };
 
@@ -224,6 +235,7 @@ function emitSlicedParagraph(
 ): void {
   for (let i = 0; i < slices.length; i += 1) {
     const slice = slices[i]!;
+    const heightTwips = slice.heightTwips ?? estimateSliceHeightFromLines(slice.lineRange);
     const fragment: FragmentWithoutPageId = {
       fragmentId: `fragment-${block.blockId}-slice-${i}`,
       blockId: block.blockId,
@@ -231,15 +243,38 @@ function emitSlicedParagraph(
       regionKind: "body",
       from: block.from,
       to: block.to,
-      heightTwips: slice.heightTwips ?? estimateSliceHeightFromLines(slice.lineRange),
+      heightTwips,
       ...deriveStyleMetadata(block),
       kind: "paragraph-slice",
       paragraphLineRange: slice.lineRange,
+      continuation: buildParagraphContinuationCursor(slice, i, slices.length),
+      layoutObject: buildFragmentLayoutObject({
+        block,
+        fragmentId: `fragment-${block.blockId}-slice-${i}`,
+        heightTwips,
+        widthTwips: slice.widthTwips,
+        paginationRole: slice.lineRange.from > 0 ? "continuation" : "slice",
+      }),
     };
     emit(slice.pageIndex, fragment);
   }
 }
 
+function buildParagraphContinuationCursor(
+  slice: ParagraphLineSlice,
+  sequenceIndex: number,
+  sliceCount: number,
+): NonNullable<RuntimeBlockFragment["continuation"]> {
+  return {
+    kind: "paragraph",
+    sequenceIndex,
+    sliceCount,
+    lineRange: slice.lineRange,
+    continuesFromPreviousPage: slice.lineRange.from > 0,
+    continuesToNextPage: slice.lineRange.to < slice.lineRange.totalLines,
+  };
+}
+
 function estimateSliceHeightFromLines(lineRange: {
   from: number;
   to: number;
@@ -259,12 +294,13 @@ function estimateSliceHeightFromLines(lineRange: {
  * every continuation page.
  */
 function emitSlicedTable(
-  block: SurfaceBlockSnapshot,
+  block: Extract<SurfaceBlockSnapshot, { kind: "table" }>,
   slices: readonly TableRowSlice[],
   emit: (pageIndex: number, fragment: FragmentWithoutPageId) => void,
 ): void {
   for (let i = 0; i < slices.length; i += 1) {
     const slice = slices[i]!;
+    const heightTwips = slice.heightTwips ?? estimateSliceHeightFromRows(slice.rowRange);
     const fragment: FragmentWithoutPageId = {
       fragmentId: `fragment-${block.blockId}-rowslice-${i}`,
       blockId: block.blockId,
@@ -272,16 +308,106 @@ function emitSlicedTable(
       regionKind: "body",
       from: block.from,
       to: block.to,
-      heightTwips: slice.heightTwips ?? estimateSliceHeightFromRows(slice.rowRange),
+      heightTwips,
       ...deriveStyleMetadata(block),
       kind: "table-slice",
       tableRowRange: slice.rowRange,
+      continuation: buildTableContinuationCursor(block, slice, i, slices.length),
+      layoutObject: buildFragmentLayoutObject({
+        block,
+        fragmentId: `fragment-${block.blockId}-rowslice-${i}`,
+        heightTwips,
+        paginationRole: slice.rowRange.from > 0 ? "continuation" : "slice",
+      }),
       ...(slice.columnIndex !== undefined ? { columnIndex: slice.columnIndex } : {}),
     };
     emit(slice.pageIndex, fragment);
   }
 }
 
+function buildTableContinuationCursor(
+  block: Extract<SurfaceBlockSnapshot, { kind: "table" }>,
+  slice: TableRowSlice,
+  sequenceIndex: number,
+  sliceCount: number,
+): NonNullable<RuntimeBlockFragment["continuation"]> {
+  return {
+    kind: "table",
+    sequenceIndex,
+    sliceCount,
+    rowRange: slice.rowRange,
+    continuesFromPreviousPage: slice.rowRange.from > 0,
+    continuesToNextPage: slice.rowRange.to < slice.rowRange.totalRows,
+    repeatedHeaderRowIndexes:
+      slice.rowRange.from > 0
+        ? collectRepeatedHeaderRowIndexes(block, slice.rowRange.from)
+        : [],
+    verticalMergeCarry: collectVerticalMergeCarry(block, slice.rowRange.from),
+  };
+}
+
+function collectRepeatedHeaderRowIndexes(
+  block: Extract<SurfaceBlockSnapshot, { kind: "table" }>,
+  startRow: number,
+): number[] {
+  const headerRows: number[] = [];
+  for (let rowIndex = 0; rowIndex < block.rows.length; rowIndex += 1) {
+    if (rowIndex >= startRow) break;
+    if (block.rows[rowIndex]?.isHeader === true) headerRows.push(rowIndex);
+  }
+  return headerRows;
+}
+
+function collectVerticalMergeCarry(
+  block: Extract<SurfaceBlockSnapshot, { kind: "table" }>,
+  startRow: number,
+): Array<{ columnIndex: number; restartRowIndex: number }> {
+  if (startRow <= 0) return [];
+
+  const activeByColumn = new Map<number, number>();
+  for (let rowIndex = 0; rowIndex < startRow; rowIndex += 1) {
+    visitRowCells(block.rows[rowIndex], (columnIndex, span, verticalMerge) => {
+      for (let column = columnIndex; column < columnIndex + span; column += 1) {
+        if (verticalMerge === "restart") {
+          activeByColumn.set(column, rowIndex);
+        } else if (verticalMerge !== "continue") {
+          activeByColumn.delete(column);
+        }
+      }
+    });
+  }
+
+  const carried = new Map<number, number>();
+  visitRowCells(block.rows[startRow], (columnIndex, span, verticalMerge) => {
+    if (verticalMerge !== "continue") return;
+    for (let column = columnIndex; column < columnIndex + span; column += 1) {
+      const restartRowIndex = activeByColumn.get(column);
+      if (restartRowIndex !== undefined) carried.set(column, restartRowIndex);
+    }
+  });
+
+  return [...carried]
+    .sort(([a], [b]) => a - b)
+    .map(([columnIndex, restartRowIndex]) => ({ columnIndex, restartRowIndex }));
+}
+
+function visitRowCells(
+  row: Extract<SurfaceBlockSnapshot, { kind: "table" }>["rows"][number] | undefined,
+  visit: (
+    columnIndex: number,
+    span: number,
+    verticalMerge: "restart" | "continue" | null,
+  ) => void,
+): void {
+  if (!row) return;
+  let columnIndex = Math.max(0, row.gridBefore ?? 0);
+  for (const cell of row.cells) {
+    const span = Math.max(1, cell.gridSpan || cell.colspan || 1);
+    visit(columnIndex, span, cell.verticalMerge);
+    columnIndex += span;
+  }
+}
+
 function estimateSliceHeightFromRows(rowRange: {
   from: number;
   to: number;
@@ -291,6 +417,59 @@ function estimateSliceHeightFromRows(rowRange: {
   return rows * 360; // ~1 line + padding per row, approximate
 }
 
+function buildFragmentLayoutObject(input: {
+  block: SurfaceBlockSnapshot;
+  fragmentId: string;
+  heightTwips: number;
+  widthTwips?: number;
+  paginationRole: NonNullable<RuntimeBlockFragment["layoutObject"]>["paginationRole"];
+}): NonNullable<RuntimeBlockFragment["layoutObject"]> {
+  const fieldFamilies = collectFieldFamilies(input.block);
+  const kind = resolveFragmentLayoutObjectKind(input.block, fieldFamilies);
+  return {
+    objectId: `${kind}:${input.fragmentId}`,
+    kind,
+    sourceBlockId: input.block.blockId,
+    paginationRole: input.paginationRole,
+    measuredExtentTwips: {
+      heightTwips: Math.max(0, input.heightTwips),
+      ...(input.widthTwips !== undefined
+        ? { widthTwips: Math.max(0, input.widthTwips) }
+        : {}),
+    },
+    ...(fieldFamilies.length > 0 ? { fieldFamilies } : {}),
+  };
+}
+
+function resolveFragmentLayoutObjectKind(
+  block: SurfaceBlockSnapshot,
+  fieldFamilies: readonly string[],
+): NonNullable<RuntimeBlockFragment["layoutObject"]>["kind"] {
+  switch (block.kind) {
+    case "paragraph":
+      if (fieldFamilies.length > 0) return "field-region";
+      return block.numbering ? "numbered-paragraph" : "paragraph";
+    case "table":
+      return "table";
+    case "sdt_block":
+      return "sdt-block";
+    case "opaque_block":
+      return "opaque-block";
+  }
+}
+
+function collectFieldFamilies(block: SurfaceBlockSnapshot): string[] {
+  if (block.kind !== "paragraph") return [];
+  const families: string[] = [];
+  const seen = new Set<string>();
+  for (const segment of block.segments) {
+    if (segment.kind !== "field_ref" || seen.has(segment.fieldFamily)) continue;
+    seen.add(segment.fieldFamily);
+    families.push(segment.fieldFamily);
+  }
+  return families;
+}
+
 function findPageIndexForOffset(
   pages: readonly DocumentPageSnapshot[],
   offset: number,

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

@@ -25,12 +25,17 @@ import type {
 } from "./page-story-resolver.ts";
 import type {
   RuntimeBlockFragment,
+  RuntimeLayoutContinuationCursor,
+  RuntimeLayoutDivergence,
   RuntimeLineBox,
   RuntimeNoteAllocation,
+  RuntimePageFrame,
   RuntimePageGraph,
   RuntimePageNode,
   RuntimePageRegion,
   RuntimePageRegions,
+  RuntimeStoryAnchoredObject,
+  RuntimeTwipsRect,
 } from "./page-graph.ts";
 import type {
   ResolvedFormattingState,
@@ -132,6 +137,67 @@ export function emitLayoutGuardWarning(
 // Public read model types (shape-stable, cloned at the facet boundary)
 // ---------------------------------------------------------------------------
 
+export interface PublicTwipsRect {
+  xTwips: number;
+  yTwips: number;
+  widthTwips: number;
+  heightTwips: number;
+}
+
+export interface PublicLayoutDivergence {
+  divergenceId: string;
+  kind: RuntimeLayoutDivergence["kind"];
+  source: RuntimeLayoutDivergence["source"];
+  severity: RuntimeLayoutDivergence["severity"];
+  message: string;
+  regionKinds?: readonly RuntimePageRegion["kind"][];
+  fragmentIds?: readonly string[];
+}
+
+export interface PublicPageFrame {
+  frameId: string;
+  pageId: string;
+  pageIndex: number;
+  sectionIndex: number;
+  displayPageNumber: number;
+  physicalBoundsTwips: PublicTwipsRect;
+  divergenceIds: readonly string[];
+  signature: string;
+  exclusionZoneCount: number;
+  regionFrames: readonly {
+    kind: RuntimePageRegion["kind"];
+    rectTwips?: PublicTwipsRect;
+    fragmentIds: readonly string[];
+  }[];
+  pageLocalStories: readonly PublicPageLocalStoryInstance[];
+}
+
+export interface PublicPageLocalStoryInstance {
+  instanceId: string;
+  storyKey: string;
+  pageId: string;
+  kind: "header" | "footer";
+  variant: "default" | "first" | "even" | "odd";
+  relationshipId: string;
+  sectionIndex?: number;
+  anchoredObjects: readonly PublicStoryAnchoredObject[];
+  measuredFrameHeightTwips: number;
+  signature: string;
+}
+
+export interface PublicStoryAnchoredObject {
+  objectId: string;
+  sourceType: RuntimeStoryAnchoredObject["sourceType"];
+  display: RuntimeStoryAnchoredObject["display"];
+  extentTwips?: {
+    widthTwips: number;
+    heightTwips: number;
+  };
+  relationshipIds?: readonly string[];
+  preserveOnly: boolean;
+  divergenceIds: readonly string[];
+}
+
 export interface PublicPageNode {
   pageId: string;
   pageIndex: number;
@@ -157,6 +223,10 @@ export interface PublicPageNode {
   lineBoxCount: number;
   /** Footnotes reserved at the bottom of the page, if any. */
   noteAllocations: readonly PublicNoteAllocation[];
+  /** PE2 page-frame graph projection, when emitted by the L04 graph. */
+  frame?: PublicPageFrame;
+  /** Typed layout divergences detected while building this page. */
+  divergences?: readonly PublicLayoutDivergence[];
 }
 
 export interface PublicResolvedPageStories {
@@ -187,6 +257,8 @@ export interface PublicPageRegion {
   widthTwips: number;
   heightTwips: number;
   fragmentCount: number;
+  /** PE2 semantic twips rect, when populated by the L04 page-frame graph. */
+  rectTwips?: PublicTwipsRect;
 }
 
 /**
@@ -208,8 +280,25 @@ export interface PublicBlockFragment {
   to: number;
   heightTwips: number;
   orderInRegion: number;
+  kind?: "whole" | "paragraph-slice" | "table-slice";
+  paragraphLineRange?: {
+    from: number;
+    to: number;
+    totalLines: number;
+  };
+  tableRowRange?: {
+    from: number;
+    to: number;
+    totalRows: number;
+  };
+  columnIndex?: number;
+  continuation?: PublicLayoutContinuationCursor;
+  layoutObject?: PublicFragmentLayoutObject;
 }
 
+export type PublicLayoutContinuationCursor = RuntimeLayoutContinuationCursor;
+export type PublicFragmentLayoutObject = NonNullable<RuntimeBlockFragment["layoutObject"]>;
+
 /**
  * P8 — One block snapshot rendered into a region of a page.  Returned by
  * `WordReviewEditorLayoutFacet.getStoryBlocksForRegion` and
@@ -245,6 +334,7 @@ export interface PublicNoteAllocation {
   noteKind: "footnote" | "endnote";
   noteId: string;
   reservedHeightTwips: number;
+  fragmentId?: string;
 }
 
 export interface PublicPageAnchor {
@@ -1367,12 +1457,113 @@ function toPublicPageNode(
     regions: toPublicPageRegions(node.regions),
     lineBoxCount: node.lineBoxes.length,
     noteAllocations: node.noteAllocations.map(toPublicNoteAllocation),
+    ...(node.frame ? { frame: toPublicPageFrame(node.frame) } : {}),
+    ...(node.divergences && node.divergences.length > 0
+      ? { divergences: node.divergences.map(toPublicLayoutDivergence) }
+      : {}),
   };
   publicPageNodeCache.set(node, built);
   void graph; // reserved for future cross-page derivations
   return built;
 }
 
+function toPublicTwipsRect(rect: RuntimeTwipsRect): PublicTwipsRect {
+  return {
+    xTwips: rect.xTwips,
+    yTwips: rect.yTwips,
+    widthTwips: rect.widthTwips,
+    heightTwips: rect.heightTwips,
+  };
+}
+
+function frameRegionEntries(
+  frame: RuntimePageFrame,
+): PublicPageFrame["regionFrames"] {
+  const regions: PublicPageFrame["regionFrames"][number][] = [];
+  const push = (region: RuntimePageRegion | undefined) => {
+    if (!region) return;
+    regions.push({
+      kind: region.kind,
+      ...(region.rectTwips ? { rectTwips: toPublicTwipsRect(region.rectTwips) } : {}),
+      fragmentIds: [...region.fragmentIds],
+    });
+  };
+  push(frame.regions.header);
+  push(frame.regions.body);
+  for (const column of frame.regions.columns ?? []) push(column);
+  push(frame.regions.footer);
+  for (const footnote of frame.regions.footnotes ?? []) push(footnote);
+  return regions;
+}
+
+function toPublicPageFrame(frame: RuntimePageFrame): PublicPageFrame {
+  return {
+    frameId: frame.frameId,
+    pageId: frame.pageId,
+    pageIndex: frame.pageIndex,
+    sectionIndex: frame.sectionIndex,
+    displayPageNumber: frame.displayPageNumber,
+    physicalBoundsTwips: toPublicTwipsRect(frame.physicalBoundsTwips),
+    divergenceIds: [...frame.divergenceIds],
+    signature: frame.signature,
+    exclusionZoneCount: frame.regions.exclusionZones.length,
+    regionFrames: frameRegionEntries(frame),
+    pageLocalStories: frame.pageLocalStories.map(toPublicPageLocalStory),
+  };
+}
+
+function toPublicPageLocalStory(
+  story: RuntimePageFrame["pageLocalStories"][number],
+): PublicPageLocalStoryInstance {
+  return {
+    instanceId: story.instanceId,
+    storyKey: story.storyKey,
+    pageId: story.pageId,
+    kind: story.kind,
+    variant: story.variant,
+    relationshipId: story.relationshipId,
+    ...(story.sectionIndex !== undefined ? { sectionIndex: story.sectionIndex } : {}),
+    anchoredObjects: story.anchoredObjects.map(toPublicStoryAnchoredObject),
+    measuredFrameHeightTwips: story.measuredFrameHeightTwips,
+    signature: story.signature,
+  };
+}
+
+function toPublicStoryAnchoredObject(
+  object: RuntimeStoryAnchoredObject,
+): PublicStoryAnchoredObject {
+  return {
+    objectId: object.objectId,
+    sourceType: object.sourceType,
+    display: object.display,
+    ...(object.extentTwips
+      ? {
+          extentTwips: {
+            widthTwips: object.extentTwips.widthTwips,
+            heightTwips: object.extentTwips.heightTwips,
+          },
+        }
+      : {}),
+    ...(object.relationshipIds ? { relationshipIds: [...object.relationshipIds] } : {}),
+    preserveOnly: object.preserveOnly,
+    divergenceIds: [...object.divergenceIds],
+  };
+}
+
+function toPublicLayoutDivergence(
+  divergence: RuntimeLayoutDivergence,
+): PublicLayoutDivergence {
+  return {
+    divergenceId: divergence.divergenceId,
+    kind: divergence.kind,
+    source: divergence.source,
+    severity: divergence.severity,
+    message: divergence.message,
+    ...(divergence.regionKinds !== undefined ? { regionKinds: [...divergence.regionKinds] } : {}),
+    ...(divergence.fragmentIds !== undefined ? { fragmentIds: [...divergence.fragmentIds] } : {}),
+  };
+}
+
 function toPublicResolvedPageStories(
   stories: ResolvedPageStories,
 ): PublicResolvedPageStories {
@@ -1404,6 +1595,7 @@ function toPublicPageRegion(region: RuntimePageRegion): PublicPageRegion {
     widthTwips: region.widthTwips,
     heightTwips: region.heightTwips,
     fragmentCount: region.fragmentIds.length,
+    ...(region.rectTwips ? { rectTwips: toPublicTwipsRect(region.rectTwips) } : {}),
   };
 }
 
@@ -1422,6 +1614,49 @@ function toPublicBlockFragment(
     to: fragment.to,
     heightTwips: fragment.heightTwips,
     orderInRegion: fragment.orderInRegion,
+    ...(fragment.kind !== undefined ? { kind: fragment.kind } : {}),
+    ...(fragment.paragraphLineRange !== undefined
+      ? { paragraphLineRange: { ...fragment.paragraphLineRange } }
+      : {}),
+    ...(fragment.tableRowRange !== undefined
+      ? { tableRowRange: { ...fragment.tableRowRange } }
+      : {}),
+    ...(fragment.columnIndex !== undefined ? { columnIndex: fragment.columnIndex } : {}),
+    ...(fragment.continuation !== undefined
+      ? { continuation: cloneContinuationCursor(fragment.continuation) }
+      : {}),
+    ...(fragment.layoutObject !== undefined
+      ? { layoutObject: cloneFragmentLayoutObject(fragment.layoutObject) }
+      : {}),
+  };
+}
+
+function cloneContinuationCursor(
+  cursor: RuntimeLayoutContinuationCursor,
+): RuntimeLayoutContinuationCursor {
+  if (cursor.kind === "paragraph") {
+    return {
+      ...cursor,
+      lineRange: { ...cursor.lineRange },
+    };
+  }
+  return {
+    ...cursor,
+    rowRange: { ...cursor.rowRange },
+    repeatedHeaderRowIndexes: [...cursor.repeatedHeaderRowIndexes],
+    verticalMergeCarry: cursor.verticalMergeCarry.map((carry) => ({ ...carry })),
+  };
+}
+
+function cloneFragmentLayoutObject(
+  layoutObject: NonNullable<RuntimeBlockFragment["layoutObject"]>,
+): NonNullable<RuntimeBlockFragment["layoutObject"]> {
+  return {
+    ...layoutObject,
+    measuredExtentTwips: { ...layoutObject.measuredExtentTwips },
+    ...(layoutObject.fieldFamilies !== undefined
+      ? { fieldFamilies: [...layoutObject.fieldFamilies] }
+      : {}),
   };
 }
 
@@ -1440,6 +1675,7 @@ function toPublicNoteAllocation(note: RuntimeNoteAllocation): PublicNoteAllocati
     noteKind: note.noteKind,
     noteId: note.noteId,
     reservedHeightTwips: note.reservedHeightTwips,
+    ...(note.fragmentId !== undefined ? { fragmentId: note.fragmentId } : {}),
   };
 }
 

package/src/runtime/prerender/graph-canonicalize.ts

@@ -3,6 +3,7 @@ import type {
   RuntimePageAnchor,
   RuntimePageFrame,
   RuntimePageGraph,
+  RuntimePageLocalStoryInstance,
   RuntimePageNode,
   RuntimePageRegion,
   RuntimePageRegions,
@@ -97,6 +98,9 @@ function rewriteFrame(
   return {
     ...frame,
     pageId: rewriteId(frame.pageId),
+    pageLocalStories: frame.pageLocalStories.map((story) =>
+      rewritePageLocalStoryInstance(story, rewriteId),
+    ),
     regions: {
       ...frame.regions,
       body: rewriteRegion(frame.regions.body, rewriteId),
@@ -116,6 +120,16 @@ function rewriteFrame(
   };
 }
 
+function rewritePageLocalStoryInstance(
+  story: RuntimePageLocalStoryInstance,
+  rewriteId: (id: string) => string,
+): RuntimePageLocalStoryInstance {
+  return {
+    ...story,
+    pageId: rewriteId(story.pageId),
+  };
+}
+
 function rewriteRegions(
   regions: RuntimePageRegions,
   rewriteId: (id: string) => string,

package/src/runtime/workflow/index.ts

@@ -19,6 +19,7 @@ export * from "./scope-writer.ts";
 export * from "./metadata-writer.ts";
 export * from "./projector.ts";
 export * from "./overlay-store.ts";
+export * from "./overlay-lanes.ts";
 export * from "./coordinator.ts";
 export * from "./visibility-policy.ts";
 export * from "./markup-mode-policy.ts";