@doeixd/machine 1.0.3 → 1.2.0

package/dist/cjs/development/index.js

@@ -67,11 +67,13 @@ __export(src_exports, {
   createTransitionExtender: () => createTransitionExtender,
   createTransitionFactory: () => createTransitionFactory,
   customCase: () => customCase,
+  delegate: () => delegate_exports,
   delegateToChild: () => delegateToChild,
   describe: () => describe,
   discriminantCase: () => discriminantCase,
   extendTransitions: () => extendTransitions,
   forContext: () => forContext,
+  freeze: () => freeze,
   fromObservable: () => fromObservable,
   fromPromise: () => fromPromise,
   guard: () => guard,
@@ -98,6 +100,7 @@ __export(src_exports, {
   mergeContext: () => mergeContext,
   metadata: () => metadata,
   middlewareBuilder: () => middlewareBuilder,
+  minimal: () => minimal_exports,
   next: () => next,
   overrideTransitions: () => overrideTransitions,
   pipeTransitions: () => pipeTransitions,
@@ -113,6 +116,7 @@ __export(src_exports, {
   state: () => state,
   step: () => step,
   stepAsync: () => stepAsync,
+  tag: () => tag,
   toggle: () => toggle,
   transitionTo: () => transitionTo,
   when: () => when,
@@ -136,19 +140,19 @@ module.exports = __toCommonJS(src_exports);
 
 // src/internal-transitions.ts
 var TRANSITIONS_SYMBOL = Symbol.for("__machine_transitions__");
-function attachTransitions(machine, transitions) {
-  Object.defineProperty(machine, TRANSITIONS_SYMBOL, {
+function attachTransitions(machine2, transitions) {
+  Object.defineProperty(machine2, TRANSITIONS_SYMBOL, {
     value: transitions,
     enumerable: false,
     configurable: false
   });
-  return machine;
+  return machine2;
 }
-function getStoredTransitions(machine) {
-  if (!machine || typeof machine !== "object") {
+function getStoredTransitions(machine2) {
+  if (!machine2 || typeof machine2 !== "object") {
     return void 0;
   }
-  return machine[TRANSITIONS_SYMBOL];
+  return machine2[TRANSITIONS_SYMBOL];
 }
 function snapshotOwnTransitions(source) {
   if (!source || typeof source !== "object") {
@@ -193,8 +197,8 @@ function yieldMachine(m) {
   return m;
 }
 function runSequence(initial, flows) {
-  return flows.reduce((machine, flow) => {
-    return run(flow, machine);
+  return flows.reduce((machine2, flow) => {
+    return run(flow, machine2);
   }, initial);
 }
 function createFlow(flow) {
@@ -449,13 +453,13 @@ function createEnsemble(store, factories, getDiscriminant) {
   const getCurrentMachine = () => {
     const context = store.getContext();
     const currentStateName = getDiscriminant(context);
-    const factory = factories[currentStateName];
-    if (!factory) {
+    const factory2 = factories[currentStateName];
+    if (!factory2) {
       throw new Error(
         `[Ensemble] Invalid state: No factory found for state "${String(currentStateName)}".`
       );
     }
-    return factory(context);
+    return factory2(context);
   };
   const actions = new Proxy({}, {
     get(_target, prop) {
@@ -601,13 +605,13 @@ function createMultiMachine(MachineClass, store) {
 function createMutableMachine(sharedContext, factories, getDiscriminant) {
   const getCurrentMachine = () => {
     const currentStateName = getDiscriminant(sharedContext);
-    const factory = factories[currentStateName];
-    if (!factory) {
+    const factory2 = factories[currentStateName];
+    if (!factory2) {
       throw new Error(
         `[MutableMachine] Invalid state: No factory for state "${String(currentStateName)}".`
       );
     }
-    return factory(sharedContext);
+    return factory2(sharedContext);
   };
   return new Proxy(sharedContext, {
     get(target, prop, _receiver) {
@@ -759,18 +763,18 @@ function createParallelMachine(m1, m2) {
 
 // src/middleware/core.ts
 var CANCEL = Symbol("CANCEL");
-function createMiddleware(machine, hooks, options = {}) {
+function createMiddleware(machine2, 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];
+  const wrappedMachine = { ...machine2 };
+  for (const prop in machine2) {
+    if (!Object.prototype.hasOwnProperty.call(machine2, prop)) continue;
+    if (prop !== "context" && typeof machine2[prop] !== "function") {
+      wrappedMachine[prop] = machine2[prop];
     }
   }
-  for (const prop in machine) {
-    if (!Object.prototype.hasOwnProperty.call(machine, prop)) continue;
-    const value = machine[prop];
+  for (const prop in machine2) {
+    if (!Object.prototype.hasOwnProperty.call(machine2, prop)) continue;
+    const value = machine2[prop];
     if (typeof value === "function" && prop !== "context") {
       wrappedMachine[prop] = function(...args) {
         const transitionName = prop;
@@ -796,23 +800,23 @@ function createMiddleware(machine, hooks, options = {}) {
             }
             throw error;
           }
-          const ensureMiddlewareProperties = (machine2) => {
-            if (machine2 && typeof machine2 === "object" && machine2.context) {
+          const ensureMiddlewareProperties = (machine3) => {
+            if (machine3 && typeof machine3 === "object" && machine3.context) {
               for (const prop2 in wrappedMachine) {
                 if (!Object.prototype.hasOwnProperty.call(wrappedMachine, prop2)) continue;
-                if (prop2 !== "context" && !(prop2 in machine2)) {
-                  machine2[prop2] = wrappedMachine[prop2];
+                if (prop2 !== "context" && !(prop2 in machine3)) {
+                  machine3[prop2] = wrappedMachine[prop2];
                 }
               }
-              for (const prop2 in machine2) {
-                if (!Object.prototype.hasOwnProperty.call(machine2, prop2)) continue;
-                const value2 = machine2[prop2];
+              for (const prop2 in machine3) {
+                if (!Object.prototype.hasOwnProperty.call(machine3, prop2)) continue;
+                const value2 = machine3[prop2];
                 if (typeof value2 === "function" && prop2 !== "context" && wrappedMachine[prop2]) {
-                  machine2[prop2] = wrappedMachine[prop2];
+                  machine3[prop2] = wrappedMachine[prop2];
                 }
               }
             }
-            return machine2;
+            return machine3;
           };
           if (nextMachine && typeof nextMachine.then === "function") {
             const asyncResult = nextMachine.then((resolvedMachine) => {
@@ -915,9 +919,9 @@ function createMiddleware(machine, hooks, options = {}) {
   }
   return wrappedMachine;
 }
-function withLogging(machine, options = {}) {
+function withLogging(machine2, options = {}) {
   const { logger = console.log, includeArgs = false, includeContext = true } = options;
-  return createMiddleware(machine, {
+  return createMiddleware(machine2, {
     before: ({ transitionName, args }) => {
       const message = includeArgs ? `→ ${transitionName} [${args.join(", ")}]` : `→ ${transitionName}`;
       logger(message);
@@ -931,9 +935,9 @@ function withLogging(machine, options = {}) {
     }
   });
 }
-function withAnalytics(machine, track, options = {}) {
+function withAnalytics(machine2, track, options = {}) {
   const { eventPrefix = "state_transition", includePrevContext = false, includeArgs = false } = options;
-  return createMiddleware(machine, {
+  return createMiddleware(machine2, {
     after: ({ transitionName, prevContext, nextContext, args }) => {
       const event = `${eventPrefix}.${transitionName}`;
       const data = { transition: transitionName };
@@ -944,8 +948,8 @@ function withAnalytics(machine, track, options = {}) {
     }
   });
 }
-function withValidation(machine, validator) {
-  return createMiddleware(machine, {
+function withValidation(machine2, validator) {
+  return createMiddleware(machine2, {
     before: (ctx) => {
       const result = validator(ctx);
       if (result === false) {
@@ -954,8 +958,8 @@ function withValidation(machine, validator) {
     }
   });
 }
-function withPermissions(machine, checker) {
-  return createMiddleware(machine, {
+function withPermissions(machine2, checker) {
+  return createMiddleware(machine2, {
     before: (ctx) => {
       if (!checker(ctx)) {
         throw new Error(`Unauthorized transition: ${ctx.transitionName}`);
@@ -963,9 +967,9 @@ function withPermissions(machine, checker) {
     }
   });
 }
-function withErrorReporting(machine, reporter, options = {}) {
+function withErrorReporting(machine2, reporter, options = {}) {
   const { includeArgs = false } = options;
-  return createMiddleware(machine, {
+  return createMiddleware(machine2, {
     error: (errorCtx) => {
       const formattedCtx = {
         transition: errorCtx.transitionName,
@@ -976,9 +980,9 @@ function withErrorReporting(machine, reporter, options = {}) {
     }
   });
 }
-function withPerformanceMonitoring(machine, tracker) {
+function withPerformanceMonitoring(machine2, tracker) {
   const startTimes = /* @__PURE__ */ new Map();
-  return createMiddleware(machine, {
+  return createMiddleware(machine2, {
     before: (ctx) => {
       startTimes.set(ctx.transitionName, Date.now());
     },
@@ -997,7 +1001,7 @@ function withPerformanceMonitoring(machine, tracker) {
     }
   });
 }
-function withRetry(machine, options = {}) {
+function withRetry(machine2, options = {}) {
   var _a, _b;
   const {
     maxAttempts = (_a = options.maxRetries) != null ? _a : 3,
@@ -1006,10 +1010,10 @@ function withRetry(machine, options = {}) {
     backoffMultiplier = 2,
     onRetry
   } = options;
-  const wrappedMachine = { ...machine };
-  for (const prop in machine) {
-    if (!Object.prototype.hasOwnProperty.call(machine, prop)) continue;
-    const value = machine[prop];
+  const wrappedMachine = { ...machine2 };
+  for (const prop in machine2) {
+    if (!Object.prototype.hasOwnProperty.call(machine2, prop)) continue;
+    const value = machine2[prop];
     if (typeof value === "function" && prop !== "context") {
       wrappedMachine[prop] = async function(...args) {
         let lastError;
@@ -1037,15 +1041,15 @@ function withRetry(machine, options = {}) {
   return wrappedMachine;
 }
 function createCustomMiddleware(hooks, options) {
-  return (machine) => createMiddleware(machine, hooks, options);
+  return (machine2) => createMiddleware(machine2, hooks, options);
 }
 
 // src/middleware/history.ts
-function withHistory(machine, options = {}) {
+function withHistory(machine2, options = {}) {
   const { maxSize, serializer, onEntry } = options;
   const history = [];
   let entryId = 0;
-  const instrumentedMachine = createMiddleware(machine, {
+  const instrumentedMachine = createMiddleware(machine2, {
     before: ({ transitionName, args }) => {
       const entry = {
         id: `entry-${entryId++}`,
@@ -1077,7 +1081,7 @@ function withHistory(machine, options = {}) {
 }
 
 // src/middleware/snapshot.ts
-function withSnapshot(machine, options = {}) {
+function withSnapshot(machine2, options = {}) {
   const {
     maxSize,
     serializer,
@@ -1086,7 +1090,7 @@ function withSnapshot(machine, options = {}) {
   } = options;
   const snapshots = [];
   let snapshotId = 0;
-  const instrumentedMachine = createMiddleware(machine, {
+  const instrumentedMachine = createMiddleware(machine2, {
     after: ({ transitionName, prevContext, nextContext }) => {
       if (onlyOnChange && JSON.stringify(prevContext) === JSON.stringify(nextContext)) {
         return;
@@ -1121,8 +1125,8 @@ function withSnapshot(machine, options = {}) {
   });
   const restoreSnapshot = (context) => {
     const transitions = Object.fromEntries(
-      Object.entries(machine).filter(
-        ([key]) => key !== "context" && key !== "snapshots" && key !== "clearSnapshots" && key !== "restoreSnapshot" && typeof machine[key] === "function"
+      Object.entries(machine2).filter(
+        ([key]) => key !== "context" && key !== "snapshots" && key !== "clearSnapshots" && key !== "restoreSnapshot" && typeof machine2[key] === "function"
       )
     );
     return Object.assign({ context }, transitions);
@@ -1138,13 +1142,13 @@ function withSnapshot(machine, options = {}) {
 }
 
 // src/middleware/time-travel.ts
-function withTimeTravel(machine, options = {}) {
+function withTimeTravel(machine2, options = {}) {
   const { maxSize, serializer, onRecord } = options;
   const history = [];
   const snapshots = [];
   let historyId = 0;
   let snapshotId = 0;
-  const instrumentedMachine = createMiddleware(machine, {
+  const instrumentedMachine = createMiddleware(machine2, {
     before: ({ transitionName, args }) => {
       const entry = {
         id: `entry-${historyId++}`,
@@ -1190,8 +1194,8 @@ function withTimeTravel(machine, options = {}) {
   });
   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"
+      Object.entries(machine2).filter(
+        ([key]) => key !== "context" && key !== "history" && key !== "snapshots" && key !== "clearHistory" && key !== "clearSnapshots" && key !== "restoreSnapshot" && key !== "clearTimeTravel" && key !== "replayFrom" && typeof machine2[key] === "function"
       )
     );
     return Object.assign({ context }, transitions);
@@ -1209,8 +1213,8 @@ function withTimeTravel(machine, options = {}) {
     const freshMachine = Object.assign(
       { context: currentContext },
       Object.fromEntries(
-        Object.entries(machine).filter(
-          ([key]) => key !== "context" && typeof machine[key] === "function"
+        Object.entries(machine2).filter(
+          ([key]) => key !== "context" && typeof machine2[key] === "function"
         )
       )
     );
@@ -1246,15 +1250,15 @@ function withTimeTravel(machine, options = {}) {
 }
 
 // src/middleware/composition.ts
-function compose(machine, ...middlewares) {
-  return middlewares.reduce((acc, middleware) => middleware(acc), machine);
+function compose(machine2, ...middlewares) {
+  return middlewares.reduce((acc, middleware) => middleware(acc), machine2);
 }
-function composeTyped(machine, ...middlewares) {
-  return middlewares.reduce((acc, middleware) => middleware(acc), machine);
+function composeTyped(machine2, ...middlewares) {
+  return middlewares.reduce((acc, middleware) => middleware(acc), machine2);
 }
 var MiddlewareChainBuilder = class _MiddlewareChainBuilder {
-  constructor(machine) {
-    this.machine = machine;
+  constructor(machine2) {
+    this.machine = machine2;
   }
   /**
    * Add a middleware to the composition chain.
@@ -1272,12 +1276,12 @@ var MiddlewareChainBuilder = class _MiddlewareChainBuilder {
     return this.machine;
   }
 };
-function chain(machine) {
-  return new MiddlewareChainBuilder(machine);
+function chain(machine2) {
+  return new MiddlewareChainBuilder(machine2);
 }
 function when(middleware, predicate) {
-  const conditional = function(machine) {
-    return predicate(machine) ? middleware(machine) : machine;
+  const conditional = function(machine2) {
+    return predicate(machine2) ? middleware(machine2) : machine2;
   };
   conditional.middleware = middleware;
   conditional.when = predicate;
@@ -1289,7 +1293,7 @@ function inDevelopment(middleware) {
   });
 }
 function whenContext(key, value, middleware) {
-  return when(middleware, (machine) => machine.context[key] === value);
+  return when(middleware, (machine2) => machine2.context[key] === value);
 }
 function createMiddlewareRegistry() {
   const registry = /* @__PURE__ */ new Map();
@@ -1335,7 +1339,7 @@ function createMiddlewareRegistry() {
      * Apply a selection of registered middlewares to a machine.
      * Middlewares are applied in priority order (lowest to highest).
      */
-    apply(machine, middlewareNames) {
+    apply(machine2, middlewareNames) {
       const middlewares = middlewareNames.map((name) => {
         const entry = registry.get(name);
         if (!entry) {
@@ -1346,14 +1350,14 @@ function createMiddlewareRegistry() {
         var _a, _b;
         return ((_a = a.priority) != null ? _a : 0) - ((_b = b.priority) != null ? _b : 0);
       });
-      return composeTyped(machine, ...middlewares.map((m) => m.middleware));
+      return composeTyped(machine2, ...middlewares.map((m) => m.middleware));
     },
     /**
      * Apply all registered middlewares to a machine in priority order.
      */
-    applyAll(machine) {
+    applyAll(machine2) {
       const middlewares = this.list();
-      return composeTyped(machine, ...middlewares.map((m) => m.middleware));
+      return composeTyped(machine2, ...middlewares.map((m) => m.middleware));
     }
   };
 }
@@ -1363,8 +1367,8 @@ function createPipeline(config = {}) {
     logErrors = true,
     onError
   } = config;
-  return (machine, ...middlewares) => {
-    let currentMachine = machine;
+  return (machine2, ...middlewares) => {
+    let currentMachine = machine2;
     const errors = [];
     let success = true;
     for (let i = 0; i < middlewares.length; i++) {
@@ -1398,16 +1402,16 @@ function createPipeline(config = {}) {
   };
 }
 function combine(...middlewares) {
-  return (machine) => composeTyped(machine, ...middlewares);
+  return (machine2) => composeTyped(machine2, ...middlewares);
 }
 function branch(branches, fallback) {
-  return (machine) => {
+  return (machine2) => {
     for (const [predicate, middleware] of branches) {
-      if (predicate(machine)) {
-        return middleware(machine);
+      if (predicate(machine2)) {
+        return middleware(machine2);
       }
     }
-    return fallback ? fallback(machine) : machine;
+    return fallback ? fallback(machine2) : machine2;
   };
 }
 function isMiddlewareFn(value) {
@@ -1452,85 +1456,85 @@ 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;
+  constructor(machine2) {
+    this.machine = machine2;
     this.middlewares = [];
   }
   /**
    * Add logging middleware with type-safe configuration.
    */
   withLogging(options) {
-    this.middlewares.push((machine) => withLogging(machine, options));
+    this.middlewares.push((machine2) => withLogging(machine2, options));
     return this;
   }
   /**
    * Add analytics middleware with type-safe configuration.
    */
   withAnalytics(track, options) {
-    this.middlewares.push((machine) => withAnalytics(machine, track, options));
+    this.middlewares.push((machine2) => withAnalytics(machine2, track, options));
     return this;
   }
   /**
    * Add validation middleware with type-safe configuration.
    */
   withValidation(validator, _options) {
-    this.middlewares.push((machine) => withValidation(machine, validator));
+    this.middlewares.push((machine2) => withValidation(machine2, validator));
     return this;
   }
   /**
    * Add permission checking middleware with type-safe configuration.
    */
   withPermissions(checker) {
-    this.middlewares.push((machine) => withPermissions(machine, checker));
+    this.middlewares.push((machine2) => withPermissions(machine2, checker));
     return this;
   }
   /**
    * Add error reporting middleware with type-safe configuration.
    */
   withErrorReporting(reporter, options) {
-    this.middlewares.push((machine) => withErrorReporting(machine, reporter, options));
+    this.middlewares.push((machine2) => withErrorReporting(machine2, reporter, options));
     return this;
   }
   /**
    * Add performance monitoring middleware with type-safe configuration.
    */
   withPerformanceMonitoring(tracker, _options) {
-    this.middlewares.push((machine) => withPerformanceMonitoring(machine, tracker));
+    this.middlewares.push((machine2) => withPerformanceMonitoring(machine2, tracker));
     return this;
   }
   /**
    * Add retry middleware with type-safe configuration.
    */
   withRetry(options) {
-    this.middlewares.push((machine) => withRetry(machine, options));
+    this.middlewares.push((machine2) => withRetry(machine2, options));
     return this;
   }
   /**
    * Add history tracking middleware with type-safe configuration.
    */
   withHistory(options) {
-    this.middlewares.push((machine) => withHistory(machine, options));
+    this.middlewares.push((machine2) => withHistory(machine2, options));
     return this;
   }
   /**
    * Add snapshot tracking middleware with type-safe configuration.
    */
   withSnapshot(options) {
-    this.middlewares.push((machine) => withSnapshot(machine, options));
+    this.middlewares.push((machine2) => withSnapshot(machine2, options));
     return this;
   }
   /**
    * Add time travel middleware with type-safe configuration.
    */
   withTimeTravel(options) {
-    this.middlewares.push((machine) => withTimeTravel(machine, options));
+    this.middlewares.push((machine2) => withTimeTravel(machine2, options));
     return this;
   }
   /**
    * Add debugging middleware (combination of history, snapshot, and time travel).
    */
   withDebugging() {
-    this.middlewares.push((machine) => withDebugging(machine));
+    this.middlewares.push((machine2) => withDebugging(machine2));
     return this;
   }
   /**
@@ -1571,13 +1575,13 @@ var MiddlewareBuilder = class {
     return this;
   }
 };
-function middlewareBuilder(machine) {
-  return new MiddlewareBuilder(machine);
+function middlewareBuilder(machine2) {
+  return new MiddlewareBuilder(machine2);
 }
 function createMiddlewareFactory(defaultOptions = {}) {
   return {
-    create: (machine) => {
-      const builder = middlewareBuilder(machine);
+    create: (machine2) => {
+      const builder = middlewareBuilder(machine2);
       if (defaultOptions.logging) {
         builder.withLogging(defaultOptions.logging);
       }
@@ -1603,8 +1607,8 @@ function createMiddlewareFactory(defaultOptions = {}) {
     }
   };
 }
-function withDebugging(machine) {
-  return withTimeTravel(withSnapshot(withHistory(machine)));
+function withDebugging(machine2) {
+  return withTimeTravel(withSnapshot(withHistory(machine2)));
 }
 
 // src/mixins.ts
@@ -1640,8 +1644,8 @@ function MachineUnion(...machines) {
       return result;
     };
   };
-  for (const machine of machines) {
-    const descriptors = getAllPropertyDescriptors(machine.prototype);
+  for (const machine2 of machines) {
+    const descriptors = getAllPropertyDescriptors(machine2.prototype);
     for (const [key, descriptor] of Object.entries(descriptors)) {
       if (key === "constructor") continue;
       if (typeof descriptor.value === "function") {
@@ -1706,14 +1710,14 @@ function machineExclude(source, ...excluded) {
 }
 
 // src/utils.ts
-function isState(machine, machineClass) {
-  return machine instanceof machineClass;
+function isState(machine2, machineClass) {
+  return machine2 instanceof machineClass;
 }
 function createEvent(type, ...args) {
   return { type, args };
 }
-function mergeContext(machine, partialContext) {
-  return setContext(machine, (ctx) => ({ ...ctx, ...partialContext }));
+function mergeContext(machine2, partialContext) {
+  return setContext(machine2, (ctx) => ({ ...ctx, ...partialContext }));
 }
 async function pipeTransitions(initialMachine, ...transitions) {
   let current = initialMachine;
@@ -1722,13 +1726,13 @@ async function pipeTransitions(initialMachine, ...transitions) {
   }
   return current;
 }
-function logState(machine, label) {
+function logState(machine2, label) {
   if (label) {
-    console.log(label, machine.context);
+    console.log(label, machine2.context);
   } else {
-    console.log(machine.context);
+    console.log(machine2.context);
   }
-  return machine;
+  return machine2;
 }
 function createTransition(getTransitions, transformer) {
   return function(...args) {
@@ -1736,11 +1740,11 @@ function createTransition(getTransitions, transformer) {
     return createMachine(nextContext, getTransitions());
   };
 }
-function call(fn, machine, ...args) {
-  return fn.apply(machine, args);
+function call(fn, machine2, ...args) {
+  return fn.apply(machine2, args);
 }
-function bindTransitions(machine) {
-  return new Proxy(machine, {
+function bindTransitions(machine2) {
+  return new Proxy(machine2, {
     get(target, prop) {
       const value = target[prop];
       if (typeof value === "function") {
@@ -1757,8 +1761,8 @@ function bindTransitions(machine) {
   });
 }
 var BoundMachine = class _BoundMachine {
-  constructor(machine) {
-    this.wrappedMachine = machine;
+  constructor(machine2) {
+    this.wrappedMachine = machine2;
     return new Proxy(this, {
       get: (target, prop) => {
         if (prop === "wrappedMachine") {
@@ -1792,15 +1796,15 @@ function createTransitionFactory() {
     };
   };
 }
-function createTransitionExtender(machine) {
+function createTransitionExtender(machine2) {
   return {
-    machine,
+    machine: machine2,
     addTransition: function(name, transformer) {
       const transitionFn = function(...args) {
         const nextContext = transformer(this.context, ...args);
         return createMachine(nextContext, this);
       };
-      const newMachine = extendTransitions(machine, { [name]: transitionFn });
+      const newMachine = extendTransitions(machine2, { [name]: transitionFn });
       return createTransitionExtender(newMachine);
     }
   };
@@ -1839,7 +1843,7 @@ function createMatcher(...cases) {
   }
   const isProxy = new Proxy({}, {
     get(_target, prop) {
-      return function isGuard(machine) {
+      return function isGuard(machine2) {
         const caseConfig = nameToCase.get(prop);
         if (!caseConfig) {
           const available = Array.from(nameToCase.keys()).join(", ");
@@ -1847,7 +1851,7 @@ function createMatcher(...cases) {
             `Unknown matcher case: "${prop}". Available cases: ${available}`
           );
         }
-        return caseConfig.predicate(machine);
+        return caseConfig.predicate(machine2);
       };
     }
   });
@@ -1871,7 +1875,7 @@ function createMatcher(...cases) {
     }
   });
   const exhaustive = { __exhaustive: true };
-  function when2(machine) {
+  function when2(machine2) {
     return {
       is(...handlers) {
         if (handlers.length === 0) {
@@ -1890,8 +1894,8 @@ function createMatcher(...cases) {
           if (!caseConfig) {
             throw new Error(`Internal error: Unknown matcher case in handler: ${caseName}`);
           }
-          if (caseConfig.predicate(machine)) {
-            return caseHandler.handler(machine);
+          if (caseConfig.predicate(machine2)) {
+            return caseHandler.handler(machine2);
           }
         }
         const handledCases = actualHandlers.map((h) => h.__name).join(", ");
@@ -1905,9 +1909,9 @@ This may occur if predicates don't cover all runtime possibilities.`
       }
     };
   }
-  function simpleMatcher(machine) {
+  function simpleMatcher(machine2) {
     for (const [name, _, predicate] of cases) {
-      if (predicate(machine)) {
+      if (predicate(machine2)) {
         return name;
       }
     }
@@ -2076,15 +2080,15 @@ var _Actor = class _Actor {
 // Global inspector
 _Actor._inspector = null;
 var Actor = _Actor;
-function createActor(machine) {
-  return new Actor(machine);
+function createActor(machine2) {
+  return new Actor(machine2);
 }
-function spawn(machine) {
-  return createActor(machine);
+function spawn(machine2) {
+  return createActor(machine2);
 }
 function fromPromise(promiseFn) {
   const initial = { status: "pending", data: void 0, error: void 0 };
-  const machine = createMachine(
+  const machine2 = createMachine(
     initial,
     (next2) => ({
       resolve(data) {
@@ -2095,13 +2099,13 @@ function fromPromise(promiseFn) {
       }
     })
   );
-  const actor = createActor(machine);
+  const actor = createActor(machine2);
   promiseFn().then((data) => actor.send.resolve(data)).catch((err) => actor.send.reject(err));
   return actor;
 }
 function fromObservable(observable) {
   const initial = { status: "active", value: void 0, error: void 0 };
-  const machine = createMachine(
+  const machine2 = createMachine(
     initial,
     (next2) => ({
       next(value) {
@@ -2115,7 +2119,7 @@ function fromObservable(observable) {
       }
     })
   );
-  const actor = createActor(machine);
+  const actor = createActor(machine2);
   observable.subscribe(
     (val) => actor.send.next(val),
     (err) => actor.send.error(err),
@@ -2150,19 +2154,240 @@ function createContextBoundMachine(initialContext, transformers) {
     boundTransitions
   );
 }
-function callWithContext(machine, transitionName, ...args) {
-  const fn = machine[transitionName];
-  const contextOnly = { context: machine.context };
+function callWithContext(machine2, transitionName, ...args) {
+  const fn = machine2[transitionName];
+  const contextOnly = { context: machine2.context };
   return fn.apply(contextOnly, args);
 }
-function isContextBound(machine) {
-  const firstTransition = Object.values(machine).find(
+function isContextBound(machine2) {
+  const firstTransition = Object.values(machine2).find(
     (v) => typeof v === "function"
   );
   if (!firstTransition) return false;
   return firstTransition.__contextBound === true;
 }
 
+// src/minimal.ts
+var minimal_exports = {};
+__export(minimal_exports, {
+  factory: () => factory,
+  freeze: () => freeze,
+  isState: () => isState2,
+  machine: () => machine,
+  match: () => match,
+  run: () => run2,
+  runnable: () => runnable,
+  tag: () => tag,
+  union: () => union,
+  withChildren: () => withChildren
+});
+
+// src/types.ts
+function tag(nameOrObj, props) {
+  if (typeof nameOrObj === "object") {
+    return nameOrObj;
+  }
+  if (props) {
+    return { ...props, tag: nameOrObj };
+  }
+  return { tag: nameOrObj };
+}
+((tag2) => {
+  function factory2(name) {
+    if (name) {
+      return (props) => tag2(name, props);
+    }
+    return (name2) => (props) => tag2(name2, props);
+  }
+  tag2.factory = factory2;
+})(tag || (tag = {}));
+function isState2(machine2, tagValue) {
+  return machine2.tag === tagValue;
+}
+function freeze(obj) {
+  Object.freeze(obj);
+  if (typeof Object.values === "function") {
+    for (const value of Object.values(obj)) {
+      if (value && typeof value === "object") {
+        freeze(value);
+      }
+    }
+  }
+  return obj;
+}
+
+// src/minimal.ts
+function machine(context, factory2) {
+  const next2 = (newContext) => machine(newContext, factory2);
+  const transitions = factory2(context, next2);
+  return Object.assign({}, context, transitions);
+}
+function match(state2, cases) {
+  const handler = cases[state2.tag];
+  return handler(state2);
+}
+var LIFECYCLE = Symbol("lifecycle");
+function runnable(initialMachine, lifecycles) {
+  const result = { ...initialMachine };
+  result[LIFECYCLE] = lifecycles;
+  return result;
+}
+function run2(initial) {
+  let current = initial;
+  let cleanup = null;
+  const listeners = /* @__PURE__ */ new Set();
+  const notify = () => {
+    listeners.forEach((fn) => fn(current));
+  };
+  const enter = () => {
+    if (cleanup) {
+      cleanup();
+      cleanup = null;
+    }
+    const lifecycles = current[LIFECYCLE];
+    const tagValue = current.tag;
+    const lifecycle = lifecycles == null ? void 0 : lifecycles[tagValue];
+    if (lifecycle == null ? void 0 : lifecycle.onEnter) {
+      cleanup = lifecycle.onEnter(send);
+    }
+  };
+  const send = (event, ...args) => {
+    const transition = current[event];
+    if (typeof transition === "function") {
+      const nextValue = transition(...args);
+      if (nextValue && typeof nextValue === "object" && "tag" in nextValue) {
+        const nextMachine = nextValue;
+        if (!nextMachine[LIFECYCLE] && current[LIFECYCLE]) {
+          nextMachine[LIFECYCLE] = current[LIFECYCLE];
+        }
+        current = nextMachine;
+        enter();
+        notify();
+      }
+    }
+  };
+  enter();
+  return {
+    get: () => current,
+    send,
+    stop: () => {
+      if (cleanup) {
+        cleanup();
+        cleanup = null;
+      }
+      listeners.clear();
+    },
+    subscribe: (listener) => {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    }
+  };
+}
+function withChildren(parent, children) {
+  const result = { ...parent };
+  for (const key of Object.keys(children)) {
+    const child = children[key];
+    const childProxy = new Proxy(child, {
+      get(target, prop) {
+        const value = target[prop];
+        if (typeof value === "function") {
+          return (...args) => {
+            const nextChild = value(...args);
+            return withChildren(
+              { ...parent },
+              { ...children, [key]: nextChild }
+            );
+          };
+        }
+        return value;
+      }
+    });
+    result[key] = childProxy;
+  }
+  return result;
+}
+function factory() {
+  return (transitionFactory) => (context) => machine(context, transitionFactory);
+}
+function union() {
+  return (factories) => {
+    const resultFactory = (context) => {
+      const factoryFn = factories[context.tag];
+      return machine(context, (ctx, _next) => factoryFn(ctx, resultFactory));
+    };
+    return resultFactory;
+  };
+}
+
+// src/delegate.ts
+var delegate_exports = {};
+__export(delegate_exports, {
+  createDelegate: () => createDelegate,
+  delegate: () => delegate,
+  delegateAll: () => delegateAll,
+  renameMap: () => renameMap
+});
+function delegate(ctx, key, next2, options) {
+  const child = ctx[key];
+  const delegated = {};
+  const allTransitions = Object.keys(child).filter(
+    (k) => typeof child[k] === "function"
+  );
+  let transitionMap;
+  if (!options) {
+    transitionMap = Object.fromEntries(allTransitions.map((t) => [t, t]));
+  } else if ("pick" in options) {
+    transitionMap = Object.fromEntries(
+      options.pick.filter((t) => allTransitions.includes(t)).map((t) => [t, t])
+    );
+  } else if ("omit" in options) {
+    const omitSet = new Set(options.omit);
+    transitionMap = Object.fromEntries(
+      allTransitions.filter((t) => !omitSet.has(t)).map((t) => [t, t])
+    );
+  } else if ("rename" in options) {
+    transitionMap = Object.fromEntries(
+      Object.entries(options.rename).filter(
+        ([childName]) => allTransitions.includes(childName)
+      )
+    );
+  } else {
+    transitionMap = {};
+  }
+  for (const [childName, parentName] of Object.entries(transitionMap)) {
+    const childTransition = child[childName];
+    delegated[parentName] = (...args) => {
+      const nextChild = childTransition.apply(child, args);
+      return next2({ ...ctx, [key]: nextChild });
+    };
+  }
+  return delegated;
+}
+function createDelegate(ctx, next2) {
+  return (key, options) => delegate(ctx, key, next2, options);
+}
+function delegateAll(ctx, keys, next2, prefix = false) {
+  const result = {};
+  for (const key of keys) {
+    const child = ctx[key];
+    const transitions = Object.keys(child).filter(
+      (k) => typeof child[k] === "function"
+    );
+    for (const transitionName of transitions) {
+      const parentName = prefix ? `${String(key)}_${transitionName}` : transitionName;
+      const childTransition = child[transitionName];
+      result[parentName] = (...args) => {
+        const nextChild = childTransition.apply(child, args);
+        return next2({ ...ctx, [key]: nextChild });
+      };
+    }
+  }
+  return result;
+}
+function renameMap() {
+  return (mapping) => mapping;
+}
+
 // src/index.ts
 function createMachine(context, fnsOrFactory) {
   if (typeof fnsOrFactory === "function") {
@@ -2175,8 +2400,8 @@ function createMachine(context, fnsOrFactory) {
   }
   const stored = getStoredTransitions(fnsOrFactory);
   const transitions = stored != null ? stored : "context" in fnsOrFactory ? snapshotOwnTransitions(fnsOrFactory) : fnsOrFactory;
-  const machine = Object.assign({ context }, transitions);
-  return attachTransitions(machine, transitions);
+  const machine2 = Object.assign({ context }, transitions);
+  return attachTransitions(machine2, transitions);
 }
 function createAsyncMachine(context, fnsOrFactory) {
   if (typeof fnsOrFactory === "function") {
@@ -2189,8 +2414,8 @@ function createAsyncMachine(context, fnsOrFactory) {
   }
   const stored = getStoredTransitions(fnsOrFactory);
   const transitions = stored != null ? stored : "context" in fnsOrFactory ? snapshotOwnTransitions(fnsOrFactory) : fnsOrFactory;
-  const machine = Object.assign({ context }, transitions);
-  return attachTransitions(machine, transitions);
+  const machine2 = Object.assign({ context }, transitions);
+  return attachTransitions(machine2, transitions);
 }
 function createMachineFactory() {
   return (transformers) => {
@@ -2208,23 +2433,23 @@ function createMachineFactory() {
     };
   };
 }
-function setContext(machine, newContextOrFn) {
+function setContext(machine2, newContextOrFn) {
   var _a;
-  const currentContext = machine.context;
-  const transitions = (_a = getStoredTransitions(machine)) != null ? _a : snapshotOwnTransitions(machine);
+  const currentContext = machine2.context;
+  const transitions = (_a = getStoredTransitions(machine2)) != null ? _a : snapshotOwnTransitions(machine2);
   const newContext = typeof newContextOrFn === "function" ? newContextOrFn(currentContext) : newContextOrFn;
   return createMachine(newContext, transitions);
 }
 function createContext(context) {
   return { context };
 }
-function overrideTransitions(machine, overrides) {
-  const { context, ...originalTransitions } = machine;
+function overrideTransitions(machine2, overrides) {
+  const { context, ...originalTransitions } = machine2;
   const newTransitions = { ...originalTransitions, ...overrides };
   return createMachine(context, newTransitions);
 }
-function extendTransitions(machine, newTransitions) {
-  const { context, ...originalTransitions } = machine;
+function extendTransitions(machine2, newTransitions) {
+  const { context, ...originalTransitions } = machine2;
   const combinedTransitions = { ...originalTransitions, ...newTransitions };
   return createMachine(context, combinedTransitions);
 }
@@ -2245,16 +2470,16 @@ function createMachineBuilder(templateMachine) {
     return createMachine(newContext, transitions);
   };
 }
-function matchMachine(machine, discriminantKey, handlers) {
-  const discriminant = machine.context[discriminantKey];
+function matchMachine(machine2, discriminantKey, handlers) {
+  const discriminant = machine2.context[discriminantKey];
   const handler = handlers[discriminant];
   if (!handler) {
     throw new Error(`No handler found for state: ${String(discriminant)}`);
   }
-  return handler(machine.context);
+  return handler(machine2.context);
 }
-function hasState(machine, key, value) {
-  return machine.context[key] === value;
+function hasState(machine2, key, value) {
+  return machine2.context[key] === value;
 }
 function runMachine(initial, onChange) {
   let current = initial;