@beyondwork/docx-react-component 1.0.29 → 1.0.30

package/src/model/snapshot.ts

@@ -0,0 +1,760 @@
+import {
+  CDS_SCHEMA_VERSION,
+  COMPATIBILITY_REPORT_VERSION,
+  LEGACY_PERSISTED_EDITOR_SNAPSHOT_VERSION,
+  PERSISTED_EDITOR_SNAPSHOT_VERSION,
+  type CompatibilityReportVersion,
+  type Base64,
+  type ISO8601DateTime,
+  type ModelValidationIssue,
+  type PersistedEditorSnapshotVersion,
+  asPlainObject,
+  assertValid,
+  expectExactString,
+  expectIso8601UtcTimestamp,
+  expectString,
+  stableStringify,
+} from "./cds-1.0.0.ts";
+import {
+  type CanonicalDocument,
+  assertCanonicalDocument,
+  validateCanonicalDocument,
+} from "./canonical-document.ts";
+
+export type EditorWarningCode =
+  | "unsupported_ooxml_preserved"
+  | "unsupported_ooxml_locked"
+  | "import_normalized"
+  | "export_roundtrip_risk"
+  | "comment_anchor_detached"
+  | "revision_anchor_detached"
+  | "large_document_degraded"
+  | "font_substitution"
+  | "image_missing";
+
+export interface EditorWarning {
+  warningId: string;
+  code: EditorWarningCode;
+  severity: "info" | "warning";
+  message: string;
+  source:
+    | "import"
+    | "runtime"
+    | "review"
+    | "preservation"
+    | "validation"
+    | "export";
+  affectedAnchor?: Record<string, unknown>;
+  featureEntryId?: string;
+  details?: Record<string, unknown>;
+}
+
+export type EditorErrorCode =
+  | "import_failed"
+  | "export_failed"
+  | "package_corrupt"
+  | "validation_failed"
+  | "datastore_failed"
+  | "internal_invariant";
+
+export interface EditorError {
+  errorId: string;
+  code: EditorErrorCode;
+  message: string;
+  isFatal: boolean;
+  source: "import" | "runtime" | "validation" | "datastore" | "host" | "export";
+  details?: Record<string, unknown>;
+}
+
+export type CompatibilityFeatureClass =
+  | "supported-roundtrip"
+  | "preserve-only"
+  | "unsupported-fatal";
+
+export interface CompatibilityFeatureEntry {
+  featureEntryId: string;
+  featureKey: string;
+  featureClass: CompatibilityFeatureClass;
+  message: string;
+  affectedAnchor?: Record<string, unknown>;
+  details?: Record<string, unknown>;
+}
+
+export interface CompatibilityReport {
+  reportVersion: CompatibilityReportVersion;
+  generatedAt: ISO8601DateTime;
+  blockExport: boolean;
+  featureEntries: CompatibilityFeatureEntry[];
+  warnings: EditorWarning[];
+  errors: EditorError[];
+}
+
+export interface PersistedSourcePackage {
+  format: "docx";
+  storage: "embedded-base64";
+  mimeType: "application/vnd.openxmlformats-officedocument.wordprocessingml.document";
+  sourceLabel?: string;
+  sha256Hex: string;
+  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;
+  documentId: string;
+  docId: string;
+  createdAt: ISO8601DateTime;
+  updatedAt: ISO8601DateTime;
+  savedAt: ISO8601DateTime;
+  editorBuild: string;
+  canonicalDocument: CanonicalDocument;
+  compatibility: CompatibilityReport;
+  warningLog: EditorWarning[];
+  protectionSnapshot?: ProtectionSnapshotRecord;
+  sourcePackage?: PersistedSourcePackage;
+  workflowMetadata?: PersistedWorkflowMetadataSnapshot;
+}
+
+const SNAPSHOT_REQUIRED_TOP_LEVEL_KEYS = [
+  "snapshotVersion",
+  "schemaVersion",
+  "documentId",
+  "docId",
+  "createdAt",
+  "updatedAt",
+  "savedAt",
+  "editorBuild",
+  "canonicalDocument",
+  "compatibility",
+  "warningLog",
+] as const;
+
+const SNAPSHOT_OPTIONAL_TOP_LEVEL_KEYS = ["sourcePackage", "protectionSnapshot", "workflowMetadata"] as const;
+
+export interface ProtectionRangeRecord {
+  rangeId: string;
+  start?: number;
+  end?: number;
+  editorGroup?: string;
+  editor?: string;
+  enforced: boolean;
+  enforcementReason: string;
+}
+
+export interface ProtectionSnapshotRecord {
+  hasDocumentProtection: boolean;
+  editType?: string;
+  enforcementActive: boolean;
+  ranges: ProtectionRangeRecord[];
+  enforcedRangeCount: number;
+  preservedRangeCount: number;
+}
+
+const PERSISTED_EDITOR_SNAPSHOT_VERSIONS = new Set<PersistedEditorSnapshotVersion>([
+  LEGACY_PERSISTED_EDITOR_SNAPSHOT_VERSION,
+  PERSISTED_EDITOR_SNAPSHOT_VERSION,
+]);
+
+const DOCX_SOURCE_PACKAGE_MIME_TYPE =
+  "application/vnd.openxmlformats-officedocument.wordprocessingml.document";
+const COMPATIBILITY_FEATURE_CLASSES = new Set<CompatibilityFeatureClass>([
+  "supported-roundtrip",
+  "preserve-only",
+  "unsupported-fatal",
+]);
+const EDITOR_WARNING_CODES = new Set<EditorWarningCode>([
+  "unsupported_ooxml_preserved",
+  "unsupported_ooxml_locked",
+  "import_normalized",
+  "export_roundtrip_risk",
+  "comment_anchor_detached",
+  "revision_anchor_detached",
+  "large_document_degraded",
+  "font_substitution",
+  "image_missing",
+]);
+const EDITOR_WARNING_SEVERITIES = new Set<EditorWarning["severity"]>(["info", "warning"]);
+const EDITOR_WARNING_SOURCES = new Set<EditorWarning["source"]>([
+  "import",
+  "runtime",
+  "review",
+  "preservation",
+  "validation",
+  "export",
+]);
+const EDITOR_ERROR_CODES = new Set<EditorErrorCode>([
+  "import_failed",
+  "export_failed",
+  "package_corrupt",
+  "validation_failed",
+  "datastore_failed",
+  "internal_invariant",
+]);
+const EDITOR_ERROR_SOURCES = new Set<EditorError["source"]>([
+  "import",
+  "runtime",
+  "validation",
+  "datastore",
+  "host",
+  "export",
+]);
+
+export function serializePersistedEditorSnapshot(
+  snapshot: PersistedEditorSnapshot,
+): string {
+  assertPersistedEditorSnapshot(snapshot);
+  return stableStringify(snapshot);
+}
+
+export function parsePersistedEditorSnapshot(
+  json: string,
+): PersistedEditorSnapshot {
+  const parsed = JSON.parse(json) as unknown;
+  assertPersistedEditorSnapshot(parsed);
+  return parsed;
+}
+
+export function assertPersistedEditorSnapshot(
+  snapshot: unknown,
+): asserts snapshot is PersistedEditorSnapshot {
+  const issues = validatePersistedEditorSnapshot(snapshot);
+  assertValid(issues, "Invalid persisted editor snapshot.");
+}
+
+export function validatePersistedEditorSnapshot(
+  snapshot: unknown,
+): ModelValidationIssue[] {
+  const issues: ModelValidationIssue[] = [];
+  const record = asPlainObject(snapshot, "$", issues);
+  if (!record) {
+    return issues;
+  }
+
+  validateExactObjectKeys(
+    record,
+    SNAPSHOT_REQUIRED_TOP_LEVEL_KEYS,
+    SNAPSHOT_OPTIONAL_TOP_LEVEL_KEYS,
+    "$",
+    issues,
+  );
+
+  validateSnapshotVersion(record.snapshotVersion, "$.snapshotVersion", issues);
+  expectExactString(
+    record.schemaVersion,
+    CDS_SCHEMA_VERSION,
+    "$.schemaVersion",
+    issues,
+  );
+  expectString(record.documentId, "$.documentId", issues);
+  expectString(record.docId, "$.docId", issues);
+  expectIso8601UtcTimestamp(record.createdAt, "$.createdAt", issues);
+  expectIso8601UtcTimestamp(record.updatedAt, "$.updatedAt", issues);
+  expectIso8601UtcTimestamp(record.savedAt, "$.savedAt", issues);
+  expectString(record.editorBuild, "$.editorBuild", issues);
+
+  const canonicalDocumentIssues = validateCanonicalDocument(record.canonicalDocument);
+  issues.push(...canonicalDocumentIssues.map(prefixIssue("$.canonicalDocument")));
+
+  if (
+    asPlainObject(record.canonicalDocument, "$.canonicalDocument", [])?.docId !==
+    record.docId
+  ) {
+    issues.push({
+      path: "$.docId",
+      message: "Snapshot docId must match canonicalDocument.docId.",
+    });
+  }
+
+  validateCompatibilityReport(record.compatibility, "$.compatibility", issues);
+
+  if (!Array.isArray(record.warningLog)) {
+    issues.push({
+      path: "$.warningLog",
+      message: "warningLog must be an array.",
+    });
+  } else {
+    record.warningLog.forEach((warning, index) => {
+      validateEditorWarning(warning, `$.warningLog[${index}]`, issues);
+    });
+  }
+
+  if (record.sourcePackage !== undefined) {
+    validatePersistedSourcePackage(record.sourcePackage, "$.sourcePackage", issues);
+  }
+  if (record.protectionSnapshot !== undefined) {
+    validateProtectionSnapshot(record.protectionSnapshot, "$.protectionSnapshot", issues);
+  }
+  if (record.workflowMetadata !== undefined) {
+    validateWorkflowMetadataSnapshot(record.workflowMetadata, "$.workflowMetadata", issues);
+  }
+
+  return issues;
+}
+
+export function assertCompatibilityReport(
+  report: unknown,
+): asserts report is CompatibilityReport {
+  const issues = validateCompatibilityReport(report);
+  assertValid(issues, "Invalid compatibility report.");
+}
+
+export function validateCompatibilityReport(
+  report: unknown,
+  path = "$",
+  issues: ModelValidationIssue[] = [],
+): ModelValidationIssue[] {
+  const record = asPlainObject(report, path, issues);
+  if (!record) {
+    return issues;
+  }
+
+  expectExactString(
+    record.reportVersion,
+    COMPATIBILITY_REPORT_VERSION,
+    `${path}.reportVersion`,
+    issues,
+  );
+  expectIso8601UtcTimestamp(record.generatedAt, `${path}.generatedAt`, issues);
+
+  if (typeof record.blockExport !== "boolean") {
+    issues.push({
+      path: `${path}.blockExport`,
+      message: "blockExport must be a boolean.",
+    });
+  }
+
+  if (!Array.isArray(record.featureEntries)) {
+    issues.push({
+      path: `${path}.featureEntries`,
+      message: "featureEntries must be an array.",
+    });
+  } else {
+    record.featureEntries.forEach((featureEntry, index) => {
+      validateCompatibilityFeatureEntry(
+        featureEntry,
+        `${path}.featureEntries[${index}]`,
+        issues,
+      );
+    });
+  }
+
+  if (!Array.isArray(record.warnings)) {
+    issues.push({
+      path: `${path}.warnings`,
+      message: "warnings must be an array.",
+    });
+  } else {
+    record.warnings.forEach((warning, index) => {
+      validateEditorWarning(warning, `${path}.warnings[${index}]`, issues);
+    });
+  }
+
+  if (!Array.isArray(record.errors)) {
+    issues.push({
+      path: `${path}.errors`,
+      message: "errors must be an array.",
+    });
+  } else {
+    record.errors.forEach((error, index) => {
+      validateEditorError(error, `${path}.errors[${index}]`, issues);
+    });
+  }
+
+  return issues;
+}
+
+function validateCompatibilityFeatureEntry(
+  featureEntry: unknown,
+  path: string,
+  issues: ModelValidationIssue[],
+): void {
+  const record = asPlainObject(featureEntry, path, issues);
+  if (!record) {
+    return;
+  }
+
+  expectString(record.featureEntryId, `${path}.featureEntryId`, issues);
+  expectString(record.featureKey, `${path}.featureKey`, issues);
+  if (
+    typeof record.featureClass !== "string" ||
+    !COMPATIBILITY_FEATURE_CLASSES.has(record.featureClass as CompatibilityFeatureClass)
+  ) {
+    issues.push({
+      path: `${path}.featureClass`,
+      message: "featureClass must be supported-roundtrip, preserve-only, or unsupported-fatal.",
+    });
+  }
+  expectString(record.message, `${path}.message`, issues);
+}
+
+function validateEditorWarning(
+  warning: unknown,
+  path: string,
+  issues: ModelValidationIssue[],
+): void {
+  const record = asPlainObject(warning, path, issues);
+  if (!record) {
+    return;
+  }
+
+  expectString(record.warningId, `${path}.warningId`, issues);
+  if (typeof record.code !== "string" || !EDITOR_WARNING_CODES.has(record.code as EditorWarningCode)) {
+    issues.push({
+      path: `${path}.code`,
+      message: `code must be one of ${JSON.stringify([...EDITOR_WARNING_CODES])}.`,
+    });
+  }
+  if (
+    typeof record.severity !== "string" ||
+    !EDITOR_WARNING_SEVERITIES.has(record.severity as EditorWarning["severity"])
+  ) {
+    issues.push({
+      path: `${path}.severity`,
+      message: "severity must be info or warning.",
+    });
+  }
+  expectString(record.message, `${path}.message`, issues);
+  if (
+    typeof record.source !== "string" ||
+    !EDITOR_WARNING_SOURCES.has(record.source as EditorWarning["source"])
+  ) {
+    issues.push({
+      path: `${path}.source`,
+      message: `source must be one of ${JSON.stringify([...EDITOR_WARNING_SOURCES])}.`,
+    });
+  }
+}
+
+function validateEditorError(
+  error: unknown,
+  path: string,
+  issues: ModelValidationIssue[],
+): void {
+  const record = asPlainObject(error, path, issues);
+  if (!record) {
+    return;
+  }
+
+  expectString(record.errorId, `${path}.errorId`, issues);
+  if (typeof record.code !== "string" || !EDITOR_ERROR_CODES.has(record.code as EditorErrorCode)) {
+    issues.push({
+      path: `${path}.code`,
+      message: `code must be one of ${JSON.stringify([...EDITOR_ERROR_CODES])}.`,
+    });
+  }
+  expectString(record.message, `${path}.message`, issues);
+  if (
+    typeof record.source !== "string" ||
+    !EDITOR_ERROR_SOURCES.has(record.source as EditorError["source"])
+  ) {
+    issues.push({
+      path: `${path}.source`,
+      message: `source must be one of ${JSON.stringify([...EDITOR_ERROR_SOURCES])}.`,
+    });
+  }
+
+  if (typeof record.isFatal !== "boolean") {
+    issues.push({
+      path: `${path}.isFatal`,
+      message: "isFatal must be a boolean.",
+    });
+  }
+}
+
+function validateExactObjectKeys(
+  record: Record<string, unknown>,
+  requiredKeys: readonly string[],
+  optionalKeys: readonly string[],
+  path: string,
+  issues: ModelValidationIssue[],
+): void {
+  const actualKeys = new Set(Object.keys(record));
+  const allowedKeys = new Set([...requiredKeys, ...optionalKeys]);
+
+  for (const requiredKey of requiredKeys) {
+    if (!actualKeys.has(requiredKey)) {
+      issues.push({
+        path,
+        message: `Missing required key ${JSON.stringify(requiredKey)}.`,
+      });
+    }
+  }
+
+  for (const actualKey of actualKeys) {
+    if (!allowedKeys.has(actualKey)) {
+      issues.push({
+        path: `${path}.${actualKey}`,
+        message:
+          "Unexpected persisted snapshot key. Render/UI state is not part of the persistence contract.",
+      });
+    }
+  }
+}
+
+function prefixIssue(basePath: string) {
+  return (issue: ModelValidationIssue): ModelValidationIssue => ({
+    path: `${basePath}${issue.path === "$" ? "" : issue.path.slice(1)}`,
+    message: issue.message,
+  });
+}
+
+function validateSnapshotVersion(
+  value: unknown,
+  path: string,
+  issues: ModelValidationIssue[],
+): PersistedEditorSnapshotVersion | null {
+  if (typeof value !== "string" || !PERSISTED_EDITOR_SNAPSHOT_VERSIONS.has(value as never)) {
+    issues.push({
+      path,
+      message: `Expected one of ${JSON.stringify([...PERSISTED_EDITOR_SNAPSHOT_VERSIONS])}.`,
+    });
+    return null;
+  }
+
+  return value as PersistedEditorSnapshotVersion;
+}
+
+function validatePersistedSourcePackage(
+  sourcePackage: unknown,
+  path: string,
+  issues: ModelValidationIssue[],
+): void {
+  const record = asPlainObject(sourcePackage, path, issues);
+  if (!record) {
+    return;
+  }
+
+  validateExactObjectKeys(
+    record,
+    ["format", "storage", "mimeType", "sha256Hex", "bytesBase64"],
+    ["sourceLabel"],
+    path,
+    issues,
+  );
+  expectExactString(record.format, "docx", `${path}.format`, issues);
+  expectExactString(record.storage, "embedded-base64", `${path}.storage`, issues);
+  expectExactString(
+    record.mimeType,
+    DOCX_SOURCE_PACKAGE_MIME_TYPE,
+    `${path}.mimeType`,
+    issues,
+  );
+  expectString(record.sha256Hex, `${path}.sha256Hex`, issues);
+  expectString(record.bytesBase64, `${path}.bytesBase64`, issues);
+
+  if (
+    typeof record.sha256Hex === "string" &&
+    !/^[0-9a-f]{64}$/u.test(record.sha256Hex)
+  ) {
+    issues.push({
+      path: `${path}.sha256Hex`,
+      message: "Expected a lowercase SHA-256 hex digest.",
+    });
+  }
+
+  if (record.sourceLabel !== undefined) {
+    expectString(record.sourceLabel, `${path}.sourceLabel`, issues);
+  }
+}
+
+export function createPersistedEditorSnapshot(params: {
+  documentId: string;
+  savedAt: ISO8601DateTime;
+  editorBuild: string;
+  canonicalDocument: CanonicalDocument;
+  compatibility: CompatibilityReport;
+  warningLog?: EditorWarning[];
+  protectionSnapshot?: ProtectionSnapshotRecord;
+  sourcePackage?: PersistedSourcePackage;
+}): PersistedEditorSnapshot {
+  assertCanonicalDocument(params.canonicalDocument);
+  assertCompatibilityReport(params.compatibility);
+
+  return {
+    snapshotVersion: PERSISTED_EDITOR_SNAPSHOT_VERSION,
+    schemaVersion: CDS_SCHEMA_VERSION,
+    documentId: params.documentId,
+    docId: params.canonicalDocument.docId,
+    createdAt: params.canonicalDocument.createdAt,
+    updatedAt: params.canonicalDocument.updatedAt,
+    savedAt: params.savedAt,
+    editorBuild: params.editorBuild,
+    canonicalDocument: params.canonicalDocument,
+    compatibility: params.compatibility,
+    warningLog: params.warningLog ?? params.compatibility.warnings,
+    protectionSnapshot: params.protectionSnapshot,
+    sourcePackage: params.sourcePackage,
+  };
+}
+
+function validateProtectionSnapshot(
+  value: unknown,
+  path: string,
+  issues: ModelValidationIssue[],
+): void {
+  const record = asPlainObject(value, path, issues);
+  if (!record) {
+    return;
+  }
+  if (typeof record.hasDocumentProtection !== "boolean") {
+    issues.push({ path: `${path}.hasDocumentProtection`, message: "hasDocumentProtection must be a boolean." });
+  }
+  if (record.editType !== undefined) {
+    expectString(record.editType, `${path}.editType`, issues);
+  }
+  if (typeof record.enforcementActive !== "boolean") {
+    issues.push({ path: `${path}.enforcementActive`, message: "enforcementActive must be a boolean." });
+  }
+  if (!Array.isArray(record.ranges)) {
+    issues.push({ path: `${path}.ranges`, message: "ranges must be an array." });
+  } else {
+    record.ranges.forEach((range, index) => validateProtectionRange(range, `${path}.ranges[${index}]`, issues));
+  }
+  if (!Number.isInteger(record.enforcedRangeCount)) {
+    issues.push({ path: `${path}.enforcedRangeCount`, message: "enforcedRangeCount must be an integer." });
+  }
+  if (!Number.isInteger(record.preservedRangeCount)) {
+    issues.push({ path: `${path}.preservedRangeCount`, message: "preservedRangeCount must be an integer." });
+  }
+}
+
+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,
+  issues: ModelValidationIssue[],
+): void {
+  const record = asPlainObject(value, path, issues);
+  if (!record) {
+    return;
+  }
+  expectString(record.rangeId, `${path}.rangeId`, issues);
+  if (record.start !== undefined && !Number.isInteger(record.start)) {
+    issues.push({ path: `${path}.start`, message: "start must be an integer." });
+  }
+  if (record.end !== undefined && !Number.isInteger(record.end)) {
+    issues.push({ path: `${path}.end`, message: "end must be an integer." });
+  }
+  if (record.editorGroup !== undefined) {
+    expectString(record.editorGroup, `${path}.editorGroup`, issues);
+  }
+  if (record.editor !== undefined) {
+    expectString(record.editor, `${path}.editor`, issues);
+  }
+  if (typeof record.enforced !== "boolean") {
+    issues.push({ path: `${path}.enforced`, message: "enforced must be a boolean." });
+  }
+  expectString(record.enforcementReason, `${path}.enforcementReason`, issues);
+}
+
+export function projectAnchorToSnapshot(
+  anchor: Record<string, unknown>,
+): Record<string, unknown> {
+  return JSON.parse(JSON.stringify(anchor)) as Record<string, unknown>;
+}