@beyondwork/docx-react-component 1.0.57 → 1.0.59

package/src/runtime/query-scopes.ts

@@ -0,0 +1,183 @@
+import type {
+  EditorStoryTarget,
+  ScopeQueryFilter,
+  ScopeQueryResult,
+  WorkflowMetadataEntry,
+  WorkflowOverlay,
+  WorkflowScope,
+  WorkflowWorkItem,
+} from "../api/public-types.ts";
+import type { CanonicalDocument } from "../model/canonical-document.ts";
+import type { CanonicalDocumentEnvelope } from "../core/state/editor-state.ts";
+import { collectScopeLocations } from "./scope-resolver.ts";
+
+function storyTargetsEqual(a: EditorStoryTarget, b: EditorStoryTarget): boolean {
+  if (a.kind !== b.kind) return false;
+  switch (a.kind) {
+    case "main":
+      return true;
+    case "header":
+    case "footer":
+      return (
+        a.relationshipId === (b as typeof a).relationshipId &&
+        a.variant === (b as typeof a).variant &&
+        a.sectionIndex === (b as typeof a).sectionIndex
+      );
+    case "footnote":
+    case "endnote":
+      return a.noteId === (b as typeof a).noteId;
+  }
+}
+
+const MAIN_STORY: EditorStoryTarget = { kind: "main" };
+
+export interface ScopeQueryInputs {
+  readonly overlay: WorkflowOverlay | null;
+  readonly entries: readonly WorkflowMetadataEntry[];
+  readonly document: Pick<CanonicalDocument, "content"> | CanonicalDocumentEnvelope;
+}
+
+/**
+ * Phase C §C2 helper — project an ordered list of scopeIds (already produced
+ * by a geometric walk like `findAllScopesAt` / `findScopesIntersecting`)
+ * into `ScopeQueryResult[]`. Preserves incoming order. Filters out scopeIds
+ * that are not in the overlay (e.g. orphan markers). Applies the §C8
+ * visibility filter via `includeHidden` / `includeInvisible`.
+ */
+export function projectScopeQueryResults(
+  inputs: ScopeQueryInputs,
+  scopeIds: readonly string[],
+  options: { includeHidden?: boolean; includeInvisible?: boolean } = {},
+): ScopeQueryResult[] {
+  const overlay = inputs.overlay;
+  if (!overlay) return [];
+  const includeHidden = options.includeHidden === true;
+  const includeInvisible = options.includeInvisible === true;
+
+  const scopesById = new Map<string, WorkflowScope>();
+  for (const scope of overlay.scopes) scopesById.set(scope.scopeId, scope);
+
+  const entriesByScope = new Map<string, WorkflowMetadataEntry[]>();
+  for (const entry of inputs.entries) {
+    if (!entry.scopeId) continue;
+    let list = entriesByScope.get(entry.scopeId);
+    if (!list) {
+      list = [];
+      entriesByScope.set(entry.scopeId, list);
+    }
+    list.push(entry);
+  }
+
+  const workItemsById = new Map<string, WorkflowWorkItem>();
+  for (const item of overlay.workItems ?? []) {
+    workItemsById.set(item.workItemId, item);
+  }
+
+  const results: ScopeQueryResult[] = [];
+  for (const scopeId of scopeIds) {
+    const scope = scopesById.get(scopeId);
+    if (!scope) 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
+      : null;
+    results.push({ scope, entries, workItem });
+  }
+  return results;
+}
+
+/**
+ * Pure §C1 projector — filter + join scopes with entries + workItem, ordered
+ * by start-marker document position (scopeId ASC tiebreak). Snapshot-based;
+ * no runtime state mutation.
+ */
+export function queryScopes(
+  inputs: ScopeQueryInputs,
+  filter: ScopeQueryFilter | undefined,
+): ScopeQueryResult[] {
+  const overlay = inputs.overlay;
+  if (!overlay) return [];
+
+  const normalizedStoryFilter = filter?.storyTarget ?? MAIN_STORY;
+  const workItemIdSet = filter?.workItemIds ? new Set(filter.workItemIds) : null;
+  const modeSet = filter?.modes ? new Set(filter.modes) : null;
+  const domainSet = filter?.domains ? new Set(filter.domains) : null;
+  const labelPrefix = filter?.labelPrefix?.toLowerCase();
+  const metadataId = filter?.metadataId;
+  const hasValue = filter?.hasValue;
+  const limit = filter?.limit;
+  const includeHidden = filter?.includeHidden === true;
+  const includeInvisible = filter?.includeInvisible === true;
+
+  const entriesByScope = new Map<string, WorkflowMetadataEntry[]>();
+  for (const entry of inputs.entries) {
+    if (!entry.scopeId) continue;
+    let list = entriesByScope.get(entry.scopeId);
+    if (!list) {
+      list = [];
+      entriesByScope.set(entry.scopeId, list);
+    }
+    list.push(entry);
+  }
+
+  const workItemsById = new Map<string, WorkflowWorkItem>();
+  for (const item of overlay.workItems ?? []) {
+    workItemsById.set(item.workItemId, item);
+  }
+
+  const locations = collectScopeLocations(inputs.document);
+
+  const candidates: Array<{ scope: WorkflowScope; startPos: number }> = [];
+  for (const scope of overlay.scopes) {
+    // §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;
+      if (!storyTargetsEqual(scopeStory, normalizedStoryFilter)) continue;
+    }
+    if (modeSet && !modeSet.has(scope.mode)) continue;
+    if (domainSet && !(scope.domain && domainSet.has(scope.domain))) continue;
+    if (workItemIdSet) {
+      if (!scope.workItemId || !workItemIdSet.has(scope.workItemId)) continue;
+    }
+    if (labelPrefix) {
+      const label = scope.label?.toLowerCase() ?? "";
+      if (!label.startsWith(labelPrefix)) continue;
+    }
+
+    const scopeEntries = entriesByScope.get(scope.scopeId) ?? [];
+
+    if (metadataId && !scopeEntries.some((e) => e.metadataId === metadataId)) continue;
+    if (hasValue) {
+      const anyMatch = scopeEntries.some(
+        (e) => e.value !== undefined && hasValue(e.value, e),
+      );
+      if (!anyMatch) continue;
+    }
+
+    const loc = locations.get(scope.scopeId);
+    const startPos =
+      loc?.startPos ?? loc?.endPos ?? Number.POSITIVE_INFINITY;
+    candidates.push({ scope, startPos });
+  }
+
+  candidates.sort((a, b) => {
+    if (a.startPos !== b.startPos) return a.startPos - b.startPos;
+    return a.scope.scopeId < b.scope.scopeId ? -1 : a.scope.scopeId > b.scope.scopeId ? 1 : 0;
+  });
+
+  const results: ScopeQueryResult[] = [];
+  for (const { scope } of candidates) {
+    if (limit !== undefined && results.length >= limit) break;
+    const entries = entriesByScope.get(scope.scopeId) ?? [];
+    const workItem = scope.workItemId
+      ? workItemsById.get(scope.workItemId) ?? null
+      : null;
+    results.push({ scope, entries, workItem });
+  }
+  return results;
+}

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/scope-resolver.ts

@@ -146,3 +146,63 @@ export function findScopeAt(
   }
   return best;
 }
+
+/**
+ * Phase C §C2 — every enclosing scope at `position`, ordered outermost →
+ * innermost (lowest startPos first; ties broken on scopeId ASC). Includes
+ * scopes that touch the position exactly (`startPos <= position <= endPos`).
+ * Companion to `findScopeAt`, which keeps the innermost-only contract.
+ */
+export function findAllScopesAt(
+  document: Pick<CanonicalDocument, "content"> | CanonicalDocumentEnvelope,
+  position: number,
+): ResolvedScopeLocation[] {
+  const locations = collectScopeLocations(document);
+  const hits: ResolvedScopeLocation[] = [];
+  for (const [scopeId, loc] of locations) {
+    if (loc.startPos === undefined || loc.endPos === undefined) continue;
+    if (position < loc.startPos || position > loc.endPos) continue;
+    hits.push({ scopeId, startPos: loc.startPos, endPos: loc.endPos });
+  }
+  hits.sort((a, b) => {
+    if (a.startPos !== b.startPos) return a.startPos - b.startPos;
+    return a.scopeId < b.scopeId ? -1 : a.scopeId > b.scopeId ? 1 : 0;
+  });
+  return hits;
+}
+
+/**
+ * Phase C §C2 — every scope whose marker range intersects `[rangeFrom,
+ * rangeTo]`. `mode: "overlap"` (default) accepts any intersection including
+ * touching endpoints; `mode: "contain"` requires the scope's entire marker
+ * range to lie within `[rangeFrom, rangeTo]`. Deterministic order: startPos
+ * ASC, scopeId ASC.
+ */
+export function findScopesIntersecting(
+  document: Pick<CanonicalDocument, "content"> | CanonicalDocumentEnvelope,
+  rangeFrom: number,
+  rangeTo: number,
+  mode: "overlap" | "contain" = "overlap",
+): ResolvedScopeLocation[] {
+  const from = Math.min(rangeFrom, rangeTo);
+  const to = Math.max(rangeFrom, rangeTo);
+  const locations = collectScopeLocations(document);
+  const hits: ResolvedScopeLocation[] = [];
+  for (const [scopeId, loc] of locations) {
+    if (loc.startPos === undefined || loc.endPos === undefined) continue;
+    const sFrom = Math.min(loc.startPos, loc.endPos);
+    const sTo = Math.max(loc.startPos, loc.endPos);
+    if (mode === "contain") {
+      if (sFrom < from || sTo > to) continue;
+    } else {
+      // overlap — any intersection including touching endpoints
+      if (sTo < from || sFrom > to) continue;
+    }
+    hits.push({ scopeId, startPos: loc.startPos, endPos: loc.endPos });
+  }
+  hits.sort((a, b) => {
+    if (a.startPos !== b.startPos) return a.startPos - b.startPos;
+    return a.scopeId < b.scopeId ? -1 : a.scopeId > b.scopeId ? 1 : 0;
+  });
+  return hits;
+}

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;
   }