@doeixd/machine 0.0.6 → 0.0.7

package/dist/types/utils.d.ts

@@ -0,0 +1,208 @@
+/**
+ * @file A collection of high-level, type-safe utility functions for @doeixd/machine.
+ * @description These helpers provide ergonomic improvements for common patterns like
+ * state checking, event creation, debugging, and composing transitions.
+ */
+import { Machine, AsyncMachine, MaybePromise, Context, Event, Transitions, TransitionArgs } from './index';
+/**
+ * A type representing a Class Constructor, used for type guards.
+ */
+type ClassConstructor = new (...args: any[]) => any;
+/**
+ * A type-safe way to check if a machine is in a specific state, acting as a Type Guard.
+ * This is the preferred way to do state checking when using class-based machines.
+ *
+ * @template T - The class constructor type to check against.
+ * @param machine - The machine instance to check.
+ * @param machineClass - The class constructor representing the state.
+ * @returns {boolean} `true` if the machine is an instance of the class, narrowing its type.
+ *
+ * @example
+ * declare const machine: LoggedInMachine | LoggedOutMachine;
+ *
+ * if (isState(machine, LoggedInMachine)) {
+ *   // `machine` is now correctly typed as LoggedInMachine
+ *   machine.logout();
+ * }
+ */
+export declare function isState<T extends ClassConstructor>(machine: any, machineClass: T): machine is InstanceType<T>;
+/**
+ * A type-safe factory function for creating event objects for `runMachine`.
+ * This provides full autocompletion and type checking for event names and their arguments.
+ *
+ * @template M - The machine type the event belongs to.
+ * @template K - The specific event name (transition method name).
+ * @param type - The name of the event (e.g., "increment").
+ * @param args - The arguments for that event, correctly typed.
+ * @returns A type-safe event object ready to be passed to `dispatch`.
+ *
+ * @example
+ * // Given: type MyMachine = Machine<{...}> & { add: (n: number) => any }
+ * const event = createEvent<MyMachine, 'add'>('add', 5);
+ * // `event` is correctly typed as { type: "add"; args: [number] }
+ *
+ * await runner.dispatch(event);
+ */
+export declare function createEvent<M extends Machine<any>, K extends keyof Transitions<M> & string>(type: K, ...args: TransitionArgs<M, K>): Event<M>;
+/**
+ * Creates a new machine instance by shallowly merging a partial context into the
+ * current context, preserving all original transitions.
+ *
+ * @template M - The machine type.
+ * @param machine - The original machine instance.
+ * @param partialContext - An object with a subset of context properties to update.
+ * @returns A new machine instance of the same type with the merged context.
+ *
+ * @example
+ * const user = new User({ name: 'Alex', age: 30, status: 'active' });
+ * const updatedUser = mergeContext(user, { status: 'inactive' });
+ * // updatedUser.context is { name: 'Alex', age: 30, status: 'inactive' }
+ */
+export declare function mergeContext<M extends Machine<any>>(machine: M, partialContext: Partial<Context<M>>): M;
+/**
+ * Sequentially applies a series of transitions to a machine.
+ * This function correctly handles both synchronous and asynchronous transitions,
+ * always returning a Promise with the final machine state.
+ *
+ * @template M - The machine type, must be compatible with AsyncMachine.
+ * @param initialMachine - The starting machine state.
+ * @param transitions - An array of functions, each taking a machine and returning the next.
+ * @returns A `Promise` that resolves to the final machine state after all transitions complete.
+ *
+ * @example
+ * const finalState = await pipeTransitions(
+ *   new Counter({ count: 0 }),
+ *   (m) => m.increment(),        // sync
+ *   (m) => m.addAsync(5),        // async
+ *   (m) => m.increment()         // sync
+ * );
+ * // finalState.context.count will be 6
+ */
+export declare function pipeTransitions<M extends AsyncMachine<any>>(initialMachine: M, ...transitions: ((m: M) => MaybePromise<M>)[]): Promise<M>;
+/**
+ * A "tap" utility for logging a machine's context without interrupting a chain of operations.
+ * It prints the context to the console and returns the machine instance unchanged.
+ *
+ * @template M - The machine type.
+ * @param machine - The machine instance to log.
+ * @param label - An optional label to print before the context object.
+ * @returns The original, unmodified machine instance.
+ *
+ * @example
+ * import { logState as tap } from './utils';
+ *
+ * await pipeTransitions(
+ *   new Counter({ count: 0 }),
+ *   tap, // Logs: { count: 0 }
+ *   (m) => m.increment(),
+ *   (m) => tap(m, 'After increment:') // Logs: After increment: { count: 1 }
+ * );
+ */
+export declare function logState<M extends Machine<any>>(machine: M, label?: string): M;
+/**
+ * Calls a transition function with an explicit `this` context.
+ * Useful for invoking transition methods with proper context binding.
+ *
+ * @template C - The context type that the function expects as `this`.
+ * @template F - The function type with a `this` parameter.
+ * @template A - The argument types for the function.
+ * @param fn - The transition function to call.
+ * @param context - The context object to bind as `this`.
+ * @param args - Arguments to pass to the function.
+ * @returns The result of calling the function with the given context and arguments.
+ *
+ * @example
+ * type MyContext = { count: number };
+ * const increment = function(this: MyContext) { return this.count + 1; };
+ * const result = call(increment, { count: 5 }); // Returns 6
+ *
+ * // Particularly useful with machine transitions:
+ * import { call } from '@doeixd/machine/utils';
+ * const nextMachine = yield* step(call(m.increment, m.context));
+ */
+export declare function call<C, F extends (this: C, ...args: any[]) => any>(fn: F, context: C, ...args: Parameters<F> extends [any, ...infer Rest] ? Rest : never): ReturnType<F>;
+/**
+ * Binds all transition methods of a machine to its context automatically.
+ * Returns a Proxy that intercepts method calls and binds them to `machine.context`.
+ * This eliminates the need to use `.call(m.context, ...)` for every transition.
+ *
+ * Automatically recursively wraps returned machines, enabling seamless chaining
+ * in generator-based flows.
+ *
+ * @template M - The machine type with a `context` property and transition methods.
+ * @param machine - The machine instance to wrap.
+ * @returns A Proxy of the machine where all callable properties (transitions) are automatically bound to the machine's context.
+ *
+ * @example
+ * type CounterContext = { count: number };
+ * const counter = bindTransitions(createMachine({ count: 0 }, {
+ *   increment(this: CounterContext) { return createCounter(this.count + 1); }
+ * }));
+ *
+ * // Now you can call transitions directly without .call():
+ * const next = counter.increment(); // Works! This is automatically bound.
+ *
+ * // Particularly useful with generators:
+ * const result = run(function* (m) {
+ *   m = yield* step(m.increment());     // Clean syntax
+ *   m = yield* step(m.add(5));          // No .call() needed
+ *   return m;
+ * }, bindTransitions(counter));
+ *
+ * @remarks
+ * The Proxy preserves all original properties and methods. Non-callable properties
+ * are accessed directly from the machine. Callable properties are wrapped to bind
+ * them to `machine.context` before invocation. Returned machines are automatically
+ * re-wrapped to maintain binding across transition chains.
+ */
+export declare function bindTransitions<M extends {
+    context: any;
+}>(machine: M): M;
+/**
+ * A strongly-typed wrapper class for binding transitions to machine context.
+ * Unlike the Proxy-based `bindTransitions`, this class preserves full type safety
+ * and provides better IDE support through explicit property forwarding.
+ *
+ * @template M - The machine type with a `context` property and transition methods.
+ *
+ * @example
+ * type CounterContext = { count: number };
+ * const counter = createMachine({ count: 0 }, {
+ *   increment(this: CounterContext) { return createCounter(this.count + 1); }
+ * });
+ *
+ * const bound = new BoundMachine(counter);
+ *
+ * // All transitions are automatically bound to context
+ * const result = run(function* (m) {
+ *   m = yield* step(m.increment());
+ *   m = yield* step(m.add(5));
+ *   return m.context.count;
+ * }, bound);
+ *
+ * @remarks
+ * Advantages over Proxy-based `bindTransitions`:
+ * - Full type safety with TypeScript's type system
+ * - Returned machines are automatically re-wrapped
+ * - Better IDE autocompletion and hover information
+ * - No type casting needed
+ *
+ * Disadvantages:
+ * - Requires explicit instance creation: `new BoundMachine(m)` vs `bindTransitions(m)`
+ * - Not a transparent drop-in replacement for the original machine
+ */
+export declare class BoundMachine<M extends {
+    context: any;
+}> {
+    private readonly wrappedMachine;
+    [key: string | symbol]: any;
+    constructor(machine: M);
+    /**
+     * Access the underlying machine's context directly.
+     */
+    get context(): M extends {
+        context: infer C;
+    } ? C : never;
+}
+export {};
+//# sourceMappingURL=utils.d.ts.map

package/dist/types/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/utils.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EACL,OAAO,EACP,YAAY,EACZ,YAAY,EACZ,OAAO,EACP,KAAK,EACL,WAAW,EACX,cAAc,EAEf,MAAM,SAAS,CAAC;AAMjB;;GAEG;AACH,KAAK,gBAAgB,GAAG,KAAK,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,CAAC;AAEpD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,OAAO,CAAC,CAAC,SAAS,gBAAgB,EAChD,OAAO,EAAE,GAAG,EACZ,YAAY,EAAE,CAAC,GACd,OAAO,IAAI,YAAY,CAAC,CAAC,CAAC,CAE5B;AAOD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,WAAW,CACzB,CAAC,SAAS,OAAO,CAAC,GAAG,CAAC,EACtB,CAAC,SAAS,MAAM,WAAW,CAAC,CAAC,CAAC,GAAG,MAAM,EACvC,IAAI,EAAE,CAAC,EAAE,GAAG,IAAI,EAAE,cAAc,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,CAElD;AAOD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,YAAY,CAAC,CAAC,SAAS,OAAO,CAAC,GAAG,CAAC,EACjD,OAAO,EAAE,CAAC,EACV,cAAc,EAAE,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,GAClC,CAAC,CAEH;AAOD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAsB,eAAe,CAAC,CAAC,SAAS,YAAY,CAAC,GAAG,CAAC,EAC/D,cAAc,EAAE,CAAC,EACjB,GAAG,WAAW,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,KAAK,YAAY,CAAC,CAAC,CAAC,CAAC,EAAE,GAC5C,OAAO,CAAC,CAAC,CAAC,CAMZ;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,QAAQ,CAAC,CAAC,SAAS,OAAO,CAAC,GAAG,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,CAAC,CAO9E;AAMD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,IAAI,CAAC,CAAC,EAAE,CAAC,SAAS,CAAC,IAAI,EAAE,CAAC,EAAE,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,EAChE,EAAE,EAAE,CAAC,EACL,OAAO,EAAE,CAAC,EACV,GAAG,IAAI,EAAE,UAAU,CAAC,CAAC,CAAC,SAAS,CAAC,GAAG,EAAE,GAAG,MAAM,IAAI,CAAC,GAAG,IAAI,GAAG,KAAK,GACjE,UAAU,CAAC,CAAC,CAAC,CAEf;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,wBAAgB,eAAe,CAAC,CAAC,SAAS;IAAE,OAAO,EAAE,GAAG,CAAA;CAAE,EAAE,OAAO,EAAE,CAAC,GAAG,CAAC,CAqBzE;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,qBAAa,YAAY,CAAC,CAAC,SAAS;IAAE,OAAO,EAAE,GAAG,CAAA;CAAE;IAClD,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAI;IACnC,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,GAAG,CAAC;gBAEhB,OAAO,EAAE,CAAC;IA+BtB;;OAEG;IACH,IAAI,OAAO,IAAI,CAAC,SAAS;QAAE,OAAO,EAAE,MAAM,CAAC,CAAA;KAAE,GAAG,CAAC,GAAG,KAAK,CAExD;CACF"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@doeixd/machine",
-  "version": "0.0.6",
+  "version": "0.0.7",
   "files": [
     "dist",
     "src"

package/src/extract.ts

@@ -20,22 +20,57 @@ import { Project, Type, Node } from 'ts-morph';
 // SECTION: CONFIGURATION TYPES
 // =============================================================================
 
+/**
+ * Configuration for a parallel region
+ */
+export interface ParallelRegionConfig {
+  /** A unique name for this region (e.g., 'fontStyle') */
+  name: string;
+  /** The initial state class for this region */
+  initialState: string;
+  /** All reachable state classes within this region */
+  classes: string[];
+}
+
+/**
+ * Configuration for child states in a hierarchical machine
+ */
+export interface ChildStatesConfig {
+  /** The property in the parent's context that holds the child machine */
+  contextProperty: string;
+  /** An array of all possible child state class names */
+  classes: string[];
+  /** The initial child state */
+  initialState: string;
+}
+
 /**
  * Configuration for a single machine to extract
  */
 export interface MachineConfig {
   /** Path to the source file containing the machine */
   input: string;
-  /** Array of class names that represent states */
-  classes: string[];
   /** Output file path (optional, defaults to stdout) */
   output?: string;
   /** Top-level ID for the statechart */
   id: string;
-  /** Name of the class that represents the initial state */
-  initialState: string;
   /** Optional description of the machine */
   description?: string;
+
+  // EITHER `initialState` and `classes` for an FSM...
+  /** Array of class names that represent states (for simple FSM) */
+  classes?: string[];
+  /** Name of the class that represents the initial state (for simple FSM) */
+  initialState?: string;
+
+  // OR `parallel` for a parallel machine.
+  /** Configuration for parallel regions (mutually exclusive with initialState/classes) */
+  parallel?: {
+    regions: ParallelRegionConfig[];
+  };
+
+  /** Configuration for hierarchical/nested states */
+  children?: ChildStatesConfig;
 }
 
 /**
@@ -63,11 +98,16 @@ export interface ExtractionConfig {
  * plain JSON-compatible value. It's smart enough to resolve class constructor
  * types into their string names.
  *
+ * Note: This function is kept for future extensibility but is not currently used
+ * as the AST-based extraction approach (via extractFromCallExpression) is preferred.
+ *
  * @param type - The `ts-morph` Type object to serialize.
  * @param verbose - Enable debug logging
  * @returns A JSON-compatible value (string, number, object, array).
+ * @internal
  */
-function typeToJson(type: Type, verbose = false): any {
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+function _typeToJson(type: Type, verbose = false): any {
   // --- Terminal Types ---
   const symbol = type.getSymbol();
   if (symbol && symbol.getDeclarations().some(Node.isClassDeclaration)) {
@@ -83,7 +123,7 @@ function typeToJson(type: Type, verbose = false): any {
   // --- Recursive Types ---
   if (type.isArray()) {
     const elementType = type.getArrayElementTypeOrThrow();
-    return [typeToJson(elementType, verbose)];
+    return [_typeToJson(elementType, verbose)];
   }
 
   // --- Object Types ---
@@ -102,7 +142,7 @@ function typeToJson(type: Type, verbose = false): any {
       if (!declaration) continue;
 
       try {
-        obj[propName] = typeToJson(declaration.getType(), verbose);
+        obj[propName] = _typeToJson(declaration.getType(), verbose);
       } catch (e) {
         if (verbose) console.error(`      Warning: Failed to serialize property ${propName}:`, e);
         obj[propName] = 'unknown';
@@ -438,6 +478,41 @@ function analyzeStateNode(classSymbol: any, verbose = false): object {
 // SECTION: MAIN ORCHESTRATOR
 // =============================================================================
 
+/**
+ * Helper function to analyze a state node with optional nesting support
+ */
+function analyzeStateNodeWithNesting(
+  className: string,
+  classSymbol: any,
+  sourceFile: any,
+  childConfig: ChildStatesConfig | undefined,
+  verbose = false
+): any {
+  const stateNode = analyzeStateNode(classSymbol, verbose) as any;
+
+  // If this state has children, analyze them recursively
+  if (childConfig) {
+    if (verbose) {
+      console.error(`  👪 Analyzing children for state: ${className}`);
+    }
+    stateNode.initial = childConfig.initialState;
+    stateNode.states = {};
+
+    // Recursively analyze each child state
+    for (const childClassName of childConfig.classes) {
+      const childClassDeclaration = sourceFile.getClass(childClassName);
+      if (childClassDeclaration) {
+        const childSymbol = childClassDeclaration.getSymbolOrThrow();
+        stateNode.states[childClassName] = analyzeStateNode(childSymbol, verbose);
+      } else {
+        console.warn(`⚠️ Warning: Child class '${childClassName}' not found.`);
+      }
+    }
+  }
+
+  return stateNode;
+}
+
 /**
  * Extracts a single machine configuration to a statechart
  *
@@ -461,6 +536,56 @@ export function extractMachine(
     throw new Error(`Source file not found: ${config.input}`);
   }
 
+  // Handle parallel machine configuration
+  if (config.parallel) {
+    if (verbose) {
+      console.error(`  ⏹️ Parallel machine detected. Analyzing regions.`);
+    }
+
+    const parallelChart: any = {
+      id: config.id,
+      type: 'parallel',
+      states: {},
+    };
+
+    if (config.description) {
+      parallelChart.description = config.description;
+    }
+
+    for (const region of config.parallel.regions) {
+      if (verbose) {
+        console.error(`    📍 Analyzing region: ${region.name}`);
+      }
+
+      const regionStates: any = {};
+      for (const className of region.classes) {
+        const classDeclaration = sourceFile.getClass(className);
+        if (classDeclaration) {
+          const classSymbol = classDeclaration.getSymbolOrThrow();
+          regionStates[className] = analyzeStateNode(classSymbol, verbose);
+        } else {
+          console.warn(`⚠️ Warning: Class '${className}' not found for region '${region.name}'.`);
+        }
+      }
+
+      parallelChart.states[region.name] = {
+        initial: region.initialState,
+        states: regionStates,
+      };
+    }
+
+    if (verbose) {
+      console.error(`  ✅ Extracted ${config.parallel.regions.length} parallel regions`);
+    }
+
+    return parallelChart;
+  }
+
+  // Handle standard FSM configuration
+  if (!config.initialState || !config.classes) {
+    throw new Error(`Machine config for '${config.id}' must have either 'parallel' or 'initialState'/'classes'.`);
+  }
+
   const fullChart: any = {
     id: config.id,
     initial: config.initialState,
@@ -478,7 +603,17 @@ export function extractMachine(
       continue;
     }
     const classSymbol = classDeclaration.getSymbolOrThrow();
-    const stateNode = analyzeStateNode(classSymbol, verbose);
+
+    // Check if this is the initial state and has children configuration
+    const hasChildren = className === config.initialState && config.children;
+    const stateNode = analyzeStateNodeWithNesting(
+      className,
+      classSymbol,
+      sourceFile,
+      hasChildren ? config.children : undefined,
+      verbose
+    );
+
     fullChart.states[className] = stateNode;
   }
 
@@ -569,6 +704,43 @@ export function generateChart() {
   }
 }
 
+/**
+ * Example configuration demonstrating hierarchical and parallel machines.
+ * This is not used by default but serves as documentation.
+ */
+export const ADVANCED_CONFIG_EXAMPLES = {
+  hierarchical: {
+    input: 'examples/dashboardMachine.ts',
+    id: 'dashboard',
+    classes: ['DashboardMachine', 'LoggedOutMachine'],
+    initialState: 'DashboardMachine',
+    children: {
+      contextProperty: 'child',
+      initialState: 'ViewingChildMachine',
+      classes: ['ViewingChildMachine', 'EditingChildMachine'],
+    },
+  } as MachineConfig,
+
+  parallel: {
+    input: 'examples/editorMachine.ts',
+    id: 'editor',
+    parallel: {
+      regions: [
+        {
+          name: 'fontWeight',
+          initialState: 'NormalWeight',
+          classes: ['NormalWeight', 'BoldWeight'],
+        },
+        {
+          name: 'textDecoration',
+          initialState: 'NoDecoration',
+          classes: ['NoDecoration', 'UnderlineState'],
+        },
+      ],
+    },
+  } as MachineConfig,
+};
+
 // This allows the script to be executed directly from the command line.
 if (require.main === module) {
   generateChart();

package/src/generators.ts

@@ -26,7 +26,7 @@
  * ```
  */
 
-import { Machine } from './index';
+
 
 /**
  * Runs a generator-based state machine flow to completion.
@@ -117,9 +117,9 @@ import { Machine } from './index';
  * }, machine);
  * ```
  */
-export function run<C extends object, T>(
-  flow: (m: Machine<C>) => Generator<Machine<C>, T, Machine<C>>,
-  initial: Machine<C>
+export function run<C extends any = any, M extends { context: C } & Record<string, any> = { context: C }, T = any>(
+  flow: (m: M) => Generator<M, T, M>,
+  initial: M
 ): T {
   // Create the generator by calling the flow function with the initial machine
   const generator = flow(initial);
@@ -197,9 +197,9 @@ export function run<C extends object, T>(
  * }, machine);
  * ```
  */
-export function step<C extends object>(
-  m: Machine<C>
-): Generator<Machine<C>, Machine<C>, Machine<C>> {
+export function step<C extends any = any, M extends { context: C } & Record<string, any> = { context: C }>(
+  m: M
+): Generator<M, M, M> {
   // Create an immediately-invoked generator that:
   // 1. Yields the provided machine
   // 2. Receives a value back (the next state)
@@ -229,7 +229,7 @@ export function step<C extends object>(
  * }, counter);
  * ```
  */
-export function yieldMachine<C extends object>(m: Machine<C>): Machine<C> {
+export function yieldMachine<C extends any = any, M extends { context: C } & Record<string, any> = { context: C }>(m: M): M {
   return m;
 }
 
@@ -259,10 +259,10 @@ export function yieldMachine<C extends object>(m: Machine<C>): Machine<C> {
  * console.log(result.context.count); // 6
  * ```
  */
-export function runSequence<C extends object>(
-  initial: Machine<C>,
-  flows: Array<(m: Machine<C>) => Generator<Machine<C>, Machine<C>, Machine<C>>>
-): Machine<C> {
+export function runSequence<C extends any = any, M extends { context: C } & Record<string, any> = { context: C }>(
+  initial: M,
+  flows: Array<(m: M) => Generator<M, M, M>>
+): M {
   return flows.reduce((machine, flow) => {
     return run(flow, machine);
   }, initial);
@@ -295,9 +295,9 @@ export function runSequence<C extends object>(
  * }, counter);
  * ```
  */
-export function createFlow<C extends object>(
-  flow: (m: Machine<C>) => Generator<Machine<C>, Machine<C>, Machine<C>>
-): (m: Machine<C>) => Generator<Machine<C>, Machine<C>, Machine<C>> {
+export function createFlow<C extends any = any, M extends { context: C } & Record<string, any> = { context: C }>(
+  flow: (m: M) => Generator<M, M, M>
+): (m: M) => Generator<M, M, M> {
   return flow;
 }
 
@@ -328,10 +328,10 @@ export function createFlow<C extends object>(
  * // Final: 6
  * ```
  */
-export function runWithDebug<C extends object, T>(
-  flow: (m: Machine<C>) => Generator<Machine<C>, T, Machine<C>>,
-  initial: Machine<C>,
-  logger: (step: number, machine: Machine<C>) => void = (step, m) => {
+export function runWithDebug<C extends any = any, M extends { context: C } & Record<string, any> = { context: C }, T = any>(
+  flow: (m: M) => Generator<M, T, M>,
+  initial: M,
+  logger: (step: number, machine: M) => void = (step, m) => {
     console.log(`Step ${step}:`, m.context);
   }
 ): T {
@@ -380,9 +380,9 @@ export function runWithDebug<C extends object, T>(
  * }, asyncMachine);
  * ```
  */
-export async function runAsync<C extends object, T>(
-  flow: (m: Machine<C>) => AsyncGenerator<Machine<C>, T, Machine<C>>,
-  initial: Machine<C>
+export async function runAsync<C extends any = any, M extends { context: C } & Record<string, any> = { context: C }, T = any>(
+  flow: (m: M) => AsyncGenerator<M, T, M>,
+  initial: M
 ): Promise<T> {
   const generator = flow(initial);
   let current = initial;
@@ -413,9 +413,9 @@ export async function runAsync<C extends object, T>(
  * }, machine);
  * ```
  */
-export async function* stepAsync<C extends object>(
-  m: Machine<C>
-): AsyncGenerator<Machine<C>, Machine<C>, Machine<C>> {
+export async function* stepAsync<C extends any = any, M extends { context: C } & Record<string, any> = { context: C }>(
+  m: M
+): AsyncGenerator<M, M, M> {
   const received = yield m;
   return received;
 }