@beyondwork/docx-react-component 1.0.0 → 1.0.1

package/src/model/canonical-document.ts

@@ -1,1911 +0,0 @@
-import {
-  CDS_SCHEMA_VERSION,
-  type ISO8601DateTime,
-  type ModelValidationIssue,
-  type UUID,
-  asPlainObject,
-  assertValid,
-  expectExactString,
-  expectIso8601UtcTimestamp,
-  expectString,
-  expectUuid,
-  stableStringify,
-} from "./cds-1.0.0.ts";
-
-const CANONICAL_DOCUMENT_TOP_LEVEL_KEYS = [
-  "schemaVersion",
-  "docId",
-  "createdAt",
-  "updatedAt",
-  "metadata",
-  "styles",
-  "numbering",
-  "media",
-  "content",
-  "review",
-  "preservation",
-  "diagnostics",
-] as const;
-
-const CANONICAL_DOCUMENT_OPTIONAL_KEYS = ["subParts"] as const;
-
-const ID_PATTERNS = {
-  styleId: /^[A-Za-z_][A-Za-z0-9._-]{0,127}$/,
-  abstractNumberingId: /^abstract-num:[A-Za-z0-9._-]{1,120}$/,
-  numberingInstanceId: /^num:[A-Za-z0-9._-]{1,120}$/,
-  mediaId: /^media:[A-Za-z0-9._/-]{1,120}$/,
-  commentId:
-    /^(?:comment:[A-Za-z0-9._-]{1,120}|comment-[A-Za-z0-9._-]{1,120}|[0-9]{1,18})$/,
-  revisionId:
-    /^(?:revision:[A-Za-z0-9._-]{1,120}|change-[A-Za-z0-9._-]{1,120})$/,
-  fragmentId: /^fragment:[A-Za-z0-9._-]{1,120}$/,
-  warningId: /^warning:[A-Za-z0-9._:-]{1,120}$/,
-  diagnosticId: /^diagnostic:[A-Za-z0-9._-]{1,120}$/,
-  packagePartName: /^\/[A-Za-z0-9_.\-\/]+\.[A-Za-z0-9]+$/,
-  relationshipId: /^rId[A-Za-z0-9._-]{1,120}$/,
-} as const;
-
-type StableIdDomain = keyof typeof ID_PATTERNS;
-
-export interface CanonicalDocument {
-  schemaVersion: typeof CDS_SCHEMA_VERSION;
-  docId: UUID;
-  createdAt: ISO8601DateTime;
-  updatedAt: ISO8601DateTime;
-  metadata: DocumentMetadata;
-  styles: StylesCatalog;
-  numbering: NumberingCatalog;
-  media: MediaCatalog;
-  content: DocumentNode;
-  review: ReviewStore;
-  preservation: PreservationStore;
-  diagnostics: DiagnosticStore;
-  subParts?: SubPartsCatalog;
-}
-
-export interface DocumentMetadata {
-  title?: string;
-  subject?: string;
-  description?: string;
-  language?: string;
-  keywords?: string[];
-  category?: string;
-  customProperties: Record<string, string>;
-}
-
-export interface StylesCatalog {
-  paragraphs: Record<string, ParagraphStyleDefinition>;
-  characters: Record<string, CharacterStyleDefinition>;
-  tables: Record<string, TableStyleDefinition>;
-  latentStyles?: Record<string, LatentStyleDefinition>;
-}
-
-export interface ParagraphStyleDefinition {
-  styleId: string;
-  basedOn?: string;
-  nextStyle?: string;
-  displayName: string;
-  kind: "paragraph";
-  isDefault: boolean;
-}
-
-export interface CharacterStyleDefinition {
-  styleId: string;
-  basedOn?: string;
-  displayName: string;
-  kind: "character";
-  isDefault: boolean;
-}
-
-export interface TableStyleDefinition {
-  styleId: string;
-  basedOn?: string;
-  displayName: string;
-  kind: "table";
-  isDefault: boolean;
-}
-
-export interface LatentStyleDefinition {
-  name: string;
-  locked?: boolean;
-  semiHidden?: boolean;
-  unhideWhenUsed?: boolean;
-  qFormat?: boolean;
-  uiPriority?: number;
-}
-
-export interface NumberingCatalog {
-  abstractDefinitions: Record<string, AbstractNumberingDefinition>;
-  instances: Record<string, NumberingInstance>;
-}
-
-export interface AbstractNumberingDefinition {
-  abstractNumberingId: string;
-  levels: NumberingLevelDefinition[];
-}
-
-export interface NumberingLevelDefinition {
-  level: number;
-  format: string;
-  text: string;
-  startAt?: number;
-  paragraphStyleId?: string;
-}
-
-export interface NumberingInstance {
-  numberingInstanceId: string;
-  abstractNumberingId: string;
-  overrides: NumberingLevelOverride[];
-}
-
-export interface NumberingLevelOverride {
-  level: number;
-  startAt?: number;
-}
-
-export interface MediaCatalog {
-  items: Record<string, MediaItem>;
-}
-
-export interface MediaItem {
-  mediaId: string;
-  contentType: string;
-  filename: string;
-  relationshipId?: string;
-  packagePartName: string;
-  altText?: string;
-}
-
-// ---- Sub-part canonical types ----
-
-export type HeaderFooterVariant = "default" | "first" | "even";
-
-export interface HeaderDocument {
-  variant: HeaderFooterVariant;
-  partPath: string;
-  relationshipId: string;
-  blocks: BlockNode[];
-}
-
-export interface FooterDocument {
-  variant: HeaderFooterVariant;
-  partPath: string;
-  relationshipId: string;
-  blocks: BlockNode[];
-}
-
-export interface FootnoteDefinition {
-  noteId: string;
-  kind: "footnote" | "endnote";
-  blocks: BlockNode[];
-}
-
-export interface FootnoteCollection {
-  footnotes: Record<string, FootnoteDefinition>;
-  endnotes: Record<string, FootnoteDefinition>;
-}
-
-export interface ThemeColorScheme {
-  name: string;
-  colors: Record<string, string>;
-}
-
-export interface ThemeFontScheme {
-  name: string;
-  majorFont?: string;
-  minorFont?: string;
-}
-
-export interface ThemeDefinition {
-  name?: string;
-  colorScheme?: ThemeColorScheme;
-  fontScheme?: ThemeFontScheme;
-}
-
-export interface SubPartsCatalog {
-  headers: HeaderDocument[];
-  footers: FooterDocument[];
-  footnoteCollection?: FootnoteCollection;
-  theme?: ThemeDefinition;
-}
-
-// ---- Inline footnote reference node ----
-
-export interface FootnoteRefNode {
-  type: "footnote_ref";
-  noteId: string;
-  noteKind: "footnote" | "endnote";
-}
-
-export type DocumentNode =
-  | DocumentRootNode
-  | ParagraphNode
-  | TableNode
-  | TableRowNode
-  | TableCellNode
-  | SdtNode
-  | CustomXmlNode
-  | AltChunkNode
-  | TextNode
-  | HardBreakNode
-  | TabNode
-  | ColumnBreakNode
-  | SymbolNode
-  | HyperlinkNode
-  | ImageNode
-  | FieldNode
-  | BookmarkStartNode
-  | BookmarkEndNode
-  | SectionBreakNode
-  | OpaqueInlineNode
-  | OpaqueBlockNode
-  | FootnoteRefNode
-  | ChartPreviewNode
-  | SmartArtPreviewNode
-  | ShapeNode
-  | WordArtNode
-  | VmlShapeNode;
-
-export interface DocumentRootNode {
-  type: "doc";
-  children: BlockNode[];
-}
-
-export type BlockNode =
-  | ParagraphNode
-  | TableNode
-  | SdtNode
-  | CustomXmlNode
-  | AltChunkNode
-  | SectionBreakNode
-  | OpaqueBlockNode;
-
-export interface ParagraphSpacing {
-  before?: number;
-  after?: number;
-  line?: number;
-  lineRule?: "auto" | "exact" | "atLeast";
-}
-
-export interface ParagraphIndentation {
-  left?: number;
-  right?: number;
-  firstLine?: number;
-  hanging?: number;
-}
-
-export interface TabStop {
-  position: number;
-  align: "left" | "center" | "right" | "decimal" | "bar" | "clear";
-  leader?: "none" | "dot" | "hyphen" | "underscore" | "heavy" | "middleDot";
-}
-
-export interface ParagraphBorders {
-  top?: BorderSpec;
-  left?: BorderSpec;
-  bottom?: BorderSpec;
-  right?: BorderSpec;
-  bar?: BorderSpec;
-  between?: BorderSpec;
-}
-
-export interface ParagraphShading {
-  fill?: string;
-  color?: string;
-  val?: string;
-}
-
-export interface ParagraphNode {
-  type: "paragraph";
-  styleId?: string;
-  numbering?: {
-    numberingInstanceId: string;
-    level: number;
-  };
-  alignment?: "left" | "center" | "right" | "both" | "distribute";
-  spacing?: ParagraphSpacing;
-  indentation?: ParagraphIndentation;
-  tabStops?: TabStop[];
-  keepNext?: boolean;
-  keepLines?: boolean;
-  outlineLevel?: number;
-  pageBreakBefore?: boolean;
-  widowControl?: boolean;
-  borders?: ParagraphBorders;
-  shading?: ParagraphShading;
-  bidi?: boolean;
-  suppressLineNumbers?: boolean;
-  cnfStyle?: string;
-  children: InlineNode[];
-}
-
-export interface BorderSpec {
-  value?: string;
-  size?: number;
-  space?: number;
-  color?: string;
-}
-
-export interface TableBorders {
-  top?: BorderSpec;
-  left?: BorderSpec;
-  bottom?: BorderSpec;
-  right?: BorderSpec;
-  insideH?: BorderSpec;
-  insideV?: BorderSpec;
-}
-
-export interface TableCellBorders {
-  top?: BorderSpec;
-  left?: BorderSpec;
-  bottom?: BorderSpec;
-  right?: BorderSpec;
-  insideH?: BorderSpec;
-  insideV?: BorderSpec;
-}
-
-export interface TableWidth {
-  value: number;
-  type: "dxa" | "auto" | "pct" | "nil";
-}
-
-export interface CellShading {
-  fill?: string;
-  color?: string;
-  val?: string;
-}
-
-export interface TableCellMargins {
-  top?: number;
-  left?: number;
-  bottom?: number;
-  right?: number;
-}
-
-export interface TableLook {
-  val?: string;
-  firstRow?: boolean;
-  lastRow?: boolean;
-  firstColumn?: boolean;
-  lastColumn?: boolean;
-  noHBand?: boolean;
-  noVBand?: boolean;
-}
-
-export interface TableNode {
-  type: "table";
-  styleId?: string;
-  propertiesXml?: string;
-  gridColumns: number[];
-  rows: TableRowNode[];
-  width?: TableWidth;
-  alignment?: "left" | "center" | "right";
-  borders?: TableBorders;
-  cellMargins?: TableCellMargins;
-  tblLook?: TableLook;
-}
-
-export interface TableRowNode {
-  type: "table_row";
-  propertiesXml?: string;
-  cells: TableCellNode[];
-  height?: number;
-  heightRule?: "auto" | "atLeast" | "exact";
-  isHeader?: boolean;
-}
-
-export interface TableCellNode {
-  type: "table_cell";
-  propertiesXml?: string;
-  gridSpan?: number;
-  verticalMerge?: "restart" | "continue";
-  children: BlockNode[];
-  width?: TableWidth;
-  borders?: TableCellBorders;
-  shading?: CellShading;
-  verticalAlign?: "top" | "center" | "bottom";
-}
-
-export interface SdtNode {
-  type: "sdt";
-  properties: {
-    sdtType?: string;
-    alias?: string;
-    tag?: string;
-    lock?: string;
-    propertiesXml?: string;
-  };
-  children: BlockNode[];
-}
-
-export interface CustomXmlNode {
-  type: "custom_xml";
-  uri?: string;
-  element?: string;
-  children: BlockNode[];
-}
-
-export interface AltChunkNode {
-  type: "alt_chunk";
-  relationshipId: string;
-}
-
-export interface FieldNode {
-  type: "field";
-  fieldType: "simple" | "complex";
-  instruction: string;
-  children: InlineNode[];
-}
-
-export interface BookmarkStartNode {
-  type: "bookmark_start";
-  bookmarkId: string;
-  name: string;
-}
-
-export interface BookmarkEndNode {
-  type: "bookmark_end";
-  bookmarkId: string;
-}
-
-export interface SectionBreakNode {
-  type: "section_break";
-  propertiesXml?: string;
-}
-
-export type InlineNode =
-  | TextNode
-  | HardBreakNode
-  | TabNode
-  | HyperlinkNode
-  | ImageNode
-  | FieldNode
-  | BookmarkStartNode
-  | BookmarkEndNode
-  | OpaqueInlineNode
-  | FootnoteRefNode
-  | ChartPreviewNode
-  | SmartArtPreviewNode
-  | ShapeNode
-  | WordArtNode
-  | VmlShapeNode;
-
-export interface TextNode {
-  type: "text";
-  text: string;
-  marks?: TextMark[];
-}
-
-export type TextMark =
-  | { type: "bold" }
-  | { type: "italic" }
-  | { type: "underline" }
-  | { type: "strikethrough" }
-  | { type: "doubleStrikethrough" }
-  | { type: "vanish" }
-  | { type: "lang"; val: string }
-  | { type: "backgroundColor"; color: string }
-  | { type: "charSpacing"; val: number }
-  | { type: "kerning"; val: number }
-  | { type: "emboss" }
-  | { type: "imprint" }
-  | { type: "shadow" }
-  | { type: "position"; val: number }
-  | { type: "textFill"; xml: string };
-
-export interface HardBreakNode {
-  type: "hard_break";
-}
-
-export interface ColumnBreakNode {
-  type: "column_break";
-}
-
-export interface TabNode {
-  type: "tab";
-}
-
-export interface SymbolNode {
-  type: "symbol";
-  char: string;
-  font?: string;
-  marks?: TextMark[];
-}
-
-export interface HyperlinkNode {
-  type: "hyperlink";
-  href: string;
-  children: Array<TextNode | HardBreakNode | ColumnBreakNode | TabNode | SymbolNode>;
-}
-
-export interface ImageNode {
-  type: "image";
-  mediaId: string;
-  altText?: string;
-  placementXml?: string;
-  display?: "inline" | "floating";
-  floating?: FloatingImageProperties;
-}
-
-export interface FloatingImageProperties {
-  horizontalPosition?: FloatingAxisPosition;
-  verticalPosition?: FloatingAxisPosition;
-  wrap?: "none" | "square" | "tight" | "through" | "topAndBottom";
-  behindDoc?: boolean;
-  layoutInCell?: boolean;
-  allowOverlap?: boolean;
-}
-
-export interface FloatingAxisPosition {
-  relativeFrom?: string;
-  align?: string;
-  offset?: number;
-}
-
-export interface OpaqueInlineNode {
-  type: "opaque_inline";
-  fragmentId: string;
-  warningId: string;
-}
-
-// ---- Complex rendering inline nodes (read-only previews) ----
-
-/**
- * Read-only preview of a chart (c:chart). The original drawing XML is stored in
- * rawXml for lossless round-trip export. If a fallback image was present in
- * mc:AlternateContent it is referenced by previewMediaId.
- */
-export interface ChartPreviewNode {
-  type: "chart_preview";
-  previewMediaId?: string;
-  rawXml: string;
-}
-
-/**
- * Read-only preview of a SmartArt diagram (dgm:*). The original drawing XML is
- * stored in rawXml for lossless round-trip export.
- */
-export interface SmartArtPreviewNode {
-  type: "smartart_preview";
-  previewMediaId?: string;
-  rawXml: string;
-}
-
-/**
- * Read-only rendering of a wps:wsp WordprocessingShape. Text content is
- * extracted for display. The original drawing XML is preserved in rawXml.
- */
-export interface ShapeNode {
-  type: "shape";
-  text?: string;
-  geometry?: string;
-  rawXml: string;
-}
-
-/**
- * Read-only rendering of WordArt — a wps:wsp shape with a text-geometry preset.
- * Text is extracted for display. The original drawing XML is preserved in rawXml.
- */
-export interface WordArtNode {
-  type: "wordart";
-  text: string;
-  geometry?: string;
-  rawXml: string;
-}
-
-/**
- * Read-only rendering of a VML shape (v:shape, v:rect, v:textbox) from a w:pict
- * element. Text is extracted for display. The original w:pict XML is preserved
- * in rawXml for lossless round-trip export.
- */
-export interface VmlShapeNode {
-  type: "vml_shape";
-  text?: string;
-  shapeType?: string;
-  rawXml: string;
-}
-
-export interface OpaqueBlockNode {
-  type: "opaque_block";
-  fragmentId: string;
-  warningId: string;
-}
-
-export interface DocRange {
-  from: number;
-  to: number;
-}
-
-export interface BoundaryAssoc {
-  start: -1 | 1;
-  end: -1 | 1;
-}
-
-export type CanonicalAnchor =
-  | {
-      kind: "range";
-      range: DocRange;
-      assoc: BoundaryAssoc;
-    }
-  | {
-      kind: "node";
-      at: number;
-      assoc: -1 | 1;
-    }
-  | {
-      kind: "detached";
-      lastKnownRange: DocRange;
-      reason: "deleted" | "invalidatedByStructureChange" | "importAmbiguity";
-    };
-
-export interface ReviewStore {
-  comments: Record<string, CommentThread>;
-  revisions: Record<string, RevisionRecord>;
-}
-
-export interface CommentThread {
-  commentId: string;
-  status: "open" | "resolved" | "detached";
-  anchor: CanonicalAnchor;
-  createdAt: ISO8601DateTime;
-  createdBy?: string;
-  authorId?: string;
-  body?: string;
-  entries?: CommentEntry[];
-  resolution?: CommentResolution;
-  resolvedAt?: ISO8601DateTime;
-  warningIds: string[];
-  isResolved?: boolean;
-  metadata?: CommentThreadMetadata;
-}
-
-export interface CommentEntry {
-  entryId: string;
-  authorId: string;
-  createdAt: ISO8601DateTime;
-  body: string;
-  metadata?: CommentEntryMetadata;
-}
-
-export interface CommentEntryMetadata {
-  ooxmlCommentId?: string;
-  paraId?: string;
-  parentParaId?: string;
-  durableId?: string;
-  initials?: string;
-}
-
-export interface CommentResolution {
-  resolvedAt: ISO8601DateTime;
-  resolvedBy: string;
-}
-
-export interface CommentThreadMetadata {
-  source?: "runtime" | "import";
-  rootOoxmlCommentId?: string;
-  rootParaId?: string;
-}
-
-export interface RevisionPropertyChangeData {
-  xmlTag: "pPrChange" | "sectPrChange" | "tblPrChange" | "rPrChange";
-  beforeXml: string;
-}
-
-export interface RevisionMoveData {
-  moveId: string;
-  direction: "from" | "to";
-}
-
-export interface RevisionRecord {
-  changeId: string;
-  kind: "insertion" | "deletion" | "formatting" | "move" | "property-change";
-  anchor: CanonicalAnchor;
-  authorId?: string;
-  createdAt: ISO8601DateTime;
-  warningIds?: string[];
-  metadata?: RevisionMetadataRecord;
-  status: "open" | "accepted" | "rejected" | "detached";
-}
-
-export interface RevisionMetadataRecord {
-  source?: "runtime" | "import";
-  preserveOnlyReason?: string;
-  importedRevisionForm?:
-    | "run-insertion"
-    | "run-deletion"
-    | "paragraph-insertion"
-    | "paragraph-deletion";
-  originalRevisionType?: string;
-  ooxmlRevisionId?: string;
-  propertyChangeData?: RevisionPropertyChangeData;
-  moveData?: RevisionMoveData;
-}
-
-export interface PreservationStore {
-  opaqueFragments: Record<string, OpaqueFragmentRecord>;
-  packageParts: Record<string, PreservedPackagePart>;
-}
-
-export interface OpaqueFragmentRecord {
-  fragmentId: string;
-  payloadKind: "xml-subtree" | "package-part";
-  payloadReference: string;
-  featureClass: "preserve-only";
-  lastKnownRange: DocRange;
-  warningId: string;
-  packagePartName?: string;
-  relationshipId?: string;
-}
-
-export interface PreservedPackagePart {
-  packagePartName: string;
-  contentType: string;
-  relationshipIds: string[];
-}
-
-export interface DiagnosticStore {
-  warnings: DiagnosticWarningEntry[];
-  errors: DiagnosticErrorEntry[];
-}
-
-export interface DiagnosticWarningEntry {
-  diagnosticId: string;
-  warningId: string;
-  source:
-    | "import"
-    | "runtime"
-    | "review"
-    | "preservation"
-    | "validation"
-    | "export";
-  message: string;
-}
-
-export interface DiagnosticErrorEntry {
-  diagnosticId: string;
-  code:
-    | "load_failed"
-    | "export_failed"
-    | "package_corrupt"
-    | "validation_failed"
-    | "datastore_failed"
-    | "internal_invariant";
-  message: string;
-  isFatal: boolean;
-  source: "import" | "runtime" | "validation" | "datastore" | "export";
-}
-
-export function createCanonicalDocument(
-  input: Omit<CanonicalDocument, "schemaVersion">,
-): CanonicalDocument {
-  const document: CanonicalDocument = {
-    schemaVersion: CDS_SCHEMA_VERSION,
-    ...input,
-  };
-
-  assertCanonicalDocument(document);
-  return document;
-}
-
-export function serializeCanonicalDocument(document: CanonicalDocument): string {
-  assertCanonicalDocument(document);
-  return stableStringify(document);
-}
-
-export function createCanonicalDocumentSignature(document: unknown): string {
-  return stableStringify(document);
-}
-
-export function parseCanonicalDocument(json: string): CanonicalDocument {
-  const parsed = JSON.parse(json) as unknown;
-  assertCanonicalDocument(parsed);
-  return parsed;
-}
-
-export function projectCanonicalDocument(
-  document: CanonicalDocument,
-): CanonicalDocument {
-  assertCanonicalDocument(document);
-  return JSON.parse(stableStringify(document)) as CanonicalDocument;
-}
-
-export function assertCanonicalDocument(
-  value: unknown,
-): asserts value is CanonicalDocument {
-  const issues = validateCanonicalDocument(value);
-  assertValid(issues, "Invalid canonical document.");
-}
-
-export function validateCanonicalDocument(
-  value: unknown,
-): ModelValidationIssue[] {
-  const issues: ModelValidationIssue[] = [];
-  const record = asPlainObject(value, "$", issues);
-  if (!record) {
-    return issues;
-  }
-
-  validateExactObjectKeys(record, CANONICAL_DOCUMENT_TOP_LEVEL_KEYS, "$", issues, CANONICAL_DOCUMENT_OPTIONAL_KEYS);
-  expectExactString(record.schemaVersion, CDS_SCHEMA_VERSION, "$.schemaVersion", issues);
-  expectUuid(record.docId, "$.docId", issues);
-  expectIso8601UtcTimestamp(record.createdAt, "$.createdAt", issues);
-  expectIso8601UtcTimestamp(record.updatedAt, "$.updatedAt", issues);
-
-  validateMetadata(record.metadata, "$.metadata", issues);
-  validateStylesCatalog(record.styles, "$.styles", issues);
-  validateNumberingCatalog(record.numbering, "$.numbering", issues);
-  validateMediaCatalog(record.media, "$.media", issues);
-  validateDocumentNode(record.content, "$.content", issues);
-  validateReviewStore(record.review, "$.review", issues);
-  validatePreservationStore(record.preservation, "$.preservation", issues);
-  validateDiagnosticStore(record.diagnostics, "$.diagnostics", issues);
-  if (record.subParts !== undefined) {
-    validateSubPartsCatalog(record.subParts, "$.subParts", issues);
-  }
-
-  return issues;
-}
-
-function validateMetadata(
-  value: unknown,
-  path: string,
-  issues: ModelValidationIssue[],
-): void {
-  const record = asPlainObject(value, path, issues);
-  if (!record) {
-    return;
-  }
-
-  const customProperties = asPlainObject(record.customProperties, `${path}.customProperties`, issues);
-  if (!customProperties) {
-    return;
-  }
-
-  for (const [propertyKey, propertyValue] of Object.entries(customProperties)) {
-    if (typeof propertyValue !== "string") {
-      issues.push({
-        path: `${path}.customProperties.${propertyKey}`,
-        message: "customProperties values must be strings.",
-      });
-    }
-  }
-}
-
-function validateStylesCatalog(
-  value: unknown,
-  path: string,
-  issues: ModelValidationIssue[],
-): void {
-  const record = asPlainObject(value, path, issues);
-  if (!record) {
-    return;
-  }
-
-  validateStyleMap(record.paragraphs, `${path}.paragraphs`, issues);
-  validateStyleMap(record.characters, `${path}.characters`, issues);
-  validateStyleMap(record.tables, `${path}.tables`, issues);
-  if (record.latentStyles !== undefined) {
-    validateLatentStyleMap(record.latentStyles, `${path}.latentStyles`, issues);
-  }
-}
-
-function validateStyleMap(
-  value: unknown,
-  path: string,
-  issues: ModelValidationIssue[],
-): void {
-  const record = asPlainObject(value, path, issues);
-  if (!record) {
-    return;
-  }
-
-  for (const [styleId, definition] of Object.entries(record)) {
-    expectDomainString(styleId, "styleId", `${path}.${styleId}`, issues);
-    const definitionRecord = asPlainObject(definition, `${path}.${styleId}`, issues);
-    if (!definitionRecord) {
-      continue;
-    }
-    if (definitionRecord.styleId !== styleId) {
-      issues.push({
-        path: `${path}.${styleId}.styleId`,
-        message: "styleId must match the map key.",
-      });
-    }
-  }
-}
-
-function validateLatentStyleMap(
-  value: unknown,
-  path: string,
-  issues: ModelValidationIssue[],
-): void {
-  const record = asPlainObject(value, path, issues);
-  if (!record) {
-    return;
-  }
-
-  for (const [styleName, definition] of Object.entries(record)) {
-    const definitionRecord = asPlainObject(definition, `${path}.${styleName}`, issues);
-    if (!definitionRecord) {
-      continue;
-    }
-    if (definitionRecord.name !== styleName) {
-      issues.push({
-        path: `${path}.${styleName}.name`,
-        message: "name must match the map key.",
-      });
-    }
-    if (definitionRecord.uiPriority !== undefined && typeof definitionRecord.uiPriority !== "number") {
-      issues.push({
-        path: `${path}.${styleName}.uiPriority`,
-        message: "uiPriority must be a number.",
-      });
-    }
-  }
-}
-
-function validateNumberingCatalog(
-  value: unknown,
-  path: string,
-  issues: ModelValidationIssue[],
-): void {
-  const record = asPlainObject(value, path, issues);
-  if (!record) {
-    return;
-  }
-
-  const abstractDefinitions = asPlainObject(
-    record.abstractDefinitions,
-    `${path}.abstractDefinitions`,
-    issues,
-  );
-  if (abstractDefinitions) {
-    for (const [abstractId, definition] of Object.entries(abstractDefinitions)) {
-      expectDomainString(
-        abstractId,
-        "abstractNumberingId",
-        `${path}.abstractDefinitions.${abstractId}`,
-        issues,
-      );
-      const definitionRecord = asPlainObject(
-        definition,
-        `${path}.abstractDefinitions.${abstractId}`,
-        issues,
-      );
-      if (definitionRecord && definitionRecord.abstractNumberingId !== abstractId) {
-        issues.push({
-          path: `${path}.abstractDefinitions.${abstractId}.abstractNumberingId`,
-          message: "abstractNumberingId must match the map key.",
-        });
-      }
-    }
-  }
-
-  const instances = asPlainObject(record.instances, `${path}.instances`, issues);
-  if (instances) {
-    for (const [instanceId, instance] of Object.entries(instances)) {
-      expectDomainString(
-        instanceId,
-        "numberingInstanceId",
-        `${path}.instances.${instanceId}`,
-        issues,
-      );
-      const instanceRecord = asPlainObject(
-        instance,
-        `${path}.instances.${instanceId}`,
-        issues,
-      );
-      if (!instanceRecord) {
-        continue;
-      }
-      if (instanceRecord.numberingInstanceId !== instanceId) {
-        issues.push({
-          path: `${path}.instances.${instanceId}.numberingInstanceId`,
-          message: "numberingInstanceId must match the map key.",
-        });
-      }
-      expectDomainString(
-        instanceRecord.abstractNumberingId,
-        "abstractNumberingId",
-        `${path}.instances.${instanceId}.abstractNumberingId`,
-        issues,
-      );
-    }
-  }
-}
-
-function validateMediaCatalog(
-  value: unknown,
-  path: string,
-  issues: ModelValidationIssue[],
-): void {
-  const record = asPlainObject(value, path, issues);
-  if (!record) {
-    return;
-  }
-
-  const items = asPlainObject(record.items, `${path}.items`, issues);
-  if (!items) {
-    return;
-  }
-
-  for (const [mediaId, item] of Object.entries(items)) {
-    expectDomainString(mediaId, "mediaId", `${path}.items.${mediaId}`, issues);
-    const itemRecord = asPlainObject(item, `${path}.items.${mediaId}`, issues);
-    if (!itemRecord) {
-      continue;
-    }
-    if (itemRecord.mediaId !== mediaId) {
-      issues.push({
-        path: `${path}.items.${mediaId}.mediaId`,
-        message: "mediaId must match the map key.",
-      });
-    }
-    expectDomainString(
-      itemRecord.packagePartName,
-      "packagePartName",
-      `${path}.items.${mediaId}.packagePartName`,
-      issues,
-    );
-    if (itemRecord.relationshipId !== undefined) {
-      expectDomainString(
-        itemRecord.relationshipId,
-        "relationshipId",
-        `${path}.items.${mediaId}.relationshipId`,
-        issues,
-      );
-    }
-  }
-}
-
-function validateDocumentNode(
-  value: unknown,
-  path: string,
-  issues: ModelValidationIssue[],
-): void {
-  const record = asPlainObject(value, path, issues);
-  if (!record) {
-    return;
-  }
-
-  const type = expectString(record.type, `${path}.type`, issues);
-  if (!type) {
-    return;
-  }
-
-  switch (type) {
-    case "doc":
-    case "paragraph":
-    case "sdt":
-    case "custom_xml":
-    case "hyperlink":
-      if (!Array.isArray(record.children)) {
-        issues.push({ path: `${path}.children`, message: "children must be an array." });
-      } else {
-        record.children.forEach((child, index) =>
-          validateDocumentNode(child, `${path}.children[${index}]`, issues),
-        );
-      }
-      if (type === "paragraph" && record.numbering !== undefined) {
-        const numbering = asPlainObject(record.numbering, `${path}.numbering`, issues);
-        if (numbering) {
-          expectDomainString(
-            numbering.numberingInstanceId,
-            "numberingInstanceId",
-            `${path}.numbering.numberingInstanceId`,
-            issues,
-          );
-        }
-      }
-      return;
-    case "alt_chunk":
-      expectDomainString(record.relationshipId, "relationshipId", `${path}.relationshipId`, issues);
-      return;
-    case "image":
-      expectDomainString(record.mediaId, "mediaId", `${path}.mediaId`, issues);
-      if (record.placementXml !== undefined) {
-        expectString(record.placementXml, `${path}.placementXml`, issues);
-      }
-      if (record.display !== undefined) {
-        const display = expectString(record.display, `${path}.display`, issues);
-        if (display && display !== "inline" && display !== "floating") {
-          issues.push({
-            path: `${path}.display`,
-            message: "display must be 'inline' or 'floating'.",
-          });
-        }
-      }
-      if (record.floating !== undefined) {
-        validateFloatingImageProperties(record.floating, `${path}.floating`, issues);
-      }
-      return;
-    case "opaque_inline":
-    case "opaque_block":
-      expectDomainString(record.fragmentId, "fragmentId", `${path}.fragmentId`, issues);
-      expectDomainString(record.warningId, "warningId", `${path}.warningId`, issues);
-      return;
-    case "table":
-      if (!Array.isArray(record.gridColumns)) {
-        issues.push({ path: `${path}.gridColumns`, message: "gridColumns must be an array." });
-      }
-      if (!Array.isArray(record.rows)) {
-        issues.push({ path: `${path}.rows`, message: "rows must be an array." });
-      } else {
-        record.rows.forEach((row, rowIndex) =>
-          validateDocumentNode(row, `${path}.rows[${rowIndex}]`, issues),
-        );
-      }
-      return;
-    case "table_row":
-      if (!Array.isArray(record.cells)) {
-        issues.push({ path: `${path}.cells`, message: "cells must be an array." });
-      } else {
-        record.cells.forEach((cell, cellIndex) =>
-          validateDocumentNode(cell, `${path}.cells[${cellIndex}]`, issues),
-        );
-      }
-      return;
-    case "table_cell":
-      if (!Array.isArray(record.children)) {
-        issues.push({ path: `${path}.children`, message: "children must be an array." });
-      } else {
-        record.children.forEach((child, childIndex) =>
-          validateDocumentNode(child, `${path}.children[${childIndex}]`, issues),
-        );
-      }
-      return;
-    case "field":
-      if (!Array.isArray(record.children)) {
-        issues.push({ path: `${path}.children`, message: "children must be an array." });
-      } else {
-        record.children.forEach((child, index) =>
-          validateDocumentNode(child, `${path}.children[${index}]`, issues),
-        );
-      }
-      return;
-    case "bookmark_start":
-      expectString(record.bookmarkId, `${path}.bookmarkId`, issues);
-      expectString(record.name, `${path}.name`, issues);
-      return;
-    case "bookmark_end":
-      expectString(record.bookmarkId, `${path}.bookmarkId`, issues);
-      return;
-    case "section_break":
-      return;
-    case "text":
-    case "hard_break":
-    case "column_break":
-    case "tab":
-      return;
-    case "symbol":
-      expectString(record.char, `${path}.char`, issues);
-      if (record.font !== undefined) {
-        expectString(record.font, `${path}.font`, issues);
-      }
-      return;
-    case "footnote_ref":
-      expectString(record.noteId, `${path}.noteId`, issues);
-      expectString(record.noteKind, `${path}.noteKind`, issues);
-      return;
-    case "chart_preview":
-    case "smartart_preview":
-    case "shape":
-    case "wordart":
-    case "vml_shape":
-      expectString(record.rawXml, `${path}.rawXml`, issues);
-      return;
-    default:
-      issues.push({
-        path: `${path}.type`,
-        message: `Unsupported node type ${JSON.stringify(type)}.`,
-      });
-  }
-}
-
-function validateFloatingImageProperties(
-  value: unknown,
-  path: string,
-  issues: ModelValidationIssue[],
-): void {
-  const record = asPlainObject(value, path, issues);
-  if (!record) {
-    return;
-  }
-
-  if (record.horizontalPosition !== undefined) {
-    validateFloatingAxisPosition(record.horizontalPosition, `${path}.horizontalPosition`, issues);
-  }
-  if (record.verticalPosition !== undefined) {
-    validateFloatingAxisPosition(record.verticalPosition, `${path}.verticalPosition`, issues);
-  }
-  if (record.wrap !== undefined) {
-    const wrap = expectString(record.wrap, `${path}.wrap`, issues);
-    if (
-      wrap &&
-      wrap !== "none" &&
-      wrap !== "square" &&
-      wrap !== "tight" &&
-      wrap !== "through" &&
-      wrap !== "topAndBottom"
-    ) {
-      issues.push({
-        path: `${path}.wrap`,
-        message: "wrap must be one of none, square, tight, through, or topAndBottom.",
-      });
-    }
-  }
-}
-
-function validateFloatingAxisPosition(
-  value: unknown,
-  path: string,
-  issues: ModelValidationIssue[],
-): void {
-  const record = asPlainObject(value, path, issues);
-  if (!record) {
-    return;
-  }
-
-  if (record.relativeFrom !== undefined) {
-    expectString(record.relativeFrom, `${path}.relativeFrom`, issues);
-  }
-  if (record.align !== undefined) {
-    expectString(record.align, `${path}.align`, issues);
-  }
-  if (record.offset !== undefined && typeof record.offset !== "number") {
-    issues.push({
-      path: `${path}.offset`,
-      message: "offset must be a number.",
-    });
-  }
-}
-
-function validateReviewStore(
-  value: unknown,
-  path: string,
-  issues: ModelValidationIssue[],
-): void {
-  const record = asPlainObject(value, path, issues);
-  if (!record) {
-    return;
-  }
-
-  const comments = asPlainObject(record.comments, `${path}.comments`, issues);
-  if (comments) {
-    for (const [commentId, thread] of Object.entries(comments)) {
-      expectDomainString(commentId, "commentId", `${path}.comments.${commentId}`, issues);
-      const threadRecord = asPlainObject(thread, `${path}.comments.${commentId}`, issues);
-      if (!threadRecord) {
-        continue;
-      }
-      if (threadRecord.commentId !== commentId) {
-        issues.push({
-          path: `${path}.comments.${commentId}.commentId`,
-          message: "commentId must match the map key.",
-        });
-      }
-      validateAnchor(threadRecord.anchor, `${path}.comments.${commentId}.anchor`, issues);
-      expectIso8601UtcTimestamp(
-        threadRecord.createdAt,
-        `${path}.comments.${commentId}.createdAt`,
-        issues,
-      );
-      validateCommentStatus(threadRecord.status, `${path}.comments.${commentId}.status`, issues);
-      if (threadRecord.createdBy !== undefined) {
-        expectString(
-          threadRecord.createdBy,
-          `${path}.comments.${commentId}.createdBy`,
-          issues,
-        );
-      }
-      if (threadRecord.authorId !== undefined) {
-        expectString(
-          threadRecord.authorId,
-          `${path}.comments.${commentId}.authorId`,
-          issues,
-        );
-      }
-      if (threadRecord.body !== undefined) {
-        expectString(threadRecord.body, `${path}.comments.${commentId}.body`, issues);
-      }
-      if (!Array.isArray(threadRecord.warningIds)) {
-        issues.push({
-          path: `${path}.comments.${commentId}.warningIds`,
-          message: "warningIds must be an array.",
-        });
-      } else {
-        threadRecord.warningIds.forEach((warningId, index) =>
-          expectDomainString(
-            warningId,
-            "warningId",
-            `${path}.comments.${commentId}.warningIds[${index}]`,
-            issues,
-          ),
-        );
-      }
-      if (threadRecord.entries !== undefined) {
-        validateCommentEntries(
-          threadRecord.entries,
-          `${path}.comments.${commentId}.entries`,
-          issues,
-        );
-      }
-      if (threadRecord.resolution !== undefined) {
-        validateCommentResolution(
-          threadRecord.resolution,
-          `${path}.comments.${commentId}.resolution`,
-          issues,
-        );
-      }
-      if (threadRecord.resolvedAt !== undefined) {
-        expectIso8601UtcTimestamp(
-          threadRecord.resolvedAt,
-          `${path}.comments.${commentId}.resolvedAt`,
-          issues,
-        );
-      }
-      if (
-        threadRecord.isResolved !== undefined &&
-        typeof threadRecord.isResolved !== "boolean"
-      ) {
-        issues.push({
-          path: `${path}.comments.${commentId}.isResolved`,
-          message: "isResolved must be a boolean.",
-        });
-      }
-      if (threadRecord.metadata !== undefined) {
-        validateCommentThreadMetadata(
-          threadRecord.metadata,
-          `${path}.comments.${commentId}.metadata`,
-          issues,
-        );
-      }
-    }
-  }
-
-  const revisions = asPlainObject(record.revisions, `${path}.revisions`, issues);
-  if (revisions) {
-    for (const [revisionId, revision] of Object.entries(revisions)) {
-      expectDomainString(revisionId, "revisionId", `${path}.revisions.${revisionId}`, issues);
-      const revisionRecord = asPlainObject(
-        revision,
-        `${path}.revisions.${revisionId}`,
-        issues,
-      );
-      if (!revisionRecord) {
-        continue;
-      }
-      if (revisionRecord.changeId !== revisionId) {
-        issues.push({
-          path: `${path}.revisions.${revisionId}.changeId`,
-          message: "changeId must match the map key.",
-        });
-      }
-      validateAnchor(revisionRecord.anchor, `${path}.revisions.${revisionId}.anchor`, issues);
-      validateRevisionKind(revisionRecord.kind, `${path}.revisions.${revisionId}.kind`, issues);
-      validateRevisionStatus(
-        revisionRecord.status,
-        `${path}.revisions.${revisionId}.status`,
-        issues,
-      );
-      expectIso8601UtcTimestamp(
-        revisionRecord.createdAt,
-        `${path}.revisions.${revisionId}.createdAt`,
-        issues,
-      );
-      if (revisionRecord.authorId !== undefined) {
-        expectString(
-          revisionRecord.authorId,
-          `${path}.revisions.${revisionId}.authorId`,
-          issues,
-        );
-      }
-      if (revisionRecord.warningIds !== undefined) {
-        validateWarningIds(
-          revisionRecord.warningIds,
-          `${path}.revisions.${revisionId}.warningIds`,
-          issues,
-        );
-      }
-      if (revisionRecord.metadata !== undefined) {
-        validateRevisionMetadata(
-          revisionRecord.metadata,
-          `${path}.revisions.${revisionId}.metadata`,
-          issues,
-        );
-      }
-    }
-  }
-}
-
-function validateCommentStatus(
-  value: unknown,
-  path: string,
-  issues: ModelValidationIssue[],
-): void {
-  if (value === "open" || value === "resolved" || value === "detached") {
-    return;
-  }
-  issues.push({
-    path,
-    message: "status must be one of open, resolved, or detached.",
-  });
-}
-
-function validateCommentEntries(
-  value: unknown,
-  path: string,
-  issues: ModelValidationIssue[],
-): void {
-  if (!Array.isArray(value)) {
-    issues.push({
-      path,
-      message: "entries must be an array.",
-    });
-    return;
-  }
-
-  value.forEach((entry, index) => {
-    const record = asPlainObject(entry, `${path}[${index}]`, issues);
-    if (!record) {
-      return;
-    }
-    expectString(record.entryId, `${path}[${index}].entryId`, issues);
-    expectString(record.authorId, `${path}[${index}].authorId`, issues);
-    expectString(record.body, `${path}[${index}].body`, issues);
-    expectIso8601UtcTimestamp(record.createdAt, `${path}[${index}].createdAt`, issues);
-    if (record.metadata !== undefined) {
-      validateCommentEntryMetadata(record.metadata, `${path}[${index}].metadata`, issues);
-    }
-  });
-}
-
-function validateCommentEntryMetadata(
-  value: unknown,
-  path: string,
-  issues: ModelValidationIssue[],
-): void {
-  const record = asPlainObject(value, path, issues);
-  if (!record) {
-    return;
-  }
-
-  for (const field of [
-    "ooxmlCommentId",
-    "paraId",
-    "parentParaId",
-    "durableId",
-    "initials",
-  ] as const) {
-    if (record[field] !== undefined) {
-      expectString(record[field], `${path}.${field}`, issues);
-    }
-  }
-}
-
-function validateCommentResolution(
-  value: unknown,
-  path: string,
-  issues: ModelValidationIssue[],
-): void {
-  const record = asPlainObject(value, path, issues);
-  if (!record) {
-    return;
-  }
-
-  expectIso8601UtcTimestamp(record.resolvedAt, `${path}.resolvedAt`, issues);
-  expectString(record.resolvedBy, `${path}.resolvedBy`, issues);
-}
-
-function validateCommentThreadMetadata(
-  value: unknown,
-  path: string,
-  issues: ModelValidationIssue[],
-): void {
-  const record = asPlainObject(value, path, issues);
-  if (!record) {
-    return;
-  }
-
-  if (
-    record.source !== undefined &&
-    record.source !== "runtime" &&
-    record.source !== "import"
-  ) {
-    issues.push({
-      path: `${path}.source`,
-      message: "source must be either runtime or import.",
-    });
-  }
-  if (record.rootOoxmlCommentId !== undefined) {
-    expectString(record.rootOoxmlCommentId, `${path}.rootOoxmlCommentId`, issues);
-  }
-  if (record.rootParaId !== undefined) {
-    expectString(record.rootParaId, `${path}.rootParaId`, issues);
-  }
-}
-
-function validateRevisionKind(
-  value: unknown,
-  path: string,
-  issues: ModelValidationIssue[],
-): void {
-  if (
-    value === "insertion" ||
-    value === "deletion" ||
-    value === "formatting" ||
-    value === "move" ||
-    value === "property-change"
-  ) {
-    return;
-  }
-  issues.push({
-    path,
-    message: "kind must be insertion, deletion, formatting, move, or property-change.",
-  });
-}
-
-function validateRevisionStatus(
-  value: unknown,
-  path: string,
-  issues: ModelValidationIssue[],
-): void {
-  if (
-    value === "open" ||
-    value === "accepted" ||
-    value === "rejected" ||
-    value === "detached"
-  ) {
-    return;
-  }
-  issues.push({
-    path,
-    message: "status must be one of open, accepted, rejected, or detached.",
-  });
-}
-
-function validateWarningIds(
-  value: unknown,
-  path: string,
-  issues: ModelValidationIssue[],
-): void {
-  if (!Array.isArray(value)) {
-    issues.push({
-      path,
-      message: "warningIds must be an array.",
-    });
-    return;
-  }
-
-  value.forEach((warningId, index) =>
-    expectDomainString(warningId, "warningId", `${path}[${index}]`, issues),
-  );
-}
-
-function validateRevisionMetadata(
-  value: unknown,
-  path: string,
-  issues: ModelValidationIssue[],
-): void {
-  const record = asPlainObject(value, path, issues);
-  if (!record) {
-    return;
-  }
-
-  if (
-    record.source !== undefined &&
-    record.source !== "runtime" &&
-    record.source !== "import"
-  ) {
-    issues.push({
-      path: `${path}.source`,
-      message: "source must be either runtime or import.",
-    });
-  }
-  for (const field of [
-    "preserveOnlyReason",
-    "importedRevisionForm",
-    "originalRevisionType",
-    "ooxmlRevisionId",
-  ] as const) {
-    if (record[field] !== undefined) {
-      expectString(record[field], `${path}.${field}`, issues);
-    }
-  }
-
-  if (record.propertyChangeData !== undefined) {
-    const pcd = asPlainObject(record.propertyChangeData, `${path}.propertyChangeData`, issues);
-    if (pcd) {
-      expectString(pcd.xmlTag, `${path}.propertyChangeData.xmlTag`, issues);
-      expectString(pcd.beforeXml, `${path}.propertyChangeData.beforeXml`, issues);
-    }
-  }
-
-  if (record.moveData !== undefined) {
-    const md = asPlainObject(record.moveData, `${path}.moveData`, issues);
-    if (md) {
-      expectString(md.moveId, `${path}.moveData.moveId`, issues);
-      expectString(md.direction, `${path}.moveData.direction`, issues);
-    }
-  }
-}
-
-function validatePreservationStore(
-  value: unknown,
-  path: string,
-  issues: ModelValidationIssue[],
-): void {
-  const record = asPlainObject(value, path, issues);
-  if (!record) {
-    return;
-  }
-
-  const opaqueFragments = asPlainObject(
-    record.opaqueFragments,
-    `${path}.opaqueFragments`,
-    issues,
-  );
-  if (opaqueFragments) {
-    for (const [fragmentId, fragment] of Object.entries(opaqueFragments)) {
-      expectDomainString(fragmentId, "fragmentId", `${path}.opaqueFragments.${fragmentId}`, issues);
-      const fragmentRecord = asPlainObject(
-        fragment,
-        `${path}.opaqueFragments.${fragmentId}`,
-        issues,
-      );
-      if (!fragmentRecord) {
-        continue;
-      }
-      if (fragmentRecord.fragmentId !== fragmentId) {
-        issues.push({
-          path: `${path}.opaqueFragments.${fragmentId}.fragmentId`,
-          message: "fragmentId must match the map key.",
-        });
-      }
-      validateRange(
-        fragmentRecord.lastKnownRange,
-        `${path}.opaqueFragments.${fragmentId}.lastKnownRange`,
-        issues,
-      );
-      expectDomainString(
-        fragmentRecord.warningId,
-        "warningId",
-        `${path}.opaqueFragments.${fragmentId}.warningId`,
-        issues,
-      );
-      if (fragmentRecord.packagePartName !== undefined) {
-        expectDomainString(
-          fragmentRecord.packagePartName,
-          "packagePartName",
-          `${path}.opaqueFragments.${fragmentId}.packagePartName`,
-          issues,
-        );
-      }
-      if (fragmentRecord.relationshipId !== undefined) {
-        expectDomainString(
-          fragmentRecord.relationshipId,
-          "relationshipId",
-          `${path}.opaqueFragments.${fragmentId}.relationshipId`,
-          issues,
-        );
-      }
-    }
-  }
-
-  const packageParts = asPlainObject(record.packageParts, `${path}.packageParts`, issues);
-  if (packageParts) {
-    for (const [packagePartName, packagePart] of Object.entries(packageParts)) {
-      expectDomainString(
-        packagePartName,
-        "packagePartName",
-        `${path}.packageParts.${packagePartName}`,
-        issues,
-      );
-      const packagePartRecord = asPlainObject(
-        packagePart,
-        `${path}.packageParts.${packagePartName}`,
-        issues,
-      );
-      if (!packagePartRecord) {
-        continue;
-      }
-      if (packagePartRecord.packagePartName !== packagePartName) {
-        issues.push({
-          path: `${path}.packageParts.${packagePartName}.packagePartName`,
-          message: "packagePartName must match the map key.",
-        });
-      }
-      if (Array.isArray(packagePartRecord.relationshipIds)) {
-        packagePartRecord.relationshipIds.forEach((relationshipId, index) =>
-          expectDomainString(
-            relationshipId,
-            "relationshipId",
-            `${path}.packageParts.${packagePartName}.relationshipIds[${index}]`,
-            issues,
-          ),
-        );
-      }
-    }
-  }
-}
-
-function validateDiagnosticStore(
-  value: unknown,
-  path: string,
-  issues: ModelValidationIssue[],
-): void {
-  const record = asPlainObject(value, path, issues);
-  if (!record) {
-    return;
-  }
-
-  if (Array.isArray(record.warnings)) {
-    record.warnings.forEach((warning, index) => {
-      const warningRecord = asPlainObject(warning, `${path}.warnings[${index}]`, issues);
-      if (!warningRecord) {
-        return;
-      }
-      expectDomainString(
-        warningRecord.diagnosticId,
-        "diagnosticId",
-        `${path}.warnings[${index}].diagnosticId`,
-        issues,
-      );
-      expectDomainString(
-        warningRecord.warningId,
-        "warningId",
-        `${path}.warnings[${index}].warningId`,
-        issues,
-      );
-    });
-  }
-
-  if (Array.isArray(record.errors)) {
-    record.errors.forEach((error, index) => {
-      const errorRecord = asPlainObject(error, `${path}.errors[${index}]`, issues);
-      if (!errorRecord) {
-        return;
-      }
-      expectDomainString(
-        errorRecord.diagnosticId,
-        "diagnosticId",
-        `${path}.errors[${index}].diagnosticId`,
-        issues,
-      );
-    });
-  }
-}
-
-function validateAnchor(
-  value: unknown,
-  path: string,
-  issues: ModelValidationIssue[],
-): void {
-  const record = asPlainObject(value, path, issues);
-  if (!record) {
-    return;
-  }
-
-  const kind = expectString(record.kind, `${path}.kind`, issues);
-  if (!kind) {
-    return;
-  }
-
-  if (kind === "range") {
-    validateRange(record.range, `${path}.range`, issues);
-  } else if (kind === "detached") {
-    validateRange(record.lastKnownRange, `${path}.lastKnownRange`, issues);
-  }
-}
-
-function validateRange(
-  value: unknown,
-  path: string,
-  issues: ModelValidationIssue[],
-): void {
-  const record = asPlainObject(value, path, issues);
-  if (!record) {
-    return;
-  }
-
-  if (typeof record.from !== "number" || typeof record.to !== "number") {
-    issues.push({
-      path,
-      message: "Range must contain numeric from and to values.",
-    });
-  }
-}
-
-function validateExactObjectKeys(
-  record: Record<string, unknown>,
-  expectedKeys: readonly string[],
-  path: string,
-  issues: ModelValidationIssue[],
-  allowedOptionalKeys?: readonly string[],
-): void {
-  const actualKeys = new Set(Object.keys(record));
-  const expected = new Set(expectedKeys);
-  const optional = new Set(allowedOptionalKeys ?? []);
-
-  for (const expectedKey of expectedKeys) {
-    if (!actualKeys.has(expectedKey)) {
-      issues.push({
-        path,
-        message: `Missing required key ${JSON.stringify(expectedKey)}.`,
-      });
-    }
-  }
-
-  for (const actualKey of actualKeys) {
-    if (!expected.has(actualKey) && !optional.has(actualKey)) {
-      issues.push({
-        path: `${path}.${actualKey}`,
-        message:
-          "Unexpected canonical document key. Render/UI state is not part of the canonical envelope.",
-      });
-    }
-  }
-}
-
-function validateSubPartsCatalog(
-  value: unknown,
-  path: string,
-  issues: ModelValidationIssue[],
-): void {
-  const record = asPlainObject(value, path, issues);
-  if (!record) {
-    return;
-  }
-
-  if (record.headers !== undefined) {
-    if (!Array.isArray(record.headers)) {
-      issues.push({ path: `${path}.headers`, message: "headers must be an array." });
-    } else {
-      record.headers.forEach((header, index) => {
-        const headerRecord = asPlainObject(header, `${path}.headers[${index}]`, issues);
-        if (headerRecord) {
-          expectString(headerRecord.variant, `${path}.headers[${index}].variant`, issues);
-          expectString(headerRecord.partPath, `${path}.headers[${index}].partPath`, issues);
-          expectString(headerRecord.relationshipId, `${path}.headers[${index}].relationshipId`, issues);
-        }
-      });
-    }
-  }
-
-  if (record.footers !== undefined) {
-    if (!Array.isArray(record.footers)) {
-      issues.push({ path: `${path}.footers`, message: "footers must be an array." });
-    } else {
-      record.footers.forEach((footer, index) => {
-        const footerRecord = asPlainObject(footer, `${path}.footers[${index}]`, issues);
-        if (footerRecord) {
-          expectString(footerRecord.variant, `${path}.footers[${index}].variant`, issues);
-          expectString(footerRecord.partPath, `${path}.footers[${index}].partPath`, issues);
-          expectString(footerRecord.relationshipId, `${path}.footers[${index}].relationshipId`, issues);
-        }
-      });
-    }
-  }
-}
-
-function expectDomainString(
-  value: unknown,
-  domain: StableIdDomain,
-  path: string,
-  issues: ModelValidationIssue[],
-): string | null {
-  const stableId = expectString(value, path, issues);
-  if (!stableId) {
-    return null;
-  }
-
-  if (!ID_PATTERNS[domain].test(stableId)) {
-    issues.push({
-      path,
-      message: `Expected a valid ${domain}.`,
-    });
-    return null;
-  }
-
-  return stableId;
-}