@beyondwork/docx-react-component 1.0.42 → 1.0.45

package/src/core/commands/index.ts

@@ -31,6 +31,7 @@ import {
   insertHardBreak,
   insertTab,
   insertText,
+  outdentParagraphAtSelection,
   splitParagraph,
 } from "./text-commands.ts";
 import type { RevisionRecord as CanonicalRevisionRecord } from "../../model/canonical-document.ts";
@@ -128,6 +129,10 @@ export type EditorCommand =
       type: "text.insert-tab";
       origin?: CommandOrigin;
     }
+  | {
+      type: "text.outdent-tab";
+      origin?: CommandOrigin;
+    }
   | {
       type: "text.insert-hard-break";
       origin?: CommandOrigin;
@@ -367,7 +372,7 @@ export interface TransactionEffects {
   commentAdded?: { commentId: string; anchor: EditorAnchorProjection };
   commentResolved?: { commentId: string };
   commentReopened?: { commentId: string };
-  commentReplyAdded?: { commentId: string };
+  commentReplyAdded?: { commentId: string; entryId: string };
   commentBodyEdited?: { commentId: string };
   changeAccepted?: { changeId: string };
   changeRejected?: { changeId: string };
@@ -513,6 +518,26 @@ export function executeEditorCommand(
         insertTab(document, selection, context),
       );
     }
+    case "text.outdent-tab": {
+      // No suggesting-mode branch: outdent is a paragraph-format change, not a
+      // text-content change, so it bypasses the suggesting/track-changes pipeline.
+      // (If a tracked-changes test fails, copy the suggesting branch from
+      // text.insert-tab.)
+      //
+      // We use `buildDocumentReplaceTransaction` (not `applyTextCommand`) so the
+      // no-op cases — already at zero indent or list paragraph — skip the
+      // transaction entirely and do not bump revisionToken. This matches the
+      // pattern used by the formatting-indent path.
+      const result = outdentParagraphAtSelection(state.document, state.selection, {
+        timestamp: context.timestamp,
+      });
+      return buildDocumentReplaceTransaction(state, context, {
+        changed: result.changed,
+        document: result.document,
+        selection: result.selection,
+        mapping: result.mapping,
+      });
+    }
     case "text.insert-hard-break": {
       const suggestingResult = context.documentMode === "suggesting"
         ? applySuggestingInsertUnit(state, "hard_break", context)
@@ -785,7 +810,7 @@ export function executeEditorCommand(
         {
           historyBoundary: "push",
           markDirty: true,
-          effects: { commentReplyAdded: { commentId: command.commentId } },
+          effects: { commentReplyAdded: { commentId: command.commentId, entryId } },
         },
       );
     }
@@ -1791,22 +1816,46 @@ function combineMappingSteps(
 // Suggesting mode: creates revision records instead of (or alongside) text mutations
 // ---------------------------------------------------------------------------
 
-let suggestingRevisionCounter = 0;
-
+/**
+ * Builds a suggesting-mode revision id that is deterministic across
+ * clients. The id is a pure function of `(existing, timestamp, authorId)`
+ * so that origin and replica — both of whom see the same `existing`
+ * revisions record after a Yjs-ordered replay and receive the same
+ * `timestamp` + `authorId` on the broadcast command event — produce
+ * the same id for the same authored revision.
+ *
+ * Previously this used a module-level counter; that counter was shared
+ * across every `DocumentRuntime` in a single process and drifted between
+ * origin and replica whenever either side had other suggesting-mode work
+ * bump the counter before replay. Cross-client `change.accept(changeId)`
+ * / `change.reject(changeId)` then missed because the target id only
+ * existed on one side.
+ */
 function createSuggestingRevisionId(
   existing: Record<string, unknown>,
   timestamp: string,
+  authorId: string,
 ): string {
-  suggestingRevisionCounter += 1;
   const ts = timestamp.replace(/[^0-9]/gu, "");
-  let id = `change-${ts}-s${suggestingRevisionCounter}`;
+  const authorMarker = sanitizeAuthorMarker(authorId);
+  const prefix = `change-${authorMarker}-${ts}-s`;
+  let n = 1;
+  let id = `${prefix}${n}`;
   while (existing[id]) {
-    suggestingRevisionCounter += 1;
-    id = `change-${ts}-s${suggestingRevisionCounter}`;
+    n += 1;
+    id = `${prefix}${n}`;
   }
   return id;
 }
 
+function sanitizeAuthorMarker(authorId: string): string {
+  // OOXML `w:id` accepts alphanumerics plus `._-`; keep within that set so
+  // the id survives round-trips unchanged (see `sanitizeRevisionId` on the
+  // serializer side).
+  const cleaned = authorId.replace(/[^A-Za-z0-9._-]/g, "-");
+  return cleaned.length > 0 ? cleaned : "u";
+}
+
 function createAuthoredRevision(
   existing: Record<string, unknown>,
   kind: "insertion" | "deletion",
@@ -1816,7 +1865,7 @@ function createAuthoredRevision(
   timestamp: string,
   metadata: Partial<NonNullable<CanonicalRevisionRecord["metadata"]>> = {},
 ): CanonicalRevisionRecord {
-  const changeId = createSuggestingRevisionId(existing, timestamp);
+  const changeId = createSuggestingRevisionId(existing, timestamp, authorId);
   return {
     changeId,
     kind,
@@ -2066,6 +2115,7 @@ function applySuggestingInsert(
   const replacementSuggestionId = createSuggestingRevisionId(
     reviewState.document.review.revisions,
     context.timestamp,
+    authorId,
   );
 
   // Step 3: Create deletion revision for the selected range (text stays in place).
@@ -2324,7 +2374,7 @@ function applySuggestingInsertUnit(
     result.mapping,
   );
   const replacementSuggestionId = from !== to
-    ? createSuggestingRevisionId(reviewState.document.review.revisions, context.timestamp)
+    ? createSuggestingRevisionId(reviewState.document.review.revisions, context.timestamp, authorId)
     : undefined;
 
   // If non-collapsed, mark selected range as deletion (positions are pre-mapping, content preserved)

package/src/core/commands/text-commands.ts

@@ -23,6 +23,8 @@ import {
   resolveParagraphScope,
   type StructuralMutationResult,
 } from "./structural-helpers.ts";
+import { applyIndentation } from "./formatting-commands.ts";
+import { createEmptyMapping, type TransactionMapping } from "../selection/mapping.ts";
 import { createEditorSurfaceSnapshot } from "../../runtime/surface-projection.ts";
 
 export interface TextCommandContext {
@@ -197,6 +199,63 @@ export function insertTab(
   );
 }
 
+/**
+ * Reduce the active paragraph's left indent by one half-inch step (720 twips).
+ * Mirrors Word's Shift+Tab behavior on a non-list paragraph.
+ *
+ * Defensive list-check: if the paragraph carries `numbering`, this is a no-op —
+ * list-level changes are owned by the list-aware dispatcher in
+ * `src/runtime/edit-dispatch/list-aware-dispatch.ts`, which intercepts before
+ * we are called. The runtime command itself never mutates list level.
+ *
+ * No text positions change, so `mapping` is empty and the selection is preserved.
+ */
+export function outdentParagraphAtSelection(
+  document: CanonicalDocumentEnvelope,
+  selection: SelectionSnapshot,
+  context: TextCommandContext,
+): {
+  changed: boolean;
+  document: CanonicalDocumentEnvelope;
+  selection: SelectionSnapshot;
+  mapping: TransactionMapping;
+} {
+  const noop = {
+    changed: false,
+    document,
+    selection,
+    mapping: createEmptyMapping(),
+  };
+
+  const scope = resolveParagraphScope(document, selection);
+  if (!scope) {
+    return noop;
+  }
+
+  // Defensive: list paragraphs are owned by the list-aware dispatcher.
+  if (scope.paragraph.numbering) {
+    return noop;
+  }
+
+  // `resolveParagraphScope` already returns a cloned paragraph, so it is
+  // safe to mutate in place.
+  const changed = applyIndentation(scope.paragraph, -1);
+  if (!changed) {
+    return noop;
+  }
+
+  const nextDocument = replaceParagraphScope(document, scope, [scope.paragraph]);
+  return {
+    changed: true,
+    document: {
+      ...nextDocument,
+      updatedAt: context.timestamp,
+    },
+    selection,
+    mapping: createEmptyMapping(),
+  };
+}
+
 export function insertHardBreak(
   document: CanonicalDocumentEnvelope,
   selection: SelectionSnapshot,

package/src/core/search/search-text.ts

@@ -26,7 +26,7 @@ export interface SecondaryStorySearchResult extends SurfaceSearchResult {
   storyTarget: EditorStoryTarget;
 }
 
-interface ProjectedSurfaceText {
+export interface ProjectedSurfaceText {
   text: string;
   offsetMap: Array<number | null>;
 }
@@ -112,7 +112,20 @@ export function searchSurfaceBlocks(
   query: string,
   options: SearchTextOptions = {},
 ): SurfaceSearchResult[] {
-  const projection = projectSurfaceText(blocks);
+  return searchProjectedSurfaceText(projectSurfaceText(blocks), query, options);
+}
+
+/**
+ * Search a pre-projected surface text. Hoist `projectSurfaceText(blocks)` out
+ * of a per-query loop to avoid rebuilding the projection N times for N queries
+ * against the same surface — L7 Phase 1.5 discovered this cost dominates
+ * `collectFieldMarkup` on the CCEP large-tables fixture.
+ */
+export function searchProjectedSurfaceText(
+  projection: ProjectedSurfaceText,
+  query: string,
+  options: SearchTextOptions = {},
+): SurfaceSearchResult[] {
   return findSearchMatches(projection.text, query, options)
     .map((match) => {
       const range = resolveProjectedRuntimeRange(

package/src/core/selection/review-anchors.ts

@@ -116,12 +116,61 @@ export function canCreateDocxCommentAnchor(
     return false;
   }
 
-  return rangeStaysWithinSingleParagraph(content, normalized);
+  return rangeStaysWithinCommentableStory(content, normalized);
+}
+
+export function rangeStaysWithinCommentableStory(
+  content: unknown,
+  range: DocRange,
+): boolean {
+  const normalized = normalizeRange(range);
+  if (normalized.from === normalized.to) {
+    return false;
+  }
+
+  const surfaceBlocks = readSurfaceBlocks(content);
+  if (surfaceBlocks) {
+    const fromOwner = findContainingParagraphForEndpoint(surfaceBlocks, normalized.from, "start");
+    const toOwner = findContainingParagraphForEndpoint(surfaceBlocks, normalized.to, "end");
+    if (!fromOwner || !toOwner) {
+      return false;
+    }
+    if (fromOwner.tableId !== toOwner.tableId) {
+      return false;
+    }
+    if (fromOwner.tableCellId !== toOwner.tableCellId) {
+      return false;
+    }
+    return !rangeCrossesOpaqueOrTableBoundary(
+      surfaceBlocks,
+      normalized,
+      fromOwner,
+    );
+  }
+
+  const story = parseTextStory(content);
+  const upperBound = Math.min(normalized.to, story.units.length);
+  for (let index = Math.max(0, normalized.from); index < upperBound; index += 1) {
+    const unit = story.units[index];
+    if (!unit) continue;
+    if (unit.kind === "opaque_block") {
+      return false;
+    }
+  }
+  return true;
+}
+
+interface FlattenedSurfaceBlock {
+  kind: string;
+  from: number;
+  to: number;
+  tableId: string | null;
+  tableCellId: string | null;
 }
 
 function readSurfaceBlocks(
   content: unknown,
-): Array<{ kind: string; from: number; to: number }> | undefined {
+): FlattenedSurfaceBlock[] | undefined {
   if (!content || typeof content !== "object" || !("blocks" in content)) {
     return undefined;
   }
@@ -131,17 +180,19 @@ function readSurfaceBlocks(
     return undefined;
   }
 
-  const normalized = flattenSurfaceBlocks(blocks);
+  const normalized = flattenSurfaceBlocks(blocks, null, null);
 
   return normalized.length > 0 ? normalized : undefined;
 }
 
 function flattenSurfaceBlocks(
   blocks: unknown[],
-): Array<{ kind: string; from: number; to: number }> {
-  const flattened: Array<{ kind: string; from: number; to: number }> = [];
+  tableId: string | null,
+  tableCellId: string | null,
+): FlattenedSurfaceBlock[] {
+  const flattened: FlattenedSurfaceBlock[] = [];
 
-  for (const block of blocks) {
+  for (const [blockIndex, block] of blocks.entries()) {
     if (
       !block ||
       typeof block !== "object" ||
@@ -152,32 +203,91 @@ function flattenSurfaceBlocks(
       continue;
     }
 
-    flattened.push({
-      kind: (block as { kind: string }).kind,
-      from: (block as { from: number }).from,
-      to: (block as { to: number }).to,
-    });
+    const kind = (block as { kind: string }).kind;
+    const from = (block as { from: number }).from;
+    const to = (block as { to: number }).to;
 
-    if (
-      (block as { kind: string }).kind === "table" &&
-      Array.isArray((block as { rows?: unknown }).rows)
-    ) {
-      for (const row of (block as { rows: Array<{ cells?: unknown[] }> }).rows) {
-        for (const cell of row.cells ?? []) {
+    flattened.push({ kind, from, to, tableId, tableCellId });
+
+    if (kind === "table" && Array.isArray((block as { rows?: unknown }).rows)) {
+      const nextTableId =
+        (block as { blockId?: string }).blockId ?? `table-${from}-${to}-${blockIndex}`;
+      const rows = (block as { rows: Array<{ cells?: unknown[] }> }).rows;
+      for (const [rowIdx, row] of rows.entries()) {
+        for (const [cellIdx, cell] of (row.cells ?? []).entries()) {
           if (cell && typeof cell === "object" && Array.isArray((cell as { content?: unknown[] }).content)) {
-            flattened.push(...flattenSurfaceBlocks((cell as { content: unknown[] }).content));
+            const cellFingerprint = `${nextTableId}-r${rowIdx}-c${cellIdx}`;
+            flattened.push(
+              ...flattenSurfaceBlocks(
+                (cell as { content: unknown[] }).content,
+                nextTableId,
+                cellFingerprint,
+              ),
+            );
           }
         }
       }
     }
 
     if (
-      (block as { kind: string }).kind === "sdt_block" &&
-      Array.isArray((block as { children?: unknown[] }).children)
+      kind === "sdt_block" &&
+      Array.isArray((block as { children?: unknown }).children)
     ) {
-      flattened.push(...flattenSurfaceBlocks((block as { children: unknown[] }).children));
+      flattened.push(
+        ...flattenSurfaceBlocks(
+          (block as { children: unknown[] }).children,
+          tableId,
+          tableCellId,
+        ),
+      );
     }
   }
 
   return flattened;
 }
+
+function findContainingParagraphForEndpoint(
+  blocks: readonly FlattenedSurfaceBlock[],
+  offset: number,
+  kind: "start" | "end",
+): FlattenedSurfaceBlock | null {
+  const matches = blocks.filter(
+    (block) =>
+      block.kind === "paragraph" && offset >= block.from && offset <= block.to,
+  );
+  if (matches.length === 0) return null;
+  if (matches.length === 1) return matches[0]!;
+  // When an offset sits exactly on a paragraph boundary it matches the
+  // trailing paragraph as well as the leading one. For a start endpoint we
+  // prefer the later paragraph (the range extends forward from it); for an
+  // end endpoint we prefer the earlier paragraph (the range ends there).
+  if (kind === "start") {
+    return matches.reduce((a, b) => (b.from >= a.from ? b : a));
+  }
+  return matches.reduce((a, b) => (b.to <= a.to ? b : a));
+}
+
+function rangeCrossesOpaqueOrTableBoundary(
+  blocks: readonly FlattenedSurfaceBlock[],
+  range: DocRange,
+  origin: FlattenedSurfaceBlock,
+): boolean {
+  for (const block of blocks) {
+    const overlapFrom = Math.max(block.from, range.from);
+    const overlapTo = Math.min(block.to, range.to);
+    if (overlapTo <= overlapFrom) continue;
+
+    if (block.kind === "opaque_block") {
+      return true;
+    }
+
+    if (
+      block.kind === "paragraph" &&
+      (block.tableId !== origin.tableId ||
+        block.tableCellId !== origin.tableCellId)
+    ) {
+      return true;
+    }
+  }
+  return false;
+}

package/src/index.ts

@@ -13,7 +13,7 @@ export { ISSUE_METADATA_ID, REVIEW_ACTION_METADATA_ID } from "./api/public-types
 // P17 — metadata persistence error class.
 export { MetadataResolverMissingError } from "./api/public-types.ts";
 
-// Collab substrate (P1 – P8f + P14). See docs/plans/collab-master-plan.md
+// Collab substrate (P1 – P8f + P14). See docs/plans/lane-4-collab-clm-vallor.md
 // for the shipped-slice table. Surfaces are stable for host integration;
 // the chrome preset + markdown renderer land in P9 / P10.
 export { createCollabSession } from "./runtime/collab-session.ts";
@@ -121,6 +121,7 @@ export type {
   LoadSourcePolicy,
   EditorSessionState,
   EditorHostAdapter,
+  ChartPreviewResolveParams,
   WordReviewEditorProps,
   WordReviewEditorChromePreset,
   WordReviewEditorChromeOptions,
@@ -185,6 +186,8 @@ export type {
   SnapshotRefreshChangeKind,
   SnapshotRefreshHints,
   AddCommentParams,
+  AddCommentResult,
+  AddCommentReplyResult,
   ExportDocxOptions,
   ExportResult,
   AutosaveConfig,
@@ -267,4 +270,29 @@ export type {
   ScopeMetadataPersistence,
   ScopeMetadataResolver,
   ScopeMetadataStorageRef,
+  // Schema 1.2 — editor-state persistence types
+  EditorStateNamespace,
+  EditorStateLocation,
+  EditorStateResolveErrorMode,
+  EditorStatePolicyEntry,
+  EditorStatePolicy,
+  EditorStateStorageRef,
+  EditorStateBlob,
+  EditorStateResolver,
+  EditorStatePersister,
+  EditorStatePolicyMigration,
+  EditorStatePartLoadFailure,
+  EditorStatePartPersistFailure,
 } from "./api/public-types.ts";
+
+// L7 Phase 2.5 — prerender cache public API. Platforms / ingest workers
+// call `prerenderDocument(buffer)` on template upload to populate the
+// cache; end-user opens read the cache and skip the layout pass. See
+// docs/plans/lane-2-render-performance.md §Phase 2.5.
+export { prerenderDocument } from "./runtime/prerender/prerender-document.ts";
+export type {
+  PrerenderOptions,
+  PrerenderResult,
+  PrerenderCounters,
+} from "./runtime/prerender/prerender-document.ts";
+export type { CacheEnvelope } from "./runtime/prerender/cache-envelope.ts";