@mmapp/react 0.1.0-alpha.1 → 0.1.0-alpha.3

package/src/config/defineModel.ts

@@ -1,753 +0,0 @@
-/**
- * defineModel — declare a workflow model with preserved literal types.
- *
- * Used in model files (models/*.ts) to define workflow definitions
- * with full TypeScript type inference. The `const` type parameter (TS 5.0+)
- * ensures field names, state names, and transition names are inferred as
- * string literals — enabling typed hooks like useModel(), useQuery(), useMutation().
- *
- * @example
- * ```typescript
- * import { defineModel } from '@mindmatrix/react';
- *
- * export default defineModel({
- *   slug: 'mod-authentication',
- *   version: '2.0.0',
- *   category: 'module',
- *
- *   fields: {
- *     appName: { type: 'string', default: '', label: 'Application Name' },
- *     layout: { type: 'string', default: 'card', enum: ['card', 'split', 'minimal'] },
- *     email: { type: 'email', required: true, validation: { maxLength: 255 } },
- *     role: {
- *       type: 'string',
- *       default: 'viewer',
- *       editableByRoles: ['admin'],
- *       visibleInStates: ['active', 'suspended'],
- *     },
- *   },
- *
- *   states: {
- *     unauthenticated: { type: 'initial' },
- *     authenticating: {},
- *     authenticated: {
- *       onEnter: [{ id: 'log', type: 'log_event', mode: 'auto', config: { event: 'auth.ok' } }],
- *     },
- *     error: {
- *       timeout: { duration: '5m', fallback: { transition: 'retry' } },
- *     },
- *   },
- *
- *   transitions: {
- *     login: {
- *       from: 'unauthenticated',
- *       to: 'authenticating',
- *       conditions: [
- *         { type: 'expression', expression: 'input.email != null' },
- *       ],
- *       actions: [
- *         { id: 'auth', type: 'server:authenticate', mode: 'auto', config: { method: 'login' } },
- *       ],
- *     },
- *     logout: {
- *       from: 'authenticated',
- *       to: 'unauthenticated',
- *       roles: ['user', 'admin'],
- *     },
- *   },
- *
- *   roles: {
- *     admin: { description: 'Full access', permissions: ['manage_users', 'manage_settings'] },
- *     user: { description: 'Standard user', permissions: ['read', 'write'], inherits: ['viewer'] },
- *     viewer: { permissions: ['read'] },
- *   },
- * });
- * ```
- */
-
-// =============================================================================
-// Field-Level Access Control
-// =============================================================================
-
-/**
- * Controls where a field's data lives and how it syncs.
- *
- * @example
- * ```typescript
- * stateHome: { scope: 'instance', persistence: 'durable', sync: 'tenant' }
- * ```
- */
-export interface StateHome {
-  /** Where the field value lives at runtime. */
-  scope?: 'ephemeral' | 'route' | 'instance' | 'global';
-  /** How the field is persisted. */
-  persistence?: 'none' | 'local' | 'durable';
-  /** How the field syncs across clients/tenants. */
-  sync?: 'none' | 'tenant' | 'p2p';
-}
-
-/**
- * Validation rules for a field.
- *
- * @example
- * ```typescript
- * validation: {
- *   min: 0,
- *   max: 100,
- *   rules: [
- *     { expression: 'value > state_data.minPrice', message: 'Must exceed minimum price', severity: 'error' },
- *   ],
- * }
- * ```
- */
-export interface FieldValidation {
-  /** Minimum numeric value. */
-  min?: number;
-  /** Maximum numeric value. */
-  max?: number;
-  /** Minimum string length. */
-  minLength?: number;
-  /** Maximum string length. */
-  maxLength?: number;
-  /** Regex pattern the value must match. */
-  pattern?: string;
-  /** Allowed values (alternative to field-level `enum`). */
-  options?: readonly string[];
-  /**
-   * Custom validation rules evaluated as expressions.
-   * Each rule has an expression that must be truthy for the field to be valid.
-   */
-  rules?: readonly ValidationRule[];
-}
-
-/** A single expression-based validation rule. */
-export interface ValidationRule {
-  /** Expression that must evaluate to truthy. `value` refers to the field value. */
-  expression: string;
-  /** Error message shown when validation fails. */
-  message: string;
-  /** Whether this rule blocks saves or just warns. Default: `'error'`. */
-  severity?: 'error' | 'warning';
-}
-
-// =============================================================================
-// Field Descriptor
-// =============================================================================
-
-/**
- * Descriptor for a single workflow field in a model definition.
- *
- * Fields map to columns in the workflow's data model. Each field has a type,
- * optional default, and optional access control / validation rules.
- *
- * @example
- * ```typescript
- * price: {
- *   type: 'currency',
- *   required: true,
- *   default: 0,
- *   label: 'Unit Price',
- *   validation: { min: 0, max: 10000 },
- *   editableByRoles: ['admin', 'manager'],
- *   editableInStates: ['draft', 'review'],
- *   computed: 'state_data.quantity * state_data.unitCost',
- *   computedDeps: ['quantity', 'unitCost'],
- * }
- * ```
- */
-export interface WorkflowFieldDescriptor {
-  /** Field type — maps to TypeScript types via `InferFields`. */
-  type: string;
-  /** Whether the field must have a value before transitions. */
-  required?: boolean;
-  /** Default value when the field is not explicitly set. */
-  default?: unknown;
-  /** Allowed values for enum/select fields. */
-  enum?: readonly string[];
-  /** Array item type descriptor (for `type: 'array'`). */
-  items?: { type: string };
-  /** Human-readable label shown in UIs. */
-  label?: string;
-  /** Description / help text for the field. */
-  description?: string;
-
-  // --- Validation ---
-
-  /** Structured validation rules (min, max, pattern, custom expressions). */
-  validation?: FieldValidation | Record<string, unknown>;
-
-  // --- Computed Fields ---
-
-  /** Expression that computes this field's value. Field becomes read-only. */
-  computed?: string;
-  /** Field names this computed field depends on (for change tracking). */
-  computedDeps?: readonly string[];
-  /** @deprecated Use `computedDeps`. */
-  computed_deps?: readonly string[];
-
-  // --- Access Control ---
-
-  /**
-   * States in which this field is visible.
-   * If omitted, visible in all states.
-   *
-   * @example `visibleInStates: ['active', 'review']`
-   */
-  visibleInStates?: readonly string[];
-  /**
-   * States in which this field is editable.
-   * If omitted, editable in all states (subject to role checks).
-   *
-   * @example `editableInStates: ['draft', 'revision']`
-   */
-  editableInStates?: readonly string[];
-  /**
-   * Roles that can see this field.
-   * If omitted, visible to all roles.
-   *
-   * @example `visibleToRoles: ['admin', 'manager']`
-   */
-  visibleToRoles?: readonly string[];
-  /**
-   * Roles that can edit this field.
-   * If omitted, editable by all roles (subject to state checks).
-   *
-   * @example `editableByRoles: ['admin']`
-   */
-  editableByRoles?: readonly string[];
-  /**
-   * Expression that controls visibility. Evaluated at runtime.
-   *
-   * @example `visibleWhen: 'state_data.showAdvanced == true'`
-   */
-  visibleWhen?: string;
-  /**
-   * Expression that controls editability. Evaluated at runtime.
-   *
-   * @example `editableWhen: 'context.actor_id == state_data.ownerId'`
-   */
-  editableWhen?: string;
-
-  // --- State Home (scope, persistence, sync) ---
-
-  /**
-   * Controls where this field's data lives and how it syncs.
-   * Defaults to `{ scope: 'instance', persistence: 'durable', sync: 'none' }`.
-   *
-   * @example
-   * ```typescript
-   * stateHome: { scope: 'ephemeral', persistence: 'none' }  // UI-only, not saved
-   * stateHome: { scope: 'instance', persistence: 'durable', sync: 'tenant' }  // saved + synced
-   * ```
-   */
-  stateHome?: StateHome;
-
-  // --- Type Versioning ---
-
-  /**
-   * Version pin for custom field types.
-   * Used when the field type is a user-defined data-type workflow.
-   */
-  typeVersion?: string;
-  /**
-   * Base type this field inherits from (for custom data-type fields).
-   *
-   * @example `baseType: 'string'` — custom type structurally extends string
-   */
-  baseType?: string;
-}
-
-// =============================================================================
-// Action Types
-// =============================================================================
-
-/**
- * An action definition within a state or transition.
- *
- * Actions are the units of work in a workflow. They can set fields,
- * log events, send notifications, spawn sub-workflows, or call
- * opaque server/device functions.
- *
- * @example
- * ```typescript
- * // Simple set_field action
- * { id: 'clear-error', type: 'set_field', mode: 'auto', config: { field: 'error', expression: '""' } }
- *
- * // Server-side opaque action
- * { id: 'send-email', type: 'server:send_email', mode: 'auto', config: { template: 'welcome' } }
- *
- * // Spawn a sub-workflow
- * {
- *   id: 'create-notification',
- *   type: 'spawn_subworkflow',
- *   mode: 'auto',
- *   config: {
- *     definition_slug: 'notification',
- *     blocking: false,
- *     input_mapping: { userId: 'context.actor_id', message: 'state_data.summary' },
- *   },
- * }
- * ```
- */
-export interface ActionDefinition {
-  /** Unique identifier for this action within its state/transition. */
-  id: string;
-  /**
-   * Action type. Built-in types:
-   * - `set_field` — set a single field via expression
-   * - `set_fields` — set multiple fields via expressions
-   * - `log_event` — emit an event to the audit log
-   * - `send_notification` — send a notification to recipients
-   * - `spawn_subworkflow` — create a child workflow instance
-   * - `server:*` — opaque server-side actions (defined in actions.server.ts)
-   * - `device:*` — opaque device-side actions (defined in actions.device.ts)
-   * - `connector.*` — external service connector actions
-   * - `llm.*` — LLM/AI actions
-   */
-  type: string;
-  /** Whether this action runs automatically or requires manual trigger. Default: `'auto'`. */
-  mode?: 'auto' | 'manual';
-  /**
-   * Action configuration. Shape depends on `type`:
-   *
-   * **set_field**: `{ field: string, expression: string }`
-   * **set_fields**: `{ fields: Record<string, { expression: string }> }`
-   * **log_event**: `{ event: string, data?: Record<string, string> }`
-   * **send_notification**: `{ template: string, recipients: string, data?: Record<string, string> }`
-   * **spawn_subworkflow**: `{ definition_slug: string, blocking?: boolean, input_mapping?: Record<string, string> }`
-   */
-  config?: Record<string, unknown>;
-  /** Expression that must be truthy for this action to execute. */
-  condition?: string;
-}
-
-/**
- * An on_event subscription — reacts to events from other workflow instances.
- *
- * @example
- * ```typescript
- * onEvent: [{
- *   match: 'order:*:transition.completed',
- *   description: 'Track order completions',
- *   conditions: ['event.transition_name == "deliver"'],
- *   actions: [
- *     { id: 'inc', type: 'set_field', mode: 'auto', config: { field: 'count', expression: 'state_data.count + 1' } },
- *   ],
- * }]
- * ```
- */
-export interface EventSubscription {
-  /** Event pattern to match (glob-style). */
-  match: string;
-  /** Human-readable description of what this subscription does. */
-  description?: string;
-  /** Expression conditions that must ALL be truthy for the actions to fire. */
-  conditions?: readonly string[];
-  /** Actions to execute when the event matches and conditions pass. */
-  actions: readonly ActionDefinition[];
-}
-
-/**
- * A scheduled/recurring action that runs while the workflow is in a given state.
- *
- * @example
- * ```typescript
- * during: [{
- *   id: 'heartbeat',
- *   type: 'interval',
- *   interval_ms: 30000,
- *   condition: 'state_data.monitoring == true',
- *   actions: [{ id: 'ping', type: 'server:health_check', mode: 'auto', config: {} }],
- * }]
- * ```
- */
-export interface DuringAction {
-  /** Unique identifier for this scheduled action. */
-  id: string;
-  /**
-   * Schedule type:
-   * - `interval` — repeats every `interval_ms` milliseconds
-   * - `timeout` — fires once after `delay_ms` milliseconds
-   * - `cron` — fires on a cron schedule
-   * - `poll` — polls at `interval_ms`, stops when condition is false
-   * - `once` — fires once on state entry
-   */
-  type?: 'interval' | 'timeout' | 'cron' | 'poll' | 'once';
-  /** Repeat interval in milliseconds (for `interval` and `poll` types). */
-  interval_ms?: number;
-  /** Cron expression (for `cron` type). */
-  cron?: string;
-  /** Delay before firing in milliseconds (for `timeout` type). */
-  delay_ms?: number;
-  /** @deprecated Use `type` + `interval_ms`/`cron` directly. */
-  schedule?: { type: string; cron?: string; interval?: number };
-  /** Actions to execute on each tick. */
-  actions: readonly ActionDefinition[];
-  /** Expression condition — scheduled action only fires when truthy. */
-  condition?: string;
-}
-
-// =============================================================================
-// State & Transition Types
-// =============================================================================
-
-/**
- * Descriptor for a workflow state.
- *
- * States are the nodes in the state machine. Each state can have entry/exit
- * actions, event subscriptions, scheduled actions, and timeouts.
- *
- * @example
- * ```typescript
- * authenticated: {
- *   description: 'User is logged in and has a valid session',
- *   onEnter: [
- *     { id: 'log', type: 'log_event', mode: 'auto', config: { event: 'auth.success' } },
- *   ],
- *   onEvent: [{
- *     match: 'session:*:expired',
- *     actions: [{ id: 'kick', type: 'set_field', mode: 'auto', config: { field: 'reason', expression: '"session_expired"' } }],
- *   }],
- *   timeout: { duration: '24h', fallback: { transition: 'logout' } },
- * }
- * ```
- */
-export interface StateDescriptor {
-  /**
-   * State type:
-   * - `'initial'` — the starting state (exactly one per model)
-   * - `'end'` — a terminal state (no outgoing transitions)
-   * - `'cancelled'` — a terminal state indicating cancellation
-   * - omitted — regular intermediate state
-   */
-  type?: 'initial' | 'end' | 'cancelled';
-  /** Human-readable description of what this state represents. */
-  description?: string;
-
-  // --- Lifecycle Actions ---
-
-  /** Actions to run when entering this state (camelCase preferred). */
-  onEnter?: readonly ActionDefinition[];
-  /** @deprecated Use `onEnter`. */
-  on_enter?: readonly ActionDefinition[];
-  /** Actions to run when leaving this state. */
-  onExit?: readonly ActionDefinition[];
-  /** @deprecated Use `onExit`. */
-  on_exit?: readonly ActionDefinition[];
-
-  // --- Event Subscriptions ---
-
-  /** React to events from other workflow instances while in this state. */
-  onEvent?: readonly EventSubscription[];
-  /** @deprecated Use `onEvent`. */
-  on_event?: readonly EventSubscription[];
-
-  // --- Scheduled Actions ---
-
-  /** Scheduled/recurring actions that run while in this state. */
-  during?: readonly DuringAction[];
-
-  // --- Timeout ---
-
-  /**
-   * Automatic timeout — if the workflow stays in this state too long,
-   * execute a fallback action or transition.
-   *
-   * @example
-   * ```typescript
-   * timeout: { duration: '30m', fallback: { transition: 'escalate' } }
-   * timeout: { duration: '24h', fallback: { action: 'server:send_reminder' } }
-   * ```
-   */
-  timeout?: {
-    /** Duration string (e.g., `'5m'`, `'24h'`, `'7d'`). */
-    duration: string;
-    /** What to do when the timeout fires. */
-    fallback?: {
-      /** Action type to execute. */
-      action?: string;
-      /** Transition to auto-fire. */
-      transition?: string;
-    };
-  };
-}
-
-/**
- * Condition for a transition guard.
- *
- * Guards prevent transitions from firing unless all conditions pass.
- * Supports expression-based, role-based, and field-based conditions,
- * as well as boolean combinators (AND/OR).
- *
- * @example
- * ```typescript
- * // Expression guard
- * { type: 'expression', expression: 'context.actor_id == state_data.ownerId' }
- *
- * // Role guard
- * { type: 'role', role: 'admin' }
- *
- * // Field guard with operator
- * { type: 'field', field: 'amount', operator: 'gte', value: 100 }
- *
- * // Nested boolean logic
- * { OR: [
- *   { type: 'role', role: 'admin' },
- *   { AND: [
- *     { type: 'expression', expression: 'context.actor_id == state_data.ownerId' },
- *     { type: 'field', field: 'status', operator: 'eq', value: 'draft' },
- *   ]},
- * ]}
- *
- * // String shorthand (treated as expression)
- * 'context.actor_id == state_data.senderId'
- * ```
- */
-export interface TransitionCondition {
-  /** Condition type. */
-  type?: 'expression' | 'role' | 'field';
-  /** Expression that must evaluate to truthy. */
-  expression?: string;
-  /** Role name required for a role-based guard. */
-  role?: string;
-  /** Field name for field-based conditions. */
-  field?: string;
-  /**
-   * Comparison operator for field-based conditions:
-   * `eq`, `ne`, `gt`, `gte`, `lt`, `lte`, `in`, `not_in`,
-   * `contains`, `is_set`, `is_empty`, `matches`.
-   */
-  operator?: string;
-  /** Value to compare against for field-based conditions. */
-  value?: unknown;
-  /**
-   * Logical OR — at least one sub-condition must pass.
-   *
-   * @example `{ OR: [{ type: 'role', role: 'admin' }, { type: 'role', role: 'manager' }] }`
-   */
-  OR?: readonly (TransitionCondition | string)[];
-  /**
-   * Logical AND — all sub-conditions must pass.
-   *
-   * @example `{ AND: [{ type: 'expression', expression: '...' }, { type: 'role', role: 'admin' }] }`
-   */
-  AND?: readonly (TransitionCondition | string)[];
-}
-
-/**
- * Descriptor for a workflow transition.
- *
- * Transitions are the edges in the state machine — they move the workflow
- * from one state to another, optionally guarded by conditions and executing
- * actions along the way.
- *
- * @example
- * ```typescript
- * approve: {
- *   from: ['review', 'escalated'],
- *   to: 'approved',
- *   description: 'Approve the request',
- *   roles: ['admin', 'manager'],
- *   requiredFields: ['approvalNote'],
- *   conditions: [
- *     { type: 'expression', expression: 'state_data.amount <= context.approvalLimit' },
- *   ],
- *   actions: [
- *     { id: 'stamp', type: 'set_fields', mode: 'auto', config: {
- *       fields: { approvedBy: { expression: 'context.actor_id' }, approvedAt: { expression: 'NOW()' } },
- *     }},
- *     { id: 'notify', type: 'send_notification', mode: 'auto', config: {
- *       template: 'request_approved', recipients: '{{ state_data.requesterId }}',
- *     }},
- *   ],
- * }
- * ```
- */
-export interface TransitionDescriptor {
-  /** Source state(s) — accepts a single string or array of strings. */
-  from: string | readonly string[];
-  /** Target state name. */
-  to: string;
-  /** Human-readable description of what this transition does. */
-  description?: string;
-  /**
-   * Guard conditions — ALL must pass for the transition to fire.
-   * Accepts `TransitionCondition` objects or expression strings.
-   */
-  conditions?: readonly (TransitionCondition | string)[];
-  /** Actions to execute when this transition fires (after guards pass). */
-  actions?: readonly ActionDefinition[];
-  /**
-   * Roles allowed to trigger this transition.
-   * If omitted, any role can trigger it.
-   *
-   * @example `roles: ['admin', 'manager']`
-   */
-  roles?: readonly string[];
-  /**
-   * Fields that must have non-empty values before this transition can fire.
-   *
-   * @example `requiredFields: ['approvalNote', 'reason']`
-   */
-  requiredFields?: readonly string[];
-  /** @deprecated Use `requiredFields`. */
-  required_fields?: readonly string[];
-  /**
-   * If `true`, this transition fires automatically when its conditions are met,
-   * without requiring an explicit trigger call.
-   *
-   * Used for pipeline/chain patterns where states flow automatically.
-   *
-   * @example
-   * ```typescript
-   * auto_advance: { from: 'processing', to: 'completed', auto: true,
-   *   conditions: [{ type: 'expression', expression: 'state_data.result != null' }],
-   * }
-   * ```
-   */
-  auto?: boolean;
-}
-
-// =============================================================================
-// Role Definitions
-// =============================================================================
-
-/**
- * Role definition for the workflow's permission model.
- *
- * @example
- * ```typescript
- * roles: {
- *   admin: { description: 'Full access', permissions: ['manage_users', 'manage_settings', 'delete'] },
- *   editor: { description: 'Can edit content', permissions: ['read', 'write', 'publish'], inherits: ['viewer'] },
- *   viewer: { description: 'Read-only access', permissions: ['read'] },
- * }
- * ```
- */
-export interface RoleDefinition {
-  /** Human-readable description of what this role can do. */
-  description?: string;
-  /** Permissions granted to this role. */
-  permissions?: readonly string[];
-  /** Roles this role inherits permissions from. */
-  inherits?: readonly string[];
-}
-
-// =============================================================================
-// Model Definition
-// =============================================================================
-
-/**
- * Full shape of a model definition passed to `defineModel()`.
- *
- * This is the canonical TypeScript representation of a workflow definition.
- * It maps closely to the IR format stored in the database, but uses
- * camelCase and provides richer type information for IDE support.
- */
-export interface ModelDefinition {
-  /** Unique slug identifier (kebab-case). */
-  slug: string;
-  /** Semantic version string. */
-  version?: string;
-  /**
-   * Definition category — determines how the engine treats this definition.
-   *
-   * Common categories:
-   * - `'model'` — a data model / state machine
-   * - `'module'` — a reusable workflow module (importable via `mmrc install`)
-   * - `'workflow'` — a business process
-   * - `'data'` — a data table (fields = columns, instances = rows)
-   * - `'blueprint'` — a full application (contains child definitions)
-   * - `'view'` — a UI definition
-   */
-  category?: string | readonly string[];
-  /** Human-readable description. */
-  description?: string;
-  /** Human-readable display name. */
-  name?: string;
-  /** Field definitions — the data schema for this workflow. */
-  fields: Record<string, WorkflowFieldDescriptor>;
-  /** State definitions — the nodes of the state machine. */
-  states: Record<string, StateDescriptor>;
-  /** Transition definitions — the edges of the state machine. */
-  transitions: Record<string, TransitionDescriptor>;
-  /**
-   * Role definitions — the permission model for this workflow.
-   * Roles can be referenced in transition `roles` guards and field ACL.
-   */
-  roles?: Record<string, RoleDefinition>;
-  /** Arbitrary metadata (not interpreted by the engine). */
-  metadata?: Record<string, unknown>;
-  /**
-   * Tags for categorization and discovery.
-   *
-   * @example `tags: ['finance', 'approval', 'internal']`
-   */
-  tags?: readonly string[];
-  /**
-   * Model-level event subscriptions — react to events from other workflows
-   * regardless of what state this workflow is in.
-   */
-  onEvent?: readonly EventSubscription[];
-  /** @deprecated Use `onEvent`. */
-  on_event?: readonly EventSubscription[];
-}
-
-// =============================================================================
-// defineModel()
-// =============================================================================
-
-/**
- * Define a workflow model with preserved literal types.
- *
- * The `const` type parameter ensures that field names, state names, and
- * transition names are inferred as string literals, not widened to `string`.
- * This is what makes typed hooks (`useModel`, `useQuery`, `useMutation`) work.
- *
- * At runtime this is an identity function — it returns the definition as-is.
- *
- * @param def - The model definition object.
- * @returns The same definition, with narrowed literal types for IDE support.
- *
- * @example
- * ```typescript
- * import { defineModel } from '@mindmatrix/react';
- *
- * export default defineModel({
- *   slug: 'invoice',
- *   version: '1.0.0',
- *   category: 'data',
- *   fields: {
- *     amount: { type: 'currency', required: true, validation: { min: 0 } },
- *     status: { type: 'string', default: 'draft', enum: ['draft', 'sent', 'paid'] },
- *   },
- *   states: {
- *     draft: { type: 'initial' },
- *     sent: {},
- *     paid: { type: 'end' },
- *   },
- *   transitions: {
- *     send: { from: 'draft', to: 'sent', requiredFields: ['amount'] },
- *     pay: { from: 'sent', to: 'paid', auto: true, conditions: [{ type: 'expression', expression: 'state_data.paymentReceived == true' }] },
- *   },
- * });
- * ```
- */
-export function defineModel<const D extends ModelDefinition>(def: D): D {
-  // Optional runtime validation (lightweight, skip in production)
-  if (typeof process !== 'undefined' && process.env?.NODE_ENV !== 'production') {
-    if (!def.slug) {
-      throw new Error('defineModel: slug is required');
-    }
-    if (!def.fields || typeof def.fields !== 'object') {
-      throw new Error(`defineModel(${def.slug}): fields object is required`);
-    }
-    if (!def.states || typeof def.states !== 'object') {
-      throw new Error(`defineModel(${def.slug}): states object is required`);
-    }
-    if (!def.transitions || typeof def.transitions !== 'object') {
-      throw new Error(`defineModel(${def.slug}): transitions object is required`);
-    }
-  }
-  return def;
-}