@mmapp/player-core 0.1.0-alpha.1

package/src/validation/definition-validator.ts

@@ -0,0 +1,812 @@
+/**
+ * Definition Validator — static validation of compiled IR definitions.
+ *
+ * Validates structural integrity, referential consistency, and semantic
+ * correctness of IRWorkflowDefinition before it reaches the runtime.
+ *
+ * Categories:
+ * - STRUCTURAL: Missing required fields, type mismatches
+ * - REFERENTIAL: Dangling state refs, missing transition targets
+ * - SEMANTIC: Unreachable states, dead transitions, missing START
+ * - EXPERIENCE: Unknown components, invalid bindings, missing data sources
+ */
+
+import type {
+  IRWorkflowDefinition,
+  IRStateDefinition,
+  IRTransitionDefinition,
+  IRFieldDefinition,
+  IRExperienceNode,
+  IRActionDefinition,
+  IRDuringAction,
+} from '../dsl/ir-types';
+
+// =============================================================================
+// Types
+// =============================================================================
+
+export type ValidationSeverity = 'error' | 'warning' | 'info';
+
+export type ValidationCategory =
+  | 'structural'
+  | 'referential'
+  | 'semantic'
+  | 'experience';
+
+export interface ValidationIssue {
+  /** Unique code for programmatic matching. */
+  code: string;
+  /** Human-readable message. */
+  message: string;
+  /** Severity level. */
+  severity: ValidationSeverity;
+  /** Validation category. */
+  category: ValidationCategory;
+  /** Location path (e.g., 'states[0].on_enter[1]'). */
+  path?: string;
+  /** Suggested fix. */
+  suggestion?: string;
+}
+
+export interface ValidationResult {
+  /** Whether the definition passed all error-level checks. */
+  valid: boolean;
+  /** All issues found. */
+  issues: ValidationIssue[];
+  /** Quick access to error count. */
+  errorCount: number;
+  /** Quick access to warning count. */
+  warningCount: number;
+  /** Summary statistics. */
+  summary: {
+    stateCount: number;
+    transitionCount: number;
+    fieldCount: number;
+    hasExperience: boolean;
+    hasExtensions: boolean;
+  };
+}
+
+export interface ValidatorOptions {
+  /** Known component IDs (for experience validation). */
+  knownComponents?: string[];
+  /** Known binding roots (default: $instance, $definition, $instances, $local, $entity, $user, $fn, $action, $item, $index). */
+  knownBindingRoots?: string[];
+  /** Skip experience tree validation. */
+  skipExperience?: boolean;
+  /** Skip semantic analysis (reachability, etc.). */
+  skipSemantic?: boolean;
+}
+
+// =============================================================================
+// Default known binding roots
+// =============================================================================
+
+const DEFAULT_BINDING_ROOTS = [
+  '$instance', '$definition', '$instances', '$local',
+  '$entity', '$user', '$fn', '$action', '$item', '$index',
+  '$pagination',
+];
+
+// =============================================================================
+// Validator
+// =============================================================================
+
+/**
+ * Validates an IRWorkflowDefinition for structural, referential,
+ * semantic, and experience correctness.
+ */
+export function validateDefinition(
+  def: IRWorkflowDefinition,
+  options: ValidatorOptions = {},
+): ValidationResult {
+  const issues: ValidationIssue[] = [];
+  const knownRoots = options.knownBindingRoots ?? DEFAULT_BINDING_ROOTS;
+
+  // Structural validation
+  validateStructure(def, issues);
+
+  // Referential validation
+  validateReferences(def, issues);
+
+  // Semantic validation
+  if (!options.skipSemantic) {
+    validateSemantics(def, issues);
+  }
+
+  // Experience tree validation
+  if (!options.skipExperience && def.metadata?.experience) {
+    validateExperienceTree(
+      def.metadata.experience as IRExperienceNode,
+      options.knownComponents,
+      knownRoots,
+      issues,
+    );
+  }
+
+  const errorCount = issues.filter(i => i.severity === 'error').length;
+  const warningCount = issues.filter(i => i.severity === 'warning').length;
+
+  return {
+    valid: errorCount === 0,
+    issues,
+    errorCount,
+    warningCount,
+    summary: {
+      stateCount: def.states?.length ?? 0,
+      transitionCount: def.transitions?.length ?? 0,
+      fieldCount: def.fields?.length ?? 0,
+      hasExperience: !!def.metadata?.experience,
+      hasExtensions: !!def.extensions && Object.keys(def.extensions).length > 0,
+    },
+  };
+}
+
+// =============================================================================
+// Structural Validation
+// =============================================================================
+
+function validateStructure(def: IRWorkflowDefinition, issues: ValidationIssue[]): void {
+  // Required top-level fields
+  if (!def.slug) {
+    issues.push({
+      code: 'MISSING_SLUG',
+      message: 'Workflow definition is missing a slug',
+      severity: 'error',
+      category: 'structural',
+      suggestion: 'Add a slug field to the workflow definition',
+    });
+  }
+
+  if (!def.name) {
+    issues.push({
+      code: 'MISSING_NAME',
+      message: 'Workflow definition is missing a name',
+      severity: 'warning',
+      category: 'structural',
+      suggestion: 'Add a name field to the workflow definition',
+    });
+  }
+
+  if (!def.version) {
+    issues.push({
+      code: 'MISSING_VERSION',
+      message: 'Workflow definition is missing a version',
+      severity: 'warning',
+      category: 'structural',
+      suggestion: 'Add a version field (e.g., "1.0.0")',
+    });
+  }
+
+  if (!def.states || def.states.length === 0) {
+    issues.push({
+      code: 'NO_STATES',
+      message: 'Workflow definition has no states',
+      severity: 'error',
+      category: 'structural',
+      suggestion: 'Add at least one state with type START',
+    });
+    return; // Can't validate further without states
+  }
+
+  // Validate each state
+  for (let i = 0; i < def.states.length; i++) {
+    validateState(def.states[i], i, issues);
+  }
+
+  // Validate transitions
+  if (def.transitions) {
+    for (let i = 0; i < def.transitions.length; i++) {
+      validateTransitionStructure(def.transitions[i], i, issues);
+    }
+  }
+
+  // Validate fields
+  if (def.fields) {
+    const fieldNames = new Set<string>();
+    for (let i = 0; i < def.fields.length; i++) {
+      validateFieldStructure(def.fields[i], i, fieldNames, issues);
+    }
+  }
+}
+
+function validateState(state: IRStateDefinition, index: number, issues: ValidationIssue[]): void {
+  const path = `states[${index}]`;
+
+  if (!state.name) {
+    issues.push({
+      code: 'STATE_MISSING_NAME',
+      message: `State at index ${index} is missing a name`,
+      severity: 'error',
+      category: 'structural',
+      path,
+    });
+  }
+
+  // Accept both 'type' (v1.1+) and 'state_type' (v1.0) naming
+  const stateType = state.type || (state as any).state_type;
+  if (!stateType) {
+    issues.push({
+      code: 'STATE_MISSING_TYPE',
+      message: `State '${state.name || index}' is missing a type`,
+      severity: 'error',
+      category: 'structural',
+      path,
+      suggestion: 'Set type to START, REGULAR, END, or CANCELLED',
+    });
+  }
+
+  // Validate on_enter actions
+  if (state.on_enter) {
+    for (let j = 0; j < state.on_enter.length; j++) {
+      validateAction(state.on_enter[j], `${path}.on_enter[${j}]`, issues);
+    }
+  }
+
+  // Validate on_exit actions
+  if (state.on_exit) {
+    for (let j = 0; j < state.on_exit.length; j++) {
+      validateAction(state.on_exit[j], `${path}.on_exit[${j}]`, issues);
+    }
+  }
+
+  // Validate during actions
+  if (state.during) {
+    for (let j = 0; j < state.during.length; j++) {
+      validateDuringAction(state.during[j], `${path}.during[${j}]`, issues);
+    }
+  }
+}
+
+function validateAction(action: IRActionDefinition, path: string, issues: ValidationIssue[]): void {
+  // Accept both 'type' and 'action_type' (compiled output uses action_type)
+  const actionType = action.type || (action as any).action_type;
+  if (!action.id) {
+    issues.push({
+      code: 'ACTION_MISSING_ID',
+      message: `Action at ${path} is missing an id`,
+      severity: 'warning',
+      category: 'structural',
+      path,
+    });
+  }
+
+  if (!actionType) {
+    issues.push({
+      code: 'ACTION_MISSING_TYPE',
+      message: `Action '${action.id || 'unknown'}' at ${path} is missing a type`,
+      severity: 'error',
+      category: 'structural',
+      path,
+      suggestion: 'Add a type field (e.g., "set_field", "set_memory")',
+    });
+  }
+}
+
+function validateDuringAction(during: IRDuringAction, path: string, issues: ValidationIssue[]): void {
+  if (!during.type) {
+    issues.push({
+      code: 'DURING_MISSING_TYPE',
+      message: `During action at ${path} is missing a type`,
+      severity: 'error',
+      category: 'structural',
+      path,
+      suggestion: 'Set type to interval, timeout, poll, once, or cron',
+    });
+  }
+
+  if (during.type === 'interval' && !during.interval_ms) {
+    issues.push({
+      code: 'DURING_MISSING_INTERVAL',
+      message: `Interval during action at ${path} is missing interval_ms`,
+      severity: 'error',
+      category: 'structural',
+      path,
+      suggestion: 'Set interval_ms to a positive number (milliseconds)',
+    });
+  }
+
+  if (during.type === 'cron' && !during.cron) {
+    issues.push({
+      code: 'DURING_MISSING_CRON',
+      message: `Cron during action at ${path} is missing cron expression`,
+      severity: 'error',
+      category: 'structural',
+      path,
+    });
+  }
+}
+
+function validateTransitionStructure(
+  transition: IRTransitionDefinition,
+  index: number,
+  issues: ValidationIssue[]
+): void {
+  const path = `transitions[${index}]`;
+
+  if (!transition.name) {
+    issues.push({
+      code: 'TRANSITION_MISSING_NAME',
+      message: `Transition at index ${index} is missing a name`,
+      severity: 'error',
+      category: 'structural',
+      path,
+    });
+  }
+
+  if (!transition.from || transition.from.length === 0) {
+    issues.push({
+      code: 'TRANSITION_MISSING_FROM',
+      message: `Transition '${transition.name || index}' has no source states`,
+      severity: 'error',
+      category: 'structural',
+      path,
+      suggestion: 'Add at least one source state in the from array',
+    });
+  }
+
+  if (!transition.to) {
+    issues.push({
+      code: 'TRANSITION_MISSING_TO',
+      message: `Transition '${transition.name || index}' has no target state`,
+      severity: 'error',
+      category: 'structural',
+      path,
+      suggestion: 'Set the to field to a valid state name',
+    });
+  }
+}
+
+function validateFieldStructure(
+  field: IRFieldDefinition,
+  index: number,
+  seen: Set<string>,
+  issues: ValidationIssue[]
+): void {
+  const path = `fields[${index}]`;
+
+  if (!field.name) {
+    issues.push({
+      code: 'FIELD_MISSING_NAME',
+      message: `Field at index ${index} is missing a name`,
+      severity: 'error',
+      category: 'structural',
+      path,
+    });
+    return;
+  }
+
+  if (seen.has(field.name)) {
+    issues.push({
+      code: 'DUPLICATE_FIELD',
+      message: `Duplicate field name '${field.name}'`,
+      severity: 'error',
+      category: 'structural',
+      path,
+      suggestion: `Rename one of the '${field.name}' fields`,
+    });
+  }
+  seen.add(field.name);
+
+  // Accept both 'type' and 'field_type' (compiled output uses field_type)
+  const fieldType = field.type || (field as any).field_type;
+  if (!fieldType) {
+    issues.push({
+      code: 'FIELD_MISSING_TYPE',
+      message: `Field '${field.name}' is missing a type`,
+      severity: 'error',
+      category: 'structural',
+      path,
+      suggestion: 'Add a type field (e.g., "text", "number", "boolean")',
+    });
+  }
+}
+
+// =============================================================================
+// Referential Validation
+// =============================================================================
+
+function validateReferences(def: IRWorkflowDefinition, issues: ValidationIssue[]): void {
+  const stateNames = new Set((def.states || []).map(s => s.name));
+  const fieldNames = new Set((def.fields || []).map(f => f.name));
+
+  // Validate transition references
+  if (def.transitions) {
+    for (let i = 0; i < def.transitions.length; i++) {
+      const t = def.transitions[i];
+      const path = `transitions[${i}]`;
+
+      // Check from states exist
+      if (t.from) {
+        for (const fromState of t.from) {
+          if (!stateNames.has(fromState)) {
+            issues.push({
+              code: 'TRANSITION_UNKNOWN_FROM',
+              message: `Transition '${t.name}' references unknown source state '${fromState}'`,
+              severity: 'error',
+              category: 'referential',
+              path,
+              suggestion: `Valid states: ${Array.from(stateNames).join(', ')}`,
+            });
+          }
+        }
+      }
+
+      // Check to state exists
+      if (t.to && !stateNames.has(t.to)) {
+        issues.push({
+          code: 'TRANSITION_UNKNOWN_TO',
+          message: `Transition '${t.name}' references unknown target state '${t.to}'`,
+          severity: 'error',
+          category: 'referential',
+          path,
+          suggestion: `Valid states: ${Array.from(stateNames).join(', ')}`,
+        });
+      }
+
+      // Check required_fields references
+      if (t.required_fields) {
+        for (const rf of t.required_fields) {
+          if (!fieldNames.has(rf)) {
+            issues.push({
+              code: 'TRANSITION_UNKNOWN_FIELD',
+              message: `Transition '${t.name}' requires unknown field '${rf}'`,
+              severity: 'warning',
+              category: 'referential',
+              path,
+            });
+          }
+        }
+      }
+    }
+  }
+
+  // Validate field references in actions
+  if (def.states) {
+    for (let i = 0; i < def.states.length; i++) {
+      const state = def.states[i];
+      validateActionFieldRefs(state.on_enter, fieldNames, `states[${i}].on_enter`, issues);
+      validateActionFieldRefs(state.on_exit, fieldNames, `states[${i}].on_exit`, issues);
+    }
+  }
+
+  // Validate field visible_in_states and editable_in_states
+  if (def.fields) {
+    for (let i = 0; i < def.fields.length; i++) {
+      const field = def.fields[i];
+      const path = `fields[${i}]`;
+
+      if (field.visible_in_states) {
+        for (const s of field.visible_in_states) {
+          if (!stateNames.has(s)) {
+            issues.push({
+              code: 'FIELD_UNKNOWN_STATE',
+              message: `Field '${field.name}' references unknown state '${s}' in visible_in_states`,
+              severity: 'warning',
+              category: 'referential',
+              path,
+            });
+          }
+        }
+      }
+
+      if (field.editable_in_states) {
+        for (const s of field.editable_in_states) {
+          if (!stateNames.has(s)) {
+            issues.push({
+              code: 'FIELD_UNKNOWN_STATE',
+              message: `Field '${field.name}' references unknown state '${s}' in editable_in_states`,
+              severity: 'warning',
+              category: 'referential',
+              path,
+            });
+          }
+        }
+      }
+    }
+  }
+}
+
+function validateActionFieldRefs(
+  actions: IRActionDefinition[] | undefined,
+  fieldNames: Set<string>,
+  basePath: string,
+  issues: ValidationIssue[]
+): void {
+  if (!actions) return;
+  for (let j = 0; j < actions.length; j++) {
+    const action = actions[j];
+    const actionType = action.type || (action as any).action_type;
+    if (actionType === 'set_field' && action.config?.field) {
+      const fieldName = String(action.config.field);
+      if (!fieldNames.has(fieldName)) {
+        issues.push({
+          code: 'ACTION_UNKNOWN_FIELD',
+          message: `Action '${action.id}' references unknown field '${fieldName}'`,
+          severity: 'warning',
+          category: 'referential',
+          path: `${basePath}[${j}]`,
+          suggestion: `Declare field '${fieldName}' in the fields array`,
+        });
+      }
+    }
+  }
+}
+
+// =============================================================================
+// Semantic Validation
+// =============================================================================
+
+/** Get state type, accepting both v1.0 (state_type) and v1.1+ (type) naming. */
+function getStateType(state: IRStateDefinition): string | undefined {
+  return state.type || (state as any).state_type;
+}
+
+function validateSemantics(def: IRWorkflowDefinition, issues: ValidationIssue[]): void {
+  if (!def.states || def.states.length === 0) return;
+
+  // Check for exactly one START state
+  const startStates = def.states.filter(s => getStateType(s) === 'START');
+  if (startStates.length === 0) {
+    issues.push({
+      code: 'NO_START_STATE',
+      message: 'Workflow has no START state',
+      severity: 'error',
+      category: 'semantic',
+      suggestion: 'Mark one state with type: "START"',
+    });
+  } else if (startStates.length > 1) {
+    issues.push({
+      code: 'MULTIPLE_START_STATES',
+      message: `Workflow has ${startStates.length} START states: ${startStates.map(s => s.name).join(', ')}`,
+      severity: 'error',
+      category: 'semantic',
+      suggestion: 'Only one state should have type: "START"',
+    });
+  }
+
+  // Check for duplicate state names
+  const stateNameCounts = new Map<string, number>();
+  for (const state of def.states) {
+    const count = stateNameCounts.get(state.name) || 0;
+    stateNameCounts.set(state.name, count + 1);
+  }
+  for (const [name, count] of stateNameCounts) {
+    if (count > 1) {
+      issues.push({
+        code: 'DUPLICATE_STATE',
+        message: `Duplicate state name '${name}' (appears ${count} times)`,
+        severity: 'error',
+        category: 'semantic',
+      });
+    }
+  }
+
+  // Check for duplicate transition names
+  if (def.transitions) {
+    const transitionNames = new Map<string, number>();
+    for (const t of def.transitions) {
+      const count = transitionNames.get(t.name) || 0;
+      transitionNames.set(t.name, count + 1);
+    }
+    for (const [name, count] of transitionNames) {
+      if (count > 1) {
+        issues.push({
+          code: 'DUPLICATE_TRANSITION',
+          message: `Duplicate transition name '${name}' (appears ${count} times)`,
+          severity: 'warning',
+          category: 'semantic',
+          suggestion: 'Consider using unique transition names for clarity',
+        });
+      }
+    }
+  }
+
+  // Check for unreachable states (no transition leads to them, except START)
+  if (def.transitions && def.transitions.length > 0) {
+    const reachableStates = new Set<string>();
+    // START states are always reachable
+    for (const state of startStates) {
+      reachableStates.add(state.name);
+    }
+    // States that are transition targets are reachable
+    for (const t of def.transitions) {
+      if (t.to) reachableStates.add(t.to);
+    }
+    // Check each state
+    for (const state of def.states) {
+      if (!reachableStates.has(state.name)) {
+        issues.push({
+          code: 'UNREACHABLE_STATE',
+          message: `State '${state.name}' is unreachable (no transition targets it)`,
+          severity: 'warning',
+          category: 'semantic',
+          suggestion: `Add a transition with to: "${state.name}" or remove this state`,
+        });
+      }
+    }
+  }
+
+  // Check for dead-end states (non-END states with no outgoing transitions)
+  if (def.transitions) {
+    const statesWithOutgoing = new Set<string>();
+    for (const t of def.transitions) {
+      if (t.from) {
+        for (const fromState of t.from) {
+          statesWithOutgoing.add(fromState);
+        }
+      }
+    }
+    for (const state of def.states) {
+      const sType = getStateType(state);
+      if (sType !== 'END' && sType !== 'CANCELLED' && !statesWithOutgoing.has(state.name)) {
+        issues.push({
+          code: 'DEAD_END_STATE',
+          message: `State '${state.name}' has no outgoing transitions (dead end)`,
+          severity: 'info',
+          category: 'semantic',
+          suggestion: `Add a transition from "${state.name}" or mark it as an END state`,
+        });
+      }
+    }
+  }
+
+  // Check for transitions from END/CANCELLED states
+  if (def.transitions) {
+    const endStates = new Set(
+      def.states
+        .filter(s => {
+          const sType = getStateType(s);
+          return sType === 'END' || sType === 'CANCELLED';
+        })
+        .map(s => s.name)
+    );
+    for (const t of def.transitions) {
+      if (t.from) {
+        for (const fromState of t.from) {
+          if (endStates.has(fromState)) {
+            issues.push({
+              code: 'TRANSITION_FROM_END',
+              message: `Transition '${t.name}' has source state '${fromState}' which is an END/CANCELLED state`,
+              severity: 'warning',
+              category: 'semantic',
+              suggestion: 'Remove transitions from END/CANCELLED states',
+            });
+          }
+        }
+      }
+    }
+  }
+}
+
+// =============================================================================
+// Experience Tree Validation
+// =============================================================================
+
+function validateExperienceTree(
+  node: IRExperienceNode,
+  knownComponents: string[] | undefined,
+  knownRoots: string[],
+  issues: ValidationIssue[],
+  path: string = 'metadata.experience',
+): void {
+  // Validate component reference
+  if (node.component && knownComponents) {
+    if (!knownComponents.includes(node.component)) {
+      issues.push({
+        code: 'UNKNOWN_COMPONENT',
+        message: `Experience node '${node.id}' references unknown component '${node.component}'`,
+        severity: 'warning',
+        category: 'experience',
+        path,
+        suggestion: `Registered components: ${knownComponents.slice(0, 10).join(', ')}${knownComponents.length > 10 ? '...' : ''}`,
+      });
+    }
+  }
+
+  // Validate bindings
+  if (node.bindings) {
+    for (const [prop, expr] of Object.entries(node.bindings)) {
+      validateBindingExpression(expr, `${path}.bindings.${prop}`, knownRoots, issues);
+    }
+  }
+
+  // Validate visible_when
+  if (node.visible_when) {
+    validateBindingExpression(node.visible_when, `${path}.visible_when`, knownRoots, issues);
+  }
+
+  // Validate children recursively
+  if (node.children) {
+    const childIds = new Set<string>();
+    for (let i = 0; i < node.children.length; i++) {
+      const child = node.children[i];
+      if (child.id && childIds.has(child.id)) {
+        issues.push({
+          code: 'DUPLICATE_NODE_ID',
+          message: `Duplicate experience node ID '${child.id}' under '${node.id}'`,
+          severity: 'warning',
+          category: 'experience',
+          path: `${path}.children[${i}]`,
+        });
+      }
+      if (child.id) childIds.add(child.id);
+      validateExperienceTree(child, knownComponents, knownRoots, issues, `${path}.children[${i}]`);
+    }
+  }
+}
+
+function validateBindingExpression(
+  expr: string,
+  path: string,
+  knownRoots: string[],
+  issues: ValidationIssue[],
+): void {
+  if (!expr) return;
+
+  const trimmed = expr.trim();
+
+  // Skip literals
+  if (trimmed.startsWith('"') || trimmed.startsWith("'") || /^-?\d/.test(trimmed) ||
+      trimmed === 'true' || trimmed === 'false' || trimmed === 'null') {
+    return;
+  }
+
+  // Skip special action syntax
+  if (trimmed.startsWith('action:') || trimmed.startsWith('setLocal:')) {
+    return;
+  }
+
+  // Skip transition.fire bindings (compiled format)
+  if (/^\w+\.fire$/.test(trimmed)) {
+    return;
+  }
+
+  // Check that $ bindings use known roots
+  if (trimmed.startsWith('$')) {
+    const dotIdx = trimmed.indexOf('.');
+    const parenIdx = trimmed.indexOf('(');
+    let root: string;
+    if (dotIdx > 0 && (parenIdx < 0 || dotIdx < parenIdx)) {
+      root = trimmed.slice(0, dotIdx);
+    } else if (parenIdx > 0) {
+      root = trimmed.slice(0, parenIdx);
+    } else {
+      root = trimmed;
+    }
+
+    // Strip operators from root if present in conditions
+    const rootClean = root.replace(/[!=<>&|+\-*/\s].*/g, '').trim();
+
+    if (rootClean && !knownRoots.includes(rootClean)) {
+      issues.push({
+        code: 'UNKNOWN_BINDING_ROOT',
+        message: `Binding expression at ${path} uses unknown root '${rootClean}'`,
+        severity: 'warning',
+        category: 'experience',
+        path,
+        suggestion: `Known roots: ${knownRoots.join(', ')}`,
+      });
+    }
+  }
+}
+
+// =============================================================================
+// Quick Check (lightweight validation for hot paths)
+// =============================================================================
+
+/**
+ * Quick structural check — returns true if the definition has minimum viable structure.
+ * Much faster than full validateDefinition() for use in render-path guards.
+ */
+export function isViableDefinition(def: unknown): def is IRWorkflowDefinition {
+  if (!def || typeof def !== 'object') return false;
+  const d = def as Record<string, unknown>;
+  return (
+    typeof d.slug === 'string' &&
+    Array.isArray(d.states) &&
+    d.states.length > 0 &&
+    Array.isArray(d.transitions) &&
+    Array.isArray(d.fields)
+  );
+}