@beyondwork/docx-react-component 1.0.133 → 1.0.134

package/dist/api/v3.cjs

@@ -33897,16 +33897,12 @@ function replaceTextCapability(scope, context) {
     );
   }
   if (scope.kind === "scope") {
-    if (scope.workflow.effectiveMode === "suggest") {
-      return unsupported(
-        "compile-refused:scope:multi-paragraph-suggesting-not-implemented",
-        ["compile-refused:scope:multi-paragraph-suggesting-not-implemented"],
-        ["guard:suggest-mode", ...evidenceWarnings(context)]
-      );
-    }
     return supported(
       "compile-supported:scope:multi-paragraph-text-replace",
-      evidenceWarnings(context)
+      [
+        ...scope.workflow.effectiveMode === "suggest" ? ["guard:suggest-mode"] : [],
+        ...evidenceWarnings(context)
+      ]
     );
   }
   if (!PARAGRAPH_LIKE.has(scope.kind)) {
@@ -33960,34 +33956,24 @@ function replaceFragmentCapability(scope, context) {
     );
   }
   if (scope.kind === "scope") {
-    if (scope.workflow.effectiveMode === "suggest") {
-      return unsupported(
-        "compile-refused:scope:multi-paragraph-structured-suggesting-not-implemented",
-        [
-          "compile-refused:scope:multi-paragraph-structured-suggesting-not-implemented"
-        ],
-        ["guard:suggest-mode", ...evidenceWarnings(context)]
-      );
-    }
     return supported(
       "compile-supported:scope:multi-paragraph-fragment-replace",
-      evidenceWarnings(context)
+      [
+        ...scope.workflow.effectiveMode === "suggest" ? ["guard:suggest-mode"] : [],
+        ...evidenceWarnings(context)
+      ]
     );
   }
   if (!PARAGRAPH_LIKE.has(scope.kind)) {
     const reason = `compile-refused:${scope.kind}`;
     return unsupported(reason, [reason], evidenceWarnings(context));
   }
-  if (scope.workflow.effectiveMode === "suggest") {
-    return unsupported(
-      `compile-refused:${scope.kind}:structured-suggesting-not-implemented`,
-      [`compile-refused:${scope.kind}:structured-suggesting-not-implemented`],
-      ["guard:suggest-mode"]
-    );
-  }
   return supported(
-    "compile-supported:paragraph-like:fragment-replace",
-    evidenceWarnings(context)
+    scope.workflow.effectiveMode === "suggest" ? "compile-supported:paragraph-like:fragment-replace-tracked" : "compile-supported:paragraph-like:fragment-replace",
+    [
+      ...scope.workflow.effectiveMode === "suggest" ? ["guard:suggest-mode"] : [],
+      ...evidenceWarnings(context)
+    ]
   );
 }
 function formattingCapability(scope, context) {
@@ -35262,6 +35248,14 @@ function supportedNonTextCommandEvidence(target) {
   if (target.commandFamily === "link-bookmark") {
     return linkBookmarkCommandEvidence(target, []);
   }
+  if (target.commandFamily === "object" && isImageObjectTarget(target) && typeof target.object?.mediaId === "string" && target.object.mediaId.length > 0 && onlyBlockers(target.posture.blockers, ["unmodeled-target"])) {
+    return {
+      status: "supported",
+      commandFamily: target.commandFamily,
+      intents: commandIntentsForTarget(target),
+      reason: "l07:image-layout-target-supported"
+    };
+  }
   return null;
 }
 function onlyBlockers(blockers, allowed) {
@@ -40380,11 +40374,9 @@ function compileParagraphReplacement(entry, proposed, options) {
     };
   }
   if (proposed.proposedContent.kind === "structured") {
-    if (options.posture === "suggest-mode") {
-      return null;
-    }
     const fragment = proposed.proposedContent.structured;
     if (!isStructuredReplacementContent(fragment)) return null;
+    const stepKind = options.posture === "suggest-mode" ? "fragment-replace-tracked" : "fragment-replace";
     const blockCount = fragment.blocks.length;
     const summaryScope = rangeKind === "inline-marker" ? `paragraph #${entry.blockIndex} inline-marker range [${effectiveRange.from}..${effectiveRange.to}]` : rangeKind === "opaque-preserving-text" ? `paragraph #${entry.blockIndex} opaque-preserving text range [${effectiveRange.from}..${effectiveRange.to}]` : `paragraph #${entry.blockIndex}`;
     const actionVerb = proposed.operation === "insert-before" ? "insert before" : proposed.operation === "insert-after" ? "insert after" : "replace";
@@ -40395,8 +40387,8 @@ function compileParagraphReplacement(entry, proposed, options) {
       operation: proposed.operation,
       steps: Object.freeze([
         {
-          kind: "fragment-replace",
-          summary: actionSummary,
+          kind: stepKind,
+          summary: stepKind === "fragment-replace" ? actionSummary : `suggest-mode ${actionSummary}`,
           ...textLeafEditableTargetHint(entry, blockRange) ? { editableTargetHint: textLeafEditableTargetHint(entry, blockRange) } : {},
           range: { from: operationRange.from, to: operationRange.to },
           fragment
@@ -40483,7 +40475,7 @@ function compileScopeKind(entry, options) {
   };
 }
 function compileScopeReplacement(entry, proposed, options) {
-  if (entry.handle.provenance !== "marker-backed" || proposed.operation !== "replace" || options.posture !== "direct-edit") {
+  if (entry.handle.provenance !== "marker-backed" || proposed.operation !== "replace") {
     return null;
   }
   const markerRange = buildScopePositionMap(options.document).markerScopes.get(
@@ -40492,14 +40484,15 @@ function compileScopeReplacement(entry, proposed, options) {
   if (!markerRange) return null;
   if (proposed.proposedContent.kind === "text") {
     const text = proposed.proposedContent.text ?? "";
+    const stepKind = options.posture === "suggest-mode" ? "text-insert-tracked" : "text-replace";
     return {
       scopeId: entry.handle.scopeId,
       targetKind: "scope",
       operation: proposed.operation,
       steps: Object.freeze([
         {
-          kind: "text-replace",
-          summary: `replace multi-paragraph scope ${entry.handle.scopeId} text [${markerRange.from}..${markerRange.to}] (len ${text.length})`,
+          kind: stepKind,
+          summary: stepKind === "text-replace" ? `replace multi-paragraph scope ${entry.handle.scopeId} text [${markerRange.from}..${markerRange.to}] (len ${text.length})` : `suggest-mode replace multi-paragraph scope ${entry.handle.scopeId} text [${markerRange.from}..${markerRange.to}] (len ${text.length})`,
           range: { from: markerRange.from, to: markerRange.to },
           text,
           ...proposed.formatting ? { formatting: proposed.formatting } : {}
@@ -40512,14 +40505,15 @@ function compileScopeReplacement(entry, proposed, options) {
   if (proposed.proposedContent.kind === "structured") {
     const fragment = proposed.proposedContent.structured;
     if (!isStructuredReplacementContent(fragment)) return null;
+    const stepKind = options.posture === "suggest-mode" ? "fragment-replace-tracked" : "fragment-replace";
     return {
       scopeId: entry.handle.scopeId,
       targetKind: "scope",
       operation: proposed.operation,
       steps: Object.freeze([
         {
-          kind: "fragment-replace",
-          summary: `replace multi-paragraph scope ${entry.handle.scopeId} with structured fragment [${markerRange.from}..${markerRange.to}] (${fragment.blocks.length} block(s))`,
+          kind: stepKind,
+          summary: stepKind === "fragment-replace" ? `replace multi-paragraph scope ${entry.handle.scopeId} with structured fragment [${markerRange.from}..${markerRange.to}] (${fragment.blocks.length} block(s))` : `suggest-mode replace multi-paragraph scope ${entry.handle.scopeId} with structured fragment [${markerRange.from}..${markerRange.to}] (${fragment.blocks.length} block(s))`,
           range: { from: markerRange.from, to: markerRange.to },
           fragment
         }
@@ -40901,6 +40895,99 @@ function paragraphFirstMarkerStart(paragraph, knownScopeIds) {
   }
   return null;
 }
+function paragraphHasMarkerEnd(paragraph, scopeId) {
+  return paragraph.children.some(
+    (child) => child.type === "scope_marker_end" && child.scopeId === scopeId
+  );
+}
+function paragraphSameParagraphMarkerScopeId(paragraph, knownScopeIds) {
+  const markerScopeId = paragraphFirstMarkerStart(paragraph, knownScopeIds);
+  if (!markerScopeId) return null;
+  return paragraphHasMarkerEnd(paragraph, markerScopeId) ? markerScopeId : null;
+}
+function markerStableRefOverride(markerScopeId, semanticPath, overlay) {
+  const hint = stableRefHintForScopeId(markerScopeId, overlay);
+  if (hint === "semantic-path") {
+    return {
+      kind: "semantic-path",
+      value: semanticPath.join("/")
+    };
+  }
+  return { kind: "scope-id", value: markerScopeId };
+}
+function enumerateNestedMarkerBackedParagraphs(blocks, input) {
+  const out = [];
+  for (let childIndex = 0; childIndex < blocks.length; childIndex += 1) {
+    const block = blocks[childIndex];
+    if (!block) continue;
+    if (block.type === "paragraph") {
+      const markerScopeId = paragraphSameParagraphMarkerScopeId(
+        block,
+        input.knownOverlayScopeIds
+      );
+      if (!markerScopeId) continue;
+      const kind = detectParagraphKind(block);
+      const semanticPath = [
+        ...input.semanticPrefix,
+        kind,
+        String(childIndex)
+      ];
+      const handle = buildHandle(
+        markerScopeId,
+        input.documentId,
+        semanticPath,
+        "marker-backed",
+        "marker-backed",
+        input.parentScopeId,
+        markerStableRefOverride(markerScopeId, semanticPath, input.overlay)
+      );
+      out.push({
+        kind,
+        handle,
+        paragraph: block,
+        blockIndex: input.rootBlockIndex,
+        classifications: input.classificationIndex.get(markerScopeId) ?? Object.freeze([])
+      });
+      continue;
+    }
+    if (block.type === "sdt") {
+      out.push(
+        ...enumerateNestedMarkerBackedParagraphs(block.children, {
+          ...input,
+          semanticPrefix: [
+            ...input.semanticPrefix,
+            "sdt",
+            String(childIndex)
+          ]
+        })
+      );
+      continue;
+    }
+    if (block.type === "table") {
+      for (let rowIdx = 0; rowIdx < block.rows.length; rowIdx += 1) {
+        const row = block.rows[rowIdx];
+        for (let cellIdx = 0; cellIdx < row.cells.length; cellIdx += 1) {
+          const cell = row.cells[cellIdx];
+          out.push(
+            ...enumerateNestedMarkerBackedParagraphs(cell.children, {
+              ...input,
+              semanticPrefix: [
+                ...input.semanticPrefix,
+                "table",
+                String(childIndex),
+                "row",
+                String(rowIdx),
+                "cell",
+                String(cellIdx)
+              ]
+            })
+          );
+        }
+      }
+    }
+  }
+  return out;
+}
 function enumerateFieldsInParagraph(paragraph, blockIndex, documentId, parentScopeId) {
   const out = [];
   for (let i = 0; i < paragraph.children.length; i += 1) {
@@ -41183,6 +41270,17 @@ function enumerateScopes(document2, inputs = {}) {
             cellIndex: cellIdx,
             classifications: Object.freeze([])
           });
+          for (const nested of enumerateNestedMarkerBackedParagraphs(cell.children, {
+            documentId,
+            rootBlockIndex: index,
+            semanticPrefix: cellSemanticPath,
+            parentScopeId: cellScopeId,
+            knownOverlayScopeIds,
+            classificationIndex,
+            overlay: inputs.overlay
+          })) {
+            results.push(nested);
+          }
         }
       }
     }
@@ -43381,9 +43479,7 @@ function applyScopeReplacement(inputs) {
   });
   if (!plan) {
     const paragraphLike = resolvedScope.kind === "paragraph" || resolvedScope.kind === "heading" || resolvedScope.kind === "list-item";
-    const blockers = resolvedScope.kind === "scope" && posture === "suggest-mode" ? [
-      proposed.proposedContent.kind === "structured" ? "compile-refused:scope:multi-paragraph-structured-suggesting-not-implemented" : "compile-refused:scope:multi-paragraph-suggesting-not-implemented"
-    ] : resolvedScope.kind === "scope" && proposed.operation !== "replace" ? [
+    const blockers = resolvedScope.kind === "scope" && proposed.operation !== "replace" ? [
       `compile-refused:scope:operation-not-implemented:${proposed.operation}`
     ] : resolvedScope.kind === "scope" ? multiParagraphReplacementBlockers(
       proposed.proposedContent.kind === "structured" ? "fragment" : "text"
@@ -45044,6 +45140,7 @@ var PICTURE_EFFECT_SCHEME_ALIASES = {
   bg2: "lt2"
 };
 var EMPTY_EDITABLE_TARGETS_BY_BLOCK_PATH = /* @__PURE__ */ new Map();
+var NO_EDITABLE_TARGETS_INDEX = EMPTY_EDITABLE_TARGETS_BY_BLOCK_PATH;
 function indexEditableTargetsByBlockPath(document2) {
   const targets = collectEditableTargetRefs(document2);
   if (targets.length === 0) return EMPTY_EDITABLE_TARGETS_BY_BLOCK_PATH;
@@ -50037,7 +50134,8 @@ function buildResolvedSections(document2) {
   const mainSurface = createEditorSurfaceSnapshot(
     document2,
     createSelectionSnapshot(0, 0),
-    MAIN_STORY_TARGET
+    MAIN_STORY_TARGET,
+    { editableTargetsByBlockPath: NO_EDITABLE_TARGETS_INDEX }
   );
   const sections = [];
   let sectionStart = 0;
@@ -60856,6 +60954,216 @@ function createOutlineFamily(runtime) {
   };
 }
 
+// src/api/v3/ai/object.ts
+var applyObjectActionMetadata = {
+  name: "ai.applyObjectAction",
+  status: "live-with-adapter",
+  sourceLayer: "runtime-core",
+  liveEvidence: {
+    runnerTest: "test/api/v3/ai/ai-object-actions.test.ts",
+    commit: "refactor-09-object-actions"
+  },
+  uxIntent: {
+    uiVisible: true,
+    expectsUxResponse: "inline-change",
+    expectedDelta: "image object layout changes"
+  },
+  agentMetadata: {
+    readOrMutate: "mutate",
+    boundedScope: "scope",
+    auditCategory: "object-action-apply",
+    contextPromptShape: "Apply an image object layout operation to an opaque actionHandle from ai.listObjectActions; preserve-only objects return typed blockers."
+  },
+  stateClass: "A-canonical",
+  persistsTo: "canonical",
+  broadcastsVia: "crdt",
+  rwdReference: "\xA7AI API \xA7 ai.applyObjectAction"
+};
+function createObjectActionFamily(runtime) {
+  const compiler = createScopeCompilerService(runtime);
+  return {
+    listObjectActions(input) {
+      const bundle = compiler.compileBundleById(input.handle.scopeId, input.nowUtc);
+      if (!bundle) {
+        return {
+          scopeId: input.handle.scopeId,
+          actions: [],
+          blockers: [`scope-not-resolvable:${input.handle.scopeId}`]
+        };
+      }
+      const seed = documentSeed2(runtime);
+      return {
+        scopeId: input.handle.scopeId,
+        actions: bundle.evidence.editableTargets?.entries.filter(isSupportedImageObjectEvidence).map((entry) => projectObjectDescriptor(runtime, seed, entry)) ?? []
+      };
+    },
+    applyObjectAction(input) {
+      emitUxResponse(runtime, {
+        apiFn: applyObjectActionMetadata.name,
+        intent: "object-action-apply",
+        mockOrLive: applyObjectActionMetadata.status,
+        uiVisible: true,
+        expectedDelta: applyObjectActionMetadata.uxIntent.expectedDelta
+      });
+      const nowUtc = currentAuditTimestamp(runtime);
+      const proposalId = input.proposalId ?? mockId(documentSeed2(runtime), `object-action-${input.actionHandle || "missing-handle"}-${input.operation.kind}`);
+      if (!input.actionHandle) {
+        return blockedResult2(input, proposalId, {
+          code: "object-action-handle-required",
+          category: "unresolved-target",
+          message: "Object actions require an actionHandle from ai.listObjectActions.",
+          nextStep: "Call ai.listObjectActions for the owning scope and retry with one returned actionHandle.",
+          operation: input.operation.kind
+        });
+      }
+      const target = resolveObjectActionHandle(runtime, documentSeed2(runtime), input.actionHandle);
+      if (!target) {
+        return blockedResult2(input, proposalId, {
+          code: `object-action-handle-not-found:${input.actionHandle}`,
+          category: "unresolved-target",
+          message: "No current object action matches the supplied opaque action handle.",
+          nextStep: "Refresh the scope bundle or call ai.listObjectActions before retrying.",
+          actionHandle: input.actionHandle,
+          operation: input.operation.kind
+        });
+      }
+      if (!isSupportedImageTarget(target)) {
+        return blockedResult2(input, proposalId, {
+          code: "object-action-image-target-required",
+          category: "blocked-target",
+          message: "The supplied object action handle no longer identifies a mutable image target.",
+          nextStep: "Refresh object actions; chart, OLE, custom XML, opaque, and stale object targets remain refused.",
+          actionHandle: input.actionHandle,
+          operation: input.operation.kind
+        });
+      }
+      const mediaId = target.object?.mediaId;
+      if (!mediaId) {
+        return blockedResult2(input, proposalId, {
+          code: "object-action-media-id-required",
+          category: "blocked-target",
+          message: "Image object layout mutation requires a mediaId-backed target.",
+          nextStep: "Retry only with an image action handle whose readback includes mediaId.",
+          actionHandle: input.actionHandle,
+          operation: input.operation.kind
+        });
+      }
+      const before = runtime.getCanonicalDocument();
+      runtime.dispatch({
+        type: "image.set-layout",
+        mediaId,
+        dimensions: {
+          widthEmu: input.operation.dimensions.widthEmu,
+          heightEmu: input.operation.dimensions.heightEmu
+        },
+        origin: { source: "api", timestamp: nowUtc }
+      });
+      const changed = runtime.getCanonicalDocument() !== before;
+      if (!changed) {
+        return blockedResult2(input, proposalId, {
+          code: `object-action-noop:${input.operation.kind}:${input.actionHandle}`,
+          category: "runtime-noop",
+          message: "The runtime accepted the image target but the object operation produced no document change.",
+          nextStep: "Refresh object actions and verify the image media item still exists before retrying.",
+          actionHandle: input.actionHandle,
+          operation: input.operation.kind
+        });
+      }
+      return {
+        proposalId,
+        applied: true,
+        changed: true,
+        actionHandle: input.actionHandle,
+        operation: input.operation.kind,
+        commandReference: {
+          command: "image.set-layout",
+          actorId: input.actorId ?? "v3-ai-api",
+          origin: input.origin ?? "agent",
+          emittedAtUtc: nowUtc
+        },
+        readback: objectReadback(runtime, target),
+        posture: "supported",
+        support: objectActionSupport()
+      };
+    }
+  };
+}
+function isSupportedImageObjectEvidence(entry) {
+  return entry.kind === "object-anchor" && entry.commandFamily === "object" && entry.runtimeCommand.status === "supported" && entry.runtimeCommand.intents.includes("image-layout") && isImageKind(entry.object?.objectKind) && typeof entry.object?.mediaId === "string";
+}
+function projectObjectDescriptor(runtime, seed, entry) {
+  return {
+    actionHandle: objectActionHandle(seed, entry.targetKey),
+    objectKind: entry.object?.objectKind ?? "unknown",
+    targetKind: entry.kind,
+    relation: entry.relation,
+    callableOperations: ["set-image-layout"],
+    supportedOperations: ["set-image-layout"],
+    readback: objectReadback(runtime, entry),
+    reason: entry.runtimeCommand.reason
+  };
+}
+function resolveObjectActionHandle(runtime, seed, actionHandle) {
+  return collectEditableTargetRefs(runtime.getCanonicalDocument()).find(
+    (target) => objectActionHandle(seed, target.targetKey) === actionHandle && isSupportedImageTarget(target)
+  ) ?? null;
+}
+function isSupportedImageTarget(target) {
+  return target.kind === "object-anchor" && target.commandFamily === "object" && isImageKind(target.object?.objectKind) && typeof target.object?.mediaId === "string" && target.object.mediaId.length > 0 && onlyObjectActionBlockers(target.posture.blockers, ["unmodeled-target"]);
+}
+function isImageKind(kind) {
+  return kind === "legacy-image" || kind === "picture";
+}
+function onlyObjectActionBlockers(blockers, allowed) {
+  const allowedSet = new Set(allowed);
+  return blockers.every((blocker2) => allowedSet.has(blocker2));
+}
+function objectReadback(runtime, target) {
+  const mediaId = target.object?.mediaId;
+  if (!mediaId) return {};
+  const media = runtime.getCanonicalDocument().media.items[mediaId];
+  return {
+    mediaId,
+    ...media?.widthEmu !== void 0 ? { widthEmu: media.widthEmu } : {},
+    ...media?.heightEmu !== void 0 ? { heightEmu: media.heightEmu } : {}
+  };
+}
+function blockedResult2(input, proposalId, detail) {
+  return {
+    proposalId,
+    applied: false,
+    changed: false,
+    actionHandle: input.actionHandle,
+    operation: input.operation.kind,
+    reason: detail.code,
+    blockers: [detail.code],
+    blockerDetails: [detail]
+  };
+}
+function objectActionSupport() {
+  return {
+    undo: "supported",
+    replay: "supported",
+    exportReopen: "supported",
+    audit: "command-reference"
+  };
+}
+function objectActionHandle(seed, targetKey) {
+  return `object-action:${hashOpaque2(`${seed}::${targetKey}`)}`;
+}
+function documentSeed2(runtime) {
+  const state = runtime.getSessionState();
+  return state.documentId ?? "document";
+}
+function hashOpaque2(input) {
+  let h = 2166136261;
+  for (let i = 0; i < input.length; i += 1) {
+    h ^= input.charCodeAt(i);
+    h = Math.imul(h, 16777619);
+  }
+  return (h >>> 0).toString(36).padStart(7, "0");
+}
+
 // src/api/v3/ai/actions.ts
 function actionMethodMetadata(method, readOrMutate, auditCategory, contextPromptShape, uxIntent) {
   return {
@@ -60900,6 +61208,17 @@ var locateAllMetadata = actionMethodMetadata(
   "Find scope/table-text targets by query; table text matches include readback {text,isEmpty}.",
   { uiVisible: false, expectsUxResponse: "none" }
 );
+var createPlaceholderScopesMetadata = actionMethodMetadata(
+  "createPlaceholderScopes",
+  "mutate",
+  "actions-placeholder-scopes",
+  "Create marker-backed workflow scopes for bracketed placeholder matches in paragraphs, tables, and lists using one bounded regex search.",
+  {
+    uiVisible: true,
+    expectsUxResponse: "scope-created",
+    expectedDelta: "placeholder text ranges become workflow scopes"
+  }
+);
 var rewriteMetadata = actionMethodMetadata(
   "rewrite",
   "mutate",
@@ -61112,6 +61431,7 @@ var ACTION_METHODS = Object.freeze([
   "discover",
   "locate",
   "locateAll",
+  "createPlaceholderScopes",
   "rewrite",
   "rewriteAll",
   "insertText",
@@ -61137,6 +61457,8 @@ var DEFAULT_LOCATE_LIMIT = 20;
 var DEFAULT_REWRITE_ALL_LIMIT = 10;
 var DEFAULT_TABLE_TEXT_SCOPE_LIMIT = 3;
 var DEFAULT_PLAN_STEP_LIMIT = 20;
+var DEFAULT_PLACEHOLDER_QUERY = "\\[[^\\[\\]]{1,200}\\]";
+var DEFAULT_PLACEHOLDER_LIMIT = 200;
 function createActionsFamily(runtime) {
   const category = {
     discover(input) {
@@ -61191,6 +61513,9 @@ function createActionsFamily(runtime) {
     locateAll(input) {
       return locateAll(runtime, input);
     },
+    createPlaceholderScopes(input) {
+      return createPlaceholderScopes(runtime, input ?? {});
+    },
     rewrite(input) {
       if (input.text === void 0) {
         return blockedApply(
@@ -61959,6 +62284,169 @@ function locateAll(runtime, input) {
     ...matches.length === 0 ? { blockers: Object.freeze([`actions:locate:not-found:${input.query}`]) } : {}
   };
 }
+function createPlaceholderScopes(runtime, input) {
+  const query = input.query ?? DEFAULT_PLACEHOLDER_QUERY;
+  if (!query) {
+    const detail = blocker(
+      "actions:placeholder-scopes:query-required",
+      "input",
+      "Placeholder scope creation requires a non-empty query.",
+      "Retry with a non-empty query string or omit query to use the bracketed-placeholder default."
+    );
+    return {
+      status: "blocked",
+      totalHits: 0,
+      created: 0,
+      blocked: 0,
+      scopes: Object.freeze([]),
+      blockers: Object.freeze([detail.code]),
+      blockerDetails: Object.freeze([detail])
+    };
+  }
+  const limit = Math.max(0, input.limit ?? DEFAULT_PLACEHOLDER_LIMIT);
+  let hits;
+  try {
+    hits = runtime.findAllText(query, {
+      regex: input.regex ?? true,
+      matchCase: input.matchCase ?? true,
+      limit
+    });
+  } catch {
+    const detail = blocker(
+      "actions:placeholder-scopes:invalid-query",
+      "input",
+      "The placeholder query could not be compiled or searched.",
+      "Retry with a valid literal query or JavaScript regex pattern."
+    );
+    return {
+      status: "blocked",
+      totalHits: 0,
+      created: 0,
+      blocked: 0,
+      scopes: Object.freeze([]),
+      blockers: Object.freeze([detail.code]),
+      blockerDetails: Object.freeze([detail])
+    };
+  }
+  if (hits.length === 0) {
+    return {
+      status: "not-found",
+      totalHits: 0,
+      created: 0,
+      blocked: 0,
+      scopes: Object.freeze([]),
+      blockers: Object.freeze([`actions:placeholder-scopes:not-found:${query}`])
+    };
+  }
+  const surface = runtime.getRenderSnapshot().surface;
+  const orderedHits = hits.filter((hit) => hit.kind === "range").map((hit, originalIndex) => ({
+    hit,
+    originalIndex,
+    text: surface ? textForSurfaceRange(surface.blocks, hit.from, hit.to) : ""
+  })).sort((a, b) => b.hit.from - a.hit.from || b.originalIndex - a.originalIndex);
+  if (orderedHits.length === 0) {
+    const detail = blocker(
+      "actions:placeholder-scopes:no-range-hits",
+      "unsupported",
+      "The placeholder query matched only projections that cannot be converted into workflow ranges.",
+      "Retry with a text query that resolves to concrete document text ranges."
+    );
+    return {
+      status: "blocked",
+      totalHits: hits.length,
+      created: 0,
+      blocked: hits.length,
+      scopes: Object.freeze([]),
+      blockers: Object.freeze([detail.code]),
+      blockerDetails: Object.freeze([detail])
+    };
+  }
+  const compiler = createScopeCompilerService(runtime);
+  const byOriginalIndex = /* @__PURE__ */ new Map();
+  for (const item of orderedHits) {
+    const text = item.text || query;
+    const label = input.labelPrefix === void 0 ? text : `${input.labelPrefix} ${item.originalIndex + 1}`;
+    const result = createScopeFromAnchor(runtime, {
+      anchor: { from: item.hit.from, to: item.hit.to },
+      mode: input.mode ?? "edit",
+      label,
+      ...input.visibility ? { visibility: input.visibility } : {},
+      ...input.guardPolicy ? { guardPolicy: input.guardPolicy } : {},
+      ...input.assoc ? { assoc: input.assoc } : {},
+      ...input.stableRefHint ? { stableRefHint: input.stableRefHint } : {}
+    });
+    if (result.status === "created") {
+      const compiled = compiler.compileScopeById(result.scopeId)?.scope;
+      byOriginalIndex.set(item.originalIndex, {
+        status: "created",
+        text,
+        excerpt: excerpt(text),
+        scopeId: result.scopeId,
+        ...compiled?.handle ? { handle: compiled.handle } : {}
+      });
+      continue;
+    }
+    const detail = blockerWithOwner(
+      `actions:placeholder-scopes:create-refused:${result.reason}`,
+      "blocked",
+      "The placeholder match could not be converted into a workflow scope.",
+      "Refresh the document and retry; if it still refuses, route the target to the workflow/scope writer owner.",
+      "L06"
+    );
+    byOriginalIndex.set(item.originalIndex, {
+      status: "blocked",
+      text,
+      excerpt: excerpt(text),
+      blockers: Object.freeze([detail.code]),
+      blockerDetails: Object.freeze([detail])
+    });
+  }
+  const scopes = orderedHits.map((item) => byOriginalIndex.get(item.originalIndex)).filter((value) => value !== void 0);
+  const created = scopes.filter((scope) => scope.status === "created").length;
+  const blocked2 = scopes.length - created;
+  const blockerDetails = scopes.flatMap((scope) => scope.blockerDetails ?? []);
+  return {
+    status: created === scopes.length ? "created" : created > 0 ? "partial" : "blocked",
+    totalHits: hits.length,
+    created,
+    blocked: blocked2,
+    scopes: Object.freeze(scopes),
+    ...blockerDetails.length > 0 ? {
+      blockers: Object.freeze(blockerDetails.map((detail) => detail.code)),
+      blockerDetails: Object.freeze(blockerDetails)
+    } : {}
+  };
+}
+function textForSurfaceRange(blocks, from, to) {
+  let acc = "";
+  const visit = (items) => {
+    for (const block of items) {
+      if (block.kind === "paragraph") {
+        for (const segment of block.segments) {
+          if (segment.kind !== "text") continue;
+          if (segment.from >= to) return;
+          if (segment.to <= from) continue;
+          acc += segment.text.slice(
+            Math.max(0, from - segment.from),
+            Math.min(segment.text.length, to - segment.from)
+          );
+        }
+        continue;
+      }
+      if (block.kind === "table") {
+        for (const row of block.rows) {
+          for (const cell of row.cells) visit(cell.content);
+        }
+        continue;
+      }
+      if (block.kind === "sdt_block") {
+        visit(block.children);
+      }
+    }
+  };
+  visit(blocks);
+  return acc;
+}
 function validateTemplateTargets(runtime, input) {
   if (!Array.isArray(input.targets) || input.targets.length === 0) {
     const detail = blocker(
@@ -62379,6 +62867,15 @@ function applyRewrite(runtime, target, input) {
     if (!listTextTarget.ok) return blockedApplyFromResolution(listTextTarget);
     return applyEditableTextRewrite(runtime, listTextTarget.target, input);
   }
+  const tableTextTarget = uniqueTableTextActionForScope(runtime, target.handle);
+  if (tableTextTarget.ok && tableTextTarget.action.readback?.text === target.scope.content.text) {
+    return applyTableScopedMarkerRewrite(
+      runtime,
+      target,
+      tableTextTarget.action,
+      input
+    );
+  }
   const rewriteBlocker = scopeRewriteCapabilityBlocker(target.scope);
   if (rewriteBlocker) {
     return blockedApply(
@@ -62511,6 +63008,106 @@ function applyEditableTextRewrite(runtime, target, input) {
     afterReadback
   };
 }
+function applyTableScopedMarkerRewrite(runtime, target, action, input) {
+  const workflowScope = runtime.getScope(target.handle.scopeId);
+  const editableTarget = tableEditableTargetForActionHandle(
+    runtime,
+    action.actionHandle
+  );
+  if (!workflowScope || workflowScope.anchor.kind !== "range" || !editableTarget) {
+    return blockedApply(
+      `actions:rewrite:table-marker-target-unresolved:${target.handle.scopeId}`,
+      "unresolved-target",
+      "The table-contained marker scope could not be joined to a current table text target.",
+      "Refresh placeholder scopes and retry; route persistent failures to L08 table scope target mapping."
+    );
+  }
+  const before = runtime.getCanonicalDocument();
+  try {
+    runtime.dispatch({
+      type: "selection.set",
+      selection: {
+        anchor: workflowScope.anchor.from,
+        head: workflowScope.anchor.to,
+        isCollapsed: workflowScope.anchor.from === workflowScope.anchor.to,
+        activeRange: {
+          kind: "range",
+          from: workflowScope.anchor.from,
+          to: workflowScope.anchor.to,
+          assoc: workflowScope.anchor.assoc ?? { start: -1, end: 1 }
+        }
+      },
+      origin: actionOrigin(runtime, input)
+    });
+    runtime.applyActiveStoryTextCommand({
+      type: "text.insert",
+      text: input.text,
+      editableTarget,
+      origin: actionOrigin(runtime, input)
+    });
+  } catch {
+    return blockedApply(
+      `actions:rewrite:table-marker-command-refused:${target.handle.scopeId}`,
+      "blocked",
+      "The table-contained marker scope could not be rewritten by the runtime text command.",
+      "Retry with an exact table text actionHandle; route repeated failures to L07 table text command support.",
+      [
+        blockerWithOwner(
+          `actions:rewrite:table-marker-command-refused:${target.handle.scopeId}`,
+          "blocked",
+          "The table-contained marker scope could not be rewritten by the runtime text command.",
+          "Retry with an exact table text actionHandle; route repeated failures to L07 table text command support.",
+          "L07 runtime text command support"
+        )
+      ]
+    );
+  }
+  const changed = runtime.getCanonicalDocument() !== before;
+  const paragraph = resolveParagraphTextTarget2(
+    runtime.getCanonicalDocument(),
+    editableTarget
+  );
+  const afterText = paragraph ? collectInlineText3(paragraph.children) : void 0;
+  const afterReadback = afterText === void 0 ? void 0 : { text: afterText, isEmpty: afterText.length === 0 };
+  if (!changed || afterReadback?.text !== input.text) {
+    return {
+      status: "blocked",
+      applied: false,
+      changed,
+      target: summarizeTarget({ kind: "table-text", action }),
+      posture: "suspect-readback",
+      blockers: Object.freeze([
+        `actions:rewrite:table-marker-readback-mismatch:${target.handle.scopeId}`
+      ]),
+      blockerDetails: Object.freeze([
+        blocker(
+          `actions:rewrite:table-marker-readback-mismatch:${target.handle.scopeId}`,
+          "blocked",
+          "The table-contained marker rewrite did not produce the requested exact table-cell readback.",
+          "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({
+      kind: "table-text",
+      action: { ...action, readback: afterReadback }
+    }),
+    commandReference: {
+      command: "text.insert",
+      actorId: input.actorId ?? "v3-ai-api",
+      origin: input.origin ?? "agent",
+      emittedAtUtc: currentAuditTimestamp(runtime)
+    },
+    ...action.readback ? { beforeReadback: action.readback } : {},
+    afterReadback
+  };
+}
 function projectRewriteScopeResult(runtime, result, target, beforeText, proposedText, documentMutated) {
   if (!result.applied) return projectApplyResult(result, target);
   const compiledAfter = createScopeCompilerService(runtime).compileScopeById(
@@ -62627,6 +63224,51 @@ function tableTextActionsForScope(runtime, handle) {
   });
   return result.actions.filter((action) => action.family === "table-text");
 }
+function uniqueTableTextActionForScope(runtime, handle) {
+  const actions2 = tableTextActionsForScope(runtime, handle).filter(
+    (action) => action.readback !== void 0
+  );
+  if (actions2.length === 1 && actions2[0]) {
+    return { ok: true, action: actions2[0] };
+  }
+  if (actions2.length === 0) {
+    return {
+      ok: false,
+      blockers: Object.freeze(["actions:rewrite:table-text-target-missing"]),
+      blockerDetails: Object.freeze([
+        blocker(
+          "actions:rewrite:table-text-target-missing",
+          "unsupported",
+          "The scope does not expose a unique command-safe table text target.",
+          "Use a paragraph/list scope, or retry with an exact table text actionHandle returned by ai.actions.locateAll."
+        )
+      ])
+    };
+  }
+  return {
+    ok: false,
+    blockers: Object.freeze(["actions:rewrite:table-text-target-ambiguous"]),
+    blockerDetails: Object.freeze([
+      blocker(
+        "actions:rewrite:table-text-target-ambiguous",
+        "ambiguous-target",
+        "The scope exposes multiple table text targets, so broad rewrite would be ambiguous.",
+        "Retry with the exact table text actionHandle returned by ai.actions.locateAll or ai.listTableActions."
+      )
+    ])
+  };
+}
+function tableEditableTargetForActionHandle(runtime, actionHandle) {
+  for (const target of collectEditableTargetRefs(runtime.getCanonicalDocument())) {
+    if (target.commandFamily !== "text-leaf" || target.table?.operationScope !== "text") {
+      continue;
+    }
+    if (deriveTableActionHandleForTarget(runtime, target.targetKey) === actionHandle) {
+      return target;
+    }
+  }
+  return null;
+}
 function editableTextActionsForScope(runtime, handle) {
   const bundle = createScopeCompilerService(runtime).compileBundleById(
     handle.scopeId,
@@ -65080,7 +65722,7 @@ function createOverlaysFamily(ctx) {
     return {
       handle: {
         kind: "table-action",
-        id: tableActionHandle2(documentSeed2(), targetKey),
+        id: tableActionHandle2(documentSeed3(), targetKey),
         targetKind,
         commandFamily,
         scope: tableActionScope(entry)
@@ -65104,9 +65746,9 @@ function createOverlaysFamily(ctx) {
     };
   }
   function tableActionHandle2(seed, targetKey) {
-    return `table-action:${hashOpaque2(`${seed}::${targetKey}`)}`;
+    return `table-action:${hashOpaque3(`${seed}::${targetKey}`)}`;
   }
-  function hashOpaque2(input) {
+  function hashOpaque3(input) {
     let h = 2166136261;
     for (let i = 0; i < input.length; i += 1) {
       h ^= input.charCodeAt(i);
@@ -65114,7 +65756,7 @@ function createOverlaysFamily(ctx) {
     }
     return (h >>> 0).toString(36).padStart(7, "0");
   }
-  function documentSeed2() {
+  function documentSeed3() {
     return ctx.handle.getSessionState().documentId ?? "document";
   }
   function modeledTargetSourceIdentity(target) {
@@ -66443,6 +67085,7 @@ function createApiV3(handle, opts) {
     ...createStatsFamily(handle),
     ...createOutlineFamily(handle),
     ...createTableActionFamily(handle),
+    ...createObjectActionFamily(handle),
     ...createActionsFamily(handle)
   };
   const runtime = {