@beyondwork/docx-react-component 1.0.106 → 1.0.109

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 {

package/src/runtime/revision-runtime.ts

@@ -1,15 +1,25 @@
+import type { EditorStoryTarget } from "../api/public-types.ts";
 import type { CanonicalDocumentEnvelope } from "../core/state/editor-state.ts";
 import {
   getReviewCommandIntent,
   isSingleRevisionReviewCommand,
   type ReviewCommand,
 } from "../core/commands/review-commands.ts";
-import type { TransactionMapping } from "../core/selection/mapping.ts";
+import {
+  MAIN_STORY_TARGET,
+  storyTargetsEqual,
+  type TransactionMapping,
+} from "../core/selection/mapping.ts";
 import {
   applyRevisionAction,
+  type ApplyRevisionActionResult,
   type RevisionActionOutcome,
 } from "../review/store/revision-actions.ts";
-import { type RevisionStore } from "../review/store/revision-store.ts";
+import {
+  createRevisionStore,
+  type RevisionStore,
+} from "../review/store/revision-store.ts";
+import { getStoryBlocks, replaceStoryBlocks } from "./story-targeting.ts";
 
 export interface RevisionRuntimeState {
   document: CanonicalDocumentEnvelope;
@@ -30,7 +40,12 @@ export interface RevisionRuntimeCommandEffects {
 
 export interface RevisionRuntimeCommandResult extends RevisionRuntimeState {
   outcomes: RevisionActionOutcome[];
-  mappings: Array<{ revisionId: string; mapping: TransactionMapping; steps: number }>;
+  mappings: Array<{
+    revisionId: string;
+    mapping: TransactionMapping;
+    steps: number;
+    storyTarget: EditorStoryTarget;
+  }>;
   effects: RevisionRuntimeCommandEffects;
 }
 
@@ -44,30 +59,31 @@ export function applyRevisionRuntimeCommand(
   const revisionIds = expandLinkedMovePartners(rawRevisionIds, options.state.store);
 
   const outcomes: RevisionActionOutcome[] = [];
-  const mappings: Array<{ revisionId: string; mapping: TransactionMapping; steps: number }> = [];
+  const mappings: RevisionRuntimeCommandResult["mappings"] = [];
   const appliedRevisionIds: string[] = [];
   const detachedRevisionIds = new Set<string>();
 
   let state = options.state;
 
   for (const revisionId of revisionIds) {
+    const revision = state.store.revisions[revisionId];
+    const storyTarget = getRevisionStoryTarget(revision);
+    const scopedState = createStoryScopedRevisionState(state, storyTarget);
     const result = applyRevisionAction({
-      document: state.document,
-      store: state.store,
+      document: scopedState.document,
+      store: scopedState.store,
       revisionId,
       intent: getReviewCommandIntent(options.command),
       timestamp: options.timestamp,
     });
 
-    state = {
-      document: result.document,
-      store: result.store,
-    };
+    state = mergeStoryScopedRevisionResult(state, storyTarget, scopedState, result);
     outcomes.push(result.outcome);
     mappings.push({
       revisionId,
       mapping: result.mapping,
       steps: result.mapping.steps.length,
+      storyTarget,
     });
 
     if (result.outcome.kind === "applied") {
@@ -94,6 +110,92 @@ export function applyRevisionRuntimeCommand(
   };
 }
 
+interface StoryScopedRevisionState extends RevisionRuntimeState {
+  storyRevisionIds: readonly string[];
+}
+
+function createStoryScopedRevisionState(
+  state: RevisionRuntimeState,
+  storyTarget: EditorStoryTarget,
+): StoryScopedRevisionState {
+  if (storyTargetsEqual(storyTarget, MAIN_STORY_TARGET)) {
+    return {
+      ...state,
+      storyRevisionIds: Object.keys(state.store.revisions),
+    };
+  }
+
+  const storyRevisionIds = Object.entries(state.store.revisions)
+    .filter(([, revision]) =>
+      storyTargetsEqual(getRevisionStoryTarget(revision), storyTarget)
+    )
+    .map(([revisionId]) => revisionId);
+  const storyRevisions = Object.fromEntries(
+    storyRevisionIds.map((revisionId) => [
+      revisionId,
+      state.store.revisions[revisionId]!,
+    ]),
+  );
+
+  return {
+    document: {
+      ...state.document,
+      content: {
+        ...state.document.content,
+        children: [...getStoryBlocks(state.document, storyTarget)],
+      },
+    },
+    store: createRevisionStore(storyRevisions),
+    storyRevisionIds,
+  };
+}
+
+function mergeStoryScopedRevisionResult(
+  previousState: RevisionRuntimeState,
+  storyTarget: EditorStoryTarget,
+  scopedState: StoryScopedRevisionState,
+  result: ApplyRevisionActionResult,
+): RevisionRuntimeState {
+  if (storyTargetsEqual(storyTarget, MAIN_STORY_TARGET)) {
+    return {
+      document: result.document,
+      store: result.store,
+    };
+  }
+
+  const nextStore = createRevisionStore({
+    ...previousState.store.revisions,
+    ...Object.fromEntries(
+      scopedState.storyRevisionIds
+        .filter((revisionId) => result.store.revisions[revisionId])
+        .map((revisionId) => [
+          revisionId,
+          result.store.revisions[revisionId]!,
+        ]),
+    ),
+  });
+
+  return {
+    document: replaceStoryBlocks(
+      {
+        ...previousState.document,
+        updatedAt: result.document.updatedAt,
+      },
+      storyTarget,
+      result.document.content.children,
+    ),
+    store: nextStore,
+  };
+}
+
+function getRevisionStoryTarget(
+  revision: RevisionStore["revisions"][string] | undefined,
+): EditorStoryTarget {
+  return revision?.metadata.storyTarget
+    ? { ...revision.metadata.storyTarget }
+    : MAIN_STORY_TARGET;
+}
+
 function expandLinkedMovePartners(
   revisionIds: readonly string[],
   store: RevisionStore,

package/src/runtime/scopes/_scope-dependencies.ts

@@ -34,6 +34,7 @@ export type {
   InteractionGuardSnapshot,
   TextFormattingDirective,
   WorkflowBlockedCommandReason,
+  WorkflowEventOrigin,
   WorkflowMetadataEntry,
   WorkflowMetadataSnapshot,
   WorkflowOverlay,

package/src/runtime/scopes/action-validation.ts

@@ -63,6 +63,7 @@ import {
 import { resolveScopeRange } from "./scope-range.ts";
 import type {
   ReplacementScope,
+  ScopeActionPosture,
   ScopeActionOperationKind,
   SemanticScope,
   ValidationApproval,
@@ -144,8 +145,6 @@ function inferActionId(
     case "insert-before":
     case "insert-after":
       return "generate_text";
-    case "split":
-      return "rewrite_paragraph";
     case "annotate":
       return "suggest_comment_response";
   }
@@ -296,6 +295,17 @@ function collectPreservationVerdict(
 ): void {
   const { document, scope, positionMap } = inputs;
   if (inputs.skipPreservation === true) return;
+  // Insert-before / insert-after lower to collapsed insertions at the
+  // effective scope edge. They do not replace or delete the scope's
+  // current contents, so preserve-only payloads and nested markers
+  // inside the scope are not at risk in the same way they are for
+  // `replace`.
+  if (
+    inputs.operation === "insert-before" ||
+    inputs.operation === "insert-after"
+  ) {
+    return;
+  }
   if (!document) return;
   const pm = positionMap ?? buildScopePositionMap(document);
   const range = inputs.enumeratedScope
@@ -397,6 +407,15 @@ function collectPolicyVerdict(
   return undefined;
 }
 
+function validationPosture(
+  blockedReasons: readonly string[],
+  warnings: readonly ValidationIssue[],
+): ScopeActionPosture {
+  if (blockedReasons.length > 0) return "hard-refusal";
+  if (warnings.length > 0) return "warn-and-proceed";
+  return "supported";
+}
+
 /**
  * Compose a single validation verdict for a proposed scope replacement.
  * Synchronous, deterministic, free of side effects. Safe to call in hot
@@ -420,6 +439,7 @@ export function composeScopeValidation(
   const safe = blockedReasons.length === 0;
   return {
     safe,
+    posture: validationPosture(blockedReasons, warnings),
     blockedReasons: Object.freeze([...blockedReasons]),
     warnings: Object.freeze([...warnings]),
     ...(approval ? { approval } : {}),