@beyondwork/docx-react-component 1.0.120 → 1.0.122

package/dist/{chunk-WVZX4NYG.js → chunk-GZW2ERUO.js}

@@ -3,17 +3,17 @@ import {
   PAGE_STACK_GAP_PX,
   defaultChromeReservations,
   resolveDefaultZoom
-} from "./chunk-TMQGWF7R.js";
+} from "./chunk-G3B2OBCZ.js";
 import {
   storyTargetKey
-} from "./chunk-AUQDC5BD.js";
+} from "./chunk-3TUQCHYT.js";
 import {
   MAIN_STORY_KEY,
   collectCanonicalLayoutInputs,
   collectStoryBlockContexts,
   createHeaderFooterStoryKey,
   createNoteStoryKey
-} from "./chunk-AQA7OZ2R.js";
+} from "./chunk-TFSXOIAI.js";
 import {
   MAIN_STORY_TARGET
 } from "./chunk-M2HUK3KF.js";
@@ -590,23 +590,20 @@ function buildBodyRegion(page, pageTopPx, zoom, activeStory, facet) {
     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 blockFrame = {
+    const fallbackBlockFrame = {
       leftPx: regionFrame.leftPx,
       topPx: blockY,
       widthPx: regionFrame.widthPx,
       heightPx: blockHeightPx
     };
     const blockLines = bodyLineBoxes.filter((box) => box.fragmentId === fragment.fragmentId).map((box) => {
-      const lineTopPx = pageTopPx + (bodyTopTwips + box.baselineTwips) * zoom.pxPerTwip;
-      const lineFrame = {
-        leftPx: regionFrame.leftPx,
-        topPx: lineTopPx,
-        widthPx: Math.min(
-          regionFrame.widthPx,
-          box.widthTwips * zoom.pxPerTwip
-        ),
-        heightPx: box.heightTwips * zoom.pxPerTwip
-      };
+      const lineFrame = lineFrameFromPublicBox(
+        box,
+        regionFrame,
+        pageTopPx,
+        bodyTopTwips,
+        zoom
+      );
       const anchors = [
         {
           runtimeOffset: fragment.from,
@@ -622,6 +619,11 @@ function buildBodyRegion(page, pageTopPx, zoom, activeStory, facet) {
       };
     });
     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,
@@ -631,7 +633,7 @@ function buildBodyRegion(page, pageTopPx, zoom, activeStory, facet) {
       blockDecorations: [],
       ...tablePlan !== void 0 ? { tablePlan } : {}
     });
-    blockY += blockHeightPx;
+    blockY = Math.max(blockY + blockHeightPx, blockFrame.topPx + blockFrame.heightPx);
   }
   return {
     storyTarget: activeStory,
@@ -640,6 +642,56 @@ function buildBodyRegion(page, pageTopPx, zoom, activeStory, facet) {
     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(rect, pageTopPx, zoom) {
+  return {
+    leftPx: rect.xTwips * zoom.pxPerTwip,
+    topPx: pageTopPx + rect.yTwips * zoom.pxPerTwip,
+    widthPx: rect.widthTwips * zoom.pxPerTwip,
+    heightPx: rect.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;
@@ -1369,6 +1421,7 @@ function projectGeometryIndexFromFrame(frame, options) {
   const replacementEnvelopes = [];
   const objectHandleEntries = /* @__PURE__ */ new Map();
   const projectedBlocksByStory = /* @__PURE__ */ new Map();
+  const projectedCommandTargetsByKey = /* @__PURE__ */ new Map();
   const precision = createPrecisionCounts();
   const pageMaterialization = createPageMaterializationCounts();
   const pageFrameCompleteness = createPageFrameCompletenessCounts();
@@ -1522,6 +1575,7 @@ function projectGeometryIndexFromFrame(frame, options) {
           storyKey: storyKey2,
           entries: semanticEntries,
           projectedBlocksByStory,
+          projectedCommandTargetsByKey,
           precision,
           frameCompleteness: pageMetadata.frameCompleteness,
           layoutDivergenceIds: pageMetadata.layoutDivergenceIds,
@@ -1573,7 +1627,9 @@ function projectGeometryIndexFromFrame(frame, options) {
   });
   editableTargetCount = appendEditableTargetSemanticEntries({
     identities,
+    unavailableAnchor: resolveEditableTargetUnavailableAnchor(frame, pages),
     projectedBlocksByStory,
+    projectedCommandTargetsByKey,
     entries: semanticEntries,
     precision
   });
@@ -1789,6 +1845,7 @@ function appendBlockSemanticEntries(input) {
     storyKey: storyKey2,
     entries,
     projectedBlocksByStory,
+    projectedCommandTargetsByKey,
     precision,
     frameCompleteness,
     layoutDivergenceIds,
@@ -1816,6 +1873,7 @@ function appendBlockSemanticEntries(input) {
     block,
     sourceIdentity: sliceIdentity,
     entries,
+    projectedCommandTargetsByKey,
     precision,
     frameCompleteness,
     layoutDivergenceIds,
@@ -1996,6 +2054,7 @@ function appendFragmentLayoutObjectSemanticEntries(input) {
     block,
     sourceIdentity,
     entries,
+    projectedCommandTargetsByKey,
     precision,
     frameCompleteness,
     layoutDivergenceIds,
@@ -2003,25 +2062,80 @@ function appendFragmentLayoutObjectSemanticEntries(input) {
   } = input;
   const layoutObject = block.fragment.layoutObject;
   if (!layoutObject) return;
+  recordFragmentCommandTargetFacts({
+    base,
+    block,
+    layoutObject,
+    sourceIdentity,
+    projectedCommandTargetsByKey
+  });
   if (layoutObject.kind === "field-region") {
-    entries.push({
-      ...base,
-      entryId: `semantic:field-region:${base.sliceId}`,
-      kind: "field-region",
-      layoutObjectId: layoutObject.objectId,
-      ...layoutObject.fieldFamilies !== void 0 ? { fieldFamilies: [...layoutObject.fieldFamilies] } : {},
-      rect: {
-        ...toGeometryRect(block.frame),
-        precision: "within-tolerance"
-      },
-      status: "realized",
-      precision: "within-tolerance",
-      frameCompleteness,
-      ...layoutDivergenceIds.length > 0 ? { layoutDivergenceIds } : {},
-      ...layoutDivergenceObjectIds.length > 0 ? { layoutDivergenceObjectIds } : {},
-      ...sourceIdentity ? { sourceIdentity } : {}
-    });
-    recordPrecision(precision, "within-tolerance");
+    const fieldRegions = layoutObject.fieldRegions ?? [];
+    if (fieldRegions.length === 0) {
+      entries.push({
+        ...base,
+        entryId: `semantic:field-region:${base.sliceId}`,
+        kind: "field-region",
+        layoutObjectId: layoutObject.objectId,
+        ...layoutObject.fieldFamilies !== void 0 ? { fieldFamilies: [...layoutObject.fieldFamilies] } : {},
+        rect: {
+          ...toGeometryRect(block.frame),
+          precision: "within-tolerance"
+        },
+        status: "realized",
+        precision: "within-tolerance",
+        frameCompleteness,
+        ...layoutDivergenceIds.length > 0 ? { layoutDivergenceIds } : {},
+        ...layoutDivergenceObjectIds.length > 0 ? { layoutDivergenceObjectIds } : {},
+        ...sourceIdentity ? { sourceIdentity } : {}
+      });
+      recordPrecision(precision, "within-tolerance");
+    }
+    for (const fieldRegion of fieldRegions) {
+      const fieldSourceIdentity = fieldRegionSourceIdentity(
+        fieldRegion,
+        sourceIdentity
+      );
+      entries.push({
+        ...base,
+        entryId: `semantic:field-region:${base.sliceId}:${fieldRegion.fieldRegionId}`,
+        kind: "field-region",
+        layoutObjectId: fieldRegion.fieldRegionId,
+        fieldFamilies: [fieldRegion.fieldFamily],
+        fieldRegionId: fieldRegion.regionId,
+        canonicalFieldId: fieldRegion.canonicalFieldId,
+        fieldRegionKind: fieldRegion.regionKind,
+        rect: {
+          ...toGeometryRect(block.frame),
+          precision: "within-tolerance"
+        },
+        status: "realized",
+        precision: "within-tolerance",
+        frameCompleteness,
+        ...layoutDivergenceIds.length > 0 ? { layoutDivergenceIds } : {},
+        ...layoutDivergenceObjectIds.length > 0 ? { layoutDivergenceObjectIds } : {},
+        sourceIdentity: fieldSourceIdentity
+      });
+      recordProjectedCommandTarget(projectedCommandTargetsByKey, {
+        targetKey: `${fieldRegion.storyKey}:field-region:${fieldRegion.regionId}:refresh`,
+        pageId: base.pageId,
+        pageIndex: base.pageIndex,
+        regionId: base.regionId,
+        regionKind: base.regionKind,
+        sliceId: base.sliceId,
+        blockId: base.blockId,
+        fragmentId: base.fragmentId,
+        blockPath: sourceIdentity?.blockPath,
+        rect: {
+          ...toGeometryRect(block.frame),
+          precision: "within-tolerance"
+        },
+        status: "realized",
+        precision: "within-tolerance",
+        sourceIdentity: fieldSourceIdentity
+      });
+      recordPrecision(precision, "within-tolerance");
+    }
     return;
   }
   if (layoutObject.kind === "numbered-paragraph") {
@@ -2040,6 +2154,92 @@ function appendFragmentLayoutObjectSemanticEntries(input) {
     recordPrecision(precision, markerProjection.precision);
   }
 }
+function recordFragmentCommandTargetFacts(input) {
+  const {
+    base,
+    block,
+    layoutObject,
+    sourceIdentity,
+    projectedCommandTargetsByKey
+  } = input;
+  for (const hyperlink of layoutObject.hyperlinks ?? []) {
+    const hyperlinkIdentity = hyperlinkSourceIdentity(
+      hyperlink,
+      sourceIdentity
+    );
+    recordProjectedCommandTarget(projectedCommandTargetsByKey, {
+      targetKey: hyperlink.targetKey,
+      pageId: base.pageId,
+      pageIndex: base.pageIndex,
+      regionId: base.regionId,
+      regionKind: base.regionKind,
+      sliceId: base.sliceId,
+      blockId: base.blockId,
+      fragmentId: base.fragmentId,
+      blockPath: sourceIdentity?.blockPath,
+      rect: {
+        ...toGeometryRect(block.frame),
+        precision: "within-tolerance"
+      },
+      status: "realized",
+      precision: "within-tolerance",
+      sourceIdentity: hyperlinkIdentity
+    });
+  }
+  for (const bookmarkRange of layoutObject.bookmarkRanges ?? []) {
+    if (!bookmarkRange.contentRangeTargetKey) continue;
+    const bookmarkIdentity = bookmarkRangeSourceIdentity(
+      bookmarkRange,
+      sourceIdentity
+    );
+    recordProjectedCommandTarget(projectedCommandTargetsByKey, {
+      targetKey: bookmarkRange.contentRangeTargetKey,
+      pageId: base.pageId,
+      pageIndex: base.pageIndex,
+      regionId: base.regionId,
+      regionKind: base.regionKind,
+      sliceId: base.sliceId,
+      blockId: base.blockId,
+      fragmentId: base.fragmentId,
+      blockPath: sourceIdentity?.blockPath,
+      rect: {
+        ...toGeometryRect(block.frame),
+        precision: "within-tolerance"
+      },
+      status: "realized",
+      precision: "within-tolerance",
+      sourceIdentity: bookmarkIdentity
+    });
+  }
+}
+function fieldRegionSourceIdentity(fact, fallback) {
+  return {
+    storyKey: fact.storyKey,
+    ...fallback?.blockPath ? { blockPath: fallback.blockPath } : {},
+    ...fact.sourcePath ? { inlinePath: fact.sourcePath } : {},
+    ...fact.sourceRef !== void 0 ? { sourceRef: fact.sourceRef } : {},
+    joinKind: "block-scoped"
+  };
+}
+function hyperlinkSourceIdentity(fact, fallback) {
+  return {
+    storyKey: fact.storyKey,
+    ...fallback?.blockPath ? { blockPath: fallback.blockPath } : {},
+    inlinePath: fact.blockPath,
+    ...fact.sourceRef !== void 0 ? { sourceRef: fact.sourceRef } : {},
+    joinKind: "block-scoped"
+  };
+}
+function bookmarkRangeSourceIdentity(fact, fallback) {
+  return {
+    storyKey: fact.storyKey,
+    ...fallback?.blockPath ? { blockPath: fallback.blockPath } : {},
+    ...fact.rangeKey !== void 0 ? { scopeKey: fact.rangeKey } : {},
+    scopeId: fact.bookmarkId,
+    ...fact.sourceRef !== void 0 ? { sourceRef: fact.sourceRef } : {},
+    joinKind: "block-scoped"
+  };
+}
 function resolveNumberingMarkerProjection(block) {
   const metadata = resolveNumberingMarkerProjectionMetadata(block);
   const blockFrame = block.frame;
@@ -2104,7 +2304,7 @@ function countBlockSemanticEntries(block) {
   const counts = createPrecisionCounts();
   const layoutObject = block.fragment.layoutObject;
   if (layoutObject?.kind === "field-region") {
-    counts["within-tolerance"] += 1;
+    counts["within-tolerance"] += layoutObject.fieldRegions?.length || 1;
   } else if (layoutObject?.kind === "numbered-paragraph") {
     counts[resolveNumberingMarkerProjectionMetadata(block).precision] += 1;
   }
@@ -2351,6 +2551,14 @@ function createIdentityLookup(options) {
       anchorsByStoryBlockId.set(key, [anchor]);
     }
   }
+  const fieldRegionBlockPathByTargetKey = /* @__PURE__ */ new Map();
+  for (const region of layoutInputs.fieldRegions) {
+    const blockPath = topLevelBlockPath(region.sourcePath ?? "") ?? defaultStoryBlockPath(region.storyKey, region.paragraphIndex);
+    fieldRegionBlockPathByTargetKey.set(
+      `${region.storyKey}:field-region:${region.regionId}:refresh`,
+      blockPath
+    );
+  }
   return {
     storyKeyForTarget(target) {
       return resolveCanonicalStoryKeyForTarget(target, storyKeys);
@@ -2382,6 +2590,9 @@ function createIdentityLookup(options) {
     objectAnchors(storyKey2, blockId) {
       return anchorsByStoryBlockId.get(storyBlockKey(storyKey2, blockId)) ?? [];
     },
+    fieldRegionBlockPath(targetKey) {
+      return fieldRegionBlockPathByTargetKey.get(targetKey);
+    },
     blockIdForPath(storyKey2, blockPath) {
       return blockIdByPath.get(storyPathKey(storyKey2, blockPath));
     },
@@ -2405,14 +2616,28 @@ function appendCanonicalObjectHandleEntries(input) {
   )) {
     if (anchor.hidden === true) continue;
     const exactObjectRect = frame.anchorIndex.byObjectId(anchor.objectKey);
-    const rect = exactObjectRect ?? block.frame;
-    const entryPrecision = exactObjectRect ? "within-tolerance" : "heuristic";
-    const status = exactObjectRect ? "realized" : "requires-rehydration";
+    const modeledObjectRect = exactObjectRect === null ? resolveCanonicalTextboxObjectFrame(page, anchor) : null;
+    const objectFrame = exactObjectRect ?? modeledObjectRect;
+    const rect = objectFrame ?? block.frame;
+    const entryPrecision = objectFrame ? "within-tolerance" : "heuristic";
+    const status = objectFrame ? "realized" : "requires-rehydration";
+    const objectUnavailableReason = objectFrame ? void 0 : "object-anchor-geometry-missing";
     const handleRects = buildObjectHandleRectsFromRect(rect, entryPrecision);
+    const objectRect = objectFrame !== null ? { ...toGeometryRect(objectFrame), precision: entryPrecision } : void 0;
+    const sourceIdentity = anchorSourceIdentity(
+      anchor,
+      objectFrame ? "direct" : "block-scoped"
+    );
     const existing = entries.get(anchor.objectKey);
     if (existing) {
       appendUnique(existing.pageIds, page.page.pageId);
       existing.rects.push(...handleRects);
+      if (objectRect && !existing.objectRect) {
+        existing.objectRect = objectRect;
+      }
+      if (objectUnavailableReason) {
+        existing.objectUnavailableReason = objectUnavailableReason;
+      }
       appendDivergenceIdsForObject(
         existing,
         input.page,
@@ -2421,25 +2646,68 @@ function appendCanonicalObjectHandleEntries(input) {
       if (existing.precision !== "heuristic" && entryPrecision === "heuristic") {
         existing.precision = "heuristic";
         existing.status = "requires-rehydration";
-        existing.sourceIdentity = anchorSourceIdentity(anchor, "block-scoped");
+        existing.sourceIdentity = sourceIdentity;
       }
       continue;
     }
     entries.set(anchor.objectKey, {
       objectId: anchor.objectKey,
       pageIds: [page.page.pageId],
+      ...objectRect ? { objectRect } : {},
       rects: [...handleRects],
       status,
       precision: entryPrecision,
+      ...objectUnavailableReason ? { objectUnavailableReason } : {},
       ...layoutDivergenceIdsForObject(input.page, anchor.objectKey),
-      sourceIdentity: anchorSourceIdentity(
-        anchor,
-        exactObjectRect ? "direct" : "block-scoped"
-      )
+      sourceIdentity
     });
     recordPrecision(precision, entryPrecision);
   }
 }
+var EMUS_PER_TWIP = 635;
+function resolveCanonicalTextboxObjectFrame(page, anchor) {
+  if (anchor.objectKind !== "textbox" || anchor.display !== "floating" || !anchor.extent) {
+    return null;
+  }
+  const region = page.page.regions.body;
+  const widthTwips = Math.max(0, anchor.extent.widthEmu / EMUS_PER_TWIP);
+  const heightTwips = Math.max(0, anchor.extent.heightEmu / EMUS_PER_TWIP);
+  if (widthTwips <= 0 || heightTwips <= 0) return null;
+  const regionXTwips = region.rectTwips?.xTwips ?? page.page.layout.marginLeft + page.page.layout.gutter;
+  const regionYTwips = region.rectTwips?.yTwips ?? page.page.layout.marginTop;
+  const xTwips = resolveCanonicalAnchorAxisTwips(
+    regionXTwips,
+    region.widthTwips,
+    widthTwips,
+    anchor.positionH?.align,
+    anchor.positionH?.offset
+  );
+  const yTwips = resolveCanonicalAnchorAxisTwips(
+    regionYTwips,
+    region.heightTwips,
+    heightTwips,
+    anchor.positionV?.align,
+    anchor.positionV?.offset
+  );
+  return pageLocalObjectAnchorFrame(page, {
+    xTwips,
+    yTwips,
+    widthTwips,
+    heightTwips
+  });
+}
+function resolveCanonicalAnchorAxisTwips(originTwips, spanTwips, objectSpanTwips, align, offsetEmu) {
+  if (typeof offsetEmu === "number") {
+    return originTwips + offsetEmu / EMUS_PER_TWIP;
+  }
+  if (align === "center" || align === "ctr") {
+    return originTwips + Math.max(0, spanTwips - objectSpanTwips) / 2;
+  }
+  if (align === "right" || align === "bottom") {
+    return originTwips + Math.max(0, spanTwips - objectSpanTwips);
+  }
+  return originTwips;
+}
 function appendPageLocalObjectHandleEntries(input) {
   const { page, entries, precision, divergenceIdsByObjectId } = input;
   const stories = page.page.frame?.pageLocalStories ?? [];
@@ -2466,6 +2734,12 @@ function appendPageLocalObjectHandleEntries(input) {
       if (existing) {
         appendUnique(existing.pageIds, page.page.pageId);
         existing.rects.push(...handleRects);
+        if (!existing.objectRect) {
+          existing.objectRect = {
+            ...toGeometryRect(objectFrame),
+            precision: entryPrecision
+          };
+        }
         appendDivergenceIds(existing, divergenceIdsByObjectId.get(object.objectId));
         if (existing.precision !== "heuristic" && entryPrecision === "heuristic") {
           existing.precision = "heuristic";
@@ -2477,6 +2751,10 @@ function appendPageLocalObjectHandleEntries(input) {
       entries.set(object.objectId, {
         objectId: object.objectId,
         pageIds: [page.page.pageId],
+        objectRect: {
+          ...toGeometryRect(objectFrame),
+          precision: entryPrecision
+        },
         rects: [...handleRects],
         status: entryStatus,
         precision: entryPrecision,
@@ -2514,9 +2792,11 @@ function finalizeObjectHandleEntries(entries) {
   return Array.from(entries.values()).map((entry) => ({
     objectId: entry.objectId,
     pageIds: entry.pageIds,
+    ...entry.objectRect ? { objectRect: entry.objectRect } : {},
     rects: entry.rects,
     status: entry.status,
     precision: entry.precision,
+    ...entry.objectUnavailableReason ? { objectUnavailableReason: entry.objectUnavailableReason } : {},
     ...entry.layoutDivergenceIds && entry.layoutDivergenceIds.length > 0 ? { layoutDivergenceIds: [...entry.layoutDivergenceIds] } : {},
     ...entry.sourceIdentity ? { sourceIdentity: entry.sourceIdentity } : {}
   }));
@@ -2537,6 +2817,14 @@ function resolveCanonicalStoryKeyForTarget(target, storyKeys) {
   }
   return exact;
 }
+function recordProjectedCommandTarget(targetsByKey, target) {
+  const list = targetsByKey.get(target.targetKey);
+  if (list) {
+    list.push(target);
+  } else {
+    targetsByKey.set(target.targetKey, [target]);
+  }
+}
 function recordProjectedScopeBlock(blocksByStory, block) {
   const list = blocksByStory.get(block.storyKey);
   if (list) {
@@ -2604,10 +2892,18 @@ function appendScopeReplacementEnvelopeEntries(input) {
   }
 }
 function appendEditableTargetSemanticEntries(input) {
-  const { identities, projectedBlocksByStory, entries, precision } = input;
+  const {
+    identities,
+    unavailableAnchor,
+    projectedBlocksByStory,
+    projectedCommandTargetsByKey,
+    entries,
+    precision
+  } = input;
   if (!identities) return 0;
   let count = 0;
   for (const target of identities.editableTargetInputs()) {
+    attachEditableTargetProvenanceToSemanticEntries(target, entries);
     const tableGeometryEntries = resolveEditableTargetTableGeometryEntries(
       target,
       entries
@@ -2636,12 +2932,34 @@ function appendEditableTargetSemanticEntries(input) {
       }
       continue;
     }
+    const projectedCommandTargets = projectedCommandTargetsByKey.get(target.targetKey) ?? [];
+    if (projectedCommandTargets.length > 0) {
+      for (const commandTarget of projectedCommandTargets) {
+        entries.push(editableTargetEntryFromCommandTarget(target, commandTarget));
+        recordPrecision(precision, commandTarget.precision);
+        count += 1;
+      }
+      continue;
+    }
     const projectedBlock = resolveEditableTargetProjectedBlock(
       target,
       identities
     );
-    if (!projectedBlock) continue;
+    if (!projectedBlock) {
+      if (!unavailableAnchor) continue;
+      entries.push(
+        unavailableEditableTargetEntryFromAnchor(
+          target,
+          unavailableAnchor,
+          unavailableReasonForEditableTarget(target)
+        )
+      );
+      recordPrecision(precision, "heuristic");
+      count += 1;
+      continue;
+    }
     const projectedBlocks = projectedBlocksByStory.get(target.storyKey) ?? [];
+    let projected = false;
     for (const block of projectedBlocks) {
       if (block.blockId !== projectedBlock.blockId || block.blockPath !== projectedBlock.blockPath) {
         continue;
@@ -2661,11 +2979,21 @@ function appendEditableTargetSemanticEntries(input) {
         editableTargetEditability: target.editability,
         editableTargetBlockers: target.posture.blockers,
         editableTargetLeafPath: target.leafPath,
+        ...editableTargetProvenance(target),
+        ...target.editableOwner ? {
+          editableTargetOwnerKey: target.editableOwner.targetKey,
+          editableTargetOwnerReason: target.editableOwner.reason,
+          ...target.editableOwner.canonicalAddress ? {
+            editableTargetOwnerCanonicalAddress: target.editableOwner.canonicalAddress
+          } : {}
+        } : {},
         rect: { ...block.rect, precision: "within-tolerance" },
         status: "realized",
         precision: "within-tolerance",
         sourceIdentity: {
+          ...target.sourceRef !== void 0 ? { sourceRef: target.sourceRef } : {},
           storyKey: target.storyKey,
+          ...tableTargetSourceIdentity(target.table),
           blockPath: projectedBlock.blockPath,
           inlinePath: target.blockPath === projectedBlock.blockPath ? target.leafPath : target.blockPath,
           editPosture: target.editability,
@@ -2674,10 +3002,61 @@ function appendEditableTargetSemanticEntries(input) {
       });
       recordPrecision(precision, "within-tolerance");
       count += 1;
+      projected = true;
+    }
+    if (!projected && unavailableAnchor) {
+      entries.push(
+        unavailableEditableTargetEntryFromAnchor(
+          target,
+          unavailableAnchor,
+          unavailableReasonForEditableTarget(target)
+        )
+      );
+      recordPrecision(precision, "heuristic");
+      count += 1;
     }
   }
   return count;
 }
+function resolveEditableTargetUnavailableAnchor(frame, pages) {
+  const projectedPage = pages[0];
+  if (projectedPage) {
+    return {
+      pageId: projectedPage.pageId,
+      pageIndex: projectedPage.pageIndex,
+      rect: zeroGeometryRectAt(projectedPage.rect),
+      frameCompleteness: projectedPage.frameCompleteness
+    };
+  }
+  const framePage = frame.pages[0];
+  if (!framePage) return null;
+  const metadata = pageFrameMetadata(framePage);
+  return {
+    pageId: framePage.page.pageId,
+    pageIndex: framePage.page.pageIndex,
+    rect: zeroGeometryRectAt(toGeometryRect(framePage.frame)),
+    frameCompleteness: metadata.frameCompleteness
+  };
+}
+function zeroGeometryRectAt(rect) {
+  return {
+    leftPx: rect.leftPx,
+    topPx: rect.topPx,
+    widthPx: 0,
+    heightPx: 0,
+    space: rect.space,
+    precision: "heuristic"
+  };
+}
+function unavailableReasonForEditableTarget(target) {
+  if (target.commandFamily === "table-structure" || target.table) {
+    return "editable-target-table-geometry-missing";
+  }
+  if (target.commandFamily === "field" || target.commandFamily === "link-bookmark") {
+    return "editable-target-command-geometry-missing";
+  }
+  return "editable-target-block-geometry-missing";
+}
 function resolveEditableTargetTableGeometryEntries(target, entries) {
   if (target.commandFamily !== "table-structure" || !target.table) return [];
   const table = target.table;
@@ -2725,21 +3104,64 @@ function editableTargetEntryFromGeometryEntry(target, geometryEntry) {
     editableTargetEditability: target.editability,
     editableTargetBlockers: target.posture.blockers,
     editableTargetLeafPath: target.leafPath,
+    ...editableTargetProvenance(target),
+    ...target.editableOwner ? {
+      editableTargetOwnerKey: target.editableOwner.targetKey,
+      editableTargetOwnerReason: target.editableOwner.reason,
+      ...target.editableOwner.canonicalAddress ? {
+        editableTargetOwnerCanonicalAddress: target.editableOwner.canonicalAddress
+      } : {}
+    } : {},
     rect: { ...geometryEntry.rect },
     status: geometryEntry.status,
     precision: geometryEntry.precision,
     ...geometryEntry.frameCompleteness ? { frameCompleteness: geometryEntry.frameCompleteness } : {},
     sourceIdentity: {
+      ...target.sourceRef !== void 0 ? { sourceRef: target.sourceRef } : {},
       ...geometryEntry.sourceIdentity ?? {
         storyKey: target.storyKey,
         blockPath: target.blockPath,
         joinKind: "block-scoped"
       },
+      ...tableTargetSourceIdentity(target.table),
       inlinePath: target.leafPath,
       editPosture: target.editability
     }
   };
 }
+function editableTargetEntryFromCommandTarget(target, commandTarget) {
+  return {
+    entryId: `semantic:editable-target:${target.targetKey}:${commandTarget.pageId}:${commandTarget.fragmentId ?? commandTarget.blockId}`,
+    kind: "editable-target",
+    pageId: commandTarget.pageId,
+    pageIndex: commandTarget.pageIndex,
+    ...commandTarget.regionId ? { regionId: commandTarget.regionId } : {},
+    ...commandTarget.regionKind ? { regionKind: commandTarget.regionKind } : {},
+    ...commandTarget.sliceId ? { sliceId: commandTarget.sliceId } : {},
+    blockId: commandTarget.blockId,
+    ...commandTarget.fragmentId ? { fragmentId: commandTarget.fragmentId } : {},
+    editableTargetKey: target.targetKey,
+    editableTargetKind: target.kind,
+    editableTargetCommandFamily: target.commandFamily,
+    editableTargetEditability: target.editability,
+    editableTargetBlockers: target.posture.blockers,
+    editableTargetLeafPath: target.leafPath,
+    ...editableTargetProvenance(target),
+    rect: { ...commandTarget.rect },
+    status: commandTarget.status,
+    precision: commandTarget.precision,
+    sourceIdentity: {
+      ...target.sourceRef !== void 0 ? { sourceRef: target.sourceRef } : {},
+      ...commandTarget.sourceIdentity ?? {
+        storyKey: target.storyKey,
+        blockPath: commandTarget.blockPath ?? target.blockPath,
+        joinKind: "block-scoped"
+      },
+      inlinePath: commandTarget.blockPath && target.blockPath !== commandTarget.blockPath ? target.blockPath : target.leafPath,
+      editPosture: target.editability
+    }
+  };
+}
 function unavailableEditableTargetEntryFromTableFrame(target, tableFrame) {
   const table = target.table;
   return {
@@ -2761,6 +3183,14 @@ function unavailableEditableTargetEntryFromTableFrame(target, tableFrame) {
     editableTargetEditability: target.editability,
     editableTargetBlockers: target.posture.blockers,
     editableTargetLeafPath: target.leafPath,
+    ...editableTargetProvenance(target),
+    ...target.editableOwner ? {
+      editableTargetOwnerKey: target.editableOwner.targetKey,
+      editableTargetOwnerReason: target.editableOwner.reason,
+      ...target.editableOwner.canonicalAddress ? {
+        editableTargetOwnerCanonicalAddress: target.editableOwner.canonicalAddress
+      } : {}
+    } : {},
     rect: {
       leftPx: tableFrame.rect.leftPx,
       topPx: tableFrame.rect.topPx,
@@ -2771,18 +3201,91 @@ function unavailableEditableTargetEntryFromTableFrame(target, tableFrame) {
     },
     status: "unavailable",
     precision: "heuristic",
+    editableTargetUnavailableReason: "editable-target-table-geometry-missing",
     ...tableFrame.frameCompleteness ? { frameCompleteness: tableFrame.frameCompleteness } : {},
     sourceIdentity: {
+      ...target.sourceRef !== void 0 ? { sourceRef: target.sourceRef } : {},
       ...tableFrame.sourceIdentity ?? {
         storyKey: target.storyKey,
         blockPath: target.table?.tablePath ?? target.blockPath,
         joinKind: "block-scoped"
       },
+      ...tableTargetSourceIdentity(target.table),
       inlinePath: target.leafPath,
       editPosture: target.editability
     }
   };
 }
+function unavailableEditableTargetEntryFromAnchor(target, anchor, reason) {
+  return {
+    entryId: `semantic:editable-target:${target.targetKey}:${anchor.pageId}:unavailable`,
+    kind: "editable-target",
+    pageId: anchor.pageId,
+    pageIndex: anchor.pageIndex,
+    editableTargetKey: target.targetKey,
+    editableTargetKind: target.kind,
+    editableTargetCommandFamily: target.commandFamily,
+    editableTargetEditability: target.editability,
+    editableTargetBlockers: target.posture.blockers,
+    editableTargetLeafPath: target.leafPath,
+    ...editableTargetProvenance(target),
+    ...target.editableOwner ? {
+      editableTargetOwnerKey: target.editableOwner.targetKey,
+      editableTargetOwnerReason: target.editableOwner.reason,
+      ...target.editableOwner.canonicalAddress ? {
+        editableTargetOwnerCanonicalAddress: target.editableOwner.canonicalAddress
+      } : {}
+    } : {},
+    rect: anchor.rect,
+    status: "unavailable",
+    precision: "heuristic",
+    editableTargetUnavailableReason: reason,
+    ...anchor.frameCompleteness ? { frameCompleteness: anchor.frameCompleteness } : {},
+    sourceIdentity: {
+      ...target.sourceRef !== void 0 ? { sourceRef: target.sourceRef } : {},
+      storyKey: target.storyKey,
+      ...tableTargetSourceIdentity(target.table),
+      blockPath: target.table?.tablePath ?? target.blockPath,
+      inlinePath: target.leafPath,
+      editPosture: target.editability,
+      joinKind: "block-scoped"
+    }
+  };
+}
+function tableTargetSourceIdentity(table) {
+  if (!table) return {};
+  return {
+    tableKey: table.tableKey,
+    ...table.sourceRef !== void 0 ? { sourceRef: table.sourceRef } : {},
+    ...table.rowSourceRef !== void 0 ? { rowSourceRef: table.rowSourceRef } : {},
+    ...table.cellSourceRef !== void 0 ? { cellSourceRef: table.cellSourceRef } : {}
+  };
+}
+function editableTargetProvenance(target) {
+  return {
+    ...target.canonicalAddress ? { editableTargetCanonicalAddress: target.canonicalAddress } : {},
+    ...target.editableOwner?.canonicalAddress ? {
+      editableTargetOwnerCanonicalAddress: target.editableOwner.canonicalAddress
+    } : {}
+  };
+}
+function attachEditableTargetProvenanceToSemanticEntries(target, entries) {
+  const provenance = editableTargetProvenance(target);
+  for (const entry of entries) {
+    if (entry.kind === "numbering-marker") {
+      if (target.commandFamily !== "text-leaf" || entry.sourceIdentity?.storyKey !== target.storyKey || entry.sourceIdentity?.blockPath !== target.blockPath) {
+        continue;
+      }
+      entry.editableTargetKey = target.targetKey;
+      entry.editableTargetKind = target.kind;
+      entry.editableTargetCommandFamily = target.commandFamily;
+      entry.editableTargetEditability = target.editability;
+      entry.editableTargetBlockers = target.posture.blockers;
+      entry.editableTargetLeafPath = target.leafPath;
+      Object.assign(entry, provenance);
+    }
+  }
+}
 function resolveEditableTargetProjectedBlock(target, identities) {
   const directBlockId = identities.blockIdForPath(
     target.storyKey,
@@ -2791,7 +3294,35 @@ function resolveEditableTargetProjectedBlock(target, identities) {
   if (directBlockId) {
     return { blockId: directBlockId, blockPath: target.blockPath };
   }
-  if (target.kind !== "hyperlink-text") return null;
+  const fieldRegionBlockPath = fieldRegionSourceBlockPath(target);
+  if (fieldRegionBlockPath) {
+    const fieldRegionBlockId = identities.blockIdForPath(
+      target.storyKey,
+      fieldRegionBlockPath
+    );
+    if (fieldRegionBlockId) {
+      return {
+        blockId: fieldRegionBlockId,
+        blockPath: fieldRegionBlockPath
+      };
+    }
+  }
+  const modeledFieldRegionBlockPath = identities.fieldRegionBlockPath(
+    target.targetKey
+  );
+  if (modeledFieldRegionBlockPath) {
+    const fieldRegionBlockId = identities.blockIdForPath(
+      target.storyKey,
+      modeledFieldRegionBlockPath
+    );
+    if (fieldRegionBlockId) {
+      return {
+        blockId: fieldRegionBlockId,
+        blockPath: modeledFieldRegionBlockPath
+      };
+    }
+  }
+  if (!shouldProjectInlineTargetFromEnclosingBlock(target)) return null;
   const enclosingBlockPath = enclosingBlockPathForInlineTarget(target.blockPath);
   if (!enclosingBlockPath) return null;
   const enclosingBlockId = identities.blockIdForPath(
@@ -2800,10 +3331,29 @@ function resolveEditableTargetProjectedBlock(target, identities) {
   );
   return enclosingBlockId ? { blockId: enclosingBlockId, blockPath: enclosingBlockPath } : null;
 }
+function fieldRegionSourceBlockPath(target) {
+  if (target.kind !== "field-region-refresh" && target.kind !== "toc-region-refresh") {
+    return null;
+  }
+  const sourcePath = target.field?.sourcePath;
+  if (!sourcePath) return null;
+  return enclosingBlockPathForInlineTarget(sourcePath) ?? topLevelBlockPath(sourcePath);
+}
+function shouldProjectInlineTargetFromEnclosingBlock(target) {
+  return target.kind === "hyperlink-text" || target.kind === "field-result-text" || target.kind === "bookmark-anchor" || target.commandFamily === "link-bookmark";
+}
 function enclosingBlockPathForInlineTarget(path) {
   const inlineAt = path.indexOf("/inline");
   return inlineAt > 0 ? path.slice(0, inlineAt) : null;
 }
+function topLevelBlockPath(path) {
+  const match = /^(.*\/block\[\d+\])(?:\/|$)/u.exec(path);
+  return match?.[1] ?? null;
+}
+function defaultStoryBlockPath(storyKey2, paragraphIndex) {
+  const base = storyKey2 === MAIN_STORY_KEY ? MAIN_STORY_KEY : storyKey2;
+  return `${base}/block[${paragraphIndex}]`;
+}
 function projectScopeReplacementEnvelopeEntry(scope, identities, storyBlocks) {
   const startBlockId = scope.start ? identities.blockIdForPath(scope.storyKey, scope.start.blockPath) : void 0;
   const endBlockId = scope.end ? identities.blockIdForPath(scope.storyKey, scope.end.blockPath) : void 0;
@@ -2900,6 +3450,7 @@ function anchorSourceIdentity(anchor, joinKind) {
     inlinePath: anchor.inlinePath,
     objectKind: anchor.objectKind,
     editPosture: anchor.editPosture,
+    ...anchor.sourceRef !== void 0 ? { sourceRef: anchor.sourceRef } : {},
     joinKind
   };
 }
@@ -2913,6 +3464,7 @@ function tableSourceIdentity(table) {
     storyKey: table.storyKey,
     blockPath: table.blockPath,
     tableKey: table.tableKey,
+    ...table.sourceRef !== void 0 ? { sourceRef: table.sourceRef } : {},
     joinKind: "direct"
   };
 }
@@ -2920,7 +3472,8 @@ function tableRowSourceIdentity(table, rowIndex) {
   const row = table.rows.find((entry) => entry.rowIndex === rowIndex);
   return {
     ...tableSourceIdentity(table),
-    ...row ? { rowKey: row.rowKey } : {}
+    ...row ? { rowKey: row.rowKey } : {},
+    ...row?.sourceRef !== void 0 ? { rowSourceRef: row.sourceRef } : {}
   };
 }
 function tableCellSourceIdentity(table, rowIndex, gridColumnStart) {
@@ -2928,7 +3481,8 @@ function tableCellSourceIdentity(table, rowIndex, gridColumnStart) {
   const cell = findCanonicalCellByGridColumn(row, gridColumnStart);
   return {
     ...tableRowSourceIdentity(table, rowIndex),
-    ...cell ? { cellKey: cell.cellKey } : {}
+    ...cell ? { cellKey: cell.cellKey } : {},
+    ...cell?.sourceRef !== void 0 ? { cellSourceRef: cell.sourceRef } : {}
   };
 }
 function findCanonicalCellByGridColumn(row, gridColumnStart) {