@beyondwork/docx-react-component 1.0.120 → 1.0.122

package/dist/{chunk-MPYYBRVN.js → chunk-PCXTMEGY.js}

@@ -7,27 +7,27 @@ import {
   resolveSectionForStoryTarget,
   searchSecondaryStories,
   searchSurfaceBlocks
-} from "./chunk-TMQGWF7R.js";
+} from "./chunk-G3B2OBCZ.js";
 import {
   createEditorSurfaceSnapshot,
   createFormattingContext,
   resolveTableStyleResolution
-} from "./chunk-AUQDC5BD.js";
+} from "./chunk-3TUQCHYT.js";
 import {
   createSelectionSnapshot
-} from "./chunk-FLNQY74K.js";
+} from "./chunk-OYGMRRR7.js";
 import {
   normalizeParsedTextDocument
-} from "./chunk-327AIUXL.js";
+} from "./chunk-UWDWGQH5.js";
 import {
   buildFieldRegistry,
   parseMainDocumentXml,
   parseTocLevelRange
-} from "./chunk-NQZUGMLW.js";
+} from "./chunk-TMU7JMXX.js";
 import {
   collectEditableTargetRefs,
   validateEditableTargetRef
-} from "./chunk-AQA7OZ2R.js";
+} from "./chunk-TFSXOIAI.js";
 import {
   serializeMainDocument
 } from "./chunk-EB6M3GE6.js";
@@ -36,7 +36,7 @@ import {
 } from "./chunk-UFVDIR2C.js";
 import {
   createPublicRangeAnchor
-} from "./chunk-4JNUMMM7.js";
+} from "./chunk-PGGPPZ65.js";
 import {
   MAIN_STORY_TARGET,
   storyTargetsEqual
@@ -372,75 +372,83 @@ function deriveWorkflowEditableTargetBlockerFacts(input) {
     (input.targetRanges ?? []).map((range) => [range.targetKey, range])
   );
   const currentTargets = input.currentTargets ? new Map(input.currentTargets.map((target) => [target.targetKey, target])) : null;
-  const auditOperations = new Map(
-    (input.auditIntents ?? []).map((intent) => [intent.targetKey, intent.operation])
-  );
+  const auditOperations = auditOperationsByTarget(input.auditIntents);
   for (const target of input.targets) {
-    const auditOperation = auditOperations.get(target.targetKey);
+    const targetAuditOperations = auditOperationsForTarget(target, auditOperations);
     if (input.activeStoryKey !== void 0 && input.activeStoryKey !== null && target.storyKey !== input.activeStoryKey) {
-      facts.push({
-        ...baseFact(target),
-        blocker: "wrong-story",
-        refusalId: "editable_target_wrong_story",
-        source: "target-resolution",
-        audit: auditFact(target, "wrong-story", "editable_target_wrong_story", auditOperation),
-        message: `Editable target belongs to story "${target.storyKey}", not active story "${input.activeStoryKey}".`
-      });
+      for (const auditOperation of targetAuditOperations) {
+        facts.push({
+          ...baseFact(target),
+          blocker: "wrong-story",
+          refusalId: "editable_target_wrong_story",
+          source: "target-resolution",
+          audit: auditFact(target, "wrong-story", "editable_target_wrong_story", auditOperation),
+          message: `Editable target belongs to story "${target.storyKey}", not active story "${input.activeStoryKey}".`
+        });
+      }
     }
     const currentTarget = currentTargets?.get(target.targetKey);
     if (currentTargets && (!currentTarget || !sameResolvedTarget(target, currentTarget))) {
-      facts.push({
-        ...baseFact(target),
-        blocker: "stale-ref",
-        refusalId: "editable_target_stale",
-        source: "target-resolution",
-        audit: auditFact(target, "stale-ref", "editable_target_stale", auditOperation),
-        message: "Editable target ref is stale for the current canonical document."
-      });
+      for (const auditOperation of targetAuditOperations) {
+        facts.push({
+          ...baseFact(target),
+          blocker: "stale-ref",
+          refusalId: "editable_target_stale",
+          source: "target-resolution",
+          audit: auditFact(target, "stale-ref", "editable_target_stale", auditOperation),
+          message: "Editable target ref is stale for the current canonical document."
+        });
+      }
     }
     for (const blocker of target.posture.blockers) {
       const refusalId = refusalIdForPostureBlocker(target, blocker);
       const message = messageForPostureBlocker(blocker);
-      facts.push({
-        ...baseFact(target),
-        blocker,
-        refusalId,
-        source: "editable-target-posture",
-        audit: auditFact(
-          target,
-          auditCategoryForPostureBlocker(target, blocker),
+      for (const auditOperation of targetAuditOperations) {
+        facts.push({
+          ...baseFact(target),
+          blocker,
           refusalId,
-          auditOperation
-        ),
-        ...message !== void 0 ? { message } : {}
-      });
+          source: "editable-target-posture",
+          audit: auditFact(
+            target,
+            auditCategoryForPostureBlocker(target, blocker),
+            refusalId,
+            auditOperation
+          ),
+          ...message !== void 0 ? { message } : {}
+        });
+      }
     }
     const range = targetRanges.get(target.targetKey);
     const protectedRange = range && input.protectionSnapshot ? findProtectionBlocker(input.protectionSnapshot, range) : null;
     if (protectedRange) {
-      facts.push({
-        ...baseFact(target),
-        blocker: "protected-range",
-        refusalId: "protected_range",
-        source: "protection-snapshot",
-        audit: auditFact(target, "protected-content", "protected_range", auditOperation),
-        message: protectedRange.enforcementReason,
-        rangeId: protectedRange.rangeId
-      });
+      for (const auditOperation of targetAuditOperations) {
+        facts.push({
+          ...baseFact(target),
+          blocker: "protected-range",
+          refusalId: "protected_range",
+          source: "protection-snapshot",
+          audit: auditFact(target, "protected-content", "protected_range", auditOperation),
+          message: protectedRange.enforcementReason,
+          rangeId: protectedRange.rangeId
+        });
+      }
     }
     for (const reason of input.guard?.blockedReasons ?? []) {
       const mapped = mapGuardReason(reason);
       if (!mapped) continue;
-      facts.push({
-        ...baseFact(target),
-        blocker: mapped.blocker,
-        refusalId: reason.code,
-        source: "interaction-guard",
-        audit: auditFact(target, mapped.auditCategory, reason.code, auditOperation),
-        message: reason.message,
-        ...reason.scopeId !== void 0 ? { scopeId: reason.scopeId } : {},
-        ...reason.workItemId !== void 0 ? { workItemId: reason.workItemId } : {}
-      });
+      for (const auditOperation of targetAuditOperations) {
+        facts.push({
+          ...baseFact(target),
+          blocker: mapped.blocker,
+          refusalId: reason.code,
+          source: "interaction-guard",
+          audit: auditFact(target, mapped.auditCategory, reason.code, auditOperation),
+          message: reason.message,
+          ...reason.scopeId !== void 0 ? { scopeId: reason.scopeId } : {},
+          ...reason.workItemId !== void 0 ? { workItemId: reason.workItemId } : {}
+        });
+      }
     }
   }
   return Object.freeze(dedupeFacts(facts).sort(compareFacts));
@@ -453,6 +461,22 @@ function baseFact(target) {
     blockPath: target.blockPath
   };
 }
+function auditOperationsByTarget(auditIntents) {
+  const byTarget = /* @__PURE__ */ new Map();
+  for (const intent of auditIntents ?? []) {
+    const operations = byTarget.get(intent.targetKey);
+    if (!operations) {
+      byTarget.set(intent.targetKey, [intent.operation]);
+    } else if (!operations.includes(intent.operation)) {
+      operations.push(intent.operation);
+    }
+  }
+  return byTarget;
+}
+function auditOperationsForTarget(target, auditOperations) {
+  const operations = auditOperations.get(target.targetKey);
+  return operations && operations.length > 0 ? operations : [auditOperationForTarget(target)];
+}
 function findProtectionBlocker(protection, targetRange) {
   const enforcedRanges = protection.ranges.filter(
     (range) => range.enforced && typeof range.start === "number" && typeof range.end === "number"
@@ -553,7 +577,7 @@ function auditOperationForTarget(target) {
     case "field":
       return target.field?.fieldFamily === "TOC" ? "toc-refresh" : "field-update";
     case "link-bookmark":
-      return target.kind === "bookmark-anchor" ? "bookmark-update" : "hyperlink-update";
+      return target.kind === "bookmark-anchor" || target.kind === "bookmark-content-range" ? "bookmark-update" : "hyperlink-update";
     case "comment-revision":
       return target.kind === "revision-anchor" ? "revision-action" : "comment-action";
     case "metadata":
@@ -567,7 +591,7 @@ function auditOperationForTarget(target) {
   }
 }
 function sameResolvedTarget(left, right) {
-  return left.kind === right.kind && left.storyKey === right.storyKey && left.blockPath === right.blockPath && left.leafPath === right.leafPath && left.commandFamily === right.commandFamily && left.editability === right.editability && stableJson(left.sourceRef) === stableJson(right.sourceRef) && stableJson(left.staleCheck) === stableJson(right.staleCheck);
+  return left.kind === right.kind && left.storyKey === right.storyKey && left.blockPath === right.blockPath && left.leafPath === right.leafPath && left.commandFamily === right.commandFamily && left.editability === right.editability && stableJson(left.sourceRef) === stableJson(right.sourceRef) && stableJson(left.staleCheck) === stableJson(right.staleCheck) && stableJson(left.editableOwner) === stableJson(right.editableOwner);
 }
 function stableJson(value) {
   if (Array.isArray(value)) {
@@ -2003,7 +2027,8 @@ function compileTableScope(entry, options = {}) {
     classifications: entry.classifications,
     content: {
       text: summary,
-      excerpt: buildExcerpt(summary)
+      excerpt: buildExcerpt(summary),
+      authority: "structural-summary"
     },
     formatting,
     layout: {},
@@ -2045,7 +2070,9 @@ function compileTableCellScope(entry, options = {}) {
     classifications: entry.classifications,
     content: {
       text: summary,
-      excerpt: buildExcerpt(summary)
+      excerpt: buildExcerpt(summary),
+      authority: "structural-summary",
+      editableTextPath: "evidence.editableTargets.entries[].readback"
     },
     formatting,
     layout: {},
@@ -2077,7 +2104,8 @@ function compileTableRowScope(entry, options = {}) {
     classifications: entry.classifications,
     content: {
       text: summary,
-      excerpt: buildExcerpt(summary)
+      excerpt: buildExcerpt(summary),
+      authority: "structural-summary"
     },
     formatting,
     layout: {},
@@ -2918,6 +2946,22 @@ function supported(reason, warnings = []) {
     ...hasWarnings ? { warnings: freezeList(warnings) } : {}
   };
 }
+function supportedCommand(reason, entries, warnings = []) {
+  const verdict = supported(reason, warnings);
+  const actionHandles = freezeUnique(
+    entries.flatMap(
+      (entry) => entry.runtimeCommand.actionHandle ? [entry.runtimeCommand.actionHandle] : []
+    )
+  );
+  const intents = freezeUnique(
+    entries.flatMap((entry) => [...entry.runtimeCommand.intents])
+  );
+  return {
+    ...verdict,
+    ...actionHandles.length > 0 ? { actionHandles } : {},
+    ...intents.length > 0 ? { intents } : {}
+  };
+}
 function unsupported(reason, blockers = [reason], warnings = []) {
   return {
     supported: false,
@@ -2959,6 +3003,27 @@ function contentControlBlockers(context) {
   if (entries.length === 0) return [];
   return freezeList(entries.map((entry) => `preserve:content-control:${entry.evidenceId}`));
 }
+function generatedOrLinkedContentBlockers(context) {
+  const blockers = [];
+  for (const entry of context?.editableTargets?.entries ?? []) {
+    if (entry.kind === "field-result-text") {
+      blockers.push("field-generated-text");
+      continue;
+    }
+    if (entry.kind === "bookmark-anchor") {
+      blockers.push("link-bookmark:bookmark-anchor");
+      continue;
+    }
+    if (entry.kind === "hyperlink-text") {
+      blockers.push("link-bookmark:hyperlink-text");
+      continue;
+    }
+    if (entry.commandFamily === "link-bookmark" && entry.runtimeCommand.status !== "supported") {
+      blockers.push(`link-bookmark:${entry.kind}`);
+    }
+  }
+  return freezeUnique(blockers);
+}
 function evidenceWarnings(context) {
   const warnings = [];
   if (context?.layout) {
@@ -2991,9 +3056,11 @@ function editableTargetWarnings(context) {
     [...kinds].sort().map((kind) => `editable-target:${kind}:available`)
   );
 }
-function commandSafeTargetWarnings(entries) {
-  return freezeUnique(
-    entries.map((entry) => `editable-target:${entry.kind}:available`).sort()
+function supportedCommandTargets(context, predicate) {
+  return Object.freeze(
+    [...context?.editableTargets?.entries ?? []].filter(
+      (entry) => entry.runtimeCommand.status === "supported" && predicate(entry)
+    )
   );
 }
 function commandTargetBlockers(entries) {
@@ -3008,6 +3075,9 @@ function commandTargetBlockers(entries) {
   }
   return freezeUnique(blockers.filter((blocker) => blocker.length > 0));
 }
+function hasRuntimeIntent(entry, intent) {
+  return entry.runtimeCommand.intents.includes(intent);
+}
 function insertCapability(scope, edge, context) {
   const guard = guardBlocker(scope);
   if (guard) return blocked(guard);
@@ -3029,10 +3099,26 @@ function insertCapability(scope, edge, context) {
 function replaceTextCapability(scope, context) {
   const guard = guardBlocker(scope);
   if (guard) return blocked(guard);
+  if (scope.kind === "list-item") {
+    return blocked(
+      "compile-blocked:list-text:authoritative-readback-required",
+      [
+        "capability:list-item:authoritative-readback-required",
+        "capability:list-text:export-persistent-target-required"
+      ]
+    );
+  }
   const contentControls = contentControlBlockers(context);
   if (contentControls.length > 0) {
     return blocked("preserve:content-control", contentControls);
   }
+  const generatedOrLinked = generatedOrLinkedContentBlockers(context);
+  if (generatedOrLinked.length > 0) {
+    return blocked(
+      "compile-refused:paragraph:generated-or-linked-content",
+      generatedOrLinked
+    );
+  }
   if (!PARAGRAPH_LIKE.has(scope.kind)) {
     if (scope.kind === "table-cell") {
       if (context?.tableCellTextRange?.status === "ok") {
@@ -3080,6 +3166,13 @@ function replaceFragmentCapability(scope, context) {
   if (contentControls.length > 0) {
     return blocked("preserve:content-control", contentControls);
   }
+  const generatedOrLinked = generatedOrLinkedContentBlockers(context);
+  if (generatedOrLinked.length > 0) {
+    return blocked(
+      "compile-refused:paragraph:generated-or-linked-content",
+      generatedOrLinked
+    );
+  }
   if (!PARAGRAPH_LIKE.has(scope.kind)) {
     const reason = scope.kind === "scope" && scope.replaceability.reason ? MULTI_PARAGRAPH_REPLACEMENT_REFUSAL : `compile-refused:${scope.kind}`;
     return unsupported(
@@ -3140,14 +3233,38 @@ function taxonomyRefusalCapability(action) {
     ]
   );
 }
+function fieldUpdateCapability(context) {
+  const supportedTargets = supportedCommandTargets(
+    context,
+    (entry) => entry.commandFamily === "field" && (entry.runtimeCommand.intents.includes("field-update") || entry.runtimeCommand.intents.includes("toc-refresh"))
+  );
+  if (supportedTargets.length === 0) return taxonomyRefusalCapability("field-update");
+  return supportedCommand(
+    supportedTargets.some((entry) => entry.runtimeCommand.intents.includes("toc-refresh")) ? "compile-supported:field-update:toc-refresh-target" : "compile-supported:field-update:editable-target",
+    supportedTargets
+  );
+}
 function linkEditCapability(context) {
   const supportedDisplayTextTarget = context?.editableTargets?.entries.find(
     (entry) => entry.kind === "hyperlink-text" && entry.commandFamily === "text-leaf" && entry.runtimeCommand.status === "supported" && entry.runtimeCommand.intents.includes("hyperlink-display-text-edit")
   );
-  if (!supportedDisplayTextTarget) {
+  const supportedDestinationTarget = context?.editableTargets?.entries.find(
+    (entry) => entry.kind === "hyperlink-destination" && entry.commandFamily === "link-bookmark" && entry.runtimeCommand.status === "supported" && entry.runtimeCommand.intents.includes("hyperlink-update")
+  );
+  if (!supportedDisplayTextTarget && !supportedDestinationTarget) {
     return taxonomyRefusalCapability("link-edit");
   }
-  return supported("compile-supported:link-edit:hyperlink-display-text");
+  return supportedCommand(
+    supportedDestinationTarget ? "compile-supported:link-edit:hyperlink-destination" : "compile-supported:link-edit:hyperlink-display-text",
+    supportedDestinationTarget ? [supportedDestinationTarget] : supportedDisplayTextTarget ? [supportedDisplayTextTarget] : []
+  );
+}
+function bookmarkEditCapability(context) {
+  const supportedRangeTarget = context?.editableTargets?.entries.find(
+    (entry) => entry.kind === "bookmark-content-range" && entry.commandFamily === "link-bookmark" && entry.runtimeCommand.status === "supported" && entry.runtimeCommand.intents.includes("bookmark-update")
+  );
+  if (!supportedRangeTarget) return taxonomyRefusalCapability("bookmark-edit");
+  return supportedCommand("compile-supported:bookmark-edit:content-range", [supportedRangeTarget]);
 }
 function tableTextCapability(scope, context) {
   const guard = guardBlocker(scope);
@@ -3159,10 +3276,10 @@ function tableTextCapability(scope, context) {
     (entry) => entry.runtimeTextCommand.status === "supported" && entry.runtimeCommand.status === "supported" && entry.runtimeCommand.intents.includes("text-leaf-edit")
   );
   if (supportedTargets.length > 0) {
-    return supported(
+    return supportedCommand(
       "compile-supported:table-text:editable-target",
+      supportedTargets,
       [
-        ...commandSafeTargetWarnings(supportedTargets),
         ...evidenceWarnings(context)
       ]
     );
@@ -3203,10 +3320,10 @@ function tableStructureCapability(scope, context) {
     (entry) => entry.runtimeCommand.status === "supported" && entry.runtimeCommand.intents.includes("table-structure-action")
   );
   if (supportedTargets.length > 0) {
-    return supported(
+    return supportedCommand(
       "compile-supported:table-structure:editable-target",
+      supportedTargets,
       [
-        ...commandSafeTargetWarnings(supportedTargets),
         ...tableFormattingWarnings(scope),
         ...evidenceWarnings(context)
       ]
@@ -3288,15 +3405,13 @@ function listTextCapability(scope, context) {
     (entry) => entry.commandFamily === "text-leaf" && LIST_TEXT_TARGET_KINDS.has(entry.kind) && (entry.relation === "exact-scope" || entry.relation === "descendant-of-scope")
   );
   const supportedTargets = listTextTargets.filter(
-    (entry) => entry.runtimeTextCommand.status === "supported" && entry.runtimeCommand.status === "supported" && entry.runtimeCommand.intents.includes("text-leaf-edit")
+    (entry) => entry.runtimeTextCommand.status === "supported" && entry.runtimeCommand.status === "supported" && hasRuntimeIntent(entry, "list-text-edit")
   );
   if (supportedTargets.length > 0) {
-    return supported(
+    return supportedCommand(
       "compile-supported:list-text:editable-target",
-      [
-        ...commandSafeTargetWarnings(supportedTargets),
-        ...evidenceWarnings(context)
-      ]
+      supportedTargets,
+      evidenceWarnings(context)
     );
   }
   if (listTextTargets.length > 0) {
@@ -3318,7 +3433,7 @@ function listTextCapability(scope, context) {
     ]
   );
 }
-function listStructureCapability(scope) {
+function listStructureCapability(scope, context) {
   if (scope.kind !== "list-item") {
     return unsupported(
       "compile-unsupported:list-structure:unsupported-target-family",
@@ -3328,6 +3443,26 @@ function listStructureCapability(scope) {
       ]
     );
   }
+  const listStructureTargets = (context?.editableTargets?.entries ?? []).filter(
+    (entry) => entry.commandFamily === "text-leaf" && LIST_TEXT_TARGET_KINDS.has(entry.kind) && (entry.relation === "exact-scope" || entry.relation === "descendant-of-scope")
+  );
+  const supportedTargets = listStructureTargets.filter(
+    (entry) => entry.runtimeCommand.status === "supported" && hasRuntimeIntent(entry, "list-structure-action")
+  );
+  if (supportedTargets.length > 0) {
+    return supportedCommand(
+      "compile-supported:list-structure:editable-target",
+      supportedTargets,
+      evidenceWarnings(context)
+    );
+  }
+  if (listStructureTargets.length > 0) {
+    const blockers = commandTargetBlockers(listStructureTargets);
+    return blocked(
+      "compile-blocked:list-structure:target-ref-blocked",
+      blockers.length > 0 ? blockers : ["compile-blocked:list-structure:target-ref-blocked"]
+    );
+  }
   return unsupported(
     "compile-unsupported:list-structure:no-target-family",
     [
@@ -3348,14 +3483,14 @@ function deriveScopeCapabilities(scope, context = {}) {
     canApplyFormatting: formattingCapability(scope, context),
     canClearFormattingLayer: formattingCapability(scope, context),
     canAttachMetadata: metadataCapability(scope),
-    canUpdateField: taxonomyRefusalCapability("field-update"),
+    canUpdateField: fieldUpdateCapability(context),
     canEditLink: linkEditCapability(context),
-    canEditBookmark: taxonomyRefusalCapability("bookmark-edit"),
+    canEditBookmark: bookmarkEditCapability(context),
     canEditTableText: tableTextCapability(scope, context),
     canEditTableStructure: tableStructureCapability(scope, context),
     canUseTableContinuationEvidence: tableContinuationEvidenceCapability(scope, context),
     canEditListText: listTextCapability(scope, context),
-    canEditListStructure: listStructureCapability(scope)
+    canEditListStructure: listStructureCapability(scope, context)
   };
 }
 
@@ -3662,6 +3797,22 @@ function relationForTarget(target, scope, entry) {
   if (entry?.kind === "revision" && target.kind === "revision-anchor" && target.review?.reviewId === entry.revision.changeId) {
     return "exact-scope";
   }
+  if (entry?.kind === "field") {
+    if (target.kind === "field-result-text" && target.blockPath === `main/block[${entry.blockIndex}]/inline[${entry.inlineIndex}]`) {
+      return "exact-scope";
+    }
+    if ((target.kind === "field-region-refresh" || target.kind === "toc-region-refresh") && target.field?.canonicalFieldId !== void 0 && target.field.canonicalFieldId === entry.field.canonicalFieldId) {
+      return "exact-scope";
+    }
+  }
+  if (entry && (entry.kind === "paragraph" || entry.kind === "heading" || entry.kind === "list-item")) {
+    if ((target.kind === "field-region-refresh" || target.kind === "toc-region-refresh") && target.field?.canonicalFieldId !== void 0 && paragraphHasFieldId(entry.paragraph, target.field.canonicalFieldId)) {
+      return "descendant-of-scope";
+    }
+    if (target.kind === "bookmark-content-range" && target.link?.bookmarkId !== void 0 && paragraphHasBookmarkId(entry.paragraph, target.link.bookmarkId)) {
+      return "descendant-of-scope";
+    }
+  }
   const parsedTargetPath = parsePath(target.blockPath);
   if (!parsedTargetPath) return null;
   const targetTokens = parsedTargetPath.tokens;
@@ -3681,6 +3832,27 @@ function relationForTarget(target, scope, entry) {
   if (targetTokens.length === scopeTokens.length) return "exact-scope";
   return targetInScope ? "descendant-of-scope" : "scope-descendant-of-target";
 }
+function paragraphHasFieldId(paragraph, canonicalFieldId) {
+  return paragraph.children.some(
+    (child) => child.type === "field" && child.canonicalFieldId === canonicalFieldId
+  );
+}
+function paragraphHasBookmarkId(paragraph, bookmarkId) {
+  return paragraph.children.some(
+    (child) => (child.type === "bookmark_start" || child.type === "bookmark_end") && child.bookmarkId === bookmarkId
+  );
+}
+function commandActionHandleForAddress(commandFamily, address) {
+  return address ? `scope-command:${commandFamily}:${address.addressKey}` : void 0;
+}
+function withCommandAction(evidence, target) {
+  if (evidence.status !== "supported" || !target.canonicalAddress) return evidence;
+  return {
+    ...evidence,
+    actionHandle: commandActionHandleForAddress(target.commandFamily, target.canonicalAddress),
+    canonicalAddress: target.canonicalAddress
+  };
+}
 function runtimeTextCommandEvidence(target, workflowBlockers) {
   const shapeIssues = validateEditableTargetRef(target);
   if (shapeIssues.length > 0) {
@@ -3730,6 +3902,11 @@ var TABLE_TEXT_TARGET_KINDS2 = /* @__PURE__ */ new Set([
   "nested-table-cell-paragraph-text",
   "sdt-table-cell-paragraph-text"
 ]);
+var LIST_TEXT_TARGET_KINDS2 = /* @__PURE__ */ new Set([
+  "paragraph-text",
+  "sdt-paragraph-text",
+  "secondary-story-paragraph-text"
+]);
 function tableTextScopeReplacementPosture(target) {
   if (target.posture.preserveOnly) {
     return {
@@ -3760,15 +3937,25 @@ function tableTextScopeReplacementPosture(target) {
     reason: "secondary-story-table-text-target-not-callable-by-scope-replacement"
   };
 }
-function runtimeCommandEvidence(target, workflowBlockers, textCommand) {
-  if (target.commandFamily === "text-leaf") {
+function runtimeCommandEvidence(target, workflowBlockers, textCommand, scopeKind) {
+  const shapeIssues = validateEditableTargetRef(target);
+  if (shapeIssues.length > 0) {
     return {
-      status: textCommand.status,
+      status: "blocked",
       commandFamily: target.commandFamily,
       intents: commandIntentsForTarget(target),
+      reason: "editable_target_malformed",
+      blockers: Object.freeze(["editable_target_malformed"])
+    };
+  }
+  if (target.commandFamily === "text-leaf") {
+    return withCommandAction({
+      status: textCommand.status,
+      commandFamily: target.commandFamily,
+      intents: commandIntentsForTarget(target, scopeKind),
       reason: textCommand.reason,
       ...textCommand.blockers ? { blockers: textCommand.blockers } : {}
-    };
+    }, target);
   }
   if (target.commandFamily === "comment-revision") {
     const isOpen = target.review?.status === "open";
@@ -3793,16 +3980,22 @@ function runtimeCommandEvidence(target, workflowBlockers, textCommand) {
         blockers: Object.freeze(actionableBlockers.map((fact) => fact.blocker))
       };
     }
-    return {
+    return withCommandAction({
       status: "supported",
       commandFamily: target.commandFamily,
       intents: commandIntentsForTarget(target),
       reason: commentRevisionCommandReason(target, true)
-    };
+    }, target);
   }
   if (target.commandFamily === "table-structure") {
     return tableStructureCommandEvidence(target, workflowBlockers);
   }
+  if (target.commandFamily === "field") {
+    return generatedFieldCommandEvidence(target, workflowBlockers);
+  }
+  if (target.commandFamily === "link-bookmark") {
+    return linkBookmarkCommandEvidence(target, workflowBlockers);
+  }
   const actionableWorkflowBlockers = workflowBlockers.filter(
     (fact) => fact.source !== "editable-target-posture"
   );
@@ -3815,6 +4008,8 @@ function runtimeCommandEvidence(target, workflowBlockers, textCommand) {
       blockers: Object.freeze(actionableWorkflowBlockers.map((fact) => fact.blocker))
     };
   }
+  const commandSupported = supportedNonTextCommandEvidence(target);
+  if (commandSupported) return commandSupported;
   return {
     status: "blocked",
     commandFamily: target.commandFamily,
@@ -3828,6 +4023,158 @@ function runtimeCommandEvidence(target, workflowBlockers, textCommand) {
     ])
   };
 }
+function generatedFieldCommandEvidence(target, workflowBlockers) {
+  const actionableWorkflowBlockers = workflowBlockers.filter(
+    (fact) => fact.source !== "editable-target-posture"
+  );
+  if (actionableWorkflowBlockers.length > 0) {
+    return {
+      status: "blocked",
+      commandFamily: target.commandFamily,
+      intents: commandIntentsForTarget(target),
+      reason: actionableWorkflowBlockers[0]?.refusalId ?? "editable_target_blocked_by_workflow",
+      blockers: Object.freeze(actionableWorkflowBlockers.map((fact) => fact.blocker))
+    };
+  }
+  if (target.posture.preserveOnly || target.posture.blockers.includes("preserve-only")) {
+    return {
+      status: "blocked",
+      commandFamily: target.commandFamily,
+      intents: commandIntentsForTarget(target),
+      reason: target.field?.fieldFamily === "TOC" ? "l07:toc-refresh-preserve-only-refused" : "l07:field-update-preserve-only-refused",
+      blockers: Object.freeze([...target.posture.blockers])
+    };
+  }
+  if (contentControlLocksTarget(target)) {
+    return {
+      status: "blocked",
+      commandFamily: target.commandFamily,
+      intents: commandIntentsForTarget(target),
+      reason: "editable_target_non_editable",
+      blockers: Object.freeze(["locked-content-control"])
+    };
+  }
+  if (target.kind !== "field-result-text" && target.kind !== "field-region-refresh" && target.kind !== "toc-region-refresh") {
+    return {
+      status: "blocked",
+      commandFamily: target.commandFamily,
+      intents: commandIntentsForTarget(target),
+      reason: "editable_target_kind_unsupported",
+      blockers: Object.freeze(["editable_target_kind_unsupported"])
+    };
+  }
+  if (!target.canonicalAddress) {
+    return {
+      status: "blocked",
+      commandFamily: target.commandFamily,
+      intents: commandIntentsForTarget(target),
+      reason: "editable_target_command_address_missing",
+      blockers: Object.freeze(["editable_target_command_address_missing"])
+    };
+  }
+  const expectedScope = target.kind === "toc-region-refresh" ? "toc-refresh" : "field-refresh";
+  if (target.canonicalAddress.operationScope !== expectedScope || target.field?.refreshStatus === "preserve-only" || !onlyBlockers(target.posture.blockers, ["field-generated-text", "unmodeled-target"])) {
+    return {
+      status: "blocked",
+      commandFamily: target.commandFamily,
+      intents: commandIntentsForTarget(target),
+      reason: commandRefusalReasonForTarget(target),
+      blockers: Object.freeze([...target.posture.blockers])
+    };
+  }
+  return withCommandAction({
+    status: "supported",
+    commandFamily: target.commandFamily,
+    intents: commandIntentsForTarget(target),
+    reason: target.kind === "toc-region-refresh" || target.field?.fieldFamily === "TOC" ? "l07:toc-refresh-target-supported" : "l07:field-refresh-target-supported"
+  }, target);
+}
+function linkBookmarkCommandEvidence(target, workflowBlockers) {
+  const actionableWorkflowBlockers = workflowBlockers.filter(
+    (fact) => fact.source !== "editable-target-posture"
+  );
+  if (actionableWorkflowBlockers.length > 0) {
+    return {
+      status: "blocked",
+      commandFamily: target.commandFamily,
+      intents: commandIntentsForTarget(target),
+      reason: actionableWorkflowBlockers[0]?.refusalId ?? "editable_target_blocked_by_workflow",
+      blockers: Object.freeze(actionableWorkflowBlockers.map((fact) => fact.blocker))
+    };
+  }
+  if (target.posture.preserveOnly || target.posture.blockers.includes("preserve-only")) {
+    return {
+      status: "blocked",
+      commandFamily: target.commandFamily,
+      intents: commandIntentsForTarget(target),
+      reason: commandRefusalReasonForTarget(target),
+      blockers: Object.freeze([...target.posture.blockers])
+    };
+  }
+  if (contentControlLocksTarget(target)) {
+    return {
+      status: "blocked",
+      commandFamily: target.commandFamily,
+      intents: commandIntentsForTarget(target),
+      reason: "editable_target_non_editable",
+      blockers: Object.freeze(["locked-content-control"])
+    };
+  }
+  if (target.kind === "hyperlink-destination") {
+    if (!target.canonicalAddress || target.canonicalAddress.operationScope !== "link-destination" || !onlyBlockers(target.posture.blockers, ["unmodeled-target"])) {
+      return {
+        status: "blocked",
+        commandFamily: target.commandFamily,
+        intents: commandIntentsForTarget(target),
+        reason: commandRefusalReasonForTarget(target),
+        blockers: Object.freeze([...target.posture.blockers])
+      };
+    }
+    return withCommandAction({
+      status: "supported",
+      commandFamily: target.commandFamily,
+      intents: commandIntentsForTarget(target),
+      reason: "l07:hyperlink-destination-target-supported"
+    }, target);
+  }
+  if (target.kind === "bookmark-content-range") {
+    if (!target.canonicalAddress || target.canonicalAddress.operationScope !== "bookmark-range" || !onlyBlockers(target.posture.blockers, ["unmodeled-target"])) {
+      return {
+        status: "blocked",
+        commandFamily: target.commandFamily,
+        intents: commandIntentsForTarget(target),
+        reason: commandRefusalReasonForTarget(target),
+        blockers: Object.freeze([...target.posture.blockers])
+      };
+    }
+    return withCommandAction({
+      status: "supported",
+      commandFamily: target.commandFamily,
+      intents: commandIntentsForTarget(target),
+      reason: "l07:bookmark-content-range-target-supported"
+    }, target);
+  }
+  return {
+    status: "blocked",
+    commandFamily: target.commandFamily,
+    intents: commandIntentsForTarget(target),
+    reason: "l07:bookmark-boundary-mutation-refused",
+    blockers: Object.freeze(["bookmark-boundary-mutation"])
+  };
+}
+function supportedNonTextCommandEvidence(target) {
+  if (target.commandFamily === "field") {
+    return generatedFieldCommandEvidence(target, []);
+  }
+  if (target.commandFamily === "link-bookmark") {
+    return linkBookmarkCommandEvidence(target, []);
+  }
+  return null;
+}
+function onlyBlockers(blockers, allowed) {
+  const allowedSet = new Set(allowed);
+  return blockers.every((blocker) => allowedSet.has(blocker));
+}
 function tableStructureCommandEvidence(target, workflowBlockers) {
   const shapeIssues = validateEditableTargetRef(target);
   if (shapeIssues.length > 0) {
@@ -3897,12 +4244,12 @@ function tableStructureCommandEvidence(target, workflowBlockers) {
       blockers: Object.freeze(["editable_target_table_path_unsupported"])
     };
   }
-  return {
+  return withCommandAction({
     status: "supported",
     commandFamily: target.commandFamily,
     intents: commandIntentsForTarget(target),
     reason: tableStructureSupportedReason(target)
-  };
+  }, target);
 }
 function tableStructureSupportedReason(target) {
   const table = target.table;
@@ -3927,17 +4274,32 @@ function commentRevisionCommandReason(target, isOpen) {
   }
   return isOpen ? "l07:comment-command-family-supported" : "l07:comment-command-not-open";
 }
-function commandIntentsForTarget(target) {
+function commandIntentsForTarget(target, scopeKind) {
   switch (target.commandFamily) {
     case "text-leaf":
-      return target.kind === "hyperlink-text" ? Object.freeze(["text-leaf-edit", "hyperlink-display-text-edit"]) : Object.freeze(["text-leaf-edit"]);
+      if (target.kind === "hyperlink-text") {
+        return Object.freeze(["text-leaf-edit", "hyperlink-display-text-edit"]);
+      }
+      if (target.table?.operationScope === "text") {
+        return Object.freeze([
+          "text-leaf-edit",
+          "table-text-paste",
+          "table-text-drop",
+          "table-structured-fragment-paste",
+          "table-structured-fragment-drop"
+        ]);
+      }
+      if (scopeKind === "list-item" && LIST_TEXT_TARGET_KINDS2.has(target.kind)) {
+        return Object.freeze(["text-leaf-edit", "list-text-edit", "list-structure-action"]);
+      }
+      return Object.freeze(["text-leaf-edit"]);
     case "field":
       return Object.freeze(
         target.field?.fieldFamily === "TOC" ? ["toc-refresh", "field-update"] : ["field-update"]
       );
     case "link-bookmark":
       return Object.freeze(
-        target.kind === "bookmark-anchor" ? ["bookmark-update"] : ["hyperlink-update"]
+        target.kind === "bookmark-anchor" || target.kind === "bookmark-content-range" ? ["bookmark-update"] : ["hyperlink-update"]
       );
     case "comment-revision":
       return Object.freeze(
@@ -3950,7 +4312,7 @@ function commandIntentsForTarget(target) {
     case "preserve-only-refusal":
       return target.object?.objectKind === "chart" ? Object.freeze(["chart-edit", "preserve-only-refusal"]) : target.object?.objectKind === "custom-xml" ? Object.freeze(["custom-xml-update", "preserve-only-refusal"]) : target.object?.objectKind === "ole" ? Object.freeze(["embedded-content-update", "preserve-only-refusal"]) : isOpaqueObjectTarget(target) ? Object.freeze(["opaque-content-preserve", "preserve-only-refusal"]) : isImageObjectTarget(target) ? Object.freeze(["image-layout", "image-frame", "preserve-only-refusal"]) : Object.freeze(["preserve-only-refusal"]);
     case "table-structure":
-      return Object.freeze(["table-structure-action"]);
+      return target.table?.operationScope === "span" ? Object.freeze(["table-structure-action", "table-merge-cells", "table-split-cell"]) : Object.freeze(["table-structure-action"]);
   }
 }
 function commandRefusalReasonForTarget(target) {
@@ -3961,7 +4323,10 @@ function commandRefusalReasonForTarget(target) {
       }
       return target.posture.preserveOnly ? "l07:field-update-preserve-only-refused" : "l07:field-update-command-family-unimplemented";
     case "link-bookmark":
-      return target.kind === "bookmark-anchor" ? "l07:bookmark-command-family-unimplemented" : "l07:hyperlink-command-family-unimplemented";
+      if (target.kind === "bookmark-anchor") {
+        return "l07:bookmark-boundary-mutation-refused";
+      }
+      return target.kind === "bookmark-content-range" ? "l07:bookmark-command-family-unimplemented" : "l07:hyperlink-command-family-unimplemented";
     case "comment-revision":
       return target.kind === "revision-anchor" ? "l07:revision-command-family-unimplemented" : "l07:comment-command-family-unimplemented";
     case "object":
@@ -4067,12 +4432,14 @@ function readbackForTarget(document, target, runtimeTextCommand) {
   }
   const leafBlock = resolveMainStoryLeafBlock(document, target.leafPath);
   if (!leafBlock) return void 0;
+  const text = collectBlockText(leafBlock);
   return {
-    text: collectBlockText(leafBlock),
+    text,
+    isEmpty: text.length === 0,
     source: "canonical-text-leaf"
   };
 }
-function projectTarget(document, target, relation, workflowBlockers) {
+function projectTarget(document, target, relation, workflowBlockers, scopeKind) {
   const runtimeTextCommand = runtimeTextCommandEvidence(target, workflowBlockers);
   const readback = readbackForTarget(document, target, runtimeTextCommand);
   return {
@@ -4091,11 +4458,13 @@ function projectTarget(document, target, relation, workflowBlockers) {
     ...target.review ? { review: target.review } : {},
     ...target.object ? { object: target.object } : {},
     ...target.table ? { table: target.table } : {},
+    ...target.editableOwner ? { editableOwner: target.editableOwner } : {},
+    ...target.canonicalAddress ? { canonicalAddress: target.canonicalAddress } : {},
     staleCheck: target.staleCheck,
     posture: target.posture,
     ...workflowBlockers.length > 0 ? { workflowBlockers: Object.freeze([...workflowBlockers]) } : {},
     runtimeTextCommand,
-    runtimeCommand: runtimeCommandEvidence(target, workflowBlockers, runtimeTextCommand),
+    runtimeCommand: runtimeCommandEvidence(target, workflowBlockers, runtimeTextCommand, scopeKind),
     ...readback ? { readback } : {}
   };
 }
@@ -4114,7 +4483,7 @@ function deriveScopeEditableTargetEvidence(document, scope, entry, options = {})
         (left, right) => left.source.localeCompare(right.source) || left.blocker.localeCompare(right.blocker) || left.refusalId.localeCompare(right.refusalId)
       )
     );
-    return projectTarget(document, target, relation, workflowBlockers);
+    return projectTarget(document, target, relation, workflowBlockers, scope.kind);
   }).filter((target) => target !== null).sort((a, b) => a.targetKey.localeCompare(b.targetKey));
   const blockers = /* @__PURE__ */ new Set();
   let supportedTextTargetCount = 0;
@@ -4211,42 +4580,76 @@ function verticalMergeFact(table, rowIndex, cellIndex) {
     role: "none"
   };
 }
-function cellFact(table, rowIndex, cellIndex) {
+function textTargetsForCell(editableTargets, blockIndex, rowIndex, cellIndex) {
+  if (!editableTargets) return Object.freeze([]);
+  const tablePath = `main/block[${blockIndex}]`;
+  return Object.freeze(
+    editableTargets.entries.filter(
+      (target) => target.commandFamily === "text-leaf" && target.table?.operationScope === "text" && target.table.tablePath === tablePath && target.table.rowIndex === rowIndex && target.table.cellIndex === cellIndex
+    )
+  );
+}
+function textState(targets, readbacks) {
+  if (targets.length === 0) return "unavailable";
+  if (readbacks.length === 0) {
+    return targets.some((target) => target.runtimeTextCommand.status === "supported") ? "unavailable" : "blocked";
+  }
+  return readbacks.some((readback) => !readback.isEmpty) ? "non-empty" : "empty";
+}
+function cellFact(table, blockIndex, rowIndex, cellIndex, editableTargets) {
   const row = table.rows[rowIndex];
   const cell = row.cells[cellIndex];
   const merge = verticalMergeFact(table, rowIndex, cellIndex);
+  const textTargets = textTargetsForCell(editableTargets, blockIndex, rowIndex, cellIndex);
+  const supportedTextTargetCount = textTargets.filter(
+    (target) => target.runtimeTextCommand.status === "supported"
+  ).length;
+  const readbacks = Object.freeze(
+    textTargets.map((target) => target.readback).filter((readback) => Boolean(readback))
+  );
   return {
     rowIndex,
     cellIndex,
+    ...cell.sourceRef ? { cellSourceRef: cell.sourceRef } : {},
     gridColumnStart: merge.gridColumnStart,
     gridSpan: merge.gridSpan,
     verticalMerge: merge,
-    childBlockCount: cell.children.length
+    childBlockCount: cell.children.length,
+    textTargetCount: textTargets.length,
+    supportedTextTargetCount,
+    textState: textState(textTargets, readbacks),
+    ...readbacks.length > 0 ? { textReadbacks: readbacks } : {}
   };
 }
-function rowFact(table, rowIndex) {
+function rowFact(table, blockIndex, rowIndex, editableTargets) {
   const row = table.rows[rowIndex];
   return {
     rowIndex,
+    ...row.sourceRef ? { rowSourceRef: row.sourceRef } : {},
     cellCount: row.cells.length,
     ...row.gridBefore !== void 0 ? { gridBefore: row.gridBefore } : {},
     ...row.gridAfter !== void 0 ? { gridAfter: row.gridAfter } : {},
     repeatedHeader: row.isHeader === true,
     splitRowAllowed: row.cantSplit !== true,
-    cells: Object.freeze(row.cells.map((_, cellIndex) => cellFact(table, rowIndex, cellIndex)))
+    cells: Object.freeze(
+      row.cells.map((_, cellIndex) => cellFact(table, blockIndex, rowIndex, cellIndex, editableTargets))
+    )
   };
 }
-function structureFacts(entry) {
+function structureFacts(entry, editableTargets) {
   const table = entry.table;
-  const rows = Object.freeze(table.rows.map((_, rowIndex) => rowFact(table, rowIndex)));
+  const rows = Object.freeze(
+    table.rows.map((_, rowIndex) => rowFact(table, entry.blockIndex, rowIndex, editableTargets))
+  );
   return {
+    ...table.sourceRef ? { sourceRef: table.sourceRef } : {},
     rowCount: table.rows.length,
     columnCount: columnCount(table),
     ...entry.kind === "table" ? { rows } : {},
     ...entry.kind === "table-row" ? { row: rows[entry.rowIndex] } : {},
     ...entry.kind === "table-cell" ? {
       row: rows[entry.rowIndex],
-      cell: cellFact(table, entry.rowIndex, entry.cellIndex)
+      cell: cellFact(table, entry.blockIndex, entry.rowIndex, entry.cellIndex, editableTargets)
     } : {}
   };
 }
@@ -4285,23 +4688,33 @@ function tableAction(entry, index) {
   if (!family || !entry.table) return null;
   const status = actionStatus(entry);
   const blockers = actionBlockers(entry);
+  const fullFidelityTableText = family === "table-text" && Boolean(entry.readback);
+  const actionHandle = entry.canonicalAddress ? `table-action:${entry.canonicalAddress.addressKey}` : `table-action:${family}:${index}`;
   return {
-    handle: `table-action:${family}:${index}`,
+    handle: actionHandle,
     family,
     status,
-    posture: status === "supported" ? "warn-and-proceed" : "hard-refusal",
+    posture: status === "supported" ? fullFidelityTableText ? "supported" : "warn-and-proceed" : "hard-refusal",
     reason: actionReason(entry),
     operationScope: entry.table.operationScope,
     targetKind: entry.kind,
     relation: entry.relation,
     intents: entry.runtimeCommand.intents,
+    ...entry.runtimeCommand.actionHandle ? { actionHandle: entry.runtimeCommand.actionHandle } : {},
+    ...entry.canonicalAddress ? { canonicalAddress: entry.canonicalAddress } : {},
+    ...entry.readback ? { readback: entry.readback } : {},
     ...blockers && blockers.length > 0 ? { blockers } : {},
-    ...status === "supported" ? { warnings: [`editable-target:${entry.kind}:available`] } : {},
+    ...status === "supported" && !fullFidelityTableText ? { warnings: [`editable-target:${entry.kind}:available`] } : {},
     diagnostics: {
-      targetKey: entry.targetKey,
-      blockPath: entry.blockPath,
-      leafPath: entry.leafPath,
-      rawTableKey: entry.table.tableKey
+      ...entry.table.sourceRef ? { sourceRef: entry.table.sourceRef } : {},
+      ...entry.table.rowSourceRef ? { rowSourceRef: entry.table.rowSourceRef } : {},
+      ...entry.table.cellSourceRef ? { cellSourceRef: entry.table.cellSourceRef } : {},
+      raw: {
+        targetKey: entry.targetKey,
+        blockPath: entry.blockPath,
+        leafPath: entry.leafPath,
+        tableKey: entry.table.tableKey
+      }
     }
   };
 }
@@ -4331,7 +4744,7 @@ function deriveScopeTableEvidence(scope, entry, options = {}) {
     status: "present",
     semanticHandle: semanticHandle(scope, entry),
     diagnostics: diagnostics(scope, entry),
-    structure: structureFacts(entry),
+    structure: structureFacts(entry, options.editableTargets),
     actions: actions(options.editableTargets),
     ...fragments ? { layoutFragments: fragments } : {}
   };
@@ -4493,6 +4906,8 @@ function mapSemanticEntry(entry) {
     return null;
   }
   const targetKey = stringValue(entry.editableTargetKey);
+  const editableTargetOwnerKey = stringValue(entry.editableTargetOwnerKey);
+  const editableTargetOwnerReason = stringValue(entry.editableTargetOwnerReason);
   const blockers = stringList(entry.editableTargetBlockers);
   const divergenceIds = stringList(entry.layoutDivergenceIds);
   const layoutDivergenceObjectIds = stringList(entry.layoutDivergenceObjectIds);
@@ -4522,7 +4937,13 @@ function mapSemanticEntry(entry) {
         ...stringValue(entry.editableTargetCommandFamily) ? { commandFamily: stringValue(entry.editableTargetCommandFamily) } : {},
         ...stringValue(entry.editableTargetEditability) ? { editability: stringValue(entry.editableTargetEditability) } : {},
         ...blockers ? { blockers } : {},
-        ...stringValue(entry.editableTargetLeafPath) ? { leafPath: stringValue(entry.editableTargetLeafPath) } : {}
+        ...stringValue(entry.editableTargetLeafPath) ? { leafPath: stringValue(entry.editableTargetLeafPath) } : {},
+        ...editableTargetOwnerKey ? {
+          editableOwner: {
+            targetKey: editableTargetOwnerKey,
+            reason: editableTargetOwnerReason ?? "unknown"
+          }
+        } : {}
       }
     } : {},
     ...entry.sourceIdentity ? { sourceIdentity: { ...entry.sourceIdentity } } : {}
@@ -5811,7 +6232,7 @@ function collectPreservationVerdict(inputs, blockedReasons, warnings) {
   }
   if (!document) return;
   const pm = positionMap ?? buildScopePositionMap(document);
-  const range = inputs.enumeratedScope ? resolveScopeRange(inputs.enumeratedScope, scope.handle, pm) : scope.handle.stableRef.kind === "scope-id" ? pm.markerScopes.get(scope.handle.stableRef.value) ?? null : null;
+  const range = inputs.enumeratedScope ? resolveScopeRange(inputs.enumeratedScope, scope.handle, pm) : scope.handle.stableRef.kind === "scope-id" ? pm.markerScopes.get(scope.handle.stableRef.value) ?? null : rangeFromSemanticPath(scope.handle.semanticPath, pm);
   const verdict = computePreservationVerdict(document, range, pm);
   if (verdict.replaceable) return;
   const opaqueOptIn = inputs.preservePolicy?.opaqueFragments === true;
@@ -5843,6 +6264,134 @@ function collectCompatibilityVerdict(runtime, blockedReasons, warnings) {
     }
   }
 }
+function collectCapabilityVerdict(inputs, blockedReasons, warnings) {
+  if (inputs.operation === "replace" && inputs.proposedContent.kind === "text") {
+    for (const blocker of generatedOrLinkedContentBlockers2(inputs)) {
+      blockedReasons.push(blocker);
+      warnings.push({
+        code: blocker,
+        message: blocker === "field-generated-text" ? "target range includes generated field text; use a field/TOC command path or refuse" : "target range includes bookmark/link boundary content; use a link/bookmark command path or refuse",
+        source: "capability"
+      });
+    }
+  }
+  if (inputs.scope.kind === "list-item" && inputs.operation === "replace" && inputs.proposedContent.kind === "text") {
+    const code = "capability:list-item:authoritative-readback-required";
+    blockedReasons.push(code);
+    warnings.push({
+      code,
+      message: "list-item flat text replacement is blocked until the runtime validates an export-persistent list text command path",
+      source: "capability"
+    });
+  }
+}
+function generatedOrLinkedContentBlockers2(inputs) {
+  const { document, scope, positionMap } = inputs;
+  if (!document) return [];
+  const pm = positionMap ?? buildScopePositionMap(document);
+  const range = inputs.enumeratedScope ? resolveScopeRange(inputs.enumeratedScope, scope.handle, pm) : scope.handle.stableRef.kind === "scope-id" ? pm.markerScopes.get(scope.handle.stableRef.value) ?? null : rangeFromSemanticPath(scope.handle.semanticPath, pm);
+  if (!range) return [];
+  const root = document.content;
+  if (!root || root.type !== "doc" || !Array.isArray(root.children)) return [];
+  const blockers = /* @__PURE__ */ new Set();
+  if (scope.kind === "table-cell") {
+    const cell = tableCellFromSemanticPath(root, scope.handle.semanticPath);
+    if (cell) {
+      collectGeneratedOrLinkedBlocksBlockers(cell.children, blockers);
+      return [...blockers].sort();
+    }
+  }
+  root.children.forEach((block, blockIndex) => {
+    if (block.type !== "paragraph") return;
+    const blockRange = pm.blocks.get(blockIndex);
+    if (!blockRange || !rangesOverlapOrTouch(range, blockRange)) return;
+    collectGeneratedOrLinkedInlineBlockers(block, blockIndex, pm, range, blockers);
+  });
+  return [...blockers].sort();
+}
+function tableCellFromSemanticPath(root, semanticPath) {
+  const tableIndex = semanticPath.findIndex((part) => part === "table");
+  const rowIndex = semanticPath.findIndex((part) => part === "row");
+  const cellIndex = semanticPath.findIndex((part) => part === "cell");
+  const tableBlockIndex = tableIndex >= 0 ? Number(semanticPath[tableIndex + 1]) : NaN;
+  const rowOrdinal = rowIndex >= 0 ? Number(semanticPath[rowIndex + 1]) : NaN;
+  const cellOrdinal = cellIndex >= 0 ? Number(semanticPath[cellIndex + 1]) : NaN;
+  if (!Number.isInteger(tableBlockIndex) || !Number.isInteger(rowOrdinal) || !Number.isInteger(cellOrdinal)) {
+    return null;
+  }
+  const table = root.children[tableBlockIndex];
+  if (!table || table.type !== "table") return null;
+  return table.rows[rowOrdinal]?.cells[cellOrdinal] ?? null;
+}
+function collectGeneratedOrLinkedBlocksBlockers(blocks, blockers) {
+  for (const block of blocks) {
+    if (block.type === "paragraph") {
+      for (const child of block.children) {
+        collectGeneratedOrLinkedNodeBlockers(child, blockers);
+      }
+      continue;
+    }
+    if (block.type === "table") {
+      for (const row of block.rows) {
+        for (const cell of row.cells) {
+          collectGeneratedOrLinkedBlocksBlockers(cell.children, blockers);
+        }
+      }
+      continue;
+    }
+    if (block.type === "sdt") {
+      collectGeneratedOrLinkedBlocksBlockers(block.children, blockers);
+    }
+  }
+}
+function rangeFromSemanticPath(semanticPath, positionMap) {
+  const paragraphIndex = semanticPath.findIndex(
+    (part) => part === "paragraph" || part === "heading" || part === "list-item"
+  );
+  if (paragraphIndex < 0) return null;
+  const rawIndex = semanticPath[paragraphIndex + 1] ?? semanticPath[semanticPath.length - 1];
+  const blockIndex = rawIndex !== void 0 ? Number(rawIndex) : NaN;
+  if (!Number.isInteger(blockIndex)) return null;
+  return positionMap.blocks.get(blockIndex) ?? null;
+}
+function collectGeneratedOrLinkedInlineBlockers(paragraph, blockIndex, positionMap, range, blockers) {
+  paragraph.children.forEach((child, inlineIndex) => {
+    const inlineRange = positionMap.inlines.get(`${blockIndex}:${inlineIndex}`);
+    if (!inlineRange || !rangesOverlapOrTouch(range, inlineRange)) return;
+    collectGeneratedOrLinkedNodeBlockers(child, blockers);
+  });
+}
+function collectGeneratedOrLinkedNodeBlockers(node, blockers) {
+  switch (node.type) {
+    case "field":
+      blockers.add("field-generated-text");
+      node.children.forEach(
+        (child) => collectGeneratedOrLinkedNodeBlockers(child, blockers)
+      );
+      break;
+    case "bookmark_start":
+    case "bookmark_end":
+      blockers.add("link-bookmark:bookmark-anchor");
+      break;
+    case "hyperlink":
+      blockers.add("link-bookmark:hyperlink-text");
+      node.children.forEach(
+        (child) => collectGeneratedOrLinkedNodeBlockers(child, blockers)
+      );
+      break;
+    default:
+      break;
+  }
+}
+function rangesOverlapOrTouch(left, right) {
+  if (right.from === right.to) {
+    return right.from >= left.from && right.from <= left.to;
+  }
+  if (left.from === left.to) {
+    return left.from >= right.from && left.from <= right.to;
+  }
+  return left.from < right.to && right.from < left.to;
+}
 function collectPolicyVerdict(actionId, blockedReasons, warnings) {
   let policy;
   try {
@@ -5882,6 +6431,7 @@ function composeScopeValidation(inputs) {
   collectGuardVerdict(inputs.scope, inputs.runtime, blockedReasons, warnings);
   collectPreservationVerdict(inputs, blockedReasons, warnings);
   collectCompatibilityVerdict(inputs.runtime, blockedReasons, warnings);
+  collectCapabilityVerdict(inputs, blockedReasons, warnings);
   const actionId = inputs.actionId ?? inferActionId(inputs.operation, inputs.proposedContent);
   const approval = collectPolicyVerdict(actionId, blockedReasons, warnings);
   const safe = blockedReasons.length === 0;
@@ -6124,8 +6674,10 @@ function applyScopeReplacement(inputs) {
     proposed.targetHandle.scopeId
   );
   const proposedText = proposed.proposedContent.kind === "text" ? proposed.proposedContent.text ?? "" : null;
-  const shouldVerifyReadback = inputs.sink.verifyReadback === true && proposed.preserve?.opaqueFragments === true;
-  const readbackFailureReason = shouldVerifyReadback && documentHashAfter === documentHashBefore && posture === "direct-edit" && !readback ? `apply-readback-unresolvable:${proposed.targetHandle.scopeId}` : shouldVerifyReadback && documentHashAfter === documentHashBefore && posture === "direct-edit" && proposed.operation === "replace" && proposedText !== null && proposedText !== resolvedScope.content.text && readback?.scope.content.text === resolvedScope.content.text ? `apply-readback-unchanged:${proposed.targetHandle.scopeId}` : void 0;
+  const paragraphLikeReadback = resolvedScope.kind === "paragraph" || resolvedScope.kind === "heading" || resolvedScope.kind === "list-item";
+  const shouldVerifyExactReadback = inputs.sink.verifyReadback === true && paragraphLikeReadback && resolvedScope.handle.provenance !== "marker-backed" && proposed.preserve?.opaqueFragments !== true && posture === "direct-edit" && proposed.operation === "replace" && proposedText !== null && proposedText !== resolvedScope.content.text;
+  const shouldVerifyOpaqueNoopReadback = inputs.sink.verifyReadback === true && proposed.preserve?.opaqueFragments === true;
+  const readbackFailureReason = shouldVerifyExactReadback && !readback ? `apply-readback-unresolvable:${proposed.targetHandle.scopeId}` : shouldVerifyExactReadback && readback?.scope.content.text !== proposedText ? readback?.scope.content.text === resolvedScope.content.text ? `apply-readback-unchanged:${proposed.targetHandle.scopeId}` : `apply-readback-mismatch:${proposed.targetHandle.scopeId}` : shouldVerifyOpaqueNoopReadback && documentHashAfter === documentHashBefore && posture === "direct-edit" && !readback ? `apply-readback-unresolvable:${proposed.targetHandle.scopeId}` : shouldVerifyOpaqueNoopReadback && documentHashAfter === documentHashBefore && posture === "direct-edit" && proposed.operation === "replace" && proposedText !== null && proposedText !== resolvedScope.content.text && readback?.scope.content.text === resolvedScope.content.text ? `apply-readback-unchanged:${proposed.targetHandle.scopeId}` : void 0;
   if (readbackFailureReason) {
     const blockers = Object.freeze([
       readbackFailureReason,
@@ -7283,7 +7835,8 @@ function resolveEditableTextTarget(input) {
       "Editable target ref does not belong to the active story."
     );
   }
-  const current = collectEditableTargetRefs(input.document).find(
+  const currentTargets = collectEditableTargetRefs(input.document);
+  const current = currentTargets.find(
     (candidate) => candidate.targetKey === input.target.targetKey
   );
   if (!current) {
@@ -7310,19 +7863,26 @@ function resolveEditableTextTarget(input) {
       `Editable target command family "${input.target.commandFamily}" is not supported by text commands.`
     );
   }
-  if (input.target.editability !== "editable" || input.target.posture.blockers.length > 0) {
+  const dispatchTarget = resolveEditableDispatchTarget(currentTargets, current);
+  if (!dispatchTarget) {
+    return reject(
+      "editable_target_synthetic_layout_cell",
+      "Vertical-merge continuation cells are synthetic layout cells and do not have an editable restart-cell owner."
+    );
+  }
+  if (dispatchTarget.editability !== "editable" || dispatchTarget.posture.blockers.length > 0) {
     return reject(
       "editable_target_non_editable",
-      `Editable target is not editable${input.target.posture.blockers.length > 0 ? `: ${input.target.posture.blockers.join(", ")}` : "."}`
+      `Editable target is not editable${dispatchTarget.posture.blockers.length > 0 ? `: ${dispatchTarget.posture.blockers.join(", ")}` : "."}`
     );
   }
-  if (contentControlLocksTarget2(input.target)) {
+  if (contentControlLocksTarget2(dispatchTarget)) {
     return reject(
       "editable_target_non_editable",
       "Editable target is inside a locked content control."
     );
   }
-  const range = locateTargetRange(input.document, input.surface, current);
+  const range = locateTargetRange(input.document, input.surface, dispatchTarget);
   if (!range) {
     return reject(
       "editable_target_surface_unavailable",
@@ -7351,6 +7911,97 @@ function resolveEditableTextTarget(input) {
     range: { from: range.from, to: range.to }
   };
 }
+function resolveEditableCommandTarget(input) {
+  if (!input.target) {
+    return rejectCommand(
+      "editable_target_required",
+      "Runtime target commands require a validated editable target ref."
+    );
+  }
+  const shapeIssues = validateEditableTargetRef(input.target);
+  if (shapeIssues.length > 0) {
+    return rejectCommand(
+      "editable_target_malformed",
+      `Editable target ref is malformed: ${shapeIssues[0]?.path ?? "$"}.`
+    );
+  }
+  const activeStoryKey = input.activeStoryKey ?? input.target.storyKey;
+  if (input.target.storyKey !== activeStoryKey) {
+    return rejectCommand(
+      "editable_target_wrong_story",
+      "Editable target ref does not belong to the active story."
+    );
+  }
+  if (!input.commandFamilies.includes(input.target.commandFamily)) {
+    return rejectCommand(
+      "editable_target_command_family_unsupported",
+      `Editable target command family "${input.target.commandFamily}" is not supported by this command.`
+    );
+  }
+  if (input.targetKinds && !input.targetKinds.includes(input.target.kind)) {
+    return rejectCommand(
+      "editable_target_kind_unsupported",
+      `Editable target kind "${input.target.kind}" is not supported by this command.`
+    );
+  }
+  const currentTargets = collectEditableTargetRefs(input.document);
+  const current = currentTargets.find(
+    (candidate) => candidate.targetKey === input.target?.targetKey
+  );
+  if (!current) {
+    return rejectCommand(
+      "editable_target_not_found",
+      "Editable target ref no longer resolves in the current canonical document."
+    );
+  }
+  if (!sameResolvedTarget2(input.target, current)) {
+    return rejectCommand(
+      "editable_target_stale",
+      "Editable target ref is stale for the current canonical document."
+    );
+  }
+  if (contentControlLocksTarget2(current)) {
+    return rejectCommand(
+      "editable_target_non_editable",
+      "Editable target is inside a locked content control."
+    );
+  }
+  if (current.posture.preserveOnly || current.posture.blockers.includes("preserve-only")) {
+    return rejectCommand(
+      "editable_target_preserve_only",
+      "Editable target is preserve-only and cannot be mutated by runtime commands."
+    );
+  }
+  if (!input.allowGeneratedPosture) {
+    const blockers = current.posture.blockers.filter(
+      (blocker) => blocker !== "unmodeled-target"
+    );
+    if (current.editability !== "editable" || blockers.length > 0) {
+      return rejectCommand(
+        "editable_target_non_editable",
+        `Editable target is not editable${blockers.length > 0 ? `: ${blockers.join(", ")}` : "."}`
+      );
+    }
+  }
+  return {
+    kind: "accepted",
+    target: current
+  };
+}
+function resolveEditableDispatchTarget(currentTargets, target) {
+  if (!isSyntheticLayoutContinuationTarget(target)) return target;
+  const owner = target.editableOwner;
+  if (!owner) return null;
+  const ownerTarget = currentTargets.find((candidate) => candidate.targetKey === owner.targetKey);
+  if (!ownerTarget) return null;
+  if (ownerTarget.commandFamily !== "text-leaf" || ownerTarget.storyKey !== owner.storyKey || ownerTarget.blockPath !== owner.blockPath || ownerTarget.leafPath !== owner.leafPath || ownerTarget.kind !== owner.kind) {
+    return null;
+  }
+  return ownerTarget;
+}
+function isSyntheticLayoutContinuationTarget(target) {
+  return target.commandFamily === "text-leaf" && target.table?.operationScope === "text" && target.table.verticalMerge === "continue" && target.posture.blockers.includes("synthetic-layout-cell");
+}
 function contentControlLocksTarget2(target) {
   const lock = target.contentControl?.lock;
   return lock !== void 0 && lock !== "unlocked" && lock !== "none";
@@ -7361,8 +8012,14 @@ function reject(code, message) {
     blockedReason: { code, message }
   };
 }
+function rejectCommand(code, message) {
+  return {
+    kind: "rejected",
+    blockedReason: { code, message }
+  };
+}
 function sameResolvedTarget2(left, right) {
-  return left.kind === right.kind && left.storyKey === right.storyKey && left.blockPath === right.blockPath && left.leafPath === right.leafPath && left.commandFamily === right.commandFamily && left.editability === right.editability && left.staleCheck.paragraphTextHash === right.staleCheck.paragraphTextHash && left.staleCheck.paragraphTextLength === right.staleCheck.paragraphTextLength && left.staleCheck.inlineCount === right.staleCheck.inlineCount && left.staleCheck.targetHash === right.staleCheck.targetHash && left.staleCheck.targetTextLength === right.staleCheck.targetTextLength && left.staleCheck.childCount === right.staleCheck.childCount && left.staleCheck.blockType === right.staleCheck.blockType && left.staleCheck.wordParaId === right.staleCheck.wordParaId && left.staleCheck.wordTextId === right.staleCheck.wordTextId && jsonStable(left.staleCheck.sourceRef) === jsonStable(right.staleCheck.sourceRef) && jsonStable(left.sourceRef) === jsonStable(right.sourceRef) && jsonStable(left.table) === jsonStable(right.table);
+  return left.kind === right.kind && left.storyKey === right.storyKey && left.blockPath === right.blockPath && left.leafPath === right.leafPath && left.commandFamily === right.commandFamily && left.editability === right.editability && left.staleCheck.paragraphTextHash === right.staleCheck.paragraphTextHash && left.staleCheck.paragraphTextLength === right.staleCheck.paragraphTextLength && left.staleCheck.inlineCount === right.staleCheck.inlineCount && left.staleCheck.targetHash === right.staleCheck.targetHash && left.staleCheck.targetTextLength === right.staleCheck.targetTextLength && left.staleCheck.childCount === right.staleCheck.childCount && left.staleCheck.blockType === right.staleCheck.blockType && left.staleCheck.wordParaId === right.staleCheck.wordParaId && left.staleCheck.wordTextId === right.staleCheck.wordTextId && jsonStable(left.staleCheck.sourceRef) === jsonStable(right.staleCheck.sourceRef) && jsonStable(left.sourceRef) === jsonStable(right.sourceRef) && jsonStable(left.table) === jsonStable(right.table) && jsonStable(left.editableOwner) === jsonStable(right.editableOwner);
 }
 function locateTargetRange(document, surface, target) {
   if (target.kind === "hyperlink-text") {
@@ -7853,5 +8510,6 @@ export {
   parseCanonicalFragmentFromWordML,
   serializeFragmentToWordML,
   resolveEditableTextTarget,
+  resolveEditableCommandTarget,
   resolveEditableTableStructureTarget
 };