@beyondwork/docx-react-component 1.0.124 → 1.0.126

package/dist/{chunk-ZMRO6P3A.js → chunk-6IGWPAR4.js}

@@ -17,7 +17,7 @@ import {
   resolveScopeRange,
   scopeSpecificity,
   searchDocument
-} from "./chunk-Q76XPPTA.js";
+} from "./chunk-FPRWV54X.js";
 import {
   BROADCAST_COMMAND_TYPES,
   COMMAND_EVENT_SCHEMA_VERSION,
@@ -28,7 +28,7 @@ import {
   buildPageAnchorElementId,
   createUiApi,
   emitUxResponse
-} from "./chunk-HXHQA4BU.js";
+} from "./chunk-YIYM4ZAP.js";
 import {
   DEFAULT_PX_PER_TWIP,
   DEFAULT_REGISTRY_ENTRIES,
@@ -36,23 +36,23 @@ import {
   LAYCACHE_SCHEMA_VERSION,
   LAYOUT_ENGINE_VERSION,
   createScopeTagRegistry
-} from "./chunk-ZRHLLPSJ.js";
+} from "./chunk-YHZHPXDB.js";
 import {
   chartModelStore,
   createFormattingContext
-} from "./chunk-H6IL5ABU.js";
+} from "./chunk-CXSYRB37.js";
 import {
   deriveDocumentStats
 } from "./chunk-OYGMRRR7.js";
 import {
   DocxSession
-} from "./chunk-7PC6XUNO.js";
+} from "./chunk-TQDQU2E3.js";
 import {
   WORKFLOW_PAYLOAD_PART_PATH,
   buildEditorStateXml,
   parseEditorStateXml,
   parseWorkflowPayloadEnvelopeFromPackage
-} from "./chunk-4B74ETJI.js";
+} from "./chunk-V6XVZFFH.js";
 import {
   EMU_PER_PX,
   GRADIENT_STOP_UNITS,
@@ -61,7 +61,7 @@ import {
   createHeaderFooterStoryKey,
   createNoteStoryKey,
   validateEditableTargetRef
-} from "./chunk-FNWKE74J.js";
+} from "./chunk-5DGKFNQT.js";
 import {
   readOpcPackage
 } from "./chunk-OL2UEHRP.js";
@@ -6302,6 +6302,17 @@ var hyperlinkDestinationEditMetadata = actionMethodMetadata(
     expectedDelta: "hyperlink destination changes"
   }
 );
+var hyperlinkTextEditMetadata = actionMethodMetadata(
+  "hyperlinkTextEdit",
+  "mutate",
+  "actions-link-bookmark",
+  "Edit supported hyperlink display text through the L07 text-leaf command target; broad carrier scope rewrite remains refused.",
+  {
+    uiVisible: true,
+    expectsUxResponse: "inline-change",
+    expectedDelta: "hyperlink display text changes"
+  }
+);
 var listOperationMetadata = actionMethodMetadata(
   "listOperation",
   "mutate",
@@ -6361,6 +6372,7 @@ var ACTION_METHODS = Object.freeze([
   "tocRefresh",
   "bookmarkEdit",
   "hyperlinkDestinationEdit",
+  "hyperlinkTextEdit",
   "listOperation",
   "tableFragment",
   "tableSelection",
@@ -6370,6 +6382,9 @@ var DEFAULT_LOCATE_LIMIT = 20;
 var DEFAULT_REWRITE_ALL_LIMIT = 10;
 var DEFAULT_TABLE_TEXT_SCOPE_LIMIT = 3;
 var DEFAULT_PLAN_STEP_LIMIT = 20;
+function documentContentHash(runtime) {
+  return JSON.stringify(runtime.getCanonicalDocument().content);
+}
 function createActionsFamily(runtime) {
   const category = {
     discover(input) {
@@ -6616,6 +6631,14 @@ function createActionsFamily(runtime) {
           ...readback ? { text: readback.text, excerpt: excerpt(readback.text) } : {}
         };
       }
+      if (resolved.target.kind === "editable-text") {
+        return {
+          status: "read",
+          target: summarizeTarget(resolved.target),
+          text: resolved.target.readback.text,
+          excerpt: excerpt(resolved.target.readback.text)
+        };
+      }
       const text = resolved.target.scope.content.text;
       return {
         status: "read",
@@ -6696,6 +6719,31 @@ function createActionsFamily(runtime) {
         input
       );
     },
+    hyperlinkTextEdit(input) {
+      if (input.text === void 0) {
+        return blockedApply(
+          "actions:hyperlink-text-edit:text-required",
+          "input",
+          "Hyperlink display text edit actions require a text value.",
+          "Retry with a text string."
+        );
+      }
+      const resolved = resolveTarget(runtime, input.target);
+      if (!resolved.ok) return blockedApplyFromResolution(resolved);
+      if (resolved.target.kind !== "editable-text" || resolved.target.targetKind !== "hyperlink-text") {
+        return blockedApply(
+          "actions:hyperlink-text-edit:hyperlink-text-handle-required",
+          "unsupported",
+          "Hyperlink display text edits require an exact hyperlink-text actionHandle.",
+          "Call ai.actions.locateAll and retry with a returned scope-command:text-leaf actionHandle."
+        );
+      }
+      return applyEditableTextRewrite(runtime, resolved.target, {
+        text: input.text,
+        actorId: input.actorId,
+        origin: input.origin
+      });
+    },
     listOperation(input) {
       return applyListOperation(runtime, input);
     },
@@ -6744,6 +6792,7 @@ function runPlan(runtime, input) {
   for (const step of input.steps) {
     const result = runPlanStep(runtime, mode, step, input);
     results.push(result);
+    if (isSuspectMutationStep(result)) break;
     if (stopOnBlocker && (result.status === "blocked" || result.status === "unsupported")) {
       break;
     }
@@ -6808,24 +6857,27 @@ function runPlanStep(runtime, mode, step, plan) {
       ...before.readback ? { beforeReadback: before.readback } : {}
     };
   }
+  const documentHashBeforeApply = documentContentHash(runtime);
   const applied = applyPlanStep(runtime, step, plan);
+  const documentHashAfterApply = documentContentHash(runtime);
+  const projectedApply = !applied.applied && documentHashAfterApply !== documentHashBeforeApply ? withSuspectMutationApplyResult(applied, step.id, applied.target ?? before.target) : applied;
   const after = step.kind === "flag" ? before : step.target ? readPlanTarget(runtime, step.target) : before;
   return {
     id: step.id,
     kind: step.kind,
-    status: applied.status === "unsupported" ? "unsupported" : applied.applied ? "applied" : "blocked",
-    applied: applied.applied,
-    changed: applied.changed,
-    ...applied.target ?? before.target ? { target: applied.target ?? before.target } : {},
+    status: projectedApply.status === "unsupported" ? "unsupported" : projectedApply.applied ? "applied" : "blocked",
+    applied: projectedApply.applied,
+    changed: projectedApply.changed,
+    ...projectedApply.target ?? before.target ? { target: projectedApply.target ?? before.target } : {},
     ...before.tableAction ? { tableAction: before.tableAction } : {},
     ...before.readback ? { beforeReadback: before.readback } : {},
     ...after.ok && after.readback ? { afterReadback: after.readback } : {},
-    ...applied.proposalId ? { proposalId: applied.proposalId } : {},
-    ...applied.posture ? { posture: applied.posture } : {},
-    ...applied.blockers ? { blockers: applied.blockers } : {},
-    ...applied.blockerDetails ? { blockerDetails: applied.blockerDetails } : {},
-    ...applied.auditReference ? { auditReference: applied.auditReference } : {},
-    ...applied.commandReference ? { commandReference: applied.commandReference } : {}
+    ...projectedApply.proposalId ? { proposalId: projectedApply.proposalId } : {},
+    ...projectedApply.posture ? { posture: projectedApply.posture } : {},
+    ...projectedApply.blockers ? { blockers: projectedApply.blockers } : {},
+    ...projectedApply.blockerDetails ? { blockerDetails: projectedApply.blockerDetails } : {},
+    ...projectedApply.auditReference ? { auditReference: projectedApply.auditReference } : {},
+    ...projectedApply.commandReference ? { commandReference: projectedApply.commandReference } : {}
   };
 }
 function runPlanTableActionStep(runtime, mode, step, plan) {
@@ -6953,6 +7005,23 @@ function locateAll(runtime, input) {
       isEmpty: text.trim().length === 0
     });
   }
+  if (matches.length < limit && !input.kind) {
+    for (const scope of scopes) {
+      if (matches.length >= limit) break;
+      for (const action of editableTextActionsForScope(runtime, scope.handle)) {
+        if (matches.length >= limit) break;
+        if (!textMatches(action.readback.text, input.query, input.matchCase)) continue;
+        matches.push({
+          kind: action.targetKind,
+          text: action.readback.text,
+          excerpt: excerpt(action.readback.text),
+          actionHandle: action.actionHandle,
+          readback: action.readback,
+          isEmpty: action.readback.isEmpty
+        });
+      }
+    }
+  }
   if (matches.length < limit && shouldScanTableText) {
     const tableTextScopeLimit = Math.max(
       0,
@@ -6987,23 +7056,27 @@ function locateAll(runtime, input) {
 function resolveTarget(runtime, target) {
   if ("actionHandle" in target) {
     const action = findTableAction(runtime, target.actionHandle);
-    if (!action) {
-      return blockedResolution(
-        `actions:target:action-handle-not-found:${target.actionHandle}`,
-        "unresolved-target",
-        "No current table text action matches the supplied actionHandle.",
-        "Call ai.actions.locateAll or ai.listTableActions again and retry with a fresh actionHandle."
-      );
+    if (action) {
+      if (action.family !== "table-text") {
+        return blockedResolution(
+          `actions:target:action-handle-not-text:${target.actionHandle}`,
+          "unsupported",
+          "This actionHandle is not a table text action.",
+          "Use table structure handles with ai.applyTableAction, or use a table text actionHandle for rewrite."
+        );
+      }
+      return { ok: true, target: { kind: "table-text", action } };
     }
-    if (action.family !== "table-text") {
-      return blockedResolution(
-        `actions:target:action-handle-not-text:${target.actionHandle}`,
-        "unsupported",
-        "This actionHandle is not a table text action.",
-        "Use table structure handles with ai.applyTableAction, or use a table text actionHandle for rewrite."
-      );
+    const editableTextAction = findEditableTextAction(runtime, target.actionHandle);
+    if (editableTextAction) {
+      return { ok: true, target: editableTextAction };
     }
-    return { ok: true, target: { kind: "table-text", action } };
+    return blockedResolution(
+      `actions:target:action-handle-not-found:${target.actionHandle}`,
+      "unresolved-target",
+      "No current table text or editable text action matches the supplied actionHandle.",
+      "Call ai.actions.locateAll again and retry with a fresh actionHandle."
+    );
   }
   if ("handle" in target) {
     const compiled = createScopeCompilerService(runtime).compileScopeById(target.handle.scopeId);
@@ -7088,7 +7161,21 @@ function applyRewrite(runtime, target, input) {
       ...result2.afterReadback ? { afterReadback: result2.afterReadback } : {}
     };
   }
+  if (target.kind === "editable-text") {
+    return applyEditableTextRewrite(runtime, target, input);
+  }
+  const rewriteBlocker = scopeRewriteCapabilityBlocker(target.scope);
+  if (rewriteBlocker) {
+    return blockedApply(
+      rewriteBlocker.code,
+      rewriteBlocker.category,
+      rewriteBlocker.message,
+      rewriteBlocker.nextStep,
+      [rewriteBlocker]
+    );
+  }
   const beforeText = target.scope.content.text;
+  const documentHashBeforeApply = documentContentHash(runtime);
   const result = createReplacementFamily(runtime).applyReplacementScope({
     targetScopeId: target.handle.scopeId,
     operation: "replace",
@@ -7100,7 +7187,22 @@ function applyRewrite(runtime, target, input) {
     ...input.origin ? { origin: input.origin } : {},
     ...input.proposalId ? { proposalId: input.proposalId } : {}
   });
-  return projectRewriteScopeResult(runtime, result, target, beforeText, input.text);
+  const documentMutated = documentContentHash(runtime) !== documentHashBeforeApply;
+  if (!result.applied) {
+    return documentMutated ? withSuspectMutationApplyResult(
+      projectApplyResult(result, target),
+      target.handle.scopeId,
+      summarizeTarget(target)
+    ) : projectApplyResult(result, target);
+  }
+  return projectRewriteScopeResult(
+    runtime,
+    result,
+    target,
+    beforeText,
+    input.text,
+    documentMutated
+  );
 }
 function projectApplyResult(result, target) {
   return {
@@ -7121,7 +7223,79 @@ function projectApplyResult(result, target) {
     ...result.auditReference ? { auditReference: result.auditReference } : {}
   };
 }
-function projectRewriteScopeResult(runtime, result, target, beforeText, proposedText) {
+function applyEditableTextRewrite(runtime, target, input) {
+  const before = runtime.getCanonicalDocument();
+  runtime.dispatch({
+    type: "selection.set",
+    selection: target.selection,
+    origin: actionOrigin(runtime, input)
+  });
+  runtime.applyActiveStoryTextCommand({
+    type: "text.insert",
+    text: input.text,
+    editableTarget: target.editableTarget,
+    origin: actionOrigin(runtime, input)
+  });
+  const changed = runtime.getCanonicalDocument() !== before;
+  if (!changed) {
+    return blockedApply(
+      `actions:editable-text:runtime-noop:${target.actionHandle}`,
+      "blocked",
+      "The editable text command was accepted but produced no document change.",
+      "Refresh the action handle with ai.actions.locateAll and retry; route persistent failures to L07 text command support.",
+      [
+        blockerWithOwner(
+          `actions:editable-text:runtime-noop:${target.actionHandle}`,
+          "blocked",
+          "The editable text command was accepted but produced no document change.",
+          "Refresh the action handle with ai.actions.locateAll and retry; route persistent failures to L07 text command support.",
+          "L07 runtime text command support"
+        )
+      ]
+    );
+  }
+  const afterTarget = findEditableTextActionByTargetKey(
+    runtime,
+    target.editableTarget.targetKey
+  );
+  const afterReadback = afterTarget?.readback ?? editableTextTargetState(
+    runtime.getCanonicalDocument(),
+    target.editableTarget
+  )?.readback;
+  if (!afterReadback || afterReadback.text !== input.text) {
+    return {
+      status: "blocked",
+      applied: false,
+      changed: true,
+      target: summarizeTarget(afterTarget ?? target),
+      posture: "suspect-readback",
+      blockers: Object.freeze([`actions:editable-text:readback-mismatch:${target.actionHandle}`]),
+      blockerDetails: Object.freeze([
+        blocker(
+          `actions:editable-text:readback-mismatch:${target.actionHandle}`,
+          "blocked",
+          "The editable text command changed the document, but exact target readback did not match the proposed text.",
+          "Treat the mutation as suspect. Re-read the target and export before claiming success."
+        )
+      ]),
+      ...afterReadback ? { afterReadback } : {}
+    };
+  }
+  return {
+    status: "applied",
+    applied: true,
+    changed: true,
+    target: summarizeTarget(afterTarget ?? { ...target, readback: afterReadback }),
+    commandReference: {
+      command: "text.insert",
+      actorId: input.actorId ?? "v3-ai-api",
+      origin: input.origin ?? "agent",
+      emittedAtUtc: currentAuditTimestamp(runtime)
+    },
+    afterReadback
+  };
+}
+function projectRewriteScopeResult(runtime, result, target, beforeText, proposedText, documentMutated) {
   if (!result.applied) return projectApplyResult(result, target);
   const compiledAfter = createScopeCompilerService(runtime).compileScopeById(
     target.handle.scopeId
@@ -7132,7 +7306,8 @@ function projectRewriteScopeResult(runtime, result, target, beforeText, proposed
       target,
       `actions:rewrite:authoritative-readback-unresolvable:${target.handle.scopeId}`,
       "The replacement primitive reported success, but the target scope could not be re-read afterwards.",
-      "Treat the mutation as untrusted. Re-locate the target and retry only after the scope resolves, or create an issue flag instead."
+      "Treat the mutation as untrusted. Re-locate the target and retry only after the scope resolves, or create an issue flag instead.",
+      documentMutated
     );
   }
   const afterText = compiledAfter.scope.content.text;
@@ -7144,7 +7319,8 @@ function projectRewriteScopeResult(runtime, result, target, beforeText, proposed
       { ...target, scope: compiledAfter.scope, handle: compiledAfter.scope.handle },
       `actions:rewrite:authoritative-readback-unchanged:${target.handle.scopeId}`,
       "The replacement primitive reported success, but authoritative scope readback showed unchanged text.",
-      "Treat the mutation as not applied. Retry with a narrower scope or create an issue flag; do not claim the replacement succeeded."
+      "Treat the mutation as not applied. Retry with a narrower scope or create an issue flag; do not claim the replacement succeeded.",
+      documentMutated
     );
   }
   if (!expectedPresent) {
@@ -7153,7 +7329,8 @@ function projectRewriteScopeResult(runtime, result, target, beforeText, proposed
       { ...target, scope: compiledAfter.scope, handle: compiledAfter.scope.handle },
       `actions:rewrite:authoritative-readback-mismatch:${target.handle.scopeId}`,
       "The replacement primitive reported success, but authoritative scope readback did not contain the proposed text.",
-      "Treat the mutation as suspect. Re-read the target, inspect the exported package when available, and retry only with a verified target."
+      "Treat the mutation as suspect. Re-read the target, inspect the exported package when available, and retry only with a verified target.",
+      documentMutated
     );
   }
   return {
@@ -7170,17 +7347,27 @@ function projectRewriteScopeResult(runtime, result, target, beforeText, proposed
     ...result.auditReference ? { auditReference: result.auditReference } : {}
   };
 }
-function blockedRewriteReadback(result, target, code, message, nextStep) {
+function blockedRewriteReadback(result, target, code, message, nextStep, documentMutated = false) {
   const detail = blocker(code, "blocked", message, nextStep);
+  const details = documentMutated ? [
+    detail,
+    blockerWithOwner(
+      `actions:rewrite:suspect-mutation:${target.handle.scopeId}`,
+      "blocked",
+      "The document changed even though authoritative target readback failed.",
+      "Abort the plan, inspect the export/readback evidence, and route the target to L08/L07 scope edit-target mapping before retrying.",
+      "L08 semantic scopes and L07 runtime text commands"
+    )
+  ] : [detail];
   return {
     status: "blocked",
     applied: false,
-    changed: false,
+    changed: documentMutated,
     target: summarizeTarget(target),
     proposalId: result.proposalId,
-    posture: "suspect-readback",
-    blockers: Object.freeze([detail.code]),
-    blockerDetails: Object.freeze([detail]),
+    posture: documentMutated ? "suspect-mutation" : "suspect-readback",
+    blockers: Object.freeze(details.map((entry) => entry.code)),
+    blockerDetails: Object.freeze(details),
     ...result.auditReference ? { auditReference: result.auditReference } : {}
   };
 }
@@ -7196,11 +7383,23 @@ function summarizeTarget(target) {
       canMark: false
     };
   }
+  if (target.kind === "editable-text") {
+    return {
+      kind: target.targetKind,
+      handle: target.ownerHandle,
+      actionHandle: target.actionHandle,
+      readback: target.readback,
+      canRewriteText: true,
+      canInsertAdjacentText: false,
+      canFlag: false,
+      canMark: false
+    };
+  }
   return {
     kind: target.scope.kind,
     handle: target.handle,
     canRewriteText: canRewriteScopeText(target.scope),
-    canInsertAdjacentText: canRewriteScopeText(target.scope),
+    canInsertAdjacentText: canInsertAdjacentScopeText(target.scope),
     canFlag: true,
     canMark: canMarkScope(target.scope)
   };
@@ -7212,6 +7411,34 @@ function tableTextActionsForScope(runtime, handle) {
   });
   return result.actions.filter((action) => action.family === "table-text");
 }
+function editableTextActionsForScope(runtime, handle) {
+  const bundle = createScopeCompilerService(runtime).compileBundleById(
+    handle.scopeId,
+    currentAuditTimestamp(runtime)
+  );
+  const entries = bundle?.evidence.editableTargets?.entries ?? [];
+  const currentTargets = collectEditableTargetRefs(runtime.getCanonicalDocument());
+  const actions = [];
+  for (const entry of entries) {
+    if (entry.kind !== "hyperlink-text" || entry.commandFamily !== "text-leaf" || entry.runtimeCommand.status !== "supported" || !entry.runtimeCommand.actionHandle) {
+      continue;
+    }
+    const currentTarget = currentTargets.find((target) => target.targetKey === entry.targetKey);
+    if (!currentTarget || currentTarget.kind !== "hyperlink-text") continue;
+    const targetState = editableTextTargetState(runtime.getCanonicalDocument(), currentTarget);
+    if (!targetState) continue;
+    actions.push({
+      kind: "editable-text",
+      targetKind: "hyperlink-text",
+      actionHandle: entry.runtimeCommand.actionHandle,
+      editableTarget: currentTarget,
+      ownerHandle: handle,
+      readback: targetState.readback,
+      selection: targetState.selection
+    });
+  }
+  return Object.freeze(actions);
+}
 function findTableAction(runtime, actionHandle) {
   const action = findAnyTableAction(runtime, actionHandle);
   return action?.family === "table-text" ? action : null;
@@ -7231,6 +7458,27 @@ function findAnyTableAction(runtime, actionHandle) {
   }
   return null;
 }
+function findEditableTextAction(runtime, actionHandle) {
+  if (!actionHandle.startsWith("scope-command:text-leaf:")) return null;
+  const compiler = createScopeCompilerService(runtime);
+  for (const scope of compiler.compileAllScopes()) {
+    const action = editableTextActionsForScope(runtime, scope.handle).find(
+      (candidate) => candidate.actionHandle === actionHandle
+    );
+    if (action) return action;
+  }
+  return null;
+}
+function findEditableTextActionByTargetKey(runtime, targetKey) {
+  const compiler = createScopeCompilerService(runtime);
+  for (const scope of compiler.compileAllScopes()) {
+    const action = editableTextActionsForScope(runtime, scope.handle).find(
+      (candidate) => candidate.editableTarget.targetKey === targetKey
+    );
+    if (action) return action;
+  }
+  return null;
+}
 function readDocumentPlanTarget(runtime) {
   const document = createInspectFamily(runtime).inspectDocument();
   return {
@@ -7287,6 +7535,18 @@ function readPlanTarget(runtime, target) {
       ])
     };
   }
+  const editableText = findEditableTextAction(runtime, target.actionHandle);
+  if (editableText) {
+    return {
+      ok: true,
+      target: summarizeTarget(editableText),
+      readback: {
+        text: editableText.readback.text,
+        excerpt: excerpt(editableText.readback.text),
+        isEmpty: editableText.readback.isEmpty
+      }
+    };
+  }
   return readPlanTableAction(runtime, target.actionHandle);
 }
 function readPlanTableAction(runtime, actionHandle) {
@@ -7349,6 +7609,15 @@ function checkPlanStepCapability(runtime, step, before) {
       "Regenerate the plan with a ScopeHandle or opaque actionHandle returned by L09."
     );
   }
+  if (step.kind === "rewrite" && target.kind === "list-item") {
+    return blockerWithOwner(
+      "capability:list-item:authoritative-readback-required",
+      "blocked",
+      "List-item text replacement is not yet backed by an authoritative mutation/readback route.",
+      "Use listOperation for numbering changes, or create an issue/explanation until L08/L07 list-item text replacement is proven.",
+      "L08 semantic scopes and L07 runtime text commands"
+    );
+  }
   if (step.kind === "rewrite" && !target.canRewriteText) {
     return blocker(
       `actions:plan:target-not-rewriteable:${step.id}`,
@@ -7381,7 +7650,20 @@ function checkPlanStepCapability(runtime, step, before) {
       "Use a supported semantic scope or create an issue flag instead."
     );
   }
-  if (step.kind === "fieldRefresh" || step.kind === "tocRefresh" || step.kind === "bookmarkEdit" || step.kind === "hyperlinkDestinationEdit") {
+  if (step.kind === "fieldRefresh" || step.kind === "tocRefresh" || step.kind === "bookmarkEdit" || step.kind === "hyperlinkDestinationEdit" || step.kind === "hyperlinkTextEdit") {
+    if (step.kind === "hyperlinkTextEdit") {
+      const resolved2 = resolveTarget(runtime, step.target);
+      if (!resolved2.ok) return resolved2.blockerDetails[0] ?? null;
+      if (resolved2.target.kind !== "editable-text" || resolved2.target.targetKind !== "hyperlink-text") {
+        return blocker(
+          `actions:hyperlink-text-edit:hyperlink-text-handle-required:${step.id}`,
+          "unsupported",
+          "Hyperlink display text plan steps require an exact hyperlink-text actionHandle.",
+          "Regenerate the plan with a scope-command:text-leaf actionHandle returned by ai.actions.locateAll."
+        );
+      }
+      return null;
+    }
     const resolved = resolveScopeExactTarget(runtime, step.target, step.kind);
     if (!resolved.ok) return resolved.blockerDetails[0] ?? null;
     const targetRef = resolveModeledEditableTarget(runtime, resolved.target, step.kind);
@@ -7486,6 +7768,13 @@ function applyPlanStep(runtime, step, plan) {
         actorId: step.actorId ?? plan.actorId,
         origin: step.origin ?? plan.origin
       });
+    case "hyperlinkTextEdit":
+      return createActionsFamily(runtime).actions.hyperlinkTextEdit({
+        target: step.target,
+        text: step.text,
+        actorId: step.actorId ?? plan.actorId,
+        origin: step.origin ?? plan.origin
+      });
     case "listOperation":
       return createActionsFamily(runtime).actions.listOperation({
         target: step.target,
@@ -7802,11 +8091,159 @@ function isTableFamilyScope(kind) {
   return kind === "table" || kind === "table-row" || kind === "table-cell";
 }
 function canRewriteScopeText(scope) {
+  return !isTableFamilyScope(scope.kind) && scope.kind !== "list-item" && (scope.replaceability.level === "full" || scope.replaceability.level === "text-only");
+}
+function canInsertAdjacentScopeText(scope) {
   return !isTableFamilyScope(scope.kind) && (scope.replaceability.level === "full" || scope.replaceability.level === "text-only");
 }
+function scopeRewriteCapabilityBlocker(scope) {
+  if (scope.kind === "list-item") {
+    return blockerWithOwner(
+      "capability:list-item:authoritative-readback-required",
+      "blocked",
+      "List-item text replacement is not yet backed by an authoritative mutation/readback route.",
+      "Use listOperation for numbering changes, or create an issue/explanation until L08/L07 list-item text replacement is proven.",
+      "L08 semantic scopes and L07 runtime text commands"
+    );
+  }
+  if (!canRewriteScopeText(scope)) {
+    return blocker(
+      `actions:rewrite:target-not-rewriteable:${scope.handle.scopeId}`,
+      "unsupported",
+      "The target capability posture does not allow text rewrite.",
+      "Use a supported text target, table text actionHandle, or create an issue flag instead."
+    );
+  }
+  return null;
+}
 function canMarkScope(scope) {
   return !isTableFamilyScope(scope.kind) && scope.replaceability.level !== "blocked" && scope.replaceability.level !== "preserve-only";
 }
+function editableTextTargetState(document, target) {
+  if (target.kind !== "hyperlink-text") return void 0;
+  const resolved = resolveHyperlinkTarget(document, target);
+  if (!resolved) return void 0;
+  const text = collectInlineText2(resolved.hyperlink.children);
+  return {
+    readback: { text, isEmpty: text.length === 0 },
+    selection: {
+      anchor: resolved.from,
+      head: resolved.to,
+      isCollapsed: resolved.from === resolved.to,
+      activeRange: {
+        kind: "range",
+        from: resolved.from,
+        to: resolved.to,
+        assoc: { start: -1, end: 1 }
+      }
+    }
+  };
+}
+function resolveHyperlinkTarget(document, target) {
+  const parsed = parseBlockInlinePath(target.blockPath);
+  if (!parsed) return null;
+  let blocks = document.content.children;
+  let block;
+  let row;
+  let offset = 0;
+  for (const token of parsed) {
+    switch (token.kind) {
+      case "block":
+        for (let index = 0; index < token.index; index += 1) {
+          offset += blockTextLength(blocks[index]);
+        }
+        block = blocks[token.index];
+        row = void 0;
+        if (!block) return null;
+        break;
+      case "row":
+        if (block?.type !== "table") return null;
+        row = block.rows[token.index];
+        block = void 0;
+        if (!row) return null;
+        break;
+      case "cell": {
+        const cell = row?.cells[token.index];
+        if (!cell) return null;
+        blocks = cell.children;
+        block = void 0;
+        row = void 0;
+        break;
+      }
+      case "inline": {
+        if (block?.type !== "paragraph") return null;
+        for (let index = 0; index < token.index; index += 1) {
+          offset += inlineTextLength(block.children[index]);
+        }
+        const inline = block.children[token.index];
+        if (inline?.type !== "hyperlink") return null;
+        const length = collectInlineText2(inline.children).length;
+        return { hyperlink: inline, from: offset, to: offset + length };
+      }
+    }
+  }
+  return null;
+}
+function parseBlockInlinePath(path) {
+  if (!path.startsWith("main/")) return null;
+  const tokens = [];
+  const re = /(block|row|cell|inline)\[(\d+)\]/gu;
+  let match;
+  while ((match = re.exec(path)) !== null) {
+    const kind = match[1];
+    tokens.push({ kind, index: Number(match[2]) });
+  }
+  return tokens.length > 0 ? Object.freeze(tokens) : null;
+}
+function collectInlineText2(inlines) {
+  let text = "";
+  for (const inline of inlines) {
+    switch (inline.type) {
+      case "text":
+        text += inline.text;
+        break;
+      case "hyperlink":
+      case "field":
+        text += collectInlineText2(inline.children);
+        break;
+      default:
+        break;
+    }
+  }
+  return text;
+}
+function blockTextLength(block) {
+  if (!block) return 0;
+  switch (block.type) {
+    case "paragraph":
+      return collectInlineText2(block.children).length;
+    case "table":
+      return block.rows.reduce(
+        (rowSum, row) => rowSum + row.cells.reduce(
+          (cellSum, cell) => cellSum + cell.children.reduce((blockSum, child) => blockSum + blockTextLength(child), 0),
+          0
+        ),
+        0
+      );
+    case "sdt":
+    case "custom_xml":
+      return block.children.reduce((sum, child) => sum + blockTextLength(child), 0);
+    default:
+      return 0;
+  }
+}
+function inlineTextLength(inline) {
+  if (!inline) return 0;
+  switch (inline.type) {
+    case "text":
+      return inline.text.length;
+    case "hyperlink":
+    case "field":
+      return collectInlineText2(inline.children).length;
+    default:
+      return 0;
+  }
+}
 function textMatches(text, query, matchCase) {
   if (matchCase) return text.includes(query);
   return text.toLocaleLowerCase().includes(query.toLocaleLowerCase());
@@ -7865,6 +8302,30 @@ function blockedApplyFromResolution(resolution) {
     blockerDetails: resolution.blockerDetails
   };
 }
+function withSuspectMutationApplyResult(result, stepOrScopeId, target) {
+  const detail = blockerWithOwner(
+    `actions:plan:suspect-mutation:${stepOrScopeId}`,
+    "blocked",
+    "The document changed even though the action did not return an applied result.",
+    "Abort the remaining plan, inspect authoritative readback/export evidence, and route the target to the owning edit-target/readback layer before retrying.",
+    "L08 semantic scopes and L07 runtime text commands"
+  );
+  return {
+    ...result,
+    status: "blocked",
+    applied: false,
+    changed: true,
+    ...target ? { target } : {},
+    posture: "suspect-mutation",
+    blockers: Object.freeze([...result.blockers ?? [], detail.code]),
+    blockerDetails: Object.freeze([...result.blockerDetails ?? [], detail])
+  };
+}
+function isSuspectMutationStep(step) {
+  return step.posture === "suspect-mutation" || (step.blockers ?? []).some(
+    (code) => code.startsWith("actions:plan:suspect-mutation:") || code.startsWith("actions:rewrite:suspect-mutation:")
+  );
+}
 function blockedPlan(mode, code, category, message, nextStep) {
   const detail = blocker(code, category, message, nextStep);
   return {