aifsmjs 0.5.8 → 0.6.0

package/dist/chunk-VGLF5NQH.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/fsm/resolver.ts","../src/fsm/snapshot.ts","../src/fsm/lifecycle.ts","../src/fsm/updater.ts"],"names":["ownValue","IS_DEV","createEnqueuer","evalGuard"],"mappings":"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","file":"chunk-VGLF5NQH.cjs","sourcesContent":["import { ownValue } from \"./evaluator.js\";\nimport type { MachineDef, TransitionConfig, TransitionDef } from \"./types.js\";\n\n/**\n * Normalize a single transition config into its object form. The string\n * shorthand `\"targetState\"` (à la XState) becomes `{ target: \"targetState\" }`;\n * the object form is returned unchanged. Centralised here so every consumer\n * (`step`, `resolveTransitions`, `can`, validation) sees the same shape.\n *\n * @since 0.5.3\n */\nexport function normalizeTransition<Ctx, Evt, States extends string>(\n  entry: TransitionConfig<Ctx, Evt, States>,\n): TransitionDef<Ctx, Evt, States> {\n  return typeof entry === \"string\" ? ({ target: entry } as TransitionDef<Ctx, Evt, States>) : entry;\n}\n\n/**\n * Normalize the raw `state.on[eventType]` value (object, string shorthand, or\n * an array mixing both) into an ordered list of {@link TransitionDef} objects.\n * Declaration order is preserved.\n *\n * @since 0.5.3\n */\nexport function normalizeTransitions<Ctx, Evt, States extends string>(\n  entry:\n    | TransitionConfig<Ctx, Evt, States>\n    | readonly TransitionConfig<Ctx, Evt, States>[]\n    | undefined,\n): readonly TransitionDef<Ctx, Evt, States>[] {\n  if (entry === undefined) return [];\n  if (Array.isArray(entry)) {\n    // Hot path (send/step/can run this per event): when no string shorthand is\n    // present, return the original array instead of allocating a normalized copy.\n    return entry.some((t) => typeof t === \"string\")\n      ? entry.map((t) => normalizeTransition(t))\n      : (entry as readonly TransitionDef<Ctx, Evt, States>[]);\n  }\n  return [normalizeTransition(entry as TransitionConfig<Ctx, Evt, States>)];\n}\n\n/**\n * Return all transition candidates for (state, eventType). Order is preserved\n * from the declaration so that guard fallthrough behaves predictably. String\n * shorthands are normalized to `{ target }` objects.\n *\n * If the event has no entry under the given state, an empty array is returned.\n */\nexport function resolveTransitions<Ctx, Evt extends { type: string }, States extends string>(\n  def: MachineDef<Ctx, Evt, States>,\n  stateValue: States,\n  eventType: string,\n): readonly TransitionDef<Ctx, Evt, States>[] {\n  const state = def.states[stateValue];\n  if (!state || !state.on) return [];\n  return normalizeTransitions(ownValue(state.on, eventType));\n}\n","import type { Snapshot } from \"./types.js\";\n\n// Written so a bundler define-replacement of `process.env.NODE_ENV` (Vite,\n// webpack 5, ...) still applies: those tools replace only the\n// `process.env.NODE_ENV` expression, not a runtime `process` global, so\n// gating on `typeof process !== \"undefined\"` first left IS_DEV permanently\n// false in a browser build even though NODE_ENV !== \"production\". A plain\n// try/catch around the read lets the replaced literal survive while still\n// falling back to false wherever `process` is entirely absent. Exported for\n// internal dev-only diagnostics (runtime.ts); not re-exported from the root.\nexport let IS_DEV = false;\ntry {\n  IS_DEV = process.env.NODE_ENV !== \"production\";\n} catch {\n  /* no `process` global (browser without bundler define-replacement) */\n}\n\nexport function isPlainObject(value: unknown): value is Record<string, unknown> {\n  if (value === null || typeof value !== \"object\") return false;\n  const proto = Object.getPrototypeOf(value);\n  return proto === Object.prototype || proto === null;\n}\n\n// Trees already deep-frozen here. Short-circuits re-walking carried-over\n// context and guards cycles; unlike `Object.isFrozen` it does not stop at a\n// shallow-frozen object (e.g. an effect descriptor) whose children are mutable.\nconst DEEP_FROZEN = new WeakSet<object>();\n\nexport function deepFreeze<T>(value: T): T {\n  if (value === null || typeof value !== \"object\") return value;\n  if (DEEP_FROZEN.has(value)) return value;\n  DEEP_FROZEN.add(value);\n  // Object.freeze throws on a non-empty TypedArray / Buffer; binary data in\n  // context or event payloads is left mutable (caller-owned) instead.\n  if (ArrayBuffer.isView(value)) return value;\n  Object.freeze(value);\n  if (Array.isArray(value)) {\n    for (const item of value) deepFreeze(item);\n  } else if (isPlainObject(value)) {\n    for (const key of Object.keys(value)) {\n      deepFreeze((value as Record<string, unknown>)[key]);\n    }\n  }\n  return value;\n}\n\n/**\n * Wrap a freshly built snapshot. In dev mode the whole tree is deep-frozen so\n * accidental mutation throws immediately. In production only the top object is\n * frozen, keeping the cost negligible.\n */\nexport function freezeSnapshot<C, S extends string>(snap: Snapshot<C, S>): Snapshot<C, S> {\n  // IS_DEV is always true in vitest; the production branch (`Object.freeze`)\n  // is exercised only when NODE_ENV === \"production\" and is intentionally\n  // left out of the coverage threshold.\n  return IS_DEV ? deepFreeze(snap) : Object.freeze(snap);\n}\n\nexport function createSnapshot<C, S extends string>(args: {\n  value: S;\n  context: C;\n  status?: \"active\" | \"final\";\n}): Snapshot<C, S> {\n  return freezeSnapshot({\n    value: args.value,\n    context: args.context,\n    status: args.status ?? \"active\",\n  });\n}\n","import { createEnqueuer } from \"../effects/enqueuer.js\";\nimport { evalGuard, ownValue } from \"./evaluator.js\";\nimport { resolveTransitions } from \"./resolver.js\";\nimport { freezeSnapshot } from \"./snapshot.js\";\nimport type {\n  Action,\n  ActionRef,\n  Effect,\n  Implementations,\n  MachineDef,\n  Snapshot,\n  StepResult,\n  TransitionDef,\n} from \"./types.js\";\nimport { mergeContext } from \"./updater.js\";\n\nexport class UnknownActionError extends Error {\n  readonly actionName: string;\n  constructor(actionName: string) {\n    super(`aifsmjs: action \"${actionName}\" not found in implementations.actions`);\n    this.name = \"UnknownActionError\";\n    this.actionName = actionName;\n  }\n}\n\n/**\n * Thrown (from `step()`, and so from `send()` before anything is committed)\n * when an action returns a non-nullish primitive (`false`, `0`, `\"\"`, ...) as\n * the patch for an object context. An object context accepts only a\n * plain-object patch or `undefined`/`null` (no change).\n *\n * `actionName` is the string ref, the inline function's name, or `\"<inline>\"`\n * for an anonymous inline action (mirrors guard naming).\n *\n * @since 0.6.0\n */\nexport class InvalidActionResultError extends Error {\n  readonly actionName: string;\n  constructor(actionName: string, patch: unknown) {\n    super(\n      `aifsmjs: action \"${actionName}\" returned ${typeof patch}; an object context accepts only a plain-object patch (or undefined)`,\n    );\n    this.name = \"InvalidActionResultError\";\n    this.actionName = actionName;\n  }\n}\n\nfunction resolveAction<Ctx, Evt>(\n  ref: ActionRef<Ctx, Evt>,\n  impl: Implementations<Ctx, Evt>,\n): Action<Ctx, Evt> {\n  if (typeof ref === \"function\") return ref;\n  const fn = ownValue(impl.actions, ref);\n  if (!fn) throw new UnknownActionError(ref);\n  return fn;\n}\n\nfunction runActions<Ctx, Evt>(\n  refs: readonly ActionRef<Ctx, Evt>[] | undefined,\n  ctx: Ctx,\n  event: Evt,\n  impl: Implementations<Ctx, Evt>,\n  effectSink: Effect[],\n): Ctx {\n  if (!refs || refs.length === 0) return ctx;\n  const enqueue = createEnqueuer(effectSink as { type: string; payload?: unknown }[]);\n  let current = ctx;\n  for (const ref of refs) {\n    const fn = resolveAction(ref, impl);\n    const patch = fn({ context: current, event, enqueue });\n    current = mergeContext(current, patch, typeof ref === \"string\" ? ref : fn.name || \"<inline>\");\n  }\n  return current;\n}\n\n/**\n * The transition `event` would fire from `snapshot`: the first candidate (in\n * declaration order) with no guard or a passing guard, or `undefined` (also\n * for a final state, which never reacts). Shared by `step()` and\n * `Runtime.can()` so both resolve candidates the same way.\n */\nexport function chooseTransition<Ctx, Evt extends { type: string }, States extends string>(\n  def: MachineDef<Ctx, Evt, States>,\n  snapshot: Snapshot<Ctx, States>,\n  event: Evt,\n  impl: Implementations<Ctx, Evt>,\n): TransitionDef<Ctx, Evt, States> | undefined {\n  if (snapshot.status === \"final\") return undefined;\n  for (const t of resolveTransitions(def, snapshot.value, event.type)) {\n    if (!t.guard || evalGuard(t.guard, snapshot.context, event, impl, snapshot.value)) return t;\n  }\n  return undefined;\n}\n\nconst NO_EFFECTS: readonly Effect[] = Object.freeze([]);\n\n/**\n * Internal `step()` that also reports whether the chosen transition is\n * external (has a `target`, including a same-value self-target). The runtime\n * uses it to decide the sub-machine lifecycle from the SAME guard pass that\n * produced the snapshot, so a non-idempotent guard is evaluated exactly once\n * per event. Not re-exported from the package root.\n */\nexport function stepWithMeta<Ctx, Evt extends { type: string }, States extends string>(\n  def: MachineDef<Ctx, Evt, States>,\n  snapshot: Snapshot<Ctx, States>,\n  event: Evt,\n  impl: Implementations<Ctx, Evt>,\n): { result: StepResult<Ctx, States>; external: boolean } {\n  // Nothing fires for a final state (inert), an undeclared event type, or\n  // when every candidate's guard fails.\n  const chosen = chooseTransition(def, snapshot, event, impl);\n  if (!chosen) {\n    return {\n      result: Object.freeze({ snapshot, effects: NO_EFFECTS, changed: false }),\n      external: false,\n    };\n  }\n  // A chosen transition implies snapshot.value is a declared state.\n  const state = def.states[snapshot.value];\n\n  const isExternal = chosen.target !== undefined;\n  const nextStateValue = (chosen.target ?? snapshot.value) as States;\n  const nextState = def.states[nextStateValue];\n\n  const effectSink: Effect[] = [];\n  let ctx = snapshot.context;\n\n  if (isExternal) {\n    ctx = runActions(state.exit, ctx, event, impl, effectSink);\n  }\n  ctx = runActions(chosen.actions, ctx, event, impl, effectSink);\n  if (isExternal && nextState) {\n    ctx = runActions(nextState.entry, ctx, event, impl, effectSink);\n  }\n\n  const status: \"active\" | \"final\" = nextState?.final === true ? \"final\" : \"active\";\n  const nextSnapshot = freezeSnapshot({\n    value: nextStateValue,\n    context: ctx,\n    status,\n  });\n\n  return {\n    result: Object.freeze({\n      snapshot: nextSnapshot,\n      effects: Object.freeze(effectSink.slice()) as readonly Effect[],\n      changed: true,\n    }),\n    external: isExternal,\n  };\n}\n\n/**\n * Compute the next snapshot and collected effects from a single event.\n *\n * Order is fixed and uninterruptible:\n *   1. resolve candidate transitions for (state, event.type)\n *   2. evaluate guards in declaration order; pick the first passing one\n *   3. if external (target defined), run exit actions of the old state\n *   4. run transition.actions in declaration order\n *   5. if external, run entry actions of the new state\n *   6. return { snapshot, effects, changed }\n *\n * The function is pure: it never dispatches effects and never mutates inputs.\n * Each guard on the path is evaluated at most once.\n */\nexport function step<Ctx, Evt extends { type: string }, States extends string>(\n  def: MachineDef<Ctx, Evt, States>,\n  snapshot: Snapshot<Ctx, States>,\n  event: Evt,\n  impl: Implementations<Ctx, Evt>,\n): StepResult<Ctx, States> {\n  return stepWithMeta(def, snapshot, event, impl).result;\n}\n","import { InvalidActionResultError } from \"./lifecycle.js\";\nimport { isPlainObject } from \"./snapshot.js\";\nimport type { Action } from \"./types.js\";\n\n/**\n * Build an Action that returns a Partial<Ctx> from a pure updater.\n * The partial is merged into the current context by `step()`.\n */\nexport function assign<Ctx, Evt>(\n  updater: (args: { context: Ctx; event: Evt }) => Partial<Ctx>,\n): Action<Ctx, Evt> {\n  return ({ context, event }) => updater({ context, event });\n}\n\n/**\n * Merge an action's result into the current context. The function never\n * mutates either argument.\n *\n * - `undefined` / `null` patch: `current` is returned unchanged.\n * - Object context (not an array or `ArrayBuffer` view) + plain-object patch:\n *   shallow merge into a new object that keeps `current`'s prototype, so a\n *   class-instance context keeps its methods and untouched fields. Only own\n *   enumerable (string and symbol) properties are carried; `#private` and\n *   non-enumerable members are not, so prefer plain-object contexts.\n * - Object context + non-nullish primitive patch (`false`, `0`, `\"\"`, ...):\n *   throws {@link InvalidActionResultError} (`actionName` names the action).\n * - Anything else (a primitive or array context, or a non-plain-object patch\n *   such as an array or class instance): the patch replaces `current`.\n */\nexport function mergeContext<Ctx>(\n  current: Ctx,\n  patch: Partial<Ctx> | void,\n  actionName = \"<inline>\",\n): Ctx {\n  if (patch === undefined || patch === null) return current;\n  if (\n    current !== null &&\n    typeof current === \"object\" &&\n    !Array.isArray(current) &&\n    !ArrayBuffer.isView(current)\n  ) {\n    // Spread (CreateDataProperty) rather than Object.assign ([[Set]]): an own\n    // `__proto__` key in a JSON-derived patch stays a plain data property\n    // instead of re-prototyping the merged context, and prototype setters\n    // are never invoked. Object.setPrototypeOf is a no-op for plain contexts.\n    if (isPlainObject(patch)) {\n      return Object.setPrototypeOf({ ...current, ...patch }, Object.getPrototypeOf(current));\n    }\n    if (typeof patch !== \"object\" && typeof patch !== \"function\") {\n      throw new InvalidActionResultError(actionName, patch);\n    }\n  }\n  return patch as Ctx;\n}\n"]}

package/dist/{chunk-FHTQ7LSQ.cjs → chunk-VV5TKFQO.cjs}

@@ -1,13 +1,13 @@
 'use strict';
 
-var chunkI354FONA_cjs = require('./chunk-I354FONA.cjs');
+var chunkVGLF5NQH_cjs = require('./chunk-VGLF5NQH.cjs');
 
 // src/replay/index.ts
 function replay(initial, events, def, impl) {
   let snapshot = initial;
   const effects = [];
   for (const event of events) {
-    const r = chunkI354FONA_cjs.step(def, snapshot, event, impl);
+    const r = chunkVGLF5NQH_cjs.step(def, snapshot, event, impl);
     snapshot = r.snapshot;
     if (r.effects.length > 0) {
       for (const eff of r.effects) effects.push(eff);
@@ -17,5 +17,5 @@ function replay(initial, events, def, impl) {
 }
 
 exports.replay = replay;
-//# sourceMappingURL=chunk-FHTQ7LSQ.cjs.map
-//# sourceMappingURL=chunk-FHTQ7LSQ.cjs.map
+//# sourceMappingURL=chunk-VV5TKFQO.cjs.map
+//# sourceMappingURL=chunk-VV5TKFQO.cjs.map

package/dist/{chunk-FHTQ7LSQ.cjs.map → chunk-VV5TKFQO.cjs.map}

@@ -1 +1 @@
-{"version":3,"sources":["../src/replay/index.ts"],"names":["step"],"mappings":";;;;;AAiBO,SAAS,MAAA,CACd,OAAA,EACA,MAAA,EACA,GAAA,EACA,IAAA,EAC2B;AAC3B,EAAA,IAAI,QAAA,GAAW,OAAA;AACf,EAAA,MAAM,UAAoB,EAAC;AAC3B,EAAA,KAAA,MAAW,SAAS,MAAA,EAAQ;AAC1B,IAAA,MAAM,CAAA,GAAIA,sBAAA,CAAK,GAAA,EAAK,QAAA,EAAU,OAAO,IAAI,CAAA;AACzC,IAAA,QAAA,GAAW,CAAA,CAAE,QAAA;AACb,IAAA,IAAI,CAAA,CAAE,OAAA,CAAQ,MAAA,GAAS,CAAA,EAAG;AACxB,MAAA,KAAA,MAAW,GAAA,IAAO,CAAA,CAAE,OAAA,EAAS,OAAA,CAAQ,KAAK,GAAG,CAAA;AAAA,IAC/C;AAAA,EACF;AACA,EAAA,OAAO,MAAA,CAAO,MAAA,CAAO,EAAE,QAAA,EAAU,OAAA,EAAS,MAAA,CAAO,MAAA,CAAO,OAAA,CAAQ,KAAA,EAAO,CAAA,EAAG,CAAA;AAC5E","file":"chunk-FHTQ7LSQ.cjs","sourcesContent":["import { step } from \"../fsm/lifecycle.js\";\nimport type { Effect, Implementations, MachineDef, Snapshot } from \"../fsm/types.js\";\n\nexport type ReplayResult<Ctx, States extends string> = Readonly<{\n  snapshot: Snapshot<Ctx, States>;\n  effects: readonly Effect[];\n}>;\n\n/**\n * Fold an event log into a final snapshot via `step()`. Effects are collected\n * but never dispatched — this is a pure function, suitable for PBT, time\n * travel, and incident reproduction.\n *\n * Equivalent to:\n *   events.reduce((s, e) => step(def, s, e, impl).snapshot, initial)\n * but also accumulates the effects across all events.\n */\nexport function replay<Ctx, Evt extends { type: string }, States extends string>(\n  initial: Snapshot<Ctx, States>,\n  events: readonly Evt[],\n  def: MachineDef<Ctx, Evt, States>,\n  impl: Implementations<Ctx, Evt>,\n): ReplayResult<Ctx, States> {\n  let snapshot = initial;\n  const effects: Effect[] = [];\n  for (const event of events) {\n    const r = step(def, snapshot, event, impl);\n    snapshot = r.snapshot;\n    if (r.effects.length > 0) {\n      for (const eff of r.effects) effects.push(eff);\n    }\n  }\n  return Object.freeze({ snapshot, effects: Object.freeze(effects.slice()) });\n}\n"]}
+{"version":3,"sources":["../src/replay/index.ts"],"names":["step"],"mappings":";;;;;AAiBO,SAAS,MAAA,CACd,OAAA,EACA,MAAA,EACA,GAAA,EACA,IAAA,EAC2B;AAC3B,EAAA,IAAI,QAAA,GAAW,OAAA;AACf,EAAA,MAAM,UAAoB,EAAC;AAC3B,EAAA,KAAA,MAAW,SAAS,MAAA,EAAQ;AAC1B,IAAA,MAAM,CAAA,GAAIA,sBAAA,CAAK,GAAA,EAAK,QAAA,EAAU,OAAO,IAAI,CAAA;AACzC,IAAA,QAAA,GAAW,CAAA,CAAE,QAAA;AACb,IAAA,IAAI,CAAA,CAAE,OAAA,CAAQ,MAAA,GAAS,CAAA,EAAG;AACxB,MAAA,KAAA,MAAW,GAAA,IAAO,CAAA,CAAE,OAAA,EAAS,OAAA,CAAQ,KAAK,GAAG,CAAA;AAAA,IAC/C;AAAA,EACF;AACA,EAAA,OAAO,MAAA,CAAO,MAAA,CAAO,EAAE,QAAA,EAAU,OAAA,EAAS,MAAA,CAAO,MAAA,CAAO,OAAA,CAAQ,KAAA,EAAO,CAAA,EAAG,CAAA;AAC5E","file":"chunk-VV5TKFQO.cjs","sourcesContent":["import { step } from \"../fsm/lifecycle.js\";\nimport type { Effect, Implementations, MachineDef, Snapshot } from \"../fsm/types.js\";\n\nexport type ReplayResult<Ctx, States extends string> = Readonly<{\n  snapshot: Snapshot<Ctx, States>;\n  effects: readonly Effect[];\n}>;\n\n/**\n * Fold an event log into a final snapshot via `step()`. Effects are collected\n * but never dispatched — this is a pure function, suitable for PBT, time\n * travel, and incident reproduction.\n *\n * Equivalent to:\n *   events.reduce((s, e) => step(def, s, e, impl).snapshot, initial)\n * but also accumulates the effects across all events.\n */\nexport function replay<Ctx, Evt extends { type: string }, States extends string>(\n  initial: Snapshot<Ctx, States>,\n  events: readonly Evt[],\n  def: MachineDef<Ctx, Evt, States>,\n  impl: Implementations<Ctx, Evt>,\n): ReplayResult<Ctx, States> {\n  let snapshot = initial;\n  const effects: Effect[] = [];\n  for (const event of events) {\n    const r = step(def, snapshot, event, impl);\n    snapshot = r.snapshot;\n    if (r.effects.length > 0) {\n      for (const eff of r.effects) effects.push(eff);\n    }\n  }\n  return Object.freeze({ snapshot, effects: Object.freeze(effects.slice()) });\n}\n"]}

package/dist/{chunk-VZCSHTOI.js → chunk-XA24A7VP.js}

@@ -1,5 +1,5 @@
-import { freezeSnapshot, step, normalizeTransitions, deepFreeze } from './chunk-ZLQ7HZCE.js';
-import { evalGuard, isAsyncGuardFn, isThenable } from './chunk-A7U7QQL5.js';
+import { freezeSnapshot, chooseTransition, normalizeTransitions, stepWithMeta, deepFreeze, IS_DEV } from './chunk-D6H64FSI.js';
+import { isAsyncGuardFn, ownValue, isThenable } from './chunk-SSNKGEVB.js';
 
 // src/fsm/types.ts
 var RESET_EVENT_TYPE = "@@aifsmjs/RESET";
@@ -11,13 +11,16 @@ var InvalidDefinitionError = class extends Error {
     this.name = "InvalidDefinitionError";
   }
 };
-function validateDefinition(def) {
+function assertObject(value, subject) {
+  if (value === null || typeof value !== "object") {
+    throw new InvalidDefinitionError(`${subject} must be an object`);
+  }
+}
+function validateDefinition(def, seen = /* @__PURE__ */ new WeakSet()) {
   if (!def.id || typeof def.id !== "string") {
     throw new InvalidDefinitionError("definition must have a non-empty string `id`");
   }
-  if (!def.states || typeof def.states !== "object") {
-    throw new InvalidDefinitionError("definition must have a `states` object");
-  }
+  assertObject(def.states, "definition states");
   const stateKeys = Object.keys(def.states);
   if (stateKeys.length === 0) {
     throw new InvalidDefinitionError("`states` must declare at least one state");
@@ -28,6 +31,7 @@ function validateDefinition(def) {
     );
   }
   for (const [stateName, stateDef] of Object.entries(def.states)) {
+    assertObject(stateDef, `state "${stateName}"`);
     if (stateDef.sub !== void 0) {
       const sub = stateDef.sub;
       const subStates = sub.states;
@@ -39,11 +43,16 @@ function validateDefinition(def) {
           `state "${stateName}".sub is not a valid sub-machine definition (missing states or initial)`
         );
       }
+      if (!seen.has(sub)) {
+        seen.add(sub);
+        validateDefinition(sub, seen);
+      }
     }
     if (!stateDef.on) continue;
     for (const [evtType, entry] of Object.entries(stateDef.on)) {
       const transitions = normalizeTransitions(entry);
       for (const t of transitions) {
+        assertObject(t, `transition ${stateName} -[${evtType}]->`);
         if (t.target !== void 0 && !stateKeys.includes(t.target)) {
           throw new InvalidDefinitionError(
             `transition ${stateName} -[${evtType}]-> "${String(t.target)}" targets an unknown state`
@@ -57,20 +66,26 @@ function validateDefinition(def) {
       }
     }
   }
+  const path = /* @__PURE__ */ new Set();
+  let d = def;
+  while (d) {
+    if (path.has(d)) {
+      throw new InvalidDefinitionError(
+        `sub-machine cycle through initial states: "${d.id}" is re-entered via initial-state subs`
+      );
+    }
+    path.add(d);
+    d = d.states[d.initial]?.sub;
+  }
 }
 function defineMachine(def) {
-  const normalized = !("context" in def) ? { ...def, context: {} } : def;
+  assertObject(def, "definition");
+  const normalized = def.context === void 0 ? { ...def, context: {} } : def;
   validateDefinition(normalized);
   return normalized;
 }
 function setup() {
-  return {
-    defineMachine: (def) => {
-      const cast = !("context" in def) ? { ...def, context: {} } : def;
-      validateDefinition(cast);
-      return cast;
-    }
-  };
+  return { defineMachine };
 }
 function initialSnapshot(def) {
   const isFinal = def.states[def.initial]?.final === true;
@@ -120,15 +135,29 @@ function composeMiddleware(middleware) {
     dispatch(0);
   };
 }
+function assertListener(listener) {
+  if (typeof listener !== "function") {
+    throw new InvalidDefinitionError("listener must be a function");
+  }
+}
 function createRuntime(def, impl, opts = {}) {
+  assertObject(def, "definition");
+  assertObject(def.states, "definition states");
+  assertObject(impl, "implementations");
+  assertObject(opts, "options");
+  const middleware = opts.middleware;
+  if (middleware !== void 0 && !(Array.isArray(middleware) && middleware.every((fn) => typeof fn === "function"))) {
+    throw new InvalidDefinitionError("options.middleware must be an array of functions");
+  }
   let snapshot = initialSnapshot(def);
   const listeners = /* @__PURE__ */ new Set();
-  const middlewareChain = opts.middleware && opts.middleware.length > 0 ? composeMiddleware(opts.middleware) : void 0;
+  const middlewareChain = middleware && middleware.length > 0 ? composeMiddleware(middleware) : void 0;
   const shouldDispatch = opts.dispatchEffects !== false;
   const controller = new AbortController();
   let disposed = false;
+  let dispatching = false;
+  const mailbox = [];
   let childRuntime;
-  let childAbortCleanup;
   const eventListeners = {
     transition: /* @__PURE__ */ new Set(),
     error: /* @__PURE__ */ new Set(),
@@ -136,162 +165,131 @@ function createRuntime(def, impl, opts = {}) {
   };
   const externalAbortCleanups = /* @__PURE__ */ new Set();
   function emit(type, payload) {
-    for (const fn of Array.from(eventListeners[type])) fn(payload);
-  }
-  function notify(committed) {
-    const captured = committed ?? snapshot;
-    for (const l of Array.from(listeners)) l(captured);
-  }
-  function runMiddleware(prev, event, effects, changed) {
-    if (!middlewareChain) return;
-    middlewareChain(deepFreeze({ prev, next: snapshot, event, effects, changed }), () => {
-    });
+    const set = eventListeners[type];
+    let failed = false;
+    let firstError;
+    for (const fn of Array.from(set)) {
+      if (!set.has(fn)) continue;
+      try {
+        fn(payload);
+      } catch (err) {
+        if (!failed) {
+          failed = true;
+          firstError = err;
+        }
+      }
+    }
+    if (failed) throw firstError;
   }
   function dispatchEffects(effects, context, event) {
     if (!impl.effects || effects.length === 0) return;
     for (const eff of effects) {
-      const handler = impl.effects[eff.type];
+      const handler = ownValue(impl.effects, eff.type);
       if (!handler) continue;
       const r = handler(eff, { context, event, signal: controller.signal });
       if (isThenable(r)) {
         Promise.resolve(r).catch((err) => {
-          emit("error", { error: err, event });
+          if (eventListeners.error.size > 0) emit("error", { error: err, event });
+          else if (IS_DEV) {
+            console.warn(
+              'aifsmjs: unhandled async effect rejection; register runtime.on("error", ...)',
+              err
+            );
+          }
         });
       }
     }
   }
-  function wireChildAbort(child) {
-    if (controller.signal.aborted) {
-      try {
-        child.dispose();
-      } catch {
-      }
-      return () => {
-      };
-    }
-    const onAbort = () => {
+  function swapChild(prevValue, nextValue) {
+    const stateDef = def.states[nextValue];
+    let next;
+    if (stateDef?.sub) {
       try {
-        child.dispose();
-      } catch {
-      }
-    };
-    controller.signal.addEventListener("abort", onAbort, { once: true });
-    return () => controller.signal.removeEventListener("abort", onAbort);
-  }
-  function initChildFor(stateValue) {
-    const stateDef = def.states[stateValue];
-    const sub = stateDef?.sub;
-    if (sub === void 0) return;
-    let newChild;
-    try {
-      newChild = createRuntime(sub, stateDef.subImpl ?? {});
-    } catch (cause) {
-      throw new SubMachineError(stateValue, "init", cause);
-    }
-    childRuntime = newChild;
-    childAbortCleanup = wireChildAbort(newChild);
-  }
-  function findChosenIsExternal(value, event, context) {
-    const state = def.states[value];
-    if (!state?.on) return false;
-    const list = normalizeTransitions(state.on[event.type]);
-    if (list.length === 0) return false;
-    for (const t of list) {
-      if (!t.guard || evalGuard(t.guard, context, event, impl, value)) {
-        return t.target !== void 0;
+        next = createRuntime(stateDef.sub, stateDef.subImpl ?? {});
+      } catch (cause) {
+        throw new SubMachineError(nextValue, "init", cause);
       }
     }
-    return false;
-  }
-  function applySubLifecycle(prevValue, nextValue) {
-    const prevStateDef = def.states[prevValue];
-    const nextStateDef = def.states[nextValue];
-    if (prevStateDef?.sub !== void 0 && childRuntime !== void 0) {
-      const child = childRuntime;
+    const old = childRuntime;
+    if (old) {
       childRuntime = void 0;
-      childAbortCleanup?.();
-      childAbortCleanup = void 0;
       try {
-        child.dispose();
+        old.dispose();
       } catch (cause) {
+        next?.dispose();
         throw new SubMachineError(prevValue, "dispose", cause);
       }
     }
-    if (nextStateDef?.sub !== void 0) {
-      initChildFor(nextValue);
-    }
+    if (disposed) next?.dispose();
+    else childRuntime = next;
   }
-  function send(event) {
-    if (disposed) throw new RuntimeDisposedError();
-    const prev = snapshot;
-    const result = step(def, prev, event, impl);
-    const isExternal = result.changed && (prev.value !== result.snapshot.value || findChosenIsExternal(prev.value, event, prev.context));
-    if (result.changed && isExternal) applySubLifecycle(prev.value, result.snapshot.value);
-    snapshot = result.snapshot;
-    const committed = result.snapshot;
-    runMiddleware(prev, event, result.effects, result.changed);
-    if (shouldDispatch) dispatchEffects(result.effects, committed.context, event);
-    if (result.changed) {
-      notify(committed);
+  function commit(prev, next, event, effects, changed) {
+    snapshot = next;
+    middlewareChain?.(
+      Object.freeze({ prev, next, event, effects: deepFreeze(effects), changed }),
+      () => {
+      }
+    );
+    if (shouldDispatch) dispatchEffects(effects, next.context, event);
+    if (changed) {
+      for (const l of Array.from(listeners)) if (listeners.has(l)) l(next);
       emit("transition", {
         prev,
-        next: committed,
+        next,
         event,
-        effects: result.effects,
+        effects,
         changed: true
       });
     }
-    return snapshot;
   }
-  function reset(event) {
-    if (disposed) throw new RuntimeDisposedError();
+  function processSend(event) {
     const prev = snapshot;
-    const nextSnap = initialSnapshot(def);
-    const changed = prev.value !== nextSnap.value;
-    if (childRuntime) {
-      const child = childRuntime;
-      childRuntime = void 0;
-      childAbortCleanup?.();
-      childAbortCleanup = void 0;
-      try {
-        child.dispose();
-      } catch (cause) {
-        throw new SubMachineError(prev.value, "dispose", cause);
-      }
+    const { result, external } = stepWithMeta(def, prev, event, impl);
+    if (result.changed && (prev.value !== result.snapshot.value || external)) {
+      swapChild(prev.value, result.snapshot.value);
     }
-    const initStateDef = def.states[nextSnap.value];
-    if (initStateDef?.sub) {
-      initChildFor(nextSnap.value);
+    commit(prev, result.snapshot, event, result.effects, result.changed);
+  }
+  function processReset(event) {
+    const prev = snapshot;
+    const next = initialSnapshot(def);
+    swapChild(prev.value, next.value);
+    commit(
+      prev,
+      next,
+      event ?? RESET_EVENT,
+      [],
+      prev.value !== next.value || prev.status !== next.status || prev.context !== next.context
+    );
+  }
+  function run(entry) {
+    if (disposed) throw new RuntimeDisposedError();
+    if ((entry.kind === "send" || entry.event !== void 0) && typeof entry.event?.type !== "string") {
+      throw new InvalidDefinitionError(
+        `${entry.kind}() event must be an object with a string type`
+      );
     }
-    snapshot = nextSnap;
-    const committed = nextSnap;
-    const triggerEvent = event ?? RESET_EVENT;
-    runMiddleware(prev, triggerEvent, [], changed);
-    if (changed) {
-      notify(committed);
-      emit("transition", {
-        prev,
-        next: committed,
-        event: triggerEvent,
-        effects: [],
-        changed: true
-      });
+    if (dispatching) {
+      mailbox.push(entry);
+      return snapshot;
     }
-    return snapshot;
-  }
-  function can(event) {
-    if (disposed || snapshot.status === "final") return false;
-    const state = def.states[snapshot.value];
-    if (!state) return false;
-    const list = normalizeTransitions(state.on?.[event.type]);
-    if (list.length === 0) return false;
-    for (const t of list) {
-      if (!t.guard) return true;
-      if (evalGuard(t.guard, snapshot.context, event, impl, snapshot.value)) return true;
+    dispatching = true;
+    try {
+      for (let m = entry; m && !disposed; m = mailbox.shift()) {
+        if (m.kind === "send") processSend(m.event);
+        else processReset(m.event);
+      }
+    } finally {
+      dispatching = false;
+      mailbox.length = 0;
     }
-    return false;
+    return snapshot;
   }
   function on(type, listener, options) {
+    if (!Object.hasOwn(eventListeners, type)) {
+      throw new InvalidDefinitionError('on() type must be "transition", "error" or "dispose"');
+    }
+    assertListener(listener);
     if (disposed || options?.signal?.aborted) return () => {
     };
     const target = eventListeners[type];
@@ -323,28 +321,31 @@ function createRuntime(def, impl, opts = {}) {
   function dispose() {
     if (disposed) return;
     disposed = true;
-    if (childRuntime) {
-      childAbortCleanup?.();
-      childAbortCleanup = void 0;
-      try {
-        childRuntime.dispose();
-      } catch {
-      }
-      childRuntime = void 0;
+    mailbox.length = 0;
+    const child = childRuntime;
+    childRuntime = void 0;
+    try {
+      child?.dispose();
+    } catch {
     }
     controller.abort();
     listeners.clear();
-    emit("dispose", void 0);
-    for (const set of Object.values(eventListeners)) set.clear();
-    for (const cleanup of externalAbortCleanups) cleanup();
-    externalAbortCleanups.clear();
+    try {
+      emit("dispose", void 0);
+    } catch {
+    } finally {
+      for (const set of Object.values(eventListeners)) set.clear();
+      for (const cleanup of externalAbortCleanups) cleanup();
+      externalAbortCleanups.clear();
+    }
   }
   const runtime = {
     getSnapshot: () => snapshot,
     snapshot: () => snapshot,
-    send,
-    can,
-    reset,
+    send: (event) => run({ kind: "send", event }),
+    // Same candidate resolution as step(), without running any action.
+    can: (event) => !disposed && chooseTransition(def, snapshot, event, impl) !== void 0,
+    reset: (event) => run({ kind: "reset", event }),
     dispose,
     on,
     get disposed() {
@@ -354,6 +355,7 @@ function createRuntime(def, impl, opts = {}) {
       return controller.signal;
     },
     subscribe(listener) {
+      assertListener(listener);
       if (disposed) return () => {
       };
       listeners.add(listener);
@@ -362,13 +364,10 @@ function createRuntime(def, impl, opts = {}) {
     subRuntime: () => childRuntime,
     onTransition: (handler, options) => on("transition", handler, options)
   };
-  const bootStateDef = def.states[snapshot.value];
-  if (bootStateDef?.sub) {
-    initChildFor(snapshot.value);
-  }
+  swapChild(snapshot.value, snapshot.value);
   return runtime;
 }
 
 export { InvalidDefinitionError, RESET_EVENT_TYPE, RuntimeDisposedError, SubMachineError, createMachine, createRuntime, defineMachine, initialSnapshot, setup };
-//# sourceMappingURL=chunk-VZCSHTOI.js.map
-//# sourceMappingURL=chunk-VZCSHTOI.js.map
+//# sourceMappingURL=chunk-XA24A7VP.js.map
+//# sourceMappingURL=chunk-XA24A7VP.js.map