@beyondwork/docx-react-component 1.0.85 → 1.0.87

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

@@ -25,8 +25,10 @@ import type {
   SurfaceBlockSnapshot,
 } from "../../api/public-types";
 import type { RuntimeBlockFragment } from "./page-graph.ts";
+import type { RuntimeLineBox } from "../../model/layout/page-graph-types.ts";
 import type {
   BlockSplits,
+  FragmentMeasurement,
   ParagraphLineSlice,
   TableRowSlice,
 } from "./paginated-layout-engine.ts";
@@ -38,6 +40,7 @@ export function projectSurfaceBlocksToPageFragments(
   pages: readonly DocumentPageSnapshot[],
   splits?: BlockSplits,
   columnByBlockIdByPageIndex?: ReadonlyMap<number, ReadonlyMap<string, number>>,
+  fragmentMeasurementsByPageIndex?: ReadonlyMap<number, ReadonlyMap<string, FragmentMeasurement>>,
 ): Map<number, FragmentWithoutPageId[]> {
   const byPage = new Map<number, FragmentWithoutPageId[]>();
   const perPageCounter = new Map<number, number>();
@@ -63,6 +66,13 @@ export function projectSurfaceBlocksToPageFragments(
   // Refactor/04 Slice 4 — per-block column placement lookup.
   const columnIndexFor = (pageIndex: number, blockId: string): number | undefined =>
     columnByBlockIdByPageIndex?.get(pageIndex)?.get(blockId);
+  const measuredHeightFor = (
+    pageIndex: number,
+    blockId: string,
+    fallback: number,
+  ): number =>
+    fragmentMeasurementsByPageIndex?.get(pageIndex)?.get(blockId)?.heightTwips ??
+    fallback;
 
   for (const block of surface.blocks) {
     // R3: table split across pages — emit one fragment per row slice.
@@ -78,7 +88,12 @@ export function projectSurfaceBlocksToPageFragments(
             pushFragment(pageIndex, {
               ...fragment,
               orderInRegion: nextOrder(pageIndex),
-              ...(columnIndex !== undefined ? { columnIndex } : {}),
+              heightTwips: fragment.heightTwips,
+              ...(fragment.columnIndex !== undefined
+                ? { columnIndex: fragment.columnIndex }
+                : columnIndex !== undefined
+                  ? { columnIndex }
+                  : {}),
             });
           },
         );
@@ -118,7 +133,11 @@ export function projectSurfaceBlocksToPageFragments(
       regionKind: "body",
       from: block.from,
       to: block.to,
-      heightTwips: estimateBlockHeightFromSpan(block),
+      heightTwips: measuredHeightFor(
+        pageIndex,
+        block.blockId,
+        estimateBlockHeightFromSpan(block),
+      ),
       ...deriveStyleMetadata(block),
       kind: "whole",
       ...(columnIndex !== undefined ? { columnIndex } : {}),
@@ -130,6 +149,69 @@ export function projectSurfaceBlocksToPageFragments(
   return byPage;
 }
 
+export function projectLineBoxesForPageFragments(
+  pages: readonly DocumentPageSnapshot[],
+  fragmentsByPageIndex: ReadonlyMap<
+    number,
+    ReadonlyArray<Omit<RuntimeBlockFragment, "pageId">>
+  >,
+  fragmentMeasurementsByPageIndex?: ReadonlyMap<number, ReadonlyMap<string, FragmentMeasurement>>,
+): Map<number, RuntimeLineBox[]> {
+  const byPage = new Map<number, RuntimeLineBox[]>();
+  for (const page of pages) {
+    const fragments = [...(fragmentsByPageIndex.get(page.pageIndex) ?? [])]
+      .filter((fragment) => fragment.regionKind === "body")
+      .sort((a, b) => a.orderInRegion - b.orderInRegion);
+    const lines: RuntimeLineBox[] = [];
+    let cursorTwips = 0;
+    for (const fragment of fragments) {
+      const measurement = fragmentMeasurementsByPageIndex
+        ?.get(page.pageIndex)
+        ?.get(fragment.blockId);
+      const explicitLines =
+        fragment.kind === "paragraph-slice" && fragment.paragraphLineRange
+          ? fragment.paragraphLineRange.to - fragment.paragraphLineRange.from
+          : measurement?.lineCount;
+      const lineCount = Math.max(
+        0,
+        explicitLines ?? (fragment.heightTwips > 0 ? 1 : 0),
+      );
+      if (lineCount === 0) {
+        cursorTwips += Math.max(0, fragment.heightTwips);
+        continue;
+      }
+      const lineHeight =
+        fragment.kind === "paragraph-slice" && fragment.paragraphLineRange
+          ? Math.max(1, Math.floor(fragment.heightTwips / lineCount))
+          : measurement?.lineHeightTwips ??
+            Math.max(1, Math.floor(fragment.heightTwips / lineCount));
+      const widthTwips =
+        measurement?.widthTwips ??
+        Math.max(
+          0,
+          page.layout.pageWidth -
+            page.layout.marginLeft -
+            page.layout.marginRight -
+            page.layout.gutter,
+        );
+      for (let lineIndex = 0; lineIndex < lineCount; lineIndex += 1) {
+        lines.push({
+          fragmentId: fragment.fragmentId,
+          lineIndex,
+          baselineTwips: cursorTwips + lineIndex * lineHeight,
+          heightTwips: lineHeight,
+          widthTwips,
+        });
+      }
+      cursorTwips += Math.max(0, fragment.heightTwips);
+    }
+    if (lines.length > 0) {
+      byPage.set(page.pageIndex, lines);
+    }
+  }
+  return byPage;
+}
+
 /**
  * Emit one fragment per slice for a paragraph that pagination split across
  * pages. The source `block` offset range stays intact on every slice; the
@@ -149,7 +231,7 @@ function emitSlicedParagraph(
       regionKind: "body",
       from: block.from,
       to: block.to,
-      heightTwips: estimateSliceHeightFromLines(slice.lineRange),
+      heightTwips: slice.heightTwips ?? estimateSliceHeightFromLines(slice.lineRange),
       ...deriveStyleMetadata(block),
       kind: "paragraph-slice",
       paragraphLineRange: slice.lineRange,
@@ -190,10 +272,11 @@ function emitSlicedTable(
       regionKind: "body",
       from: block.from,
       to: block.to,
-      heightTwips: estimateSliceHeightFromRows(slice.rowRange),
+      heightTwips: slice.heightTwips ?? estimateSliceHeightFromRows(slice.rowRange),
       ...deriveStyleMetadata(block),
       kind: "table-slice",
       tableRowRange: slice.rowRange,
+      ...(slice.columnIndex !== undefined ? { columnIndex: slice.columnIndex } : {}),
     };
     emit(slice.pageIndex, fragment);
   }

package/src/runtime/layout/resolve-page-fields.ts

@@ -14,7 +14,10 @@
  */
 
 import type { SupportedFieldFamily } from "../../model/canonical-document.ts";
-import { formatPageNumber } from "../formatting/field/page-number-format.ts";
+import {
+  formatPageNumber,
+  formatPageNumberWithChapter,
+} from "../formatting/field/page-number-format.ts";
 import type { PublicPageNode } from "./public-facet.ts";
 import type { RuntimePageGraph, RuntimePageNode } from "./page-graph.ts";
 
@@ -46,9 +49,9 @@ export function resolvePageFieldDisplayText(
 ): string {
   switch (family) {
     case "PAGE":
-      return formatPageNumber(
+      return formatPageNumberWithChapter(
         context.page.stories.displayPageNumber,
-        context.page.layout?.pageNumbering?.format,
+        context.page.layout?.pageNumbering,
       );
     case "NUMPAGES":
       // Blank fillers (evenPage/oddPage section breaks) don't count toward
@@ -78,9 +81,9 @@ export function resolvePublicPageFieldDisplayText(
 ): string {
   switch (family) {
     case "PAGE":
-      return formatPageNumber(
+      return formatPageNumberWithChapter(
         context.page.displayPageNumber,
-        context.page.layout.pageNumbering?.format,
+        context.page.layout.pageNumbering,
       );
     case "NUMPAGES":
       return formatPageNumber(

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

@@ -37,6 +37,12 @@
 
 import type { LayoutMeasurementProvider } from "./layout-measurement-provider.ts";
 import type { SurfaceBlockSnapshot } from "../../api/public-types";
+import {
+  buildRunFormattingMap,
+  calculateParagraphHeight,
+  resolveBlockFormatting,
+  type LayoutThemeFonts,
+} from "./resolved-formatting-state.ts";
 
 // Re-export the resolveCellWidth helper from paginated-layout-engine so the
 // math stays single-sourced.  The engine module exposes it via the
@@ -50,6 +56,9 @@ export interface MeasureTableRowHeightsInput {
   block: Extract<SurfaceBlockSnapshot, { kind: "table" }>;
   columnWidth: number;
   measurementProvider?: LayoutMeasurementProvider;
+  defaultTabInterval?: number;
+  themeFonts?: LayoutThemeFonts;
+  contentMode?: "legacy-min" | "resolved";
 }
 
 /**
@@ -65,7 +74,14 @@ export interface MeasureTableRowHeightsInput {
 export function measureTableRowHeights(
   input: MeasureTableRowHeightsInput,
 ): number[] {
-  const { block, columnWidth, measurementProvider } = input;
+  const {
+    block,
+    columnWidth,
+    measurementProvider,
+    defaultTabInterval = 720,
+    themeFonts,
+    contentMode = "legacy-min",
+  } = input;
   const heights: number[] = [];
 
   const totalGridTwips = block.gridColumns.reduce((sum, w) => sum + w, 0);
@@ -96,11 +112,15 @@ export function measureTableRowHeights(
       let cellContentHeight = 0;
       for (const child of cell.content) {
         if (child.kind === "paragraph") {
-          cellContentHeight += measureParagraphStandaloneHeight(
-            child,
-            cellWidth,
-            measurementProvider,
-          );
+          cellContentHeight += contentMode === "resolved"
+            ? measureParagraphStandaloneHeight(
+                child,
+                cellWidth,
+                measurementProvider,
+                defaultTabInterval,
+                themeFonts,
+              )
+            : MIN_ROW_HEIGHT_TWIPS;
         } else {
           cellContentHeight += MIN_ROW_HEIGHT_TWIPS;
         }
@@ -126,26 +146,80 @@ export function measureTableRowHeights(
 }
 
 /**
- * Lightweight paragraph height estimate used when walking table cell
- * content.  Matches the engine's internal measureTableHeight math
- * (MIN_ROW_HEIGHT_TWIPS per paragraph) rather than delegating back to
- * `measureBlockHeight`, which would require threading the
- * per-invocation cache through.  Since cell content already re-runs
- * through `measureBlockHeight` on the main pagination path, this
- * helper is only used by `measureTableRowHeights` for the split-math
- * preflight and does not affect canonical pagination.
+ * Paragraph height used when walking table cell content. This mirrors the
+ * paginator's paragraph measurement path closely enough for row-boundary
+ * decisions without importing `measureBlockHeight` back from the paginator.
  */
 function measureParagraphStandaloneHeight(
-  _block: SurfaceBlockSnapshot,
-  _columnWidth: number,
-  _provider: LayoutMeasurementProvider | undefined,
+  block: Extract<SurfaceBlockSnapshot, { kind: "paragraph" }>,
+  columnWidth: number,
+  provider: LayoutMeasurementProvider | undefined,
+  defaultTabInterval: number,
+  themeFonts: LayoutThemeFonts | undefined,
 ): number {
-  // P6.b scope: the engine's existing table measurement treats every
-  // cell paragraph as MIN_ROW_HEIGHT_TWIPS (see `measureTableHeight`
-  // inner loop).  P6.b preserves that exact constant so the split
-  // math agrees with pagination.  P6.c can upgrade this to call
-  // `measureBlockHeight` via the cache once the cache is threaded in.
-  return MIN_ROW_HEIGHT_TWIPS;
+  const formatting = resolveBlockFormatting(block, defaultTabInterval, themeFonts);
+  if (!formatting) return MIN_ROW_HEIGHT_TWIPS;
+  if (provider) {
+    const measured = provider.measureLineFragments({
+      block,
+      formatting,
+      runs: buildRunFormattingMap(block),
+      columnWidth,
+    });
+    const contentHeight = measured.lineHeights.reduce(
+      (total, lineHeight) => total + lineHeight,
+      0,
+    );
+    return Math.max(
+      MIN_ROW_HEIGHT_TWIPS,
+      contentHeight + formatting.spacingBefore + formatting.spacingAfter,
+    );
+  }
+  const firstLineWidth = Math.max(
+    1,
+    columnWidth -
+      formatting.indentLeft -
+      formatting.indentRight -
+      Math.max(0, formatting.firstLineIndent),
+  );
+  const subsequentLineWidth = Math.max(
+    1,
+    columnWidth - formatting.indentLeft - formatting.indentRight,
+  );
+  const firstCapacity = Math.max(
+    1,
+    Math.floor(firstLineWidth / formatting.averageCharWidthTwips),
+  );
+  const subsequentCapacity = Math.max(
+    1,
+    Math.floor(subsequentLineWidth / formatting.averageCharWidthTwips),
+  );
+  let lineCount = 1;
+  let current = 0;
+  let capacity = firstCapacity;
+  for (const segment of block.segments) {
+    if (segment.kind === "hard_break") {
+      lineCount += 1;
+      current = 0;
+      capacity = subsequentCapacity;
+      continue;
+    }
+    const advance =
+      segment.kind === "text"
+        ? Array.from(segment.text).length
+        : segment.kind === "tab"
+          ? 4
+          : segment.kind === "opaque_inline" && segment.presentation === "quiet-marker"
+            ? 0
+            : 1;
+    current += advance;
+    while (current > capacity) {
+      lineCount += 1;
+      current -= capacity;
+      capacity = subsequentCapacity;
+    }
+  }
+  return calculateParagraphHeight(formatting, lineCount);
 }
 
 export interface FindTableRowSplitInput {

package/src/runtime/surface-projection.ts

@@ -29,6 +29,7 @@ import type {
   SdtNode,
   ShapeNode,
   SmartArtPreviewNode,
+  LegacyFormFieldNode,
   BorderSpec,
   TableBorders,
   TableCellBorders,
@@ -1186,7 +1187,11 @@ function createParagraphBlock(
   let cursor = start;
   const children = Array.isArray(paragraph.children) ? paragraph.children : [];
 
-  for (const child of children) {
+  for (let childIndex = 0; childIndex < children.length; childIndex += 1) {
+    const child = children[childIndex];
+    if (isEmptyTocFieldWithCachedResult(child, children, childIndex)) {
+      continue;
+    }
     const result = appendInlineSegments(
       accumulator,
       child,
@@ -1210,6 +1215,54 @@ function createParagraphBlock(
   };
 }
 
+function isEmptyTocFieldWithCachedResult(
+  child: InlineNode,
+  siblings: readonly InlineNode[],
+  childIndex: number,
+): boolean {
+  if (child.type !== "field") return false;
+  if (child.fieldFamily !== "TOC") return false;
+  if (child.children.length > 0) return false;
+
+  for (let index = childIndex + 1; index < siblings.length; index += 1) {
+    if (isVisibleTocResultInline(siblings[index])) {
+      return true;
+    }
+  }
+  return false;
+}
+
+function isVisibleTocResultInline(node: InlineNode): boolean {
+  switch (node.type) {
+    case "text":
+      return node.text.length > 0;
+    case "hyperlink":
+      return node.children.some(isVisibleTocResultInline);
+    case "tab":
+    case "hard_break":
+    case "symbol":
+    case "image":
+    case "opaque_inline":
+    case "footnote_ref":
+    case "chart_preview":
+    case "smartart_preview":
+    case "shape":
+    case "wordart":
+    case "vml_shape":
+    case "drawing_frame":
+    case "ole_embed":
+      return true;
+    case "bookmark_start":
+    case "bookmark_end":
+    case "scope_marker_start":
+    case "scope_marker_end":
+    case "field":
+      return false;
+    default:
+      return false;
+  }
+}
+
 // `advanceNumberingCounterOnly`, `resolveEffectiveParagraphNumbering`,
 // `collectParagraphStyleChain`, `resolveStyleLinkedNumberingLevel`, and
 // `buildDirectRunFormattingFromMarks` were removed from surface-projection
@@ -1374,22 +1427,7 @@ function appendInlineSegments(
       return { nextCursor: start + 1, lockedFragmentIds: [node.fragmentId] };
     }
     case "chart_preview": {
-      let parsedChartId: string | undefined;
-      if (node.parsedData) {
-        parsedChartId = stableChartId(node.rawXml);
-        // Always call `set` (even when the entry exists) so the active
-        // `chartModelStore` build pass records the id in its seen-set —
-        // the pass uses the seen-set to evict stale entries from earlier
-        // builds. The entry object is a tiny reference so the set cost
-        // is negligible.
-        const { widthPx, heightPx } = extractChartDimensions(node.rawXml);
-        chartModelStore.set(parsedChartId, {
-          model: node.parsedData,
-          widthPx,
-          heightPx,
-          theme: undefined,
-        });
-      }
+      const parsedChartId = registerParsedChartPreview(node);
       return appendComplexPreviewSegment(paragraph, node, start, "Embedded chart", createChartDetail(node), {
         previewMediaId: node.previewMediaId,
         parsedChartId,
@@ -1467,14 +1505,37 @@ function appendInlineSegments(
         });
         return { nextCursor: start + 1, lockedFragmentIds: [] };
       }
-      const rawXml = "rawXml" in c ? c.rawXml : "";
-      const label =
-        c.type === "chart_preview"
-          ? "Embedded chart"
-          : c.type === "smartart_preview"
-            ? "SmartArt diagram"
-            : "Drawing frame";
-      return appendComplexPreviewSegment(paragraph, { rawXml } as DrawingFrameNode["content"] & { rawXml: string }, start, label, `DrawingFrame ${c.type} (${node.anchor.wrapMode}).`);
+      if (c.type === "chart_preview") {
+        const parsedChartId = registerParsedChartPreview(c);
+        return appendComplexPreviewSegment(
+          paragraph,
+          c,
+          start,
+          "Embedded chart",
+          `DrawingFrame chart_preview (${node.anchor.wrapMode}).`,
+          {
+            previewMediaId: c.previewMediaId,
+            parsedChartId,
+          },
+        );
+      }
+      if (c.type === "smartart_preview") {
+        return appendComplexPreviewSegment(
+          paragraph,
+          c,
+          start,
+          "SmartArt diagram",
+          `DrawingFrame smartart_preview (${node.anchor.wrapMode}).`,
+          { previewMediaId: c.previewMediaId },
+        );
+      }
+      return appendComplexPreviewSegment(
+        paragraph,
+        c,
+        start,
+        "Drawing frame",
+        `DrawingFrame ${c.type} (${node.anchor.wrapMode}).`,
+      );
     }
     case "symbol":
       paragraph.segments.push({
@@ -1530,6 +1591,51 @@ function appendInlineSegments(
       });
       return { nextCursor: start + 1, lockedFragmentIds: [] };
     case "field": {
+      const legacyFormDisplay = legacyFormFieldDisplay(node.legacyFormField);
+      if (legacyFormDisplay && !fieldHasVisibleChildren(node)) {
+        if (legacyFormDisplay.presentation === "checkbox") {
+          paragraph.segments.push({
+            segmentId: `${paragraph.blockId}-segment-${paragraph.segments.length}`,
+            kind: "opaque_inline",
+            from: start,
+            to: start + 1,
+            fragmentId: `legacy-form:${legacyFormDisplay.kind}:${start}`,
+            warningId: `warning:legacy-form:${start}`,
+            label: legacyFormDisplay.label,
+            detail: legacyFormDisplay.detail,
+            presentation: "checkbox",
+            displayText: legacyFormDisplay.text,
+            state: "locked-preserve-only",
+          });
+          return { nextCursor: start + 1, lockedFragmentIds: [] };
+        }
+
+        if (legacyFormDisplay.text.length > 0) {
+          paragraph.segments.push({
+            segmentId: `${paragraph.blockId}-segment-${paragraph.segments.length}`,
+            kind: "text",
+            from: start,
+            to: start + legacyFormDisplay.text.length,
+            text: legacyFormDisplay.text,
+          });
+          return { nextCursor: start + legacyFormDisplay.text.length, lockedFragmentIds: [] };
+        }
+
+        paragraph.segments.push({
+          segmentId: `${paragraph.blockId}-segment-${paragraph.segments.length}`,
+          kind: "opaque_inline",
+          from: start,
+          to: start + 1,
+          fragmentId: `legacy-form:${legacyFormDisplay.kind}:${start}`,
+          warningId: `warning:legacy-form:${start}`,
+          label: legacyFormDisplay.label,
+          detail: legacyFormDisplay.detail,
+          presentation: "quiet-marker",
+          state: "locked-preserve-only",
+        });
+        return { nextCursor: start + 1, lockedFragmentIds: [] };
+      }
+
       const isSupportedField =
         node.fieldFamily === "REF" ||
         node.fieldFamily === "PAGEREF" ||
@@ -1565,9 +1671,12 @@ function appendInlineSegments(
         return { nextCursor: start + 1, lockedFragmentIds: [] };
       }
       if (node.children && node.children.length > 0) {
-        // For REF \h, pass the bookmark as a hyperlink href so child text gets hyperlink styling
+        // For REF/PAGEREF/NOTEREF \h, pass the bookmark as a hyperlink
+        // href so cached result text gets hyperlink styling.
         const refHyperlinkHref =
-          node.fieldFamily === "REF" &&
+          (node.fieldFamily === "REF" ||
+            node.fieldFamily === "PAGEREF" ||
+            node.fieldFamily === "NOTEREF") &&
           node.switches?.hyperlink === true &&
           node.fieldTarget
             ? `#${node.fieldTarget}`
@@ -1643,6 +1752,97 @@ function appendInlineSegments(
   }
 }
 
+function registerParsedChartPreview(node: ChartPreviewNode): string | undefined {
+  if (!node.parsedData) return undefined;
+  const parsedChartId = stableChartId(node.rawXml);
+  // Always call `set` (even when the entry exists) so the active
+  // `chartModelStore` build pass records the id in its seen-set; the
+  // pass uses that seen-set to evict stale entries from earlier builds.
+  const { widthPx, heightPx } = extractChartDimensions(node.rawXml);
+  chartModelStore.set(parsedChartId, {
+    model: node.parsedData,
+    widthPx,
+    heightPx,
+    theme: undefined,
+  });
+  return parsedChartId;
+}
+
+function fieldHasVisibleChildren(node: Extract<InlineNode, { type: "field" }>): boolean {
+  return (node.children ?? []).some((child) => inlineNodeHasVisibleText(child));
+}
+
+function inlineNodeHasVisibleText(node: InlineNode): boolean {
+  switch (node.type) {
+    case "text":
+      return node.text.trim().length > 0;
+    case "tab":
+    case "hard_break":
+    case "image":
+    case "footnote_ref":
+    case "symbol":
+    case "chart_preview":
+    case "smartart_preview":
+    case "shape":
+    case "wordart":
+    case "vml_shape":
+    case "drawing_frame":
+    case "ole_embed":
+      return true;
+    case "hyperlink":
+    case "field":
+      return node.children.some((child) => inlineNodeHasVisibleText(child));
+    default:
+      return false;
+  }
+}
+
+function legacyFormFieldDisplay(
+  legacyFormField: LegacyFormFieldNode | undefined,
+): {
+  kind: LegacyFormFieldNode["kind"];
+  text: string;
+  label: string;
+  detail: string;
+  presentation?: "checkbox";
+} | undefined {
+  if (!legacyFormField) return undefined;
+  switch (legacyFormField.kind) {
+    case "textInput": {
+      const value = legacyFormField.textInput?.default;
+      return {
+        kind: legacyFormField.kind,
+        text: value && value.length > 0 ? value : "",
+        label: "Legacy text form field",
+        detail: "Word legacy text form field preserved from ffData.",
+      };
+    }
+    case "checkBox": {
+      const checked =
+        legacyFormField.checkBox?.checked ??
+        legacyFormField.checkBox?.default ??
+        false;
+      return {
+        kind: legacyFormField.kind,
+        text: checked ? "☒" : "☐",
+        label: "Legacy checkbox form field",
+        detail: "Word legacy checkbox form field preserved from ffData.",
+        presentation: "checkbox",
+      };
+    }
+    case "ddList": {
+      const entries = legacyFormField.ddList?.listEntry ?? [];
+      const index = legacyFormField.ddList?.default ?? 0;
+      return {
+        kind: legacyFormField.kind,
+        text: entries[index] ?? entries[0] ?? "",
+        label: "Legacy dropdown form field",
+        detail: "Word legacy dropdown form field preserved from ffData.",
+      };
+    }
+  }
+}
+
 /**
  * V2c.4 — Map a canonical `AnchorGeometry` onto the surface anchor type.
  * Returns `undefined` when the anchor carries only the trivial inline

package/src/shell/session-bootstrap.ts

@@ -1486,7 +1486,12 @@ export async function persistAndExport(input: {
   const saveExport = input.hostAdapter?.saveExport ?? input.datastore?.saveExport;
   const saveExportSource = input.hostAdapter?.saveExport ? "host" : "datastore";
   if (!saveExport) {
-    result = downloadExportResult(result);
+    result =
+      input.options?.download === false
+        ? withExportDelivery(result, {
+            mode: "exported-bytes-only",
+          })
+        : downloadExportResult(result);
     emitEditorEvent({
       hostAdapter: input.hostAdapter,
       datastore: input.datastore,