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

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import { StateMachine, EventBus, ActionDispatcher, Evaluator, PlayerWorkflowDefinition, ExpressionContext, TransitionResult as TransitionResult$1, RuntimeProfile, ActionHandlerFn, BusEvent, StateMachineEvent } from '@mindmatrix/player-core';
-export { ExpressionContext, IRStateHome, PlayerWorkflowDefinition, RuntimeProfile, StateMachineEvent, TransitionResult } from '@mindmatrix/player-core';
+import { StateMachine, EventBus, ActionDispatcher, Evaluator, PlayerWorkflowDefinition, ExpressionContext, TransitionResult as TransitionResult$1, RuntimeProfile, ActionHandlerFn, BusEvent, StateMachineEvent } from '@mmapp/player-core';
+export { ExpressionContext, IRStateHome, PlayerWorkflowDefinition, RuntimeProfile, StateMachineEvent, TransitionResult } from '@mmapp/player-core';
 import * as react_jsx_runtime from 'react/jsx-runtime';
 import { QueryClient } from '@tanstack/react-query';
 import * as React$1 from 'react';
@@ -145,7 +145,7 @@ declare function useDuringAction(config: DuringActionConfig): void;
  *
  * @example
  * ```typescript
- * import { defineModel } from '@mindmatrix/react';
+ * import { defineModel } from '@mmapp/react';
  *
  * export default defineModel({
  *   slug: 'mod-authentication',
@@ -426,6 +426,11 @@ interface ActionDefinition {
     config?: Record<string, unknown>;
     /** Expression that must be truthy for this action to execute. */
     condition?: string;
+    /**
+     * Where this action executes at runtime.
+     * Default: inherited from the parent state/transition or `'any'`.
+     */
+    runtime?: RuntimeTarget;
 }
 /**
  * An on_event subscription — reacts to events from other workflow instances.
@@ -562,6 +567,11 @@ interface StateDescriptor {
             transition?: string;
         };
     };
+    /**
+     * Where this state executes at runtime.
+     * Default: inherited from `orchestration.defaultRuntime` or `'any'`.
+     */
+    runtime?: RuntimeTarget;
 }
 /**
  * Condition for a transition guard.
@@ -696,6 +706,11 @@ interface TransitionDescriptor {
      * ```
      */
     auto?: boolean;
+    /**
+     * Where this transition executes at runtime.
+     * Default: inherited from `orchestration.defaultRuntime` or `'any'`.
+     */
+    runtime?: RuntimeTarget;
 }
 /**
  * Role definition for the workflow's permission model.
@@ -717,6 +732,133 @@ interface RoleDefinition {
     /** Roles this role inherits permissions from. */
     inherits?: readonly string[];
 }
+/** Strategy for multi-player workflow orchestration. */
+type OrchestrationStrategy = 'solo' | 'client-server' | 'multi-client' | 'service-mesh' | 'peer-to-peer' | 'hybrid' | 'headless' | 'custom';
+/** Where a state, transition, or action executes at runtime. */
+type RuntimeTarget = 'server' | 'client' | 'worker' | 'edge' | 'any';
+/** Conflict resolution strategy. */
+type ConflictStrategy = 'last-writer-wins' | 'first-write-wins' | 'crdt' | 'manual' | 'custom';
+/** Per-field conflict resolution override. */
+interface FieldConflictConfig {
+    strategy: ConflictStrategy | string;
+    /** CRDT type when strategy is 'crdt' (e.g., 'lww-register', 'g-counter', 'or-set'). */
+    type?: string;
+}
+/** Role-based visibility configuration. */
+interface RoleVisibility {
+    /** Fields visible to this role. Use '*' for all. */
+    fields: readonly string[] | '*';
+    /** States visible to this role. Use '*' for all. */
+    states?: readonly string[] | '*';
+}
+/** Player-type visibility configuration. */
+interface PlayerVisibility {
+    /** Fields visible to this player type. Use '*' for all. */
+    fields: readonly string[] | '*';
+}
+/** Presence tracking configuration. */
+interface PresenceConfig {
+    /** Enable real-time presence tracking. */
+    enabled?: boolean;
+    /** Show which fields other users are editing. */
+    showEditing?: boolean;
+    /** Show connected viewers. */
+    showViewing?: boolean;
+    /** Highlight fields with conflicting edits. */
+    conflictHighlight?: boolean;
+}
+/** Service registration for action routing. */
+interface ServiceConfig {
+    /** Transport type for this service. */
+    type: 'webhook' | 'websocket' | 'job' | 'p2p';
+    /** Service endpoint URL (for webhook/websocket). */
+    url?: string;
+    /** Actions this service handles. */
+    actions: readonly string[];
+    /** Request timeout (e.g., '30s', '5m'). */
+    timeout?: string;
+    /** Number of retry attempts on failure. */
+    retry?: number;
+}
+/** Per-action routing rule. */
+interface ActionRoutingRule {
+    /** Target player/service for this action. */
+    target: string;
+    /** Fallback target if primary is unavailable. */
+    fallback?: string;
+    /** Whether this action must succeed (no silent failure). */
+    required?: boolean;
+}
+/**
+ * Orchestration configuration for multi-player workflow execution.
+ *
+ * Controls how actions are routed, conflicts are resolved, presence is tracked,
+ * and visibility is scoped across multiple clients, servers, and services.
+ *
+ * @example
+ * ```typescript
+ * orchestration: {
+ *   strategy: 'multi-client',
+ *   evaluation: { pure: 'local' },
+ *   conflicts: {
+ *     default: 'last-writer-wins',
+ *     fields: { description: { strategy: 'crdt', type: 'lww-register' } },
+ *   },
+ *   visibility: {
+ *     roles: {
+ *       customer: { fields: ['status', 'total'], states: ['submitted', 'completed'] },
+ *       admin: { fields: '*', states: '*' },
+ *     },
+ *   },
+ *   presence: { enabled: true, showEditing: true },
+ * }
+ * ```
+ */
+interface OrchestrationConfig {
+    /** High-level orchestration strategy. Default: 'client-server'. */
+    strategy?: OrchestrationStrategy;
+    /** Default runtime target for states/transitions that don't specify one. */
+    defaultRuntime?: RuntimeTarget;
+    /** Expression evaluation routing. */
+    evaluation?: {
+        /** Where pure expressions are evaluated. */
+        pure?: 'local' | 'primary' | 'consensus' | 'nearest';
+    };
+    /** Action scheduling configuration. */
+    scheduling?: {
+        /** Who coordinates scheduled/during actions. */
+        coordinator?: 'server' | 'primary-client' | 'any' | string;
+    };
+    /** Event evaluation configuration. */
+    events?: {
+        /** Who evaluates onEvent subscriptions. */
+        evaluator?: 'server' | 'any-subscriber' | 'primary-client' | 'all';
+    };
+    /** Error handling strategy for failed actions. */
+    errorHandling?: {
+        strategy?: 'compensate' | 'rollback' | 'partial-commit' | 'saga' | 'manual';
+    };
+    /** Conflict resolution configuration. */
+    conflicts?: {
+        /** Default conflict resolution strategy. */
+        default?: ConflictStrategy;
+        /** Per-field conflict resolution overrides. */
+        fields?: Record<string, FieldConflictConfig>;
+    };
+    /** Visibility scoping by role and/or player type. */
+    visibility?: {
+        /** Per-role field/state visibility. */
+        roles?: Record<string, RoleVisibility>;
+        /** Per-player-type field visibility. */
+        players?: Record<string, PlayerVisibility>;
+    };
+    /** Real-time presence tracking. */
+    presence?: PresenceConfig;
+    /** Registered services for action routing. */
+    services?: Record<string, ServiceConfig>;
+    /** Per-action routing rules (action name → routing config). */
+    actionRouting?: Record<string, ActionRoutingRule>;
+}
 /**
  * Full shape of a model definition passed to `defineModel()`.
  *
@@ -771,6 +913,23 @@ interface ModelDefinition {
     onEvent?: readonly EventSubscription[];
     /** @deprecated Use `onEvent`. */
     on_event?: readonly EventSubscription[];
+    /**
+     * Multi-player orchestration configuration.
+     *
+     * Controls how this workflow executes across multiple clients, servers,
+     * and services — including conflict resolution, visibility, presence,
+     * and action routing.
+     *
+     * @example
+     * ```typescript
+     * orchestration: {
+     *   strategy: 'multi-client',
+     *   presence: { enabled: true, showEditing: true },
+     *   conflicts: { default: 'last-writer-wins' },
+     * }
+     * ```
+     */
+    orchestration?: OrchestrationConfig;
 }
 /**
  * Define a workflow model with preserved literal types.
@@ -786,7 +945,7 @@ interface ModelDefinition {
  *
  * @example
  * ```typescript
- * import { defineModel } from '@mindmatrix/react';
+ * import { defineModel } from '@mmapp/react';
  *
  * export default defineModel({
  *   slug: 'invoice',
@@ -2281,6 +2440,141 @@ interface ToastHandle {
  */
 declare function useToast(): ToastHandle;
 
+/**
+ * useVisibility — filters fields and states based on orchestration visibility config.
+ *
+ * Reads the `orchestration.visibility` configuration from a ModelDefinition
+ * and returns which fields/states are visible for the given role or player type.
+ *
+ * @example
+ * ```typescript
+ * import { useVisibility, defineModel } from '@mmapp/react';
+ *
+ * const order = defineModel({
+ *   slug: 'order',
+ *   fields: { status: { type: 'string' }, total: { type: 'currency' }, internalNotes: { type: 'string' } },
+ *   states: { draft: { type: 'initial' }, submitted: {}, completed: { type: 'end' } },
+ *   transitions: { submit: { from: 'draft', to: 'submitted' }, complete: { from: 'submitted', to: 'completed' } },
+ *   orchestration: {
+ *     visibility: {
+ *       roles: {
+ *         customer: { fields: ['status', 'total'], states: ['submitted', 'completed'] },
+ *         admin: { fields: '*', states: '*' },
+ *       },
+ *     },
+ *   },
+ * });
+ *
+ * function OrderView() {
+ *   const vis = useVisibility(order, 'customer');
+ *   // vis.visibleFields → ['status', 'total']
+ *   // vis.canSeeField('internalNotes') → false
+ *   // vis.canSeeState('draft') → false
+ * }
+ * ```
+ */
+
+/** Result of the useVisibility hook. */
+interface VisibilityResult {
+    /** Fields visible to the current role/player. */
+    visibleFields: string[];
+    /** States visible to the current role/player. */
+    visibleStates: string[];
+    /** Check if a specific field is visible. */
+    canSeeField: (field: string) => boolean;
+    /** Check if a specific state is visible. */
+    canSeeState: (state: string) => boolean;
+}
+/**
+ * Compute visibility for a role or player type.
+ *
+ * When no orchestration.visibility config is defined, or when
+ * the role/player is not listed, all fields and states are visible.
+ *
+ * @param model - The model definition containing orchestration config.
+ * @param role - The role name to check visibility for.
+ * @param playerType - The player type to check visibility for (optional, additive to role).
+ */
+declare function useVisibility(model: ModelDefinition, role?: string, playerType?: string): VisibilityResult;
+/**
+ * Pure function to compute visibility (testable without React).
+ */
+declare function computeVisibility(model: ModelDefinition, role?: string, playerType?: string): VisibilityResult;
+
+/**
+ * usePresence — real-time presence tracking for workflow instances.
+ *
+ * Tracks who is viewing and editing a workflow instance, and which
+ * fields are currently being edited by other users.
+ *
+ * Built on top of `useChannel` for real-time transport.
+ *
+ * @example
+ * ```typescript
+ * import { usePresence } from '@mmapp/react';
+ *
+ * function CollaborativeEditor({ instanceId }: { instanceId: string }) {
+ *   const { viewers, editors, viewerCount, isEditing, startEditing, stopEditing } =
+ *     usePresence(instanceId);
+ *
+ *   return (
+ *     <div>
+ *       <span>{viewerCount} viewing</span>
+ *       {editors.map(e => <span key={e.id}>Editing: {e.field}</span>)}
+ *       <input
+ *         onFocus={() => startEditing('name')}
+ *         onBlur={() => stopEditing('name')}
+ *       />
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+/** A connected viewer. */
+interface PresenceViewer {
+    id: string;
+    name: string;
+    connectedAt: number;
+}
+/** A user currently editing a field. */
+interface PresenceEditor {
+    id: string;
+    name: string;
+    field: string;
+    startedAt: number;
+}
+/** Options for the usePresence hook. */
+interface PresenceOptions {
+    /** Current user ID. */
+    userId?: string;
+    /** Current user display name. */
+    userName?: string;
+    /** WebSocket URL override. */
+    wsUrl?: string;
+    /** Whether presence is enabled. Default: true. */
+    enabled?: boolean;
+    /** Heartbeat interval in ms. Default: 15000. */
+    heartbeatInterval?: number;
+    /** Stale timeout in ms (remove viewers after this). Default: 45000. */
+    staleTimeout?: number;
+}
+/** Result of the usePresence hook. */
+interface PresenceHandle {
+    /** All connected viewers. */
+    viewers: PresenceViewer[];
+    /** Users currently editing fields. */
+    editors: PresenceEditor[];
+    /** Number of connected viewers. */
+    viewerCount: number;
+    /** Check if a specific field is being edited by another user. */
+    isEditing: (field: string) => boolean;
+    /** Announce that the current user started editing a field. */
+    startEditing: (field: string) => void;
+    /** Announce that the current user stopped editing a field. */
+    stopEditing: (field: string) => void;
+}
+declare function usePresence(instanceId: string, options?: PresenceOptions): PresenceHandle;
+
 /**
  * useMiddleware — Pre-render middleware pipeline for workflow pages.
  *
@@ -2304,7 +2598,7 @@ declare function useToast(): ToastHandle;
  *   // ... render page
  *
  * Factory functions for common middleware:
- *   import { requireAuth, requireRole, prefetchData } from '@mindmatrix/react';
+ *   import { requireAuth, requireRole, prefetchData } from '@mmapp/react';
  */
 /** Result of a middleware function. */
 interface MiddlewareResult {
@@ -2361,7 +2655,7 @@ declare function requireAuth(loginPath?: string): MiddlewareFn;
 /**
  * Factory: Require a specific role. Checks auth token for role claim.
  */
-declare function requireRole(role: string, redirectPath?: string): MiddlewareFn;
+declare function requireRole$1(role: string, redirectPath?: string): MiddlewareFn;
 /**
  * Factory: Prefetch data before rendering.
  */
@@ -2566,7 +2860,7 @@ declare function createLocalEngineAdapter(_engine: LocalWorkflowEngine, store: L
 declare function createLocalDataResolver(engine: LocalWorkflowEngine, store: LocalEngineStore): LocalDataResolver;
 
 /**
- * @mindmatrix/react/actions — Typed action factory functions.
+ * @mmapp/react/actions — Typed action factory functions.
  *
  * Provides ergonomic helpers that produce {@link ActionDefinition} objects
  * for use in model definitions (states and transitions). Every function
@@ -2574,8 +2868,8 @@ declare function createLocalDataResolver(engine: LocalWorkflowEngine, store: Loc
  *
  * @example
  * ```typescript
- * import { defineModel } from '@mindmatrix/react';
- * import { setField, logEvent, notify, spawn } from '@mindmatrix/react/actions';
+ * import { defineModel } from '@mmapp/react';
+ * import { setField, logEvent, notify, spawn } from '@mmapp/react/actions';
  *
  * export default defineModel({
  *   slug: 'order',
@@ -2725,7 +3019,7 @@ interface ActionNotifyOptions {
  * })
  * ```
  */
-declare function notify(template: string, options?: ActionNotifyOptions): ActionDefinition;
+declare function notify$1(template: string, options?: ActionNotifyOptions): ActionDefinition;
 /**
  * Options for the {@link spawn} action factory.
  */
@@ -2927,14 +3221,14 @@ interface ActionOptions {
 declare function action(id: string, type: string, config?: Record<string, unknown>, options?: ActionOptions): ActionDefinition;
 
 /**
- * @mindmatrix/react/actionCreators — Type-safe action reference factories.
+ * @mmapp/react/actionCreators — Type-safe action reference factories.
  *
  * Replaces stringly-typed `serverAction("authenticate", {...})` calls with
  * typed action creators that catch typos at compile time.
  *
  * @example
  * ```typescript
- * import { createActions } from '@mindmatrix/react';
+ * import { createActions } from '@mmapp/react';
  *
  * const actions = createActions({
  *   authenticate: { handler: 'actions/auth.server.ts' },
@@ -3015,6 +3309,77 @@ type ActionCreators<M extends ActionManifest> = {
  */
 declare function createActions<const M extends ActionManifest>(manifest: M): ActionCreators<M>;
 
+/**
+ * Orchestration Strategy Presets (Design 28)
+ *
+ * Each preset provides sensible defaults for a common multi-player pattern.
+ * Users can override any field — the preset just fills in defaults.
+ */
+
+/** Fully resolved orchestration config — every field has a value. */
+interface ResolvedOrchestrationConfig {
+    strategy: OrchestrationStrategy;
+    evaluation: {
+        pure: 'local' | 'primary' | 'consensus' | 'nearest';
+    };
+    scheduling: {
+        coordinator: string;
+    };
+    events: {
+        evaluator: string;
+    };
+    errorHandling: {
+        strategy: string;
+    };
+    conflicts: {
+        default: string;
+        fields: Record<string, {
+            strategy: string;
+            type?: string;
+        }>;
+    };
+    visibility: {
+        roles: Record<string, {
+            fields: readonly string[] | '*';
+            states?: readonly string[] | '*';
+        }>;
+        players: Record<string, {
+            fields: readonly string[] | '*';
+        }>;
+    };
+    presence: {
+        enabled: boolean;
+        showEditing: boolean;
+        showViewing: boolean;
+        conflictHighlight: boolean;
+    };
+    services: Record<string, {
+        type: string;
+        url?: string;
+        actions: readonly string[];
+        timeout?: string;
+        retry?: number;
+    }>;
+    actionRouting: Record<string, {
+        target: string;
+        fallback?: string;
+        required?: boolean;
+    }>;
+}
+/** Preset lookup by strategy name. */
+declare const ORCHESTRATION_PRESETS: Record<OrchestrationStrategy, OrchestrationConfig>;
+/**
+ * Resolve user-provided orchestration config with preset defaults.
+ *
+ * 1. If `config.strategy` is set, use that preset as the base.
+ * 2. Merge user overrides on top.
+ * 3. Fill any remaining gaps with the default (client-server).
+ *
+ * @param config - User-provided partial orchestration config.
+ * @returns Fully resolved config with all fields populated.
+ */
+declare function resolveOrchestration(config?: OrchestrationConfig): ResolvedOrchestrationConfig;
+
 /**
  * defineBlueprint — declarative configuration for a MindMatrix workflow blueprint.
  *
@@ -3027,7 +3392,7 @@ declare function createActions<const M extends ActionManifest>(manifest: M): Act
  * it requires (dependencies, capabilities).
  *
  * Usage in mm.config.ts:
- *   import { defineBlueprint } from '@mindmatrix/react';
+ *   import { defineBlueprint } from '@mmapp/react';
  *
  *   export default defineBlueprint({
  *     slug: 'mod-authentication',
@@ -3188,7 +3553,7 @@ interface BlueprintConfig {
     icon?: string;
     /** Tags for discovery. */
     tags?: string[];
-    /** Compilation mode: strict enforces @mindmatrix/react-only hooks; infer allows escape hatches. */
+    /** Compilation mode: strict enforces @mmapp/react-only hooks; infer allows escape hatches. */
     mode?: 'strict' | 'infer';
     /** Default runtime profile for all workflows in this definition. */
     defaultRuntime?: RuntimeProfile;
@@ -3277,7 +3642,7 @@ declare function defineModule<const M extends BlueprintConfig>(manifest: M): M &
 };
 
 /**
- * @mindmatrix/react/conditions — Typed condition helpers for transition guards.
+ * @mmapp/react/conditions — Typed condition helpers for transition guards.
  *
  * Factory functions that produce `TransitionCondition` objects for use in
  * model transition definitions. Instead of writing raw condition objects:
@@ -3293,7 +3658,7 @@ declare function defineModule<const M extends BlueprintConfig>(manifest: M): M &
  * You can use ergonomic helpers:
  *
  * ```typescript
- * import { isSender, hasRole, fieldEquals, or } from '@mindmatrix/react';
+ * import { isSender, hasRole, fieldEquals, or } from '@mmapp/react';
  *
  * conditions: [
  *   or(isSender(), hasRole('admin')),
@@ -3310,7 +3675,7 @@ declare function defineModule<const M extends BlueprintConfig>(manifest: M): M &
  *
  * @example
  * ```typescript
- * import { expr } from '@mindmatrix/react';
+ * import { expr } from '@mmapp/react';
  *
  * transitions: {
  *   approve: {
@@ -3331,7 +3696,7 @@ declare function expr(expression: string): TransitionCondition;
  *
  * @example
  * ```typescript
- * import { when } from '@mindmatrix/react';
+ * import { when } from '@mmapp/react';
  *
  * conditions: [when('input.email != null && LEN(input.email) > 0')]
  * ```
@@ -3345,7 +3710,7 @@ declare function when(expression: string): TransitionCondition;
  *
  * @example
  * ```typescript
- * import { hasRole } from '@mindmatrix/react';
+ * import { hasRole } from '@mmapp/react';
  *
  * transitions: {
  *   delete: {
@@ -3366,7 +3731,7 @@ declare function hasRole(role: string): TransitionCondition;
  *
  * @example
  * ```typescript
- * import { hasAnyRole } from '@mindmatrix/react';
+ * import { hasAnyRole } from '@mmapp/react';
  *
  * transitions: {
  *   archive: {
@@ -3387,7 +3752,7 @@ declare function hasAnyRole(...roles: string[]): TransitionCondition;
  *
  * @example
  * ```typescript
- * import { isOwner } from '@mindmatrix/react';
+ * import { isOwner } from '@mmapp/react';
  *
  * // Default: checks state_data.ownerId
  * conditions: [isOwner()]
@@ -3407,7 +3772,7 @@ declare function isOwner(ownerField?: string): TransitionCondition;
  *
  * @example
  * ```typescript
- * import { isActor } from '@mindmatrix/react';
+ * import { isActor } from '@mmapp/react';
  *
  * // Only the sender can edit their message
  * conditions: [isActor('senderId')]
@@ -3424,7 +3789,7 @@ declare function isActor(actorField: string): TransitionCondition;
  *
  * @example
  * ```typescript
- * import { isSender, hasRole, or } from '@mindmatrix/react';
+ * import { isSender, hasRole, or } from '@mmapp/react';
  *
  * // Only the sender or an admin can delete a message
  * conditions: [or(isSender(), hasRole('admin'))]
@@ -3440,7 +3805,7 @@ declare function isSender(): TransitionCondition;
  *
  * @example
  * ```typescript
- * import { isCreator } from '@mindmatrix/react';
+ * import { isCreator } from '@mmapp/react';
  *
  * conditions: [isCreator()]
  * ```
@@ -3455,7 +3820,7 @@ declare function isCreator(): TransitionCondition;
  *
  * @example
  * ```typescript
- * import { fieldEquals } from '@mindmatrix/react';
+ * import { fieldEquals } from '@mmapp/react';
  *
  * conditions: [fieldEquals('status', 'draft')]
  * // Equivalent to: { type: 'field', field: 'status', operator: 'eq', value: 'draft' }
@@ -3471,7 +3836,7 @@ declare function fieldEquals(field: string, value: unknown): TransitionCondition
  *
  * @example
  * ```typescript
- * import { fieldNotEquals } from '@mindmatrix/react';
+ * import { fieldNotEquals } from '@mmapp/react';
  *
  * conditions: [fieldNotEquals('type', 'system')]
  * ```
@@ -3486,7 +3851,7 @@ declare function fieldNotEquals(field: string, value: unknown): TransitionCondit
  *
  * @example
  * ```typescript
- * import { fieldGreaterThan } from '@mindmatrix/react';
+ * import { fieldGreaterThan } from '@mmapp/react';
  *
  * conditions: [fieldGreaterThan('amount', 1000)]
  * ```
@@ -3501,7 +3866,7 @@ declare function fieldGreaterThan(field: string, value: number): TransitionCondi
  *
  * @example
  * ```typescript
- * import { fieldLessThan } from '@mindmatrix/react';
+ * import { fieldLessThan } from '@mmapp/react';
  *
  * conditions: [fieldLessThan('retryCount', 3)]
  * ```
@@ -3516,7 +3881,7 @@ declare function fieldLessThan(field: string, value: number): TransitionConditio
  *
  * @example
  * ```typescript
- * import { fieldIn } from '@mindmatrix/react';
+ * import { fieldIn } from '@mmapp/react';
  *
  * conditions: [fieldIn('priority', ['high', 'critical'])]
  * ```
@@ -3531,7 +3896,7 @@ declare function fieldIn(field: string, values: unknown[]): TransitionCondition;
  *
  * @example
  * ```typescript
- * import { fieldNotIn } from '@mindmatrix/react';
+ * import { fieldNotIn } from '@mmapp/react';
  *
  * conditions: [fieldNotIn('status', ['deleted', 'archived'])]
  * ```
@@ -3546,7 +3911,7 @@ declare function fieldNotIn(field: string, values: unknown[]): TransitionConditi
  *
  * @example
  * ```typescript
- * import { fieldContains } from '@mindmatrix/react';
+ * import { fieldContains } from '@mmapp/react';
  *
  * // Check if the members array contains the actor
  * conditions: [fieldContains('members', 'context.actor_id')]
@@ -3561,7 +3926,7 @@ declare function fieldContains(field: string, value: unknown): TransitionConditi
  *
  * @example
  * ```typescript
- * import { fieldIsSet } from '@mindmatrix/react';
+ * import { fieldIsSet } from '@mmapp/react';
  *
  * conditions: [fieldIsSet('approvedBy')]
  * ```
@@ -3575,7 +3940,7 @@ declare function fieldIsSet(field: string): TransitionCondition;
  *
  * @example
  * ```typescript
- * import { fieldIsEmpty } from '@mindmatrix/react';
+ * import { fieldIsEmpty } from '@mmapp/react';
  *
  * conditions: [fieldIsEmpty('errorMessage')]
  * ```
@@ -3590,7 +3955,7 @@ declare function fieldIsEmpty(field: string): TransitionCondition;
  *
  * @example
  * ```typescript
- * import { fieldMatches } from '@mindmatrix/react';
+ * import { fieldMatches } from '@mmapp/react';
  *
  * conditions: [fieldMatches('email', '^[^@]+@[^@]+\\.[^@]+$')]
  * ```
@@ -3608,7 +3973,7 @@ declare function fieldMatches(field: string, pattern: string): TransitionConditi
  *
  * @example
  * ```typescript
- * import { inputRequired } from '@mindmatrix/react';
+ * import { inputRequired } from '@mmapp/react';
  *
  * transitions: {
  *   login: {
@@ -3635,7 +4000,7 @@ declare function inputRequired(...fields: string[]): TransitionCondition;
  *
  * @example
  * ```typescript
- * import { inputEquals } from '@mindmatrix/react';
+ * import { inputEquals } from '@mmapp/react';
  *
  * conditions: [inputEquals('confirmDelete', true)]
  * // Generates: { type: 'expression', expression: 'input.confirmDelete == true' }
@@ -3655,7 +4020,7 @@ declare function inputEquals(field: string, value: unknown): TransitionCondition
  *
  * @example
  * ```typescript
- * import { inState } from '@mindmatrix/react';
+ * import { inState } from '@mmapp/react';
  *
  * conditions: [inState('active')]
  * ```
@@ -3671,7 +4036,7 @@ declare function inState(state: string): TransitionCondition;
  *
  * @example
  * ```typescript
- * import { notInState } from '@mindmatrix/react';
+ * import { notInState } from '@mmapp/react';
  *
  * conditions: [notInState('deleted')]
  * ```
@@ -3687,7 +4052,7 @@ declare function notInState(state: string): TransitionCondition;
  *
  * @example
  * ```typescript
- * import { and, isOwner, fieldEquals } from '@mindmatrix/react';
+ * import { and, isOwner, fieldEquals } from '@mmapp/react';
  *
  * conditions: [and(isOwner(), fieldEquals('status', 'draft'))]
  * ```
@@ -3704,7 +4069,7 @@ declare function and(...conditions: (TransitionCondition | string)[]): Transitio
  *
  * @example
  * ```typescript
- * import { or, isSender, hasRole } from '@mindmatrix/react';
+ * import { or, isSender, hasRole } from '@mmapp/react';
  *
  * // Only the sender or an admin can delete — mirrors the chat-message delete pattern
  * transitions: {
@@ -3728,7 +4093,7 @@ declare function or(...conditions: (TransitionCondition | string)[]): Transition
  *
  * @example
  * ```typescript
- * import { not, hasRole, fieldEquals } from '@mindmatrix/react';
+ * import { not, hasRole, fieldEquals } from '@mmapp/react';
  *
  * // Deny admins
  * conditions: [not(hasRole('admin'))]
@@ -3755,7 +4120,7 @@ declare function not(condition: TransitionCondition | string): TransitionConditi
  *
  * @example
  * ```typescript
- * import { refHasRole } from '@mindmatrix/react';
+ * import { refHasRole } from '@mmapp/react';
  *
  * // Only channel owners can delete — mirrors chat-channel delete pattern
  * transitions: {
@@ -3784,7 +4149,7 @@ declare function refHasRole(slug: string, lookupField: string, lookupValue: stri
  *
  * @example
  * ```typescript
- * import { refHasAnyRole } from '@mindmatrix/react';
+ * import { refHasAnyRole } from '@mmapp/react';
  *
  * // Admins or owners can archive — mirrors chat-channel archive pattern
  * transitions: {
@@ -3809,7 +4174,7 @@ declare function refHasAnyRole(slug: string, lookupField: string, lookupValue: s
  * @example
  * ```tsx
  * import auth from '../models/authentication.workflow';
- * import { useModel } from '@mindmatrix/react';
+ * import { useModel } from '@mmapp/react';
  *
  * export default function LoginPage() {
  *   const { fields, state, trigger, loading } = useModel(auth);
@@ -3967,12 +4332,12 @@ declare function useCollection<D extends ModelDefinition>(definition: D, options
  * Compile-Time Atom Stubs — markers for the compiler to recognize.
  *
  * These are NOT runtime components — they are compile-time type stubs that
- * the @mindmatrix/react-compiler recognizes in JSX and maps to IRExperienceNode
+ * the @mmapp/react-compiler recognizes in JSX and maps to IRExperienceNode
  * entries. At runtime, the frontend's ComponentTreeRenderer resolves the
  * component name string to the actual registered React component.
  *
  * Usage in .workflow.tsx files:
- *   import { Stack, Row, Text, Button, TextInput } from '@mindmatrix/react/atoms';
+ *   import { Stack, Row, Text, Button, TextInput } from '@mmapp/react/atoms';
  *
  *   return (
  *     <Stack gap={4}>
@@ -4317,7 +4682,7 @@ declare const RoleGuard: FC<RoleGuardProps>;
  * - jsonpath: JSONPath expressions
  *
  * Usage in model files:
- *   import { cedar, sql, cron } from '@mindmatrix/react';
+ *   import { cedar, sql, cron } from '@mmapp/react';
  *
  *   export const access = cedar`
  *     permit (principal, action == Action::"read", resource)
@@ -4393,7 +4758,7 @@ declare function sql(strings: TemplateStringsArray, ...values: unknown[]): Gramm
  * Usage:
  *   const schedule = cron`0 3 * * *`;  // Every day at 3 AM
  */
-declare function cron(strings: TemplateStringsArray, ...values: unknown[]): GrammarIsland;
+declare function cron$1(strings: TemplateStringsArray, ...values: unknown[]): GrammarIsland;
 /**
  * DMN decision table (markdown-like syntax).
  *
@@ -4434,7 +4799,7 @@ declare function jsonpath(strings: TemplateStringsArray, ...values: unknown[]):
  * and the backend runtime provides the concrete implementation.
  *
  * Usage in action files (actions.server.ts):
- *   import type { TransitionContext } from '@mindmatrix/react/server';
+ *   import type { TransitionContext } from '@mmapp/react/server';
  *
  *   export async function notifyMembers(ctx: TransitionContext) {
  *     const channel = ctx.stateData;
@@ -4579,7 +4944,7 @@ type ServerActionFn = (ctx: TransitionContext) => void | Promise<void>;
  * - No collision between blueprints
  *
  * Usage:
- *   import { deriveInstanceKey, deriveInstanceKeySync } from '@mindmatrix/react';
+ *   import { deriveInstanceKey, deriveInstanceKeySync } from '@mmapp/react';
  *
  *   const key = deriveInstanceKeySync('mm-chat', '/chat/[channelId]', { channelId: '123' });
  *   // → 'mm-chat:a1b2c3d4'
@@ -4600,11 +4965,11 @@ declare function deriveInstanceKey(blueprintSlug: string, layoutPath: string, pa
 declare function deriveInstanceKeySync(blueprintSlug: string, layoutPath: string, params?: InstanceKeyParams): string;
 
 /**
- * Authoring-time API — compile-time declarations for the @mindmatrix/react
+ * Authoring-time API — compile-time declarations for the @mmapp/react
  * workflow DSL.
  *
  * These functions are used when writing .workflow.tsx files. The Babel plugin
- * (@mindmatrix/react-compiler) transforms them at compile time into IR.
+ * (@mmapp/react-compiler) transforms them at compile time into IR.
  * They are NOT called at runtime — the compiler replaces them with runtime
  * equivalents (useExperienceState, useTransition with 1 arg, etc.).
  *
@@ -4776,14 +5141,14 @@ declare function useModuleConfigWithMutation(moduleSlug: string): {
 };
 
 /**
- * @mindmatrix/react/builders — Fluent builder API for ModelDefinition objects.
+ * @mmapp/react/builders — Fluent builder API for ModelDefinition objects.
  *
  * Provides a chainable API for constructing workflow models, fields, states,
  * and transitions without deeply nested object literals.
  *
  * @example
  * ```typescript
- * import { model, field, state, transition } from '@mindmatrix/react/builders';
+ * import { model, field, state, transition } from '@mmapp/react/builders';
  *
  * export default model('invoice')
  *   .version('1.0.0')
@@ -5273,7 +5638,7 @@ declare class ModelBuilder<F extends Record<string, {
  *
  * @example
  * ```typescript
- * import { model, field, state, transition } from '@mindmatrix/react/builders';
+ * import { model, field, state, transition } from '@mmapp/react/builders';
  *
  * export default model('my-model')
  *   .version('1.0.0')
@@ -5394,8 +5759,8 @@ declare function createCRUD(config: CRUDConfig): ModelDefinition;
  *
  * @example
  * ```typescript
- * import { defineModel } from '@mindmatrix/react';
- * import { pipe, withAuditTrail, withSoftDelete, withTags } from '@mindmatrix/react/mixins';
+ * import { defineModel } from '@mmapp/react';
+ * import { pipe, withAuditTrail, withSoftDelete, withTags } from '@mmapp/react/mixins';
  *
  * export default defineModel(pipe(
  *   {
@@ -5413,7 +5778,7 @@ declare function createCRUD(config: CRUDConfig): ModelDefinition;
  * ));
  * ```
  *
- * @module @mindmatrix/react/mixins
+ * @module @mmapp/react/mixins
  */
 
 /**
@@ -5435,8 +5800,8 @@ type ModelMixin = (def: ModelDefinition) => ModelDefinition;
  *
  * @example
  * ```typescript
- * import { defineModel } from '@mindmatrix/react';
- * import { applyMixins, withTimestamps, withTags } from '@mindmatrix/react/mixins';
+ * import { defineModel } from '@mmapp/react';
+ * import { applyMixins, withTimestamps, withTags } from '@mmapp/react/mixins';
  *
  * const base = {
  *   slug: 'article',
@@ -5461,8 +5826,8 @@ declare function applyMixins(def: ModelDefinition, ...mixins: ModelMixin[]): Mod
  *
  * @example
  * ```typescript
- * import { defineModel } from '@mindmatrix/react';
- * import { pipe, withAuditTrail, withSoftDelete, withOwnership } from '@mindmatrix/react/mixins';
+ * import { defineModel } from '@mmapp/react';
+ * import { pipe, withAuditTrail, withSoftDelete, withOwnership } from '@mmapp/react/mixins';
  *
  * export default defineModel(pipe(
  *   {
@@ -5505,8 +5870,8 @@ interface WithAuditTrailOptions {
  *
  * @example
  * ```typescript
- * import { defineModel } from '@mindmatrix/react';
- * import { pipe, withAuditTrail } from '@mindmatrix/react/mixins';
+ * import { defineModel } from '@mmapp/react';
+ * import { pipe, withAuditTrail } from '@mmapp/react/mixins';
  *
  * export default defineModel(pipe(
  *   {
@@ -5552,8 +5917,8 @@ interface WithSoftDeleteOptions {
  *
  * @example
  * ```typescript
- * import { defineModel } from '@mindmatrix/react';
- * import { pipe, withSoftDelete } from '@mindmatrix/react/mixins';
+ * import { defineModel } from '@mmapp/react';
+ * import { pipe, withSoftDelete } from '@mmapp/react/mixins';
  *
  * export default defineModel(pipe(
  *   {
@@ -5594,8 +5959,8 @@ interface WithVersioningOptions {
  *
  * @example
  * ```typescript
- * import { defineModel } from '@mindmatrix/react';
- * import { pipe, withVersioning } from '@mindmatrix/react/mixins';
+ * import { defineModel } from '@mmapp/react';
+ * import { pipe, withVersioning } from '@mmapp/react/mixins';
  *
  * export default defineModel(pipe(
  *   {
@@ -5650,8 +6015,8 @@ interface WithRBACOptions {
  *
  * @example
  * ```typescript
- * import { defineModel } from '@mindmatrix/react';
- * import { pipe, withRBAC } from '@mindmatrix/react/mixins';
+ * import { defineModel } from '@mmapp/react';
+ * import { pipe, withRBAC } from '@mmapp/react/mixins';
  *
  * export default defineModel(pipe(
  *   {
@@ -5685,8 +6050,8 @@ declare function withRBAC(options: WithRBACOptions): ModelMixin;
  *
  * @example
  * ```typescript
- * import { defineModel } from '@mindmatrix/react';
- * import { pipe, withTimestamps } from '@mindmatrix/react/mixins';
+ * import { defineModel } from '@mmapp/react';
+ * import { pipe, withTimestamps } from '@mmapp/react/mixins';
  *
  * export default defineModel(pipe(
  *   {
@@ -5723,8 +6088,8 @@ interface WithSlugOptions {
  *
  * @example
  * ```typescript
- * import { defineModel } from '@mindmatrix/react';
- * import { pipe, withSlug } from '@mindmatrix/react/mixins';
+ * import { defineModel } from '@mmapp/react';
+ * import { pipe, withSlug } from '@mmapp/react/mixins';
  *
  * export default defineModel(pipe(
  *   {
@@ -5759,8 +6124,8 @@ interface WithOwnershipOptions {
  *
  * @example
  * ```typescript
- * import { defineModel } from '@mindmatrix/react';
- * import { pipe, withOwnership } from '@mindmatrix/react/mixins';
+ * import { defineModel } from '@mmapp/react';
+ * import { pipe, withOwnership } from '@mmapp/react/mixins';
  *
  * export default defineModel(pipe(
  *   {
@@ -5789,8 +6154,8 @@ declare function withOwnership(options?: WithOwnershipOptions): ModelMixin;
  *
  * @example
  * ```typescript
- * import { defineModel } from '@mindmatrix/react';
- * import { pipe, withTags } from '@mindmatrix/react/mixins';
+ * import { defineModel } from '@mmapp/react';
+ * import { pipe, withTags } from '@mmapp/react/mixins';
  *
  * export default defineModel(pipe(
  *   {
@@ -5828,8 +6193,8 @@ interface WithSearchOptions {
  *
  * @example
  * ```typescript
- * import { defineModel } from '@mindmatrix/react';
- * import { pipe, withSearch } from '@mindmatrix/react/mixins';
+ * import { defineModel } from '@mmapp/react';
+ * import { pipe, withSearch } from '@mmapp/react/mixins';
  *
  * export default defineModel(pipe(
  *   {
@@ -5864,8 +6229,8 @@ declare function withSearch(options: WithSearchOptions): ModelMixin;
  *
  * @example
  * ```typescript
- * import { defineModel } from '@mindmatrix/react';
- * import { pipe, withPagination, withTimestamps } from '@mindmatrix/react/mixins';
+ * import { defineModel } from '@mmapp/react';
+ * import { pipe, withPagination, withTimestamps } from '@mmapp/react/mixins';
  *
  * export default defineModel(pipe(
  *   {
@@ -5889,7 +6254,7 @@ declare function withPagination(): ModelMixin;
  *
  * @example
  * ```typescript
- * import { Blueprint, field, state, transition } from '@mindmatrix/react';
+ * import { Blueprint, field, state, transition } from '@mmapp/react';
  *
  * class AuthModule extends Blueprint {
  *   slug = 'mod-authentication';
@@ -6009,8 +6374,8 @@ declare abstract class Blueprint {
  *
  * @example
  * ```typescript
- * import { model, field, state } from '@mindmatrix/react';
- * import { approval, escalation, review, crud } from '@mindmatrix/react/factories';
+ * import { model, field, state } from '@mmapp/react';
+ * import { approval, escalation, review, crud } from '@mmapp/react/factories';
  *
  * export default model('invoice')
  *   .field('amount', field.currency().required())
@@ -6097,14 +6462,14 @@ interface CrudConfig {
 declare function crud(config?: CrudConfig): (def: ModelDefinition) => ModelDefinition;
 
 /**
- * @mindmatrix/react/testing — Testing utilities for workflow models.
+ * @mmapp/react/testing — Testing utilities for workflow models.
  *
  * Provides static analysis, BDD-style test harnesses, and pretty-printing
  * for models defined with `defineModel()`.
  *
  * @example
  * ```typescript
- * import { validateModel, testModel, describeModel, assertModelValid } from '@mindmatrix/react/testing';
+ * import { validateModel, testModel, describeModel, assertModelValid } from '@mmapp/react/testing';
  * import authModel from '../models/authentication';
  *
  * // Static analysis
@@ -6160,8 +6525,8 @@ interface ValidationIssue {
  *
  * @example
  * ```typescript
- * import { defineModel } from '@mindmatrix/react';
- * import { validateModel } from '@mindmatrix/react/testing';
+ * import { defineModel } from '@mmapp/react';
+ * import { validateModel } from '@mmapp/react/testing';
  *
  * const model = defineModel({
  *   slug: 'order',
@@ -6194,7 +6559,7 @@ declare function validateModel(def: ModelDefinition): ValidationIssue[];
  *
  * @example
  * ```typescript
- * import { assertModelValid } from '@mindmatrix/react/testing';
+ * import { assertModelValid } from '@mmapp/react/testing';
  * import orderModel from '../models/order';
  *
  * // In a test file
@@ -6336,7 +6701,7 @@ interface TestChain extends TestStep {
  *
  * @example
  * ```typescript
- * import { testModel } from '@mindmatrix/react/testing';
+ * import { testModel } from '@mmapp/react/testing';
  * import messageModel from '../models/message';
  *
  * testModel(messageModel)
@@ -6385,7 +6750,7 @@ declare function testModel(def: ModelDefinition): {
  *
  * @example
  * ```typescript
- * import { describeModel } from '@mindmatrix/react/testing';
+ * import { describeModel } from '@mmapp/react/testing';
  * import authModel from '../models/authentication';
  *
  * console.log(describeModel(authModel));
@@ -6411,6 +6776,311 @@ declare function testModel(def: ModelDefinition): {
  */
 declare function describeModel(def: ModelDefinition): string;
 
+/**
+ * Workflow Inheritance — extend a base workflow to create a derived workflow.
+ *
+ * `extend()` is a compile-time declaration. The compiler (@mmapp/react-compiler):
+ * 1. Resolves the base workflow import
+ * 2. Compiles the base to IR
+ * 3. Applies overrides (replaced states, new fields, inserted states, modified transitions)
+ * 4. Outputs a single flat IR definition
+ *
+ * At runtime, `extend()` throws — it must be compiled away before execution.
+ *
+ * @example
+ * ```typescript
+ * import orderWorkflow from './order';
+ *
+ * export default extend(orderWorkflow, {
+ *   slug: 'premium-order',
+ *   fields: {
+ *     loyaltyTier: 'gold | silver | bronze',
+ *     giftMessage: 'string',
+ *   },
+ *   states: {
+ *     processPayment: async (order, base) => {
+ *       await fraudCheck(order);
+ *       await base(order);
+ *       await addLoyaltyPoints(order);
+ *     },
+ *   },
+ *   insert: {
+ *     after: { checkout: verifyMembership },
+ *     before: { ship: giftWrap },
+ *   },
+ *   transitions: {
+ *     ship: { roles: ['premium-warehouse'] },
+ *   },
+ * });
+ * ```
+ *
+ * @module @mmapp/react/extend
+ */
+/**
+ * Shorthand field type string (e.g. 'string', 'number', 'gold | silver | bronze')
+ * or a full field configuration object.
+ */
+type FieldShorthand = string | {
+    type: string;
+    required?: boolean;
+    default?: unknown;
+    description?: string;
+    validation?: Record<string, unknown>;
+};
+/**
+ * Partial transition configuration for overriding base transitions.
+ * All properties are optional — they merge with the base transition definition.
+ */
+interface TransitionOverride {
+    /** Roles allowed to trigger this transition. Replaces the base roles if provided. */
+    roles?: string[];
+    /** Required field keys that must be set before the transition fires. */
+    require?: string[];
+    /** Expression string evaluated at transition time. Must return truthy. */
+    when?: string;
+    /** If true, the transition fires automatically when conditions are met. */
+    auto?: boolean;
+    /** Override the 'from' state(s). */
+    from?: string | string[];
+    /** Override the 'to' state. */
+    to?: string;
+}
+/** Role configuration for additional roles merged into the derived workflow. */
+interface ExtendRoleDefinition {
+    /** Human-readable description of the role. */
+    description?: string;
+    /** Permission keys granted to this role. */
+    permissions?: string[];
+    /** Parent roles this role inherits from. */
+    inherits?: string[];
+}
+/**
+ * Insert configuration — inject new state functions at specific points in the
+ * base workflow's state machine.
+ *
+ * The compiler rewires transitions so the inserted states execute in the
+ * correct order while preserving the base workflow's transition graph.
+ */
+interface InsertConfig<TData> {
+    /**
+     * Insert a state function after the named base state.
+     * A new transition is created from the base state to the inserted state,
+     * and the inserted state inherits the base state's outgoing transitions.
+     */
+    after?: Record<string, (data: TData) => Promise<void>>;
+    /**
+     * Insert a state function before the named base state.
+     * A new transition is created from the inserted state to the base state,
+     * and the inserted state inherits the base state's incoming transitions.
+     */
+    before?: Record<string, (data: TData) => Promise<void>>;
+}
+/**
+ * Configuration for creating a derived workflow from a base workflow.
+ *
+ * @typeParam TData - The data shape of the workflow (inferred from base).
+ */
+interface ExtendOptions<TData = unknown> {
+    /** Slug for the derived workflow. If omitted, compiler generates one. */
+    slug?: string;
+    /** Human-readable name for the derived workflow. */
+    name?: string;
+    /** Description of the derived workflow. */
+    description?: string;
+    /** Category override (e.g. 'workflow', 'data', 'module'). */
+    category?: string;
+    /**
+     * Additional fields to add to the derived workflow.
+     * Uses shorthand strings ('string', 'number', 'gold | silver | bronze')
+     * or full field configuration objects.
+     */
+    fields?: Record<string, FieldShorthand>;
+    /**
+     * Override state functions from the base workflow.
+     *
+     * Each key is a state name from the base. The function receives the
+     * workflow data and a `base` callback that invokes the original state
+     * function (the "super" call).
+     *
+     * @example
+     * ```typescript
+     * states: {
+     *   processPayment: async (order, base) => {
+     *     await fraudCheck(order);
+     *     await base(order);        // call the original processPayment
+     *     await addLoyaltyPoints(order);
+     *   },
+     * }
+     * ```
+     */
+    states?: Record<string, (data: TData, base: (data: TData) => Promise<void>) => Promise<void>>;
+    /**
+     * Insert new state functions at specific points in the base workflow.
+     * Creates new states and rewires transitions accordingly.
+     */
+    insert?: InsertConfig<TData>;
+    /**
+     * Override transition options. Properties are merged with the base
+     * transition — you only need to specify what changes.
+     */
+    transitions?: Record<string, TransitionOverride>;
+    /**
+     * Additional roles to merge with the base workflow's roles.
+     * New roles are added; existing roles are merged (arrays are concatenated).
+     */
+    roles?: Record<string, ExtendRoleDefinition>;
+    /**
+     * Override orchestration configuration (multi-player strategies, conflict
+     * resolution, etc.). Merged shallowly with the base orchestration.
+     */
+    orchestration?: Record<string, unknown>;
+}
+/**
+ * Create a derived workflow by extending a base workflow.
+ *
+ * This function is a **compile-time declaration**. The compiler
+ * (`@mmapp/react-compiler`) detects `extend()` calls and:
+ *
+ * 1. Resolves the base workflow (which must be a default export from another
+ *    `.workflow.tsx` file or an imported `defineModel()` definition).
+ * 2. Compiles the base workflow to IR.
+ * 3. Applies the `options` as overrides — merging fields, replacing or
+ *    wrapping state functions, inserting new states, and adjusting transitions.
+ * 4. Outputs a single flat IR definition (no runtime inheritance chain).
+ *
+ * **At runtime, this function throws.** It must be compiled away before the
+ * code executes. If you see the runtime error, ensure your build pipeline
+ * includes the `@mmapp/react-compiler` Babel plugin or use `mmrc build`.
+ *
+ * @typeParam TData - The data shape of the base workflow (inferred).
+ * @param base - The base workflow function (imported from another file).
+ * @param options - Override and extension configuration.
+ * @returns A workflow function with the same signature as the base (for type inference).
+ *
+ * @example
+ * ```typescript
+ * import orderWorkflow from './order';
+ *
+ * export default extend(orderWorkflow, {
+ *   slug: 'premium-order',
+ *   fields: {
+ *     loyaltyTier: 'gold | silver | bronze',
+ *     giftMessage: 'string',
+ *   },
+ *   states: {
+ *     processPayment: async (order, base) => {
+ *       await fraudCheck(order);
+ *       await base(order);
+ *       await addLoyaltyPoints(order);
+ *     },
+ *   },
+ *   insert: {
+ *     after: { checkout: verifyMembership },
+ *     before: { ship: giftWrap },
+ *   },
+ *   transitions: {
+ *     ship: { roles: ['premium-warehouse'] },
+ *   },
+ * });
+ * ```
+ */
+declare function extend<TData>(base: (data: TData) => Promise<void>, options: ExtendOptions<TData>): (data: TData) => Promise<void>;
+
+/**
+ * Workflow Composition — wrap a workflow with mixins for cross-cutting concerns.
+ *
+ * `compose()` applies mixins to a workflow function. Unlike `extend()` (which
+ * creates a derived workflow from a base), `compose()` decorates an existing
+ * workflow with additional fields, states, and transitions without modifying
+ * the original function.
+ *
+ * Mixins are applied post-compilation: the compiler detects `compose()` calls,
+ * compiles the inner workflow to IR, then applies each mixin's `apply()`
+ * function to the IR in order (left to right).
+ *
+ * @example
+ * ```typescript
+ * import { compose, withAuditTrail, withSoftDelete, withRBAC } from '@mmapp/react';
+ *
+ * export default compose(taskWorkflow,
+ *   withAuditTrail(),
+ *   withSoftDelete(),
+ *   withRBAC({ admin: ['*'], member: ['start', 'complete'] }),
+ * );
+ * ```
+ *
+ * @module @mmapp/react/compose
+ */
+/**
+ * A mixin that can be applied to a compiled workflow IR.
+ *
+ * Mixins are created by factory functions (e.g. `withAuditTrail()`,
+ * `withSoftDelete()`, `withRBAC()`). The factory returns a `WorkflowMixin`
+ * object that the compiler applies to the IR after the base workflow is
+ * compiled.
+ *
+ * The `apply` function receives the compiled IR and returns a new IR with
+ * the mixin's enhancements. It must not mutate the input.
+ */
+interface WorkflowMixin {
+    /** Discriminator tag — always `true`. Used by the compiler to identify mixin objects. */
+    readonly __mixin: true;
+    /** Human-readable name for the mixin (e.g. 'audit-trail', 'soft-delete'). */
+    readonly name: string;
+    /**
+     * Apply this mixin to a compiled workflow IR.
+     * Returns a new IR with the mixin's enhancements (fields, states, transitions, etc.).
+     * Must not mutate the input IR.
+     *
+     * @param ir - The compiled workflow IR (opaque at the type level; the compiler knows the shape).
+     * @returns The enhanced IR.
+     */
+    apply: (ir: unknown) => unknown;
+}
+/**
+ * Internal metadata attached to the wrapper function returned by `compose()`.
+ * The compiler inspects this to discover the base workflow and mixin chain.
+ */
+interface ComposedWorkflowMetadata<T extends (...args: unknown[]) => Promise<void>> {
+    readonly __composed: true;
+    /** The original workflow function before composition. */
+    readonly workflow: T;
+    /** The ordered list of mixins to apply post-compilation. */
+    readonly mixins: readonly WorkflowMixin[];
+}
+/**
+ * Compose a workflow with one or more mixins.
+ *
+ * Returns a thin wrapper that stores the workflow reference and mixin list.
+ * The compiler detects `compose()` calls and:
+ * 1. Compiles the inner workflow to IR.
+ * 2. Applies each mixin's `apply()` to the IR in left-to-right order.
+ * 3. Outputs the final enhanced IR.
+ *
+ * At runtime, the wrapper delegates to the original workflow function.
+ * Mixin application only happens at compile time (in the IR layer).
+ *
+ * @typeParam T - The workflow function type (preserved through composition).
+ * @param workflow - The workflow function to compose.
+ * @param mixins - One or more `WorkflowMixin` objects to apply.
+ * @returns A function with the same signature as `workflow`, annotated with composition metadata.
+ *
+ * @example
+ * ```typescript
+ * import { compose } from '@mmapp/react';
+ * import { withAuditTrail, withSoftDelete, withRBAC } from '@mmapp/react';
+ *
+ * const taskWorkflow = async (data: TaskData) => { ... };
+ *
+ * export default compose(taskWorkflow,
+ *   withAuditTrail(),
+ *   withSoftDelete(),
+ *   withRBAC({ admin: ['*'], member: ['start', 'complete'] }),
+ * );
+ * ```
+ */
+declare function compose<T extends (...args: any[]) => Promise<void>>(workflow: T, ...mixins: WorkflowMixin[]): T;
+
 /**
  * Player Web Types — React integration types for the browser-side workflow engine.
  */
@@ -7021,4 +7691,593 @@ declare class BrowserPlayer {
     private log;
 }
 
-export { Accordion, type ActionContext, type ActionCreator, type ActionCreators, type ActionDefinition, type ActionEnvironment, type ActionHandler, type ActionManifest, type ActionManifestEntry, type ActionNotifyOptions, type ActionOptions, type ActionResult, AnimatedBox, type ApprovalConfig, type AuthOptions, type AuthResolver, type AuthResult, type AuthUser, Badge, type BadgeProps, Blueprint, type BlueprintAction, type BlueprintConfig, type BlueprintConfigSchema, type BlueprintDependency, type BlueprintManifest, type BlueprintRoute, type BlueprintServerActionDeclaration, type BlueprintSlotContribution, type BlueprintViewDeclaration, BrowserPlayer, type BrowserPlayerConfig, type TransitionResult as BrowserTransitionResult, Button, type ButtonProps, type CRUDConfig, Canvas3D, Card, type CardProps, type CedarPolicy, type ChannelHandle, type ChannelMessage, type ChannelOptions, type ChannelTransport, Chart, type CollectionHandle, Column, type ColumnProps, type ComputedFieldMode, type ComputedFieldResult, type CronFields, type CrudConfig, DataGrid, type DataSource, type DataSourceResult, Divider, type DividerProps, type DmnRule, type DomainEvent, type DomainSubscriptionConfig, type DomainSubscriptionTransport, type DuringAction, type DuringActionConfig, Each, type EachProps, type EscalationConfig, type EventPayload, type EventSubscription, type ExperienceViewConfig, ExperienceWorkflowBridge, type ExperienceWorkflowBridgeProps, type ExperienceWorkflowDefinition, type ExpressionLibraryRecord, type ExpressionLibraryResolver, type ExpressionLibraryResult, Field, FieldBuilder, type FieldRegistration, type FieldTypeMap, type FieldValidation, type FieldValidator, type FormConfig, type FormHandle, type FormValidator, type GeoPosition, type GeolocationError, type GeolocationOptions, type GeolocationResult, type GrammarIsland, Grid, Heading, type HeadingProps, Icon, Image, type InferFieldNames, type InferFields, type InferSlug, type InferStates, type InferTransitions, type InstalledModuleRef, type InstanceData, type InstanceKeyParams, type InstanceRef, type LatLng, type LatLngBounds, type LibraryParam, Link, type LocalDataResolver, type LocalEngineAdapter, type LocalEngineContextValue, LocalEngineProvider, type LocalEngineStore, LocalWorkflowEngine, type LoginCredentials, type MapMarker, type MapViewHandle, type MapViewOptions, Markdown, MetricCard, type MiddlewareContext, type MiddlewareFn, type MiddlewareHandle, type MiddlewareOptions, type MiddlewareResult, type MmWasmModule, Modal, ModelBuilder, type ModelDefinition, type ModelHandle, type ModelMixin, type ModelTestContext, type ModuleAction, type ModuleConfigSchema, type ModuleDependency, type ModuleHandle, type ModuleManifest, type ModuleRoute, type ModuleRouteConfig, type MutationHandle, type MutationResolver, NavLink, type NotificationResult, type NotifyOptions, type PackageChild, type PackageManifest, type PackageResult, type PipelineConfig, type PipelineStage, type PlayerConfig, type PlayerEvent, type PlayerEventCallback, type PlayerEventListener, type PlayerHandle, type PlayerInstance, type PlayerLogEntry, PlayerProvider, type PlayerProviderProps, type QueryParams$1 as QueryParams, type QueryResolver, type QueryResult, type RealtimeQueryParams, type RealtimeQueryResult, type ReviewConfig, type RoleDefinition, RoleGuard, type RoleOptions, type RoleResult, Route, type RouteDefinition, type RouteGuard, type RouteLocation, type RouteParamsOptions, Router, type RouterHandle, type RouterOptions, Row, type RowProps, type RuntimeConfig, RuntimeContext, type RuntimeSnapshot, ScrollArea, Section, Select, type ServerActionFn, type ServerActionHandle, type ServerActionOptions, type ServerActionResolver, type ServerActionResult, ServerGrid, type ServerStateOptions, type ServerStateResolver, type ServerStateResult, type ServerStateSnapshot, type SetupWizard, type SetupWizardStep, Show, type ShowProps, Slot, type SlotContribution, type SlotContributions, type SlotProps, Spacer, type SpawnActionOptions, type SpawnOptions, Stack, type StackProps, StateBuilder, type StateDescriptor, type StateHome, type Subscription, Tabs, type TestChain, type TestStep, Text, TextInput, type TextInputProps, type TextProps, type ToastConfig, type ToastHandle, type ToastInstance, type ToastVariant, TransitionBuilder, type TransitionCondition, type TransitionConfig, type TransitionContext, type TransitionDescriptor, type TransitionHandle, type TypedMutationHandle, TypedTransitionBuilder, type UseCollectionOptions, type UseComputedOptions, type UseModelOptions, type UseModuleOptions, type UseOnEventOptions, type UseWorkflowOptions, type ValidationIssue, type ValidationResult, type ValidationRule, type ViewDefinitionResult, type ViewRecord, type ViewResolver, type WithAuditTrailOptions, type WithOwnershipOptions, type WithRBACOptions, type WithSearchOptions, type WithSlugOptions, type WithSoftDeleteOptions, type WithVersioningOptions, type WorkflowDataSource, type WorkflowDefinition, type WorkflowEvent, type WorkflowEventHandler, type WorkflowFieldDef, type WorkflowFieldDescriptor, type WorkflowHandle, type WorkflowInstance, type WorkflowInstanceWithEvents, WorkflowProvider, type WorkflowProviderProps, WorkflowRuntime, type WorkflowState, type WorkflowTransition, action, and, applyMixins, approval, assertModelValid, cedar, connector, createActions, createCRUD, createLocalDataResolver, createLocalEngineAdapter, createPipeline, cron, crud, defineBlueprint, defineModel, defineModule, defineWorkspace, deriveInstanceKey, deriveInstanceKeySync, describeModel, deviceAction, dmn, escalation, expr, field, fieldContains, fieldEquals, fieldGreaterThan, fieldIn, fieldIsEmpty, fieldIsSet, fieldLessThan, fieldMatches, fieldNotEquals, fieldNotIn, getInstalledModule, getInstalledModules, graphql, hasAnyRole, hasRole, inState, inputEquals, inputRequired, isActor, isCreator, isOwner, isPlayerDebug, isSender, jsonpath, llm, loadExperienceWorkflow, logEvent, model, normalizeDefinition, not, notInState, notify, or, pipe, playerLog, prefetchData, refHasAnyRole, refHasRole, requireAuth, requireRole, review, serverAction, setAuthResolver, setChannelTransport, setConfigContext, setExpressionLibraryResolver, setField, setFields, setInstalledModules, setModuleConfigDefaults, setMutationResolver, setPersistedModuleConfig, setPlayerDebug, setQueryResolver, setRealtimeQueryResolver, setRoleHierarchy, setServerActionResolver, setServerStateResolver, setViewResolver, spawn, sql, state, syncConfigDefaults, testModel, transition, updateDefinitionConfig, useAuth, useChannel, useCollection, useComputed, useComputedWithMeta, useDomainSubscription, useDuringAction, useExperienceState, useExpressionLibrary, useForm, useGeolocation, useLocalEngine, useMapView, useMiddleware, useModel, useModule, useModuleConfig, useModuleConfigWithMutation, useMutation, useNotification, useOnChange, useOnEnter, useOnEvent, useOnExit, useOnTransition, usePackage, useParams, usePlayer, usePlayerContext, usePlayerContextSafe, useQuery, useRealtimeQuery, useRole, useRouteParams, useRouter, useRuntimeContext, useServerAction, useServerState, useStateField, useToast, useTransition, useView, useWhileIn, useWorkflow, useState as useWorkflowState, validateExperienceWorkflow, validateModel, when, withAuditTrail, withOwnership, withPagination, withRBAC, withSearch, withSlug, withSoftDelete, withTags, withTimestamps, withVersioning };
+/**
+ * Middleware Definition API (Design 33) — compile-time declarations for engine middleware.
+ *
+ * Middleware intercepts engine execution points (transitions, state changes, field updates, etc.)
+ * and can block, modify, or wrap the operation. This is the declaration layer — the compiler
+ * extracts match patterns and action bodies into IR for the engine to execute.
+ *
+ * Usage:
+ *   import { defineMiddleware } from '@mmapp/react';
+ *
+ *   export default defineMiddleware({
+ *     name: 'audit-logger',
+ *     match: '*:*:transition.execute',
+ *     priority: 10,
+ *     after(ctx) {
+ *       ctx.modify({ lastAuditAt: ctx.timestamp });
+ *     },
+ *   });
+ */
+/**
+ * Execution points that middleware can intercept.
+ * Used in match patterns: `{scope}:{slug}:{executionPoint}`
+ */
+type ExecutionPoint = 'instance.create' | 'instance.delete' | 'transition.evaluate' | 'transition.execute' | 'state.enter' | 'state.exit' | 'action.execute' | 'field.change' | 'event.emit' | 'event.receive' | 'schedule.fire' | 'validation.check';
+/**
+ * Context available to middleware at each execution point.
+ *
+ * NOTE: Named EngineMiddlewareContext to avoid collision with the existing
+ * MiddlewareContext in hooks/useMiddleware.ts (which is a pre-render middleware).
+ * This type represents the engine-level interception context.
+ */
+interface EngineMiddlewareContext {
+    /** The workflow instance being operated on. */
+    instance: {
+        id: string;
+        state: string;
+        fields: Record<string, unknown>;
+        slug: string;
+    };
+    /** The actor performing the operation. */
+    actor: {
+        id: string;
+        roles: string[];
+        email?: string;
+    };
+    /** The workflow definition metadata. */
+    definition: {
+        slug: string;
+        version?: string;
+        category?: string;
+    };
+    /** Timestamp of the operation (epoch ms). */
+    timestamp: number;
+    /** Block the operation with a reason string. Prevents execution. */
+    block(reason: string): void;
+    /** Modify instance fields or operation parameters. */
+    modify(changes: Record<string, unknown>): void;
+    /** Skip the operation silently (no error, no execution). */
+    skip(): void;
+    /** Available for transition.evaluate / transition.execute. */
+    transition?: {
+        name: string;
+        from: string;
+        to: string;
+        input?: Record<string, unknown>;
+    };
+    /** Available for state.enter / state.exit. */
+    state?: {
+        name: string;
+        type: string;
+    };
+    /** Available for action.execute. */
+    action?: {
+        id: string;
+        type: string;
+        config: Record<string, unknown>;
+    };
+    /** Available for field.change. */
+    field?: {
+        name: string;
+        oldValue: unknown;
+        newValue: unknown;
+    };
+    /** Available for event.emit / event.receive. */
+    event?: {
+        type: string;
+        payload: unknown;
+    };
+    /** Available for validation.check. */
+    validation?: {
+        field: string;
+        rule: unknown;
+        value: unknown;
+    };
+}
+/**
+ * Inter-type declarations — fields, states, and transitions that a middleware
+ * introduces into workflows it applies to (AOP inter-type declaration pattern).
+ */
+interface MiddlewareIntroduce {
+    /** Fields to add to workflows this middleware applies to. */
+    fields?: Record<string, {
+        type: string;
+        default?: unknown;
+    }>;
+    /** States to add to workflows this middleware applies to. */
+    states?: Record<string, {
+        type?: string;
+    }>;
+    /** Transitions to add to workflows this middleware applies to. */
+    transitions?: Record<string, {
+        from: string | string[];
+        to: string;
+    }>;
+}
+/**
+ * Middleware definition object — the shape passed to defineMiddleware().
+ */
+interface MiddlewareDefinition {
+    /** Unique name for this middleware. */
+    name: string;
+    /**
+     * Match pattern(s) specifying which execution points to intercept.
+     * Format: `{scope}:{slug}:{executionPoint}` where `*` is a wildcard.
+     * Examples: `'*:*:transition.execute'`, `['order:*:field.change', '*:*:state.enter']`
+     */
+    match: string | string[];
+    /** Priority — higher values run first. Default: 0. */
+    priority?: number;
+    /** Configurable parameters for this middleware (schema for runtime config). */
+    config?: Record<string, {
+        type: string;
+        default?: unknown;
+    }>;
+    /** Runs before the matched execution point. Can block/modify/skip. */
+    before?: (ctx: EngineMiddlewareContext, config?: Record<string, unknown>) => void;
+    /** Runs after the matched execution point completes. */
+    after?: (ctx: EngineMiddlewareContext, config?: Record<string, unknown>) => void;
+    /** Wraps the matched execution point. Must call next() to proceed. */
+    around?: (ctx: EngineMiddlewareContext, next: () => Promise<void>, config?: Record<string, unknown>) => Promise<void>;
+    /**
+     * Inter-type declarations: fields, states, and transitions that this middleware
+     * introduces into any workflow it applies to. The compiler merges these into the
+     * workflow definition at compile time.
+     *
+     * @example
+     * ```typescript
+     * defineMiddleware({
+     *   name: 'mm:soft-delete',
+     *   match: '*:*:instance.delete',
+     *   introduce: {
+     *     fields: { deletedAt: { type: 'datetime' }, isDeleted: { type: 'boolean', default: false } },
+     *     states: { soft_deleted: { type: 'terminal' } },
+     *     transitions: { soft_delete: { from: '*', to: 'soft_deleted' } },
+     *   },
+     *   before(ctx) { ctx.skip(); ctx.modify({ isDeleted: true, deletedAt: ctx.timestamp }); },
+     * });
+     * ```
+     */
+    introduce?: MiddlewareIntroduce;
+    /**
+     * Scope of this middleware instance.
+     * - `'definition'` (default): one instance per workflow definition (shared state across all instances).
+     * - `'instance'`: one instance per workflow instance (per-instance isolated state).
+     */
+    scope?: 'definition' | 'instance';
+    /**
+     * Access level for this middleware.
+     * - `'public'` (default): can only access public instance data (fields, state, actor).
+     * - `'privileged'`: can access internal engine state (for platform-level middleware like metrics, tracing).
+     */
+    access?: 'public' | 'privileged';
+}
+/**
+ * Define middleware for intercepting engine execution points.
+ *
+ * This is a compile-time declaration. The compiler extracts the match patterns
+ * and action bodies. At runtime this is an identity function.
+ *
+ * @example
+ * export default defineMiddleware({
+ *   name: 'require-auth',
+ *   match: '*:*:transition.execute',
+ *   priority: 90,
+ *   before(ctx) {
+ *     if (!ctx.actor.id) ctx.block('Authentication required');
+ *   },
+ * });
+ */
+declare function defineMiddleware<const D extends MiddlewareDefinition>(def: D): D;
+/**
+ * Create a derived middleware by extending a base middleware definition.
+ *
+ * The override fields are shallow-merged on top of the base. For `match`,
+ * the override replaces the base entirely (not concatenated). For `introduce`,
+ * the sub-objects (fields, states, transitions) are merged.
+ *
+ * @param base - The base middleware to extend.
+ * @param overrides - Fields to override or add.
+ * @returns A new MiddlewareDefinition with merged values.
+ *
+ * @example
+ * ```typescript
+ * const baseAuth = defineMiddleware({
+ *   name: 'mm:auth',
+ *   match: '*:*:transition.execute',
+ *   priority: 90,
+ *   before(ctx) { if (!ctx.actor.id) ctx.block('Auth required'); },
+ * });
+ *
+ * const strictAuth = extendMiddleware(baseAuth, {
+ *   name: 'mm:strict-auth',
+ *   priority: 95,
+ *   before(ctx) {
+ *     if (!ctx.actor.id) ctx.block('Auth required');
+ *     if (!ctx.actor.email) ctx.block('Verified email required');
+ *   },
+ * });
+ * ```
+ */
+declare function extendMiddleware(base: MiddlewareDefinition, overrides: Partial<MiddlewareDefinition>): MiddlewareDefinition;
+/**
+ * Authentication middleware — blocks transitions if no actor is present.
+ */
+declare function withAuth(opts?: {
+    redirectTo?: string;
+}): MiddlewareDefinition;
+/**
+ * Audit log middleware — logs transition details after execution.
+ */
+declare function withAuditLog(opts?: {
+    level?: 'debug' | 'info' | 'warn';
+}): MiddlewareDefinition;
+/**
+ * Rate limiting middleware — blocks transitions exceeding the rate limit.
+ */
+declare function withRateLimit(opts?: {
+    maxPerMinute?: number;
+}): MiddlewareDefinition;
+/**
+ * Validation middleware — evaluates field validation rules on field changes.
+ */
+declare function withValidation(opts?: {
+    rules?: Array<{
+        fields: string[];
+        check: string;
+        message: string;
+    }>;
+}): MiddlewareDefinition;
+/**
+ * Metrics middleware — wraps execution with timing measurements.
+ */
+declare function withMetrics(opts?: {
+    endpoint?: string;
+}): MiddlewareDefinition;
+
+/**
+ * Actor Model formalization for workflow instances.
+ *
+ * Each workflow instance is an actor:
+ * - Private state: instance fields
+ * - Mailbox: pending transitions/events
+ * - Behavior: state machine definition
+ * - Communication: events (emit/on)
+ *
+ * Supervision: what happens when an actor fails.
+ * Hierarchy: parent-child relationships between instances.
+ *
+ * All functions are compile-time stubs that throw at runtime.
+ * The compiler extracts the configuration at build time.
+ */
+/** Supervision strategy when an actor (instance) fails */
+type SupervisionStrategy = 'restart' | 'resume' | 'stop' | 'escalate';
+/** Actor supervision configuration */
+interface ActorSupervision {
+    strategy: SupervisionStrategy;
+    /** Max restart attempts before escalating */
+    maxRetries?: number;
+    /** Time window for retry counting (e.g., '1h', '30m') */
+    retryWindow?: string;
+    /** Backoff strategy between retries */
+    backoff?: 'none' | 'linear' | 'exponential';
+    /** Optional callback descriptor for failure handling (extracted at compile time) */
+    onFailure?: (ctx: {
+        instanceId: string;
+        error: string;
+        retryCount: number;
+    }) => void;
+}
+/** Actor hierarchy — parent-child relationships between workflow instances */
+interface ActorHierarchy {
+    /** Parent instance that spawned this actor */
+    parent?: string;
+    /** Children spawned by this actor */
+    children?: string[];
+    /** Supervision strategy applied to children */
+    childSupervision?: ActorSupervision;
+}
+/** Actor mailbox configuration — controls message queuing behavior */
+interface ActorMailbox {
+    /** Max pending messages before backpressure */
+    capacity?: number;
+    /** What to do when mailbox is full */
+    overflow?: 'drop-oldest' | 'drop-newest' | 'block' | 'error';
+    /** Priority ordering for messages */
+    priority?: 'fifo' | 'priority';
+}
+/** Resolved actor configuration (returned by configureActor) */
+interface ActorConfig {
+    readonly __actor: true;
+    readonly supervision: ActorSupervision;
+    readonly mailbox: ActorMailbox;
+    readonly hierarchy: Partial<ActorHierarchy>;
+}
+/**
+ * Configure actor behavior for a workflow.
+ * Used alongside imperative workflow definitions.
+ *
+ * This is a compile-time function. The Babel plugin extracts the
+ * configuration and stores it in the workflow IR metadata.
+ *
+ * @example
+ * ```typescript
+ * import { configureActor } from '@mmapp/react';
+ *
+ * export const actor = configureActor({
+ *   supervision: { strategy: 'restart', maxRetries: 3 },
+ *   mailbox: { capacity: 100, overflow: 'drop-oldest' },
+ * });
+ * ```
+ */
+declare function configureActor(config: {
+    supervision?: ActorSupervision;
+    mailbox?: ActorMailbox;
+    hierarchy?: Partial<ActorHierarchy>;
+}): ActorConfig;
+/**
+ * Spawn a child actor (sub-workflow instance).
+ * The child is supervised by the current actor according to
+ * the provided (or inherited) supervision strategy.
+ *
+ * This is a compile-time function. The compiler transforms it
+ * into a spawn action in the workflow IR.
+ *
+ * @example
+ * ```typescript
+ * async function processing(order: Order) {
+ *   const paymentActor = await spawnActor('payment', {
+ *     input: { amount: order.total },
+ *     supervision: { strategy: 'restart', maxRetries: 3 },
+ *   });
+ *   // paymentActor is a child — if it fails, our supervision strategy applies
+ * }
+ * ```
+ */
+declare function spawnActor(_slug: string, _options?: {
+    input?: Record<string, unknown>;
+    supervision?: ActorSupervision;
+    /** If true, block until the child completes */
+    blocking?: boolean;
+}): Promise<{
+    instanceId: string;
+}>;
+/**
+ * Send a message to another actor (instance).
+ * Messages are delivered to the target actor's mailbox and
+ * processed as transitions or events.
+ *
+ * This is a compile-time function. The compiler transforms it
+ * into a send action in the workflow IR.
+ *
+ * @example
+ * ```typescript
+ * await sendMessage(targetInstanceId, 'process-payment', { amount: 100 });
+ * ```
+ */
+declare function sendMessage(_instanceId: string, _action: string, _payload?: Record<string, unknown>): Promise<void>;
+/**
+ * Check if a value is an ActorConfig (returned by configureActor).
+ */
+declare function isActorConfig(value: unknown): value is ActorConfig;
+
+/**
+ * Constraint Programming DX (Design 34) — declarative workflow constraints.
+ *
+ * Users declare what must be true about their workflow, and the compiler/verifier
+ * proves it at build time using Design 32's verification layers.
+ *
+ * Usage:
+ *   import { constraints } from '@mmapp/react';
+ *
+ *   export const rules = constraints(
+ *     'every state is reachable',
+ *     'no deadlocks',
+ *     'deterministic guards',
+ *     // Business rules (checked via property-based testing)
+ *     'amount >= 0',
+ *     'endDate > startDate',
+ *     // Custom expressions
+ *     'state_data.approvedBy != state_data.requesterId',
+ *   );
+ */
+/**
+ * Built-in constraints that map directly to Design 32 verification layers.
+ * The compiler knows how to statically verify each of these.
+ */
+type BuiltInConstraint = 'every state is reachable' | 'no deadlocks' | 'no unreachable states' | 'deterministic guards' | 'terminates' | 'no guard overlaps' | 'all roles defined' | 'all fields validated';
+/**
+ * A constraint is either a built-in (statically verified) or a custom string
+ * expression (checked via property-based testing at compile time).
+ */
+type Constraint = BuiltInConstraint | (string & {});
+/**
+ * The declaration object returned by constraints(). The compiler detects
+ * this shape via the `__constraints` brand and runs the appropriate
+ * verification layers for each rule.
+ */
+interface ConstraintDeclaration {
+    readonly __constraints: true;
+    readonly rules: readonly Constraint[];
+}
+/** Set of all built-in constraint strings for compiler/tooling use. */
+declare const BUILT_IN_CONSTRAINTS: ReadonlySet<string>;
+/**
+ * Declare workflow constraints that the compiler verifies at build time.
+ *
+ * Built-in constraints (e.g. `'no deadlocks'`, `'deterministic guards'`) map
+ * to Design 32 verification layers and are proven via static analysis of the
+ * workflow's state graph.
+ *
+ * Custom string constraints (e.g. `'amount >= 0'`) are checked via
+ * property-based testing — the compiler generates random inputs and verifies
+ * the expression holds for all reachable states.
+ *
+ * At runtime this is an identity function — it returns the branded declaration
+ * object so the compiler can extract and verify the rules during compilation.
+ *
+ * @param rules - One or more constraint strings.
+ * @returns A branded ConstraintDeclaration object.
+ *
+ * @example
+ * ```typescript
+ * // Structural constraints
+ * export const safety = constraints(
+ *   'every state is reachable',
+ *   'no deadlocks',
+ *   'deterministic guards',
+ * );
+ *
+ * // Business rule constraints
+ * export const invariants = constraints(
+ *   'amount >= 0',
+ *   'endDate > startDate',
+ *   'state_data.approvedBy != state_data.requesterId',
+ * );
+ * ```
+ */
+declare function constraints(...rules: Constraint[]): ConstraintDeclaration;
+/**
+ * Type guard: check if a value is a ConstraintDeclaration.
+ * Useful for compiler internals and tooling.
+ */
+declare function isConstraintDeclaration(value: unknown): value is ConstraintDeclaration;
+/**
+ * Check if a constraint string is a built-in constraint.
+ */
+declare function isBuiltInConstraint(rule: string): rule is BuiltInConstraint;
+
+/**
+ * @mmapp/react/imperative — Compile-time stubs for the imperative
+ * workflow authoring API (Design 30).
+ *
+ * These functions exist ONLY for TypeScript type-checking and IDE IntelliSense.
+ * At runtime they throw helpful errors telling developers to use `mmrc build`.
+ * The Rust compiler (mmrc) transforms calls to these functions into workflow
+ * IR at compile time — they are never executed in the browser or on the server.
+ */
+
+type FieldConfig<T> = {
+    [K in keyof T]?: {
+        required?: boolean;
+        min?: number;
+        max?: number;
+        minLength?: number;
+        maxLength?: number;
+        pattern?: string;
+        default?: T[K];
+    } | string;
+};
+declare function validate(_condition: boolean, _message: string, _severity?: 'error' | 'warning'): void;
+declare function log(_event: string, _data?: Record<string, unknown>): void;
+declare function notify(_to: string, _message: string, _opts?: {
+    channel?: string;
+    template?: string;
+}): void;
+declare function emit(_event: string, _payload?: unknown): void;
+declare function requireRole(..._roles: string[]): void;
+declare function requireField(..._fields: string[]): void;
+declare function guard(_expression: string): void;
+declare function every(_interval: string, _fn: (() => void) | {
+    when?: string;
+    do: () => void;
+}): void;
+declare function cron(_expression: string, _fn: () => void): void;
+declare function after(_delay: string, _fn: () => void): void;
+declare function on(_pattern: string, _handlerOrOpts: ((event: unknown) => void) | {
+    when?: string;
+    do: (event: unknown) => void;
+    timeout?: string;
+} | {
+    when?: string;
+    timeout?: string;
+}): void | Promise<unknown>;
+declare function timeout(_duration: string, _handler: (() => void) | {
+    transition?: string;
+    escalate?: boolean;
+}): void;
+declare function userAction(_name: string, _opts?: {
+    roles?: string[];
+    require?: string[];
+    when?: string;
+    timeout?: string;
+    description?: string;
+    onTimeout?: () => void;
+}): Promise<void>;
+declare function userChoice<T extends Record<string, {
+    roles?: string[];
+    require?: string[];
+    when?: string;
+    description?: string;
+}>>(_options: T): Promise<Extract<keyof T, string>>;
+declare function named(_name: string, _stateCall: Promise<void>): Promise<void>;
+declare function delay(_duration: string): Promise<void>;
+declare function allowTransition(_name: string, _opts: {
+    from: string | string[];
+    to: string;
+    roles?: string[];
+    require?: string[];
+    when?: string;
+}): void;
+declare function restrict(_field: string, _opts: {
+    visibleTo?: string[];
+    editableBy?: string[];
+    editableIn?: string[];
+}): void;
+declare function visibleTo(..._roles: string[]): {
+    visibleTo: string[];
+};
+declare function editableBy(..._roles: string[]): {
+    editableBy: string[];
+};
+declare function editableIn(..._states: string[]): {
+    editableIn: string[];
+};
+declare function defineRoles<T extends Record<string, {
+    description?: string;
+    permissions?: string[];
+    inherits?: string[];
+}>>(roles: T): T;
+/**
+ * Compiler hint: set the runtime target for the current state.
+ * Does not execute at runtime.
+ */
+declare function runtime(_target: RuntimeTarget): void;
+declare function orchestration(config: OrchestrationConfig): OrchestrationConfig;
+declare function blueprint(_slug: string, _config: {
+    workflows: Record<string, Function>;
+    views?: string[];
+    routes?: Array<{
+        path: string;
+        view: string;
+        label?: string;
+    }>;
+    dependencies?: string[];
+}): unknown;
+
+declare function patch(_id: string, _overrides: Record<string, unknown>): void;
+
+declare const actor: {
+    id: string;
+    email: string;
+    roles: string[];
+};
+declare const instance: {
+    id: string;
+    state: string;
+    slug: string;
+};
+
+export { Accordion, type ActionContext, type ActionCreator, type ActionCreators, type ActionDefinition, type ActionEnvironment, type ActionHandler, type ActionManifest, type ActionManifestEntry, type ActionNotifyOptions, type ActionOptions, type ActionResult, type ActionRoutingRule, type ActorConfig, type ActorHierarchy, type ActorMailbox, type ActorSupervision, AnimatedBox, type ApprovalConfig, type AuthOptions, type AuthResolver, type AuthResult, type AuthUser, BUILT_IN_CONSTRAINTS, Badge, type BadgeProps, Blueprint, type BlueprintAction, type BlueprintConfig, type BlueprintConfigSchema, type BlueprintDependency, type BlueprintManifest, type BlueprintRoute, type BlueprintServerActionDeclaration, type BlueprintSlotContribution, type BlueprintViewDeclaration, BrowserPlayer, type BrowserPlayerConfig, type TransitionResult as BrowserTransitionResult, type BuiltInConstraint, Button, type ButtonProps, type CRUDConfig, Canvas3D, Card, type CardProps, type CedarPolicy, type ChannelHandle, type ChannelMessage, type ChannelOptions, type ChannelTransport, Chart, type CollectionHandle, Column, type ColumnProps, type ComposedWorkflowMetadata, type ComputedFieldMode, type ComputedFieldResult, type ConflictStrategy, type Constraint, type ConstraintDeclaration, type CronFields, type CrudConfig, DataGrid, type DataSource, type DataSourceResult, Divider, type DividerProps, type DmnRule, type DomainEvent, type DomainSubscriptionConfig, type DomainSubscriptionTransport, type DuringAction, type DuringActionConfig, Each, type EachProps, type EngineMiddlewareContext, type EscalationConfig, type EventPayload, type EventSubscription, type ExecutionPoint, type ExperienceViewConfig, ExperienceWorkflowBridge, type ExperienceWorkflowBridgeProps, type ExperienceWorkflowDefinition, type ExpressionLibraryRecord, type ExpressionLibraryResolver, type ExpressionLibraryResult, type ExtendOptions, type ExtendRoleDefinition, Field, FieldBuilder, type FieldConfig, type FieldConflictConfig, type FieldRegistration, type FieldShorthand, type FieldTypeMap, type FieldValidation, type FieldValidator, type FormConfig, type FormHandle, type FormValidator, type GeoPosition, type GeolocationError, type GeolocationOptions, type GeolocationResult, type GrammarIsland, Grid, Heading, type HeadingProps, Icon, Image, type InferFieldNames, type InferFields, type InferSlug, type InferStates, type InferTransitions, type InsertConfig, type InstalledModuleRef, type InstanceData, type InstanceKeyParams, type InstanceRef, type LatLng, type LatLngBounds, type LibraryParam, Link, type LocalDataResolver, type LocalEngineAdapter, type LocalEngineContextValue, LocalEngineProvider, type LocalEngineStore, LocalWorkflowEngine, type LoginCredentials, type MapMarker, type MapViewHandle, type MapViewOptions, Markdown, MetricCard, type MiddlewareContext, type MiddlewareDefinition, type MiddlewareFn, type MiddlewareHandle, type MiddlewareIntroduce, type MiddlewareOptions, type MiddlewareResult, type MmWasmModule, Modal, ModelBuilder, type ModelDefinition, type ModelHandle, type ModelMixin, type ModelTestContext, type ModuleAction, type ModuleConfigSchema, type ModuleDependency, type ModuleHandle, type ModuleManifest, type ModuleRoute, type ModuleRouteConfig, type MutationHandle, type MutationResolver, NavLink, type NotificationResult, type NotifyOptions, ORCHESTRATION_PRESETS, type OrchestrationConfig, type OrchestrationStrategy, type PackageChild, type PackageManifest, type PackageResult, type PipelineConfig, type PipelineStage, type PlayerConfig, type PlayerEvent, type PlayerEventCallback, type PlayerEventListener, type PlayerHandle, type PlayerInstance, type PlayerLogEntry, PlayerProvider, type PlayerProviderProps, type PlayerVisibility, type PresenceConfig, type PresenceEditor, type PresenceHandle, type PresenceOptions, type PresenceViewer, type QueryParams$1 as QueryParams, type QueryResolver, type QueryResult, type RealtimeQueryParams, type RealtimeQueryResult, type ResolvedOrchestrationConfig, type ReviewConfig, type RoleDefinition, RoleGuard, type RoleOptions, type RoleResult, type RoleVisibility, Route, type RouteDefinition, type RouteGuard, type RouteLocation, type RouteParamsOptions, Router, type RouterHandle, type RouterOptions, Row, type RowProps, type RuntimeConfig, RuntimeContext, type RuntimeSnapshot, type RuntimeTarget, ScrollArea, Section, Select, type ServerActionFn, type ServerActionHandle, type ServerActionOptions, type ServerActionResolver, type ServerActionResult, ServerGrid, type ServerStateOptions, type ServerStateResolver, type ServerStateResult, type ServerStateSnapshot, type ServiceConfig, type SetupWizard, type SetupWizardStep, Show, type ShowProps, Slot, type SlotContribution, type SlotContributions, type SlotProps, Spacer, type SpawnActionOptions, type SpawnOptions, Stack, type StackProps, StateBuilder, type StateDescriptor, type StateHome, type Subscription, type SupervisionStrategy, Tabs, type TestChain, type TestStep, Text, TextInput, type TextInputProps, type TextProps, type ToastConfig, type ToastHandle, type ToastInstance, type ToastVariant, TransitionBuilder, type TransitionCondition, type TransitionConfig, type TransitionContext, type TransitionDescriptor, type TransitionHandle, type TransitionOverride, type TypedMutationHandle, TypedTransitionBuilder, type UseCollectionOptions, type UseComputedOptions, type UseModelOptions, type UseModuleOptions, type UseOnEventOptions, type UseWorkflowOptions, type ValidationIssue, type ValidationResult, type ValidationRule, type ViewDefinitionResult, type ViewRecord, type ViewResolver, type VisibilityResult, type WithAuditTrailOptions, type WithOwnershipOptions, type WithRBACOptions, type WithSearchOptions, type WithSlugOptions, type WithSoftDeleteOptions, type WithVersioningOptions, type WorkflowDataSource, type WorkflowDefinition, type WorkflowEvent, type WorkflowEventHandler, type WorkflowFieldDef, type WorkflowFieldDescriptor, type WorkflowHandle, type WorkflowInstance, type WorkflowInstanceWithEvents, type WorkflowMixin, WorkflowProvider, type WorkflowProviderProps, WorkflowRuntime, type WorkflowState, type WorkflowTransition, action, actor, after, allowTransition, and, applyMixins, approval, assertModelValid, cedar, compose, computeVisibility, configureActor, connector, constraints, createActions, createCRUD, createLocalDataResolver, createLocalEngineAdapter, createPipeline, cron$1 as cron, crud, defineBlueprint, blueprint as defineImperativeBlueprint, defineMiddleware, defineModel, defineModule, defineRoles, defineWorkspace, delay, deriveInstanceKey, deriveInstanceKeySync, describeModel, deviceAction, dmn, editableBy, editableIn, emit, escalation, every, expr, extend, extendMiddleware, field, fieldContains, fieldEquals, fieldGreaterThan, fieldIn, fieldIsEmpty, fieldIsSet, fieldLessThan, fieldMatches, fieldNotEquals, fieldNotIn, getInstalledModule, getInstalledModules, graphql, guard, hasAnyRole, hasRole, cron as imperativeCron, log as imperativeLog, notify as imperativeNotify, requireRole as imperativeRequireRole, inState, inputEquals, inputRequired, instance, isActor, isActorConfig, isBuiltInConstraint, isConstraintDeclaration, isCreator, isOwner, isPlayerDebug, isSender, jsonpath, llm, loadExperienceWorkflow, logEvent, model, named, normalizeDefinition, not, notInState, notify$1 as notify, on, or, orchestration, patch, pipe, playerLog, prefetchData, refHasAnyRole, refHasRole, requireAuth, requireField, requireRole$1 as requireRole, resolveOrchestration, restrict, review, runtime, sendMessage, serverAction, setAuthResolver, setChannelTransport, setConfigContext, setExpressionLibraryResolver, setField, setFields, setInstalledModules, setModuleConfigDefaults, setMutationResolver, setPersistedModuleConfig, setPlayerDebug, setQueryResolver, setRealtimeQueryResolver, setRoleHierarchy, setServerActionResolver, setServerStateResolver, setViewResolver, spawn, spawnActor, sql, state, syncConfigDefaults, testModel, timeout, transition, updateDefinitionConfig, useAuth, useChannel, useCollection, useComputed, useComputedWithMeta, useDomainSubscription, useDuringAction, useExperienceState, useExpressionLibrary, useForm, useGeolocation, useLocalEngine, useMapView, useMiddleware, useModel, useModule, useModuleConfig, useModuleConfigWithMutation, useMutation, useNotification, useOnChange, useOnEnter, useOnEvent, useOnExit, useOnTransition, usePackage, useParams, usePlayer, usePlayerContext, usePlayerContextSafe, usePresence, useQuery, useRealtimeQuery, useRole, useRouteParams, useRouter, useRuntimeContext, useServerAction, useServerState, useStateField, useToast, useTransition, useView, useVisibility, useWhileIn, useWorkflow, useState as useWorkflowState, userAction, userChoice, validate, validateExperienceWorkflow, validateModel, visibleTo, when, withAuditLog, withAuditTrail, withAuth, withMetrics, withOwnership, withPagination, withRBAC, withRateLimit, withSearch, withSlug, withSoftDelete, withTags, withTimestamps, withValidation, withVersioning };