@beyondwork/docx-react-component 1.0.131 → 1.0.133

package/dist/{chunk-THVM6EP5.js → chunk-CVSD3UNK.js}

@@ -19,13 +19,13 @@ import {
   resolveSectionVariants,
   sectionSupportsStoryTarget,
   storyTargetKey
-} from "./chunk-A3GSNB4G.js";
+} from "./chunk-XBQFDBXE.js";
 import {
   createSelectionSnapshot
 } from "./chunk-OYGMRRR7.js";
 import {
   collectCanonicalLayoutInputs
-} from "./chunk-A66ZVUAT.js";
+} from "./chunk-5KTJKTNE.js";
 import {
   MAIN_STORY_TARGET,
   createDetachedAnchor,
@@ -110,6 +110,1175 @@ function createScopeTagRegistry() {
   };
 }
 
+// src/runtime/telemetry/perf-probe.ts
+var PREDICTED_LANE_COUNTERS = {
+  applied: "predictions.applied",
+  equivalent: "predictions.equivalent",
+  adjusted: "predictions.adjusted",
+  rejected: "predictions.rejected",
+  rollback: "predictions.rollback",
+  structuralDivergence: "predictions.structuralDivergence",
+  bailBeforePredict: "predictions.bailBeforePredict",
+  refreshSelectionOnly: "predictions.refresh.selectionOnly",
+  refreshLocalTextEquivalent: "predictions.refresh.localTextEquivalent",
+  refreshSurfaceOnly: "predictions.refresh.surfaceOnly",
+  refreshFullProjection: "predictions.refresh.fullProjection",
+  refreshBlocked: "predictions.refresh.blocked"
+};
+function startPerfProbe(kind) {
+  const state = getEnabledState();
+  if (!state) {
+    return null;
+  }
+  const token = `${kind}-${state.nextToken ?? 0}`;
+  state.nextToken = (state.nextToken ?? 0) + 1;
+  state.pending ??= {};
+  state.pending[token] = {
+    kind,
+    startedAt: performance.now()
+  };
+  return token;
+}
+function finishPerfProbe(token) {
+  if (!token) {
+    return null;
+  }
+  const state = getEnabledState();
+  if (!state?.pending?.[token]) {
+    return null;
+  }
+  const pending = state.pending[token];
+  delete state.pending[token];
+  const sample = {
+    token,
+    kind: pending.kind,
+    durationMs: performance.now() - pending.startedAt,
+    recordedAt: Date.now()
+  };
+  pushSample(state, sample);
+  return sample;
+}
+function recordPerfSample(kind, durationMs = 0) {
+  const state = getEnabledState();
+  if (!state) {
+    return null;
+  }
+  const token = `${kind}-${state.nextToken ?? 0}`;
+  state.nextToken = (state.nextToken ?? 0) + 1;
+  const sample = {
+    token,
+    kind,
+    durationMs,
+    recordedAt: Date.now()
+  };
+  pushSample(state, sample);
+  return sample;
+}
+function incrementInvalidationCounter(counter, amount = 1) {
+  const state = getEnabledState();
+  if (!state) {
+    return 0;
+  }
+  state.invalidationCounts ??= {};
+  state.invalidationCounts[counter] = (state.invalidationCounts[counter] ?? 0) + amount;
+  return state.invalidationCounts[counter];
+}
+function getEnabledState() {
+  if (typeof window === "undefined") {
+    return null;
+  }
+  const state = window.__DOCX_REACT_PERF_PROBE__;
+  if (!state?.enabled) {
+    return null;
+  }
+  return state;
+}
+function pushSample(state, sample) {
+  state.samples ??= [];
+  state.samples.push(sample);
+  const maxSamples = state.maxSamples ?? 20;
+  if (state.samples.length > maxSamples) {
+    state.samples.splice(0, state.samples.length - maxSamples);
+  }
+}
+
+// src/runtime/render/decoration-resolver.ts
+function resolveDecorationIndex(input) {
+  const workflow = [];
+  const comments = [];
+  const revisions = [];
+  const search = [];
+  const locked = [];
+  if (input.workflowSegments) {
+    for (const segment of input.workflowSegments) {
+      const frame = input.anchorIndex.bySelection(
+        segment.fromOffset,
+        segment.toOffset
+      );
+      if (!frame) continue;
+      workflow.push({
+        kind: "workflow",
+        refId: segment.scopeId,
+        frame
+      });
+    }
+  }
+  if (input.comments) {
+    for (const thread of input.comments.threads) {
+      const frame = resolveRange(
+        input.anchorIndex,
+        thread.from,
+        thread.to
+      );
+      if (!frame) continue;
+      comments.push({
+        kind: "comment",
+        refId: thread.commentId,
+        frame
+      });
+      void asCommentThread(thread);
+    }
+  }
+  if (input.revisions) {
+    for (const revision of input.revisions.revisions) {
+      const frame = resolveRange(
+        input.anchorIndex,
+        revision.from,
+        revision.to
+      );
+      if (!frame) continue;
+      revisions.push({
+        kind: "revision",
+        refId: revision.revisionId,
+        frame
+      });
+      void asRevisionEntry(revision);
+    }
+  }
+  if (input.searchMatches) {
+    for (const match of input.searchMatches) {
+      const frame = resolveRange(input.anchorIndex, match.from, match.to);
+      if (!frame) continue;
+      search.push({
+        kind: "search",
+        refId: match.matchId,
+        frame
+      });
+    }
+  }
+  if (input.lockedRanges) {
+    for (const lock of input.lockedRanges) {
+      const frame = resolveRange(input.anchorIndex, lock.from, lock.to);
+      if (!frame) continue;
+      locked.push({
+        kind: "locked",
+        refId: lock.lockId,
+        frame
+      });
+    }
+  }
+  return { workflow, comments, revisions, search, locked };
+}
+function resolveRange(anchorIndex, from, to) {
+  if (from >= to) {
+    return anchorIndex.byRuntimeOffset(from);
+  }
+  return anchorIndex.bySelection(from, to);
+}
+function asCommentThread(thread) {
+  return thread;
+}
+function asRevisionEntry(entry) {
+  return entry;
+}
+
+// src/runtime/render/block-fragment-projection.ts
+function classifyBlockKind(blockId) {
+  if (blockId.startsWith("paragraph")) return "paragraph";
+  if (blockId.startsWith("table")) return "table";
+  if (blockId.startsWith("placeholder-culled-")) return "opaque";
+  if (blockId.startsWith("opaque")) return "opaque";
+  if (blockId.startsWith("section-break")) return "opaque";
+  if (blockId.startsWith("sdt")) return "opaque";
+  if (blockId.startsWith("custom-xml")) return "opaque";
+  if (blockId.startsWith("alt-chunk")) return "opaque";
+  if (blockId.startsWith("synthetic")) return "synthetic";
+  return "paragraph";
+}
+
+// src/runtime/render/render-frame-diff.ts
+function diffRenderFrames(prev, next) {
+  if (!prev) {
+    return {
+      addedPages: next.pages.map((p) => p.page.pageIndex),
+      removedPages: [],
+      unchangedPages: [],
+      changedPages: []
+    };
+  }
+  const prevByIndex = /* @__PURE__ */ new Map();
+  for (const page of prev.pages) {
+    prevByIndex.set(page.page.pageIndex, page);
+  }
+  const nextIndices = /* @__PURE__ */ new Set();
+  for (const page of next.pages) {
+    nextIndices.add(page.page.pageIndex);
+  }
+  const addedPages = [];
+  const removedPages = [];
+  const unchangedPages = [];
+  const changedPages = [];
+  for (const nextPage of next.pages) {
+    const pageIndex = nextPage.page.pageIndex;
+    const prevPage = prevByIndex.get(pageIndex);
+    if (!prevPage) {
+      addedPages.push(pageIndex);
+      continue;
+    }
+    const regions = diffPage(prevPage, nextPage, prev.decorationIndex, next.decorationIndex);
+    const frameChanged = !rectEquals(prevPage.frame, nextPage.frame);
+    const reservationsChanged = !reservationsEqual(
+      prevPage.chromeReservations,
+      nextPage.chromeReservations
+    );
+    if (regions.length === 0 && !frameChanged && !reservationsChanged) {
+      unchangedPages.push(pageIndex);
+    } else {
+      changedPages.push({
+        pageIndex,
+        regions,
+        ...frameChanged ? { pageFrameChanged: true } : {}
+      });
+    }
+  }
+  for (const prevPage of prev.pages) {
+    if (!nextIndices.has(prevPage.page.pageIndex)) {
+      removedPages.push(prevPage.page.pageIndex);
+    }
+  }
+  return { addedPages, removedPages, unchangedPages, changedPages };
+}
+function createPagePatchPlan(prev, next, diff = diffRenderFrames(prev, next), options = {}) {
+  const prevByIndex = indexPagesByIndex(prev?.pages ?? []);
+  const nextByIndex = indexPagesByIndex(next.pages);
+  const addedPages = diff.addedPages.map(
+    (pageIndex) => pageIdForIndex(nextByIndex, pageIndex)
+  );
+  const removedPages = diff.removedPages.map(
+    (pageIndex) => pageIdForIndex(prevByIndex, pageIndex)
+  );
+  const unchangedPages = diff.unchangedPages.map(
+    (pageIndex) => pageIdForIndex(nextByIndex, pageIndex)
+  );
+  const changedPages = diff.changedPages.map(
+    (entry) => createPagePatchEntry(entry, pageIdForIndex(nextByIndex, entry.pageIndex), options)
+  );
+  return {
+    layoutRevision: options.layoutRevision ?? next.revision,
+    geometryRevision: options.geometryRevision ?? next.revision,
+    addedPages,
+    removedPages,
+    unchangedPages,
+    changedPages,
+    mountChanges: resolveMountChanges({
+      addedPages,
+      removedPages,
+      mountedPageIds: options.mountedPageIds,
+      requestedMountPageIds: options.requestedMountPageIds
+    })
+  };
+}
+function createPagePatchEntry(entry, pageId, options) {
+  const regionChanges = entry.regions.map((region) => region.kind);
+  const fragmentChanges = uniqueStrings(
+    entry.regions.flatMap((region) => region.changedBlockIds)
+  );
+  const overlayLaneChanges = !entry.pageFrameChanged && entry.regions.length === 0 ? ["chrome-reservations"] : [];
+  return {
+    pageId,
+    pageIndex: entry.pageIndex,
+    frameChanged: entry.pageFrameChanged === true,
+    regionChanges,
+    fragmentChanges,
+    lineBoxChanges: fragmentChanges,
+    overlayLaneChanges,
+    reason: options.reason ?? (overlayLaneChanges.length > 0 ? "overlay" : "layout")
+  };
+}
+function resolveMountChanges(input) {
+  if (!input.mountedPageIds || !input.requestedMountPageIds) {
+    return {
+      mountPageIds: input.addedPages,
+      unmountPageIds: input.removedPages
+    };
+  }
+  const mounted = new Set(input.mountedPageIds);
+  const requested = new Set(input.requestedMountPageIds);
+  return {
+    mountPageIds: input.requestedMountPageIds.filter((pageId) => !mounted.has(pageId)),
+    unmountPageIds: input.mountedPageIds.filter((pageId) => !requested.has(pageId))
+  };
+}
+function indexPagesByIndex(pages) {
+  return new Map(pages.map((page) => [page.page.pageIndex, page]));
+}
+function pageIdForIndex(pages, pageIndex) {
+  return pages.get(pageIndex)?.page.pageId ?? `page:${pageIndex}`;
+}
+function uniqueStrings(values) {
+  return [...new Set(values)];
+}
+function diffPage(prev, next, prevIndex, nextIndex) {
+  const changed = [];
+  const bodyChanges = diffRegion(prev.regions.body, next.regions.body, prevIndex, nextIndex);
+  if (bodyChanges.length > 0) {
+    changed.push({ kind: "body", changedBlockIds: bodyChanges });
+  }
+  const headerChanges = diffOptionalRegion(
+    prev.regions.header,
+    next.regions.header,
+    prevIndex,
+    nextIndex
+  );
+  if (headerChanges.length > 0) {
+    changed.push({ kind: "header", changedBlockIds: headerChanges });
+  }
+  const footerChanges = diffOptionalRegion(
+    prev.regions.footer,
+    next.regions.footer,
+    prevIndex,
+    nextIndex
+  );
+  if (footerChanges.length > 0) {
+    changed.push({ kind: "footer", changedBlockIds: footerChanges });
+  }
+  const prevFoot = prev.regions.footnotes ?? [];
+  const nextFoot = next.regions.footnotes ?? [];
+  if (prevFoot.length !== nextFoot.length) {
+    changed.push({ kind: "footnote-area", changedBlockIds: ["<count-changed>"] });
+  } else {
+    for (let i = 0; i < prevFoot.length; i += 1) {
+      const fChanges = diffRegion(prevFoot[i], nextFoot[i], prevIndex, nextIndex);
+      if (fChanges.length > 0) {
+        changed.push({ kind: "footnote-area", changedBlockIds: fChanges });
+      }
+    }
+  }
+  return changed;
+}
+function diffOptionalRegion(prev, next, prevIndex, nextIndex) {
+  if (!prev && !next) return [];
+  if (!prev && next) return ["<added>"];
+  if (prev && !next) return ["<removed>"];
+  return diffRegion(prev, next, prevIndex, nextIndex);
+}
+function diffRegion(prev, next, prevIndex, nextIndex) {
+  const changed = [];
+  if (!rectEquals(prev.frame, next.frame)) {
+    changed.push("<region-frame>");
+  }
+  const prevBlocks = /* @__PURE__ */ new Map();
+  for (const block of prev.blocks) {
+    prevBlocks.set(block.fragment.blockId, block);
+  }
+  const nextIds = /* @__PURE__ */ new Set();
+  for (const block of next.blocks) {
+    nextIds.add(block.fragment.blockId);
+    const prevBlock = prevBlocks.get(block.fragment.blockId);
+    if (!prevBlock) {
+      changed.push(block.fragment.blockId);
+      continue;
+    }
+    if (!blocksStructurallyEqual(prevBlock, block, prevIndex, nextIndex)) {
+      changed.push(block.fragment.blockId);
+    }
+  }
+  for (const blockId of prevBlocks.keys()) {
+    if (!nextIds.has(blockId)) changed.push(blockId);
+  }
+  return changed;
+}
+function blocksStructurallyEqual(a, b, aIndex, bIndex) {
+  if (a.kind !== b.kind) return false;
+  if (a.fragment.regionKind !== b.fragment.regionKind) return false;
+  if (a.fragment.from !== b.fragment.from) return false;
+  if (a.fragment.to !== b.fragment.to) return false;
+  if (!rectEquals(a.frame, b.frame)) return false;
+  if (a.lines.length !== b.lines.length) return false;
+  for (let i = 0; i < a.lines.length; i += 1) {
+    if (!rectEquals(a.lines[i].frame, b.lines[i].frame)) return false;
+  }
+  const aHash = decorationHashForBlock(a.frame, aIndex);
+  const bHash = decorationHashForBlock(b.frame, bIndex);
+  if (aHash !== bHash) return false;
+  return true;
+}
+function decorationHashForBlock(blockFrame, index) {
+  const tokens = [];
+  for (const lane of [index.workflow, index.comments, index.revisions, index.search, index.locked]) {
+    for (const entry of lane) {
+      if (rectIntersects(entry.frame, blockFrame)) {
+        tokens.push(`${entry.kind}:${entry.refId}`);
+      }
+    }
+  }
+  tokens.sort();
+  return tokens.join("|");
+}
+function reservationsEqual(a, b) {
+  return a.railLaneTwips === b.railLaneTwips && a.balloonLaneTwips === b.balloonLaneTwips && a.footnoteAreaTwips === b.footnoteAreaTwips && a.pageFrameWidthPx === b.pageFrameWidthPx && a.pageFrameHeightPx === b.pageFrameHeightPx;
+}
+var RECT_EPS = 0.1;
+function rectEquals(a, b) {
+  return Math.abs(a.leftPx - b.leftPx) < RECT_EPS && Math.abs(a.topPx - b.topPx) < RECT_EPS && Math.abs(a.widthPx - b.widthPx) < RECT_EPS && Math.abs(a.heightPx - b.heightPx) < RECT_EPS;
+}
+function rectIntersects(a, b) {
+  return !(a.leftPx + a.widthPx <= b.leftPx || b.leftPx + b.widthPx <= a.leftPx || a.topPx + a.heightPx <= b.topPx || b.topPx + b.heightPx <= a.topPx);
+}
+
+// src/runtime/render/render-frame-types.ts
+var DEFAULT_PX_PER_TWIP = 96 / 1440;
+var PAGE_STACK_GAP_PX = 48;
+function resolveDefaultZoom(input = {}) {
+  return {
+    pxPerTwip: input.pxPerTwip ?? DEFAULT_PX_PER_TWIP,
+    viewportWidthPx: input.viewportWidthPx ?? 900,
+    fitMode: input.fitMode ?? "fixed"
+  };
+}
+var EMPTY_DECORATION_INDEX = Object.freeze({
+  workflow: Object.freeze([]),
+  comments: Object.freeze([]),
+  revisions: Object.freeze([]),
+  search: Object.freeze([]),
+  locked: Object.freeze([])
+});
+function defaultChromeReservations(layout, zoom) {
+  return {
+    railLaneTwips: 360,
+    balloonLaneTwips: 2160,
+    footnoteAreaTwips: 0,
+    pageFrameWidthPx: layout.pageWidth * zoom.pxPerTwip,
+    pageFrameHeightPx: layout.pageHeight * zoom.pxPerTwip
+  };
+}
+
+// src/runtime/render/render-kernel.ts
+function sumDeltasBefore(deltas, runtimeOffset) {
+  let total = 0;
+  for (const d of deltas) {
+    if (d.fromRuntime <= runtimeOffset) total += d.delta;
+  }
+  return total;
+}
+function createRenderKernel(input) {
+  const { facet } = input;
+  const getActiveStory = input.getActiveStory ?? (() => MAIN_STORY_TARGET);
+  let zoom = input.initialZoom ?? resolveDefaultZoom();
+  let cache = null;
+  let lastEmittedFrame = null;
+  let diCacheKey = null;
+  let diCacheValue = null;
+  const listeners = /* @__PURE__ */ new Set();
+  const unsubscribeFacet = facet.subscribe((event) => {
+    if (event.kind === "layout_recomputed" || event.kind === "incremental_relayout" || event.kind === "measurement_backend_ready" || event.kind === "zoom_changed") {
+      cache = null;
+    }
+  });
+  void unsubscribeFacet;
+  function emit(event) {
+    for (const listener of listeners) {
+      try {
+        listener(event);
+      } catch {
+      }
+    }
+  }
+  function buildFrame(options) {
+    const t0 = typeof performance !== "undefined" ? performance.now() : 0;
+    const activeStory = options?.story ?? getActiveStory();
+    const measurementFidelity = facet.getMeasurementFidelity();
+    const rawPages = facet.getPages();
+    const pageRange = options?.pageRange;
+    const filteredPages = pageRange ? rawPages.filter(
+      (p) => p.pageIndex >= pageRange.fromPageIndex && p.pageIndex <= pageRange.toPageIndex
+    ) : rawPages;
+    let y = 0;
+    const renderPages = [];
+    for (const page of filteredPages) {
+      const renderPage = buildPage(page, y, zoom, activeStory, facet);
+      renderPages.push(renderPage);
+      y += renderPage.frame.heightPx + PAGE_STACK_GAP_PX;
+    }
+    const pendingDeltas = input.getPendingOpDeltas?.() ?? [];
+    const baseAnchorIndex = buildAnchorIndex(
+      renderPages,
+      pendingDeltas,
+      zoom.pxPerTwip
+    );
+    const revision = filteredPages[0] ? Number(extractRevisionFromPageId(filteredPages[0].pageId)) : 0;
+    const includeDecorations = options?.includeDecorations ?? true;
+    const sources = input.getDecorationSources?.();
+    const hasSources = sources !== void 0 && (sources.workflowSegments && sources.workflowSegments.length > 0 || (sources.comments?.threads?.length ?? 0) > 0 || (sources.revisions?.revisions?.length ?? 0) > 0 || sources.searchMatches && sources.searchMatches.length > 0 || sources.lockedRanges && sources.lockedRanges.length > 0);
+    const newDIKey = {
+      revision: Number.isFinite(revision) ? revision : 0,
+      activeStoryKind: activeStory.kind,
+      zoomPxPerTwip: zoom.pxPerTwip,
+      workflowSegments: sources?.workflowSegments,
+      comments: sources?.comments,
+      revisions: sources?.revisions,
+      searchMatches: sources?.searchMatches,
+      lockedRanges: sources?.lockedRanges
+    };
+    const diCacheHit = hasSources && diCacheKey !== null && diCacheValue !== null && diCacheKey.revision === newDIKey.revision && diCacheKey.activeStoryKind === newDIKey.activeStoryKind && diCacheKey.zoomPxPerTwip === newDIKey.zoomPxPerTwip && diCacheKey.workflowSegments === newDIKey.workflowSegments && diCacheKey.comments === newDIKey.comments && diCacheKey.revisions === newDIKey.revisions && diCacheKey.searchMatches === newDIKey.searchMatches && diCacheKey.lockedRanges === newDIKey.lockedRanges;
+    let decorationIndex;
+    if (!includeDecorations) {
+      decorationIndex = EMPTY_DECORATION_INDEX;
+    } else if (hasSources) {
+      if (diCacheHit) {
+        decorationIndex = diCacheValue;
+      } else {
+        decorationIndex = resolveDecorationIndex({ anchorIndex: baseAnchorIndex, ...sources });
+        diCacheKey = newDIKey;
+        diCacheValue = decorationIndex;
+      }
+    } else {
+      decorationIndex = buildDecorationIndex(renderPages);
+    }
+    const anchorIndex = buildAnchorIndex(
+      renderPages,
+      pendingDeltas,
+      zoom.pxPerTwip,
+      decorationIndex
+    );
+    const frame = {
+      revision: Number.isFinite(revision) ? revision : 0,
+      measurementFidelity,
+      activeStory,
+      zoom: { ...zoom },
+      pages: renderPages,
+      decorationIndex,
+      anchorIndex
+    };
+    if (t0 > 0) recordPerfSample("render.frame_build", performance.now() - t0);
+    return frame;
+  }
+  return {
+    getRenderFrame(options) {
+      const rebuild = options !== void 0 || cache === null;
+      if (!rebuild && cache) {
+        return cache.frame;
+      }
+      const frame = buildFrame(options);
+      if (options === void 0) {
+        cache = { revision: frame.revision, frame };
+        emit({ kind: "frame_built", revision: frame.revision, reason: "full" });
+        const diffT0 = typeof performance !== "undefined" ? performance.now() : 0;
+        const diff = diffRenderFrames(lastEmittedFrame, frame);
+        const patchPlan = createPagePatchPlan(lastEmittedFrame, frame, diff);
+        recordPagePatchPlanTelemetry(patchPlan);
+        if (diffT0 > 0) {
+          recordPerfSample("render.frame_diff", performance.now() - diffT0);
+        }
+        emit({ kind: "frame_diff", revision: frame.revision, diff, patchPlan });
+        lastEmittedFrame = frame;
+      }
+      return frame;
+    },
+    getZoom() {
+      return { ...zoom };
+    },
+    setZoom(next) {
+      zoom = { ...next };
+      cache = null;
+    },
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    invalidate() {
+      cache = null;
+    }
+  };
+}
+function recordPagePatchPlanTelemetry(plan) {
+  incrementInvalidationCounter(
+    "pageRender.patch.addedPages",
+    plan.addedPages.length
+  );
+  incrementInvalidationCounter(
+    "pageRender.patch.removedPages",
+    plan.removedPages.length
+  );
+  incrementInvalidationCounter(
+    "pageRender.patch.unchangedPages",
+    plan.unchangedPages.length
+  );
+  incrementInvalidationCounter(
+    "pageRender.patch.changedFragments",
+    plan.changedPages.reduce(
+      (total, page) => total + page.fragmentChanges.length,
+      0
+    )
+  );
+  incrementInvalidationCounter(
+    "pageRender.patch.mountedPages",
+    plan.mountChanges.mountPageIds.length
+  );
+  incrementInvalidationCounter(
+    "pageRender.patch.unmountedPages",
+    plan.mountChanges.unmountPageIds.length
+  );
+}
+function buildPage(page, topPx, zoom, activeStory, facet) {
+  const layout = page.layout;
+  const widthPx = layout.pageWidth * zoom.pxPerTwip;
+  const heightPx = layout.pageHeight * zoom.pxPerTwip;
+  const frame = {
+    leftPx: 0,
+    topPx,
+    widthPx,
+    heightPx
+  };
+  const bodyRegion = buildBodyRegion(
+    page,
+    topPx,
+    zoom,
+    activeStory,
+    facet
+  );
+  const regions = {
+    body: bodyRegion
+  };
+  if (page.stories.header) {
+    regions.header = buildHeaderFooterRegion(
+      page,
+      topPx,
+      zoom,
+      "header",
+      page.stories.header,
+      facet
+    );
+  }
+  if (page.stories.footer) {
+    regions.footer = buildHeaderFooterRegion(
+      page,
+      topPx,
+      zoom,
+      "footer",
+      page.stories.footer,
+      facet
+    );
+  }
+  const footnoteRegions = buildFootnoteRegions(page, topPx, zoom, facet);
+  if (footnoteRegions.length > 0) {
+    regions.footnotes = footnoteRegions;
+  }
+  const chromeReservations = {
+    ...defaultChromeReservations(layout, zoom)
+  };
+  return {
+    page,
+    frame,
+    regions,
+    chromeReservations
+  };
+}
+function buildBodyRegion(page, pageTopPx, zoom, activeStory, facet) {
+  const layout = page.layout;
+  const bodyLeftTwips = layout.marginLeft;
+  const bodyTopTwips = layout.marginTop;
+  const bodyWidthTwips = page.regions.body.widthTwips;
+  const bodyHeightTwips = page.regions.body.heightTwips;
+  const regionFrame = {
+    leftPx: bodyLeftTwips * zoom.pxPerTwip,
+    topPx: pageTopPx + bodyTopTwips * zoom.pxPerTwip,
+    widthPx: bodyWidthTwips * zoom.pxPerTwip,
+    heightPx: bodyHeightTwips * zoom.pxPerTwip
+  };
+  const fragments = facet.getFragmentsForPage(page.pageIndex);
+  const bodyLineBoxes = facet.getLineBoxes(page.pageIndex, { region: "body" });
+  const blocks = [];
+  let blockY = regionFrame.topPx;
+  const totalFragmentHeight = fragments.reduce(
+    (acc, fragment) => acc + Math.max(0, fragment.heightTwips),
+    0
+  );
+  for (const fragment of fragments) {
+    if (fragment.regionKind !== "body") continue;
+    const fragmentHeightTwips = fragment.heightTwips > 0 ? fragment.heightTwips : totalFragmentHeight === 0 ? bodyHeightTwips / Math.max(1, fragments.length) : 0;
+    const blockHeightPx = fragmentHeightTwips * zoom.pxPerTwip;
+    const fallbackBlockFrame = {
+      leftPx: regionFrame.leftPx,
+      topPx: blockY,
+      widthPx: regionFrame.widthPx,
+      heightPx: blockHeightPx
+    };
+    const blockLines = bodyLineBoxes.filter((box) => box.fragmentId === fragment.fragmentId).map((box) => {
+      const lineFrame = lineFrameFromPublicBox(
+        box,
+        regionFrame,
+        pageTopPx,
+        bodyTopTwips,
+        zoom
+      );
+      const anchors = [
+        {
+          runtimeOffset: fragment.from,
+          frame: lineFrame,
+          fragmentId: fragment.fragmentId,
+          blockId: fragment.blockId
+        }
+      ];
+      return {
+        line: box,
+        frame: lineFrame,
+        anchors
+      };
+    });
+    const kind = classifyBlockKind(fragment.blockId);
+    const blockFrame = blockFrameFromLineFacts(
+      fallbackBlockFrame,
+      kind,
+      blockLines
+    );
+    const tablePlan = kind === "table" ? facet.getTableRenderPlan(fragment.blockId, page.pageIndex) : void 0;
+    blocks.push({
+      fragment,
+      frame: blockFrame,
+      kind,
+      lines: blockLines,
+      blockDecorations: [],
+      ...tablePlan !== void 0 ? { tablePlan } : {}
+    });
+    blockY = Math.max(blockY + blockHeightPx, blockFrame.topPx + blockFrame.heightPx);
+  }
+  return {
+    storyTarget: activeStory,
+    region: page.regions.body,
+    frame: regionFrame,
+    blocks
+  };
+}
+function lineFrameFromPublicBox(box, regionFrame, pageTopPx, bodyTopTwips, zoom) {
+  if (box.rectTwips) {
+    return projectPageTwipsRectToFrame(box.rectTwips, pageTopPx, zoom);
+  }
+  const lineTopPx = pageTopPx + (bodyTopTwips + box.baselineTwips) * zoom.pxPerTwip;
+  return {
+    leftPx: regionFrame.leftPx,
+    topPx: lineTopPx,
+    widthPx: Math.min(
+      regionFrame.widthPx,
+      box.widthTwips * zoom.pxPerTwip
+    ),
+    heightPx: box.heightTwips * zoom.pxPerTwip
+  };
+}
+function projectPageTwipsRectToFrame(rect2, pageTopPx, zoom) {
+  return {
+    leftPx: rect2.xTwips * zoom.pxPerTwip,
+    topPx: pageTopPx + rect2.yTwips * zoom.pxPerTwip,
+    widthPx: rect2.widthTwips * zoom.pxPerTwip,
+    heightPx: rect2.heightTwips * zoom.pxPerTwip
+  };
+}
+function blockFrameFromLineFacts(fallback, kind, lines) {
+  const union = unionRenderLineFrames(lines);
+  if (!union) return fallback;
+  if (kind === "paragraph") return union;
+  if (fallback.widthPx <= 0 || fallback.heightPx <= 0) return union;
+  return fallback;
+}
+function unionRenderLineFrames(lines) {
+  let left = Number.POSITIVE_INFINITY;
+  let top = Number.POSITIVE_INFINITY;
+  let right = Number.NEGATIVE_INFINITY;
+  let bottom = Number.NEGATIVE_INFINITY;
+  for (const line of lines) {
+    if (line.frame.widthPx <= 0 || line.frame.heightPx <= 0) continue;
+    left = Math.min(left, line.frame.leftPx);
+    top = Math.min(top, line.frame.topPx);
+    right = Math.max(right, line.frame.leftPx + line.frame.widthPx);
+    bottom = Math.max(bottom, line.frame.topPx + line.frame.heightPx);
+  }
+  if (!Number.isFinite(left) || !Number.isFinite(top)) return null;
+  return {
+    leftPx: left,
+    topPx: top,
+    widthPx: Math.max(0, right - left),
+    heightPx: Math.max(0, bottom - top)
+  };
+}
+function buildHeaderFooterRegion(page, pageTopPx, zoom, kind, storyTarget, facet) {
+  const layout = page.layout;
+  const fallbackWidthTwips = layout.pageWidth - layout.marginLeft - layout.marginRight;
+  const fallbackTopTwips = kind === "header" ? layout.headerMargin ?? 720 : layout.pageHeight - layout.marginBottom;
+  const fallbackHeightTwips = kind === "header" ? Math.max(0, layout.marginTop - (layout.headerMargin ?? 720)) : Math.max(0, layout.marginBottom - (layout.footerMargin ?? 720));
+  const region = (kind === "header" ? page.regions.header : page.regions.footer) ?? {
+    kind,
+    originTwips: fallbackTopTwips,
+    widthTwips: fallbackWidthTwips,
+    heightTwips: fallbackHeightTwips,
+    fragmentCount: 0
+  };
+  const frame = {
+    leftPx: layout.marginLeft * zoom.pxPerTwip,
+    topPx: pageTopPx + region.originTwips * zoom.pxPerTwip,
+    widthPx: region.widthTwips * zoom.pxPerTwip,
+    heightPx: region.heightTwips * zoom.pxPerTwip
+  };
+  const regionBlocks = facet.getStoryBlocksForRegion(page.pageIndex, kind);
+  const blocks = projectRegionBlocks(
+    regionBlocks,
+    frame,
+    zoom.pxPerTwip,
+    page.pageId,
+    page.pageIndex,
+    kind
+  );
+  return {
+    storyTarget,
+    region,
+    frame,
+    blocks
+  };
+}
+function buildFootnoteRegions(page, pageTopPx, zoom, facet) {
+  const footnoteRegions = page.regions.footnotes;
+  if (!footnoteRegions || footnoteRegions.length === 0) return [];
+  const regionBlocks = facet.getStoryBlocksForRegion(
+    page.pageIndex,
+    "footnote-area"
+  );
+  if (regionBlocks.length === 0) return [];
+  const results = [];
+  let cursor = 0;
+  for (const region of footnoteRegions) {
+    const frame = {
+      leftPx: page.layout.marginLeft * zoom.pxPerTwip,
+      topPx: pageTopPx + region.originTwips * zoom.pxPerTwip,
+      widthPx: region.widthTwips * zoom.pxPerTwip,
+      heightPx: region.heightTwips * zoom.pxPerTwip
+    };
+    const blocksForThisRegion = footnoteRegions.length === 1 ? regionBlocks : regionBlocks.slice(cursor, cursor + region.fragmentCount);
+    cursor += region.fragmentCount;
+    const blocks = projectRegionBlocks(
+      blocksForThisRegion,
+      frame,
+      zoom.pxPerTwip,
+      page.pageId,
+      page.pageIndex,
+      "footnote-area"
+    );
+    const firstNote = page.noteAllocations.find(
+      (alloc) => alloc.noteKind === "footnote"
+    );
+    const storyTarget = firstNote ? { kind: "footnote", noteId: firstNote.noteId } : MAIN_STORY_TARGET;
+    results.push({
+      storyTarget,
+      region,
+      frame,
+      blocks
+    });
+  }
+  return results;
+}
+function projectRegionBlocks(regionBlocks, regionFrame, pxPerTwip, pageId, pageIndex, regionKind) {
+  const blocks = [];
+  let y = regionFrame.topPx;
+  for (let i = 0; i < regionBlocks.length; i += 1) {
+    const regionBlock = regionBlocks[i];
+    const blockHeightPx = Math.max(0, regionBlock.heightTwips) * pxPerTwip;
+    const blockFrame = {
+      leftPx: regionFrame.leftPx,
+      topPx: y,
+      widthPx: regionFrame.widthPx,
+      heightPx: blockHeightPx
+    };
+    const fragment = {
+      fragmentId: regionBlock.fragmentId,
+      blockId: regionBlock.blockId,
+      pageId,
+      pageIndex,
+      regionKind,
+      from: regionBlock.runtimeFromOffset,
+      to: regionBlock.runtimeToOffset,
+      heightTwips: regionBlock.heightTwips,
+      orderInRegion: i
+    };
+    blocks.push({
+      fragment,
+      frame: blockFrame,
+      kind: classifyBlockKind(regionBlock.blockId),
+      lines: [],
+      blockDecorations: []
+    });
+    y += blockHeightPx;
+  }
+  return blocks;
+}
+function buildAnchorIndex(pages, pendingDeltas = [], pxPerTwip = 1, decorationIndex = EMPTY_DECORATION_INDEX) {
+  const byRuntimeOffset = /* @__PURE__ */ new Map();
+  const byRuntimeOffsetByStory = /* @__PURE__ */ new Map();
+  const byFragmentId = /* @__PURE__ */ new Map();
+  const byBlockId = /* @__PURE__ */ new Map();
+  const byPageIndex = /* @__PURE__ */ new Map();
+  const tableCellRects = /* @__PURE__ */ new Map();
+  const tableColumnEdges = /* @__PURE__ */ new Map();
+  const tableRowEdges = /* @__PURE__ */ new Map();
+  const recordBlock = (block, offsetMap) => {
+    byFragmentId.set(block.fragment.fragmentId, block.frame);
+    byBlockId.set(block.fragment.blockId, block.frame);
+    offsetMap.set(block.fragment.from, block.frame);
+    for (const line of block.lines) {
+      for (const anchor of line.anchors) {
+        offsetMap.set(anchor.runtimeOffset, anchor.frame);
+      }
+    }
+    if (block.kind === "table" && block.tablePlan) {
+      recordTableAnchors(
+        block.fragment.blockId,
+        block.frame,
+        block.tablePlan,
+        pxPerTwip,
+        tableCellRects,
+        tableColumnEdges,
+        tableRowEdges
+      );
+    }
+  };
+  const recordStoryRegion = (region) => {
+    const storyKey = storyTargetKey(region.storyTarget);
+    let storyMap = byRuntimeOffsetByStory.get(storyKey);
+    if (!storyMap) {
+      storyMap = /* @__PURE__ */ new Map();
+      byRuntimeOffsetByStory.set(storyKey, storyMap);
+    }
+    for (const block of region.blocks) {
+      recordBlock(block, storyMap);
+    }
+  };
+  for (const page of pages) {
+    byPageIndex.set(page.page.pageIndex, page.frame);
+    for (const block of page.regions.body.blocks) {
+      recordBlock(block, byRuntimeOffset);
+    }
+    if (page.regions.header) recordStoryRegion(page.regions.header);
+    if (page.regions.footer) recordStoryRegion(page.regions.footer);
+    if (page.regions.footnotes) {
+      for (const footnote of page.regions.footnotes) {
+        recordStoryRegion(footnote);
+      }
+    }
+  }
+  const shiftForDeltas = (offset) => {
+    if (pendingDeltas.length === 0) return offset;
+    return offset - sumDeltasBefore(pendingDeltas, offset);
+  };
+  const resolveByRuntimeOffset = (offset, story) => {
+    const lookup = shiftForDeltas(offset);
+    const targetMap = story && story.kind !== "main" ? byRuntimeOffsetByStory.get(storyTargetKey(story)) ?? byRuntimeOffset : byRuntimeOffset;
+    const exact = targetMap.get(lookup);
+    if (exact) return exact;
+    let best = null;
+    let bestDistance = Number.POSITIVE_INFINITY;
+    for (const [key, rect2] of targetMap) {
+      const distance = Math.abs(key - lookup);
+      if (distance < bestDistance) {
+        best = rect2;
+        bestDistance = distance;
+      }
+    }
+    return best;
+  };
+  return {
+    byRuntimeOffset(offset, story) {
+      return resolveByRuntimeOffset(offset, story);
+    },
+    byBlockId(blockId) {
+      return byBlockId.get(blockId) ?? null;
+    },
+    byFragmentId(fragmentId) {
+      return byFragmentId.get(fragmentId) ?? null;
+    },
+    byPageIndex(pageIndex) {
+      return byPageIndex.get(pageIndex) ?? null;
+    },
+    bySelection(fromOffset, toOffset, story) {
+      const lo = Math.min(fromOffset, toOffset);
+      const hi = Math.max(fromOffset, toOffset);
+      if (lo === hi) {
+        return resolveByRuntimeOffset(lo, story);
+      }
+      const loShifted = shiftForDeltas(lo);
+      const hiShifted = shiftForDeltas(hi);
+      const targetMap = story && story.kind !== "main" ? byRuntimeOffsetByStory.get(storyTargetKey(story)) ?? byRuntimeOffset : byRuntimeOffset;
+      let union = null;
+      for (const [key, rect2] of targetMap) {
+        if (key < loShifted || key >= hiShifted) continue;
+        union = unionRects(union, rect2);
+      }
+      if (union) return union;
+      const fromRect = resolveByRuntimeOffset(lo, story);
+      const toRect = resolveByRuntimeOffset(hi - 1, story);
+      return unionRects(fromRect, toRect);
+    },
+    byTableCell(tableBlockId, rowIndex, columnIndex) {
+      return tableCellRects.get(`${tableBlockId}:${rowIndex}:${columnIndex}`) ?? null;
+    },
+    byTableColumnEdge(tableBlockId, columnIndex) {
+      return tableColumnEdges.get(`${tableBlockId}:${columnIndex}`) ?? null;
+    },
+    byTableRowEdge(tableBlockId, rowIndex) {
+      return tableRowEdges.get(`${tableBlockId}:${rowIndex}`) ?? null;
+    },
+    // P9 Phase A — chrome-kind resolvers sourced from the resolved
+    // decoration index. Empty by default (the initial frame build passes
+    // `EMPTY_DECORATION_INDEX` until decoration resolution runs); the
+    // kernel re-invokes `buildAnchorIndex` with the resolved index so the
+    // final anchor index carries chrome-aware lookups.
+    byScopeId(scopeId) {
+      return decorationIndex.workflow.filter((decoration) => decoration.refId === scopeId).map((decoration) => decoration.frame);
+    },
+    byCommentId(commentId) {
+      const match = decorationIndex.comments.find(
+        (decoration) => decoration.refId === commentId
+      );
+      return match?.frame ?? null;
+    },
+    byRevisionId(revisionId) {
+      const match = decorationIndex.revisions.find(
+        (decoration) => decoration.refId === revisionId
+      );
+      return match?.frame ?? null;
+    },
+    // Refactor/05 Slice 7c substrate: object-specific index. Falls back
+    // to `byBlockId` because the render kernel does not yet carry
+    // per-object metadata on anchor frames — the layout facet would
+    // need to emit `byObjectId` entries on the page graph. When that
+    // follow-up ships, populate a dedicated `byObjectIdMap` here and
+    // consult it before the `byBlockId` fallback. The fallback is
+    // correct for block-level drawings (whose object id equals their
+    // block id); it is `heuristic` for inline images (which share
+    // their block id with the enclosing paragraph). `object-handles.ts`
+    // tags those handles `precision: "heuristic"` accordingly.
+    byObjectId(objectId) {
+      return byBlockId.get(objectId) ?? null;
+    }
+  };
+}
+function recordTableAnchors(tableBlockId, blockFrame, plan, pxPerTwip, cellRects, columnEdges, rowEdges) {
+  if (!plan) return;
+  const columnCount = plan.columnsTwips.length;
+  if (columnCount === 0) return;
+  const columnLeftsPx = [blockFrame.leftPx];
+  for (let i = 0; i < columnCount; i += 1) {
+    columnLeftsPx.push(
+      columnLeftsPx[i] + (plan.columnsTwips[i] ?? 0) * pxPerTwip
+    );
+  }
+  const rowCount = Math.max(
+    1,
+    plan.bandClasses.rows.length || plan.bandClasses.cells.reduce(
+      (max, c) => Math.max(max, c.rowIndex + 1),
+      0
+    )
+  );
+  const rowHeightPx = rowCount > 0 ? blockFrame.heightPx / rowCount : blockFrame.heightPx;
+  const rowTopsPx = [];
+  for (let r = 0; r <= rowCount; r += 1) {
+    rowTopsPx.push(blockFrame.topPx + r * rowHeightPx);
+  }
+  for (const cell of plan.bandClasses.cells) {
+    const sameRow = plan.bandClasses.cells.filter((c) => c.rowIndex === cell.rowIndex);
+    const sorted = [...sameRow].sort((a, b) => a.columnIndex - b.columnIndex);
+    const idx = sorted.findIndex((c) => c === cell);
+    const next = sorted[idx + 1];
+    const columnSpan = (next?.columnIndex ?? columnCount) - cell.columnIndex;
+    const left = columnLeftsPx[cell.columnIndex] ?? blockFrame.leftPx;
+    const right = columnLeftsPx[cell.columnIndex + columnSpan] ?? blockFrame.leftPx + blockFrame.widthPx;
+    const top = rowTopsPx[cell.rowIndex] ?? blockFrame.topPx;
+    const bottom = rowTopsPx[cell.rowIndex + 1] ?? blockFrame.topPx + blockFrame.heightPx;
+    cellRects.set(`${tableBlockId}:${cell.rowIndex}:${cell.columnIndex}`, {
+      leftPx: left,
+      topPx: top,
+      widthPx: Math.max(0, right - left),
+      heightPx: Math.max(0, bottom - top)
+    });
+  }
+  for (const handle of plan.columnResizeHandles) {
+    const x = blockFrame.leftPx + handle.originTwips * pxPerTwip;
+    columnEdges.set(`${tableBlockId}:${handle.columnIndex}`, {
+      leftPx: x,
+      topPx: blockFrame.topPx,
+      widthPx: 0,
+      heightPx: handle.heightTwips * pxPerTwip
+    });
+  }
+  for (let r = 0; r < rowCount - 1; r += 1) {
+    const y = rowTopsPx[r + 1] ?? blockFrame.topPx + blockFrame.heightPx;
+    rowEdges.set(`${tableBlockId}:${r}`, {
+      leftPx: blockFrame.leftPx,
+      topPx: y,
+      widthPx: blockFrame.widthPx,
+      heightPx: 0
+    });
+  }
+}
+function unionRects(a, b) {
+  if (!a) return b ?? null;
+  if (!b) return a;
+  const left = Math.min(a.leftPx, b.leftPx);
+  const top = Math.min(a.topPx, b.topPx);
+  const right = Math.max(a.leftPx + a.widthPx, b.leftPx + b.widthPx);
+  const bottom = Math.max(a.topPx + a.heightPx, b.topPx + b.heightPx);
+  return {
+    leftPx: left,
+    topPx: top,
+    widthPx: right - left,
+    heightPx: bottom - top
+  };
+}
+function buildDecorationIndex(pages) {
+  const workflow = [];
+  const comments = [];
+  const revisions = [];
+  const search = [];
+  const locked = [];
+  for (const page of pages) {
+    for (const block of page.regions.body.blocks) {
+      for (const decoration of block.blockDecorations) {
+        switch (decoration.kind) {
+          case "workflow":
+            workflow.push(decoration);
+            break;
+          case "comment":
+            comments.push(decoration);
+            break;
+          case "revision":
+            revisions.push(decoration);
+            break;
+          case "search":
+            search.push(decoration);
+            break;
+          case "locked":
+            locked.push(decoration);
+            break;
+        }
+      }
+    }
+  }
+  return { workflow, comments, revisions, search, locked };
+}
+function extractRevisionFromPageId(pageId) {
+  const match = /^page-(\d+)-/.exec(pageId);
+  if (!match) return pageId;
+  return Number(match[1]);
+}
+
 // src/core/selection/review-anchors.ts
 function detachReviewAnchor(lastKnownRange, reason) {
   return createDetachedAnchor(lastKnownRange, reason);
@@ -5112,6 +6281,11 @@ function freezeNumberingLayoutFacts(numbering) {
   if (numbering.numberingSourceRef) Object.freeze(numbering.numberingSourceRef);
   if (numbering.numberingInstanceSourceRef) Object.freeze(numbering.numberingInstanceSourceRef);
   if (numbering.abstractNumberingSourceRef) Object.freeze(numbering.abstractNumberingSourceRef);
+  if (numbering.markerTextPosture) Object.freeze(numbering.markerTextPosture);
+  if (numbering.pictureBulletPosture) {
+    if (numbering.pictureBulletPosture.sourceRef) Object.freeze(numbering.pictureBulletPosture.sourceRef);
+    Object.freeze(numbering.pictureBulletPosture);
+  }
   if (numbering.markerLane) Object.freeze(numbering.markerLane);
   if (numbering.textColumn) Object.freeze(numbering.textColumn);
   if (numbering.tabStops) {
@@ -6087,8 +7261,17 @@ function collectNumberingLayoutFacts(block) {
     ...block.resolvedNumbering?.format !== void 0 ? { format: block.resolvedNumbering.format } : {},
     ...block.resolvedNumbering?.formatPosture !== void 0 ? { formatPosture: { ...block.resolvedNumbering.formatPosture } } : {},
     ...block.numberingPrefix !== void 0 ? { markerText: block.numberingPrefix } : {},
+    ...block.resolvedNumbering?.markerTextPosture !== void 0 ? { markerTextPosture: { ...block.resolvedNumbering.markerTextPosture } } : {},
     ...block.numberingSuffix !== void 0 ? { markerSuffix: block.numberingSuffix } : {},
     ...block.resolvedNumbering?.geometry.markerJustification !== void 0 ? { markerJustification: block.resolvedNumbering.geometry.markerJustification } : {},
+    ...block.resolvedNumbering?.picBulletId !== void 0 ? { picBulletId: block.resolvedNumbering.picBulletId } : {},
+    ...block.resolvedNumbering?.picBulletMediaId !== void 0 ? { picBulletMediaId: block.resolvedNumbering.picBulletMediaId } : {},
+    ...block.resolvedNumbering?.pictureBulletPosture !== void 0 ? {
+      pictureBulletPosture: {
+        ...block.resolvedNumbering.pictureBulletPosture,
+        ...block.resolvedNumbering.pictureBulletPosture.sourceRef !== void 0 ? { sourceRef: { ...block.resolvedNumbering.pictureBulletPosture.sourceRef } } : {}
+      }
+    } : {},
     ...markerLane ? {
       markerLane: {
         startTwips: markerLane.start,
@@ -6902,8 +8085,8 @@ function fnv1a(input) {
 }
 
 // src/runtime/layout/layout-engine-version.ts
-var LAYOUT_ENGINE_VERSION = 93;
-var LAYCACHE_SCHEMA_VERSION = 12;
+var LAYOUT_ENGINE_VERSION = 94;
+var LAYCACHE_SCHEMA_VERSION = 13;
 
 // src/runtime/layout/layout-engine-instance.ts
 var FULL_VIEWPORT_WINDOW_KEY = "full";
@@ -7129,11 +8312,45 @@ function createLayoutEngine(options = {}) {
   const telemetryBus = options.telemetryBus;
   const dirtyFieldFamilies = /* @__PURE__ */ new Set();
   const listeners = /* @__PURE__ */ new Set();
-  let cachedKey = null;
-  let cachedGraph = null;
-  let cachedFormatting = null;
-  let cachedMapper = null;
+  let cachedFull = null;
+  let cachedWindowed = null;
   let previousPageCount = 0;
+  function isFullViewportKey(key) {
+    return key === FULL_VIEWPORT_WINDOW_KEY;
+  }
+  function getCachedSlot(viewportWindowKeyValue) {
+    return isFullViewportKey(viewportWindowKeyValue) ? cachedFull : cachedWindowed;
+  }
+  function preferredCachedGraph() {
+    return cachedFull?.graph ?? cachedWindowed?.graph ?? null;
+  }
+  function clearAllSlots() {
+    cachedFull = null;
+    cachedWindowed = null;
+  }
+  function clearWindowedSlot() {
+    cachedWindowed = null;
+  }
+  function evictStaleSiblingSlot(freshKey) {
+    const sibling = isFullViewportKey(freshKey.viewportWindowKey) ? cachedWindowed : cachedFull;
+    if (sibling === null) return;
+    if (sibling.key.content === freshKey.content && sibling.key.styles === freshKey.styles && sibling.key.subParts === freshKey.subParts) {
+      return;
+    }
+    if (isFullViewportKey(freshKey.viewportWindowKey)) {
+      cachedWindowed = null;
+    } else {
+      cachedFull = null;
+    }
+  }
+  function commitSlot(slot) {
+    if (isFullViewportKey(slot.key.viewportWindowKey)) {
+      cachedFull = slot;
+    } else {
+      cachedWindowed = slot;
+    }
+    evictStaleSiblingSlot(slot.key);
+  }
   let pendingInvalidation = null;
   function emit(event) {
     for (const listener of listeners) {
@@ -7279,27 +8496,31 @@ function createLayoutEngine(options = {}) {
       subParts: document2.subParts,
       anchors: layoutInputs.anchors
     });
+    const priorGraphForMaterialization = preferredCachedGraph();
     const graph = applyViewportWindowMaterialization(
       measuredGraph,
       viewportWindow,
-      cachedGraph
+      priorGraphForMaterialization
     );
-    const dirtyFamilies = computeFieldDirtiness(cachedGraph, graph);
+    const priorGraphForFieldDirtiness = preferredCachedGraph();
+    const dirtyFamilies = computeFieldDirtiness(priorGraphForFieldDirtiness, graph);
     for (const family of dirtyFamilies) {
       dirtyFieldFamilies.add(family);
     }
     const formatting = buildResolvedFormattingState(document2, mainSurface);
     const currentPageCount = graph.contentPageCount;
     const pageCountDelta = currentPageCount !== previousPageCount ? { previous: previousPageCount, current: currentPageCount } : void 0;
-    cachedKey = {
-      content: document2.content,
-      styles: document2.styles,
-      subParts: document2.subParts,
-      viewportWindowKey: viewportWindowKey(viewportWindow)
-    };
-    cachedGraph = graph;
-    cachedFormatting = formatting;
-    cachedMapper = createPageFragmentMapper(graph);
+    commitSlot({
+      key: {
+        content: document2.content,
+        styles: document2.styles,
+        subParts: document2.subParts,
+        viewportWindowKey: viewportWindowKey(viewportWindow)
+      },
+      graph,
+      formatting,
+      mapper: createPageFragmentMapper(graph)
+    });
     if (pageCountDelta) {
       emit({
         kind: "page_count_changed",
@@ -7340,7 +8561,7 @@ function createLayoutEngine(options = {}) {
     return graph;
   }
   function incrementalRelayout(input, pending) {
-    const priorGraph = cachedGraph;
+    const priorGraph = cachedFull?.graph ?? null;
     const range = pending.result.dirtyPageRange;
     if (!priorGraph || !range) return null;
     const telemetryOn = telemetryBus?.isEnabled("layout") ?? false;
@@ -7433,6 +8654,22 @@ function createLayoutEngine(options = {}) {
       deriveDocumentPageSnapshots(splicedGraph)
     );
     const pageCountDelta = currentPageCount !== previousPageCount ? { previous: previousPageCount, current: currentPageCount } : void 0;
+    const priorMapper = cachedFull?.mapper ?? null;
+    commitSlot({
+      key: {
+        content: document2.content,
+        styles: document2.styles,
+        subParts: document2.subParts,
+        viewportWindowKey: FULL_VIEWPORT_WINDOW_KEY
+      },
+      graph: splicedGraph,
+      formatting,
+      mapper: rebuildMapper(
+        priorMapper ?? createPageFragmentMapper(splicedGraph),
+        splicedGraph,
+        firstDirty
+      )
+    });
     if (pageCountDelta) {
       emit({
         kind: "page_count_changed",
@@ -7462,19 +8699,6 @@ function createLayoutEngine(options = {}) {
       ...dirtyFamilies.length > 0 ? { dirtyFieldFamilies: dirtyFamilies } : {},
       ...pageCountDelta ? { pageCountDelta } : {}
     });
-    cachedKey = {
-      content: document2.content,
-      styles: document2.styles,
-      subParts: document2.subParts,
-      viewportWindowKey: FULL_VIEWPORT_WINDOW_KEY
-    };
-    cachedGraph = splicedGraph;
-    cachedFormatting = formatting;
-    cachedMapper = rebuildMapper(
-      cachedMapper ?? createPageFragmentMapper(splicedGraph),
-      splicedGraph,
-      firstDirty
-    );
     if (telemetryOn) {
       emitRecomputeCompleted(
         "bounded",
@@ -7491,13 +8715,14 @@ function createLayoutEngine(options = {}) {
     const document2 = input.document;
     const normalizedWindow = normalizeViewportPageWindow(input.viewportPageWindow);
     const currentViewportWindowKey = viewportWindowKey(normalizedWindow);
-    const keyEqual = cachedGraph !== null && cachedKey !== null && cachedKey.content === document2.content && cachedKey.styles === document2.styles && cachedKey.subParts === document2.subParts && cachedKey.viewportWindowKey === currentViewportWindowKey;
+    const slot = getCachedSlot(currentViewportWindowKey);
+    const keyEqual = slot !== null && slot.key.content === document2.content && slot.key.styles === document2.styles && slot.key.subParts === document2.subParts && slot.key.viewportWindowKey === currentViewportWindowKey;
     if (keyEqual && pendingInvalidation === null) {
-      return cachedGraph;
+      return slot.graph;
     }
     const pending = pendingInvalidation;
     pendingInvalidation = null;
-    if (pending !== null && pending.result.scope === "bounded" && cachedGraph !== null && normalizedWindow === void 0) {
+    if (pending !== null && pending.result.scope === "bounded" && cachedFull !== null && normalizedWindow === void 0) {
       const spliced = incrementalRelayout(input, pending);
       if (spliced !== null) {
         return spliced;
@@ -7506,16 +8731,39 @@ function createLayoutEngine(options = {}) {
     }
     return fullRebuild(input, pending?.reason);
   }
+  function ensureSlotMapperAndFormatting(slot, document2) {
+    if (slot.mapper === null) {
+      slot.mapper = createPageFragmentMapper(slot.graph);
+    }
+    if (slot.formatting === null) {
+      const mainSurface = createEditorSurfaceSnapshot(
+        document2,
+        createSelectionSnapshot(0, 0),
+        MAIN_STORY_TARGET
+      );
+      slot.formatting = buildResolvedFormattingState(document2, mainSurface);
+    }
+  }
   function getMapper(input) {
     getGraphInternal(input);
-    return cachedMapper;
+    const currentViewportWindowKey = viewportWindowKey(
+      normalizeViewportPageWindow(input.viewportPageWindow)
+    );
+    const slot = getCachedSlot(currentViewportWindowKey);
+    ensureSlotMapperAndFormatting(slot, input.document);
+    return slot.mapper;
   }
   function getFormatting(input) {
     getGraphInternal(input);
-    return cachedFormatting;
+    const currentViewportWindowKey = viewportWindowKey(
+      normalizeViewportPageWindow(input.viewportPageWindow)
+    );
+    const slot = getCachedSlot(currentViewportWindowKey);
+    ensureSlotMapperAndFormatting(slot, input.document);
+    return slot.formatting;
   }
   if (autoUpgradeToCanvas && options.measurementProvider === void 0 && typeof document !== "undefined" && typeof HTMLCanvasElement !== "undefined") {
-    const readCachedRevision = () => cachedGraph?.revision ?? 0;
+    const readCachedRevision = () => preferredCachedGraph()?.revision ?? 0;
     void (async () => {
       try {
         const mod = await import("./measurement-backend-canvas-F7ZYDACK.js");
@@ -7525,10 +8773,7 @@ function createLayoutEngine(options = {}) {
           options.measurementCache,
           telemetryBus
         );
-        cachedKey = null;
-        cachedGraph = null;
-        cachedFormatting = null;
-        cachedMapper = null;
+        clearAllSlots();
         emit({
           kind: "measurement_backend_ready",
           revision: readCachedRevision(),
@@ -7572,22 +8817,19 @@ function createLayoutEngine(options = {}) {
       return getMapper(input);
     },
     invalidate(reason) {
-      const result = analyzeInvalidation(reason, cachedGraph);
+      const result = analyzeInvalidation(reason, preferredCachedGraph());
       for (const family of result.dirtyFieldFamilies) {
         dirtyFieldFamilies.add(family);
       }
       if (result.scope === "bounded") {
         pendingInvalidation = { reason, result };
       } else {
-        cachedKey = null;
-        cachedGraph = null;
-        cachedFormatting = null;
-        cachedMapper = null;
+        clearAllSlots();
         pendingInvalidation = { reason, result };
       }
     },
     analyzeInvalidation(reason) {
-      return analyzeInvalidation(reason, cachedGraph);
+      return analyzeInvalidation(reason, preferredCachedGraph());
     },
     getDirtyFieldFamilies() {
       return Array.from(dirtyFieldFamilies);
@@ -7615,14 +8857,11 @@ function createLayoutEngine(options = {}) {
         telemetryBus
       );
       if (previousFidelity !== provider.fidelity) {
-        cachedKey = null;
-        cachedGraph = null;
-        cachedFormatting = null;
-        cachedMapper = null;
+        clearAllSlots();
       }
       emit({
         kind: "measurement_backend_ready",
-        revision: cachedGraph?.revision ?? 0,
+        revision: preferredCachedGraph()?.revision ?? 0,
         fidelity: provider.fidelity
       });
     },
@@ -7637,30 +8876,33 @@ function createLayoutEngine(options = {}) {
      */
     invalidateMeasurementCache() {
       measurementProvider.invalidateCache();
-      cachedKey = null;
-      cachedGraph = null;
-      cachedFormatting = null;
-      cachedMapper = null;
+      clearAllSlots();
     },
     getMeasurementCacheStats() {
       if (!isCachedLayoutMeasurementProvider(measurementProvider)) return null;
       return measurementProvider.measurementCacheStats();
     },
     /**
-     * L7 Phase 2.5 — seed the cached graph from a prerender envelope.
-     * Populates both `cachedGraph` and `cachedKey` (keyed on the provided
-     * document's identity-equal slots) so the next getPageGraph query
-     * returns the seeded graph directly. Any subsequent mutation
-     * invalidates normally through the existing path.
+     * L7 Phase 2.5 — seed the full-slot cached graph from a prerender
+     * envelope. Populates the full slot (graph + key, with formatting and
+     * mapper computed lazily on first read) so the next viewport-
+     * independent `getPageGraph` query returns the seeded graph directly.
+     * Any subsequent mutation invalidates normally through the existing
+     * path; sibling eviction in `commitSlot` clears `cachedWindowed` if
+     * it carried a different document tuple.
      */
     seedCachedGraph(graph, document2) {
-      cachedGraph = graph;
-      cachedKey = {
-        content: document2.content,
-        styles: document2.styles,
-        subParts: document2.subParts,
-        viewportWindowKey: FULL_VIEWPORT_WINDOW_KEY
-      };
+      commitSlot({
+        key: {
+          content: document2.content,
+          styles: document2.styles,
+          subParts: document2.subParts,
+          viewportWindowKey: FULL_VIEWPORT_WINDOW_KEY
+        },
+        graph,
+        formatting: null,
+        mapper: null
+      });
       previousPageCount = graph.contentPageCount;
     }
   };
@@ -7941,33 +9183,6 @@ function resolveProjectedRuntimeRange(offsetMap, from, to) {
   return { from: runtimeFrom, to: runtimeTo };
 }
 
-// src/runtime/render/render-frame-types.ts
-var DEFAULT_PX_PER_TWIP = 96 / 1440;
-var PAGE_STACK_GAP_PX = 48;
-function resolveDefaultZoom(input = {}) {
-  return {
-    pxPerTwip: input.pxPerTwip ?? DEFAULT_PX_PER_TWIP,
-    viewportWidthPx: input.viewportWidthPx ?? 900,
-    fitMode: input.fitMode ?? "fixed"
-  };
-}
-var EMPTY_DECORATION_INDEX = Object.freeze({
-  workflow: Object.freeze([]),
-  comments: Object.freeze([]),
-  revisions: Object.freeze([]),
-  search: Object.freeze([]),
-  locked: Object.freeze([])
-});
-function defaultChromeReservations(layout, zoom) {
-  return {
-    railLaneTwips: 360,
-    balloonLaneTwips: 2160,
-    footnoteAreaTwips: 0,
-    pageFrameWidthPx: layout.pageWidth * zoom.pxPerTwip,
-    pageFrameHeightPx: layout.pageHeight * zoom.pxPerTwip
-  };
-}
-
 // src/runtime/markdown-sanitizer.ts
 function sanitizeMarkdown(raw) {
   let sanitized = false;
@@ -8080,6 +9295,16 @@ export {
   DEFAULT_UNKNOWN_BEHAVIOR,
   DEFAULT_REGISTRY_ENTRIES,
   createScopeTagRegistry,
+  PREDICTED_LANE_COUNTERS,
+  startPerfProbe,
+  finishPerfProbe,
+  recordPerfSample,
+  incrementInvalidationCounter,
+  createPagePatchPlan,
+  DEFAULT_PX_PER_TWIP,
+  PAGE_STACK_GAP_PX,
+  resolveDefaultZoom,
+  createRenderKernel,
   detachReviewAnchor,
   mapReviewAnchor,
   getAnchorRange,
@@ -8127,11 +9352,6 @@ export {
   searchProjectedSurfaceText,
   searchSecondaryStories,
   projectSurfaceText,
-  DEFAULT_PX_PER_TWIP,
-  PAGE_STACK_GAP_PX,
-  resolveDefaultZoom,
-  EMPTY_DECORATION_INDEX,
-  defaultChromeReservations,
   sanitizeMarkdown,
   sha256Hex,
   ISSUE_METADATA_ID,