@doeixd/machine 0.0.21 → 0.0.23

package/dist/esm/development/react.js

@@ -0,0 +1,1955 @@
+// src/generators.ts
+function run(flow, initial) {
+  const generator = flow(initial);
+  let current = initial;
+  while (true) {
+    const { value, done } = generator.next(current);
+    if (done) {
+      return value;
+    }
+    current = value;
+  }
+}
+function step(m) {
+  return function* () {
+    const received = yield m;
+    return received;
+  }();
+}
+function yieldMachine(m) {
+  return m;
+}
+function runSequence(initial, flows) {
+  return flows.reduce((machine, flow) => {
+    return run(flow, machine);
+  }, initial);
+}
+function createFlow(flow) {
+  return flow;
+}
+function runWithDebug(flow, initial, logger = (step2, m) => {
+  console.log(`Step ${step2}:`, m.context);
+}) {
+  const generator = flow(initial);
+  let current = initial;
+  let stepCount = 0;
+  logger(stepCount, current);
+  while (true) {
+    const { value, done } = generator.next(current);
+    if (done) {
+      console.log("Final:", value);
+      return value;
+    }
+    current = value;
+    stepCount++;
+    logger(stepCount, current);
+  }
+}
+async function runAsync(flow, initial) {
+  const generator = flow(initial);
+  let current = initial;
+  while (true) {
+    const { value, done } = await generator.next(current);
+    if (done) {
+      return value;
+    }
+    current = value;
+  }
+}
+async function* stepAsync(m) {
+  const received = yield m;
+  return received;
+}
+
+// src/primitives.ts
+var META_KEY = Symbol("MachineMeta");
+var RUNTIME_META = Symbol("__machine_runtime_meta__");
+function attachRuntimeMeta(fn, metadata2) {
+  const existing = fn[RUNTIME_META] || {};
+  const merged = { ...existing, ...metadata2 };
+  if (metadata2.guards && existing.guards) {
+    merged.guards = [...metadata2.guards, ...existing.guards];
+  } else if (metadata2.guards) {
+    merged.guards = [...metadata2.guards];
+  }
+  if (metadata2.actions && existing.actions) {
+    merged.actions = [...metadata2.actions, ...existing.actions];
+  } else if (metadata2.actions) {
+    merged.actions = [...metadata2.actions];
+  }
+  Object.defineProperty(fn, RUNTIME_META, {
+    value: merged,
+    enumerable: false,
+    writable: false,
+    configurable: true
+    // CRITICAL: Must be configurable for re-definition
+  });
+}
+function transitionTo(_target, implementation) {
+  attachRuntimeMeta(implementation, {
+    target: _target.name || _target.toString()
+  });
+  return implementation;
+}
+function describe(_text, transition) {
+  attachRuntimeMeta(transition, {
+    description: _text
+  });
+  return transition;
+}
+function guarded(guard2, transition) {
+  attachRuntimeMeta(transition, {
+    guards: [guard2]
+  });
+  return transition;
+}
+function invoke(service, implementation) {
+  attachRuntimeMeta(implementation, {
+    invoke: {
+      src: service.src,
+      onDone: service.onDone.name || service.onDone.toString(),
+      onError: service.onError.name || service.onError.toString(),
+      description: service.description
+    }
+  });
+  return implementation;
+}
+function action(action2, transition) {
+  attachRuntimeMeta(transition, {
+    actions: [action2]
+  });
+  return transition;
+}
+function guard(condition, transition, options = {}) {
+  const { onFail = "throw", errorMessage, description } = options;
+  const fullOptions = { ...options, onFail, errorMessage, description };
+  const guardedTransition = function(...args) {
+    const isMachine = typeof this === "object" && "context" in this;
+    const ctx = isMachine ? this.context : this;
+    const conditionResult = 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 || "Synchronous guarded transition",
+    guards: [{ name: "runtime_guard", description: description || "Synchronous condition check" }]
+  });
+  return guardedTransition;
+}
+function guardAsync(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 whenGuardAsync(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 = guardAsync(condition, transition);
+      guarded2.else = function(fallback) {
+        return guardAsync(condition, transition, { onFail: fallback });
+      };
+      return guarded2;
+    }
+  };
+}
+function metadata(_meta, value) {
+  return value;
+}
+
+// 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();
+  }
+  return result.value;
+}
+function runWithEnsemble(flow, ensemble) {
+  const generator = flow(ensemble);
+  let result = generator.next();
+  while (!result.done) {
+    result = generator.next();
+  }
+  return result.value;
+}
+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();
+  }
+  /**
+   * 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];
+      }
+      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
+        };
+      }
+      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];
+      }
+      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";
+    }
+  });
+}
+
+// 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/core.ts
+var CANCEL = Symbol("CANCEL");
+function createMiddleware(machine, hooks, options = {}) {
+  const { continueOnError = false, logErrors = true, onError } = options;
+  const wrappedMachine = { ...machine };
+  for (const prop in machine) {
+    if (!Object.prototype.hasOwnProperty.call(machine, prop)) continue;
+    if (prop !== "context" && typeof machine[prop] !== "function") {
+      wrappedMachine[prop] = machine[prop];
+    }
+  }
+  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;
+          }
+          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;
+          };
+          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;
+            });
+            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;
+          }
+        };
+        if (hooks.before) {
+          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 });
+          }
+        }
+        ;
+        return executeTransition();
+      };
+    }
+  }
+  return wrappedMachine;
+}
+function withLogging(machine, options = {}) {
+  const { logger = console.log, includeArgs = false, includeContext = true } = options;
+  return createMiddleware(machine, {
+    before: ({ transitionName, args }) => {
+      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 = false } = options;
+  return createMiddleware(machine, {
+    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);
+    }
+  });
+}
+function withValidation(machine, validator) {
+  return createMiddleware(machine, {
+    before: (ctx) => {
+      const result = validator(ctx);
+      if (result === false) {
+        throw new Error(`Validation failed for transition: ${ctx.transitionName}`);
+      }
+    }
+  });
+}
+function withPermissions(machine, checker) {
+  return createMiddleware(machine, {
+    before: (ctx) => {
+      if (!checker(ctx)) {
+        throw new Error(`Unauthorized transition: ${ctx.transitionName}`);
+      }
+    }
+  });
+}
+function withErrorReporting(machine, reporter, options = {}) {
+  const { includeArgs = false } = options;
+  return createMiddleware(machine, {
+    error: (errorCtx) => {
+      const formattedCtx = {
+        transition: errorCtx.transitionName,
+        context: errorCtx.context,
+        ...includeArgs && { args: errorCtx.args }
+      };
+      reporter(errorCtx.error, formattedCtx);
+    }
+  });
+}
+function withPerformanceMonitoring(machine, tracker) {
+  const startTimes = /* @__PURE__ */ new Map();
+  return createMiddleware(machine, {
+    before: (ctx) => {
+      startTimes.set(ctx.transitionName, Date.now());
+    },
+    after: (result) => {
+      const startTime = startTimes.get(result.transitionName);
+      if (startTime) {
+        const duration = Date.now() - startTime;
+        startTimes.delete(result.transitionName);
+        const testResult = {
+          transitionName: result.transitionName,
+          duration,
+          context: result.nextContext || result.prevContext
+        };
+        tracker(testResult);
+      }
+    }
+  });
+}
+function withRetry(machine, options = {}) {
+  var _a, _b;
+  const {
+    maxAttempts = (_a = options.maxRetries) != null ? _a : 3,
+    shouldRetry = () => true,
+    backoffMs = (_b = options.delay) != null ? _b : 100,
+    backoffMultiplier = 2,
+    onRetry
+  } = options;
+  const wrappedMachine = { ...machine };
+  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] = 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;
+            }
+          }
+        }
+        throw lastError;
+      };
+    }
+  }
+  return wrappedMachine;
+}
+function createCustomMiddleware(hooks, options) {
+  return (machine) => createMiddleware(machine, hooks, options);
+}
+
+// src/middleware/history.ts
+function withHistory(machine, options = {}) {
+  const { maxSize, serializer, onEntry } = options;
+  const history = [];
+  let entryId = 0;
+  const instrumentedMachine = createMiddleware(machine, {
+    before: ({ 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();
+      }
+      onEntry == null ? void 0 : onEntry(entry);
+    }
+  });
+  return Object.assign(instrumentedMachine, {
+    history,
+    clearHistory: () => {
+      history.length = 0;
+      entryId = 0;
+    }
+  });
+}
+
+// src/middleware/snapshot.ts
+function withSnapshot(machine, options = {}) {
+  const {
+    maxSize,
+    serializer,
+    captureSnapshot,
+    onlyOnChange = false
+  } = options;
+  const snapshots = [];
+  let snapshotId = 0;
+  const instrumentedMachine = createMiddleware(machine, {
+    after: ({ transitionName, prevContext, nextContext }) => {
+      if (onlyOnChange && JSON.stringify(prevContext) === JSON.stringify(nextContext)) {
+        return;
+      }
+      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);
+        }
+      }
+      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();
+      }
+    }
+  });
+  const restoreSnapshot = (context) => {
+    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);
+  };
+  return Object.assign(instrumentedMachine, {
+    snapshots,
+    clearSnapshots: () => {
+      snapshots.length = 0;
+      snapshotId = 0;
+    },
+    restoreSnapshot
+  });
+}
+
+// src/middleware/time-travel.ts
+function withTimeTravel(machine, options = {}) {
+  const { maxSize, serializer, onRecord } = options;
+  const history = [];
+  const snapshots = [];
+  let historyId = 0;
+  let snapshotId = 0;
+  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);
+    },
+    after: ({ 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 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 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 replayedMachine;
+  };
+  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 composeTyped(machine, ...middlewares) {
+  return middlewares.reduce((acc, middleware) => middleware(acc), 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 chain(machine) {
+  return new MiddlewareChainBuilder(machine);
+}
+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 by name.
+     */
+    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 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 };
+  };
+}
+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 && (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
+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 createTransition(getTransitions, transformer) {
+  return function(...args) {
+    const nextContext = transformer(this.context, ...args);
+    return createMachine(nextContext, getTransitions());
+  };
+}
+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/functional-combinators.ts
+function createTransitionFactory() {
+  return function createTransition2(transformer) {
+    return function(...args) {
+      const nextContext = transformer(this.context, ...args);
+      return createMachine(nextContext, this);
+    };
+  };
+}
+function createTransitionExtender(machine) {
+  return {
+    machine,
+    addTransition: function(name, transformer) {
+      const transitionFn = function(...args) {
+        const nextContext = transformer(this.context, ...args);
+        return createMachine(nextContext, this);
+      };
+      const newMachine = extendTransitions(machine, { [name]: transitionFn });
+      return createTransitionExtender(newMachine);
+    }
+  };
+}
+function createFunctionalMachine(initialContext) {
+  return function withTransitions(transformers) {
+    const transitions = {};
+    const machineTransitions = Object.fromEntries(
+      Object.entries(transformers).map(([key, transformer]) => [
+        key,
+        function(...args) {
+          const nextContext = transformer(this.context, ...args);
+          return createMachine(nextContext, transitions);
+        }
+      ])
+    );
+    Object.assign(transitions, machineTransitions);
+    return createMachine(initialContext, transitions);
+  };
+}
+function state(context, transitions) {
+  if (transitions !== void 0) {
+    return createMachine(context, transitions);
+  }
+  return createFunctionalMachine(context);
+}
+
+// src/index.ts
+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, 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) => {
+    const fns = Object.fromEntries(
+      Object.entries(transformers).map(([key, transform]) => [
+        key,
+        function(...args) {
+          const newContext = transform(this.context, ...args);
+          return createMachine(newContext, fns);
+        }
+      ])
+    );
+    return (initialContext) => {
+      return createMachine(initialContext, fns);
+    };
+  };
+}
+function setContext(machine, newContextOrFn) {
+  const { context, ...transitions } = machine;
+  const newContext = typeof newContextOrFn === "function" ? newContextOrFn(context) : newContextOrFn;
+  return createMachine(newContext, transitions);
+}
+function overrideTransitions(machine, overrides) {
+  const { context, ...originalTransitions } = machine;
+  const newTransitions = { ...originalTransitions, ...overrides };
+  return createMachine(context, newTransitions);
+}
+function extendTransitions(machine, newTransitions) {
+  const { context, ...originalTransitions } = machine;
+  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) => {
+    return createMachine(newContext, transitions);
+  };
+}
+function matchMachine(machine, discriminantKey, handlers) {
+  const discriminant = machine.context[discriminantKey];
+  const handler = handlers[discriminant];
+  if (!handler) {
+    throw new Error(`No handler found for state: ${String(discriminant)}`);
+  }
+  return handler(machine.context);
+}
+function hasState(machine, key, value) {
+  return machine.context[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 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. */
+    get state() {
+      return current.context;
+    },
+    /** Dispatches a type-safe event to the machine, triggering a transition. */
+    dispatch,
+    /** Stops any pending async operation and cleans up resources. */
+    stop: () => {
+      if (activeController) {
+        activeController.abort();
+        activeController = null;
+      }
+    }
+  };
+}
+var MachineBase = class {
+  /**
+   * Initializes a new machine instance with its starting context.
+   * @param context - The initial state of the machine.
+   */
+  constructor(context) {
+    this.context = context;
+  }
+};
+function next(m, update) {
+  const { context, ...transitions } = m;
+  return createMachine(update(context), transitions);
+}
+
+// src/react.ts
+import {
+  useState,
+  useRef,
+  useEffect,
+  useMemo,
+  createContext,
+  useContext,
+  createElement,
+  useSyncExternalStore
+} from "react";
+function useMachine(machineFactory) {
+  const [machine, setMachine] = useState(machineFactory);
+  const runner = useMemo(
+    () => runMachine(machine, (newState) => {
+      setMachine(newState);
+    }),
+    []
+  );
+  const actions = useMemo(() => {
+    return new Proxy({}, {
+      get: (_target, prop) => {
+        return (...args) => {
+          runner.dispatch({ type: prop, args });
+        };
+      }
+    });
+  }, [runner]);
+  return [machine, actions];
+}
+function useMachineSelector(machine, selector, isEqual = Object.is) {
+  const [selectedValue, setSelectedValue] = useState(() => selector(machine));
+  const selectorRef = useRef(selector);
+  const isEqualRef = useRef(isEqual);
+  selectorRef.current = selector;
+  isEqualRef.current = isEqual;
+  useEffect(() => {
+    const nextValue = selectorRef.current(machine);
+    if (!isEqualRef.current(selectedValue, nextValue)) {
+      setSelectedValue(nextValue);
+    }
+  }, [machine, selectedValue]);
+  return selectedValue;
+}
+function useEnsemble(initialContext, factories, getDiscriminant) {
+  const [context, setContext2] = useState(initialContext);
+  const contextRef = useRef(context);
+  contextRef.current = context;
+  const store = useMemo(
+    () => ({
+      // getContext reads from the ref to ensure it always has the latest value,
+      // avoiding stale closures.
+      getContext: () => contextRef.current,
+      setContext: (newContext) => {
+        setContext2(newContext);
+      }
+    }),
+    []
+    // The store itself is stable and created only once.
+  );
+  const ensemble = useMemo(
+    () => createEnsemble(store, factories, getDiscriminant),
+    [store, factories, getDiscriminant]
+  );
+  return ensemble;
+}
+function createMachineContext() {
+  const Context3 = createContext(null);
+  const Provider = ({
+    machine,
+    actions,
+    children
+  }) => {
+    const value = useMemo(() => [machine, actions], [machine, actions]);
+    return createElement(Context3.Provider, { value }, children);
+  };
+  const useMachineContext = () => {
+    const context = useContext(Context3);
+    if (!context) {
+      throw new Error("useMachineContext must be used within a Machine.Provider");
+    }
+    return context;
+  };
+  const useMachineState = () => useMachineContext()[0];
+  const useMachineActions = () => useMachineContext()[1];
+  const useSelector = (selector, isEqual) => {
+    const machine = useMachineState();
+    return useMachineSelector(machine, selector, isEqual);
+  };
+  return {
+    Provider,
+    useMachineContext,
+    useMachineState,
+    useMachineActions,
+    useSelector
+  };
+}
+function useActor(actor) {
+  const subscribe = useMemo(() => actor.subscribe.bind(actor), [actor]);
+  const getSnapshot = useMemo(() => actor.getSnapshot.bind(actor), [actor]);
+  return useSyncExternalStore(subscribe, getSnapshot);
+}
+function useActorSelector(actor, selector, isEqual = Object.is) {
+  const subscribe = useMemo(() => actor.subscribe.bind(actor), [actor]);
+  const getSnapshot = useMemo(() => actor.getSnapshot.bind(actor), [actor]);
+  const getSelection = () => selector(getSnapshot());
+  const [selection, setSelection] = useState(getSelection);
+  useEffect(() => {
+    const checkUpdate = () => {
+      const nextSelection = selector(actor.getSnapshot());
+      setSelection((prev) => isEqual(prev, nextSelection) ? prev : nextSelection);
+    };
+    checkUpdate();
+    return actor.subscribe(() => {
+      checkUpdate();
+    });
+  }, [actor, selector, isEqual]);
+  return selection;
+}
+export {
+  BoundMachine,
+  CANCEL,
+  META_KEY,
+  MachineBase,
+  MiddlewareBuilder,
+  MultiMachineBase,
+  action,
+  bindTransitions,
+  branch,
+  call,
+  chain,
+  combine,
+  combineFactories,
+  compose,
+  composeTyped,
+  createAsyncMachine,
+  createCustomMiddleware,
+  createEnsemble,
+  createEnsembleFactory,
+  createEvent,
+  createFetchMachine,
+  createFlow,
+  createFunctionalMachine,
+  createMachine,
+  createMachineBuilder,
+  createMachineContext,
+  createMachineFactory,
+  createMiddleware,
+  createMiddlewareFactory,
+  createMiddlewareRegistry,
+  createMultiMachine,
+  createMutableMachine,
+  createParallelMachine,
+  createPipeline,
+  createRunner,
+  createTransition,
+  createTransitionExtender,
+  createTransitionFactory,
+  delegateToChild,
+  describe,
+  extendTransitions,
+  guard,
+  guardAsync,
+  guarded,
+  hasState,
+  inDevelopment,
+  invoke,
+  isConditionalMiddleware,
+  isMiddlewareContext,
+  isMiddlewareError,
+  isMiddlewareFn,
+  isMiddlewareHooks,
+  isMiddlewareOptions,
+  isMiddlewareResult,
+  isNamedMiddleware,
+  isPipelineConfig,
+  isState,
+  logState,
+  matchMachine,
+  mergeContext,
+  metadata,
+  middlewareBuilder,
+  next,
+  overrideTransitions,
+  pipeTransitions,
+  run,
+  runAsync,
+  runMachine,
+  runSequence,
+  runWithDebug,
+  runWithEnsemble,
+  runWithRunner,
+  setContext,
+  state,
+  step,
+  stepAsync,
+  toggle,
+  transitionTo,
+  useActor,
+  useActorSelector,
+  useEnsemble,
+  useMachine,
+  useMachineSelector,
+  when,
+  whenContext,
+  whenGuard,
+  whenGuardAsync,
+  withAnalytics,
+  withDebugging,
+  withErrorReporting,
+  withHistory,
+  withLogging,
+  withPerformanceMonitoring,
+  withPermissions,
+  withRetry,
+  withSnapshot,
+  withTimeTravel,
+  withValidation,
+  yieldMachine
+};
+//# sourceMappingURL=react.js.map