@beyondwork/docx-react-component 1.0.129 → 1.0.131

package/dist/{chunk-XQCAMKIQ.js → chunk-WZDKNF37.js}

@@ -18,7 +18,7 @@ import {
   resolveScopeRange,
   scopeSpecificity,
   searchDocument
-} from "./chunk-SKPTKQHF.js";
+} from "./chunk-7G5GR3VV.js";
 import {
   BROADCAST_COMMAND_TYPES,
   COMMAND_EVENT_SCHEMA_VERSION,
@@ -29,7 +29,7 @@ import {
   buildPageAnchorElementId,
   createUiApi,
   emitUxResponse
-} from "./chunk-YIYM4ZAP.js";
+} from "./chunk-CI2TD3T4.js";
 import {
   DEFAULT_PX_PER_TWIP,
   DEFAULT_REGISTRY_ENTRIES,
@@ -37,24 +37,24 @@ import {
   LAYCACHE_SCHEMA_VERSION,
   LAYOUT_ENGINE_VERSION,
   createScopeTagRegistry
-} from "./chunk-RMRTQGW3.js";
+} from "./chunk-THVM6EP5.js";
 import {
   chartModelStore,
   createFormattingContext
-} from "./chunk-HUIHBBAQ.js";
+} from "./chunk-A3GSNB4G.js";
 import {
   createSelectionSnapshot,
   deriveDocumentStats
 } from "./chunk-OYGMRRR7.js";
 import {
   DocxSession
-} from "./chunk-63FYIGCT.js";
+} from "./chunk-DGA7M77X.js";
 import {
   WORKFLOW_PAYLOAD_PART_PATH,
   buildEditorStateXml,
   parseEditorStateXml,
   parseWorkflowPayloadEnvelopeFromPackage
-} from "./chunk-XMHSGPLN.js";
+} from "./chunk-VRKK2CSZ.js";
 import {
   EMU_PER_PX,
   GRADIENT_STOP_UNITS,
@@ -63,10 +63,10 @@ import {
   createHeaderFooterStoryKey,
   createNoteStoryKey,
   validateEditableTargetRef
-} from "./chunk-5DGKFNQT.js";
+} from "./chunk-A66ZVUAT.js";
 import {
   readOpcPackage
-} from "./chunk-OL2UEHRP.js";
+} from "./chunk-WUDSNHWF.js";
 
 // src/api/v3/_mocks.ts
 function mockPayload(reason, shape, body) {
@@ -6775,7 +6775,7 @@ var listOperationMetadata = actionMethodMetadata(
   "listOperation",
   "mutate",
   "actions-list-operation",
-  "Apply list toggle, indent, outdent, restart, or continue-numbering commands to paragraph-like scope handles.",
+  "Apply list toggle, indent, outdent, restart, or continue-numbering commands through opaque list action handles or command-safe list scope targets.",
   {
     uiVisible: true,
     expectsUxResponse: "inline-change",
@@ -8510,25 +8510,16 @@ function checkPlanStepCapability(runtime, step, before) {
     return null;
   }
   if (step.kind === "listOperation") {
-    const resolved = resolveScopeExactTarget(runtime, step.target, step.kind);
+    const resolved = resolveListOperationTarget(runtime, step.target);
     if (!resolved.ok) return resolved.blockerDetails[0] ?? null;
-    const scope = resolved.target.scope;
-    if (scope.kind !== "list-item" && scope.kind !== "paragraph" && scope.kind !== "heading") {
-      return blocker(
-        `actions:list-operation:target-kind-unsupported:${scope.kind}`,
-        "unsupported",
-        "List operations require a paragraph-like scope handle.",
-        "Use ai.actions.locateAll or ai.listScopes to select a paragraph, heading, or list-item handle."
-      );
-    }
-    if (paragraphIndexFromHandle(scope.handle) === null) {
-      return blockerWithOwner(
-        `actions:list-operation:paragraph-index-unresolved:${scope.handle.scopeId}`,
-        "blocked",
-        "The list operation target did not resolve to a current paragraph index.",
-        "Refresh the scope handle and retry; route persistent failures to L08 scope resolution.",
-        "L08 semantic scope compiler"
-      );
+    const command = runtimeListCommandForOperation(step.operation);
+    const preview = createListsFamily(runtime).previewCommand({
+      ...resolved.input,
+      command,
+      ...step.operation.kind === "restart-numbering" && step.operation.startAt !== void 0 ? { startAt: step.operation.startAt } : {}
+    });
+    if (preview.blockers.length > 0) {
+      return listBlockerDetails("actions:list-operation:preflight", preview.blockers)[0] ?? null;
     }
     return null;
   }
@@ -8685,70 +8676,253 @@ function applyModeledCommand(runtime, targetInput, kind, commandInput, reference
   };
 }
 function applyListOperation(runtime, input) {
-  const resolvedScope = resolveScopeExactTarget(runtime, input.target, "listOperation");
-  if (!resolvedScope.ok) return blockedApplyFromResolution(resolvedScope);
+  const resolvedTarget = resolveListOperationTarget(runtime, input.target);
+  if (!resolvedTarget.ok) return blockedApplyFromResolution(resolvedTarget);
+  const command = runtimeListCommandForOperation(input.operation);
+  const result = createListsFamily(runtime).applyCommand({
+    ...resolvedTarget.input,
+    command,
+    ...input.operation.kind === "restart-numbering" && input.operation.startAt !== void 0 ? { startAt: input.operation.startAt } : {}
+  });
+  if (!result.applied) {
+    const details = result.blockers.length > 0 ? listBlockerDetails("actions:list-operation", result.blockers) : [
+      blockerWithOwner(
+        `actions:list-operation:runtime-noop:${resolvedTarget.before?.addressKey ?? "unknown"}`,
+        "blocked",
+        "The runtime list command produced no document change for the selected list target.",
+        "Refresh the list action handle and retry; route persistent failures with before/after readback to L07 runtime list commands.",
+        "L07 runtime list commands"
+      )
+    ];
+    return {
+      status: details.some((detail) => detail.category === "unsupported") ? "unsupported" : "blocked",
+      applied: false,
+      changed: false,
+      target: summarizeListTarget(resolvedTarget, result.before ?? resolvedTarget.before),
+      blockers: Object.freeze(details.map((detail) => detail.code)),
+      blockerDetails: Object.freeze(details),
+      listReadback: listOperationReadback(result, resolvedTarget.before)
+    };
+  }
+  const compiledAfter = resolvedTarget.scopeHandle ? createScopeCompilerService(runtime).compileScopeById(resolvedTarget.scopeHandle.scopeId) : null;
+  const target = compiledAfter ? summarizeTarget({ kind: "scope", scope: compiledAfter.scope, handle: compiledAfter.scope.handle }) : summarizeListTarget(resolvedTarget, result.after ?? result.before ?? resolvedTarget.before);
+  return {
+    status: "applied",
+    applied: true,
+    changed: result.applied,
+    target,
+    commandReference: {
+      command: commandReferenceForListCommand(result.command),
+      actorId: input.actorId ?? "v3-ai-api",
+      origin: input.origin ?? "agent",
+      emittedAtUtc: currentAuditTimestamp(runtime)
+    },
+    listReadback: listOperationReadback(result, resolvedTarget.before)
+  };
+}
+function resolveListOperationTarget(runtime, targetInput) {
+  const lists = createListsFamily(runtime);
+  if ("actionHandle" in targetInput) {
+    const addressKey = listAddressKeyFromActionHandle(targetInput.actionHandle);
+    if (!addressKey) {
+      const detail = blockerWithOwner(
+        `actions:list-operation:action-handle-malformed:${targetInput.actionHandle}`,
+        "unsupported",
+        "List operations require an opaque list action handle from runtime.lists or list editable-target evidence.",
+        "Call runtime.lists.list or refresh the scope bundle and retry with a list-action:* or scope-command:text-leaf:* list handle.",
+        "L07 runtime list commands and L08 semantic scopes"
+      );
+      return {
+        ok: false,
+        blockers: Object.freeze([detail.code]),
+        blockerDetails: Object.freeze([detail])
+      };
+    }
+    const before2 = lists.get({ addressKey });
+    if (!before2) {
+      const detail = blockerWithOwner(
+        `actions:list-operation:action-handle-not-found:${targetInput.actionHandle}`,
+        "unresolved-target",
+        "No current list target matches the supplied opaque action handle.",
+        "Refresh runtime.lists.list or the scope bundle, then retry with the current list action handle.",
+        "L07 runtime list commands"
+      );
+      return {
+        ok: false,
+        blockers: Object.freeze([detail.code]),
+        blockerDetails: Object.freeze([detail])
+      };
+    }
+    return { ok: true, input: { addressKey }, before: before2 };
+  }
+  const resolvedScope = resolveScopeExactTarget(runtime, targetInput, "listOperation");
+  if (!resolvedScope.ok) return resolvedScope;
   const scope = resolvedScope.target.scope;
   if (scope.kind !== "list-item" && scope.kind !== "paragraph" && scope.kind !== "heading") {
-    return blockedApply(
+    const detail = blocker(
       `actions:list-operation:target-kind-unsupported:${scope.kind}`,
       "unsupported",
-      "List operations require a paragraph-like scope handle.",
-      "Use ai.actions.locateAll or ai.listScopes to select a paragraph, heading, or list-item handle."
+      "List operations require a list item or command-safe paragraph-like scope target.",
+      "Use ai.actions.locateAll, ai.listScopes, or runtime.lists.list to select a current list item target."
     );
+    return {
+      ok: false,
+      blockers: Object.freeze([detail.code]),
+      blockerDetails: Object.freeze([detail])
+    };
   }
-  const paragraphIndex = paragraphIndexFromHandle(scope.handle);
-  if (paragraphIndex === null) {
-    return blockedApply(
-      `actions:list-operation:paragraph-index-unresolved:${scope.handle.scopeId}`,
+  const bundle = createScopeCompilerService(runtime).compileBundleById(
+    scope.handle.scopeId,
+    currentAuditTimestamp(runtime)
+  );
+  const entries = bundle?.evidence.editableTargets?.entries ?? [];
+  const listEntry = entries.find(
+    (entry) => entry.commandFamily === "text-leaf" && entry.runtimeCommand.status === "supported" && entry.runtimeCommand.intents.includes("list-structure-action") && entry.runtimeCommand.canonicalAddress?.operationScope === "list-text" && entry.runtimeCommand.canonicalAddress.addressKind === "list-item-text"
+  );
+  if (!listEntry) {
+    const detail = blockerWithOwner(
+      `actions:list-operation:list-target-missing:${scope.handle.scopeId}`,
       "blocked",
-      "The list operation target did not resolve to a current paragraph index.",
-      "Refresh the scope handle and retry; route persistent failures to L08 scope resolution.",
-      [
-        blockerWithOwner(
-          `actions:list-operation:paragraph-index-unresolved:${scope.handle.scopeId}`,
-          "blocked",
-          "The list operation target did not resolve to a current paragraph index.",
-          "Refresh the scope handle and retry; route persistent failures to L08 scope resolution.",
-          "L08 semantic scope compiler"
-        )
-      ]
+      "The selected scope does not expose a command-safe list structure target.",
+      "Refresh the scope bundle and route missing list editable-target evidence to L08/L07; do not derive a paragraph index from the scope handle.",
+      "L08 semantic scopes and L07 runtime list commands"
     );
+    return {
+      ok: false,
+      blockers: Object.freeze([detail.code]),
+      blockerDetails: Object.freeze([detail])
+    };
   }
-  const command = listCommandForOperation(input.operation, paragraphIndex, actionOrigin(runtime, input));
-  const before = runtime.getCanonicalDocument();
-  runtime.dispatch(command);
-  const changed = runtime.getCanonicalDocument() !== before;
-  if (!changed) {
-    return blockedApply(
-      `actions:list-operation:runtime-noop:${scope.handle.scopeId}`,
+  const currentTarget = collectEditableTargetRefs(runtime.getCanonicalDocument()).find(
+    (target) => target.targetKey === listEntry.targetKey || target.listAddress?.addressKey === listEntry.runtimeCommand.canonicalAddress?.addressKey
+  );
+  if (!currentTarget) {
+    const detail = blockerWithOwner(
+      `actions:list-operation:list-target-not-current:${scope.handle.scopeId}`,
+      "unresolved-target",
+      "The list editable target evidence is stale in the current document.",
+      "Refresh the scope bundle and retry with the current opaque list target.",
+      "L08 semantic scopes and L07 runtime list commands"
+    );
+    return {
+      ok: false,
+      blockers: Object.freeze([detail.code]),
+      blockerDetails: Object.freeze([detail])
+    };
+  }
+  const before = lists.get({ editableTarget: currentTarget });
+  if (!before) {
+    const detail = blockerWithOwner(
+      `actions:list-operation:list-readback-missing:${scope.handle.scopeId}`,
       "blocked",
-      "The list runtime command produced no document change for the selected scope.",
-      "Select a list-compatible paragraph and retry, or route to L03/L07 list command support with the scope handle.",
-      [
-        blockerWithOwner(
-          `actions:list-operation:runtime-noop:${scope.handle.scopeId}`,
-          "blocked",
-          "The list runtime command produced no document change for the selected scope.",
-          "Select a list-compatible paragraph and retry, or route to L03/L07 list command support with the scope handle.",
-          "L03 numbering/list semantics and L07 runtime list commands"
-        )
-      ]
+      "The list target was present in scope evidence but runtime.lists could not produce readback.",
+      "Route the target with editable-target evidence to L07 runtime list readback.",
+      "L07 runtime list commands"
     );
+    return {
+      ok: false,
+      blockers: Object.freeze([detail.code]),
+      blockerDetails: Object.freeze([detail])
+    };
   }
-  const compiledAfter = createScopeCompilerService(runtime).compileScopeById(scope.handle.scopeId);
   return {
-    status: "applied",
-    applied: true,
-    changed: true,
-    target: compiledAfter ? summarizeTarget({ kind: "scope", scope: compiledAfter.scope, handle: compiledAfter.scope.handle }) : summarizeTarget(resolvedScope.target),
-    commandReference: {
-      command: command.type,
-      actorId: input.actorId ?? "v3-ai-api",
-      origin: input.origin ?? "agent",
-      emittedAtUtc: command.origin?.timestamp ?? currentAuditTimestamp(runtime)
-    }
+    ok: true,
+    input: { editableTarget: currentTarget },
+    before,
+    scopeHandle: scope.handle
+  };
+}
+function listAddressKeyFromActionHandle(actionHandle) {
+  const listPrefix = "list-action:";
+  if (actionHandle.startsWith(listPrefix)) return actionHandle.slice(listPrefix.length) || null;
+  const scopeCommandPrefix = "scope-command:text-leaf:";
+  if (actionHandle.startsWith(scopeCommandPrefix)) {
+    return actionHandle.slice(scopeCommandPrefix.length) || null;
+  }
+  return null;
+}
+function runtimeListCommandForOperation(operation) {
+  switch (operation.kind) {
+    case "toggle":
+      return operation.listKind === "numbered" ? "toggle-numbered" : "toggle-bulleted";
+    case "indent":
+      return "indent";
+    case "outdent":
+      return "outdent";
+    case "restart-numbering":
+      return "restart-numbering";
+    case "continue-numbering":
+      return "continue-numbering";
+  }
+}
+function commandReferenceForListCommand(command) {
+  switch (command) {
+    case "toggle-numbered":
+    case "toggle-bulleted":
+      return "list.toggle";
+    case "indent":
+      return "list.indent";
+    case "outdent":
+      return "list.outdent";
+    case "restart-numbering":
+      return "list.restart-numbering";
+    case "continue-numbering":
+      return "list.continue-numbering";
+    default:
+      return "list.toggle";
+  }
+}
+function listOperationReadback(result, fallbackBefore) {
+  const before = sanitizeListReadback(result.before ?? fallbackBefore);
+  const after = sanitizeListReadback(result.after);
+  return {
+    ...before ? { before } : {},
+    ...after ? { after } : {}
+  };
+}
+function sanitizeListReadback(readback) {
+  if (!readback) return void 0;
+  return {
+    actionHandle: readback.actionHandle,
+    kind: readback.kind,
+    storyKey: readback.storyKey,
+    addressKey: readback.addressKey,
+    numberingInstanceId: readback.numberingInstanceId,
+    ...readback.abstractNumberingId ? { abstractNumberingId: readback.abstractNumberingId } : {},
+    level: readback.level,
+    ...readback.listKind ? { listKind: readback.listKind } : {},
+    editability: readback.editability,
+    blockers: readback.blockers,
+    supportedCommands: readback.supportedCommands,
+    unsupportedCommands: readback.unsupportedCommands,
+    staleDiscriminators: readback.staleDiscriminators
   };
 }
+function summarizeListTarget(target, readback) {
+  const current = readback ?? target.before;
+  return {
+    kind: "list-item",
+    ...target.scopeHandle ? { handle: target.scopeHandle } : {},
+    ...current?.actionHandle ? { actionHandle: current.actionHandle } : {},
+    canRewriteText: current?.editability === "editable" && (current.blockers.length ?? 0) === 0,
+    canInsertAdjacentText: false,
+    canFlag: Boolean(target.scopeHandle),
+    canMark: Boolean(target.scopeHandle)
+  };
+}
+function listBlockerDetails(prefix, blockers) {
+  return Object.freeze(
+    blockers.map(
+      (entry) => blockerWithOwner(
+        `${prefix}:${entry.code}:${entry.addressKey ?? entry.targetKey ?? "unknown"}`,
+        entry.code === "list-command-unsupported" ? "unsupported" : "blocked",
+        entry.message,
+        "Refresh the opaque list target/readback and route persistent blockers to the owning runtime list layer.",
+        entry.ownerLayer === "L07" ? "L07 runtime list commands" : entry.ownerLayer
+      )
+    )
+  );
+}
 function projectTableApplyResult(result) {
   return {
     status: result.applied ? "applied" : "blocked",
@@ -8876,36 +9050,6 @@ function tableSelectionStepHasDescriptor(operation) {
     operation && "selectionDescriptor" in operation && operation.selectionDescriptor
   );
 }
-function listCommandForOperation(operation, paragraphIndex, origin) {
-  switch (operation.kind) {
-    case "toggle":
-      return {
-        type: "list.toggle",
-        kind: operation.listKind,
-        paragraphIndexes: [paragraphIndex],
-        origin
-      };
-    case "indent":
-      return { type: "list.indent", paragraphIndexes: [paragraphIndex], origin };
-    case "outdent":
-      return { type: "list.outdent", paragraphIndexes: [paragraphIndex], origin };
-    case "restart-numbering":
-      return {
-        type: "list.restart-numbering",
-        paragraphIndex,
-        ...operation.startAt !== void 0 ? { startAt: operation.startAt } : {},
-        origin
-      };
-    case "continue-numbering":
-      return { type: "list.continue-numbering", paragraphIndex, origin };
-  }
-}
-function paragraphIndexFromHandle(handle) {
-  const raw = handle.semanticPath[handle.semanticPath.length - 1];
-  if (raw === void 0) return null;
-  const index = Number(raw);
-  return Number.isSafeInteger(index) && index >= 0 ? index : null;
-}
 function actionOrigin(runtime, input) {
   return { source: "api", timestamp: currentAuditTimestamp(runtime) };
 }

package/dist/{chunk-PRAZBHNF.js → chunk-YLL7MF5C.js}

@@ -11,7 +11,7 @@ import {
 } from "./chunk-M6XR534O.js";
 import {
   buildBookmarkNameMap
-} from "./chunk-YZDZ4FGR.js";
+} from "./chunk-ZVC23LKV.js";
 import {
   deleteSelectionOrBackward,
   deleteSelectionOrForward,
@@ -22,7 +22,7 @@ import {
   insertText,
   outdentParagraphAtSelection,
   splitParagraph
-} from "./chunk-LJH64PV3.js";
+} from "./chunk-QXKQPUOM.js";
 import {
   applyFormattingOperationToDocument,
   applyTextMarkOperationToDocumentRange,
@@ -32,18 +32,18 @@ import {
   insertImage,
   repositionFloatingImage,
   resizeImage
-} from "./chunk-DJU2W4E4.js";
+} from "./chunk-KNHMXKC6.js";
 import {
   applyTextTransaction
-} from "./chunk-5DSHUYSY.js";
+} from "./chunk-T5YYFDZB.js";
 import {
   applyTableStructureOperationForEditableTarget,
   removeCellFromRow,
   removeTableRowPure
-} from "./chunk-DDN2AIGE.js";
+} from "./chunk-Q7Y57KOK.js";
 import {
   resolveParagraphScope
-} from "./chunk-W34X3KBR.js";
+} from "./chunk-PHMWH23E.js";
 import {
   buildGeometryDebugEntry,
   collectLineBoxesForRegion,
@@ -51,7 +51,7 @@ import {
   createRenderKernel,
   incrementInvalidationCounter,
   recordPerfSample
-} from "./chunk-OTQIW2TC.js";
+} from "./chunk-35RHOE6I.js";
 import {
   AI_ACTION_POLICIES,
   allocateNumberingInstance,
@@ -79,7 +79,7 @@ import {
   resolveScope,
   serializeFragmentToWordML,
   setStartOverride
-} from "./chunk-SKPTKQHF.js";
+} from "./chunk-7G5GR3VV.js";
 import {
   ISSUE_METADATA_ID,
   LAYOUT_ENGINE_VERSION,
@@ -114,7 +114,7 @@ import {
   setWorkspaceMode,
   setZoomLevel,
   snapCommentAnchorAwayFromTable
-} from "./chunk-RMRTQGW3.js";
+} from "./chunk-THVM6EP5.js";
 import {
   countLogicalPositions,
   createPlainText,
@@ -133,11 +133,11 @@ import {
   replaceStoryBlocks,
   resolvePageFieldDisplayText,
   storyTargetKey
-} from "./chunk-HUIHBBAQ.js";
+} from "./chunk-A3GSNB4G.js";
 import {
   createCommentSidebarProjection,
   createCommentStoreFromRuntimeComments
-} from "./chunk-CX42VC67.js";
+} from "./chunk-SYQWQ6FE.js";
 import {
   createEditorState,
   createPersistedEditorSnapshot,
@@ -157,12 +157,12 @@ import {
   persistedSnapshotFromEditorSessionState,
   remapRevisionStore,
   setRevisionStatus
-} from "./chunk-JJGVE5J7.js";
+} from "./chunk-4YCWECLZ.js";
 import {
   isSupportedFieldFamily,
   parseTocLevelRange,
   resolveRefFieldText
-} from "./chunk-Q3QYGKFE.js";
+} from "./chunk-M7YRJX6V.js";
 import {
   collectEditableTargetRefs,
   collectEditableTargetRefsForStoryBlockRanges,
@@ -171,10 +171,10 @@ import {
   createHeaderFooterStoryKey,
   sha256TextHex,
   validateEditableTargetRef
-} from "./chunk-5DGKFNQT.js";
+} from "./chunk-A66ZVUAT.js";
 import {
   setActiveSerializeTelemetryBus
-} from "./chunk-EB6M3GE6.js";
+} from "./chunk-FM4K4XFJ.js";
 import {
   describeOpaqueFragment,
   findOpaqueFragmentsIntersectingRange,

package/dist/{chunk-YZDZ4FGR.js → chunk-ZVC23LKV.js}

@@ -1,6 +1,6 @@
 import {
   extractBookmarksFromBodyXml
-} from "./chunk-Q3QYGKFE.js";
+} from "./chunk-M7YRJX6V.js";
 
 // src/legal/document-root.ts
 function resolveWalkableRoot(document) {