@doeixd/machine 0.0.6 → 0.0.8

package/dist/cjs/development/index.js

@@ -20,20 +20,37 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
+  BoundMachine: () => BoundMachine,
   META_KEY: () => META_KEY,
   MachineBase: () => MachineBase,
   MultiMachineBase: () => MultiMachineBase,
   RUNTIME_META: () => RUNTIME_META,
   action: () => action,
+  bindTransitions: () => bindTransitions,
+  branch: () => branch,
+  call: () => call,
+  chain: () => chain,
+  combine: () => combine,
+  combineFactories: () => combineFactories,
+  compose: () => compose,
+  composeTyped: () => composeTyped,
   createAsyncMachine: () => createAsyncMachine,
+  createCustomMiddleware: () => createCustomMiddleware,
   createEnsemble: () => createEnsemble,
+  createEvent: () => createEvent,
+  createFetchMachine: () => createFetchMachine,
   createFlow: () => createFlow,
   createMachine: () => createMachine,
   createMachineBuilder: () => createMachineBuilder,
   createMachineFactory: () => createMachineFactory,
+  createMiddleware: () => createMiddleware,
+  createMiddlewareRegistry: () => createMiddlewareRegistry,
   createMultiMachine: () => createMultiMachine,
   createMutableMachine: () => createMutableMachine,
+  createParallelMachine: () => createParallelMachine,
+  createPipeline: () => createPipeline,
   createRunner: () => createRunner,
+  delegateToChild: () => delegateToChild,
   describe: () => describe,
   extendTransitions: () => extendTransitions,
   extractFromInstance: () => extractFromInstance,
@@ -43,13 +60,21 @@ __export(src_exports, {
   extractStateNode: () => extractStateNode,
   generateChart: () => generateChart,
   generateStatechart: () => generateStatechart,
+  guard: () => guard,
   guarded: () => guarded,
   hasState: () => hasState,
+  inDevelopment: () => inDevelopment,
   invoke: () => invoke,
+  isConditionalMiddleware: () => isConditionalMiddleware,
+  isMiddlewareFn: () => isMiddlewareFn,
+  isState: () => isState,
+  logState: () => logState,
   matchMachine: () => matchMachine,
+  mergeContext: () => mergeContext,
   metadata: () => metadata,
   next: () => next,
   overrideTransitions: () => overrideTransitions,
+  pipeTransitions: () => pipeTransitions,
   run: () => run,
   runAsync: () => runAsync,
   runMachine: () => runMachine,
@@ -60,7 +85,22 @@ __export(src_exports, {
   setContext: () => setContext,
   step: () => step,
   stepAsync: () => stepAsync,
+  toggle: () => toggle,
   transitionTo: () => transitionTo,
+  when: () => when,
+  whenContext: () => whenContext,
+  whenGuard: () => whenGuard,
+  withAnalytics: () => withAnalytics,
+  withDebugging: () => withDebugging,
+  withErrorReporting: () => withErrorReporting,
+  withHistory: () => withHistory,
+  withLogging: () => withLogging,
+  withPerformanceMonitoring: () => withPerformanceMonitoring,
+  withPermissions: () => withPermissions,
+  withRetry: () => withRetry,
+  withSnapshot: () => withSnapshot,
+  withTimeTravel: () => withTimeTravel,
+  withValidation: () => withValidation,
   yieldMachine: () => yieldMachine
 });
 module.exports = __toCommonJS(src_exports);
@@ -164,9 +204,9 @@ function describe(_text, transition) {
   });
   return transition;
 }
-function guarded(guard, transition) {
+function guarded(guard2, transition) {
   attachRuntimeMeta(transition, {
-    guards: [guard]
+    guards: [guard2]
   });
   return transition;
 }
@@ -187,6 +227,62 @@ function action(action2, transition) {
   });
   return transition;
 }
+function guard(condition, transition, options = {}) {
+  const { onFail = "throw", errorMessage, description } = options;
+  const fullOptions = { ...options, onFail, errorMessage, description };
+  const guardedTransition = async function(...args) {
+    const isMachine = typeof this === "object" && "context" in this;
+    const ctx = isMachine ? this.context : this;
+    const conditionResult = await Promise.resolve(condition(ctx, ...args));
+    if (conditionResult) {
+      const contextForTransition = isMachine ? this.context : this;
+      return transition.apply(contextForTransition, args);
+    } else {
+      if (onFail === "throw") {
+        const message = errorMessage || "Guard condition failed";
+        throw new Error(message);
+      } else if (onFail === "ignore") {
+        if (isMachine) {
+          return this;
+        } else {
+          throw new Error('Cannot use "ignore" mode with context-only binding. Use full machine binding or provide fallback.');
+        }
+      } else if (typeof onFail === "function") {
+        if (isMachine) {
+          return onFail.apply(this, args);
+        } else {
+          throw new Error("Cannot use function fallback with context-only binding. Use full machine binding.");
+        }
+      } else {
+        return onFail;
+      }
+    }
+  };
+  Object.defineProperty(guardedTransition, "__guard", { value: true, enumerable: false });
+  Object.defineProperty(guardedTransition, "condition", { value: condition, enumerable: false });
+  Object.defineProperty(guardedTransition, "transition", { value: transition, enumerable: false });
+  Object.defineProperty(guardedTransition, "options", { value: fullOptions, enumerable: false });
+  attachRuntimeMeta(guardedTransition, {
+    description: description || "Runtime guarded transition",
+    guards: [{ name: "runtime_guard", description: description || "Runtime condition check" }]
+  });
+  return guardedTransition;
+}
+function whenGuard(condition) {
+  return {
+    /**
+     * Define the transition to execute when the condition passes.
+     * Returns a guarded transition that can optionally have an else clause.
+     */
+    do(transition) {
+      const guarded2 = guard(condition, transition);
+      guarded2.else = function(fallback) {
+        return guard(condition, transition, { onFail: fallback });
+      };
+      return guarded2;
+    }
+  };
+}
 function metadata(_meta, value) {
   return value;
 }
@@ -256,17 +352,17 @@ function parseInvokeService(obj) {
   }
   return service;
 }
-function extractFromCallExpression(call, verbose = false) {
-  if (!import_ts_morph.Node.isCallExpression(call)) {
+function extractFromCallExpression(call2, verbose = false) {
+  if (!import_ts_morph.Node.isCallExpression(call2)) {
     return null;
   }
-  const expression = call.getExpression();
+  const expression = call2.getExpression();
   const fnName = import_ts_morph.Node.isIdentifier(expression) ? expression.getText() : null;
   if (!fnName) {
     return null;
   }
   const metadata2 = {};
-  const args = call.getArguments();
+  const args = call2.getArguments();
   switch (fnName) {
     case "transitionTo":
       if (args[0]) {
@@ -286,9 +382,9 @@ function extractFromCallExpression(call, verbose = false) {
       break;
     case "guarded":
       if (args[0]) {
-        const guard = parseObjectLiteral(args[0]);
-        if (Object.keys(guard).length > 0) {
-          metadata2.guards = [guard];
+        const guard2 = parseObjectLiteral(args[0]);
+        if (Object.keys(guard2).length > 0) {
+          metadata2.guards = [guard2];
         }
       }
       if (args[1] && import_ts_morph.Node.isCallExpression(args[1])) {
@@ -406,6 +502,26 @@ function analyzeStateNode(classSymbol, verbose = false) {
   }
   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}`);
+    }
+    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 stateNode;
+}
 function extractMachine(config, project, verbose = false) {
   if (verbose) {
     console.error(`
@@ -416,6 +532,45 @@ function extractMachine(config, project, verbose = false) {
   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: {}
+    };
+    if (config.description) {
+      parallelChart.description = config.description;
+    }
+    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}'.`);
+        }
+      }
+      parallelChart.states[region.name] = {
+        initial: region.initialState,
+        states: regionStates
+      };
+    }
+    if (verbose) {
+      console.error(`  ✅ Extracted ${config.parallel.regions.length} parallel regions`);
+    }
+    return parallelChart;
+  }
+  if (!config.initialState || !config.classes) {
+    throw new Error(`Machine config for '${config.id}' must have either 'parallel' or 'initialState'/'classes'.`);
+  }
   const fullChart = {
     id: config.id,
     initial: config.initialState,
@@ -431,7 +586,14 @@ function extractMachine(config, project, verbose = false) {
       continue;
     }
     const classSymbol = classDeclaration.getSymbolOrThrow();
-    const stateNode = analyzeStateNode(classSymbol, verbose);
+    const hasChildren = className === config.initialState && config.children;
+    const stateNode = analyzeStateNodeWithNesting(
+      className,
+      classSymbol,
+      sourceFile,
+      hasChildren ? config.children : void 0,
+      verbose
+    );
     fullChart.states[className] = stateNode;
   }
   if (verbose) {
@@ -539,6 +701,16 @@ function extractStateNode(stateInstance) {
         transition.actions = meta.actions.map((a) => a.name);
       }
       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;
+      }
+      stateNode.on[key] = transition;
     }
   }
   if (invoke2.length > 0) {
@@ -797,9 +969,1055 @@ function createMutableMachine(sharedContext, factories, getDiscriminant) {
   });
 }
 
+// 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 });
+    }
+    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.`);
+    }
+    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);
+      }
+      (_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);
+    };
+  }
+  for (const key in transitions2) {
+    const transitionFn = transitions2[key];
+    combinedTransitions[key] = (...args) => {
+      const nextM2 = transitionFn.apply(m2.context, args);
+      return createParallelMachine(m1, nextM2);
+    };
+  }
+  return {
+    context: combinedContext,
+    ...combinedTransitions
+  };
+}
+
+// src/middleware.ts
+var CANCEL = Symbol("CANCEL");
+function createMiddleware(machine, hooks, options = {}) {
+  const { mode = "auto", exclude = ["context"] } = options;
+  const wrapped = {};
+  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 (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}`
+            );
+          }
+        }
+        return result;
+      } catch (err) {
+        if (hooks.error) {
+          const middlewareError = {
+            transitionName,
+            context,
+            args,
+            error: err
+          };
+          const errorResult = hooks.error(middlewareError);
+          if (errorResult instanceof Promise) {
+            errorResult.catch(() => {
+            });
+            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;
+          }
+        }
+        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;
+          }
+        }
+        throw err;
+      }
+    };
+    if (mode === "async") {
+      return executeAsyncTransition();
+    } else if (mode === "sync") {
+      return executeSyncTransition();
+    } else {
+      return executeSyncTransition();
+    }
+  };
+}
+function withLogging(machine, options = {}) {
+  const {
+    logger = console.log,
+    includeContext = true,
+    includeArgs = true
+  } = options;
+  return createMiddleware(machine, {
+    before: ({ transitionName, args }) => {
+      const argsStr = includeArgs && args.length > 0 ? ` ${JSON.stringify(args)}` : "";
+      logger(`→ ${transitionName}${argsStr}`);
+    },
+    after: ({ transitionName, nextContext }) => {
+      const contextStr = includeContext ? ` ${JSON.stringify(nextContext)}` : "";
+      logger(`✓ ${transitionName}${contextStr}`);
+    }
+  });
+}
+function withAnalytics(machine, track, options = {}) {
+  const {
+    eventPrefix = "state_transition",
+    includePrevContext = false,
+    includeArgs = true
+  } = 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);
+    }
+  }, { mode: "async" });
+}
+function withValidation(machine, validate, options) {
+  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;
+        });
+      }
+      if (result === false) {
+        throw new Error(`Validation failed for transition: ${ctx.transitionName}`);
+      }
+      return void 0;
+    }
+  }, { mode: "auto", ...options });
+}
+function withPermissions(machine, canPerform, options) {
+  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) {
+        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;
+  return createMiddleware(machine, {
+    error: async ({ transitionName, context, args, error }) => {
+      const errorContext = {
+        transition: transitionName
+      };
+      if (includeContext) {
+        errorContext.context = context;
+      }
+      if (includeArgs && args.length > 0) {
+        errorContext.args = args;
+      }
+      await Promise.resolve(captureError(error, errorContext));
+    }
+  }, { mode });
+}
+function withPerformanceMonitoring(machine, onMetric) {
+  const timings = /* @__PURE__ */ new Map();
+  return createMiddleware(machine, {
+    before: ({ transitionName }) => {
+      timings.set(transitionName, performance.now());
+      return void 0;
+    },
+    after: ({ transitionName, nextContext }) => {
+      const startTime = timings.get(transitionName);
+      if (startTime) {
+        const duration = performance.now() - startTime;
+        timings.delete(transitionName);
+        const result = onMetric({ transitionName, duration, context: nextContext });
+        if (result instanceof Promise) {
+          return result;
+        }
+      }
+      return void 0;
+    }
+  }, { mode: "auto" });
+}
+function withRetry(machine, options = {}) {
+  const {
+    maxRetries = 3,
+    delay = 1e3,
+    backoffMultiplier = 1,
+    shouldRetry = () => true,
+    onRetry
+  } = options;
+  const wrapped = {};
+  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;
+          }
+          onRetry == null ? void 0 : onRetry(attempt + 1, lastError);
+          const currentDelay = delay * Math.pow(backoffMultiplier, attempt);
+          await new Promise((resolve) => setTimeout(resolve, currentDelay));
+        }
+      }
+      throw lastError;
+    };
+  }
+  return wrapped;
+}
+function withHistory(machine, options = {}) {
+  const {
+    maxSize,
+    serializer,
+    filter,
+    onEntry,
+    _isRewrap = false
+  } = 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) {
+        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();
+      }
+      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: () => {
+      history.length = 0;
+      entryId = 0;
+    }
+  });
+}
+function withSnapshot(machine, options = {}) {
+  const {
+    maxSize,
+    serializer,
+    captureSnapshot,
+    onlyIfChanged = false,
+    filter,
+    onSnapshot,
+    _extraExclusions = [],
+    _isRewrap = false
+  } = options;
+  const snapshots = [];
+  let snapshotId = 0;
+  const instrumentedMachine = createMiddleware(machine, {
+    after: ({ transitionName, prevContext, nextContext }) => {
+      if (filter && !filter(transitionName)) {
+        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) {
+        try {
+          snapshot.serializedBefore = serializer.serialize(prevContext);
+          snapshot.serializedAfter = serializer.serialize(nextContext);
+        } catch (err) {
+          console.error("Failed to serialize snapshot:", err);
+        }
+      }
+      if (captureSnapshot) {
+        try {
+          snapshot.diff = captureSnapshot(prevContext, nextContext);
+        } 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);
+    }
+  }, { exclude: ["context", "snapshots", "clearSnapshots", "restoreSnapshot", ..._extraExclusions] });
+  const restoreSnapshot = (context) => {
+    const { context: _, ...transitions } = machine;
+    return { 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: () => {
+      snapshots.length = 0;
+      snapshotId = 0;
+    },
+    restoreSnapshot
+  });
+}
+function withTimeTravel(machine, options = {}) {
+  const { maxSize, serializer, onRecord } = options;
+  const history = [];
+  const snapshots = [];
+  let entryId = 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);
+      }
+    }
+    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);
+      }
+    }
+    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") {
+        try {
+          current = transition.apply(current.context, entry.args);
+        } catch (err) {
+          console.error(`Replay failed at step ${i}:`, err);
+          throw err;
+        }
+      }
+    }
+    return current;
+  };
+  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;
+        };
+      }
+    }
+    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 wrapMachine(machine);
+}
+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;
+  }
+  /**
+   * Add a middleware to the composition chain.
+   * @param middleware - The middleware function to add
+   * @returns A new composer with the middleware applied
+   */
+  with(middleware) {
+    const result = middleware(this.machine);
+    return new _MiddlewareChainBuilder(result);
+  }
+  /**
+   * Build the final machine with all middlewares applied.
+   */
+  build() {
+    return this.machine;
+  }
+};
+function withDebugging(machine) {
+  return withTimeTravel(withSnapshot(withHistory(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 createMiddlewareRegistry() {
+  const registry = /* @__PURE__ */ new Map();
+  return {
+    /**
+     * Register a middleware with a name and optional metadata.
+     */
+    register(name, middleware, description, priority) {
+      if (registry.has(name)) {
+        throw new Error(`Middleware '${name}' is already registered`);
+      }
+      registry.set(name, { name, middleware, description, priority });
+      return this;
+    },
+    /**
+     * Unregister a middleware by name.
+     */
+    unregister(name) {
+      return registry.delete(name);
+    },
+    /**
+     * Check if a middleware is registered.
+     */
+    has(name) {
+      return registry.has(name);
+    },
+    /**
+     * Get a registered middleware by name.
+     */
+    get(name) {
+      return registry.get(name);
+    },
+    /**
+     * List all registered middlewares.
+     */
+    list() {
+      return Array.from(registry.values()).sort((a, b) => {
+        var _a, _b;
+        return ((_a = a.priority) != null ? _a : 0) - ((_b = b.priority) != null ? _b : 0);
+      });
+    },
+    /**
+     * Apply a selection of registered middlewares to a machine.
+     * Middlewares are applied in priority order (lowest to highest).
+     */
+    apply(machine, middlewareNames) {
+      const middlewares = middlewareNames.map((name) => {
+        const entry = registry.get(name);
+        if (!entry) {
+          throw new Error(`Middleware '${name}' is not registered`);
+        }
+        return entry;
+      }).sort((a, b) => {
+        var _a, _b;
+        return ((_a = a.priority) != null ? _a : 0) - ((_b = b.priority) != null ? _b : 0);
+      });
+      return composeTyped(machine, ...middlewares.map((m) => m.middleware));
+    },
+    /**
+     * Apply all registered middlewares to a machine in priority order.
+     */
+    applyAll(machine) {
+      const middlewares = this.list();
+      return composeTyped(machine, ...middlewares.map((m) => m.middleware));
+    }
+  };
+}
+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 combine(...middlewares) {
+  return (machine) => composeTyped(machine, ...middlewares);
+}
+function branch(branches, fallback) {
+  return (machine) => {
+    for (const [predicate, middleware] of branches) {
+      if (predicate(machine)) {
+        return middleware(machine);
+      }
+    }
+    return fallback ? fallback(machine) : machine;
+  };
+}
+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";
+}
+
+// src/utils.ts
+function isState(machine, machineClass) {
+  return machine instanceof machineClass;
+}
+function createEvent(type, ...args) {
+  return { type, args };
+}
+function mergeContext(machine, partialContext) {
+  return setContext(machine, (ctx) => ({ ...ctx, ...partialContext }));
+}
+async function pipeTransitions(initialMachine, ...transitions) {
+  let current = initialMachine;
+  for (const transitionFn of transitions) {
+    current = await transitionFn(current);
+  }
+  return current;
+}
+function logState(machine, label) {
+  if (label) {
+    console.log(label, machine.context);
+  } else {
+    console.log(machine.context);
+  }
+  return machine;
+}
+function call(fn, context, ...args) {
+  return fn.apply(context, args);
+}
+function bindTransitions(machine) {
+  return new Proxy(machine, {
+    get(target, prop) {
+      const value = target[prop];
+      if (typeof value === "function") {
+        return function(...args) {
+          const result = value.apply(target.context, args);
+          if (result && typeof result === "object" && "context" in result) {
+            return bindTransitions(result);
+          }
+          return result;
+        };
+      }
+      return value;
+    }
+  });
+}
+var BoundMachine = class _BoundMachine {
+  constructor(machine) {
+    this.wrappedMachine = machine;
+    return new Proxy(this, {
+      get: (target, prop) => {
+        if (prop === "wrappedMachine") {
+          return Reflect.get(target, prop);
+        }
+        if (prop === "context") {
+          return this.wrappedMachine.context;
+        }
+        const value = this.wrappedMachine[prop];
+        if (typeof value === "function") {
+          return (...args) => {
+            const result = value.apply(this.wrappedMachine.context, args);
+            if (result && typeof result === "object" && "context" in result) {
+              return new _BoundMachine(result);
+            }
+            return result;
+          };
+        }
+        return value;
+      }
+    });
+  }
+};
+
 // src/index.ts
 function createMachine(context, fns) {
-  return Object.assign({ context }, fns);
+  const transitions = "context" in fns ? Object.fromEntries(
+    Object.entries(fns).filter(([key]) => key !== "context")
+  ) : fns;
+  const machine = Object.assign({ context }, transitions);
+  return machine;
 }
 function createAsyncMachine(context, fns) {
   return Object.assign({ context }, fns);
@@ -835,6 +2053,17 @@ function extendTransitions(machine, newTransitions) {
   const combinedTransitions = { ...originalTransitions, ...newTransitions };
   return createMachine(context, combinedTransitions);
 }
+function combineFactories(factory1, factory2) {
+  return (...args) => {
+    const machine1 = factory1(...args);
+    const machine2 = factory2();
+    const combinedContext = { ...machine1.context, ...machine2.context };
+    const { context: _, ...transitions1 } = machine1;
+    const { context: __, ...transitions2 } = machine2;
+    const combinedTransitions = { ...transitions1, ...transitions2 };
+    return createMachine(combinedContext, combinedTransitions);
+  };
+}
 function createMachineBuilder(templateMachine) {
   const { context, ...transitions } = templateMachine;
   return (newContext) => {
@@ -854,15 +2083,32 @@ function hasState(machine, key, value) {
 }
 function runMachine(initial, onChange) {
   let current = initial;
+  let activeController = null;
   async function dispatch(event) {
+    if (activeController) {
+      activeController.abort();
+      activeController = null;
+    }
     const fn = current[event.type];
     if (typeof fn !== "function") {
       throw new Error(`[Machine] Unknown event type '${String(event.type)}' on current state.`);
     }
-    const nextState = await fn.apply(current.context, event.args);
-    current = nextState;
-    onChange == null ? void 0 : onChange(current);
-    return current;
+    const controller = new AbortController();
+    activeController = controller;
+    try {
+      const nextStatePromise = fn.apply(current.context, [...event.args, { signal: controller.signal }]);
+      const nextState = await nextStatePromise;
+      if (controller.signal.aborted) {
+        return current;
+      }
+      current = nextState;
+      onChange == null ? void 0 : onChange(current);
+      return current;
+    } finally {
+      if (activeController === controller) {
+        activeController = null;
+      }
+    }
   }
   return {
     /** Gets the context of the current state of the machine. */
@@ -870,7 +2116,14 @@ function runMachine(initial, onChange) {
       return current.context;
     },
     /** Dispatches a type-safe event to the machine, triggering a transition. */
-    dispatch
+    dispatch,
+    /** Stops any pending async operation and cleans up resources. */
+    stop: () => {
+      if (activeController) {
+        activeController.abort();
+        activeController = null;
+      }
+    }
   };
 }
 var MachineBase = class {