@beyondwork/docx-react-component 1.0.58 → 1.0.60

package/src/runtime/query-scopes.ts

@@ -1,4 +1,5 @@
 import type {
+  EditorAnchorProjection,
   EditorStoryTarget,
   ScopeQueryFilter,
   ScopeQueryResult,
@@ -31,10 +32,97 @@ function storyTargetsEqual(a: EditorStoryTarget, b: EditorStoryTarget): boolean
 
 const MAIN_STORY: EditorStoryTarget = { kind: "main" };
 
+function workflowAnchorsEqual(
+  left: EditorAnchorProjection,
+  right: EditorAnchorProjection,
+): boolean {
+  if (left.kind !== right.kind) return false;
+  switch (left.kind) {
+    case "range":
+      return (
+        right.kind === "range" &&
+        left.from === right.from &&
+        left.to === right.to &&
+        left.assoc.start === right.assoc.start &&
+        left.assoc.end === right.assoc.end
+      );
+    case "node":
+      return right.kind === "node" && left.at === right.at;
+    case "detached":
+      return (
+        right.kind === "detached" &&
+        left.reason === right.reason &&
+        left.lastKnownRange.from === right.lastKnownRange.from &&
+        left.lastKnownRange.to === right.lastKnownRange.to
+      );
+    default:
+      return false;
+  }
+}
+
+function buildScopeIdCounts(overlay: WorkflowOverlay): Map<string, number> {
+  const counts = new Map<string, number>();
+  for (const scope of overlay.scopes) {
+    counts.set(scope.scopeId, (counts.get(scope.scopeId) ?? 0) + 1);
+  }
+  return counts;
+}
+
+function normalizeScopeAnchor(
+  scope: WorkflowScope,
+  scopeIdCounts: ReadonlyMap<string, number>,
+  locations: ReadonlyMap<string, { startPos?: number; endPos?: number }>,
+  markerBackedScopeIds: ReadonlySet<string>,
+): WorkflowScope {
+  if ((scopeIdCounts.get(scope.scopeId) ?? 0) !== 1) {
+    return scope;
+  }
+
+  const location = locations.get(scope.scopeId);
+  let nextAnchor: EditorAnchorProjection | null = null;
+  if (
+    location &&
+    location.startPos !== undefined &&
+    location.endPos !== undefined
+  ) {
+    nextAnchor = {
+      kind: "range",
+      from: Math.min(location.startPos, location.endPos),
+      to: Math.max(location.startPos, location.endPos),
+      assoc: { start: -1, end: 1 },
+    };
+  } else if (markerBackedScopeIds.has(scope.scopeId)) {
+    const lastKnownRange =
+      scope.anchor.kind === "range"
+        ? { from: scope.anchor.from, to: scope.anchor.to }
+        : scope.anchor.kind === "node"
+          ? { from: scope.anchor.at, to: scope.anchor.at }
+          : scope.anchor.lastKnownRange;
+    nextAnchor = {
+      kind: "detached",
+      reason:
+        location && (location.startPos !== undefined || location.endPos !== undefined)
+          ? "deleted"
+          : "invalidatedByStructureChange",
+      lastKnownRange,
+    };
+  } else {
+    return scope;
+  }
+
+  return workflowAnchorsEqual(scope.anchor, nextAnchor)
+    ? scope
+    : {
+        ...scope,
+        anchor: nextAnchor,
+      };
+}
+
 export interface ScopeQueryInputs {
   readonly overlay: WorkflowOverlay | null;
   readonly entries: readonly WorkflowMetadataEntry[];
   readonly document: Pick<CanonicalDocument, "content"> | CanonicalDocumentEnvelope;
+  readonly markerBackedScopeIds?: ReadonlySet<string>;
 }
 
 /**
@@ -53,9 +141,17 @@ export function projectScopeQueryResults(
   if (!overlay) return [];
   const includeHidden = options.includeHidden === true;
   const includeInvisible = options.includeInvisible === true;
+  const scopeIdCounts = buildScopeIdCounts(overlay);
+  const locations = collectScopeLocations(inputs.document);
+  const markerBackedScopeIds = inputs.markerBackedScopeIds ?? new Set<string>();
 
   const scopesById = new Map<string, WorkflowScope>();
-  for (const scope of overlay.scopes) scopesById.set(scope.scopeId, scope);
+  for (const scope of overlay.scopes) {
+    scopesById.set(
+      scope.scopeId,
+      normalizeScopeAnchor(scope, scopeIdCounts, locations, markerBackedScopeIds),
+    );
+  }
 
   const entriesByScope = new Map<string, WorkflowMetadataEntry[]>();
   for (const entry of inputs.entries) {
@@ -77,9 +173,8 @@ export function projectScopeQueryResults(
   for (const scopeId of scopeIds) {
     const scope = scopesById.get(scopeId);
     if (!scope) continue;
-    const visibility = (scope as WorkflowScope & { visibility?: string }).visibility;
-    if (visibility === "hidden" && !includeHidden) continue;
-    if (visibility === "invisible" && !includeInvisible) continue;
+    if (scope.visibility === "hidden" && !includeHidden) continue;
+    if (scope.visibility === "invisible" && !includeInvisible) continue;
     const entries = entriesByScope.get(scopeId) ?? [];
     const workItem = scope.workItemId
       ? workItemsById.get(scope.workItemId) ?? null
@@ -129,14 +224,14 @@ export function queryScopes(
   }
 
   const locations = collectScopeLocations(inputs.document);
+  const scopeIdCounts = buildScopeIdCounts(overlay);
+  const markerBackedScopeIds = inputs.markerBackedScopeIds ?? new Set<string>();
 
   const candidates: Array<{ scope: WorkflowScope; startPos: number }> = [];
   for (const scope of overlay.scopes) {
-    // §C8 pre-wire: respect visibility flags. Visibility field itself lands
-    // in §C8; treating missing as "visible" keeps this forward-compatible.
-    const visibility = (scope as WorkflowScope & { visibility?: string }).visibility;
-    if (visibility === "hidden" && !includeHidden) continue;
-    if (visibility === "invisible" && !includeInvisible) continue;
+    // §C8: respect visibility flags. Missing field treated as "visible".
+    if (scope.visibility === "hidden" && !includeHidden) continue;
+    if (scope.visibility === "invisible" && !includeInvisible) continue;
 
     if (normalizedStoryFilter !== "*") {
       const scopeStory = scope.storyTarget ?? MAIN_STORY;
@@ -165,7 +260,10 @@ export function queryScopes(
     const loc = locations.get(scope.scopeId);
     const startPos =
       loc?.startPos ?? loc?.endPos ?? Number.POSITIVE_INFINITY;
-    candidates.push({ scope, startPos });
+    candidates.push({
+      scope: normalizeScopeAnchor(scope, scopeIdCounts, locations, markerBackedScopeIds),
+      startPos,
+    });
   }
 
   candidates.sort((a, b) => {

package/src/runtime/resolved-numbering-geometry.ts

@@ -199,8 +199,24 @@ function resolveNumberingGeometry(
   paragraph: Pick<ParagraphNode, "spacing" | "indentation" | "tabStops"> | undefined,
   levelRunProperties: CanonicalRunFormatting | undefined,
 ): ResolvedNumberingGeometry {
+  // LibreOffice SyncIndentWithList pattern: when a numbered paragraph's w:ind has
+  // hanging === left (e.g. left=851 hanging=851), it is a stale Word-written snapshot
+  // meaning "no custom indent beyond the list style" — use level geometry directly.
+  // This also covers the prior CO3.8 heuristic (para.left === level.left) since Word
+  // typically writes hanging=left in that situation too.
+  const paraInd = paragraph?.indentation;
+  const levelInd = levelGeometry?.indentation;
+  const isDegenerateParaInd =
+    paraInd !== undefined &&
+    paraInd.hanging !== undefined &&
+    paraInd.left !== undefined &&
+    paraInd.hanging === paraInd.left;
+
+  const indentation = isDegenerateParaInd
+    ? levelInd ? { ...levelInd } : undefined
+    : mergeParagraphIndentation(levelInd, paraInd);
+
   const spacing = mergeParagraphSpacing(levelGeometry?.spacing, paragraph?.spacing);
-  const indentation = mergeParagraphIndentation(levelGeometry?.indentation, paragraph?.indentation);
   const tabStops = paragraph?.tabStops?.length
     ? cloneTabStops(paragraph.tabStops)
     : levelGeometry?.tabStops?.length
@@ -244,12 +260,27 @@ function mergeParagraphIndentation(
     return undefined;
   }
 
-  const indentation: ParagraphIndentation = {
-    ...(base ?? {}),
-    ...(override ?? {}),
-  };
+  const out: ParagraphIndentation = {};
+
+  const left = override?.left ?? base?.left;
+  if (left !== undefined) out.left = left;
+
+  const right = override?.right ?? base?.right;
+  if (right !== undefined) out.right = right;
+
+  // ECMA-376 §17.3.1.12: firstLine and hanging are mutually exclusive on a single
+  // w:ind element. When override specifies either, it wins exclusively.
+  const overrideTouchesFLorH =
+    override?.firstLine !== undefined || override?.hanging !== undefined;
+  if (overrideTouchesFLorH) {
+    if (override?.hanging !== undefined) out.hanging = override.hanging;
+    else if (override?.firstLine !== undefined) out.firstLine = override.firstLine;
+  } else {
+    if (base?.hanging !== undefined) out.hanging = base.hanging;
+    else if (base?.firstLine !== undefined) out.firstLine = base.firstLine;
+  }
 
-  return Object.keys(indentation).length > 0 ? indentation : undefined;
+  return Object.keys(out).length > 0 ? out : undefined;
 }
 
 function cloneTabStops(tabStops: readonly TabStop[]): TabStop[] {

package/src/runtime/revision-runtime.ts

@@ -37,10 +37,12 @@ export interface RevisionRuntimeCommandResult extends RevisionRuntimeState {
 export function applyRevisionRuntimeCommand(
   options: ApplyRevisionRuntimeCommandOptions,
 ): RevisionRuntimeCommandResult {
-  const revisionIds = isSingleRevisionReviewCommand(options.command)
+  const rawRevisionIds = isSingleRevisionReviewCommand(options.command)
     ? [options.command.revisionId]
     : listBatchRevisionIds(options.state.store);
 
+  const revisionIds = expandLinkedMovePartners(rawRevisionIds, options.state.store);
+
   const outcomes: RevisionActionOutcome[] = [];
   const mappings: Array<{ revisionId: string; mapping: TransactionMapping; steps: number }> = [];
   const appliedRevisionIds: string[] = [];
@@ -92,6 +94,30 @@ export function applyRevisionRuntimeCommand(
   };
 }
 
+function expandLinkedMovePartners(
+  revisionIds: readonly string[],
+  store: RevisionStore,
+): string[] {
+  const expanded = new Set<string>(revisionIds);
+  for (const revisionId of revisionIds) {
+    const revision = store.revisions[revisionId];
+    const partner = revision?.metadata.moveData?.linkedRevisionId;
+    if (!partner) {
+      continue;
+    }
+    const partnerRevision = store.revisions[partner];
+    // Only pull the partner in if it's still eligible. Partners that have
+    // already been accepted/rejected/detached don't belong in the
+    // current-intent batch — adding them would surface a cosmetic
+    // "already-resolved" skip in `effects.skippedRevisions` that the user
+    // never targeted.
+    if (partnerRevision && partnerRevision.status === "active") {
+      expanded.add(partner);
+    }
+  }
+  return [...expanded];
+}
+
 function listBatchRevisionIds(store: RevisionStore): string[] {
   return Object.values(store.revisions)
     .filter((revision) => revision.status === "active")

package/src/runtime/selection/post-edit-validator.ts

@@ -1,5 +1,14 @@
 import type { CanonicalDocumentEnvelope } from "../../core/state/editor-state.ts";
 import type { SelectionSnapshot } from "../../core/state/editor-state.ts";
+import type {
+  EditorSurfaceSnapshot,
+  SurfaceBlockSnapshot,
+  SurfaceInlineSegment,
+} from "../../api/public-types.ts";
+
+export interface SelectionValidationOptions {
+  isValidNodeTarget?: (at: number) => boolean;
+}
 
 /**
  * Snap a selection to a valid position relative to the document.
@@ -16,9 +25,9 @@ import type { SelectionSnapshot } from "../../core/state/editor-state.ts";
  * POST-mutation `surface.storySize`, primed via
  * `getCachedSurface(state.document, activeStory).storySize`).
  *
- * NodeAnchor invalidation is deferred until CanonicalDocumentEnvelope
- * grows an O(1) node-by-id accessor.  Until then, NodeAnchor selections
- * are returned unchanged (identity).
+ * NodeAnchor invalidation stays caller-driven: pass a cheap node-target probe
+ * when the caller already has the post-mutation surface. Without that probe,
+ * NodeAnchor selections are returned unchanged (identity).
  *
  * @param document   The post-mutation canonical document.  Currently
  *                   unused except for the deferred NodeAnchor branch;
@@ -42,11 +51,28 @@ export function validateSelectionAgainstDocument(
   document: CanonicalDocumentEnvelope,
   selection: SelectionSnapshot,
   maxOffset: number,
+  options?: SelectionValidationOptions,
 ): SelectionSnapshot {
   if (selection.activeRange.kind === "node") {
-    // Deferred: NodeAnchor invalidation requires an O(1) node-by-id
-    // accessor on CanonicalDocumentEnvelope.  Until that lands, return
-    // identity so we never falsely invalidate a still-valid node anchor.
+    if (
+      options?.isValidNodeTarget &&
+      !options.isValidNodeTarget(selection.activeRange.at)
+    ) {
+      const collapsed = clamp(selection.activeRange.at, 0, maxOffset);
+      return {
+        anchor: collapsed,
+        head: collapsed,
+        isCollapsed: true,
+        activeRange: {
+          kind: "range",
+          range: { from: collapsed, to: collapsed },
+          assoc: {
+            start: selection.activeRange.assoc,
+            end: selection.activeRange.assoc,
+          },
+        },
+      };
+    }
     return selection;
   }
 
@@ -75,3 +101,31 @@ export function validateSelectionAgainstDocument(
 function clamp(n: number, lo: number, hi: number): number {
   return n < lo ? lo : n > hi ? hi : n;
 }
+
+export function createSurfaceNodeSelectionProbe(
+  surface: EditorSurfaceSnapshot,
+): (at: number) => boolean {
+  return (at) => surface.blocks.some((block) => blockHasNodeTarget(block, at));
+}
+
+function blockHasNodeTarget(block: SurfaceBlockSnapshot, at: number): boolean {
+  switch (block.kind) {
+    case "paragraph":
+      return block.segments.some((segment) => isNodeSelectableSegment(segment) && segment.from === at);
+    case "table":
+      return (
+        block.from === at ||
+        block.rows.some((row) =>
+          row.cells.some((cell) => cell.content.some((child) => blockHasNodeTarget(child, at))),
+        )
+      );
+    case "sdt_block":
+      return block.from === at || block.children.some((child) => blockHasNodeTarget(child, at));
+    case "opaque_block":
+      return block.from === at;
+  }
+}
+
+function isNodeSelectableSegment(segment: SurfaceInlineSegment): boolean {
+  return segment.kind !== "text" && segment.kind !== "tab" && segment.kind !== "hard_break";
+}

package/src/runtime/structure-ops/index.ts

@@ -25,7 +25,11 @@ import type {
 import type { StructuralMutationResult } from "../../core/commands/structural-helpers.ts";
 import type { TextCommandContext } from "../../core/commands/text-commands.ts";
 import { countLogicalPositions, parseTextStory } from "../../core/schema/text-schema.ts";
-import { validateSelectionAgainstDocument } from "../selection/post-edit-validator.ts";
+import { createEditorSurfaceSnapshot } from "../surface-projection.ts";
+import {
+  createSurfaceNodeSelectionProbe,
+  validateSelectionAgainstDocument,
+} from "../selection/post-edit-validator.ts";
 import { applyFragmentInsert } from "./fragment-insert.ts";
 
 export interface StructureLayer {
@@ -58,9 +62,21 @@ function validateResult(result: StructuralMutationResult): StructuralMutationRes
   if (!result.changed) {
     return result;
   }
-  const story = parseTextStory(result.document.content);
-  const maxOffset = countLogicalPositions(story.units);
-  const validated = validateSelectionAgainstDocument(result.document, result.selection, maxOffset);
+  const surface = result.selection.activeRange.kind === "node"
+    ? createEditorSurfaceSnapshot(result.document, result.selection)
+    : null;
+  const options = surface
+    ? { isValidNodeTarget: createSurfaceNodeSelectionProbe(surface) }
+    : undefined;
+  const maxOffset = surface
+    ? surface.storySize
+    : countLogicalPositions(parseTextStory(result.document.content).units);
+  const validated = validateSelectionAgainstDocument(
+    result.document,
+    result.selection,
+    maxOffset,
+    options,
+  );
   if (validated === result.selection) {
     return result;
   }