@beyondwork/docx-react-component 1.0.28 → 1.0.30

package/src/model/canonical-document.ts

@@ -90,11 +90,17 @@ export interface ParagraphStyleDefinition {
   basedOn?: string;
   nextStyle?: string;
   outlineLevel?: number;
+  numbering?: ParagraphStyleNumberingReference;
   displayName: string;
   kind: "paragraph";
   isDefault: boolean;
 }
 
+export interface ParagraphStyleNumberingReference {
+  numberingInstanceId: string;
+  level?: number;
+}
+
 export interface CharacterStyleDefinition {
   styleId: string;
   basedOn?: string;
@@ -109,6 +115,8 @@ export interface TableStyleDefinition {
   displayName: string;
   kind: "table";
   isDefault: boolean;
+  formatting?: TableStyleFormatting;
+  conditionalFormatting?: Partial<Record<TableStyleConditionalRegion, TableStyleFormatting>>;
 }
 
 export interface LatentStyleDefinition {
@@ -130,6 +138,13 @@ export interface AbstractNumberingDefinition {
   levels: NumberingLevelDefinition[];
 }
 
+export interface NumberingLevelParagraphGeometry {
+  justification?: "left" | "center" | "right" | "both" | "distribute";
+  spacing?: ParagraphSpacing;
+  indentation?: ParagraphIndentation;
+  tabStops?: TabStop[];
+}
+
 export interface NumberingLevelDefinition {
   level: number;
   format: string;
@@ -138,6 +153,18 @@ export interface NumberingLevelDefinition {
   paragraphStyleId?: string;
   isLegalNumbering?: boolean;
   suffix?: "tab" | "space" | "nothing";
+  paragraphGeometry?: NumberingLevelParagraphGeometry;
+}
+
+export interface NumberingLevelOverrideDefinition {
+  level: number;
+  format?: string;
+  text?: string;
+  startAt?: number;
+  paragraphStyleId?: string;
+  isLegalNumbering?: boolean;
+  suffix?: "tab" | "space" | "nothing";
+  paragraphGeometry?: NumberingLevelParagraphGeometry;
 }
 
 export interface NumberingInstance {
@@ -149,6 +176,7 @@ export interface NumberingInstance {
 export interface NumberingLevelOverride {
   level: number;
   startAt?: number;
+  levelDefinition?: NumberingLevelOverrideDefinition;
 }
 
 export interface MediaCatalog {
@@ -303,7 +331,7 @@ export interface ParagraphIndentation {
 
 export interface TabStop {
   position: number;
-  align: "left" | "center" | "right" | "decimal" | "bar" | "clear";
+  align: "left" | "center" | "right" | "decimal" | "num" | "bar" | "clear";
   leader?: "none" | "dot" | "hyphen" | "underscore" | "heavy" | "middleDot";
 }
 
@@ -400,6 +428,37 @@ export interface TableLook {
   noVBand?: boolean;
 }
 
+export type TableStyleConditionalRegion =
+  | "firstRow"
+  | "lastRow"
+  | "firstColumn"
+  | "lastColumn"
+  | "band1Horz"
+  | "band2Horz"
+  | "band1Vert"
+  | "band2Vert";
+
+export interface TableStyleFormatting {
+  table?: {
+    width?: TableWidth;
+    alignment?: "left" | "center" | "right";
+    borders?: TableBorders;
+    cellMargins?: TableCellMargins;
+    tblLook?: TableLook;
+  };
+  row?: {
+    height?: number;
+    heightRule?: "auto" | "atLeast" | "exact";
+    isHeader?: boolean;
+  };
+  cell?: {
+    width?: TableWidth;
+    borders?: TableCellBorders;
+    shading?: CellShading;
+    verticalAlign?: "top" | "center" | "bottom";
+  };
+}
+
 export interface TableNode {
   type: "table";
   styleId?: string;
@@ -476,6 +535,7 @@ export interface CustomXmlNode {
   type: "custom_xml";
   uri?: string;
   element?: string;
+  rawXml?: string;
   children: BlockNode[];
 }
 
@@ -935,6 +995,8 @@ export interface CommentThreadMetadata {
   source?: "runtime" | "import";
   rootOoxmlCommentId?: string;
   rootParaId?: string;
+  detachedReason?: "incomplete-markers" | "multi-paragraph" | "opaque-region" | "revision-overlap";
+  actionabilityNote?: string;
 }
 
 export interface RevisionPropertyChangeData {
@@ -945,6 +1007,7 @@ export interface RevisionPropertyChangeData {
 export interface RevisionMoveData {
   moveId: string;
   direction: "from" | "to";
+  linkedRevisionId?: string;
 }
 
 export type RevisionStoryTargetRecord =
@@ -979,6 +1042,17 @@ export interface RevisionMetadataRecord {
   source?: "runtime" | "import";
   storyTarget?: RevisionStoryTargetRecord;
   preserveOnlyReason?: string;
+  suggestionId?: string;
+  semanticKind?:
+    | "insertion"
+    | "deletion"
+    | "replacement"
+    | "formatting-change"
+    | "paragraph-property-change"
+    | "structural-change"
+    | "object-change";
+  linkedRevisionIds?: string[];
+  predecessorSuggestionId?: string;
   importedRevisionForm?:
     | "run-insertion"
     | "run-deletion"
@@ -1909,6 +1983,9 @@ function validateRevisionMetadata(
   }
   for (const field of [
     "preserveOnlyReason",
+    "suggestionId",
+    "semanticKind",
+    "predecessorSuggestionId",
     "importedRevisionForm",
     "originalRevisionType",
     "ooxmlRevisionId",
@@ -1918,6 +1995,19 @@ function validateRevisionMetadata(
     }
   }
 
+  if (record.linkedRevisionIds !== undefined) {
+    if (!Array.isArray(record.linkedRevisionIds)) {
+      issues.push({
+        path: `${path}.linkedRevisionIds`,
+        message: "linkedRevisionIds must be an array of strings.",
+      });
+    } else {
+      for (const [index, value] of record.linkedRevisionIds.entries()) {
+        expectString(value, `${path}.linkedRevisionIds.${index}`, issues);
+      }
+    }
+  }
+
   if (record.propertyChangeData !== undefined) {
     const pcd = asPlainObject(record.propertyChangeData, `${path}.propertyChangeData`, issues);
     if (pcd) {

package/src/model/snapshot.ts

@@ -98,6 +98,30 @@ export interface PersistedSourcePackage {
   bytesBase64: Base64;
 }
 
+export interface PersistedWorkflowMetadataDefinition {
+  metadataId: string;
+  kind: string;
+  label: string;
+  color?: string;
+  icon?: string;
+  persistence: "runtime-only" | "session" | "document-metadata";
+}
+
+export interface PersistedWorkflowMetadataEntry {
+  entryId: string;
+  metadataId: string;
+  anchor: Record<string, unknown>;
+  storyTarget?: Record<string, unknown>;
+  value?: Record<string, unknown>;
+  scopeId?: string;
+  workItemId?: string;
+}
+
+export interface PersistedWorkflowMetadataSnapshot {
+  definitions: PersistedWorkflowMetadataDefinition[];
+  entries: PersistedWorkflowMetadataEntry[];
+}
+
 export interface PersistedEditorSnapshot {
   snapshotVersion: PersistedEditorSnapshotVersion;
   schemaVersion: typeof CDS_SCHEMA_VERSION;
@@ -112,6 +136,7 @@ export interface PersistedEditorSnapshot {
   warningLog: EditorWarning[];
   protectionSnapshot?: ProtectionSnapshotRecord;
   sourcePackage?: PersistedSourcePackage;
+  workflowMetadata?: PersistedWorkflowMetadataSnapshot;
 }
 
 const SNAPSHOT_REQUIRED_TOP_LEVEL_KEYS = [
@@ -128,7 +153,7 @@ const SNAPSHOT_REQUIRED_TOP_LEVEL_KEYS = [
   "warningLog",
 ] as const;
 
-const SNAPSHOT_OPTIONAL_TOP_LEVEL_KEYS = ["sourcePackage", "protectionSnapshot"] as const;
+const SNAPSHOT_OPTIONAL_TOP_LEVEL_KEYS = ["sourcePackage", "protectionSnapshot", "workflowMetadata"] as const;
 
 export interface ProtectionRangeRecord {
   rangeId: string;
@@ -283,6 +308,9 @@ export function validatePersistedEditorSnapshot(
   if (record.protectionSnapshot !== undefined) {
     validateProtectionSnapshot(record.protectionSnapshot, "$.protectionSnapshot", issues);
   }
+  if (record.workflowMetadata !== undefined) {
+    validateWorkflowMetadataSnapshot(record.workflowMetadata, "$.workflowMetadata", issues);
+  }
 
   return issues;
 }
@@ -614,6 +642,89 @@ function validateProtectionSnapshot(
   }
 }
 
+function validateWorkflowMetadataSnapshot(
+  value: unknown,
+  path: string,
+  issues: ModelValidationIssue[],
+): void {
+  const record = asPlainObject(value, path, issues);
+  if (!record) {
+    return;
+  }
+  if (!Array.isArray(record.definitions)) {
+    issues.push({ path: `${path}.definitions`, message: "definitions must be an array." });
+  } else {
+    record.definitions.forEach((definition, index) =>
+      validateWorkflowMetadataDefinition(definition, `${path}.definitions[${index}]`, issues),
+    );
+  }
+  if (!Array.isArray(record.entries)) {
+    issues.push({ path: `${path}.entries`, message: "entries must be an array." });
+  } else {
+    record.entries.forEach((entry, index) =>
+      validateWorkflowMetadataEntry(entry, `${path}.entries[${index}]`, issues),
+    );
+  }
+}
+
+function validateWorkflowMetadataDefinition(
+  value: unknown,
+  path: string,
+  issues: ModelValidationIssue[],
+): void {
+  const record = asPlainObject(value, path, issues);
+  if (!record) {
+    return;
+  }
+  expectString(record.metadataId, `${path}.metadataId`, issues);
+  expectString(record.kind, `${path}.kind`, issues);
+  expectString(record.label, `${path}.label`, issues);
+  if (record.color !== undefined) {
+    expectString(record.color, `${path}.color`, issues);
+  }
+  if (record.icon !== undefined) {
+    expectString(record.icon, `${path}.icon`, issues);
+  }
+  if (
+    record.persistence !== "runtime-only" &&
+    record.persistence !== "session" &&
+    record.persistence !== "document-metadata"
+  ) {
+    issues.push({
+      path: `${path}.persistence`,
+      message: "persistence must be runtime-only, session, or document-metadata.",
+    });
+  }
+}
+
+function validateWorkflowMetadataEntry(
+  value: unknown,
+  path: string,
+  issues: ModelValidationIssue[],
+): void {
+  const record = asPlainObject(value, path, issues);
+  if (!record) {
+    return;
+  }
+  expectString(record.entryId, `${path}.entryId`, issues);
+  expectString(record.metadataId, `${path}.metadataId`, issues);
+  if (!asPlainObject(record.anchor, `${path}.anchor`, issues)) {
+    return;
+  }
+  if (record.storyTarget !== undefined) {
+    asPlainObject(record.storyTarget, `${path}.storyTarget`, issues);
+  }
+  if (record.value !== undefined) {
+    asPlainObject(record.value, `${path}.value`, issues);
+  }
+  if (record.scopeId !== undefined) {
+    expectString(record.scopeId, `${path}.scopeId`, issues);
+  }
+  if (record.workItemId !== undefined) {
+    expectString(record.workItemId, `${path}.workItemId`, issues);
+  }
+}
+
 function validateProtectionRange(
   value: unknown,
   path: string,

package/src/preservation/store.ts

@@ -1,4 +1,5 @@
 import type {
+  BlockNode,
   DocRange,
   OpaqueFragmentRecord,
   PreservationStore,
@@ -21,6 +22,11 @@ export interface OpaqueFragmentDescriptor {
   detail: string;
 }
 
+const BLOCKED_IMPORT_FEATURE_KEYS = new Set<OpaqueFragmentDescriptor["featureKey"]>([
+  "alt-chunk",
+  "custom-xml",
+]);
+
 export function createPreservationStore(
   seed?: Partial<PreservationStore>,
 ): PreservationStore {
@@ -122,16 +128,18 @@ export function describeOpaqueFragment(
   if (/\b(?:w:)?altChunk\b/u.test(xml)) {
     return {
       featureKey: "alt-chunk",
-      label: "Alternate content import",
+      label: "AltChunk import",
       detail,
     };
   }
 
   if (/\b(?:w:)?object\b|\b(?:o:)?OLEObject\b/u.test(xml)) {
+    const isOleObject = /\b(?:o:)?OLEObject\b/u.test(xml);
+    const label = isOleObject ? "OLE embedded object" : "Embedded object";
     return {
       featureKey: "embedded-objects",
-      label: "Embedded object",
-      detail,
+      label,
+      detail: `${detail} Preserve-only embedded object retained for export and Word reopen.`,
     };
   }
 
@@ -150,6 +158,54 @@ export function describeOpaqueFragment(
   };
 }
 
+export function describeStructuredWrapperBlock(
+  block: BlockNode,
+): OpaqueFragmentDescriptor | null {
+  if (block.type === "sdt") {
+    if (isTocContentControl(block)) {
+      return {
+        featureKey: "content-controls",
+        label: "TOC content control",
+        detail: "TOC content control remains a wrapper-heavy template structure and read-only.",
+      };
+    }
+    if (block.properties.sdtType === "docPartObj") {
+      return {
+        featureKey: "content-controls",
+        label: "Template content control",
+        detail: "Template content control remains a wrapper-heavy document part and read-only.",
+      };
+    }
+  }
+
+  if (block.type === "custom_xml") {
+    const descriptor = [block.element, block.uri].filter(Boolean).join(" ");
+    return {
+      featureKey: "custom-xml",
+      label: "Custom XML wrapper",
+      detail: descriptor.length > 0
+        ? `Custom XML wrapper ${descriptor} remains package-backed and read-only.`
+        : "Custom XML wrapper remains package-backed and read-only.",
+    };
+  }
+
+  if (block.type === "alt_chunk") {
+    return {
+      featureKey: "alt-chunk",
+      label: "AltChunk import",
+      detail: `AltChunk import remains package-backed and blocked through relationship ${block.relationshipId}.`,
+    };
+  }
+
+  return null;
+}
+
+export function isBlockedImportFeatureKey(
+  featureKey: OpaqueFragmentDescriptor["featureKey"],
+): boolean {
+  return BLOCKED_IMPORT_FEATURE_KEYS.has(featureKey);
+}
+
 function createDetail(fragment: OpaqueFragmentRecord): string {
   const detail = [
     `Preserved whole-unit from ${fragment.lastKnownRange.from}-${fragment.lastKnownRange.to}.`,
@@ -164,6 +220,20 @@ function createDetail(fragment: OpaqueFragmentRecord): string {
     : "Preserved whole-unit to keep unsupported OOXML intact.";
 }
 
+function isTocContentControl(block: Extract<BlockNode, { type: "sdt" }>): boolean {
+  const searchText = [
+    block.properties.alias,
+    block.properties.tag,
+    block.properties.sdtType,
+    block.properties.propertiesXml,
+  ]
+    .filter(Boolean)
+    .join(" ")
+    .toLowerCase();
+
+  return searchText.includes("table of contents") || /\btoc\b/u.test(searchText);
+}
+
 function rangesIntersect(left: DocRange, right: DocRange): boolean {
   return left.from < right.to && right.from < left.to;
 }

package/src/review/store/comment-store.ts

@@ -45,6 +45,8 @@ export interface CommentThreadMetadata {
   source?: "runtime" | "import";
   rootOoxmlCommentId?: string;
   rootParaId?: string;
+  detachedReason?: "incomplete-markers" | "multi-paragraph" | "opaque-region" | "revision-overlap";
+  actionabilityNote?: string;
 }
 
 export interface CommentStore {
@@ -261,6 +263,7 @@ function toSidebarThread(
 ): CommentSidebarThread {
   const firstEntry = thread.entries[0];
   const anchorSummary = summarizeCommentAnchor(thread.anchor);
+  const detachedReason = thread.metadata?.detachedReason;
 
   return {
     commentId: thread.commentId,
@@ -272,7 +275,9 @@ function toSidebarThread(
     warningCount: thread.warningIds.length,
     anchorLabel:
       anchorSummary.state === "detached"
-        ? `Detached ${anchorSummary.range.from}-${anchorSummary.range.to}`
+        ? detachedReason
+          ? `Detached (${humanizeDetachedReason(detachedReason)}) ${anchorSummary.range.from}-${anchorSummary.range.to}`
+          : `Detached ${anchorSummary.range.from}-${anchorSummary.range.to}`
         : `Range ${anchorSummary.range.from}-${anchorSummary.range.to}`,
     isActive: activeCommentId === thread.commentId,
     resolvedAt: thread.resolution?.resolvedAt,
@@ -310,6 +315,19 @@ function compareSidebarThreads(
   return left.createdAt.localeCompare(right.createdAt);
 }
 
+function humanizeDetachedReason(reason: NonNullable<CommentThreadMetadata["detachedReason"]>): string {
+  switch (reason) {
+    case "incomplete-markers":
+      return "incomplete markers";
+    case "multi-paragraph":
+      return "multi-paragraph";
+    case "opaque-region":
+      return "opaque region";
+    case "revision-overlap":
+      return "revision overlap";
+  }
+}
+
 function priorityForStatus(status: CommentThreadStatus): number {
   switch (status) {
     case "open":

package/src/review/store/revision-actions.ts

@@ -98,6 +98,23 @@ export function applyRevisionAction(
     );
   }
 
+  if (canResolveImportedDeletionWithoutContentMutation(revision, options.intent)) {
+    const resultingStatus = toResultingStatus(options.intent);
+    return {
+      document: options.document,
+      store: setRevisionStatus(options.store, revision.revisionId, resultingStatus),
+      mapping: createEmptyMapping(),
+      outcome: {
+        kind: "applied",
+        revisionId: revision.revisionId,
+        intent: options.intent,
+        resultingStatus,
+        contentChanged: false,
+      },
+      detachedRevisionIds: [],
+    };
+  }
+
   const story = parseTextStory(options.document.content);
   const range = normalizeRange(
     revision.anchor.range.from,
@@ -270,6 +287,18 @@ function requiresContentDeletion(
   );
 }
 
+function canResolveImportedDeletionWithoutContentMutation(
+  revision: RevisionRecord,
+  intent: RevisionActionIntent,
+): boolean {
+  return (
+    revision.kind === "deletion" &&
+    intent === "accept" &&
+    revision.metadata.source === "import" &&
+    revision.metadata.originalRevisionType !== "paragraph-del"
+  );
+}
+
 function requiresParagraphBoundaryDeletion(
   revision: RevisionRecord,
   intent: RevisionActionIntent,

package/src/review/store/revision-store.ts

@@ -87,6 +87,10 @@ export function createRevisionRecord(
         (getRevisionActionability(params.kind) === "preserve-only"
           ? "Imported preserve-only revision."
           : undefined),
+      suggestionId: params.metadata?.suggestionId,
+      semanticKind: params.metadata?.semanticKind,
+      linkedRevisionIds: params.metadata?.linkedRevisionIds,
+      predecessorSuggestionId: params.metadata?.predecessorSuggestionId,
       importedRevisionForm: params.metadata?.importedRevisionForm,
       originalRevisionType: params.metadata?.originalRevisionType,
       ooxmlRevisionId: params.metadata?.ooxmlRevisionId,
@@ -220,7 +224,14 @@ function toSidebarEntry(revision: RevisionRecord): RevisionSidebarEntry {
   return {
     revisionId: revision.revisionId,
     kind: revision.kind,
-    label: describeRevisionKind(revision.kind),
+    label:
+      revision.kind === "move"
+        ? moveData?.direction === "from"
+          ? "Move from"
+          : moveData?.direction === "to"
+            ? "Move to"
+            : describeRevisionKind(revision.kind)
+        : describeRevisionKind(revision.kind),
     status: revision.status,
     actionability,
     anchorLabel:

package/src/review/store/revision-types.ts

@@ -36,6 +36,17 @@ export interface RevisionMetadataEnvelope {
   source: "runtime" | "import";
   storyTarget?: RevisionStoryTargetRecord;
   preserveOnlyReason?: string;
+  suggestionId?: string;
+  semanticKind?:
+    | "insertion"
+    | "deletion"
+    | "replacement"
+    | "formatting-change"
+    | "paragraph-property-change"
+    | "structural-change"
+    | "object-change";
+  linkedRevisionIds?: string[];
+  predecessorSuggestionId?: string;
   importedRevisionForm?:
     | "run-insertion"
     | "run-deletion"