@beyondwork/docx-react-component 1.0.105 → 1.0.108

package/src/runtime/revision-runtime.ts

@@ -1,15 +1,25 @@
+import type { EditorStoryTarget } from "../api/public-types.ts";
 import type { CanonicalDocumentEnvelope } from "../core/state/editor-state.ts";
 import {
   getReviewCommandIntent,
   isSingleRevisionReviewCommand,
   type ReviewCommand,
 } from "../core/commands/review-commands.ts";
-import type { TransactionMapping } from "../core/selection/mapping.ts";
+import {
+  MAIN_STORY_TARGET,
+  storyTargetsEqual,
+  type TransactionMapping,
+} from "../core/selection/mapping.ts";
 import {
   applyRevisionAction,
+  type ApplyRevisionActionResult,
   type RevisionActionOutcome,
 } from "../review/store/revision-actions.ts";
-import { type RevisionStore } from "../review/store/revision-store.ts";
+import {
+  createRevisionStore,
+  type RevisionStore,
+} from "../review/store/revision-store.ts";
+import { getStoryBlocks, replaceStoryBlocks } from "./story-targeting.ts";
 
 export interface RevisionRuntimeState {
   document: CanonicalDocumentEnvelope;
@@ -30,7 +40,12 @@ export interface RevisionRuntimeCommandEffects {
 
 export interface RevisionRuntimeCommandResult extends RevisionRuntimeState {
   outcomes: RevisionActionOutcome[];
-  mappings: Array<{ revisionId: string; mapping: TransactionMapping; steps: number }>;
+  mappings: Array<{
+    revisionId: string;
+    mapping: TransactionMapping;
+    steps: number;
+    storyTarget: EditorStoryTarget;
+  }>;
   effects: RevisionRuntimeCommandEffects;
 }
 
@@ -44,30 +59,31 @@ export function applyRevisionRuntimeCommand(
   const revisionIds = expandLinkedMovePartners(rawRevisionIds, options.state.store);
 
   const outcomes: RevisionActionOutcome[] = [];
-  const mappings: Array<{ revisionId: string; mapping: TransactionMapping; steps: number }> = [];
+  const mappings: RevisionRuntimeCommandResult["mappings"] = [];
   const appliedRevisionIds: string[] = [];
   const detachedRevisionIds = new Set<string>();
 
   let state = options.state;
 
   for (const revisionId of revisionIds) {
+    const revision = state.store.revisions[revisionId];
+    const storyTarget = getRevisionStoryTarget(revision);
+    const scopedState = createStoryScopedRevisionState(state, storyTarget);
     const result = applyRevisionAction({
-      document: state.document,
-      store: state.store,
+      document: scopedState.document,
+      store: scopedState.store,
       revisionId,
       intent: getReviewCommandIntent(options.command),
       timestamp: options.timestamp,
     });
 
-    state = {
-      document: result.document,
-      store: result.store,
-    };
+    state = mergeStoryScopedRevisionResult(state, storyTarget, scopedState, result);
     outcomes.push(result.outcome);
     mappings.push({
       revisionId,
       mapping: result.mapping,
       steps: result.mapping.steps.length,
+      storyTarget,
     });
 
     if (result.outcome.kind === "applied") {
@@ -94,6 +110,92 @@ export function applyRevisionRuntimeCommand(
   };
 }
 
+interface StoryScopedRevisionState extends RevisionRuntimeState {
+  storyRevisionIds: readonly string[];
+}
+
+function createStoryScopedRevisionState(
+  state: RevisionRuntimeState,
+  storyTarget: EditorStoryTarget,
+): StoryScopedRevisionState {
+  if (storyTargetsEqual(storyTarget, MAIN_STORY_TARGET)) {
+    return {
+      ...state,
+      storyRevisionIds: Object.keys(state.store.revisions),
+    };
+  }
+
+  const storyRevisionIds = Object.entries(state.store.revisions)
+    .filter(([, revision]) =>
+      storyTargetsEqual(getRevisionStoryTarget(revision), storyTarget)
+    )
+    .map(([revisionId]) => revisionId);
+  const storyRevisions = Object.fromEntries(
+    storyRevisionIds.map((revisionId) => [
+      revisionId,
+      state.store.revisions[revisionId]!,
+    ]),
+  );
+
+  return {
+    document: {
+      ...state.document,
+      content: {
+        ...state.document.content,
+        children: [...getStoryBlocks(state.document, storyTarget)],
+      },
+    },
+    store: createRevisionStore(storyRevisions),
+    storyRevisionIds,
+  };
+}
+
+function mergeStoryScopedRevisionResult(
+  previousState: RevisionRuntimeState,
+  storyTarget: EditorStoryTarget,
+  scopedState: StoryScopedRevisionState,
+  result: ApplyRevisionActionResult,
+): RevisionRuntimeState {
+  if (storyTargetsEqual(storyTarget, MAIN_STORY_TARGET)) {
+    return {
+      document: result.document,
+      store: result.store,
+    };
+  }
+
+  const nextStore = createRevisionStore({
+    ...previousState.store.revisions,
+    ...Object.fromEntries(
+      scopedState.storyRevisionIds
+        .filter((revisionId) => result.store.revisions[revisionId])
+        .map((revisionId) => [
+          revisionId,
+          result.store.revisions[revisionId]!,
+        ]),
+    ),
+  });
+
+  return {
+    document: replaceStoryBlocks(
+      {
+        ...previousState.document,
+        updatedAt: result.document.updatedAt,
+      },
+      storyTarget,
+      result.document.content.children,
+    ),
+    store: nextStore,
+  };
+}
+
+function getRevisionStoryTarget(
+  revision: RevisionStore["revisions"][string] | undefined,
+): EditorStoryTarget {
+  return revision?.metadata.storyTarget
+    ? { ...revision.metadata.storyTarget }
+    : MAIN_STORY_TARGET;
+}
+
 function expandLinkedMovePartners(
   revisionIds: readonly string[],
   store: RevisionStore,

package/src/runtime/scopes/_scope-dependencies.ts

@@ -34,6 +34,7 @@ export type {
   InteractionGuardSnapshot,
   TextFormattingDirective,
   WorkflowBlockedCommandReason,
+  WorkflowEventOrigin,
   WorkflowMetadataEntry,
   WorkflowMetadataSnapshot,
   WorkflowOverlay,

package/src/runtime/scopes/action-validation.ts

@@ -63,6 +63,7 @@ import {
 import { resolveScopeRange } from "./scope-range.ts";
 import type {
   ReplacementScope,
+  ScopeActionPosture,
   ScopeActionOperationKind,
   SemanticScope,
   ValidationApproval,
@@ -144,8 +145,6 @@ function inferActionId(
     case "insert-before":
     case "insert-after":
       return "generate_text";
-    case "split":
-      return "rewrite_paragraph";
     case "annotate":
       return "suggest_comment_response";
   }
@@ -296,6 +295,17 @@ function collectPreservationVerdict(
 ): void {
   const { document, scope, positionMap } = inputs;
   if (inputs.skipPreservation === true) return;
+  // Insert-before / insert-after lower to collapsed insertions at the
+  // effective scope edge. They do not replace or delete the scope's
+  // current contents, so preserve-only payloads and nested markers
+  // inside the scope are not at risk in the same way they are for
+  // `replace`.
+  if (
+    inputs.operation === "insert-before" ||
+    inputs.operation === "insert-after"
+  ) {
+    return;
+  }
   if (!document) return;
   const pm = positionMap ?? buildScopePositionMap(document);
   const range = inputs.enumeratedScope
@@ -397,6 +407,15 @@ function collectPolicyVerdict(
   return undefined;
 }
 
+function validationPosture(
+  blockedReasons: readonly string[],
+  warnings: readonly ValidationIssue[],
+): ScopeActionPosture {
+  if (blockedReasons.length > 0) return "hard-refusal";
+  if (warnings.length > 0) return "warn-and-proceed";
+  return "supported";
+}
+
 /**
  * Compose a single validation verdict for a proposed scope replacement.
  * Synchronous, deterministic, free of side effects. Safe to call in hot
@@ -420,6 +439,7 @@ export function composeScopeValidation(
   const safe = blockedReasons.length === 0;
   return {
     safe,
+    posture: validationPosture(blockedReasons, warnings),
     blockedReasons: Object.freeze([...blockedReasons]),
     warnings: Object.freeze([...warnings]),
     ...(approval ? { approval } : {}),

package/src/runtime/scopes/capabilities.ts

@@ -0,0 +1,316 @@
+/**
+ * Scope action capability projection.
+ *
+ * This module reports what the shipped L08 compiler/runtime can lower today.
+ * It does not validate a specific payload and does not authorize a mutation;
+ * every apply path still re-runs validation and compile.
+ */
+
+import type {
+  ScopeContentControlEvidence,
+  ScopeGeometryEvidence,
+  ScopeLayoutEvidence,
+  ScopeCapabilities,
+  ScopeCapabilityVerdict,
+  SemanticScope,
+  SemanticScopeKind,
+} from "./semantic-scope-types.ts";
+import {
+  MULTI_PARAGRAPH_REPLACEMENT_REFUSAL,
+  multiParagraphReplacementBlockers,
+} from "./multi-paragraph-refusal.ts";
+
+const PARAGRAPH_LIKE = new Set<SemanticScopeKind>([
+  "paragraph",
+  "heading",
+  "list-item",
+]);
+
+const FORMATTING_SUPPORTED = new Set<SemanticScopeKind>([
+  "paragraph",
+  "heading",
+  "list-item",
+  "scope",
+]);
+
+const METADATA_SUPPORTED = new Set<SemanticScopeKind>([
+  "paragraph",
+  "heading",
+  "list-item",
+  "table",
+  "table-row",
+  "table-cell",
+  "scope",
+]);
+
+export interface ScopeCapabilityContext {
+  readonly layout?: ScopeLayoutEvidence;
+  readonly geometry?: ScopeGeometryEvidence;
+  readonly contentControls?: ScopeContentControlEvidence;
+}
+
+function freezeList(values: readonly string[]): readonly string[] {
+  return Object.freeze([...values]);
+}
+
+function supported(
+  reason: string,
+  warnings: readonly string[] = [],
+): ScopeCapabilityVerdict {
+  const hasWarnings = warnings.length > 0;
+  return {
+    supported: true,
+    status: hasWarnings ? "degraded" : "supported",
+    posture: hasWarnings ? "warn-and-proceed" : "supported",
+    reason,
+    ...(hasWarnings ? { warnings: freezeList(warnings) } : {}),
+  };
+}
+
+function unsupported(
+  reason: string,
+  blockers: readonly string[] = [reason],
+  warnings: readonly string[] = [],
+): ScopeCapabilityVerdict {
+  return {
+    supported: false,
+    status: "unsupported",
+    posture: "hard-refusal",
+    reason,
+    blockers: freezeList(blockers),
+    ...(warnings.length > 0 ? { warnings: freezeList(warnings) } : {}),
+  };
+}
+
+function blocked(
+  reason: string,
+  blockers: readonly string[] = [reason],
+): ScopeCapabilityVerdict {
+  return {
+    supported: false,
+    status: "blocked",
+    posture: "hard-refusal",
+    reason,
+    blockers: freezeList(blockers),
+  };
+}
+
+function guardBlocker(scope: SemanticScope): string | null {
+  switch (scope.workflow.effectiveMode) {
+    case "view":
+      return "guard:view-mode-active";
+    case "comment":
+      return "guard:comment-only";
+    case "blocked": {
+      const [first] = scope.workflow.blockedReasons ?? [];
+      return first ? `guard:block-${first}` : "guard:block-scope-overlay";
+    }
+    default:
+      return null;
+  }
+}
+
+function operationRefusal(scope: SemanticScope): string {
+  return `compile-refused:${scope.kind}`;
+}
+
+function contentControlBlockers(
+  context: ScopeCapabilityContext | undefined,
+): readonly string[] {
+  const entries = context?.contentControls?.entries ?? [];
+  if (entries.length === 0) return [];
+  return freezeList(entries.map((entry) => `preserve:content-control:${entry.evidenceId}`));
+}
+
+function evidenceWarnings(
+  context: ScopeCapabilityContext | undefined,
+): readonly string[] {
+  const warnings: string[] = [];
+  if (context?.layout) {
+    if (
+      context.layout.status === "requires-rehydration" ||
+      context.layout.status === "unavailable" ||
+      context.layout.completeness !== "complete"
+    ) {
+      warnings.push(`layout:${context.layout.completeness}`);
+    }
+  }
+  if (context?.geometry) {
+    if (context.geometry.requiresRehydration) {
+      warnings.push("geometry:requires-rehydration");
+    } else if (context.geometry.status === "unavailable") {
+      warnings.push("geometry:unavailable");
+    }
+    if (context.geometry.continuationState?.crossesPageBoundary) {
+      warnings.push("geometry:crosses-page-boundary");
+    }
+  }
+  return freezeList(warnings);
+}
+
+function insertCapability(
+  scope: SemanticScope,
+  edge: "before" | "after",
+  context?: ScopeCapabilityContext,
+): ScopeCapabilityVerdict {
+  const guard = guardBlocker(scope);
+  if (guard) return blocked(guard);
+
+  if (!PARAGRAPH_LIKE.has(scope.kind)) {
+    return unsupported(operationRefusal(scope));
+  }
+
+  if (
+    scope.replaceability.level === "blocked" ||
+    scope.replaceability.level === "preserve-only"
+  ) {
+    const reason = scope.replaceability.reason
+      ? `replaceability:${scope.replaceability.reason}`
+      : `replaceability:${scope.replaceability.level}`;
+    return unsupported(reason);
+  }
+
+  return supported(
+    `compile-supported:paragraph-like:insert-${edge}`,
+    [
+      ...(scope.workflow.effectiveMode === "suggest" ? ["guard:suggest-mode"] : []),
+      ...evidenceWarnings(context),
+    ],
+  );
+}
+
+function replaceTextCapability(
+  scope: SemanticScope,
+  context?: ScopeCapabilityContext,
+): ScopeCapabilityVerdict {
+  const guard = guardBlocker(scope);
+  if (guard) return blocked(guard);
+
+  const contentControls = contentControlBlockers(context);
+  if (contentControls.length > 0) {
+    return blocked("preserve:content-control", contentControls);
+  }
+
+  if (!PARAGRAPH_LIKE.has(scope.kind)) {
+    const reason =
+      scope.kind === "scope" && scope.replaceability.reason
+        ? MULTI_PARAGRAPH_REPLACEMENT_REFUSAL
+        : `compile-refused:${scope.kind}`;
+    return unsupported(
+      reason,
+      scope.kind === "scope"
+        ? multiParagraphReplacementBlockers("text")
+        : [reason],
+      evidenceWarnings(context),
+    );
+  }
+
+  if (
+    scope.replaceability.level === "blocked" ||
+    scope.replaceability.level === "preserve-only" ||
+    scope.replaceability.level === "formatting-only"
+  ) {
+    const reason = scope.replaceability.reason
+      ? `replaceability:${scope.replaceability.reason}`
+      : `replaceability:${scope.replaceability.level}`;
+    return unsupported(reason);
+  }
+
+  return supported(
+    "compile-supported:paragraph-like:text-replace",
+    [
+      ...(scope.workflow.effectiveMode === "suggest" ? ["guard:suggest-mode"] : []),
+      ...evidenceWarnings(context),
+    ],
+  );
+}
+
+function replaceFragmentCapability(
+  scope: SemanticScope,
+  context?: ScopeCapabilityContext,
+): ScopeCapabilityVerdict {
+  const guard = guardBlocker(scope);
+  if (guard) return blocked(guard);
+
+  const contentControls = contentControlBlockers(context);
+  if (contentControls.length > 0) {
+    return blocked("preserve:content-control", contentControls);
+  }
+
+  if (!PARAGRAPH_LIKE.has(scope.kind)) {
+    const reason =
+      scope.kind === "scope" && scope.replaceability.reason
+        ? MULTI_PARAGRAPH_REPLACEMENT_REFUSAL
+        : `compile-refused:${scope.kind}`;
+    return unsupported(
+      reason,
+      scope.kind === "scope"
+        ? multiParagraphReplacementBlockers("fragment")
+        : [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),
+  );
+}
+
+function formattingCapability(
+  scope: SemanticScope,
+  context?: ScopeCapabilityContext,
+): ScopeCapabilityVerdict {
+  const guard = guardBlocker(scope);
+  if (guard) return blocked(guard);
+
+  if (!FORMATTING_SUPPORTED.has(scope.kind)) {
+    return unsupported(`compile-refused:${scope.kind}:formatting-not-implemented`);
+  }
+
+  if (scope.workflow.effectiveMode === "suggest") {
+    return unsupported(
+      `compile-refused:${scope.kind}:formatting-suggesting-not-implemented`,
+      [`compile-refused:${scope.kind}:formatting-suggesting-not-implemented`],
+      ["guard:suggest-mode"],
+    );
+  }
+
+  return supported("compile-supported:scope-formatting", evidenceWarnings(context));
+}
+
+function metadataCapability(scope: SemanticScope): ScopeCapabilityVerdict {
+  if (METADATA_SUPPORTED.has(scope.kind)) {
+    return supported(
+      scope.kind === "table" ||
+        scope.kind === "table-row" ||
+        scope.kind === "table-cell"
+        ? "metadata-supported:derived-table-family"
+        : "metadata-supported:scope-id",
+    );
+  }
+  return unsupported(`scope-not-resolvable:${scope.handle.scopeId}`);
+}
+
+export function deriveScopeCapabilities(
+  scope: SemanticScope,
+  context: ScopeCapabilityContext = {},
+): ScopeCapabilities {
+  return {
+    canReplaceText: replaceTextCapability(scope, context),
+    canReplaceFragment: replaceFragmentCapability(scope, context),
+    canInsertBefore: insertCapability(scope, "before", context),
+    canInsertAfter: insertCapability(scope, "after", context),
+    canApplyFormatting: formattingCapability(scope, context),
+    canClearFormattingLayer: formattingCapability(scope, context),
+    canAttachMetadata: metadataCapability(scope),
+  };
+}

package/src/runtime/scopes/compile-scope-bundle.ts

@@ -17,6 +17,7 @@ import type {
   WorkflowMetadataEntry,
   WorkflowOverlay,
 } from "./_scope-dependencies.ts";
+import type { ScopeGeometryEvidenceProvider } from "./geometry-evidence.ts";
 
 import {
   buildParagraphIndexMap,
@@ -26,6 +27,7 @@ import {
 import type { EnumeratedScope } from "./enumerate-scopes.ts";
 import { enumerateScopes } from "./enumerate-scopes.ts";
 import { composeEvidence } from "./evidence.ts";
+import type { ScopeLayoutEvidenceProvider } from "./layout-evidence.ts";
 import type {
   ScopeBundle,
   ScopeBundleNeighborhood,
@@ -47,6 +49,16 @@ export interface ScopeBundleInputs {
    * to walk the metadata snapshot.
    */
   readonly workflowMetadataEntries?: readonly WorkflowMetadataEntry[];
+  /**
+   * Optional Layer-05 replacement-envelope read seam. When omitted, bundle
+   * evidence records geometry as unavailable rather than synthesizing rects.
+   */
+  readonly geometry?: ScopeGeometryEvidenceProvider;
+  /**
+   * Optional lower-layer layout evidence seam. When absent, bundle evidence
+   * records layout as unavailable instead of deriving page slices in L08.
+   */
+  readonly layout?: ScopeLayoutEvidenceProvider;
 }
 
 /**
@@ -126,6 +138,8 @@ export function compileScopeBundle(
     ...(inputs.workflowMetadataEntries
       ? { workflowMetadataEntries: inputs.workflowMetadataEntries }
       : {}),
+    ...(inputs.geometry ? { geometry: inputs.geometry } : {}),
+    ...(inputs.layout ? { layout: inputs.layout } : {}),
   });
   return {
     scope,