@beyondwork/docx-react-component 1.0.43 → 1.0.45

package/src/core/selection/review-anchors.ts

@@ -116,12 +116,61 @@ export function canCreateDocxCommentAnchor(
     return false;
   }
 
-  return rangeStaysWithinSingleParagraph(content, normalized);
+  return rangeStaysWithinCommentableStory(content, normalized);
+}
+
+export function rangeStaysWithinCommentableStory(
+  content: unknown,
+  range: DocRange,
+): boolean {
+  const normalized = normalizeRange(range);
+  if (normalized.from === normalized.to) {
+    return false;
+  }
+
+  const surfaceBlocks = readSurfaceBlocks(content);
+  if (surfaceBlocks) {
+    const fromOwner = findContainingParagraphForEndpoint(surfaceBlocks, normalized.from, "start");
+    const toOwner = findContainingParagraphForEndpoint(surfaceBlocks, normalized.to, "end");
+    if (!fromOwner || !toOwner) {
+      return false;
+    }
+    if (fromOwner.tableId !== toOwner.tableId) {
+      return false;
+    }
+    if (fromOwner.tableCellId !== toOwner.tableCellId) {
+      return false;
+    }
+    return !rangeCrossesOpaqueOrTableBoundary(
+      surfaceBlocks,
+      normalized,
+      fromOwner,
+    );
+  }
+
+  const story = parseTextStory(content);
+  const upperBound = Math.min(normalized.to, story.units.length);
+  for (let index = Math.max(0, normalized.from); index < upperBound; index += 1) {
+    const unit = story.units[index];
+    if (!unit) continue;
+    if (unit.kind === "opaque_block") {
+      return false;
+    }
+  }
+  return true;
+}
+
+interface FlattenedSurfaceBlock {
+  kind: string;
+  from: number;
+  to: number;
+  tableId: string | null;
+  tableCellId: string | null;
 }
 
 function readSurfaceBlocks(
   content: unknown,
-): Array<{ kind: string; from: number; to: number }> | undefined {
+): FlattenedSurfaceBlock[] | undefined {
   if (!content || typeof content !== "object" || !("blocks" in content)) {
     return undefined;
   }
@@ -131,17 +180,19 @@ function readSurfaceBlocks(
     return undefined;
   }
 
-  const normalized = flattenSurfaceBlocks(blocks);
+  const normalized = flattenSurfaceBlocks(blocks, null, null);
 
   return normalized.length > 0 ? normalized : undefined;
 }
 
 function flattenSurfaceBlocks(
   blocks: unknown[],
-): Array<{ kind: string; from: number; to: number }> {
-  const flattened: Array<{ kind: string; from: number; to: number }> = [];
+  tableId: string | null,
+  tableCellId: string | null,
+): FlattenedSurfaceBlock[] {
+  const flattened: FlattenedSurfaceBlock[] = [];
 
-  for (const block of blocks) {
+  for (const [blockIndex, block] of blocks.entries()) {
     if (
       !block ||
       typeof block !== "object" ||
@@ -152,32 +203,91 @@ function flattenSurfaceBlocks(
       continue;
     }
 
-    flattened.push({
-      kind: (block as { kind: string }).kind,
-      from: (block as { from: number }).from,
-      to: (block as { to: number }).to,
-    });
+    const kind = (block as { kind: string }).kind;
+    const from = (block as { from: number }).from;
+    const to = (block as { to: number }).to;
 
-    if (
-      (block as { kind: string }).kind === "table" &&
-      Array.isArray((block as { rows?: unknown }).rows)
-    ) {
-      for (const row of (block as { rows: Array<{ cells?: unknown[] }> }).rows) {
-        for (const cell of row.cells ?? []) {
+    flattened.push({ kind, from, to, tableId, tableCellId });
+
+    if (kind === "table" && Array.isArray((block as { rows?: unknown }).rows)) {
+      const nextTableId =
+        (block as { blockId?: string }).blockId ?? `table-${from}-${to}-${blockIndex}`;
+      const rows = (block as { rows: Array<{ cells?: unknown[] }> }).rows;
+      for (const [rowIdx, row] of rows.entries()) {
+        for (const [cellIdx, cell] of (row.cells ?? []).entries()) {
           if (cell && typeof cell === "object" && Array.isArray((cell as { content?: unknown[] }).content)) {
-            flattened.push(...flattenSurfaceBlocks((cell as { content: unknown[] }).content));
+            const cellFingerprint = `${nextTableId}-r${rowIdx}-c${cellIdx}`;
+            flattened.push(
+              ...flattenSurfaceBlocks(
+                (cell as { content: unknown[] }).content,
+                nextTableId,
+                cellFingerprint,
+              ),
+            );
           }
         }
       }
     }
 
     if (
-      (block as { kind: string }).kind === "sdt_block" &&
-      Array.isArray((block as { children?: unknown[] }).children)
+      kind === "sdt_block" &&
+      Array.isArray((block as { children?: unknown }).children)
     ) {
-      flattened.push(...flattenSurfaceBlocks((block as { children: unknown[] }).children));
+      flattened.push(
+        ...flattenSurfaceBlocks(
+          (block as { children: unknown[] }).children,
+          tableId,
+          tableCellId,
+        ),
+      );
     }
   }
 
   return flattened;
 }
+
+function findContainingParagraphForEndpoint(
+  blocks: readonly FlattenedSurfaceBlock[],
+  offset: number,
+  kind: "start" | "end",
+): FlattenedSurfaceBlock | null {
+  const matches = blocks.filter(
+    (block) =>
+      block.kind === "paragraph" && offset >= block.from && offset <= block.to,
+  );
+  if (matches.length === 0) return null;
+  if (matches.length === 1) return matches[0]!;
+  // When an offset sits exactly on a paragraph boundary it matches the
+  // trailing paragraph as well as the leading one. For a start endpoint we
+  // prefer the later paragraph (the range extends forward from it); for an
+  // end endpoint we prefer the earlier paragraph (the range ends there).
+  if (kind === "start") {
+    return matches.reduce((a, b) => (b.from >= a.from ? b : a));
+  }
+  return matches.reduce((a, b) => (b.to <= a.to ? b : a));
+}
+
+function rangeCrossesOpaqueOrTableBoundary(
+  blocks: readonly FlattenedSurfaceBlock[],
+  range: DocRange,
+  origin: FlattenedSurfaceBlock,
+): boolean {
+  for (const block of blocks) {
+    const overlapFrom = Math.max(block.from, range.from);
+    const overlapTo = Math.min(block.to, range.to);
+    if (overlapTo <= overlapFrom) continue;
+
+    if (block.kind === "opaque_block") {
+      return true;
+    }
+
+    if (
+      block.kind === "paragraph" &&
+      (block.tableId !== origin.tableId ||
+        block.tableCellId !== origin.tableCellId)
+    ) {
+      return true;
+    }
+  }
+  return false;
+}

package/src/index.ts

@@ -13,7 +13,7 @@ export { ISSUE_METADATA_ID, REVIEW_ACTION_METADATA_ID } from "./api/public-types
 // P17 — metadata persistence error class.
 export { MetadataResolverMissingError } from "./api/public-types.ts";
 
-// Collab substrate (P1 – P8f + P14). See docs/plans/collab-master-plan.md
+// Collab substrate (P1 – P8f + P14). See docs/plans/lane-4-collab-clm-vallor.md
 // for the shipped-slice table. Surfaces are stable for host integration;
 // the chrome preset + markdown renderer land in P9 / P10.
 export { createCollabSession } from "./runtime/collab-session.ts";
@@ -121,6 +121,7 @@ export type {
   LoadSourcePolicy,
   EditorSessionState,
   EditorHostAdapter,
+  ChartPreviewResolveParams,
   WordReviewEditorProps,
   WordReviewEditorChromePreset,
   WordReviewEditorChromeOptions,
@@ -185,6 +186,8 @@ export type {
   SnapshotRefreshChangeKind,
   SnapshotRefreshHints,
   AddCommentParams,
+  AddCommentResult,
+  AddCommentReplyResult,
   ExportDocxOptions,
   ExportResult,
   AutosaveConfig,
@@ -281,3 +284,15 @@ export type {
   EditorStatePartLoadFailure,
   EditorStatePartPersistFailure,
 } from "./api/public-types.ts";
+
+// L7 Phase 2.5 — prerender cache public API. Platforms / ingest workers
+// call `prerenderDocument(buffer)` on template upload to populate the
+// cache; end-user opens read the cache and skip the layout pass. See
+// docs/plans/lane-2-render-performance.md §Phase 2.5.
+export { prerenderDocument } from "./runtime/prerender/prerender-document.ts";
+export type {
+  PrerenderOptions,
+  PrerenderResult,
+  PrerenderCounters,
+} from "./runtime/prerender/prerender-document.ts";
+export type { CacheEnvelope } from "./runtime/prerender/cache-envelope.ts";

package/src/io/chart-preview-resolver.ts

@@ -0,0 +1,281 @@
+/**
+ * Stage 0B.1 — chart preview resolver.
+ *
+ * Given a freshly imported `CanonicalDocument` and the source
+ * `OpcPackage`, iterate every `chart_preview` inline node whose
+ * `previewMediaId` is unset, extract the chart part XML + theme, and
+ * ask the host adapter's `renderChartPreview` callback for preview
+ * bytes. Successful returns become synthesized `MediaItem` entries on
+ * the document; unresolved charts keep their existing shape so
+ * downstream rendering falls back to the Stage 0 typed badge.
+ *
+ * Pure Node-side. No React imports. Not reachable from the edit path
+ * (runs at import time only) so §Performance Invariants in CLAUDE.md
+ * about synchronous layout reads do not apply.
+ *
+ * See docs/plans/lane-5-charts.md §2 Task 2.
+ */
+
+import type {
+  BlockNode,
+  CanonicalDocument,
+  ChartPreviewNode,
+  DocumentRootNode,
+  InlineNode,
+  MediaItem,
+  ParagraphNode,
+} from "../model/canonical-document.ts";
+import type {
+  ChartPreviewResolveParams,
+  EditorHostAdapter,
+} from "../api/public-types.ts";
+import type { OpcPackage } from "./opc/package-reader.ts";
+import { normalizePartPath, resolveRelationshipTarget } from "./ooxml/part-manifest.ts";
+
+interface ResolveContext {
+  readonly package: OpcPackage;
+  readonly adapter: EditorHostAdapter;
+  readonly themeXml: string | undefined;
+  /** Monotonic counter so we can generate unique media ids across one run. */
+  seq: number;
+}
+
+interface PendingResolution {
+  /** Path from the document root to the chart_preview node, used to surgically replace the node on resolution. */
+  readonly pointer: Pointer;
+  readonly node: ChartPreviewNode;
+  readonly chartPartPath: string;
+  readonly chartXml: string;
+  readonly widthEmu: number;
+  readonly heightEmu: number;
+}
+
+type Pointer = Array<number>;
+
+export async function resolveChartPreviewsForDocument(
+  doc: CanonicalDocument,
+  pkg: OpcPackage,
+  adapter: EditorHostAdapter | undefined,
+): Promise<CanonicalDocument> {
+  if (!adapter?.renderChartPreview) return doc;
+
+  const pending = collectUnresolvedChartPreviews(doc, pkg);
+  if (pending.length === 0) return doc;
+
+  const themeXml = extractPartTextFromPackage(pkg, "/word/theme/theme1.xml");
+  const renderer = adapter.renderChartPreview;
+  const ctx: ResolveContext = { package: pkg, adapter, themeXml, seq: 0 };
+
+  const resolutions = await Promise.all(
+    pending.map(async (entry) => {
+      const params: ChartPreviewResolveParams = {
+        chartXml: entry.chartXml,
+        chartPartPath: entry.chartPartPath,
+        themeXml,
+        widthEmu: entry.widthEmu,
+        heightEmu: entry.heightEmu,
+      };
+      try {
+        const bytes = await renderer(params);
+        if (!bytes || bytes.length === 0) return null;
+        return { entry, bytes };
+      } catch (err) {
+        try {
+          adapter.logEvent?.({
+            type: "chart_preview_render_failed",
+            documentId: doc.docId,
+            detail: {
+              chartPartPath: entry.chartPartPath,
+              message: err instanceof Error ? err.message : String(err),
+            },
+          });
+        } catch {
+          // Host's logEvent can throw too; swallow silently — one chart failing
+          // must never surface as an unhandled rejection during import.
+        }
+        return null;
+      }
+    }),
+  );
+
+  const successful = resolutions.filter(
+    (r): r is { entry: PendingResolution; bytes: Uint8Array } => r !== null,
+  );
+  if (successful.length === 0) return doc;
+
+  void ctx; // resolveContext is reserved for future use (caching, progress events)
+  return applyResolutions(doc, successful);
+}
+
+/**
+ * Walk the whole content tree and yield one PendingResolution per
+ * chart_preview node that (a) has no previewMediaId yet and (b) can
+ * resolve its chart part from the package. The pointer path lets
+ * `applyResolutions` rewrite those exact nodes without touching the
+ * surrounding structure.
+ */
+function collectUnresolvedChartPreviews(doc: CanonicalDocument, pkg: OpcPackage): PendingResolution[] {
+  const out: PendingResolution[] = [];
+  const documentRels = collectDocumentPartRelationships(pkg);
+
+  const paragraphs = doc.content.children;
+  for (let i = 0; i < paragraphs.length; i++) {
+    const block = paragraphs[i]!;
+    if (block.type !== "paragraph") continue;
+    const paragraph = block as ParagraphNode;
+    for (let j = 0; j < paragraph.children.length; j++) {
+      const child = paragraph.children[j];
+      if (!child || child.type !== "chart_preview") continue;
+      const chartNode = child as ChartPreviewNode;
+      if (chartNode.previewMediaId) continue;
+      const resolved = resolveChartPart(chartNode, documentRels, pkg);
+      if (!resolved) continue;
+      out.push({
+        pointer: [i, j],
+        node: chartNode,
+        chartPartPath: resolved.chartPartPath,
+        chartXml: resolved.chartXml,
+        widthEmu: resolved.widthEmu,
+        heightEmu: resolved.heightEmu,
+      });
+    }
+  }
+  return out;
+}
+
+function collectDocumentPartRelationships(pkg: OpcPackage): Map<string, string> {
+  // Only walk /word/document.xml for Stage 0B.1; headers/footers/endnotes
+  // carry charts rarely and will be a later iteration.
+  const docPart = pkg.parts.get("/word/document.xml");
+  if (!docPart?.relationships) return new Map();
+  const map = new Map<string, string>();
+  for (const rel of docPart.relationships) {
+    if (rel.targetMode !== "internal") continue;
+    if (!rel.type.endsWith("/chart")) continue;
+    const target = resolveRelationshipTarget("/word/document.xml", rel);
+    map.set(rel.id, normalizePartPath(target));
+  }
+  return map;
+}
+
+interface ResolvedChartLocation {
+  chartPartPath: string;
+  chartXml: string;
+  widthEmu: number;
+  heightEmu: number;
+}
+
+function resolveChartPart(
+  node: ChartPreviewNode,
+  documentRels: Map<string, string>,
+  pkg: OpcPackage,
+): ResolvedChartLocation | null {
+  const relId = extractChartRelId(node.rawXml);
+  if (!relId) return null;
+  const chartPartPath = documentRels.get(relId);
+  if (!chartPartPath) return null;
+  const chartXml = extractPartTextFromPackage(pkg, chartPartPath);
+  if (!chartXml) return null;
+  const extent = extractDrawingExtent(node.rawXml);
+  return {
+    chartPartPath,
+    chartXml,
+    widthEmu: extent.widthEmu,
+    heightEmu: extent.heightEmu,
+  };
+}
+
+/** Find `<c:chart ... r:id="rIdN"/>` and return the relationship id. */
+function extractChartRelId(rawXml: string): string | null {
+  const match = /<c:chart\b[^>]*?r:id="([^"]+)"/.exec(rawXml);
+  return match ? match[1]! : null;
+}
+
+/** Read `<wp:extent cx="..." cy="..."/>` out of the drawing XML. */
+function extractDrawingExtent(rawXml: string): { widthEmu: number; heightEmu: number } {
+  const match = /<wp:extent\b([^/>]*)\/>/.exec(rawXml);
+  if (!match) return { widthEmu: 5486400, heightEmu: 3200400 };
+  const attrs = match[1] ?? "";
+  const cx = /\bcx="(\d+)"/.exec(attrs)?.[1];
+  const cy = /\bcy="(\d+)"/.exec(attrs)?.[1];
+  return {
+    widthEmu: cx ? parseInt(cx, 10) : 5486400,
+    heightEmu: cy ? parseInt(cy, 10) : 3200400,
+  };
+}
+
+function extractPartTextFromPackage(pkg: OpcPackage, path: string): string | undefined {
+  const part = pkg.parts.get(path);
+  if (!part?.bytes) return undefined;
+  try {
+    return new TextDecoder("utf-8").decode(part.bytes);
+  } catch {
+    return undefined;
+  }
+}
+
+/**
+ * Produce a new CanonicalDocument with the resolved chart_preview
+ * nodes carrying previewMediaId + corresponding MediaCatalog entries.
+ * Never mutates the input doc.
+ */
+function applyResolutions(
+  doc: CanonicalDocument,
+  resolutions: Array<{ entry: PendingResolution; bytes: Uint8Array }>,
+): CanonicalDocument {
+  const newMediaItems: Record<string, MediaItem> = { ...doc.media.items };
+  const updates = new Map<string, { previewMediaId: string }>();
+
+  let seq = 0;
+  for (const { entry, bytes } of resolutions) {
+    seq += 1;
+    const contentType = inferPreviewContentType(bytes);
+    const extension = contentType === "image/png" ? "png" : "svg";
+    const packagePartName = `/word/media/chart-preview-synth-${seq}.${extension}`;
+    const mediaId = `media:word/media/chart-preview-synth-${seq}.${extension}`;
+    newMediaItems[mediaId] = {
+      mediaId,
+      contentType,
+      filename: packagePartName.slice(packagePartName.lastIndexOf("/") + 1),
+      packagePartName,
+      widthEmu: entry.widthEmu,
+      heightEmu: entry.heightEmu,
+    };
+    const pointerKey = entry.pointer.join(",");
+    updates.set(pointerKey, { previewMediaId: mediaId });
+  }
+
+  if (updates.size === 0) return doc;
+
+  // Clone the content tree along pointer paths only — everything else
+  // keeps object identity so downstream React memoization stays stable.
+  const newParagraphs: BlockNode[] = doc.content.children.slice();
+  for (const [pointerKey, update] of updates) {
+    const [pi, ci] = pointerKey.split(",").map((s) => parseInt(s, 10)) as [number, number];
+    const paragraph = newParagraphs[pi];
+    if (!paragraph || paragraph.type !== "paragraph") continue;
+    const newChildren: InlineNode[] = (paragraph as ParagraphNode).children.slice();
+    const existing = newChildren[ci];
+    if (!existing || existing.type !== "chart_preview") continue;
+    newChildren[ci] = { ...(existing as ChartPreviewNode), previewMediaId: update.previewMediaId };
+    newParagraphs[pi] = { ...(paragraph as ParagraphNode), children: newChildren };
+  }
+
+  const newContent: DocumentRootNode = { ...doc.content, children: newParagraphs };
+  const newMedia = { items: newMediaItems };
+  return { ...doc, content: newContent, media: newMedia };
+}
+
+/**
+ * Content-type sniff from the first bytes of the rendered preview.
+ * PNG magic is 0x89 0x50 0x4E 0x47; everything else is assumed to be
+ * SVG text. Hosts that need a different content type should extend
+ * this in a follow-up.
+ */
+function inferPreviewContentType(bytes: Uint8Array): string {
+  if (bytes.length >= 4 &&
+      bytes[0] === 0x89 && bytes[1] === 0x50 && bytes[2] === 0x4e && bytes[3] === 0x47) {
+    return "image/png";
+  }
+  return "image/svg+xml";
+}

package/src/io/docx-session.ts

@@ -1,6 +1,7 @@
 import type {
   CompatibilityReport as PublicCompatibilityReport,
   EditorError,
+  EditorHostAdapter,
   EditorSessionState,
   EditorWarning as PublicEditorWarning,
   EditorAnchorProjection as PublicEditorAnchorProjection,
@@ -43,6 +44,7 @@ import {
   normalizeParsedTextDocument,
   normalizeParsedTextDocumentAsync,
 } from "./normalize/normalize-text.ts";
+import { resolveChartPreviewsForDocument } from "./chart-preview-resolver.ts";
 import { type LoadScheduler } from "./load-scheduler.ts";
 import {
   CONTENT_TYPES_PATH,
@@ -228,6 +230,15 @@ interface LoadDocxEditorSessionOptions {
    * change.
    */
   onLoadStage?: (stage: import("../api/public-types.ts").LoadStage, durationMs: number) => void;
+  /**
+   * Stage 0B.1: host-adapter surface. The sync loader accepts the option for
+   * API symmetry with {@link LoadDocxEditorSessionAsyncOptions} but does not
+   * invoke `renderChartPreview` — chart-preview synthesis is asynchronous, so
+   * hosts that want preview bitmaps must call {@link loadDocxEditorSessionAsync}.
+   * Other adapter methods (load/saveSession/logEvent) are not consumed by the
+   * loader itself and are carried through unchanged.
+   */
+  hostAdapter?: EditorHostAdapter;
 }
 
 export interface LoadedDocxEditorSession {
@@ -1322,7 +1333,7 @@ export async function loadDocxEditorSessionAsync(
       workflowMetadata: embeddedWorkflowMetadata,
       timestamp,
     });
-    const document = createImportedCanonicalDocument({
+    const importedDocument = createImportedCanonicalDocument({
       documentId: options.documentId,
       timestamp,
       numbering: parsedNumbering,
@@ -1377,6 +1388,15 @@ export async function loadDocxEditorSessionAsync(
         ]),
       },
     });
+    // Stage 0B.1: if the host implements `renderChartPreview`, resolve
+    // chart_preview nodes inline so the first snapshot already carries the
+    // synthesized `previewMediaId`. Fallback-safe: returning null or throwing
+    // is per-chart — the typed badge renders as if the adapter weren't set.
+    const document = (await resolveChartPreviewsForDocument(
+      importedDocument,
+      sourcePackage,
+      options.hostAdapter,
+    )) as CanonicalDocumentEnvelope;
     const compatibility = buildCompatibilityReport({
       document,
       generatedAt: timestamp,

package/src/io/export/build-app-properties-xml.ts

@@ -7,7 +7,7 @@
  * content type.
  *
  * Required by:
- *   docs/plans/close-render-fidelity.md §2 A.5
+ *   docs/plans/lane-3-layout-engine-ooxml-fidelity.md §2 A.5
  *
  * Schema shape (ECMA-376 Part 1, Office Extended properties):
  *   <Properties xmlns="…/extended-properties" xmlns:vt="…/docPropsVTypes">

package/src/io/export/serialize-comments.ts

@@ -267,19 +267,16 @@ export function serializeCommentAnchorsIntoDocumentXml(
       continue;
     }
 
-    const paragraph = paragraphs.find(
-      (candidate) =>
-        anchor.range.from >= candidate.start &&
-        anchor.range.to <= candidate.end,
-    );
+    const startParagraph = findParagraphForEndpoint(paragraphs, anchor.range.from, "start");
+    const endParagraph = findParagraphForEndpoint(paragraphs, anchor.range.to, "end");
 
-    if (!paragraph) {
+    if (!startParagraph || !endParagraph) {
       skippedCommentIds.push(thread.commentId);
       continue;
     }
 
-    const startIndex = paragraph.boundaries.get(anchor.range.from);
-    const endIndex = paragraph.boundaries.get(anchor.range.to);
+    const startIndex = startParagraph.boundaries.get(anchor.range.from);
+    const endIndex = endParagraph.boundaries.get(anchor.range.to);
 
     if (startIndex === undefined || endIndex === undefined) {
       skippedCommentIds.push(thread.commentId);
@@ -324,6 +321,25 @@ export function serializeCommentAnchorsIntoDocumentXml(
   };
 }
 
+function findParagraphForEndpoint(
+  paragraphs: readonly Pick<
+    RevisionParagraphBoundary,
+    "paragraphIndex" | "start" | "end" | "boundaries"
+  >[],
+  offset: number,
+  kind: "start" | "end",
+): Pick<RevisionParagraphBoundary, "paragraphIndex" | "start" | "end" | "boundaries"> | undefined {
+  const matches = paragraphs.filter(
+    (p) => offset >= p.start && offset <= p.end,
+  );
+  if (matches.length === 0) return undefined;
+  if (matches.length === 1) return matches[0];
+  if (kind === "start") {
+    return matches.reduce((a, b) => (b.start >= a.start ? b : a));
+  }
+  return matches.reduce((a, b) => (b.end <= a.end ? b : a));
+}
+
 export function createCommentExportIdMap(
   threads: readonly CommentThread[],
   preservedDefinitions: readonly ImportedCommentDefinition[] = [],
@@ -729,6 +745,8 @@ function walkInlineNodeForBoundaries(
   }
 
   switch (localName(node.name)) {
+    case "pPr":
+      return;
     case "r": {
       if (!boundaries.has(getCursor())) {
         boundaries.set(getCursor(), node.start);
@@ -750,7 +768,18 @@ function walkInlineNodeForBoundaries(
       return;
     }
     case "tab":
-    case "br": {
+    case "br":
+    case "footnoteReference":
+    case "endnoteReference":
+    case "drawing":
+    case "pict":
+    case "object":
+    case "sym":
+    case "ptab":
+    case "separator":
+    case "continuationSeparator":
+    case "noBreakHyphen":
+    case "softHyphen": {
       const startCursor = getCursor();
       boundaries.set(startCursor, node.start);
       const nextCursor = startCursor + 1;

package/src/io/export/twip.ts

@@ -18,7 +18,7 @@
  *   requireTwip(value)  — mandatory numeric: throws on non-finite input.
  *
  * Source:
- *   docs/plans/close-render-fidelity.md §2 A.2
+ *   docs/plans/lane-3-layout-engine-ooxml-fidelity.md §2 A.2
  */
 
 /**