@beyondwork/docx-react-component 1.0.31 → 1.0.32

package/src/io/ooxml/workflow-payload.ts

@@ -4,9 +4,13 @@ import type {
   OpcRelationship,
 } from "./part-manifest.ts";
 import type {
+  EditorAnchorProjection,
+  WorkflowOverlay,
   WorkflowMetadataDefinition,
   WorkflowMetadataEntry,
   WorkflowMetadataSnapshot,
+  WorkflowScope,
+  WorkflowWorkItem,
 } from "../../api/public-types.ts";
 
 export const WORKFLOW_PAYLOAD_PART_PATH = "/customXml/item1.xml";
@@ -17,6 +21,8 @@ export const WORKFLOW_PAYLOAD_ITEM_PROPS_CONTENT_TYPE =
   "application/vnd.openxmlformats-officedocument.customXmlProperties+xml";
 export const WORKFLOW_PAYLOAD_CUSTOM_PROPS_CONTENT_TYPE =
   "application/vnd.openxmlformats-officedocument.custom-properties+xml";
+export const WORKFLOW_PAYLOAD_RELATIONSHIP_TYPE =
+  "http://schemas.openxmlformats.org/officeDocument/2006/relationships/customXml";
 export const WORKFLOW_PAYLOAD_ITEM_PROPS_RELATIONSHIP_TYPE =
   "http://schemas.openxmlformats.org/officeDocument/2006/relationships/customXmlProps";
 export const WORKFLOW_PAYLOAD_CUSTOM_PROPS_RELATIONSHIP_TYPE =
@@ -30,6 +36,11 @@ type EmbeddedWorkflowPayloadDescriptor = {
   itemPropsPartPath: string;
 };
 
+export interface WorkflowPayloadEnvelope {
+  workflowMetadata: WorkflowMetadataSnapshot;
+  workflowOverlay?: WorkflowOverlay;
+}
+
 export function getDocumentBackedWorkflowMetadata(
   snapshot: WorkflowMetadataSnapshot | undefined,
 ): WorkflowMetadataSnapshot {
@@ -51,6 +62,7 @@ export function getDocumentBackedWorkflowMetadata(
 export function buildWorkflowPayloadParts(input: {
   sourcePackage: OpcPackage;
   workflowMetadata: WorkflowMetadataSnapshot | undefined;
+  workflowOverlay?: WorkflowOverlay;
   documentId: string;
   createdAt: string;
   updatedAt: string;
@@ -65,7 +77,20 @@ export function buildWorkflowPayloadParts(input: {
   descriptor: EmbeddedWorkflowPayloadDescriptor;
 } | null {
   const workflowMetadata = getDocumentBackedWorkflowMetadata(input.workflowMetadata);
-  if (workflowMetadata.definitions.length === 0 && workflowMetadata.entries.length === 0) {
+  const existingPayloadPartPath = resolvePayloadPartPath(input.sourcePackage);
+  const existingPayloadEnvelope = existingPayloadPartPath
+    ? parseWorkflowPayloadEnvelopeFromPackage(input.sourcePackage)
+    : undefined;
+  const sourceHasRuntimeOwnedPayloadContent = Boolean(
+    existingPayloadEnvelope?.workflowOverlay ||
+      (existingPayloadEnvelope?.workflowMetadata.definitions.length ?? 0) > 0,
+  );
+  if (
+    workflowMetadata.definitions.length === 0 &&
+    workflowMetadata.entries.length === 0 &&
+    !input.workflowOverlay &&
+    !sourceHasRuntimeOwnedPayloadContent
+  ) {
     return null;
   }
 
@@ -76,6 +101,8 @@ export function buildWorkflowPayloadParts(input: {
     updatedAt: input.updatedAt,
     producerVersion: input.producerVersion,
     workflowMetadata,
+    workflowOverlay: input.workflowOverlay,
+    preservedExtensionsXml: getPreservedExtensionsXml(input.sourcePackage, descriptor.payloadPartPath),
   });
   const itemPropsXml = buildItemPropsXml(descriptor.itemId);
   const customPropertiesXml = buildCustomPropertiesXml(descriptor, workflowMetadata, input.sourcePackage);
@@ -101,6 +128,12 @@ export function buildWorkflowPayloadParts(input: {
 export function parseWorkflowPayloadFromPackage(
   sourcePackage: OpcPackage,
 ): WorkflowMetadataSnapshot | undefined {
+  return parseWorkflowPayloadEnvelopeFromPackage(sourcePackage)?.workflowMetadata;
+}
+
+export function parseWorkflowPayloadEnvelopeFromPackage(
+  sourcePackage: OpcPackage,
+): WorkflowPayloadEnvelope | undefined {
   const payloadPartPath = resolvePayloadPartPath(sourcePackage);
   if (!payloadPartPath) {
     return undefined;
@@ -120,6 +153,7 @@ export function parseWorkflowPayloadFromPackage(
     if (!attributes.key) {
       continue;
     }
+
     if (attributes.key.startsWith("definition.")) {
       const metadataId = attributes.key.replace(/^definition\./, "");
       const kind = attributes.ns ?? "tag-category";
@@ -133,7 +167,7 @@ export function parseWorkflowPayloadFromPackage(
         label,
         ...(attributes.source ? { color: attributes.source } : {}),
         ...(attributes.status ? { icon: attributes.status } : {}),
-        persistence: "document-metadata",
+        persistence: "document-metadata" as const,
       });
       continue;
     }
@@ -153,10 +187,10 @@ export function parseWorkflowPayloadFromPackage(
       entryId,
       metadataId,
       anchor: {
-        kind: "range",
+        kind: "range" as const,
         from: 0,
         to: 0,
-        assoc: { start: -1, end: 1 },
+        assoc: { start: -1 as const, end: 1 as const },
       },
       storyTarget: parseWorkflowStoryTarget(attributes),
       value: parseWorkflowMetadataValue(payloadText, attributes.valueType),
@@ -168,8 +202,11 @@ export function parseWorkflowPayloadFromPackage(
   }
 
   return {
-    definitions,
-    entries,
+    workflowMetadata: {
+      definitions,
+      entries,
+    },
+    workflowOverlay: parseWorkflowOverlay(xml),
   };
 }
 
@@ -179,6 +216,8 @@ function buildPayloadXml(input: {
   updatedAt: string;
   producerVersion: string;
   workflowMetadata: WorkflowMetadataSnapshot;
+  workflowOverlay?: WorkflowOverlay;
+  preservedExtensionsXml: string;
 }): string {
   const definitionEntriesXml = input.workflowMetadata.definitions
     .map((definition) => [
@@ -212,6 +251,11 @@ function buildPayloadXml(input: {
     .filter((value) => value.length > 0)
     .join("\n");
 
+  const workblockXml = buildWorkblockExtensionXml(input.workflowOverlay);
+  const extensionsXml = [workblockXml, input.preservedExtensionsXml]
+    .filter((value) => value.trim().length > 0)
+    .join("\n");
+
   return [
     `<?xml version="1.0" encoding="UTF-8"?>`,
     `<bw:workflowPayload xmlns:bw="urn:beyondwork:workflow-payload:1" version="1.0" payloadId="${escapeXml(input.descriptor.payloadId)}" itemId="${escapeXml(input.descriptor.itemId)}" documentId="${escapeXml(input.descriptor.documentId)}" createdAt="${escapeXml(input.createdAt)}" updatedAt="${escapeXml(input.updatedAt)}">`,
@@ -223,7 +267,9 @@ function buildPayloadXml(input: {
     definitionEntriesXml ? indentLines(definitionEntriesXml, 4) : "",
     metadataEntriesXml ? indentLines(metadataEntriesXml, 4) : "",
     `  </bw:metadata>`,
-    `  <bw:extensions />`,
+    extensionsXml
+      ? `  <bw:extensions>\n${indentLines(extensionsXml, 4)}\n  </bw:extensions>`
+      : `  <bw:extensions />`,
     `</bw:workflowPayload>`,
   ].filter((line) => line.length > 0).join("\n");
 }
@@ -283,6 +329,129 @@ function buildCustomProperty(pid: number, name: string, value: string): string {
   return `  <property fmtid="{D5CDD505-2E9C-101B-9397-08002B2CF9AE}" pid="${pid}" name="${escapeXml(name)}"><vt:lpwstr>${escapeXml(value)}</vt:lpwstr></property>`;
 }
 
+function buildWorkblockExtensionXml(workflowOverlay: WorkflowOverlay | undefined): string {
+  if (!workflowOverlay) {
+    return "";
+  }
+  const workItemsXml = (workflowOverlay.workItems ?? [])
+    .map((workItem) => [
+      `<bw:workItem`,
+      ` id="${escapeXml(workItem.workItemId)}"`,
+      ` title="${escapeXml(workItem.title)}"`,
+      workItem.status ? ` status="${escapeXml(workItem.status)}"` : "",
+      workItem.domain ? ` domain="${escapeXml(workItem.domain)}"` : "",
+      `>`,
+      workItem.scopeIds.map((scopeId) => `  <bw:scopeRef ref="${escapeXml(scopeId)}" />`).join("\n"),
+      `</bw:workItem>`,
+    ].join(""))
+    .join("\n");
+  const scopesXml = workflowOverlay.scopes
+    .map((scope) => buildWorkflowScopeXml(scope))
+    .join("\n");
+
+  return [
+    `<bw:workblock>`,
+    [
+      `<bw:workflowOverlay`,
+      ` overlayVersion="${escapeXml(workflowOverlay.overlayVersion)}"`,
+      workflowOverlay.activeWorkItemId
+        ? ` activeWorkItemId="${escapeXml(workflowOverlay.activeWorkItemId)}"`
+        : "",
+      `>`,
+    ].join(""),
+    `  <bw:workItems>`,
+    workItemsXml ? indentLines(workItemsXml, 4) : "",
+    `  </bw:workItems>`,
+    `  <bw:scopes>`,
+    scopesXml ? indentLines(scopesXml, 4) : "",
+    `  </bw:scopes>`,
+    `</bw:workflowOverlay>`,
+    `</bw:workblock>`,
+  ].filter((line) => line.length > 0).join("\n");
+}
+
+function buildWorkflowScopeXml(scope: WorkflowScope): string {
+  return [
+    `<bw:scope`,
+    ` id="${escapeXml(scope.scopeId)}"`,
+    ` mode="${escapeXml(scope.mode)}"`,
+    scope.workItemId ? ` workItemRef="${escapeXml(scope.workItemId)}"` : "",
+    scope.label ? ` label="${escapeXml(scope.label)}"` : "",
+    scope.domain ? ` domain="${escapeXml(scope.domain)}"` : "",
+    `>`,
+    indentLines(buildWorkflowAnchorXml(scope.anchor, scope.storyTarget), 2),
+    `</bw:scope>`,
+  ].join("");
+}
+
+function buildWorkflowAnchorXml(
+  anchor: EditorAnchorProjection,
+  storyTarget: WorkflowScope["storyTarget"],
+): string {
+  const resolvedStoryTarget = storyTarget ?? { kind: "main" as const };
+  const range = anchor.kind === "range"
+    ? { from: anchor.from, to: anchor.to }
+    : anchor.kind === "node"
+      ? { from: anchor.at, to: anchor.at }
+      : { from: anchor.lastKnownRange.from, to: anchor.lastKnownRange.to };
+
+  return [
+    `<bw:anchor${serializeOverlayStoryTargetAttributes(resolvedStoryTarget)} targetKind="text">`,
+    `  <bw:selector type="position-range" start="${String(range.from)}" end="${String(range.to)}" />`,
+    `  <bw:selector type="binding-hash" alg="sha256" value="${escapeXml(createAnchorBindingHash(resolvedStoryTarget, range.from, range.to))}" />`,
+    `</bw:anchor>`,
+  ].join("\n");
+}
+
+function serializeOverlayStoryTargetAttributes(target: WorkflowScope["storyTarget"]): string {
+  const storyTarget = target ?? { kind: "main" as const };
+  switch (storyTarget.kind) {
+    case "main":
+      return ` story="main"`;
+    case "header":
+    case "footer":
+      return [
+        ` story="${escapeXml(storyTarget.kind)}"`,
+        ` relationshipId="${escapeXml(storyTarget.relationshipId)}"`,
+        ` variant="${escapeXml(storyTarget.variant)}"`,
+        typeof storyTarget.sectionIndex === "number"
+          ? ` sectionIndex="${String(storyTarget.sectionIndex)}"`
+          : "",
+      ].join("");
+    case "footnote":
+    case "endnote":
+      return [
+        ` story="${escapeXml(storyTarget.kind)}"`,
+        ` noteId="${escapeXml(storyTarget.noteId)}"`,
+      ].join("");
+  }
+}
+
+function createAnchorBindingHash(
+  storyTarget: NonNullable<WorkflowScope["storyTarget"]>,
+  from: number,
+  to: number,
+): string {
+  return `${serializeStoryTargetKey(storyTarget)}:${from}:${to}`;
+}
+
+function getPreservedExtensionsXml(sourcePackage: OpcPackage, payloadPartPath: string): string {
+  const payloadPart = sourcePackage.parts.get(payloadPartPath);
+  if (!payloadPart) {
+    return "";
+  }
+  const xml = decodeUtf8(payloadPart.bytes);
+  const match = xml.match(/<bw:extensions\b[^>]*>([\s\S]*?)<\/bw:extensions>/u);
+  if (!match) {
+    return "";
+  }
+  return stripWorkblockExtension(match[1] ?? "").trim();
+}
+
+function stripWorkblockExtension(extensionsInnerXml: string): string {
+  return extensionsInnerXml.replace(/<bw:workblock\b[\s\S]*?<\/bw:workblock>/gu, "").trim();
+}
+
 function serializeWorkflowMetadataValue(
   value: WorkflowMetadataEntry["value"],
 ): { type: "json"; text: string } {
@@ -361,6 +530,140 @@ function serializeWorkflowStoryTarget(target: WorkflowMetadataEntry["storyTarget
   }
 }
 
+function parseWorkflowOverlay(xml: string): WorkflowOverlay | undefined {
+  const overlayMatch = xml.match(/<bw:workflowOverlay\b([^>]*)>([\s\S]*?)<\/bw:workflowOverlay>/u);
+  if (!overlayMatch) {
+    return undefined;
+  }
+  const overlayAttributes = parseAttributes(overlayMatch[1] ?? "");
+  const overlayBody = overlayMatch[2] ?? "";
+  const scopes = [...overlayBody.matchAll(/<bw:scope\b([^>]*)>([\s\S]*?)<\/bw:scope>/gu)]
+    .map((match) => parseWorkflowScope(match[1] ?? "", match[2] ?? ""))
+    .filter((scope): scope is WorkflowScope => scope !== null);
+  const workItems = [...overlayBody.matchAll(/<bw:workItem\b([^>]*)>([\s\S]*?)<\/bw:workItem>/gu)]
+    .map((match) => parseWorkflowWorkItem(match[1] ?? "", match[2] ?? ""))
+    .filter((item): item is WorkflowWorkItem => item !== null);
+
+  return {
+    overlayVersion: (overlayAttributes.overlayVersion as WorkflowOverlay["overlayVersion"]) ?? "workflow-overlay/1",
+    activeWorkItemId: overlayAttributes.activeWorkItemId ?? null,
+    scopes,
+    ...(workItems.length > 0 ? { workItems } : {}),
+  };
+}
+
+function parseWorkflowScope(attributesSource: string, body: string): WorkflowScope | null {
+  const attributes = parseAttributes(attributesSource);
+  if (!attributes.id || !attributes.mode) {
+    return null;
+  }
+  const anchorMatch = body.match(/<bw:anchor\b([^>]*)>([\s\S]*?)<\/bw:anchor>/u);
+  const anchor = anchorMatch
+    ? parseWorkflowOverlayAnchor(anchorMatch[1] ?? "", anchorMatch[2] ?? "")
+    : createDefaultRangeAnchor(0, 0);
+  return {
+    scopeId: attributes.id,
+    mode: attributes.mode as WorkflowScope["mode"],
+    anchor,
+    storyTarget: anchorMatch ? parseOverlayStoryTarget(parseAttributes(anchorMatch[1] ?? "")) : { kind: "main" },
+    workItemId: attributes.workItemRef,
+    label: attributes.label,
+    domain: attributes.domain as WorkflowScope["domain"],
+  };
+}
+
+function parseWorkflowWorkItem(attributesSource: string, body: string): WorkflowWorkItem | null {
+  const attributes = parseAttributes(attributesSource);
+  if (!attributes.id || !attributes.title) {
+    return null;
+  }
+  const scopeIds = [...body.matchAll(/<bw:scopeRef\b([^>]*)\/>/gu)]
+    .map((match) => parseAttributes(match[1] ?? "").ref ?? "")
+    .filter((value) => value.length > 0);
+  return {
+    workItemId: attributes.id,
+    title: attributes.title,
+    status: attributes.status as WorkflowWorkItem["status"],
+    domain: attributes.domain as WorkflowWorkItem["domain"],
+    scopeIds,
+  };
+}
+
+function parseWorkflowOverlayAnchor(
+  attributesSource: string,
+  body: string,
+): EditorAnchorProjection {
+  const selectorMatches = [...body.matchAll(/<bw:selector\b([^>]*)\/>/gu)];
+  const positionSelector = selectorMatches
+    .map((match) => parseAttributes(match[1] ?? ""))
+    .find((attributes) => attributes.type === "position-range");
+  if (positionSelector?.start !== undefined && positionSelector.end !== undefined) {
+    return createDefaultRangeAnchor(Number(positionSelector.start), Number(positionSelector.end));
+  }
+  const anchorAttributes = parseAttributes(attributesSource);
+  if (anchorAttributes.targetKind === "node" && anchorAttributes.at !== undefined) {
+    return {
+      kind: "node",
+      at: Number(anchorAttributes.at),
+      assoc: 1,
+    };
+  }
+  return createDefaultRangeAnchor(0, 0);
+}
+
+function parseOverlayStoryTarget(attributes: Record<string, string>): WorkflowScope["storyTarget"] {
+  switch (attributes.story) {
+    case "header":
+    case "footer":
+      if (!attributes.relationshipId || !attributes.variant) {
+        return { kind: "main" };
+      }
+      return {
+        kind: attributes.story,
+        relationshipId: attributes.relationshipId,
+        variant: attributes.variant as "default" | "first" | "even",
+        sectionIndex: attributes.sectionIndex !== undefined ? Number(attributes.sectionIndex) : undefined,
+      };
+    case "footnote":
+    case "endnote":
+      if (!attributes.noteId) {
+        return { kind: "main" };
+      }
+      return {
+        kind: attributes.story,
+        noteId: attributes.noteId,
+      };
+    case "main":
+    default:
+      return { kind: "main" };
+  }
+}
+
+function createDefaultRangeAnchor(from: number, to: number): EditorAnchorProjection {
+  return {
+    kind: "range",
+    from,
+    to,
+    assoc: {
+      start: -1,
+      end: 1,
+    },
+  };
+}
+
+function serializeStoryTargetKey(storyTarget: NonNullable<WorkflowScope["storyTarget"]>): string {
+  switch (storyTarget.kind) {
+    case "main":
+      return "main";
+    case "header":
+    case "footer":
+      return `${storyTarget.kind}:${storyTarget.relationshipId}:${storyTarget.variant}:${storyTarget.sectionIndex ?? "none"}`;
+    case "footnote":
+    case "endnote":
+      return `${storyTarget.kind}:${storyTarget.noteId}`;
+  }
+}
+
 function parseWorkflowStoryTarget(
   attributes: Record<string, string>,
 ): WorkflowMetadataEntry["storyTarget"] {
@@ -423,7 +726,7 @@ function resolveDescriptor(sourcePackage: OpcPackage, documentId: string): Embed
   };
 }
 
-function resolvePayloadPartPath(sourcePackage: OpcPackage): string | null {
+export function resolvePayloadPartPath(sourcePackage: OpcPackage): string | null {
   const mirroredItemId = readCustomPropertyValue(
     sourcePackage,
     "BwWorkflowPayloadItemId",

package/src/model/snapshot.ts

@@ -122,6 +122,33 @@ export interface PersistedWorkflowMetadataSnapshot {
   entries: PersistedWorkflowMetadataEntry[];
 }
 
+export interface PersistedWorkflowScope {
+  scopeId: string;
+  mode: "edit" | "suggest" | "comment" | "view";
+  anchor: Record<string, unknown>;
+  storyTarget?: Record<string, unknown>;
+  workItemId?: string;
+  label?: string;
+  domain?: "legal" | "commercial" | "finance" | "other";
+}
+
+export interface PersistedWorkflowWorkItem {
+  workItemId: string;
+  title: string;
+  description?: string;
+  domain?: "legal" | "commercial" | "finance" | "other";
+  status?: "pending" | "active" | "done" | "blocked";
+  scopeIds: string[];
+}
+
+export interface PersistedWorkflowOverlay {
+  overlayVersion: "workflow-overlay/1";
+  candidates?: Array<Record<string, unknown>>;
+  scopes: PersistedWorkflowScope[];
+  workItems?: PersistedWorkflowWorkItem[];
+  activeWorkItemId?: string | null;
+}
+
 export interface PersistedEditorSnapshot {
   snapshotVersion: PersistedEditorSnapshotVersion;
   schemaVersion: typeof CDS_SCHEMA_VERSION;
@@ -136,6 +163,7 @@ export interface PersistedEditorSnapshot {
   warningLog: EditorWarning[];
   protectionSnapshot?: ProtectionSnapshotRecord;
   sourcePackage?: PersistedSourcePackage;
+  workflowOverlay?: PersistedWorkflowOverlay;
   workflowMetadata?: PersistedWorkflowMetadataSnapshot;
 }
 
@@ -153,7 +181,12 @@ const SNAPSHOT_REQUIRED_TOP_LEVEL_KEYS = [
   "warningLog",
 ] as const;
 
-const SNAPSHOT_OPTIONAL_TOP_LEVEL_KEYS = ["sourcePackage", "protectionSnapshot", "workflowMetadata"] as const;
+const SNAPSHOT_OPTIONAL_TOP_LEVEL_KEYS = [
+  "sourcePackage",
+  "protectionSnapshot",
+  "workflowOverlay",
+  "workflowMetadata",
+] as const;
 
 export interface ProtectionRangeRecord {
   rangeId: string;
@@ -308,6 +341,9 @@ export function validatePersistedEditorSnapshot(
   if (record.protectionSnapshot !== undefined) {
     validateProtectionSnapshot(record.protectionSnapshot, "$.protectionSnapshot", issues);
   }
+  if (record.workflowOverlay !== undefined) {
+    validateWorkflowOverlay(record.workflowOverlay, "$.workflowOverlay", issues);
+  }
   if (record.workflowMetadata !== undefined) {
     validateWorkflowMetadataSnapshot(record.workflowMetadata, "$.workflowMetadata", issues);
   }
@@ -642,6 +678,82 @@ function validateProtectionSnapshot(
   }
 }
 
+function validateWorkflowOverlay(
+  value: unknown,
+  path: string,
+  issues: ModelValidationIssue[],
+): void {
+  const record = asPlainObject(value, path, issues);
+  if (!record) {
+    return;
+  }
+  expectExactString(record.overlayVersion, "workflow-overlay/1", `${path}.overlayVersion`, issues);
+  if (!Array.isArray(record.scopes)) {
+    issues.push({ path: `${path}.scopes`, message: "scopes must be an array." });
+  } else {
+    record.scopes.forEach((scope, index) => validateWorkflowScope(scope, `${path}.scopes[${index}]`, issues));
+  }
+  if (record.workItems !== undefined) {
+    if (!Array.isArray(record.workItems)) {
+      issues.push({ path: `${path}.workItems`, message: "workItems must be an array." });
+    } else {
+      record.workItems.forEach((workItem, index) =>
+        validateWorkflowWorkItem(workItem, `${path}.workItems[${index}]`, issues),
+      );
+    }
+  }
+  if (record.activeWorkItemId !== undefined && record.activeWorkItemId !== null) {
+    expectString(record.activeWorkItemId, `${path}.activeWorkItemId`, issues);
+  }
+}
+
+function validateWorkflowScope(
+  value: unknown,
+  path: string,
+  issues: ModelValidationIssue[],
+): void {
+  const record = asPlainObject(value, path, issues);
+  if (!record) {
+    return;
+  }
+  expectString(record.scopeId, `${path}.scopeId`, issues);
+  if (
+    record.mode !== "edit" &&
+    record.mode !== "suggest" &&
+    record.mode !== "comment" &&
+    record.mode !== "view"
+  ) {
+    issues.push({ path: `${path}.mode`, message: "mode must be edit, suggest, comment, or view." });
+  }
+  asPlainObject(record.anchor, `${path}.anchor`, issues);
+  if (record.workItemId !== undefined) {
+    expectString(record.workItemId, `${path}.workItemId`, issues);
+  }
+  if (record.label !== undefined) {
+    expectString(record.label, `${path}.label`, issues);
+  }
+}
+
+function validateWorkflowWorkItem(
+  value: unknown,
+  path: string,
+  issues: ModelValidationIssue[],
+): void {
+  const record = asPlainObject(value, path, issues);
+  if (!record) {
+    return;
+  }
+  expectString(record.workItemId, `${path}.workItemId`, issues);
+  expectString(record.title, `${path}.title`, issues);
+  if (!Array.isArray(record.scopeIds)) {
+    issues.push({ path: `${path}.scopeIds`, message: "scopeIds must be an array." });
+  } else {
+    record.scopeIds.forEach((scopeId, index) => {
+      expectString(scopeId, `${path}.scopeIds[${index}]`, issues);
+    });
+  }
+}
+
 function validateWorkflowMetadataSnapshot(
   value: unknown,
   path: string,