@beyondwork/docx-react-component 1.0.105 → 1.0.108

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

@@ -34,6 +34,7 @@ import type {
   RuntimePageNode,
   RuntimePageRegion,
   RuntimePageRegions,
+  RuntimeStoryAnchoredObject,
   RuntimeTwipsRect,
 } from "./page-graph.ts";
 import type {
@@ -90,6 +91,7 @@ import { resolvePageFieldDisplayText } from "./resolve-page-fields.ts";
 //    `runtime.workflow.*`; the layout facet supplies the page graph
 //    as input, not the rail output.
 import { collectLineBoxesForRegion } from "../geometry/project-fragments.ts";
+import { emitLayoutGuardWarning } from "../diagnostics/layout-guard-warning.ts";
 // `recordPerfSample` no longer imported — used only by the removed
 // `hitTest` wrapper to emit `chrome.hit_test` samples. Geometry facet
 // can add its own instrumentation at call site if needed.
@@ -111,26 +113,11 @@ export type { ScopeRailSegment };
 // Module-level warning emitter (D1 silent-success probes)
 // ---------------------------------------------------------------------------
 
-type LayoutWarningEmitter = (type: string, guard: string, inputs: Record<string, unknown>) => void;
-let _activeLayoutWarningEmitter: LayoutWarningEmitter | undefined;
-
-export function setActiveLayoutWarningEmitter(fn: LayoutWarningEmitter | undefined): void {
-  _activeLayoutWarningEmitter = fn;
-}
-
-/**
- * Exported so debug-infra D1 probes at layout-semantic guards that have
- * physically moved into `src/runtime/geometry/**` (Slice 2a+ of refactor/05)
- * can continue to emit through the same `setActiveLayoutWarningEmitter`
- * pipeline as the remaining in-facet probes. The emit surface is unchanged;
- * only the call-site location moved.
- */
-export function emitLayoutGuardWarning(
-  guard: string,
-  inputs: Record<string, unknown>,
-): void {
-  _activeLayoutWarningEmitter?.(`layout.guard.return-empty`, guard, inputs);
-}
+export {
+  emitLayoutGuardWarning,
+  setActiveLayoutWarningEmitter,
+  type LayoutWarningEmitter,
+} from "../diagnostics/layout-guard-warning.ts";
 
 // ---------------------------------------------------------------------------
 // Public read model types (shape-stable, cloned at the facet boundary)
@@ -151,6 +138,7 @@ export interface PublicLayoutDivergence {
   message: string;
   regionKinds?: readonly RuntimePageRegion["kind"][];
   fragmentIds?: readonly string[];
+  objectIds?: readonly string[];
 }
 
 export interface PublicPageFrame {
@@ -159,6 +147,7 @@ export interface PublicPageFrame {
   pageIndex: number;
   sectionIndex: number;
   displayPageNumber: number;
+  completeness: RuntimePageFrame["completeness"];
   physicalBoundsTwips: PublicTwipsRect;
   divergenceIds: readonly string[];
   signature: string;
@@ -168,6 +157,42 @@ export interface PublicPageFrame {
     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;
+  resolvedFields: readonly PublicResolvedStoryField[];
+  anchoredObjects: readonly PublicStoryAnchoredObject[];
+  measuredFrameHeightTwips: number;
+  signature: string;
+}
+
+export interface PublicResolvedStoryField {
+  fieldId: string;
+  family: string;
+  displayText: string;
+}
+
+export interface PublicStoryAnchoredObject {
+  objectId: string;
+  sourceType: RuntimeStoryAnchoredObject["sourceType"];
+  display: RuntimeStoryAnchoredObject["display"];
+  wrapMode?: RuntimeStoryAnchoredObject["wrapMode"];
+  extentTwips?: {
+    widthTwips: number;
+    heightTwips: number;
+  };
+  relationshipIds?: readonly string[];
+  mediaIds?: readonly string[];
+  preserveOnly: boolean;
+  divergenceIds: readonly string[];
 }
 
 export interface PublicPageNode {
@@ -265,9 +290,11 @@ export interface PublicBlockFragment {
   };
   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
@@ -1473,11 +1500,64 @@ function toPublicPageFrame(frame: RuntimePageFrame): PublicPageFrame {
     pageIndex: frame.pageIndex,
     sectionIndex: frame.sectionIndex,
     displayPageNumber: frame.displayPageNumber,
+    completeness: frame.completeness,
     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 } : {}),
+    resolvedFields: story.resolvedFields.map(toPublicResolvedStoryField),
+    anchoredObjects: story.anchoredObjects.map(toPublicStoryAnchoredObject),
+    measuredFrameHeightTwips: story.measuredFrameHeightTwips,
+    signature: story.signature,
+  };
+}
+
+function toPublicResolvedStoryField(
+  field: RuntimePageFrame["pageLocalStories"][number]["resolvedFields"][number],
+): PublicResolvedStoryField {
+  return {
+    fieldId: field.fieldId,
+    family: field.family,
+    displayText: field.displayText,
+  };
+}
+
+function toPublicStoryAnchoredObject(
+  object: RuntimeStoryAnchoredObject,
+): PublicStoryAnchoredObject {
+  return {
+    objectId: object.objectId,
+    sourceType: object.sourceType,
+    display: object.display,
+    ...(object.wrapMode !== undefined ? { wrapMode: object.wrapMode } : {}),
+    ...(object.extentTwips
+      ? {
+          extentTwips: {
+            widthTwips: object.extentTwips.widthTwips,
+            heightTwips: object.extentTwips.heightTwips,
+          },
+        }
+      : {}),
+    ...(object.relationshipIds ? { relationshipIds: [...object.relationshipIds] } : {}),
+    ...(object.mediaIds ? { mediaIds: [...object.mediaIds] } : {}),
+    preserveOnly: object.preserveOnly,
+    divergenceIds: [...object.divergenceIds],
   };
 }
 
@@ -1492,6 +1572,7 @@ function toPublicLayoutDivergence(
     message: divergence.message,
     ...(divergence.regionKinds !== undefined ? { regionKinds: [...divergence.regionKinds] } : {}),
     ...(divergence.fragmentIds !== undefined ? { fragmentIds: [...divergence.fragmentIds] } : {}),
+    ...(divergence.objectIds !== undefined ? { objectIds: [...divergence.objectIds] } : {}),
   };
 }
 
@@ -1556,6 +1637,9 @@ function toPublicBlockFragment(
     ...(fragment.continuation !== undefined
       ? { continuation: cloneContinuationCursor(fragment.continuation) }
       : {}),
+    ...(fragment.layoutObject !== undefined
+      ? { layoutObject: cloneFragmentLayoutObject(fragment.layoutObject) }
+      : {}),
   };
 }
 
@@ -1572,10 +1656,66 @@ function cloneContinuationCursor(
     ...cursor,
     rowRange: { ...cursor.rowRange },
     repeatedHeaderRowIndexes: [...cursor.repeatedHeaderRowIndexes],
+    ...(cursor.splitRowCarry
+      ? { splitRowCarry: cursor.splitRowCarry.map((carry) => ({ ...carry })) }
+      : {}),
     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] }
+      : {}),
+    ...(layoutObject.fieldRegions !== undefined
+      ? {
+          fieldRegions: layoutObject.fieldRegions.map((region) => ({
+            ...region,
+            ...(region.sourceRef !== undefined ? { sourceRef: { ...region.sourceRef } } : {}),
+            ...(region.fieldEvidence !== undefined
+              ? {
+                  fieldEvidence: {
+                    ...region.fieldEvidence,
+                    ...(region.fieldEvidence.sourceRef !== undefined
+                      ? { sourceRef: { ...region.fieldEvidence.sourceRef } }
+                      : {}),
+                  },
+                }
+              : {}),
+          })),
+        }
+      : {}),
+    ...(layoutObject.numbering !== undefined
+      ? { numbering: cloneNumberingLayoutFacts(layoutObject.numbering) }
+      : {}),
+    ...(layoutObject.numberingRows !== undefined
+      ? { numberingRows: layoutObject.numberingRows.map(cloneNumberingLayoutFacts) }
+      : {}),
+  };
+}
+
+function cloneNumberingLayoutFacts(
+  numbering: NonNullable<NonNullable<RuntimeBlockFragment["layoutObject"]>["numbering"]>,
+): NonNullable<NonNullable<RuntimeBlockFragment["layoutObject"]>["numbering"]> {
+  return {
+    ...numbering,
+    ...(numbering.markerLane !== undefined
+      ? { markerLane: { ...numbering.markerLane } }
+      : {}),
+    ...(numbering.textColumn !== undefined
+      ? { textColumn: { ...numbering.textColumn } }
+      : {}),
+    ...(numbering.tabStops !== undefined
+      ? { tabStops: numbering.tabStops.map((tab) => ({ ...tab })) }
+      : {}),
+  };
+}
+
 function toPublicLineBox(box: RuntimeLineBox): PublicLineBox {
   return {
     fragmentId: box.fragmentId,
@@ -1824,10 +1964,8 @@ function findPageForOffsetAndStory(
 // `src/runtime/geometry/project-anchors.ts` in refactor/05 Slice 2b. The
 // facet's `getLineBoxes` / `getScopeRailSegments` / `getAllScopeRailSegments`
 // / `getAllScopeCardModels` methods above now import from there. The D1
-// `emitLayoutGuardWarning` probes (including the
-// `collectScopeRailSegmentsForQuery` null-input probe) are ported alongside
-// via the exported `emitLayoutGuardWarning` symbol — they continue to
-// fire through `setActiveLayoutWarningEmitter`.
+// `emitLayoutGuardWarning` probes continue to fire through the shared
+// diagnostics helper behind `setActiveLayoutWarningEmitter`.
 //
 // Hit-test (`resolveHitTest`, `hitTestRegion`, `containsPoint`) and
 // anchor-rect resolution (`resolveAnchorRects`) were moved in Slice 2a.

package/src/runtime/layout/table-row-continuation-contract.ts

@@ -0,0 +1,107 @@
+export interface TableRowRangeContract {
+  readonly pageIndex?: number;
+  readonly pageNumber?: number;
+  readonly rowRange: {
+    readonly from: number;
+    readonly to: number;
+    readonly totalRows: number;
+  };
+}
+
+export interface TableSplitRowContinuation {
+  readonly rowIndex: number;
+  readonly fromPageIndex?: number;
+  readonly toPageIndex?: number;
+  readonly fromPageNumber?: number;
+  readonly toPageNumber?: number;
+}
+
+export interface TableSplitRowCarry {
+  readonly rowIndex: number;
+  readonly continuesFromPreviousPage: boolean;
+  readonly continuesToNextPage: boolean;
+}
+
+/**
+ * Detect Word-style row continuations from adjacent page-local row ranges.
+ *
+ * Runtime table slices were initially row-boundary-only, so adjacent ranges
+ * looked like [0, 8), [8, 10). Word can split a row across the page boundary,
+ * which appears as an intentional overlap such as [0, 8), [7, 10). This helper
+ * keeps that contract explicit for D-8 table-pagination evidence and future
+ * split-row rendering work.
+ */
+export function collectSplitRowContinuations(
+  ranges: readonly TableRowRangeContract[],
+): TableSplitRowContinuation[] {
+  const continuations: TableSplitRowContinuation[] = [];
+  const seen = new Set<string>();
+
+  for (let index = 1; index < ranges.length; index += 1) {
+    const previous = ranges[index - 1]!;
+    const current = ranges[index]!;
+    const overlapFrom = Math.max(previous.rowRange.from, current.rowRange.from);
+    const overlapTo = Math.min(previous.rowRange.to, current.rowRange.to);
+    for (let rowIndex = overlapFrom; rowIndex < overlapTo; rowIndex += 1) {
+      const key = `${rowIndex}:${previous.pageIndex ?? ""}:${current.pageIndex ?? ""}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      continuations.push({
+        rowIndex,
+        ...(previous.pageIndex !== undefined ? { fromPageIndex: previous.pageIndex } : {}),
+        ...(current.pageIndex !== undefined ? { toPageIndex: current.pageIndex } : {}),
+        ...(previous.pageNumber !== undefined ? { fromPageNumber: previous.pageNumber } : {}),
+        ...(current.pageNumber !== undefined ? { toPageNumber: current.pageNumber } : {}),
+      });
+    }
+  }
+
+  return continuations;
+}
+
+export function collectSplitRowCarryForPage(
+  ranges: readonly TableRowRangeContract[],
+  pageRangeIndex: number,
+): TableSplitRowCarry[] {
+  const current = ranges[pageRangeIndex];
+  if (!current) return [];
+
+  const rows = new Map<number, TableSplitRowCarry>();
+  const addRows = (
+    from: number,
+    to: number,
+    direction: "fromPrevious" | "toNext",
+  ): void => {
+    for (let rowIndex = from; rowIndex < to; rowIndex += 1) {
+      const prior = rows.get(rowIndex);
+      rows.set(rowIndex, {
+        rowIndex,
+        continuesFromPreviousPage:
+          direction === "fromPrevious" || prior?.continuesFromPreviousPage === true,
+        continuesToNextPage:
+          direction === "toNext" || prior?.continuesToNextPage === true,
+      });
+    }
+  };
+
+  const previous = ranges[pageRangeIndex - 1];
+  if (previous) {
+    addRows(
+      Math.max(previous.rowRange.from, current.rowRange.from),
+      Math.min(previous.rowRange.to, current.rowRange.to),
+      "fromPrevious",
+    );
+  }
+
+  const next = ranges[pageRangeIndex + 1];
+  if (next) {
+    addRows(
+      Math.max(current.rowRange.from, next.rowRange.from),
+      Math.min(current.rowRange.to, next.rowRange.to),
+      "toNext",
+    );
+  }
+
+  return [...rows.values()].sort((a, b) => a.rowIndex - b.rowIndex);
+}
+

package/src/runtime/layout/table-row-split.ts

@@ -51,6 +51,9 @@ import { __resolveCellWidth } from "./paginated-layout-engine.ts";
 
 const MIN_ROW_HEIGHT_TWIPS = 240;
 const TABLE_ROW_PADDING_TWIPS = 120;
+const AUTO_ROW_CALIBRATION_MIN_RESOLVED_TWIPS = 1440;
+const AUTO_ROW_CALIBRATION_MIN_DELTA_TWIPS = 720;
+const AUTO_ROW_CALIBRATION_MIN_RATIO = 1.75;
 
 export interface MeasureTableRowHeightsInput {
   block: Extract<SurfaceBlockSnapshot, { kind: "table" }>;
@@ -58,7 +61,12 @@ export interface MeasureTableRowHeightsInput {
   measurementProvider?: LayoutMeasurementProvider;
   defaultTabInterval?: number;
   themeFonts?: LayoutThemeFonts;
-  contentMode?: "legacy-min" | "resolved";
+  contentMode?: "legacy-min" | "resolved" | "auto-height-calibrated";
+}
+
+export interface TableRowHeightProfile {
+  readonly heights: readonly number[];
+  readonly calibratedAutoRowIndexes: readonly number[];
 }
 
 /**
@@ -74,6 +82,12 @@ export interface MeasureTableRowHeightsInput {
 export function measureTableRowHeights(
   input: MeasureTableRowHeightsInput,
 ): number[] {
+  return [...measureTableRowHeightProfile(input).heights];
+}
+
+export function measureTableRowHeightProfile(
+  input: MeasureTableRowHeightsInput,
+): TableRowHeightProfile {
   const {
     block,
     columnWidth,
@@ -83,66 +97,109 @@ export function measureTableRowHeights(
     contentMode = "legacy-min",
   } = input;
   const heights: number[] = [];
+  const calibratedAutoRowIndexes: number[] = [];
 
   const totalGridTwips = block.gridColumns.reduce((sum, w) => sum + w, 0);
   const gridScale =
     totalGridTwips > 0 && columnWidth > 0 ? columnWidth / totalGridTwips : 1;
 
-  for (const row of block.rows) {
+  for (let rowIndex = 0; rowIndex < block.rows.length; rowIndex += 1) {
+    const row = block.rows[rowIndex]!;
     const explicitHeight = row.height ?? 0;
     const heightRule = row.heightRule ?? "auto";
     const gridBefore = row.gridBefore ?? 0;
 
-    let contentHeight = MIN_ROW_HEIGHT_TWIPS;
-    let columnCursor = gridBefore;
+    const measureContentHeight = (mode: "legacy-min" | "resolved"): number => {
+      let contentHeight = MIN_ROW_HEIGHT_TWIPS;
+      let columnCursor = gridBefore;
 
-    for (const cell of row.cells) {
-      const span = Math.max(1, cell.colspan ?? 1);
-      const cellWidth = __resolveCellWidth(
-        block.gridColumns,
-        columnCursor,
-        span,
-        columnWidth,
-        gridScale,
-      );
-      columnCursor += span;
+      for (const cell of row.cells) {
+        const span = Math.max(1, cell.colspan ?? 1);
+        const cellWidth = __resolveCellWidth(
+          block.gridColumns,
+          columnCursor,
+          span,
+          columnWidth,
+          gridScale,
+        );
+        columnCursor += span;
 
-      if (cell.verticalMerge === "continue") continue;
+        if (cell.verticalMerge === "continue") continue;
 
-      let cellContentHeight = 0;
-      for (const child of cell.content) {
-        if (child.kind === "paragraph") {
-          cellContentHeight += contentMode === "resolved"
-            ? measureParagraphStandaloneHeight(
-                child,
-                cellWidth,
-                measurementProvider,
-                defaultTabInterval,
-                themeFonts,
-              )
-            : MIN_ROW_HEIGHT_TWIPS;
-        } else {
-          cellContentHeight += MIN_ROW_HEIGHT_TWIPS;
+        let cellContentHeight = 0;
+        for (const child of cell.content) {
+          if (child.kind === "paragraph") {
+            cellContentHeight += mode === "resolved"
+              ? measureParagraphStandaloneHeight(
+                  child,
+                  cellWidth,
+                  measurementProvider,
+                  defaultTabInterval,
+                  themeFonts,
+                )
+              : MIN_ROW_HEIGHT_TWIPS;
+          } else {
+            cellContentHeight += MIN_ROW_HEIGHT_TWIPS;
+          }
         }
+        contentHeight = Math.max(contentHeight, cellContentHeight + TABLE_ROW_PADDING_TWIPS);
       }
-      contentHeight = Math.max(contentHeight, cellContentHeight + TABLE_ROW_PADDING_TWIPS);
-    }
+
+      return contentHeight;
+    };
+
+    const legacyContentHeight = measureContentHeight("legacy-min");
+    const resolvedContentHeight = contentMode === "legacy-min"
+      ? legacyContentHeight
+      : measureContentHeight("resolved");
 
     let rowHeight: number;
     if (heightRule === "exact" && explicitHeight > 0) {
       rowHeight = explicitHeight;
     } else if (heightRule === "atLeast" && explicitHeight > 0) {
-      rowHeight = Math.max(explicitHeight, contentHeight);
+      rowHeight = Math.max(explicitHeight, resolvedContentHeight);
     } else if (explicitHeight > 0) {
-      rowHeight = Math.max(explicitHeight, contentHeight);
+      const legacyRowHeight = Math.max(explicitHeight, legacyContentHeight);
+      const resolvedRowHeight = Math.max(explicitHeight, resolvedContentHeight);
+      const shouldCalibrate =
+        contentMode === "auto-height-calibrated" &&
+        shouldUseResolvedAutoRowHeight(row, legacyRowHeight, resolvedRowHeight);
+      if (shouldCalibrate) calibratedAutoRowIndexes.push(rowIndex);
+      rowHeight = contentMode === "resolved" || shouldCalibrate
+        ? resolvedRowHeight
+        : legacyRowHeight;
     } else {
-      rowHeight = contentHeight;
+      const shouldCalibrate =
+        contentMode === "auto-height-calibrated" &&
+        shouldUseResolvedAutoRowHeight(row, legacyContentHeight, resolvedContentHeight);
+      if (shouldCalibrate) calibratedAutoRowIndexes.push(rowIndex);
+      rowHeight = contentMode === "resolved" || shouldCalibrate
+        ? resolvedContentHeight
+        : legacyContentHeight;
     }
 
     heights.push(Math.max(MIN_ROW_HEIGHT_TWIPS, rowHeight));
   }
 
-  return heights;
+  return {
+    heights: Object.freeze(heights),
+    calibratedAutoRowIndexes: Object.freeze(calibratedAutoRowIndexes),
+  };
+}
+
+function shouldUseResolvedAutoRowHeight(
+  row: Extract<SurfaceBlockSnapshot, { kind: "table" }>["rows"][number],
+  legacyHeight: number,
+  resolvedHeight: number,
+): boolean {
+  if ((row.heightRule ?? "auto") === "exact") return false;
+  if (row.cantSplit === true) return false;
+  const delta = resolvedHeight - legacyHeight;
+  return (
+    resolvedHeight >= AUTO_ROW_CALIBRATION_MIN_RESOLVED_TWIPS &&
+    delta >= AUTO_ROW_CALIBRATION_MIN_DELTA_TWIPS &&
+    resolvedHeight / Math.max(1, legacyHeight) >= AUTO_ROW_CALIBRATION_MIN_RATIO
+  );
 }
 
 /**

package/src/runtime/prerender/cache-envelope.ts

@@ -17,8 +17,8 @@ import type { RuntimePageGraph } from "../../model/layout/runtime-page-graph-typ
  * it, and the warm-path loader that rehydrates it.
  *
  * Load-time invariants checked by consumers before trusting the envelope:
- *   - `schemaVersion === LAYCACHE_SCHEMA_VERSION`  — bump invalidates
- *   - `engineVersion === LAYOUT_ENGINE_VERSION`    — bump invalidates
+ *   - `schemaVersion === LAYCACHE_SCHEMA_VERSION` — cache shape matches
+ *   - `engineVersion === LAYOUT_ENGINE_VERSION` — layout output matches
  *   - `graph.revision === 0`                       — canonical marker
  *
  * The envelope MUST be structured-clone-safe because IndexedDB and Plan B's

package/src/runtime/prerender/cache-key.ts

@@ -14,11 +14,12 @@
  *                                  metric source. "empirical-backend" in
  *                                  Plan A; a real font-derived string after
  *                                  Phase 8.
- *   3. engineVersion             — LAYOUT_ENGINE_VERSION from src/runtime/
- *                                  layout/layout-engine-version.ts. Bumped by
- *                                  CI gate on any layout/render shape change.
+ *   3. engineVersion             — LAYOUT_ENGINE_VERSION from
+ *                                  src/runtime/layout/layout-engine-version.ts.
+ *                                  Bumped when layout output or cache-key
+ *                                  semantics change for the same input.
  *   4. schemaVersion             — LAYCACHE_SCHEMA_VERSION for envelope
- *                                  format.
+ *                                  format and cached payload shape.
  *   5. canonicalDocumentHash     — (Plan B, schema v2) sha256 of sorted-keys
  *                                  JSON of the CanonicalDocument. Catches
  *                                  non-structural mutations (styles,

package/src/runtime/prerender/customxml-cache.ts

@@ -222,4 +222,3 @@ function isValidCacheEnvelope(value: unknown): value is CacheEnvelope {
   }
   return true;
 }
-

package/src/runtime/render/render-kernel.ts

@@ -14,7 +14,7 @@
  */
 
 import { MAIN_STORY_TARGET } from "../../core/selection/mapping.ts";
-import { recordPerfSample } from "../../ui-tailwind/editor-surface/perf-probe.ts";
+import { recordPerfSample } from "../telemetry/perf-probe.ts";
 import { storyTargetKey } from "../story-targeting.ts";
 import type { EditorStoryTarget } from "../../api/public-types";
 import type {