@doeixd/machine 0.0.13 → 0.0.17

package/dist/esm/development/index.js

@@ -243,1209 +243,1083 @@ function metadata(_meta, value) {
   return value;
 }
 
-// src/extract.ts
-import { Project, Node } from "ts-morph";
-function resolveClassName(node) {
-  if (Node.isIdentifier(node)) {
-    return node.getText();
-  }
-  if (Node.isTypeOfExpression(node)) {
-    return node.getExpression().getText();
-  }
-  return "unknown";
-}
-function parseObjectLiteral(obj) {
-  if (!Node.isObjectLiteralExpression(obj)) {
-    return {};
-  }
-  const result = {};
-  for (const prop of obj.getProperties()) {
-    if (Node.isPropertyAssignment(prop)) {
-      const name = prop.getName();
-      const init = prop.getInitializer();
-      if (init) {
-        if (Node.isStringLiteral(init)) {
-          result[name] = init.getLiteralValue();
-        } else if (Node.isNumericLiteral(init)) {
-          result[name] = init.getLiteralValue();
-        } else if (init.getText() === "true" || init.getText() === "false") {
-          result[name] = init.getText() === "true";
-        } else if (Node.isIdentifier(init)) {
-          result[name] = init.getText();
-        } else if (Node.isObjectLiteralExpression(init)) {
-          result[name] = parseObjectLiteral(init);
-        } else if (Node.isArrayLiteralExpression(init)) {
-          result[name] = init.getElements().map((el) => {
-            if (Node.isObjectLiteralExpression(el)) {
-              return parseObjectLiteral(el);
-            }
-            return el.getText();
-          });
-        }
+// src/multi.ts
+function createRunner(initialMachine, onChange) {
+  let currentMachine = initialMachine;
+  const setState = (newState) => {
+    currentMachine = newState;
+    onChange == null ? void 0 : onChange(newState);
+  };
+  const { context: _initialContext, ...originalTransitions } = initialMachine;
+  const actions = new Proxy({}, {
+    get(_target, prop) {
+      const transition = currentMachine[prop];
+      if (typeof transition !== "function") {
+        return void 0;
       }
+      return (...args) => {
+        const nextState = transition.apply(currentMachine.context, args);
+        const nextStateWithTransitions = Object.assign(
+          { context: nextState.context },
+          originalTransitions
+        );
+        setState(nextStateWithTransitions);
+        return nextStateWithTransitions;
+      };
     }
-  }
-  return result;
+  });
+  return {
+    get state() {
+      return currentMachine;
+    },
+    get context() {
+      return currentMachine.context;
+    },
+    actions,
+    setState
+  };
 }
-function parseInvokeService(obj) {
-  if (!Node.isObjectLiteralExpression(obj)) {
-    return {};
-  }
-  const service = {};
-  for (const prop of obj.getProperties()) {
-    if (Node.isPropertyAssignment(prop)) {
-      const name = prop.getName();
-      const init = prop.getInitializer();
-      if (!init) continue;
-      if (name === "onDone" || name === "onError") {
-        service[name] = resolveClassName(init);
-      } else if (Node.isStringLiteral(init)) {
-        service[name] = init.getLiteralValue();
-      } else if (Node.isIdentifier(init)) {
-        service[name] = init.getText();
+function createEnsemble(store, factories, getDiscriminant) {
+  const getCurrentMachine = () => {
+    const context = store.getContext();
+    const currentStateName = getDiscriminant(context);
+    const factory = factories[currentStateName];
+    if (!factory) {
+      throw new Error(
+        `[Ensemble] Invalid state: No factory found for state "${String(currentStateName)}".`
+      );
+    }
+    return factory(context);
+  };
+  const actions = new Proxy({}, {
+    get(_target, prop) {
+      const currentMachine = getCurrentMachine();
+      const action2 = currentMachine[prop];
+      if (typeof action2 !== "function") {
+        throw new Error(
+          `[Ensemble] Transition "${prop}" is not valid in the current state.`
+        );
       }
+      return (...args) => {
+        return action2.apply(currentMachine.context, args);
+      };
     }
-  }
-  return service;
+  });
+  return {
+    get context() {
+      return store.getContext();
+    },
+    get state() {
+      return getCurrentMachine();
+    },
+    actions
+  };
 }
-function extractFromCallExpression(call2, verbose = false) {
-  if (!Node.isCallExpression(call2)) {
-    return null;
-  }
-  const expression = call2.getExpression();
-  const fnName = Node.isIdentifier(expression) ? expression.getText() : null;
-  if (!fnName) {
-    return null;
-  }
-  const metadata2 = {};
-  const args = call2.getArguments();
-  switch (fnName) {
-    case "transitionTo":
-      if (args[0]) {
-        metadata2.target = resolveClassName(args[0]);
-      }
-      break;
-    case "describe":
-      if (args[0] && Node.isStringLiteral(args[0])) {
-        metadata2.description = args[0].getLiteralValue();
-      }
-      if (args[1] && Node.isCallExpression(args[1])) {
-        const nested = extractFromCallExpression(args[1], verbose);
-        if (nested) {
-          Object.assign(metadata2, nested);
-        }
-      }
-      break;
-    case "guarded":
-      if (args[0]) {
-        const guard2 = parseObjectLiteral(args[0]);
-        if (Object.keys(guard2).length > 0) {
-          metadata2.guards = [guard2];
-        }
-      }
-      if (args[1] && Node.isCallExpression(args[1])) {
-        const nested = extractFromCallExpression(args[1], verbose);
-        if (nested) {
-          Object.assign(metadata2, nested);
-        }
-      }
-      break;
-    case "invoke":
-      if (args[0]) {
-        const service = parseInvokeService(args[0]);
-        if (Object.keys(service).length > 0) {
-          metadata2.invoke = service;
-        }
-      }
-      break;
-    case "action":
-      if (args[0]) {
-        const actionMeta = parseObjectLiteral(args[0]);
-        if (Object.keys(actionMeta).length > 0) {
-          metadata2.actions = [actionMeta];
-        }
-      }
-      if (args[1] && Node.isCallExpression(args[1])) {
-        const nested = extractFromCallExpression(args[1], verbose);
-        if (nested) {
-          Object.assign(metadata2, nested);
-        }
-      }
-      break;
-    case "guard":
-      if (args[2]) {
-        const options = parseObjectLiteral(args[2]);
-        if (options.description) {
-          metadata2.description = options.description;
-        }
-      }
-      metadata2.guards = [{ name: "runtime_guard", description: metadata2.description || "Synchronous condition check" }];
-      if (args[1] && Node.isCallExpression(args[1])) {
-        const nested = extractFromCallExpression(args[1], verbose);
-        if (nested) {
-          Object.assign(metadata2, nested);
-        }
-      }
-      break;
-    case "guardAsync":
-      if (args[2]) {
-        const options = parseObjectLiteral(args[2]);
-        if (options.description) {
-          metadata2.description = options.description;
-        }
-      }
-      metadata2.guards = [{ name: "runtime_guard_async", description: metadata2.description || "Asynchronous condition check" }];
-      if (args[1] && Node.isCallExpression(args[1])) {
-        const nested = extractFromCallExpression(args[1], verbose);
-        if (nested) {
-          Object.assign(metadata2, nested);
-        }
-      }
-      break;
-    default:
-      return null;
-  }
-  return Object.keys(metadata2).length > 0 ? metadata2 : null;
+function createEnsembleFactory(store, getDiscriminant) {
+  return function withFactories(factories) {
+    return createEnsemble(store, factories, getDiscriminant);
+  };
 }
-function extractMetaFromMember(member, verbose = false) {
-  if (!Node.isPropertyDeclaration(member)) {
-    if (verbose) console.error(`      ⚠️ Not a property declaration`);
-    return null;
-  }
-  const initializer = member.getInitializer();
-  if (!initializer) {
-    if (verbose) console.error(`      ⚠️ No initializer`);
-    return null;
-  }
-  if (!Node.isCallExpression(initializer)) {
-    if (verbose) console.error(`      ⚠️ Initializer is not a call expression`);
-    return null;
+function runWithRunner(flow, initialMachine) {
+  const runner = createRunner(initialMachine);
+  const generator = flow(runner);
+  let result = generator.next();
+  while (!result.done) {
+    result = generator.next();
   }
-  const metadata2 = extractFromCallExpression(initializer, verbose);
-  if (metadata2 && verbose) {
-    console.error(`      ✅ Extracted metadata:`, JSON.stringify(metadata2, null, 2));
+  return result.value;
+}
+function runWithEnsemble(flow, ensemble) {
+  const generator = flow(ensemble);
+  let result = generator.next();
+  while (!result.done) {
+    result = generator.next();
   }
-  return metadata2;
+  return result.value;
 }
-function analyzeStateNode(classSymbol, verbose = false) {
-  const chartNode = { on: {} };
-  const classDeclaration = classSymbol.getDeclarations()[0];
-  if (!classDeclaration || !Node.isClassDeclaration(classDeclaration)) {
-    if (verbose) {
-      console.error(`⚠️ Warning: Could not get class declaration for ${classSymbol.getName()}`);
-    }
-    return chartNode;
+var MultiMachineBase = class {
+  /**
+   * @param store - The StateStore that will manage this machine's context.
+   */
+  constructor(store) {
+    this.store = store;
   }
-  const className = classSymbol.getName();
-  if (verbose) {
-    console.error(`  Analyzing state: ${className}`);
+  /**
+   * Read-only access to the current context from the external store.
+   * This getter always returns the latest context from the store.
+   *
+   * @protected
+   *
+   * @example
+   * const currentStatus = this.context.status;
+   * const currentData = this.context.data;
+   */
+  get context() {
+    return this.store.getContext();
   }
-  for (const member of classDeclaration.getInstanceMembers()) {
-    const memberName = member.getName();
-    if (verbose) {
-      console.error(`    Checking member: ${memberName}`);
-    }
-    const meta = extractMetaFromMember(member, verbose);
-    if (!meta) continue;
-    if (verbose) {
-      console.error(`    Found transition: ${memberName}`);
-    }
-    const { invoke: invoke2, actions, guards, ...onEntry } = meta;
-    if (invoke2) {
-      if (!chartNode.invoke) chartNode.invoke = [];
-      chartNode.invoke.push({
-        src: invoke2.src,
-        onDone: { target: invoke2.onDone },
-        onError: { target: invoke2.onError },
-        description: invoke2.description
-      });
-      if (verbose) {
-        console.error(`      → Invoke: ${invoke2.src}`);
-      }
-    }
-    if (onEntry.target) {
-      const transition = { target: onEntry.target };
-      if (onEntry.description) {
-        transition.description = onEntry.description;
+  /**
+   * Update the shared context in the external store.
+   * Call this method in your transition methods to update the state.
+   *
+   * @protected
+   * @param newContext - The new context object. Should typically be a shallow
+   *   copy with only the properties you're changing, merged with the current
+   *   context using spread operators.
+   *
+   * @example
+   * // In a transition method:
+   * this.setContext({ ...this.context, status: 'loading' });
+   *
+   * @example
+   * // Updating nested properties:
+   * this.setContext({
+   *   ...this.context,
+   *   user: { ...this.context.user, name: 'Alice' }
+   * });
+   */
+  setContext(newContext) {
+    this.store.setContext(newContext);
+  }
+};
+function createMultiMachine(MachineClass, store) {
+  const instance = new MachineClass(store);
+  return new Proxy({}, {
+    get(_target, prop) {
+      const context = store.getContext();
+      if (prop in context) {
+        return context[prop];
       }
-      if (guards) {
-        transition.cond = guards.map((g) => g.name).join(" && ");
-        if (verbose) {
-          console.error(`      → Guard: ${transition.cond}`);
-        }
+      const method = instance[prop];
+      if (typeof method === "function") {
+        return (...args) => {
+          return method.apply(instance, args);
+        };
       }
-      if (actions && actions.length > 0) {
-        transition.actions = actions.map((a) => a.name);
-        if (verbose) {
-          console.error(`      → Actions: ${transition.actions.join(", ")}`);
-        }
+      return void 0;
+    },
+    set(_target, prop, value) {
+      const context = store.getContext();
+      if (prop in context) {
+        const newContext = { ...context, [prop]: value };
+        store.setContext(newContext);
+        return true;
       }
-      chartNode.on[memberName] = transition;
-      if (verbose) {
-        console.error(`      → Target: ${onEntry.target}`);
+      return false;
+    },
+    has(_target, prop) {
+      const context = store.getContext();
+      return prop in context || typeof instance[prop] === "function";
+    },
+    ownKeys(_target) {
+      const context = store.getContext();
+      const contextKeys = Object.keys(context);
+      const methodKeys = Object.getOwnPropertyNames(
+        Object.getPrototypeOf(instance)
+      ).filter((key) => key !== "constructor" && typeof instance[key] === "function");
+      return Array.from(/* @__PURE__ */ new Set([...contextKeys, ...methodKeys]));
+    },
+    getOwnPropertyDescriptor(_target, prop) {
+      const context = store.getContext();
+      if (prop in context || typeof instance[prop] === "function") {
+        return {
+          value: void 0,
+          writable: true,
+          enumerable: true,
+          configurable: true
+        };
       }
+      return void 0;
     }
-  }
-  return chartNode;
+  });
 }
-function analyzeStateNodeWithNesting(className, classSymbol, sourceFile, childConfig, verbose = false) {
-  const stateNode = analyzeStateNode(classSymbol, verbose);
-  if (childConfig) {
-    if (verbose) {
-      console.error(`  👪 Analyzing children for state: ${className}`);
+function createMutableMachine(sharedContext, factories, getDiscriminant) {
+  const getCurrentMachine = () => {
+    const currentStateName = getDiscriminant(sharedContext);
+    const factory = factories[currentStateName];
+    if (!factory) {
+      throw new Error(
+        `[MutableMachine] Invalid state: No factory for state "${String(currentStateName)}".`
+      );
     }
-    stateNode.initial = childConfig.initialState;
-    stateNode.states = {};
-    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 factory(sharedContext);
+  };
+  return new Proxy(sharedContext, {
+    get(target, prop, _receiver) {
+      if (prop in target) {
+        return target[prop];
       }
+      const currentMachine = getCurrentMachine();
+      const transition = currentMachine[prop];
+      if (typeof transition === "function") {
+        return (...args) => {
+          const nextContext = transition.apply(currentMachine.context, args);
+          if (typeof nextContext !== "object" || nextContext === null) {
+            console.warn(`[MutableMachine] Transition "${String(prop)}" did not return a valid context object. State may be inconsistent.`);
+            return;
+          }
+          Object.keys(target).forEach((key) => delete target[key]);
+          Object.assign(target, nextContext);
+        };
+      }
+      return void 0;
+    },
+    set(target, prop, value, _receiver) {
+      target[prop] = value;
+      return true;
+    },
+    has(target, prop) {
+      const currentMachine = getCurrentMachine();
+      return prop in target || typeof currentMachine[prop] === "function";
     }
-  }
-  return stateNode;
+  });
 }
-function extractMachine(config, project, verbose = false) {
-  if (verbose) {
-    console.error(`
-🔍 Analyzing machine: ${config.id}`);
-    console.error(`  Source: ${config.input}`);
-  }
-  const sourceFile = project.getSourceFile(config.input);
-  if (!sourceFile) {
-    throw new Error(`Source file not found: ${config.input}`);
-  }
-  if (config.parallel) {
-    if (verbose) {
-      console.error(`  ⏹️ Parallel machine detected. Analyzing regions.`);
+
+// src/higher-order.ts
+function delegateToChild(actionName) {
+  return function(...args) {
+    const child = this.context.child;
+    if (typeof child[actionName] === "function") {
+      const newChildState = child[actionName](...args);
+      return setContext(this, { ...this.context, child: newChildState });
     }
-    const parallelChart = {
-      id: config.id,
-      type: "parallel",
-      states: {}
-    };
-    if (config.description) {
-      parallelChart.description = config.description;
+    return this;
+  };
+}
+function toggle(prop) {
+  return function() {
+    if (typeof this.context[prop] !== "boolean") {
+      console.warn(`[toggle primitive] Property '${String(prop)}' is not a boolean. Toggling may have unexpected results.`);
     }
-    for (const region of config.parallel.regions) {
-      if (verbose) {
-        console.error(`    📍 Analyzing region: ${region.name}`);
-      }
-      const regionStates = {};
-      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}'.`);
-        }
+    return setContext(this, {
+      ...this.context,
+      [prop]: !this.context[prop]
+    });
+  };
+}
+var IdleMachine = class extends MachineBase {
+  constructor(config) {
+    super({ status: "idle" });
+    this.config = config;
+    this.fetch = (params) => new LoadingMachine(this.config, params != null ? params : this.config.initialParams, 1);
+  }
+};
+var LoadingMachine = class extends MachineBase {
+  constructor(config, params, attempts) {
+    super({ status: "loading", abortController: new AbortController(), attempts });
+    this.config = config;
+    this.params = params;
+    this.succeed = (data) => {
+      var _a, _b;
+      (_b = (_a = this.config).onSuccess) == null ? void 0 : _b.call(_a, data);
+      return new SuccessMachine(this.config, { status: "success", data });
+    };
+    this.fail = (error) => {
+      var _a, _b, _c;
+      const maxRetries = (_a = this.config.maxRetries) != null ? _a : 3;
+      if (this.context.attempts < maxRetries) {
+        return new RetryingMachine(this.config, this.params, error, this.context.attempts);
       }
-      parallelChart.states[region.name] = {
-        initial: region.initialState,
-        states: regionStates
-      };
-    }
-    if (verbose) {
-      console.error(`  ✅ Extracted ${config.parallel.regions.length} parallel regions`);
-    }
-    return parallelChart;
+      (_c = (_b = this.config).onError) == null ? void 0 : _c.call(_b, error);
+      return new ErrorMachine(this.config, { status: "error", error });
+    };
+    this.cancel = () => {
+      this.context.abortController.abort();
+      return new CanceledMachine(this.config);
+    };
+    this.execute();
+  }
+  async execute() {
+  }
+};
+var RetryingMachine = class extends MachineBase {
+  constructor(config, params, error, attempts) {
+    super({ status: "retrying", error, attempts });
+    this.config = config;
+    this.params = params;
+    // This would be called after a delay.
+    this.retry = (params) => new LoadingMachine(this.config, params != null ? params : this.params, this.context.attempts + 1);
+  }
+};
+var SuccessMachine = class extends MachineBase {
+  constructor(config, context) {
+    super(context);
+    this.config = config;
+    this.refetch = (params) => new LoadingMachine(this.config, params != null ? params : this.config.initialParams, 1);
+  }
+};
+var ErrorMachine = class extends MachineBase {
+  constructor(config, context) {
+    super(context);
+    this.config = config;
+    this.retry = (params) => new LoadingMachine(this.config, params != null ? params : this.config.initialParams, 1);
+  }
+};
+var CanceledMachine = class extends MachineBase {
+  constructor(config) {
+    super({ status: "canceled" });
+    this.config = config;
+    this.refetch = (params) => new LoadingMachine(this.config, params != null ? params : this.config.initialParams, 1);
+  }
+};
+function createFetchMachine(config) {
+  return new IdleMachine(config);
+}
+function createParallelMachine(m1, m2) {
+  const combinedContext = { ...m1.context, ...m2.context };
+  const transitions1 = { ...m1 };
+  const transitions2 = { ...m2 };
+  delete transitions1.context;
+  delete transitions2.context;
+  const combinedTransitions = {};
+  for (const key in transitions1) {
+    const transitionFn = transitions1[key];
+    combinedTransitions[key] = (...args) => {
+      const nextM1 = transitionFn.apply(m1.context, args);
+      return createParallelMachine(nextM1, m2);
+    };
   }
-  if (!config.initialState || !config.classes) {
-    throw new Error(`Machine config for '${config.id}' must have either 'parallel' or 'initialState'/'classes'.`);
+  for (const key in transitions2) {
+    const transitionFn = transitions2[key];
+    combinedTransitions[key] = (...args) => {
+      const nextM2 = transitionFn.apply(m2.context, args);
+      return createParallelMachine(m1, nextM2);
+    };
   }
-  const fullChart = {
-    id: config.id,
-    initial: config.initialState,
-    states: {}
+  return {
+    context: combinedContext,
+    ...combinedTransitions
   };
-  if (config.description) {
-    fullChart.description = config.description;
-  }
-  for (const className of config.classes) {
-    const classDeclaration = sourceFile.getClass(className);
-    if (!classDeclaration) {
-      console.warn(`⚠️ Warning: Class '${className}' not found in '${config.input}'. Skipping.`);
-      continue;
-    }
-    const classSymbol = classDeclaration.getSymbolOrThrow();
-    const hasChildren = className === config.initialState && config.children;
-    const stateNode = analyzeStateNodeWithNesting(
-      className,
-      classSymbol,
-      sourceFile,
-      hasChildren ? config.children : void 0,
-      verbose
-    );
-    fullChart.states[className] = stateNode;
+}
+
+// src/extract.ts
+import { Project, Node } from "ts-morph";
+function resolveClassName(node) {
+  if (Node.isIdentifier(node)) {
+    return node.getText();
   }
-  if (verbose) {
-    console.error(`  ✅ Extracted ${config.classes.length} states`);
+  if (Node.isTypeOfExpression(node)) {
+    return node.getExpression().getText();
   }
-  return fullChart;
+  return "unknown";
 }
-function extractMachines(config) {
-  var _a;
-  const verbose = (_a = config.verbose) != null ? _a : false;
-  if (verbose) {
-    console.error(`
-📊 Starting statechart extraction`);
-    console.error(`  Machines to extract: ${config.machines.length}`);
+function parseObjectLiteral(obj) {
+  if (!Node.isObjectLiteralExpression(obj)) {
+    return {};
   }
-  const project = new Project();
-  project.addSourceFilesAtPaths("src/**/*.ts");
-  project.addSourceFilesAtPaths("examples/**/*.ts");
-  const results = [];
-  for (const machineConfig of config.machines) {
-    try {
-      const chart = extractMachine(machineConfig, project, verbose);
-      results.push(chart);
-    } catch (error) {
-      console.error(`❌ Error extracting machine '${machineConfig.id}':`, error);
-      if (!verbose) {
-        console.error(`   Run with --verbose for more details`);
+  const result = {};
+  for (const prop of obj.getProperties()) {
+    if (Node.isPropertyAssignment(prop)) {
+      const name = prop.getName();
+      const init = prop.getInitializer();
+      if (init) {
+        if (Node.isStringLiteral(init)) {
+          result[name] = init.getLiteralValue();
+        } else if (Node.isNumericLiteral(init)) {
+          result[name] = init.getLiteralValue();
+        } else if (init.getText() === "true" || init.getText() === "false") {
+          result[name] = init.getText() === "true";
+        } else if (Node.isIdentifier(init)) {
+          result[name] = init.getText();
+        } else if (Node.isObjectLiteralExpression(init)) {
+          result[name] = parseObjectLiteral(init);
+        } else if (Node.isArrayLiteralExpression(init)) {
+          result[name] = init.getElements().map((el) => {
+            if (Node.isObjectLiteralExpression(el)) {
+              return parseObjectLiteral(el);
+            }
+            return el.getText();
+          });
+        }
       }
     }
   }
-  if (verbose) {
-    console.error(`
-✅ Extraction complete: ${results.length}/${config.machines.length} machines extracted`);
-  }
-  return results;
+  return result;
 }
-function generateChart() {
-  const config = {
-    input: "examples/authMachine.ts",
-    classes: [
-      "LoggedOutMachine",
-      "LoggingInMachine",
-      "LoggedInMachine",
-      "SessionExpiredMachine",
-      "ErrorMachine"
-    ],
-    id: "auth",
-    initialState: "LoggedOutMachine",
-    description: "Authentication state machine"
-  };
-  console.error("🔍 Using legacy generateChart function");
-  console.error("⚠️ Consider using extractMachines() with a config file instead\n");
-  const project = new Project();
-  project.addSourceFilesAtPaths("src/**/*.ts");
-  project.addSourceFilesAtPaths("examples/**/*.ts");
-  try {
-    const chart = extractMachine(config, project, true);
-    console.log(JSON.stringify(chart, null, 2));
-  } catch (error) {
-    console.error(`❌ Error:`, error);
-    process.exit(1);
+function parseInvokeService(obj) {
+  if (!Node.isObjectLiteralExpression(obj)) {
+    return {};
   }
-}
-var ADVANCED_CONFIG_EXAMPLES = {
-  hierarchical: {
-    input: "examples/dashboardMachine.ts",
-    id: "dashboard",
-    classes: ["DashboardMachine", "LoggedOutMachine"],
-    initialState: "DashboardMachine",
-    children: {
-      contextProperty: "child",
-      initialState: "ViewingChildMachine",
-      classes: ["ViewingChildMachine", "EditingChildMachine"]
-    }
-  },
-  parallel: {
-    input: "examples/editorMachine.ts",
-    id: "editor",
-    parallel: {
-      regions: [
-        {
-          name: "fontWeight",
-          initialState: "NormalWeight",
-          classes: ["NormalWeight", "BoldWeight"]
-        },
-        {
-          name: "textDecoration",
-          initialState: "NoDecoration",
-          classes: ["NoDecoration", "UnderlineState"]
-        }
-      ]
+  const service = {};
+  for (const prop of obj.getProperties()) {
+    if (Node.isPropertyAssignment(prop)) {
+      const name = prop.getName();
+      const init = prop.getInitializer();
+      if (!init) continue;
+      if (name === "onDone" || name === "onError") {
+        service[name] = resolveClassName(init);
+      } else if (Node.isStringLiteral(init)) {
+        service[name] = init.getLiteralValue();
+      } else if (Node.isIdentifier(init)) {
+        service[name] = init.getText();
+      }
     }
   }
-};
-if (__require.main === module) {
-  generateChart();
+  return service;
 }
-
-// src/runtime-extract.ts
-function extractFunctionMetadata(fn) {
-  if (typeof fn !== "function") {
+function extractFromCallExpression(call2, verbose = false) {
+  if (!Node.isCallExpression(call2)) {
     return null;
   }
-  const meta = fn[RUNTIME_META];
-  return meta || null;
-}
-function extractStateNode(stateInstance) {
-  const stateNode = { on: {} };
-  const invoke2 = [];
-  for (const key in stateInstance) {
-    const value = stateInstance[key];
-    if (typeof value !== "function") {
-      continue;
-    }
-    const meta = extractFunctionMetadata(value);
-    if (!meta) {
-      continue;
-    }
-    if (meta.invoke) {
-      invoke2.push({
-        src: meta.invoke.src,
-        onDone: { target: meta.invoke.onDone },
-        onError: { target: meta.invoke.onError },
-        description: meta.invoke.description
-      });
-    }
-    if (meta.target) {
-      const transition = { target: meta.target };
-      if (meta.description) {
-        transition.description = meta.description;
+  const expression = call2.getExpression();
+  const fnName = Node.isIdentifier(expression) ? expression.getText() : null;
+  if (!fnName) {
+    return null;
+  }
+  const metadata2 = {};
+  const args = call2.getArguments();
+  switch (fnName) {
+    case "transitionTo":
+      if (args[0]) {
+        metadata2.target = resolveClassName(args[0]);
+      }
+      break;
+    case "describe":
+      if (args[0] && Node.isStringLiteral(args[0])) {
+        metadata2.description = args[0].getLiteralValue();
+      }
+      if (args[1] && Node.isCallExpression(args[1])) {
+        const nested = extractFromCallExpression(args[1], verbose);
+        if (nested) {
+          Object.assign(metadata2, nested);
+        }
+      }
+      break;
+    case "guarded":
+      if (args[0]) {
+        const guard2 = parseObjectLiteral(args[0]);
+        if (Object.keys(guard2).length > 0) {
+          metadata2.guards = [guard2];
+        }
+      }
+      if (args[1] && Node.isCallExpression(args[1])) {
+        const nested = extractFromCallExpression(args[1], verbose);
+        if (nested) {
+          Object.assign(metadata2, nested);
+        }
+      }
+      break;
+    case "invoke":
+      if (args[0]) {
+        const service = parseInvokeService(args[0]);
+        if (Object.keys(service).length > 0) {
+          metadata2.invoke = service;
+        }
+      }
+      break;
+    case "action":
+      if (args[0]) {
+        const actionMeta = parseObjectLiteral(args[0]);
+        if (Object.keys(actionMeta).length > 0) {
+          metadata2.actions = [actionMeta];
+        }
+      }
+      if (args[1] && Node.isCallExpression(args[1])) {
+        const nested = extractFromCallExpression(args[1], verbose);
+        if (nested) {
+          Object.assign(metadata2, nested);
+        }
+      }
+      break;
+    case "guard":
+      if (args[2]) {
+        const options = parseObjectLiteral(args[2]);
+        if (options.description) {
+          metadata2.description = options.description;
+        }
       }
-      if (meta.guards && meta.guards.length > 0) {
-        transition.cond = meta.guards.map((g) => g.name).join(" && ");
+      metadata2.guards = [{ name: "runtime_guard", description: metadata2.description || "Synchronous condition check" }];
+      if (args[1] && Node.isCallExpression(args[1])) {
+        const nested = extractFromCallExpression(args[1], verbose);
+        if (nested) {
+          Object.assign(metadata2, nested);
+        }
       }
-      if (meta.actions && meta.actions.length > 0) {
-        transition.actions = meta.actions.map((a) => a.name);
+      break;
+    case "guardAsync":
+      if (args[2]) {
+        const options = parseObjectLiteral(args[2]);
+        if (options.description) {
+          metadata2.description = options.description;
+        }
       }
-      stateNode.on[key] = transition;
-    } else if (meta.guards && meta.guards.length > 0) {
-      const transition = {
-        target: "GuardedTransition",
-        // Placeholder - actual target determined at runtime
-        cond: meta.guards.map((g) => g.name).join(" && ")
-      };
-      if (meta.description) {
-        transition.description = meta.description;
+      metadata2.guards = [{ name: "runtime_guard_async", description: metadata2.description || "Asynchronous condition check" }];
+      if (args[1] && Node.isCallExpression(args[1])) {
+        const nested = extractFromCallExpression(args[1], verbose);
+        if (nested) {
+          Object.assign(metadata2, nested);
+        }
       }
-      stateNode.on[key] = transition;
-    }
-  }
-  if (invoke2.length > 0) {
-    stateNode.invoke = invoke2;
+      break;
+    default:
+      return null;
   }
-  return stateNode;
+  return Object.keys(metadata2).length > 0 ? metadata2 : null;
 }
-function generateStatechart(states, config) {
-  const chart = {
-    id: config.id,
-    initial: config.initial,
-    states: {}
-  };
-  if (config.description) {
-    chart.description = config.description;
+function extractMetaFromMember(member, verbose = false) {
+  if (!Node.isPropertyDeclaration(member)) {
+    if (verbose) console.error(`      ⚠️ Not a property declaration`);
+    return null;
   }
-  for (const [stateName, stateInstance] of Object.entries(states)) {
-    chart.states[stateName] = extractStateNode(stateInstance);
+  const initializer = member.getInitializer();
+  if (!initializer) {
+    if (verbose) console.error(`      ⚠️ No initializer`);
+    return null;
   }
-  return chart;
-}
-function extractFromInstance(machineInstance, config) {
-  const stateName = config.stateName || machineInstance.constructor.name || "State";
-  return {
-    id: config.id,
-    initial: stateName,
-    states: {
-      [stateName]: extractStateNode(machineInstance)
-    }
-  };
-}
-
-// src/multi.ts
-function createRunner(initialMachine, onChange) {
-  let currentMachine = initialMachine;
-  const setState = (newState) => {
-    currentMachine = newState;
-    onChange == null ? void 0 : onChange(newState);
-  };
-  const { context: _initialContext, ...originalTransitions } = initialMachine;
-  const actions = new Proxy({}, {
-    get(_target, prop) {
-      const transition = currentMachine[prop];
-      if (typeof transition !== "function") {
-        return void 0;
-      }
-      return (...args) => {
-        const nextState = transition.apply(currentMachine.context, args);
-        const nextStateWithTransitions = Object.assign(
-          { context: nextState.context },
-          originalTransitions
-        );
-        setState(nextStateWithTransitions);
-        return nextStateWithTransitions;
-      };
-    }
-  });
-  return {
-    get state() {
-      return currentMachine;
-    },
-    get context() {
-      return currentMachine.context;
-    },
-    actions,
-    setState
-  };
-}
-function createEnsemble(store, factories, getDiscriminant) {
-  const getCurrentMachine = () => {
-    const context = store.getContext();
-    const currentStateName = getDiscriminant(context);
-    const factory = factories[currentStateName];
-    if (!factory) {
-      throw new Error(
-        `[Ensemble] Invalid state: No factory found for state "${String(currentStateName)}".`
-      );
-    }
-    return factory(context);
-  };
-  const actions = new Proxy({}, {
-    get(_target, prop) {
-      const currentMachine = getCurrentMachine();
-      const action2 = currentMachine[prop];
-      if (typeof action2 !== "function") {
-        throw new Error(
-          `[Ensemble] Transition "${prop}" is not valid in the current state.`
-        );
-      }
-      return (...args) => {
-        return action2.apply(currentMachine.context, args);
-      };
-    }
-  });
-  return {
-    get context() {
-      return store.getContext();
-    },
-    get state() {
-      return getCurrentMachine();
-    },
-    actions
-  };
-}
-function createEnsembleFactory(store, getDiscriminant) {
-  return function withFactories(factories) {
-    return createEnsemble(store, factories, getDiscriminant);
-  };
-}
-function runWithRunner(flow, initialMachine) {
-  const runner = createRunner(initialMachine);
-  const generator = flow(runner);
-  let result = generator.next();
-  while (!result.done) {
-    result = generator.next();
+  if (!Node.isCallExpression(initializer)) {
+    if (verbose) console.error(`      ⚠️ Initializer is not a call expression`);
+    return null;
   }
-  return result.value;
-}
-function runWithEnsemble(flow, ensemble) {
-  const generator = flow(ensemble);
-  let result = generator.next();
-  while (!result.done) {
-    result = generator.next();
+  const metadata2 = extractFromCallExpression(initializer, verbose);
+  if (metadata2 && verbose) {
+    console.error(`      ✅ Extracted metadata:`, JSON.stringify(metadata2, null, 2));
   }
-  return result.value;
+  return metadata2;
 }
-var MultiMachineBase = class {
-  /**
-   * @param store - The StateStore that will manage this machine's context.
-   */
-  constructor(store) {
-    this.store = store;
-  }
-  /**
-   * Read-only access to the current context from the external store.
-   * This getter always returns the latest context from the store.
-   *
-   * @protected
-   *
-   * @example
-   * const currentStatus = this.context.status;
-   * const currentData = this.context.data;
-   */
-  get context() {
-    return this.store.getContext();
+function analyzeStateNode(classSymbol, verbose = false) {
+  const chartNode = { on: {} };
+  const classDeclaration = classSymbol.getDeclarations()[0];
+  if (!classDeclaration || !Node.isClassDeclaration(classDeclaration)) {
+    if (verbose) {
+      console.error(`⚠️ Warning: Could not get class declaration for ${classSymbol.getName()}`);
+    }
+    return chartNode;
   }
-  /**
-   * Update the shared context in the external store.
-   * Call this method in your transition methods to update the state.
-   *
-   * @protected
-   * @param newContext - The new context object. Should typically be a shallow
-   *   copy with only the properties you're changing, merged with the current
-   *   context using spread operators.
-   *
-   * @example
-   * // In a transition method:
-   * this.setContext({ ...this.context, status: 'loading' });
-   *
-   * @example
-   * // Updating nested properties:
-   * this.setContext({
-   *   ...this.context,
-   *   user: { ...this.context.user, name: 'Alice' }
-   * });
-   */
-  setContext(newContext) {
-    this.store.setContext(newContext);
+  const className = classSymbol.getName();
+  if (verbose) {
+    console.error(`  Analyzing state: ${className}`);
   }
-};
-function createMultiMachine(MachineClass, store) {
-  const instance = new MachineClass(store);
-  return new Proxy({}, {
-    get(_target, prop) {
-      const context = store.getContext();
-      if (prop in context) {
-        return context[prop];
-      }
-      const method = instance[prop];
-      if (typeof method === "function") {
-        return (...args) => {
-          return method.apply(instance, args);
-        };
-      }
-      return void 0;
-    },
-    set(_target, prop, value) {
-      const context = store.getContext();
-      if (prop in context) {
-        const newContext = { ...context, [prop]: value };
-        store.setContext(newContext);
-        return true;
-      }
-      return false;
-    },
-    has(_target, prop) {
-      const context = store.getContext();
-      return prop in context || typeof instance[prop] === "function";
-    },
-    ownKeys(_target) {
-      const context = store.getContext();
-      const contextKeys = Object.keys(context);
-      const methodKeys = Object.getOwnPropertyNames(
-        Object.getPrototypeOf(instance)
-      ).filter((key) => key !== "constructor" && typeof instance[key] === "function");
-      return Array.from(/* @__PURE__ */ new Set([...contextKeys, ...methodKeys]));
-    },
-    getOwnPropertyDescriptor(_target, prop) {
-      const context = store.getContext();
-      if (prop in context || typeof instance[prop] === "function") {
-        return {
-          value: void 0,
-          writable: true,
-          enumerable: true,
-          configurable: true
-        };
+  for (const member of classDeclaration.getInstanceMembers()) {
+    const memberName = member.getName();
+    if (verbose) {
+      console.error(`    Checking member: ${memberName}`);
+    }
+    const meta = extractMetaFromMember(member, verbose);
+    if (!meta) continue;
+    if (verbose) {
+      console.error(`    Found transition: ${memberName}`);
+    }
+    const { invoke: invoke2, actions, guards, ...onEntry } = meta;
+    if (invoke2) {
+      if (!chartNode.invoke) chartNode.invoke = [];
+      chartNode.invoke.push({
+        src: invoke2.src,
+        onDone: { target: invoke2.onDone },
+        onError: { target: invoke2.onError },
+        description: invoke2.description
+      });
+      if (verbose) {
+        console.error(`      → Invoke: ${invoke2.src}`);
       }
-      return void 0;
-    }
-  });
-}
-function createMutableMachine(sharedContext, factories, getDiscriminant) {
-  const getCurrentMachine = () => {
-    const currentStateName = getDiscriminant(sharedContext);
-    const factory = factories[currentStateName];
-    if (!factory) {
-      throw new Error(
-        `[MutableMachine] Invalid state: No factory for state "${String(currentStateName)}".`
-      );
     }
-    return factory(sharedContext);
-  };
-  return new Proxy(sharedContext, {
-    get(target, prop, _receiver) {
-      if (prop in target) {
-        return target[prop];
+    if (onEntry.target) {
+      const transition = { target: onEntry.target };
+      if (onEntry.description) {
+        transition.description = onEntry.description;
       }
-      const currentMachine = getCurrentMachine();
-      const transition = currentMachine[prop];
-      if (typeof transition === "function") {
-        return (...args) => {
-          const nextContext = transition.apply(currentMachine.context, args);
-          if (typeof nextContext !== "object" || nextContext === null) {
-            console.warn(`[MutableMachine] Transition "${String(prop)}" did not return a valid context object. State may be inconsistent.`);
-            return;
-          }
-          Object.keys(target).forEach((key) => delete target[key]);
-          Object.assign(target, nextContext);
-        };
+      if (guards) {
+        transition.cond = guards.map((g) => g.name).join(" && ");
+        if (verbose) {
+          console.error(`      → Guard: ${transition.cond}`);
+        }
+      }
+      if (actions && actions.length > 0) {
+        transition.actions = actions.map((a) => a.name);
+        if (verbose) {
+          console.error(`      → Actions: ${transition.actions.join(", ")}`);
+        }
+      }
+      chartNode.on[memberName] = transition;
+      if (verbose) {
+        console.error(`      → Target: ${onEntry.target}`);
       }
-      return void 0;
-    },
-    set(target, prop, value, _receiver) {
-      target[prop] = value;
-      return true;
-    },
-    has(target, prop) {
-      const currentMachine = getCurrentMachine();
-      return prop in target || typeof currentMachine[prop] === "function";
     }
-  });
+  }
+  return chartNode;
 }
-
-// src/higher-order.ts
-function delegateToChild(actionName) {
-  return function(...args) {
-    const child = this.context.child;
-    if (typeof child[actionName] === "function") {
-      const newChildState = child[actionName](...args);
-      return setContext(this, { ...this.context, child: newChildState });
+function analyzeStateNodeWithNesting(className, classSymbol, sourceFile, childConfig, verbose = false) {
+  const stateNode = analyzeStateNode(classSymbol, verbose);
+  if (childConfig) {
+    if (verbose) {
+      console.error(`  👪 Analyzing children for state: ${className}`);
     }
-    return this;
-  };
-}
-function toggle(prop) {
-  return function() {
-    if (typeof this.context[prop] !== "boolean") {
-      console.warn(`[toggle primitive] Property '${String(prop)}' is not a boolean. Toggling may have unexpected results.`);
+    stateNode.initial = childConfig.initialState;
+    stateNode.states = {};
+    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 setContext(this, {
-      ...this.context,
-      [prop]: !this.context[prop]
-    });
-  };
+  }
+  return stateNode;
 }
-var IdleMachine = class extends MachineBase {
-  constructor(config) {
-    super({ status: "idle" });
-    this.config = config;
-    this.fetch = (params) => new LoadingMachine(this.config, params != null ? params : this.config.initialParams, 1);
+function extractMachine(config, project, verbose = false) {
+  if (verbose) {
+    console.error(`
+🔍 Analyzing machine: ${config.id}`);
+    console.error(`  Source: ${config.input}`);
   }
-};
-var LoadingMachine = class extends MachineBase {
-  constructor(config, params, attempts) {
-    super({ status: "loading", abortController: new AbortController(), attempts });
-    this.config = config;
-    this.params = params;
-    this.succeed = (data) => {
-      var _a, _b;
-      (_b = (_a = this.config).onSuccess) == null ? void 0 : _b.call(_a, data);
-      return new SuccessMachine(this.config, { status: "success", data });
+  const sourceFile = project.getSourceFile(config.input);
+  if (!sourceFile) {
+    throw new Error(`Source file not found: ${config.input}`);
+  }
+  if (config.parallel) {
+    if (verbose) {
+      console.error(`  ⏹️ Parallel machine detected. Analyzing regions.`);
+    }
+    const parallelChart = {
+      id: config.id,
+      type: "parallel",
+      states: {}
     };
-    this.fail = (error) => {
-      var _a, _b, _c;
-      const maxRetries = (_a = this.config.maxRetries) != null ? _a : 3;
-      if (this.context.attempts < maxRetries) {
-        return new RetryingMachine(this.config, this.params, error, this.context.attempts);
+    if (config.description) {
+      parallelChart.description = config.description;
+    }
+    for (const region of config.parallel.regions) {
+      if (verbose) {
+        console.error(`    📍 Analyzing region: ${region.name}`);
       }
-      (_c = (_b = this.config).onError) == null ? void 0 : _c.call(_b, error);
-      return new ErrorMachine(this.config, { status: "error", error });
-    };
-    this.cancel = () => {
-      this.context.abortController.abort();
-      return new CanceledMachine(this.config);
-    };
-    this.execute();
+      const regionStates = {};
+      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;
   }
-  async execute() {
+  if (!config.initialState || !config.classes) {
+    throw new Error(`Machine config for '${config.id}' must have either 'parallel' or 'initialState'/'classes'.`);
   }
-};
-var RetryingMachine = class extends MachineBase {
-  constructor(config, params, error, attempts) {
-    super({ status: "retrying", error, attempts });
-    this.config = config;
-    this.params = params;
-    // This would be called after a delay.
-    this.retry = (params) => new LoadingMachine(this.config, params != null ? params : this.params, this.context.attempts + 1);
+  const fullChart = {
+    id: config.id,
+    initial: config.initialState,
+    states: {}
+  };
+  if (config.description) {
+    fullChart.description = config.description;
   }
-};
-var SuccessMachine = class extends MachineBase {
-  constructor(config, context) {
-    super(context);
-    this.config = config;
-    this.refetch = (params) => new LoadingMachine(this.config, params != null ? params : this.config.initialParams, 1);
+  for (const className of config.classes) {
+    const classDeclaration = sourceFile.getClass(className);
+    if (!classDeclaration) {
+      console.warn(`⚠️ Warning: Class '${className}' not found in '${config.input}'. Skipping.`);
+      continue;
+    }
+    const classSymbol = classDeclaration.getSymbolOrThrow();
+    const hasChildren = className === config.initialState && config.children;
+    const stateNode = analyzeStateNodeWithNesting(
+      className,
+      classSymbol,
+      sourceFile,
+      hasChildren ? config.children : void 0,
+      verbose
+    );
+    fullChart.states[className] = stateNode;
   }
-};
-var ErrorMachine = class extends MachineBase {
-  constructor(config, context) {
-    super(context);
-    this.config = config;
-    this.retry = (params) => new LoadingMachine(this.config, params != null ? params : this.config.initialParams, 1);
+  if (verbose) {
+    console.error(`  ✅ Extracted ${config.classes.length} states`);
   }
-};
-var CanceledMachine = class extends MachineBase {
-  constructor(config) {
-    super({ status: "canceled" });
-    this.config = config;
-    this.refetch = (params) => new LoadingMachine(this.config, params != null ? params : this.config.initialParams, 1);
+  return fullChart;
+}
+function extractMachines(config) {
+  var _a;
+  const verbose = (_a = config.verbose) != null ? _a : false;
+  if (verbose) {
+    console.error(`
+📊 Starting statechart extraction`);
+    console.error(`  Machines to extract: ${config.machines.length}`);
+  }
+  const project = new Project();
+  project.addSourceFilesAtPaths("src/**/*.ts");
+  project.addSourceFilesAtPaths("examples/**/*.ts");
+  const results = [];
+  for (const machineConfig of config.machines) {
+    try {
+      const chart = extractMachine(machineConfig, project, verbose);
+      results.push(chart);
+    } catch (error) {
+      console.error(`❌ Error extracting machine '${machineConfig.id}':`, error);
+      if (!verbose) {
+        console.error(`   Run with --verbose for more details`);
+      }
+    }
+  }
+  if (verbose) {
+    console.error(`
+✅ Extraction complete: ${results.length}/${config.machines.length} machines extracted`);
   }
-};
-function createFetchMachine(config) {
-  return new IdleMachine(config);
+  return results;
 }
-function createParallelMachine(m1, m2) {
-  const combinedContext = { ...m1.context, ...m2.context };
-  const transitions1 = { ...m1 };
-  const transitions2 = { ...m2 };
-  delete transitions1.context;
-  delete transitions2.context;
-  const combinedTransitions = {};
-  for (const key in transitions1) {
-    const transitionFn = transitions1[key];
-    combinedTransitions[key] = (...args) => {
-      const nextM1 = transitionFn.apply(m1.context, args);
-      return createParallelMachine(nextM1, m2);
-    };
+function generateChart() {
+  const config = {
+    input: "examples/authMachine.ts",
+    classes: [
+      "LoggedOutMachine",
+      "LoggingInMachine",
+      "LoggedInMachine",
+      "SessionExpiredMachine",
+      "ErrorMachine"
+    ],
+    id: "auth",
+    initialState: "LoggedOutMachine",
+    description: "Authentication state machine"
+  };
+  console.error("🔍 Using legacy generateChart function");
+  console.error("⚠️ Consider using extractMachines() with a config file instead\n");
+  const project = new Project();
+  project.addSourceFilesAtPaths("src/**/*.ts");
+  project.addSourceFilesAtPaths("examples/**/*.ts");
+  try {
+    const chart = extractMachine(config, project, true);
+    console.log(JSON.stringify(chart, null, 2));
+  } catch (error) {
+    console.error(`❌ Error:`, error);
+    process.exit(1);
   }
-  for (const key in transitions2) {
-    const transitionFn = transitions2[key];
-    combinedTransitions[key] = (...args) => {
-      const nextM2 = transitionFn.apply(m2.context, args);
-      return createParallelMachine(m1, nextM2);
-    };
+}
+var ADVANCED_CONFIG_EXAMPLES = {
+  hierarchical: {
+    input: "examples/dashboardMachine.ts",
+    id: "dashboard",
+    classes: ["DashboardMachine", "LoggedOutMachine"],
+    initialState: "DashboardMachine",
+    children: {
+      contextProperty: "child",
+      initialState: "ViewingChildMachine",
+      classes: ["ViewingChildMachine", "EditingChildMachine"]
+    }
+  },
+  parallel: {
+    input: "examples/editorMachine.ts",
+    id: "editor",
+    parallel: {
+      regions: [
+        {
+          name: "fontWeight",
+          initialState: "NormalWeight",
+          classes: ["NormalWeight", "BoldWeight"]
+        },
+        {
+          name: "textDecoration",
+          initialState: "NoDecoration",
+          classes: ["NoDecoration", "UnderlineState"]
+        }
+      ]
+    }
   }
-  return {
-    context: combinedContext,
-    ...combinedTransitions
-  };
+};
+if (__require.main === module) {
+  generateChart();
 }
 
-// src/middleware.ts
+// src/middleware/core.ts
 var CANCEL = Symbol("CANCEL");
 function createMiddleware(machine, hooks, options = {}) {
-  const { mode = "auto", exclude = ["context"] } = options;
-  const wrapped = {};
+  const { continueOnError = false, logErrors = true, onError } = options;
+  const wrappedMachine = { ...machine };
   for (const prop in machine) {
     if (!Object.prototype.hasOwnProperty.call(machine, prop)) continue;
-    const value = machine[prop];
-    if (prop === "context") {
-      wrapped.context = value;
-      continue;
-    }
-    if (exclude.includes(prop)) {
-      wrapped[prop] = value;
-      continue;
+    if (prop !== "context" && typeof machine[prop] !== "function") {
+      wrappedMachine[prop] = machine[prop];
     }
-    if (typeof value !== "function" || prop.startsWith("_")) {
-      wrapped[prop] = value;
-      continue;
-    }
-    wrapped[prop] = createTransitionWrapper(
-      prop,
-      value,
-      machine,
-      hooks,
-      mode
-    );
   }
-  return wrapped;
-}
-function createTransitionWrapper(transitionName, originalFn, machine, hooks, mode) {
-  return function wrappedTransition(...args) {
-    const context = machine.context;
-    const middlewareCtx = {
-      transitionName,
-      context,
-      args
-    };
-    const executeSyncTransition = () => {
-      try {
-        if (hooks.before) {
-          const beforeResult = hooks.before(middlewareCtx);
-          if (beforeResult === CANCEL) {
-            return machine;
-          }
-          if (beforeResult instanceof Promise) {
-            throw new Error(
-              `Middleware mode is 'sync' but before hook returned Promise for transition: ${transitionName}`
-            );
-          }
-        }
-        const result = originalFn.call(this, ...args);
-        if (result instanceof Promise) {
-          return handleAsyncResult(result, context);
-        }
-        if (hooks.after) {
-          const middlewareResult = {
-            transitionName,
-            prevContext: context,
-            nextContext: result.context,
-            args
-          };
-          const afterResult = hooks.after(middlewareResult);
-          if (afterResult instanceof Promise) {
-            throw new Error(
-              `Middleware mode is 'sync' but after hook returned Promise for transition: ${transitionName}`
-            );
+  for (const prop in machine) {
+    if (!Object.prototype.hasOwnProperty.call(machine, prop)) continue;
+    const value = machine[prop];
+    if (typeof value === "function" && prop !== "context") {
+      wrappedMachine[prop] = function(...args) {
+        const transitionName = prop;
+        const context = wrappedMachine.context;
+        const executeTransition = () => {
+          let nextMachine;
+          try {
+            nextMachine = value.apply(this, args);
+          } catch (error) {
+            if (hooks.error) {
+              try {
+                hooks.error({
+                  transitionName,
+                  context,
+                  args: [...args],
+                  error
+                });
+              } catch (hookError) {
+                if (!continueOnError) throw hookError;
+                if (logErrors) console.error(`Middleware error hook error for ${transitionName}:`, hookError);
+                onError == null ? void 0 : onError(hookError, "error", { transitionName, context, args, error });
+              }
+            }
+            throw error;
           }
-        }
-        return result;
-      } catch (err) {
-        if (hooks.error) {
-          const middlewareError = {
-            transitionName,
-            context,
-            args,
-            error: err
+          const ensureMiddlewareProperties = (machine2) => {
+            if (machine2 && typeof machine2 === "object" && machine2.context) {
+              for (const prop2 in wrappedMachine) {
+                if (!Object.prototype.hasOwnProperty.call(wrappedMachine, prop2)) continue;
+                if (prop2 !== "context" && !(prop2 in machine2)) {
+                  machine2[prop2] = wrappedMachine[prop2];
+                }
+              }
+              for (const prop2 in machine2) {
+                if (!Object.prototype.hasOwnProperty.call(machine2, prop2)) continue;
+                const value2 = machine2[prop2];
+                if (typeof value2 === "function" && prop2 !== "context" && wrappedMachine[prop2]) {
+                  machine2[prop2] = wrappedMachine[prop2];
+                }
+              }
+            }
+            return machine2;
           };
-          const errorResult = hooks.error(middlewareError);
-          if (errorResult instanceof Promise) {
-            errorResult.catch(() => {
+          if (nextMachine && typeof nextMachine.then === "function") {
+            const asyncResult = nextMachine.then((resolvedMachine) => {
+              ensureMiddlewareProperties(resolvedMachine);
+              if (hooks.after) {
+                try {
+                  const result = hooks.after({
+                    transitionName,
+                    prevContext: context,
+                    nextContext: resolvedMachine.context,
+                    args: [...args]
+                  });
+                  if (result && typeof result.then === "function") {
+                    return result.then(() => resolvedMachine);
+                  }
+                } catch (error) {
+                  if (!continueOnError) throw error;
+                  if (logErrors) console.error(`Middleware after hook error for ${transitionName}:`, error);
+                  onError == null ? void 0 : onError(error, "after", {
+                    transitionName,
+                    prevContext: context,
+                    nextContext: resolvedMachine.context,
+                    args
+                  });
+                }
+              }
+              return resolvedMachine;
             });
-            throw err;
-          }
-          if (errorResult && typeof errorResult === "object" && "context" in errorResult) {
-            return errorResult;
-          }
-        }
-        throw err;
-      }
-    };
-    const handleAsyncResult = async (resultPromise, ctx) => {
-      try {
-        const result = await resultPromise;
-        if (hooks.after) {
-          const middlewareResult = {
-            transitionName,
-            prevContext: ctx,
-            nextContext: result.context,
-            args
-          };
-          await hooks.after(middlewareResult);
-        }
-        return result;
-      } catch (err) {
-        if (hooks.error) {
-          const middlewareError = {
-            transitionName,
-            context: ctx,
-            args,
-            error: err
-          };
-          const errorResult = await hooks.error(middlewareError);
-          if (errorResult && typeof errorResult === "object" && "context" in errorResult) {
-            return errorResult;
+            return asyncResult;
+          } else {
+            ensureMiddlewareProperties(nextMachine);
+            if (hooks.after) {
+              try {
+                const result = hooks.after({
+                  transitionName,
+                  prevContext: context,
+                  nextContext: nextMachine.context,
+                  args: [...args]
+                });
+                if (result && typeof result === "object" && result && "then" in result) {
+                  return result.then(() => nextMachine).catch((error) => {
+                    if (!continueOnError) throw error;
+                    if (logErrors) console.error(`Middleware after hook error for ${transitionName}:`, error);
+                    onError == null ? void 0 : onError(error, "after", {
+                      transitionName,
+                      prevContext: context,
+                      nextContext: nextMachine.context,
+                      args
+                    });
+                    return nextMachine;
+                  });
+                }
+              } catch (error) {
+                if (!continueOnError) throw error;
+                if (logErrors) console.error(`Middleware after hook error for ${transitionName}:`, error);
+                onError == null ? void 0 : onError(error, "after", {
+                  transitionName,
+                  prevContext: context,
+                  nextContext: nextMachine.context,
+                  args
+                });
+              }
+            }
+            return nextMachine;
           }
-        }
-        throw err;
-      }
-    };
-    const executeAsyncTransition = async () => {
-      try {
+        };
         if (hooks.before) {
-          const beforeResult = await hooks.before(middlewareCtx);
-          if (beforeResult === CANCEL) {
-            return machine;
-          }
-        }
-        const result = await originalFn.call(this, ...args);
-        if (hooks.after) {
-          const middlewareResult = {
-            transitionName,
-            prevContext: context,
-            nextContext: result.context,
-            args
-          };
-          await hooks.after(middlewareResult);
-        }
-        return result;
-      } catch (err) {
-        if (hooks.error) {
-          const middlewareError = {
-            transitionName,
-            context,
-            args,
-            error: err
-          };
-          const errorResult = await hooks.error(middlewareError);
-          if (errorResult && typeof errorResult === "object" && "context" in errorResult) {
-            return errorResult;
+          try {
+            const result = hooks.before({
+              transitionName,
+              context,
+              args: [...args]
+            });
+            if (result && typeof result === "object" && result && "then" in result) {
+              return result.then((hookResult) => {
+                if (hookResult === CANCEL) {
+                  return wrappedMachine;
+                }
+                return executeTransition();
+              }).catch((error) => {
+                if (!continueOnError) throw error;
+                if (logErrors) console.error(`Middleware before hook error for ${transitionName}:`, error);
+                onError == null ? void 0 : onError(error, "before", { transitionName, context, args });
+                return executeTransition();
+              });
+            }
+            if (result === CANCEL) {
+              return wrappedMachine;
+            }
+          } catch (error) {
+            if (!continueOnError) throw error;
+            if (logErrors) console.error(`Middleware before hook error for ${transitionName}:`, error);
+            onError == null ? void 0 : onError(error, "before", { transitionName, context, args });
           }
         }
-        throw err;
-      }
-    };
-    if (mode === "async") {
-      return executeAsyncTransition();
-    } else if (mode === "sync") {
-      return executeSyncTransition();
-    } else {
-      return executeSyncTransition();
+        ;
+        return executeTransition();
+      };
     }
-  };
+  }
+  return wrappedMachine;
 }
 function withLogging(machine, options = {}) {
-  const {
-    logger = console.log,
-    includeContext = true,
-    includeArgs = true
-  } = options;
+  const { logger = console.log, includeArgs = false, includeContext = true } = options;
   return createMiddleware(machine, {
     before: ({ transitionName, args }) => {
-      const argsStr = includeArgs && args.length > 0 ? ` ${JSON.stringify(args)}` : "";
-      logger(`→ ${transitionName}${argsStr}`);
+      const message = includeArgs ? `→ ${transitionName} [${args.join(", ")}]` : `→ ${transitionName}`;
+      logger(message);
     },
     after: ({ transitionName, nextContext }) => {
       const contextStr = includeContext ? ` ${JSON.stringify(nextContext)}` : "";
       logger(`✓ ${transitionName}${contextStr}`);
+    },
+    error: ({ transitionName, error }) => {
+      console.error(`[Machine] ${transitionName} failed:`, error);
     }
   });
 }
 function withAnalytics(machine, track, options = {}) {
-  const {
-    eventPrefix = "state_transition",
-    includePrevContext = false,
-    includeArgs = true
-  } = options;
+  const { eventPrefix = "state_transition", includePrevContext = false, includeArgs = false } = options;
   return createMiddleware(machine, {
-    after: async ({ transitionName, prevContext, nextContext, args }) => {
-      const properties = {
-        transition: transitionName,
-        to: nextContext
-      };
-      if (includePrevContext) {
-        properties.from = prevContext;
-      }
-      if (includeArgs && args.length > 0) {
-        properties.args = args;
-      }
-      await track(`${eventPrefix}.${transitionName}`, properties);
+    after: ({ transitionName, prevContext, nextContext, args }) => {
+      const event = `${eventPrefix}.${transitionName}`;
+      const data = { transition: transitionName };
+      if (includePrevContext) data.from = prevContext;
+      data.to = nextContext;
+      if (includeArgs) data.args = args;
+      track(event, data);
     }
-  }, { mode: "async" });
+  });
 }
-function withValidation(machine, validate, options) {
+function withValidation(machine, validator) {
   return createMiddleware(machine, {
     before: (ctx) => {
-      const result = validate(ctx);
-      if (result instanceof Promise) {
-        return result.then((r) => {
-          if (r === false) {
-            throw new Error(`Validation failed for transition: ${ctx.transitionName}`);
-          }
-          return void 0;
-        });
-      }
+      const result = validator(ctx);
       if (result === false) {
         throw new Error(`Validation failed for transition: ${ctx.transitionName}`);
       }
-      return void 0;
     }
-  }, { mode: "auto", ...options });
+  });
 }
-function withPermissions(machine, canPerform, options) {
+function withPermissions(machine, checker) {
   return createMiddleware(machine, {
     before: (ctx) => {
-      const result = canPerform(ctx);
-      if (result instanceof Promise) {
-        return result.then((allowed) => {
-          if (!allowed) {
-            throw new Error(`Unauthorized transition: ${ctx.transitionName}`);
-          }
-          return void 0;
-        });
-      }
-      if (!result) {
+      if (!checker(ctx)) {
         throw new Error(`Unauthorized transition: ${ctx.transitionName}`);
       }
-      return void 0;
     }
-  }, { mode: "auto", ...options });
+  });
 }
-function withErrorReporting(machine, captureError, options = {}) {
-  const { includeContext = true, includeArgs = true, mode } = options;
+function withErrorReporting(machine, reporter, options = {}) {
+  const { includeArgs = false } = options;
   return createMiddleware(machine, {
-    error: async ({ transitionName, context, args, error }) => {
-      const errorContext = {
-        transition: transitionName
+    error: (errorCtx) => {
+      const formattedCtx = {
+        transition: errorCtx.transitionName,
+        context: errorCtx.context,
+        ...includeArgs && { args: errorCtx.args }
       };
-      if (includeContext) {
-        errorContext.context = context;
-      }
-      if (includeArgs && args.length > 0) {
-        errorContext.args = args;
-      }
-      await Promise.resolve(captureError(error, errorContext));
+      reporter(errorCtx.error, formattedCtx);
     }
-  }, { mode });
+  });
 }
-function withPerformanceMonitoring(machine, onMetric) {
-  const timings = /* @__PURE__ */ new Map();
+function withPerformanceMonitoring(machine, tracker) {
+  const startTimes = /* @__PURE__ */ new Map();
   return createMiddleware(machine, {
-    before: ({ transitionName }) => {
-      timings.set(transitionName, performance.now());
-      return void 0;
+    before: (ctx) => {
+      startTimes.set(ctx.transitionName, Date.now());
     },
-    after: ({ transitionName, nextContext }) => {
-      const startTime = timings.get(transitionName);
+    after: (result) => {
+      const startTime = startTimes.get(result.transitionName);
       if (startTime) {
-        const duration = performance.now() - startTime;
-        timings.delete(transitionName);
-        const result = onMetric({ transitionName, duration, context: nextContext });
-        if (result instanceof Promise) {
-          return result;
-        }
+        const duration = Date.now() - startTime;
+        startTimes.delete(result.transitionName);
+        const testResult = {
+          transitionName: result.transitionName,
+          duration,
+          context: result.nextContext || result.prevContext
+        };
+        tracker(testResult);
       }
-      return void 0;
     }
-  }, { mode: "auto" });
+  });
 }
 function withRetry(machine, options = {}) {
+  var _a, _b;
   const {
-    maxRetries = 3,
-    delay = 1e3,
-    backoffMultiplier = 1,
+    maxAttempts = (_a = options.maxRetries) != null ? _a : 3,
     shouldRetry = () => true,
+    backoffMs = (_b = options.delay) != null ? _b : 100,
+    backoffMultiplier = 2,
     onRetry
   } = options;
-  const wrapped = {};
+  const wrappedMachine = { ...machine };
   for (const prop in machine) {
     if (!Object.prototype.hasOwnProperty.call(machine, prop)) continue;
     const value = machine[prop];
-    if (prop === "context" || typeof value !== "function") {
-      wrapped[prop] = value;
-      continue;
-    }
-    wrapped[prop] = async function retriableTransition(...args) {
-      let lastError;
-      for (let attempt = 0; attempt <= maxRetries; attempt++) {
-        try {
-          return await value.call(this, ...args);
-        } catch (error) {
-          lastError = error;
-          if (attempt === maxRetries) {
-            break;
-          }
-          if (!shouldRetry(lastError)) {
-            break;
+    if (typeof value === "function" && prop !== "context") {
+      wrappedMachine[prop] = async function(...args) {
+        let lastError;
+        let attempt = 0;
+        while (attempt < maxAttempts) {
+          try {
+            return await value.apply(this, args);
+          } catch (error) {
+            lastError = error;
+            attempt++;
+            if (attempt < maxAttempts && shouldRetry(lastError, attempt)) {
+              onRetry == null ? void 0 : onRetry(lastError, attempt);
+              const baseDelay = typeof backoffMs === "function" ? backoffMs(attempt) : backoffMs;
+              const delay = baseDelay * Math.pow(backoffMultiplier, attempt - 1);
+              await new Promise((resolve) => setTimeout(resolve, delay));
+            } else {
+              throw lastError;
+            }
           }
-          onRetry == null ? void 0 : onRetry(attempt + 1, lastError);
-          const currentDelay = delay * Math.pow(backoffMultiplier, attempt);
-          await new Promise((resolve) => setTimeout(resolve, currentDelay));
         }
-      }
-      throw lastError;
-    };
+        throw lastError;
+      };
+    }
   }
-  return wrapped;
+  return wrappedMachine;
 }
+function createCustomMiddleware(hooks, options) {
+  return (machine) => createMiddleware(machine, hooks, options);
+}
+
+// src/middleware/history.ts
 function withHistory(machine, options = {}) {
-  const {
-    maxSize,
-    serializer,
-    filter,
-    onEntry,
-    _isRewrap = false
-  } = options;
+  const { maxSize, serializer, onEntry } = options;
   const history = [];
   let entryId = 0;
   const instrumentedMachine = createMiddleware(machine, {
     before: ({ transitionName, args }) => {
-      if (filter && !filter(transitionName, args)) {
-        return;
-      }
       const entry = {
         id: `entry-${entryId++}`,
         transitionName,
         args: [...args],
-        // Shallow clone args (fast, works with any type)
         timestamp: Date.now()
       };
       if (serializer) {
@@ -1461,54 +1335,7 @@ function withHistory(machine, options = {}) {
       }
       onEntry == null ? void 0 : onEntry(entry);
     }
-  }, { exclude: ["context", "history", "clearHistory"] });
-  if (!_isRewrap) {
-    for (const prop in instrumentedMachine) {
-      if (!Object.prototype.hasOwnProperty.call(instrumentedMachine, prop)) continue;
-      const value = instrumentedMachine[prop];
-      if (typeof value === "function" && !prop.startsWith("_") && prop !== "context" && !["history", "clearHistory"].includes(prop)) {
-        const originalFn = value;
-        instrumentedMachine[prop] = function(...args) {
-          const result = originalFn.apply(this, args);
-          if (result && typeof result === "object" && "context" in result && !("history" in result)) {
-            const rewrappedResult = createMiddleware(result, {
-              before: ({ transitionName, args: transArgs }) => {
-                if (filter && !filter(transitionName, transArgs)) {
-                  return;
-                }
-                const entry = {
-                  id: `entry-${entryId++}`,
-                  transitionName,
-                  args: [...transArgs],
-                  timestamp: Date.now()
-                };
-                if (serializer) {
-                  try {
-                    entry.serializedArgs = serializer.serialize(transArgs);
-                  } catch (err) {
-                    console.error("Failed to serialize history args:", err);
-                  }
-                }
-                history.push(entry);
-                if (maxSize && history.length > maxSize) {
-                  history.shift();
-                }
-                onEntry == null ? void 0 : onEntry(entry);
-              }
-            }, { exclude: ["context", "history", "clearHistory"] });
-            return Object.assign(rewrappedResult, {
-              history,
-              clearHistory: () => {
-                history.length = 0;
-                entryId = 0;
-              }
-            });
-          }
-          return result;
-        };
-      }
-    }
-  }
+  });
   return Object.assign(instrumentedMachine, {
     history,
     clearHistory: () => {
@@ -1517,37 +1344,27 @@ function withHistory(machine, options = {}) {
     }
   });
 }
+
+// src/middleware/snapshot.ts
 function withSnapshot(machine, options = {}) {
   const {
     maxSize,
     serializer,
     captureSnapshot,
-    onlyIfChanged = false,
-    filter,
-    onSnapshot,
-    _extraExclusions = [],
-    _isRewrap = false
+    onlyOnChange = false
   } = options;
   const snapshots = [];
   let snapshotId = 0;
   const instrumentedMachine = createMiddleware(machine, {
     after: ({ transitionName, prevContext, nextContext }) => {
-      if (filter && !filter(transitionName)) {
+      if (onlyOnChange && JSON.stringify(prevContext) === JSON.stringify(nextContext)) {
         return;
       }
-      if (onlyIfChanged) {
-        const changed = JSON.stringify(prevContext) !== JSON.stringify(nextContext);
-        if (!changed) {
-          return;
-        }
-      }
       const snapshot = {
         id: `snapshot-${snapshotId++}`,
         transitionName,
         before: { ...prevContext },
-        // Clone
         after: { ...nextContext },
-        // Clone
         timestamp: Date.now()
       };
       if (serializer) {
@@ -1569,92 +1386,16 @@ function withSnapshot(machine, options = {}) {
       if (maxSize && snapshots.length > maxSize) {
         snapshots.shift();
       }
-      onSnapshot == null ? void 0 : onSnapshot(snapshot);
     }
-  }, { exclude: ["context", "snapshots", "clearSnapshots", "restoreSnapshot", ..._extraExclusions] });
+  });
   const restoreSnapshot = (context) => {
-    const { context: _, ...transitions } = machine;
-    return { context, ...transitions };
+    const transitions = Object.fromEntries(
+      Object.entries(machine).filter(
+        ([key]) => key !== "context" && key !== "snapshots" && key !== "clearSnapshots" && key !== "restoreSnapshot" && typeof machine[key] === "function"
+      )
+    );
+    return Object.assign({ context }, transitions);
   };
-  if (!_isRewrap) {
-    for (const prop in instrumentedMachine) {
-      if (!Object.prototype.hasOwnProperty.call(instrumentedMachine, prop)) continue;
-      const value = instrumentedMachine[prop];
-      if (typeof value === "function" && !prop.startsWith("_") && prop !== "context" && !["snapshots", "clearSnapshots", "restoreSnapshot", "history", "clearHistory"].includes(prop)) {
-        const originalWrappedFn = value;
-        instrumentedMachine[prop] = function(...args) {
-          const result = originalWrappedFn.apply(this, args);
-          if (result && typeof result === "object" && "context" in result && !("snapshots" in result)) {
-            for (const transProp in result) {
-              if (!Object.prototype.hasOwnProperty.call(result, transProp)) continue;
-              const transValue = result[transProp];
-              if (typeof transValue === "function" && !transProp.startsWith("_") && transProp !== "context" && !["snapshots", "clearSnapshots", "restoreSnapshot", "history", "clearHistory"].includes(transProp)) {
-                const origTransFn = transValue;
-                result[transProp] = function(...transArgs) {
-                  const prevCtx = result.context;
-                  const transResult = origTransFn.apply(this, transArgs);
-                  if (transResult && typeof transResult === "object" && "context" in transResult) {
-                    const nextCtx = transResult.context;
-                    if (!(filter && !filter(transProp))) {
-                      let shouldRecord = true;
-                      if (onlyIfChanged) {
-                        const changed = JSON.stringify(prevCtx) !== JSON.stringify(nextCtx);
-                        shouldRecord = changed;
-                      }
-                      if (shouldRecord) {
-                        const snapshot = {
-                          id: `snapshot-${snapshotId++}`,
-                          transitionName: transProp,
-                          before: { ...prevCtx },
-                          after: { ...nextCtx },
-                          timestamp: Date.now()
-                        };
-                        if (serializer) {
-                          try {
-                            snapshot.serializedBefore = serializer.serialize(prevCtx);
-                            snapshot.serializedAfter = serializer.serialize(nextCtx);
-                          } catch (err) {
-                            console.error("Failed to serialize snapshot:", err);
-                          }
-                        }
-                        if (captureSnapshot) {
-                          try {
-                            snapshot.diff = captureSnapshot(prevCtx, nextCtx);
-                          } catch (err) {
-                            console.error("Failed to capture snapshot:", err);
-                          }
-                        }
-                        snapshots.push(snapshot);
-                        if (maxSize && snapshots.length > maxSize) {
-                          snapshots.shift();
-                        }
-                        onSnapshot == null ? void 0 : onSnapshot(snapshot);
-                      }
-                    }
-                  }
-                  return transResult;
-                };
-              }
-            }
-            const resultWithTracking = Object.assign(result, {
-              snapshots,
-              clearSnapshots: () => {
-                snapshots.length = 0;
-                snapshotId = 0;
-              },
-              restoreSnapshot
-            });
-            if (machine.history) {
-              resultWithTracking.history = machine.history;
-              resultWithTracking.clearHistory = machine.clearHistory;
-            }
-            return resultWithTracking;
-          }
-          return result;
-        };
-      }
-    }
-  }
   return Object.assign(instrumentedMachine, {
     snapshots,
     clearSnapshots: () => {
@@ -1664,139 +1405,122 @@ function withSnapshot(machine, options = {}) {
     restoreSnapshot
   });
 }
+
+// src/middleware/time-travel.ts
 function withTimeTravel(machine, options = {}) {
   const { maxSize, serializer, onRecord } = options;
   const history = [];
   const snapshots = [];
-  let entryId = 0;
+  let historyId = 0;
   let snapshotId = 0;
-  const recordHistory = (transitionName, args) => {
-    const entry = {
-      id: `entry-${entryId++}`,
-      transitionName,
-      args: [...args],
-      timestamp: Date.now()
-    };
-    if (serializer) {
-      try {
-        entry.serializedArgs = serializer.serialize(args);
-      } catch (err) {
-        console.error("Failed to serialize history args:", err);
+  const instrumentedMachine = createMiddleware(machine, {
+    before: ({ transitionName, args }) => {
+      const entry = {
+        id: `entry-${historyId++}`,
+        transitionName,
+        args: [...args],
+        timestamp: Date.now()
+      };
+      if (serializer) {
+        try {
+          entry.serializedArgs = serializer.serialize(args);
+        } catch (err) {
+          console.error("Failed to serialize history args:", err);
+        }
       }
-    }
-    history.push(entry);
-    if (maxSize && history.length > maxSize) {
-      history.shift();
-    }
-    onRecord == null ? void 0 : onRecord("history", entry);
-  };
-  const recordSnapshot = (transitionName, prevContext, nextContext) => {
-    const snapshot = {
-      id: `snapshot-${snapshotId++}`,
-      transitionName,
-      before: { ...prevContext },
-      after: { ...nextContext },
-      timestamp: Date.now()
-    };
-    if (serializer) {
-      try {
-        snapshot.serializedBefore = serializer.serialize(prevContext);
-        snapshot.serializedAfter = serializer.serialize(nextContext);
-      } catch (err) {
-        console.error("Failed to serialize snapshot:", err);
+      history.push(entry);
+      if (maxSize && history.length > maxSize) {
+        history.shift();
       }
-    }
-    snapshots.push(snapshot);
-    if (maxSize && snapshots.length > maxSize) {
-      snapshots.shift();
-    }
-    onRecord == null ? void 0 : onRecord("snapshot", snapshot);
-  };
-  const restoreSnapshot = (context) => {
-    const { context: _, ...transitions } = machine;
-    return Object.assign({ context }, context, transitions);
-  };
-  const replayFrom = (snapshotIndex = 0) => {
-    if (snapshotIndex < 0 || snapshotIndex >= snapshots.length) {
-      throw new Error(`Invalid snapshot index: ${snapshotIndex}`);
-    }
-    let current = restoreSnapshot(snapshots[snapshotIndex].before);
-    const snapshot = snapshots[snapshotIndex];
-    const historyStartIndex = history.findIndex(
-      (entry) => entry.transitionName === snapshot.transitionName && entry.timestamp === snapshot.timestamp
-    );
-    if (historyStartIndex === -1) {
-      throw new Error("Could not find matching history entry for snapshot");
-    }
-    for (let i = historyStartIndex; i < history.length; i++) {
-      const entry = history[i];
-      const transition = current[entry.transitionName];
-      if (typeof transition === "function") {
+      onRecord == null ? void 0 : onRecord("history", entry);
+    },
+    after: ({ transitionName, prevContext, nextContext }) => {
+      const snapshot = {
+        id: `snapshot-${snapshotId++}`,
+        transitionName,
+        before: { ...prevContext },
+        after: { ...nextContext },
+        timestamp: Date.now()
+      };
+      if (serializer) {
         try {
-          current = transition.apply(current.context, entry.args);
+          snapshot.serializedBefore = serializer.serialize(prevContext);
+          snapshot.serializedAfter = serializer.serialize(nextContext);
         } catch (err) {
-          console.error(`Replay failed at step ${i}:`, err);
-          throw err;
+          console.error("Failed to serialize snapshot:", err);
         }
       }
+      snapshots.push(snapshot);
+      if (maxSize && snapshots.length > maxSize) {
+        snapshots.shift();
+      }
+      onRecord == null ? void 0 : onRecord("snapshot", snapshot);
     }
-    return current;
+  });
+  const restoreSnapshot = (context) => {
+    const transitions = Object.fromEntries(
+      Object.entries(machine).filter(
+        ([key]) => key !== "context" && key !== "history" && key !== "snapshots" && key !== "clearHistory" && key !== "clearSnapshots" && key !== "restoreSnapshot" && key !== "clearTimeTravel" && key !== "replayFrom" && typeof machine[key] === "function"
+      )
+    );
+    return Object.assign({ context }, transitions);
   };
-  const wrapMachine = (machine2) => {
-    const wrapped = { ...machine2 };
-    for (const prop in machine2) {
-      if (!Object.prototype.hasOwnProperty.call(machine2, prop)) continue;
-      const value = machine2[prop];
-      if (typeof value === "function" && !prop.startsWith("_") && prop !== "context" && !["history", "snapshots", "clearHistory", "clearSnapshots", "clearTimeTravel", "restoreSnapshot", "replayFrom"].includes(prop)) {
-        wrapped[prop] = function(...args) {
-          recordHistory(prop, args);
-          const prevContext = wrapped.context;
-          const result = value.apply(this, args);
-          if (result && typeof result === "object" && "context" in result) {
-            recordSnapshot(prop, prevContext, result.context);
-          }
-          if (result && typeof result === "object" && "context" in result) {
-            return wrapMachine(result);
-          }
-          return result;
-        };
+  const replayFrom = (startIndex) => {
+    var _a;
+    if (startIndex < 0 || startIndex >= history.length) {
+      throw new Error(`Invalid replay start index: ${startIndex}`);
+    }
+    let currentContext = (_a = snapshots[startIndex]) == null ? void 0 : _a.before;
+    if (!currentContext) {
+      throw new Error(`No snapshot available for index ${startIndex}`);
+    }
+    const transitionsToReplay = history.slice(startIndex);
+    const freshMachine = Object.assign(
+      { context: currentContext },
+      Object.fromEntries(
+        Object.entries(machine).filter(
+          ([key]) => key !== "context" && typeof machine[key] === "function"
+        )
+      )
+    );
+    let replayedMachine = freshMachine;
+    for (const entry of transitionsToReplay) {
+      const transitionFn = replayedMachine[entry.transitionName];
+      if (transitionFn) {
+        replayedMachine = transitionFn.apply(replayedMachine.context, entry.args);
       }
     }
-    return Object.assign(wrapped, {
-      history,
-      snapshots,
-      clearHistory: () => {
-        history.length = 0;
-        entryId = 0;
-      },
-      clearSnapshots: () => {
-        snapshots.length = 0;
-        snapshotId = 0;
-      },
-      clearTimeTravel: () => {
-        history.length = 0;
-        snapshots.length = 0;
-        entryId = 0;
-        snapshotId = 0;
-      },
-      restoreSnapshot,
-      replayFrom
-    });
+    return replayedMachine;
   };
-  return wrapMachine(machine);
+  return Object.assign(instrumentedMachine, {
+    history,
+    snapshots,
+    clearHistory: () => {
+      history.length = 0;
+      historyId = 0;
+    },
+    clearSnapshots: () => {
+      snapshots.length = 0;
+      snapshotId = 0;
+    },
+    clearTimeTravel: () => {
+      history.length = 0;
+      snapshots.length = 0;
+      historyId = 0;
+      snapshotId = 0;
+    },
+    restoreSnapshot,
+    replayFrom
+  });
 }
+
+// src/middleware/composition.ts
 function compose(machine, ...middlewares) {
   return middlewares.reduce((acc, middleware) => middleware(acc), machine);
 }
-function createCustomMiddleware(hooks, options) {
-  return (machine) => createMiddleware(machine, hooks, options);
-}
 function composeTyped(machine, ...middlewares) {
   return middlewares.reduce((acc, middleware) => middleware(acc), machine);
 }
-function chain(machine) {
-  return new MiddlewareChainBuilder(machine);
-}
 var MiddlewareChainBuilder = class _MiddlewareChainBuilder {
   constructor(machine) {
     this.machine = machine;
@@ -1817,53 +1541,30 @@ var MiddlewareChainBuilder = class _MiddlewareChainBuilder {
     return this.machine;
   }
 };
-function withDebugging(machine) {
-  return withTimeTravel(withSnapshot(withHistory(machine)));
+function chain(machine) {
+  return new MiddlewareChainBuilder(machine);
 }
-function createPipeline(config = {}) {
-  const {
-    continueOnError = false,
-    logErrors = true,
-    onError
-  } = config;
-  return (machine, ...middlewares) => {
-    let currentMachine = machine;
-    const errors = [];
-    for (let i = 0; i < middlewares.length; i++) {
-      const middleware = middlewares[i];
-      try {
-        if ("middleware" in middleware && "when" in middleware) {
-          if (!middleware.when(currentMachine)) {
-            continue;
-          }
-          currentMachine = middleware.middleware(currentMachine);
-        } else {
-          currentMachine = middleware(currentMachine);
-        }
-      } catch (error) {
-        const err = error instanceof Error ? error : new Error(String(error));
-        errors.push({ error: err, middlewareIndex: i });
-        if (logErrors) {
-          console.error(`Middleware pipeline error at index ${i}:`, err);
-        }
-        onError == null ? void 0 : onError(err, `middleware-${i}`);
-        if (!continueOnError) {
-          break;
-        }
-      }
-    }
-    return {
-      machine: currentMachine,
-      errors,
-      success: errors.length === 0
-    };
+function when(middleware, predicate) {
+  const conditional = function(machine) {
+    return predicate(machine) ? middleware(machine) : machine;
   };
+  conditional.middleware = middleware;
+  conditional.when = predicate;
+  return conditional;
+}
+function inDevelopment(middleware) {
+  return when(middleware, () => {
+    return typeof process !== "undefined" ? true : typeof window !== "undefined" ? !window.location.hostname.includes("production") : false;
+  });
+}
+function whenContext(key, value, middleware) {
+  return when(middleware, (machine) => machine.context[key] === value);
 }
 function createMiddlewareRegistry() {
   const registry = /* @__PURE__ */ new Map();
   return {
     /**
-     * Register a middleware with a name and optional metadata.
+     * Register a middleware by name.
      */
     register(name, middleware, description, priority) {
       if (registry.has(name)) {
@@ -1925,21 +1626,45 @@ function createMiddlewareRegistry() {
     }
   };
 }
-function when(middleware, predicate) {
-  const conditional = function(machine) {
-    return predicate(machine) ? middleware(machine) : machine;
+function createPipeline(config = {}) {
+  const {
+    continueOnError = false,
+    logErrors = true,
+    onError
+  } = config;
+  return (machine, ...middlewares) => {
+    let currentMachine = machine;
+    const errors = [];
+    let success = true;
+    for (let i = 0; i < middlewares.length; i++) {
+      const middleware = middlewares[i];
+      try {
+        if ("middleware" in middleware && "when" in middleware) {
+          if (!middleware.when(currentMachine)) {
+            continue;
+          }
+          currentMachine = middleware.middleware(currentMachine);
+        } else {
+          currentMachine = middleware(currentMachine);
+        }
+      } catch (error) {
+        success = false;
+        if (!continueOnError) {
+          throw error;
+        }
+        errors.push({
+          error,
+          middlewareIndex: i,
+          middlewareName: middleware.name
+        });
+        if (logErrors) {
+          console.error(`Pipeline middleware error at index ${i}:`, error);
+        }
+        onError == null ? void 0 : onError(error, i, middleware.name);
+      }
+    }
+    return { machine: currentMachine, errors, success };
   };
-  conditional.middleware = middleware;
-  conditional.when = predicate;
-  return conditional;
-}
-function inDevelopment(middleware) {
-  return when(middleware, () => {
-    return typeof process !== "undefined" ? true : typeof window !== "undefined" ? !window.location.hostname.includes("production") : false;
-  });
-}
-function whenContext(key, value, middleware) {
-  return when(middleware, (machine) => machine.context[key] === value);
 }
 function combine(...middlewares) {
   return (machine) => composeTyped(machine, ...middlewares);
@@ -1958,7 +1683,197 @@ function isMiddlewareFn(value) {
   return typeof value === "function" && value.length === 1;
 }
 function isConditionalMiddleware(value) {
-  return value !== null && "middleware" in value && "when" in value && isMiddlewareFn(value.middleware) && typeof value.when === "function";
+  return value !== null && (typeof value === "object" || typeof value === "function") && "middleware" in value && "when" in value && isMiddlewareFn(value.middleware) && typeof value.when === "function";
+}
+function isMiddlewareResult(value, contextType) {
+  return value !== null && typeof value === "object" && "transitionName" in value && "prevContext" in value && "nextContext" in value && "args" in value && typeof value.transitionName === "string" && Array.isArray(value.args) && (!contextType || isValidContext(value.prevContext, contextType) && isValidContext(value.nextContext, contextType));
+}
+function isMiddlewareContext(value, contextType) {
+  return value !== null && typeof value === "object" && "transitionName" in value && "context" in value && "args" in value && typeof value.transitionName === "string" && Array.isArray(value.args) && (!contextType || isValidContext(value.context, contextType));
+}
+function isMiddlewareError(value, contextType) {
+  return value !== null && typeof value === "object" && "transitionName" in value && "context" in value && "args" in value && "error" in value && typeof value.transitionName === "string" && Array.isArray(value.args) && value.error instanceof Error && (!contextType || isValidContext(value.context, contextType));
+}
+function isMiddlewareHooks(value, _contextType) {
+  if (value === null || typeof value !== "object") return false;
+  const hooks = value;
+  if ("before" in hooks && hooks.before !== void 0) {
+    if (typeof hooks.before !== "function") return false;
+  }
+  if ("after" in hooks && hooks.after !== void 0) {
+    if (typeof hooks.after !== "function") return false;
+  }
+  if ("error" in hooks && hooks.error !== void 0) {
+    if (typeof hooks.error !== "function") return false;
+  }
+  return true;
+}
+function isMiddlewareOptions(value) {
+  return value === void 0 || value !== null && typeof value === "object" && ("continueOnError" in value ? typeof value.continueOnError === "boolean" : true) && ("logErrors" in value ? typeof value.logErrors === "boolean" : true) && ("onError" in value ? typeof value.onError === "function" || value.onError === void 0 : true);
+}
+function isValidContext(value, _contextType) {
+  return value !== null && typeof value === "object";
+}
+function isNamedMiddleware(value) {
+  return value !== null && typeof value === "object" && "name" in value && "middleware" in value && typeof value.name === "string" && isMiddlewareFn(value.middleware) && ("description" in value ? typeof value.description === "string" || value.description === void 0 : true) && ("priority" in value ? typeof value.priority === "number" || value.priority === void 0 : true);
+}
+function isPipelineConfig(value) {
+  return value === void 0 || value !== null && typeof value === "object" && ("continueOnError" in value ? typeof value.continueOnError === "boolean" : true) && ("logErrors" in value ? typeof value.logErrors === "boolean" : true) && ("onError" in value ? typeof value.onError === "function" || value.onError === void 0 : true);
+}
+var MiddlewareBuilder = class {
+  constructor(machine) {
+    this.machine = machine;
+    this.middlewares = [];
+  }
+  /**
+   * Add logging middleware with type-safe configuration.
+   */
+  withLogging(options) {
+    this.middlewares.push((machine) => withLogging(machine, options));
+    return this;
+  }
+  /**
+   * Add analytics middleware with type-safe configuration.
+   */
+  withAnalytics(track, options) {
+    this.middlewares.push((machine) => withAnalytics(machine, track, options));
+    return this;
+  }
+  /**
+   * Add validation middleware with type-safe configuration.
+   */
+  withValidation(validator, _options) {
+    this.middlewares.push((machine) => withValidation(machine, validator));
+    return this;
+  }
+  /**
+   * Add permission checking middleware with type-safe configuration.
+   */
+  withPermissions(checker) {
+    this.middlewares.push((machine) => withPermissions(machine, checker));
+    return this;
+  }
+  /**
+   * Add error reporting middleware with type-safe configuration.
+   */
+  withErrorReporting(reporter, options) {
+    this.middlewares.push((machine) => withErrorReporting(machine, reporter, options));
+    return this;
+  }
+  /**
+   * Add performance monitoring middleware with type-safe configuration.
+   */
+  withPerformanceMonitoring(tracker, _options) {
+    this.middlewares.push((machine) => withPerformanceMonitoring(machine, tracker));
+    return this;
+  }
+  /**
+   * Add retry middleware with type-safe configuration.
+   */
+  withRetry(options) {
+    this.middlewares.push((machine) => withRetry(machine, options));
+    return this;
+  }
+  /**
+   * Add history tracking middleware with type-safe configuration.
+   */
+  withHistory(options) {
+    this.middlewares.push((machine) => withHistory(machine, options));
+    return this;
+  }
+  /**
+   * Add snapshot tracking middleware with type-safe configuration.
+   */
+  withSnapshot(options) {
+    this.middlewares.push((machine) => withSnapshot(machine, options));
+    return this;
+  }
+  /**
+   * Add time travel middleware with type-safe configuration.
+   */
+  withTimeTravel(options) {
+    this.middlewares.push((machine) => withTimeTravel(machine, options));
+    return this;
+  }
+  /**
+   * Add debugging middleware (combination of history, snapshot, and time travel).
+   */
+  withDebugging() {
+    this.middlewares.push((machine) => withDebugging(machine));
+    return this;
+  }
+  /**
+   * Add a custom middleware function.
+   */
+  withCustom(middleware) {
+    this.middlewares.push(middleware);
+    return this;
+  }
+  /**
+   * Add a conditional middleware.
+   */
+  withConditional(middleware, predicate) {
+    this.middlewares.push(when(middleware, predicate));
+    return this;
+  }
+  /**
+   * Build the final machine with all configured middleware applied.
+   */
+  build() {
+    let result = this.machine;
+    for (const middleware of this.middlewares) {
+      result = middleware(result);
+    }
+    return result;
+  }
+  /**
+   * Get the middleware chain without building (for inspection or further composition).
+   */
+  getChain() {
+    return [...this.middlewares];
+  }
+  /**
+   * Clear all configured middleware.
+   */
+  clear() {
+    this.middlewares = [];
+    return this;
+  }
+};
+function middlewareBuilder(machine) {
+  return new MiddlewareBuilder(machine);
+}
+function createMiddlewareFactory(defaultOptions = {}) {
+  return {
+    create: (machine) => {
+      const builder = middlewareBuilder(machine);
+      if (defaultOptions.logging) {
+        builder.withLogging(defaultOptions.logging);
+      }
+      if (defaultOptions.analytics) {
+        builder.withAnalytics(
+          defaultOptions.analytics.track,
+          defaultOptions.analytics.options
+        );
+      }
+      if (defaultOptions.history) {
+        builder.withHistory(defaultOptions.history);
+      }
+      if (defaultOptions.snapshot) {
+        builder.withSnapshot(defaultOptions.snapshot);
+      }
+      if (defaultOptions.timeTravel) {
+        builder.withTimeTravel(defaultOptions.timeTravel);
+      }
+      if (defaultOptions.retry) {
+        builder.withRetry(defaultOptions.retry);
+      }
+      return builder;
+    }
+  };
+}
+function withDebugging(machine) {
+  return withTimeTravel(withSnapshot(withHistory(machine)));
 }
 
 // src/utils.ts
@@ -2085,15 +2000,61 @@ function state(context, transitions) {
 }
 
 // src/index.ts
-function createMachine(context, fns) {
-  const transitions = "context" in fns ? Object.fromEntries(
-    Object.entries(fns).filter(([key]) => key !== "context")
-  ) : fns;
+function createMachine(context, fnsOrFactory) {
+  if (typeof fnsOrFactory === "function") {
+    let transitions2;
+    const transition = (newContext) => {
+      const machine2 = createMachine(newContext, transitions2);
+      const boundTransitions2 = Object.fromEntries(
+        Object.entries(transitions2).map(([key, fn]) => [
+          key,
+          fn.bind(newContext)
+        ])
+      );
+      return Object.assign(machine2, boundTransitions2);
+    };
+    transitions2 = fnsOrFactory(transition);
+    const boundTransitions = Object.fromEntries(
+      Object.entries(transitions2).map(([key, fn]) => [
+        key,
+        fn.bind(context)
+      ])
+    );
+    return Object.assign({ context }, boundTransitions);
+  }
+  const transitions = "context" in fnsOrFactory ? Object.fromEntries(
+    Object.entries(fnsOrFactory).filter(([key]) => key !== "context")
+  ) : fnsOrFactory;
   const machine = Object.assign({ context }, transitions);
   return machine;
 }
-function createAsyncMachine(context, fns) {
-  return Object.assign({ context }, fns);
+function createAsyncMachine(context, fnsOrFactory) {
+  if (typeof fnsOrFactory === "function") {
+    let transitions2;
+    const transition = (newContext) => {
+      const machine2 = createAsyncMachine(newContext, transitions2);
+      const boundTransitions2 = Object.fromEntries(
+        Object.entries(transitions2).map(([key, fn]) => [
+          key,
+          fn.bind(newContext)
+        ])
+      );
+      return Object.assign(machine2, boundTransitions2);
+    };
+    transitions2 = fnsOrFactory(transition);
+    const boundTransitions = Object.fromEntries(
+      Object.entries(transitions2).map(([key, fn]) => [
+        key,
+        fn.bind(context)
+      ])
+    );
+    return Object.assign({ context }, boundTransitions);
+  }
+  const transitions = "context" in fnsOrFactory ? Object.fromEntries(
+    Object.entries(fnsOrFactory).filter(([key]) => key !== "context")
+  ) : fnsOrFactory;
+  const machine = Object.assign({ context }, transitions);
+  return machine;
 }
 function createMachineFactory() {
   return (transformers) => {
@@ -2101,7 +2062,7 @@ function createMachineFactory() {
       Object.entries(transformers).map(([key, transform]) => [
         key,
         function(...args) {
-          const newContext = transform(this, ...args);
+          const newContext = transform(this.context, ...args);
           return createMachine(newContext, fns);
         }
       ])
@@ -2215,10 +2176,11 @@ function next(m, update) {
 export {
   ADVANCED_CONFIG_EXAMPLES,
   BoundMachine,
+  CANCEL,
   META_KEY,
   MachineBase,
+  MiddlewareBuilder,
   MultiMachineBase,
-  RUNTIME_META,
   action,
   bindTransitions,
   branch,
@@ -2240,6 +2202,7 @@ export {
   createMachineBuilder,
   createMachineFactory,
   createMiddleware,
+  createMiddlewareFactory,
   createMiddlewareRegistry,
   createMultiMachine,
   createMutableMachine,
@@ -2252,13 +2215,9 @@ export {
   delegateToChild,
   describe,
   extendTransitions,
-  extractFromInstance,
-  extractFunctionMetadata,
   extractMachine,
   extractMachines,
-  extractStateNode,
   generateChart,
-  generateStatechart,
   guard,
   guardAsync,
   guarded,
@@ -2266,12 +2225,20 @@ export {
   inDevelopment,
   invoke,
   isConditionalMiddleware,
+  isMiddlewareContext,
+  isMiddlewareError,
   isMiddlewareFn,
+  isMiddlewareHooks,
+  isMiddlewareOptions,
+  isMiddlewareResult,
+  isNamedMiddleware,
+  isPipelineConfig,
   isState,
   logState,
   matchMachine,
   mergeContext,
   metadata,
+  middlewareBuilder,
   next,
   overrideTransitions,
   pipeTransitions,