@beyondwork/docx-react-component 1.0.53 → 1.0.54

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

@@ -81,7 +81,7 @@ import {
 export type LayoutInvalidationReason =
   | { kind: "content-edit"; from: number; to: number }
   | { kind: "section-change"; sectionIndex: number }
-  | { kind: "styles-change" }
+  | { kind: "styles-change"; dirtyStyleIds?: readonly string[] }
   | { kind: "theme-change" }
   | { kind: "numbering-change"; numberingInstanceId?: string }
   | { kind: "field-refresh"; family?: string }
@@ -416,28 +416,137 @@ export function buildPageStackFromWithSplits(
   resumeAt: { startPageIndex: number; startOffset: number },
   measurementProvider?: LayoutMeasurementProvider,
 ): PageStackResultWithSplits {
-  void resumeAt.startOffset;
-  const full = buildPageStackWithSplits(
-    document,
-    sections as ResolvedDocumentSection[],
-    mainSurface,
-    measurementProvider,
+  const startOffset = resumeAt.startOffset;
+  const dirtyPageNumberOffset = Math.max(0, resumeAt.startPageIndex);
+
+  // Fast path: offset at document start → full paginate is identical.
+  if (startOffset <= 0) {
+    return buildPageStackWithSplits(
+      document,
+      sections as ResolvedDocumentSection[],
+      mainSurface,
+      measurementProvider,
+    );
+  }
+
+  // Find the first section that contains or starts after startOffset.
+  const firstDirtySectionIdx = (sections as ResolvedDocumentSection[]).findIndex(
+    (s) => s.end > startOffset,
   );
-  const startIndex = Math.max(0, resumeAt.startPageIndex);
-  const tailPages = full.pages.slice(startIndex);
-  const tailSplits = new Map<string, ParagraphLineSlice[]>();
-  for (const [blockId, slices] of full.splits.byBlockId) {
-    const tail = slices.filter((s) => s.pageIndex >= startIndex);
-    if (tail.length > 0) tailSplits.set(blockId, tail);
+  if (firstDirtySectionIdx < 0) {
+    // All sections end before the dirty offset — nothing to re-paginate.
+    return buildPageStackWithSplits(
+      document,
+      sections as ResolvedDocumentSection[],
+      mainSurface,
+      measurementProvider,
+    );
   }
-  const tailTableSplits = new Map<string, TableRowSlice[]>();
-  for (const [blockId, slices] of full.splits.tablesByBlockId) {
-    const tail = slices.filter((s) => s.pageIndex >= startIndex);
-    if (tail.length > 0) tailTableSplits.set(blockId, tail);
+
+  // Safety guard: if any block straddles the section boundary (to > startOffset
+  // but from < section.start), we cannot safely skip without reconstructing
+  // carry-over state — fall back to full paginate to avoid silent correctness loss.
+  const dirtySectionStart = (sections as ResolvedDocumentSection[])[firstDirtySectionIdx]!.start;
+  const straddling = mainSurface.blocks.some(
+    (b) => b.from < dirtySectionStart && b.to > startOffset,
+  );
+  // When the dirty section is section 0, there is nothing to skip — fall
+  // back to the full-build + tail-slice path so page startOffsets are
+  // correct (the section-skip path shifts only pageIndex, not startOffset,
+  // which would produce phantom pages when spliceGraph prepends page 0).
+  if (straddling || firstDirtySectionIdx === 0) {
+    const full = buildPageStackWithSplits(
+      document,
+      sections as ResolvedDocumentSection[],
+      mainSurface,
+      measurementProvider,
+    );
+    const tailPages = full.pages.slice(dirtyPageNumberOffset);
+    const tailSplits = new Map<string, ParagraphLineSlice[]>();
+    for (const [blockId, slices] of full.splits.byBlockId) {
+      const tail = slices.filter((s) => s.pageIndex >= dirtyPageNumberOffset);
+      if (tail.length > 0) tailSplits.set(blockId, tail);
+    }
+    const tailTableSplits = new Map<string, TableRowSlice[]>();
+    for (const [blockId, slices] of full.splits.tablesByBlockId) {
+      const tail = slices.filter((s) => s.pageIndex >= dirtyPageNumberOffset);
+      if (tail.length > 0) tailTableSplits.set(blockId, tail);
+    }
+    return {
+      pages: tailPages,
+      splits: { byBlockId: tailSplits, tablesByBlockId: tailTableSplits },
+    };
   }
+
+  // Section-level skip: paginate only the dirty sections onward (only
+  // reached when firstDirtySectionIdx > 0).
+  const dirtySections = (sections as ResolvedDocumentSection[]).slice(firstDirtySectionIdx);
+  const dirtyBlockSet = new Set(
+    mainSurface.blocks
+      .filter((b) => b.from >= dirtySectionStart)
+      .map((b) => b.blockId),
+  );
+  const dirtySurface: EditorSurfaceSnapshot = {
+    ...mainSurface,
+    blocks: mainSurface.blocks.filter((b) => dirtyBlockSet.has(b.blockId)),
+  };
+
+  const tailResult = buildPageStackWithSplits(
+    document,
+    dirtySections,
+    dirtySurface,
+    measurementProvider,
+  );
+
+  // Shift global page indices on all returned pages and splits so they align
+  // with the global page graph (the caller's spliceGraph prepends the head).
+  const shiftedPages = tailResult.pages.map((p) => ({
+    ...p,
+    pageIndex: p.pageIndex + dirtyPageNumberOffset,
+  }));
+  const shiftedSplits: BlockSplits = {
+    byBlockId: new Map(
+      Array.from(tailResult.splits.byBlockId.entries()).map(([id, slices]) => [
+        id,
+        slices.map((s) => ({ ...s, pageIndex: s.pageIndex + dirtyPageNumberOffset })),
+      ]),
+    ),
+    tablesByBlockId: new Map(
+      Array.from(tailResult.splits.tablesByBlockId.entries()).map(([id, slices]) => [
+        id,
+        slices.map((s) => ({ ...s, pageIndex: s.pageIndex + dirtyPageNumberOffset })),
+      ]),
+    ),
+  };
+  // Shift note-allocation page indices if present.
+  const shiftedNoteAllocs =
+    tailResult.noteAllocationsByPageIndex && tailResult.noteAllocationsByPageIndex.size > 0
+      ? new Map(
+          Array.from(tailResult.noteAllocationsByPageIndex.entries()).map(([pi, allocs]) => [
+            pi + dirtyPageNumberOffset,
+            allocs,
+          ]),
+        )
+      : undefined;
+  const shiftedNoteFragments =
+    tailResult.noteFragmentsByPageIndex && tailResult.noteFragmentsByPageIndex.size > 0
+      ? new Map(
+          Array.from(tailResult.noteFragmentsByPageIndex.entries()).map(([pi, frags]) => [
+            pi + dirtyPageNumberOffset,
+            frags,
+          ]),
+        )
+      : undefined;
+
   return {
-    pages: tailPages,
-    splits: { byBlockId: tailSplits, tablesByBlockId: tailTableSplits },
+    pages: shiftedPages,
+    splits: shiftedSplits,
+    ...(shiftedNoteAllocs !== undefined
+      ? { noteAllocationsByPageIndex: shiftedNoteAllocs }
+      : {}),
+    ...(shiftedNoteFragments !== undefined
+      ? { noteFragmentsByPageIndex: shiftedNoteFragments }
+      : {}),
   };
 }
 

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

@@ -109,6 +109,7 @@ export function projectSurfaceBlocksToPageFragments(
       from: block.from,
       to: block.to,
       heightTwips: estimateBlockHeightFromSpan(block),
+      ...deriveStyleMetadata(block),
       kind: "whole",
     };
 
@@ -138,6 +139,7 @@ function emitSlicedParagraph(
       from: block.from,
       to: block.to,
       heightTwips: estimateSliceHeightFromLines(slice.lineRange),
+      ...deriveStyleMetadata(block),
       kind: "paragraph-slice",
       paragraphLineRange: slice.lineRange,
     };
@@ -178,6 +180,7 @@ function emitSlicedTable(
       from: block.from,
       to: block.to,
       heightTwips: estimateSliceHeightFromRows(slice.rowRange),
+      ...deriveStyleMetadata(block),
       kind: "table-slice",
       tableRowRange: slice.rowRange,
     };
@@ -223,3 +226,27 @@ function estimateBlockHeightFromSpan(block: SurfaceBlockSnapshot): number {
   const lines = Math.max(1, Math.ceil(span / 80));
   return lines * 240;
 }
+
+/**
+ * Slice 5 — extract style metadata from a surface block for use in
+ * bounded invalidation. `resolvedStyleChainRef` is the block's styleId
+ * (paragraphs and tables only); `numberingInstanceId` comes from the
+ * block's list-instance (paragraphs only). Both fields are optional and
+ * absent when the block carries no style or numbering data.
+ */
+function deriveStyleMetadata(
+  block: SurfaceBlockSnapshot,
+): Pick<FragmentWithoutPageId, "resolvedStyleChainRef" | "numberingInstanceId"> {
+  const styleId =
+    block.kind === "paragraph" || block.kind === "table"
+      ? (block.styleId ?? undefined)
+      : undefined;
+  const numberingInstanceId =
+    block.kind === "paragraph"
+      ? (block.numbering?.numberingInstanceId ?? undefined)
+      : undefined;
+  return {
+    ...(styleId !== undefined ? { resolvedStyleChainRef: styleId } : {}),
+    ...(numberingInstanceId !== undefined ? { numberingInstanceId } : {}),
+  };
+}

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

@@ -560,6 +560,15 @@ export interface WordReviewEditorLayoutFacet {
     pageIndex: number,
   ): import("./table-render-plan.ts").TableRenderPlan | null;
 
+  /**
+   * Returns the Y offset (in twips from the top of the page body) where this
+   * table fragment starts on the given page. Computed by summing
+   * `heightTwips` of all body fragments with `orderInRegion` less than the
+   * table fragment's order. Returns `null` when the block is not found on
+   * the specified page.
+   */
+  getTableBodyYOffsetOnPage(blockId: string, pageIndex: number): number | null;
+
   // Fields ---------------------------------------------------------------
   getDirtyFieldFamilies(): readonly string[];
   getFieldDirtinessReport(): PublicFieldDirtinessReport;
@@ -1255,6 +1264,24 @@ export function createLayoutFacet(
       });
     },
 
+    getTableBodyYOffsetOnPage(blockId, pageIndex) {
+      const graph = currentGraph();
+      const pageNode = graph.pages.find(
+        (p) => p.pageIndex === pageIndex && !p.isBlankFiller,
+      );
+      if (!pageNode) return null;
+      const bodyFragmentIdSet = new Set(pageNode.regions.body.fragmentIds);
+      const bodyFragments = graph.fragments
+        .filter((f) => bodyFragmentIdSet.has(f.fragmentId))
+        .sort((a, b) => a.orderInRegion - b.orderInRegion);
+      let yOffset = 0;
+      for (const frag of bodyFragments) {
+        if (frag.blockId === blockId) return yOffset;
+        yOffset += frag.heightTwips;
+      }
+      return null;
+    },
+
     getDirtyFieldFamilies() {
       return engine.getDirtyFieldFamilies();
     },

package/src/runtime/render/render-frame-diff.ts

@@ -22,6 +22,7 @@ import type {
   RenderPage,
   RenderStoryRegion,
   DecorationIndex,
+  PageChromeReservations,
 } from "./render-frame-types.ts";
 
 // ---------------------------------------------------------------------------
@@ -46,6 +47,14 @@ export interface ChangedPageEntry {
      */
     changedBlockIds: readonly string[];
   }[];
+  /**
+   * R1: Set when the page's physical frame rect changed but no individual
+   * block regions changed. Consumers that iterate `regions` for targeted
+   * re-render targets must also honour this flag to avoid silently skipping
+   * pages whose geometry shifted without block-level changes (e.g. zoom
+   * change or page margin edit that shifts every page frame uniformly).
+   */
+  pageFrameChanged?: boolean;
 }
 
 export interface RenderFrameDiff {
@@ -110,10 +119,21 @@ export function diffRenderFrames(
       continue;
     }
     const regions = diffPage(prevPage, nextPage, prev.decorationIndex, next.decorationIndex);
-    if (regions.length === 0 && rectEquals(prevPage.frame, nextPage.frame)) {
+    // R1: track page-frame geometry changes independently of block regions.
+    const frameChanged = !rectEquals(prevPage.frame, nextPage.frame);
+    // R2: track chrome-reservation changes so chrome re-projection isn't skipped.
+    const reservationsChanged = !reservationsEqual(
+      prevPage.chromeReservations,
+      nextPage.chromeReservations,
+    );
+    if (regions.length === 0 && !frameChanged && !reservationsChanged) {
       unchangedPages.push(pageIndex);
     } else {
-      changedPages.push({ pageIndex, regions });
+      changedPages.push({
+        pageIndex,
+        regions,
+        ...(frameChanged ? { pageFrameChanged: true } : {}),
+      });
     }
   }
 
@@ -268,6 +288,22 @@ function decorationHashForBlock(
   return tokens.join("|");
 }
 
+// ---------------------------------------------------------------------------
+// Chrome reservations compare
+// ---------------------------------------------------------------------------
+
+// R2: Compare all five reservation fields so changes to rail/balloon lanes
+// or footnote area trigger changedPages, not unchangedPages.
+function reservationsEqual(a: PageChromeReservations, b: PageChromeReservations): boolean {
+  return (
+    a.railLaneTwips === b.railLaneTwips &&
+    a.balloonLaneTwips === b.balloonLaneTwips &&
+    a.footnoteAreaTwips === b.footnoteAreaTwips &&
+    a.pageFrameWidthPx === b.pageFrameWidthPx &&
+    a.pageFrameHeightPx === b.pageFrameHeightPx
+  );
+}
+
 // ---------------------------------------------------------------------------
 // Geometry compare
 // ---------------------------------------------------------------------------

package/src/ui/WordReviewEditor.tsx

@@ -782,7 +782,9 @@ export function __createWordReviewEditorRefBridge(
     clearWorkflowOverlay: () => {
       runtime.clearWorkflowOverlay();
     },
-    getWorkflowOverlay: () => clonePublicValue(runtime.getWorkflowOverlay()),
+    getWorkflowOverlay: () => {
+      return clonePublicValue(runtime.getWorkflowOverlay());
+    },
     setSharedWorkflowState: (state) => {
       runtime.setSharedWorkflowState(state === null ? null : clonePublicValue(state));
     },
@@ -1834,8 +1836,9 @@ export const WordReviewEditor = forwardRef<WordReviewEditorRef, WordReviewEditor
         clearWorkflowOverlay: () => {
           activeRuntime.clearWorkflowOverlay();
         },
-        getWorkflowOverlay: () =>
-          clonePublicValue(activeRuntime.getWorkflowOverlay()),
+        getWorkflowOverlay: () => {
+          return clonePublicValue(activeRuntime.getWorkflowOverlay());
+        },
         setSharedWorkflowState: (state) => {
           activeRuntime.setSharedWorkflowState(state === null ? null : clonePublicValue(state));
         },

package/src/ui/headless/comment-decoration-model.ts

@@ -77,7 +77,61 @@ export function getCommentRangeState(
   };
 }
 
-export type MarkupDisplay = "clean" | "simple" | "all";
+/**
+ * Markup display mode — controls how tracked changes and comments render.
+ *
+ * L6d.N2 widens the union to Word's 4-mode grammar (`"all-markup"`,
+ * `"simple-markup"`, `"no-markup"`, `"original"`) while keeping the
+ * legacy aliases `"clean" | "simple" | "all"` for backward compat with
+ * hosts that already pass the old values.  Callers that switch on this
+ * value should either:
+ *   - handle both sets of names (the decoration models do), or
+ *   - normalize via `normalizeMarkupDisplay()` before matching.
+ *
+ * New in 6d.N2:
+ *   - `"original"` — hide insertions entirely, render deletions as
+ *     plain body text.  Shows what the document looked like before the
+ *     current batch of tracked changes.
+ */
+export type MarkupDisplay =
+  | "all-markup"
+  | "simple-markup"
+  | "no-markup"
+  | "original"
+  // Legacy aliases — accepted on the public API; prefer the canonical names above.
+  | "clean"
+  | "simple"
+  | "all";
+
+/**
+ * Collapse legacy `MarkupDisplay` aliases to their canonical Word-grammar
+ * name:
+ *   - `"all"` → `"all-markup"`
+ *   - `"simple"` → `"simple-markup"`
+ *   - `"clean"` → `"no-markup"`
+ *   - `"original"` → `"original"` (identity)
+ *
+ * The two sets remain interchangeable inside the decoration models, but
+ * external surfaces (selector labels, telemetry, host events) should
+ * normalize first so Word's grammar is the single source of truth.
+ */
+export function normalizeMarkupDisplay(
+  value: MarkupDisplay,
+): "all-markup" | "simple-markup" | "no-markup" | "original" {
+  switch (value) {
+    case "all":
+    case "all-markup":
+      return "all-markup";
+    case "simple":
+    case "simple-markup":
+      return "simple-markup";
+    case "clean":
+    case "no-markup":
+      return "no-markup";
+    case "original":
+      return "original";
+  }
+}
 
 export function getCommentHighlightClass(
   model: CommentDecorationModel | undefined,
@@ -90,10 +144,11 @@ export function getCommentHighlightClass(
     return "";
   }
 
-  switch (markupDisplay) {
-    case "clean":
+  switch (normalizeMarkupDisplay(markupDisplay)) {
+    case "no-markup":
+    case "original":
       return state.hasActive ? "bg-comment-soft" : "";
-    case "simple":
+    case "simple-markup":
       if (state.hasActive) {
         return "underline decoration-comment decoration-2 underline-offset-4";
       }
@@ -101,7 +156,7 @@ export function getCommentHighlightClass(
         return "underline decoration-comment/60 decoration-1 underline-offset-4";
       }
       return "underline decoration-comment/40 decoration-1 underline-offset-4";
-    case "all":
+    case "all-markup":
       if (state.hasActive) {
         return "bg-comment-strong";
       }

package/src/ui/headless/revision-decoration-model.ts

@@ -1,5 +1,9 @@
 import type { TrackedChangesSnapshot, TrackedChangeEntrySnapshot } from "../../api/public-types";
-import { rangesOverlap, type MarkupDisplay } from "./comment-decoration-model";
+import {
+  normalizeMarkupDisplay,
+  rangesOverlap,
+  type MarkupDisplay,
+} from "./comment-decoration-model";
 
 export interface RevisionDecorationModel {
   revisions: RevisionDecorationEntry[];
@@ -13,6 +17,65 @@ export interface RevisionDecorationEntry {
   status: TrackedChangeEntrySnapshot["status"];
   actionability: TrackedChangeEntrySnapshot["actionability"];
   isActive: boolean;
+  /** L6d.N3 — source author, used to pick the decoration color. */
+  authorId?: string;
+  /** L6d.N3 — palette slot for `authorId` (0..7, stable via FNV-1a hash). */
+  authorPaletteIndex?: number;
+}
+
+/**
+ * L6d.N3 — author-color assignment.
+ *
+ * Map `authorId` → one of the 8 `--color-chart-categorical-*` vars
+ * using FNV-1a 32-bit hashing.  FNV-1a is deterministic, allocation-
+ * free, and has better avalanche on short ASCII keys than djb2, so
+ * typical author-id alphabets (emails, UUIDs, Slack IDs) distribute
+ * evenly across the 8 slots.
+ *
+ * The palette lives as CSS vars so theme swaps / reduced-contrast
+ * overrides in `tokens.css` cascade automatically — we emit `var(...)`
+ * strings, never hex literals.
+ */
+export const AUTHOR_PALETTE: readonly string[] = [
+  "var(--color-chart-categorical-1)",
+  "var(--color-chart-categorical-2)",
+  "var(--color-chart-categorical-3)",
+  "var(--color-chart-categorical-4)",
+  "var(--color-chart-categorical-5)",
+  "var(--color-chart-categorical-6)",
+  "var(--color-chart-categorical-7)",
+  "var(--color-chart-categorical-8)",
+];
+
+/**
+ * FNV-1a 32-bit hash.  Constants from the Fowler–Noll–Vo reference:
+ *   offset basis = 0x811c9dc5
+ *   prime        = 0x01000193
+ * The `>>> 0` keeps the value in unsigned 32-bit territory after each
+ * multiplication so two identical inputs always produce the same hash.
+ */
+export function hashAuthorId(authorId: string): number {
+  let hash = 0x811c9dc5;
+  for (let i = 0; i < authorId.length; i += 1) {
+    hash ^= authorId.charCodeAt(i);
+    hash = Math.imul(hash, 0x01000193) >>> 0;
+  }
+  return hash;
+}
+
+/** Reduce a hash to a palette slot in `[0, AUTHOR_PALETTE.length)`. */
+export function authorPaletteIndex(authorId: string): number {
+  return hashAuthorId(authorId) % AUTHOR_PALETTE.length;
+}
+
+/**
+ * Resolve a CSS color string for an author.  Returns `undefined` when
+ * `authorId` is missing so callers can fall back to the default
+ * per-kind class (e.g. `bg-insert-soft`).
+ */
+export function getAuthorColor(authorId: string | undefined): string | undefined {
+  if (!authorId) return undefined;
+  return AUTHOR_PALETTE[authorPaletteIndex(authorId)];
 }
 
 export interface RevisionRangeState {
@@ -47,6 +110,8 @@ export function createRevisionDecorationModel(
         status: rev.status,
         actionability: rev.actionability,
         isActive: rev.revisionId === activeRevisionId,
+        authorId: rev.authorId,
+        authorPaletteIndex: rev.authorId ? authorPaletteIndex(rev.authorId) : undefined,
       };
       }),
   };
@@ -94,12 +159,17 @@ export function getRevisionHighlightClass(
 
   const activeRing = state.hasActive ? " ring-1 ring-accent/30" : "";
 
-  switch (markupDisplay) {
-    case "clean":
-      // In clean mode, deletions are hidden entirely (caller should not render).
+  switch (normalizeMarkupDisplay(markupDisplay)) {
+    case "no-markup":
+      // In no-markup mode, deletions are hidden entirely (caller should not render).
       // Insertions render as normal text with no decoration.
       return "";
-    case "simple":
+    case "original":
+      // L6d.N2 — "original" shows what the doc looked like BEFORE the
+      // pending tracked changes: insertions are hidden (caller checks
+      // `shouldHideInOriginalMode`), deletions render as plain body text.
+      return "";
+    case "simple-markup":
       if (state.hasInsertions) {
         return `underline decoration-insert/60 decoration-1 underline-offset-2 text-primary${activeRing}`;
       }
@@ -107,7 +177,7 @@ export function getRevisionHighlightClass(
         return `text-secondary line-through decoration-danger/70 decoration-1${activeRing}`;
       }
       return activeRing;
-    case "all":
+    case "all-markup":
       if (state.hasInsertions) {
         return `text-primary bg-insert-soft/80 ring-1 ring-insert/20${activeRing}`;
       }
@@ -118,6 +188,10 @@ export function getRevisionHighlightClass(
   }
 }
 
+/**
+ * `no-markup` hides deletions (pretending the doc already accepted all
+ * pending changes).  The caller skips rendering affected spans entirely.
+ */
 export function shouldHideInCleanMode(
   model: RevisionDecorationModel | undefined,
   from: number,
@@ -126,3 +200,17 @@ export function shouldHideInCleanMode(
   const state = getRevisionRangeState(model, from, to);
   return state.hasDeletions;
 }
+
+/**
+ * L6d.N2 — `original` mode hides insertions (pretending the pending
+ * batch of tracked changes was rejected).  Caller skips rendering
+ * affected spans entirely.
+ */
+export function shouldHideInOriginalMode(
+  model: RevisionDecorationModel | undefined,
+  from: number,
+  to: number,
+): boolean {
+  const state = getRevisionRangeState(model, from, to);
+  return state.hasInsertions;
+}

package/src/ui/shared/revision-filters.ts

@@ -1,20 +1,24 @@
 import type { RuntimeRenderSnapshot } from "../../api/public-types";
+import {
+  normalizeMarkupDisplay,
+  type MarkupDisplay,
+} from "../headless/comment-decoration-model";
 
 type Revision = RuntimeRenderSnapshot["trackedChanges"]["revisions"][number];
-type MarkupDisplay = "clean" | "simple" | "all";
 
 export function selectVisibleRevisions(
   revisions: readonly Revision[],
   markupDisplay: MarkupDisplay,
 ): Revision[] {
-  switch (markupDisplay) {
-    case "clean":
-    case "simple":
+  switch (normalizeMarkupDisplay(markupDisplay)) {
+    case "no-markup":
+    case "simple-markup":
+    case "original":
       return revisions.filter(
         (revision) =>
           revision.status === "active" && revision.actionability === "actionable",
       );
-    case "all":
+    case "all-markup":
       return [...revisions];
   }
 }
@@ -23,7 +27,13 @@ export function describeEmptyRevisionState(
   markupDisplay: MarkupDisplay,
   totalCount: number,
 ): string {
-  if ((markupDisplay === "clean" || markupDisplay === "simple") && totalCount > 0) {
+  const canonical = normalizeMarkupDisplay(markupDisplay);
+  if (
+    (canonical === "no-markup" ||
+      canonical === "simple-markup" ||
+      canonical === "original") &&
+    totalCount > 0
+  ) {
     return "Simple markup keeps the rail focused on actionable live changes. Switch to All to inspect preserve-only or historical revision records.";
   }