@beyondwork/docx-react-component 1.0.19 → 1.0.20

package/src/validation/docx-comment-proof.ts

@@ -1,6 +1,8 @@
 import type {
   CompatibilityReport,
   DocumentNavigationSnapshot,
+  FieldSnapshot,
+  ProtectionSnapshot,
   RuntimeRenderSnapshot,
 } from "../api/public-types.ts";
 import { parseCommentsFromOoxml } from "../io/ooxml/parse-comments.ts";
@@ -19,6 +21,32 @@ export interface ClosureValidationContext {
   navigation?: Pick<DocumentNavigationSnapshot, "pages">;
   compatibility: Pick<CompatibilityReport, "errors" | "featureEntries">;
   surface: RuntimeRenderSnapshot["surface"];
+  fieldSnapshot?: FieldSnapshot;
+  protectionSnapshot?: ProtectionSnapshot;
+  harnessShowcase?: HarnessShowcaseValidationContext;
+}
+
+export type HarnessShowcaseArea =
+  | "workflow-overlay"
+  | "blocked-commands"
+  | "preserve-only"
+  | "search-candidates"
+  | "right-rail"
+  | "multi-scope"
+  | "public-api"
+  | "sidebar-integration"
+  | "policy-yaml"
+  | "harness-lifecycle"
+  | "export-continuity";
+
+export interface HarnessShowcaseAreaProof {
+  demonstrated: boolean;
+  detail?: string;
+  proofArtifacts?: string[];
+}
+
+export interface HarnessShowcaseValidationContext {
+  areas: Partial<Record<HarnessShowcaseArea, HarnessShowcaseAreaProof>>;
 }
 
 export type ClosureValidationCheck =
@@ -31,6 +59,31 @@ export type ClosureValidationCheck =
   | { type: "surfaceBlockKind"; kind: string; count?: number }
   | { type: "opaqueBlockLabelPrefix"; value: string }
   | { type: "opaqueInlineLabelPrefix"; value: string }
+  | {
+      type: "trackedChangeMatch";
+      kind?: "insertion" | "deletion" | "formatting" | "move" | "property-change";
+      actionability?: "actionable" | "preserve-only";
+      status?: "active" | "accepted" | "rejected" | "detached";
+      preserveOnlyReasonIncludes?: string[];
+    }
+  | {
+      type: "fieldEntryMatch";
+      fieldFamily?: string;
+      supported?: boolean;
+      refreshStatus?: string;
+      displayTextIncludes?: string[];
+      fieldTarget?: string;
+    }
+  | {
+      type: "protectionMatch";
+      hasDocumentProtection?: boolean;
+      editType?: string;
+      enforcementActive?: boolean;
+      enforcedRangeCountAtLeast?: number;
+      preservedRangeCountAtLeast?: number;
+      rangeId?: string;
+      rangeEnforced?: boolean;
+    }
   | {
       type: "secondaryStoryMatch";
       kind: "header" | "footer" | "footnote" | "endnote";
@@ -59,6 +112,11 @@ export type ClosureValidationCheck =
       entryBodies?: string[];
       entryAuthorIds?: string[];
       authorId?: string;
+    }
+  | {
+      type: "harnessShowcase";
+      area: HarnessShowcaseArea;
+      claim: string;
     };
 
 export interface ClosureValidationResult {
@@ -87,6 +145,28 @@ export interface DocxCommentProof {
   }>;
 }
 
+export function evaluateHarnessShowcaseCheck(
+  check: Extract<ClosureValidationCheck, { type: "harnessShowcase" }>,
+  context: HarnessShowcaseValidationContext,
+): ClosureValidationResult {
+  const areaProof = context.areas[check.area];
+  if (!areaProof) {
+    return {
+      type: check.type,
+      passed: false,
+      reason: `missing harness showcase proof for area ${check.area}: ${check.claim}`,
+    };
+  }
+
+  return {
+    type: check.type,
+    passed: areaProof.demonstrated,
+    reason:
+      areaProof.detail ??
+      `expected harness showcase proof for area ${check.area}: ${check.claim}`,
+  };
+}
+
 export function evaluateClosureCheck(
   check: ClosureValidationCheck,
   context: ClosureValidationContext,
@@ -163,6 +243,87 @@ export function evaluateClosureCheck(
         passed: hasOpaqueInlineLabelPrefix(context.surface, check.value),
         reason: `expected an opaque inline label starting with ${check.value}`,
       };
+    case "trackedChangeMatch": {
+      const passed = context.renderSnapshot.trackedChanges.revisions.some((revision) => {
+        if (check.kind && revision.kind !== check.kind) {
+          return false;
+        }
+        if (check.actionability && revision.actionability !== check.actionability) {
+          return false;
+        }
+        if (check.status && revision.status !== check.status) {
+          return false;
+        }
+        if (
+          check.preserveOnlyReasonIncludes &&
+          !check.preserveOnlyReasonIncludes.every((fragment) =>
+            (revision.preserveOnlyReason ?? "").includes(fragment),
+          )
+        ) {
+          return false;
+        }
+        return true;
+      });
+      return {
+        type: check.type,
+        passed,
+        reason: `expected a tracked change matching ${describeTrackedChangeMatch(check)}`,
+      };
+    }
+    case "fieldEntryMatch": {
+      const passed =
+        context.fieldSnapshot?.fields.some((field) => {
+          if (check.fieldFamily && field.fieldFamily !== check.fieldFamily) {
+            return false;
+          }
+          if (check.supported !== undefined && field.supported !== check.supported) {
+            return false;
+          }
+          if (check.refreshStatus && field.refreshStatus !== check.refreshStatus) {
+            return false;
+          }
+          if (check.fieldTarget && field.fieldTarget !== check.fieldTarget) {
+            return false;
+          }
+          if (
+            check.displayTextIncludes &&
+            !check.displayTextIncludes.every((fragment) => field.displayText.includes(fragment))
+          ) {
+            return false;
+          }
+          return true;
+        }) ?? false;
+      return {
+        type: check.type,
+        passed,
+        reason: `expected a field entry matching ${describeFieldEntryMatch(check)}`,
+      };
+    }
+    case "protectionMatch": {
+      const snapshot = context.protectionSnapshot;
+      const passed = Boolean(
+        snapshot &&
+          (check.hasDocumentProtection === undefined ||
+            snapshot.hasDocumentProtection === check.hasDocumentProtection) &&
+          (check.editType === undefined || snapshot.editType === check.editType) &&
+          (check.enforcementActive === undefined ||
+            snapshot.enforcementActive === check.enforcementActive) &&
+          (check.enforcedRangeCountAtLeast === undefined ||
+            snapshot.enforcedRangeCount >= check.enforcedRangeCountAtLeast) &&
+          (check.preservedRangeCountAtLeast === undefined ||
+            snapshot.preservedRangeCount >= check.preservedRangeCountAtLeast) &&
+          (!check.rangeId ||
+            snapshot.ranges.some((range) =>
+              range.rangeId === check.rangeId &&
+              (check.rangeEnforced === undefined || range.enforced === check.rangeEnforced),
+            ))
+      );
+      return {
+        type: check.type,
+        passed,
+        reason: `expected protection snapshot matching ${describeProtectionMatch(check)}`,
+      };
+    }
     case "secondaryStoryMatch": {
       const passed =
         context.surface?.secondaryStories.some((story) => {
@@ -229,6 +390,8 @@ export function evaluateClosureCheck(
         reason: `expected a comment thread matching ${describeCommentThreadMatch(check)}`,
       };
     }
+    case "harnessShowcase":
+      return evaluateHarnessShowcaseCheck(check, context.harnessShowcase ?? { areas: {} });
     default:
       return {
         type: (check as { type: string }).type,
@@ -364,6 +527,63 @@ function matchesCommentThread(
   return true;
 }
 
+function describeTrackedChangeMatch(
+  check: Extract<ClosureValidationCheck, { type: "trackedChangeMatch" }>,
+): string {
+  return [
+    check.kind ? `kind=${check.kind}` : undefined,
+    check.actionability ? `actionability=${check.actionability}` : undefined,
+    check.status ? `status=${check.status}` : undefined,
+    check.preserveOnlyReasonIncludes?.length
+      ? `preserveOnlyReasonIncludes=${check.preserveOnlyReasonIncludes.join(",")}`
+      : undefined,
+  ]
+    .filter(Boolean)
+    .join(" ");
+}
+
+function describeFieldEntryMatch(
+  check: Extract<ClosureValidationCheck, { type: "fieldEntryMatch" }>,
+): string {
+  return [
+    check.fieldFamily ? `fieldFamily=${check.fieldFamily}` : undefined,
+    check.supported !== undefined ? `supported=${String(check.supported)}` : undefined,
+    check.refreshStatus ? `refreshStatus=${check.refreshStatus}` : undefined,
+    check.fieldTarget ? `fieldTarget=${check.fieldTarget}` : undefined,
+    check.displayTextIncludes?.length
+      ? `displayTextIncludes=${check.displayTextIncludes.join(",")}`
+      : undefined,
+  ]
+    .filter(Boolean)
+    .join(" ");
+}
+
+function describeProtectionMatch(
+  check: Extract<ClosureValidationCheck, { type: "protectionMatch" }>,
+): string {
+  return [
+    check.hasDocumentProtection !== undefined
+      ? `hasDocumentProtection=${String(check.hasDocumentProtection)}`
+      : undefined,
+    check.editType ? `editType=${check.editType}` : undefined,
+    check.enforcementActive !== undefined
+      ? `enforcementActive=${String(check.enforcementActive)}`
+      : undefined,
+    check.enforcedRangeCountAtLeast !== undefined
+      ? `enforcedRangeCountAtLeast=${String(check.enforcedRangeCountAtLeast)}`
+      : undefined,
+    check.preservedRangeCountAtLeast !== undefined
+      ? `preservedRangeCountAtLeast=${String(check.preservedRangeCountAtLeast)}`
+      : undefined,
+    check.rangeId ? `rangeId=${check.rangeId}` : undefined,
+    check.rangeEnforced !== undefined
+      ? `rangeEnforced=${String(check.rangeEnforced)}`
+      : undefined,
+  ]
+    .filter(Boolean)
+    .join(" ");
+}
+
 function getLayoutsForCheck(
   context: ClosureValidationContext,
   check: Extract<ClosureValidationCheck, { type: "pageLayoutMatch" }>,