@pyreon/machine 0.10.0 → 0.11.0

package/lib/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":[],"sources":["../src/machine.ts"],"sourcesContent":["import { signal } from '@pyreon/reactivity'\nimport type {\n  EnterCallback,\n  InferEvents,\n  InferStates,\n  Machine,\n  MachineConfig,\n  MachineEvent,\n  TransitionCallback,\n  TransitionConfig,\n} from './types'\n\n/**\n * Create a reactive state machine — a constrained signal with type-safe transitions.\n *\n * The returned instance is callable (reads like a signal) and exposes\n * `send()`, `matches()`, `can()`, and listeners for state changes.\n *\n * @param config - Machine definition with initial state and state configs\n * @returns A reactive machine instance\n *\n * @example\n * ```tsx\n * const machine = createMachine({\n *   initial: 'idle',\n *   states: {\n *     idle: { on: { FETCH: 'loading' } },\n *     loading: { on: { SUCCESS: 'done', ERROR: 'error' } },\n *     done: {},\n *     error: { on: { RETRY: 'loading' } },\n *   },\n * })\n *\n * machine()              // 'idle'\n * machine.send('FETCH')\n * machine()              // 'loading'\n *\n * // Reactive in JSX\n * {() => machine.matches('loading') && <Spinner />}\n * ```\n */\nexport function createMachine<\n  const TConfig extends MachineConfig<string, string>,\n>(config: TConfig): Machine<InferStates<TConfig>, InferEvents<TConfig>> {\n  type TState = InferStates<TConfig>\n  type TEvent = InferEvents<TConfig>\n\n  const { initial, states } = config as unknown as MachineConfig<TState, TEvent>\n\n  // Validate initial state\n  if (!(initial in states)) {\n    throw new Error(\n      `[@pyreon/machine] Initial state '${initial}' is not defined in states`,\n    )\n  }\n\n  const current = signal<TState>(initial)\n  const enterListeners = new Map<TState, Set<EnterCallback<TEvent>>>()\n  const transitionListeners = new Set<TransitionCallback<TState, TEvent>>()\n\n  function resolveTransition(event: TEvent, payload?: unknown): TState | null {\n    const stateConfig = states[current.peek()]\n    if (!stateConfig?.on) return null\n\n    const transition = stateConfig.on[event] as\n      | TransitionConfig<TState>\n      | undefined\n    if (!transition) return null\n\n    if (typeof transition === 'string') {\n      return transition\n    }\n\n    // Guarded transition\n    if (transition.guard && !transition.guard(payload)) {\n      return null\n    }\n\n    return transition.target\n  }\n\n  // The machine instance — callable like a signal\n  function machine(): TState {\n    return current()\n  }\n\n  machine.send = (event: TEvent, payload?: unknown): void => {\n    const target = resolveTransition(event, payload)\n    if (target === null) return\n\n    const from = current.peek()\n    const machineEvent: MachineEvent<TEvent> = { type: event, payload }\n\n    current.set(target)\n\n    // Fire transition listeners\n    for (const cb of transitionListeners) {\n      cb(from, target, machineEvent)\n    }\n\n    // Fire enter listeners for the target state\n    const listeners = enterListeners.get(target)\n    if (listeners) {\n      for (const cb of listeners) {\n        cb(machineEvent)\n      }\n    }\n  }\n\n  machine.matches = (...matchStates: TState[]): boolean => {\n    const state = current()\n    return matchStates.includes(state)\n  }\n\n  machine.can = (event: TEvent): boolean => {\n    const stateConfig = states[current()]\n    if (!stateConfig?.on) return false\n\n    const transition = stateConfig.on[event]\n    if (!transition) return false\n\n    // For guarded transitions, we can't know without payload\n    // Return true if the event exists (guard may still reject)\n    return true\n  }\n\n  machine.nextEvents = (): TEvent[] => {\n    const stateConfig = states[current()]\n    if (!stateConfig?.on) return []\n    return Object.keys(stateConfig.on) as TEvent[]\n  }\n\n  machine.reset = (): void => {\n    current.set(initial)\n  }\n\n  machine.onEnter = (\n    state: TState,\n    callback: EnterCallback<TEvent>,\n  ): (() => void) => {\n    if (!enterListeners.has(state)) {\n      enterListeners.set(state, new Set())\n    }\n    enterListeners.get(state)!.add(callback)\n\n    return () => {\n      enterListeners.get(state)?.delete(callback)\n    }\n  }\n\n  machine.onTransition = (\n    callback: TransitionCallback<TState, TEvent>,\n  ): (() => void) => {\n    transitionListeners.add(callback)\n    return () => {\n      transitionListeners.delete(callback)\n    }\n  }\n\n  machine.dispose = (): void => {\n    enterListeners.clear()\n    transitionListeners.clear()\n  }\n\n  return machine as Machine<TState, TEvent>\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyCA,SAAgB,cAEd,QAAsE;CAItE,MAAM,EAAE,SAAS,WAAW;AAG5B,KAAI,EAAE,WAAW,QACf,OAAM,IAAI,MACR,oCAAoC,QAAQ,4BAC7C;CAGH,MAAM,UAAU,OAAe,QAAQ;CACvC,MAAM,iCAAiB,IAAI,KAAyC;CACpE,MAAM,sCAAsB,IAAI,KAAyC;CAEzE,SAAS,kBAAkB,OAAe,SAAkC;EAC1E,MAAM,cAAc,OAAO,QAAQ,MAAM;AACzC,MAAI,CAAC,aAAa,GAAI,QAAO;EAE7B,MAAM,aAAa,YAAY,GAAG;AAGlC,MAAI,CAAC,WAAY,QAAO;AAExB,MAAI,OAAO,eAAe,SACxB,QAAO;AAIT,MAAI,WAAW,SAAS,CAAC,WAAW,MAAM,QAAQ,CAChD,QAAO;AAGT,SAAO,WAAW;;CAIpB,SAAS,UAAkB;AACzB,SAAO,SAAS;;AAGlB,SAAQ,QAAQ,OAAe,YAA4B;EACzD,MAAM,SAAS,kBAAkB,OAAO,QAAQ;AAChD,MAAI,WAAW,KAAM;EAErB,MAAM,OAAO,QAAQ,MAAM;EAC3B,MAAM,eAAqC;GAAE,MAAM;GAAO;GAAS;AAEnE,UAAQ,IAAI,OAAO;AAGnB,OAAK,MAAM,MAAM,oBACf,IAAG,MAAM,QAAQ,aAAa;EAIhC,MAAM,YAAY,eAAe,IAAI,OAAO;AAC5C,MAAI,UACF,MAAK,MAAM,MAAM,UACf,IAAG,aAAa;;AAKtB,SAAQ,WAAW,GAAG,gBAAmC;EACvD,MAAM,QAAQ,SAAS;AACvB,SAAO,YAAY,SAAS,MAAM;;AAGpC,SAAQ,OAAO,UAA2B;EACxC,MAAM,cAAc,OAAO,SAAS;AACpC,MAAI,CAAC,aAAa,GAAI,QAAO;AAG7B,MAAI,CADe,YAAY,GAAG,OACjB,QAAO;AAIxB,SAAO;;AAGT,SAAQ,mBAA6B;EACnC,MAAM,cAAc,OAAO,SAAS;AACpC,MAAI,CAAC,aAAa,GAAI,QAAO,EAAE;AAC/B,SAAO,OAAO,KAAK,YAAY,GAAG;;AAGpC,SAAQ,cAAoB;AAC1B,UAAQ,IAAI,QAAQ;;AAGtB,SAAQ,WACN,OACA,aACiB;AACjB,MAAI,CAAC,eAAe,IAAI,MAAM,CAC5B,gBAAe,IAAI,uBAAO,IAAI,KAAK,CAAC;AAEtC,iBAAe,IAAI,MAAM,CAAE,IAAI,SAAS;AAExC,eAAa;AACX,kBAAe,IAAI,MAAM,EAAE,OAAO,SAAS;;;AAI/C,SAAQ,gBACN,aACiB;AACjB,sBAAoB,IAAI,SAAS;AACjC,eAAa;AACX,uBAAoB,OAAO,SAAS;;;AAIxC,SAAQ,gBAAsB;AAC5B,iBAAe,OAAO;AACtB,sBAAoB,OAAO;;AAG7B,QAAO"}
+{"version":3,"file":"index.js","names":[],"sources":["../src/machine.ts"],"sourcesContent":["import { signal } from \"@pyreon/reactivity\"\nimport type {\n  EnterCallback,\n  InferEvents,\n  InferStates,\n  Machine,\n  MachineConfig,\n  MachineEvent,\n  TransitionCallback,\n  TransitionConfig,\n} from \"./types\"\n\n/**\n * Create a reactive state machine — a constrained signal with type-safe transitions.\n *\n * The returned instance is callable (reads like a signal) and exposes\n * `send()`, `matches()`, `can()`, and listeners for state changes.\n *\n * @param config - Machine definition with initial state and state configs\n * @returns A reactive machine instance\n *\n * @example\n * ```tsx\n * const machine = createMachine({\n *   initial: 'idle',\n *   states: {\n *     idle: { on: { FETCH: 'loading' } },\n *     loading: { on: { SUCCESS: 'done', ERROR: 'error' } },\n *     done: {},\n *     error: { on: { RETRY: 'loading' } },\n *   },\n * })\n *\n * machine()              // 'idle'\n * machine.send('FETCH')\n * machine()              // 'loading'\n *\n * // Reactive in JSX\n * {() => machine.matches('loading') && <Spinner />}\n * ```\n */\nexport function createMachine<const TConfig extends MachineConfig<string, string>>(\n  config: TConfig,\n): Machine<InferStates<TConfig>, InferEvents<TConfig>> {\n  type TState = InferStates<TConfig>\n  type TEvent = InferEvents<TConfig>\n\n  const { initial, states } = config as unknown as MachineConfig<TState, TEvent>\n\n  // Validate initial state\n  if (!(initial in states)) {\n    throw new Error(`[@pyreon/machine] Initial state '${initial}' is not defined in states`)\n  }\n\n  const current = signal<TState>(initial)\n  const enterListeners = new Map<TState, Set<EnterCallback<TEvent>>>()\n  const transitionListeners = new Set<TransitionCallback<TState, TEvent>>()\n\n  function resolveTransition(event: TEvent, payload?: unknown): TState | null {\n    const stateConfig = states[current.peek()]\n    if (!stateConfig?.on) return null\n\n    const transition = stateConfig.on[event] as TransitionConfig<TState> | undefined\n    if (!transition) return null\n\n    if (typeof transition === \"string\") {\n      return transition\n    }\n\n    // Guarded transition\n    if (transition.guard && !transition.guard(payload)) {\n      return null\n    }\n\n    return transition.target\n  }\n\n  // The machine instance — callable like a signal\n  function machine(): TState {\n    return current()\n  }\n\n  machine.send = (event: TEvent, payload?: unknown): void => {\n    const target = resolveTransition(event, payload)\n    if (target === null) return\n\n    const from = current.peek()\n    const machineEvent: MachineEvent<TEvent> = { type: event, payload }\n\n    current.set(target)\n\n    // Fire transition listeners\n    for (const cb of transitionListeners) {\n      cb(from, target, machineEvent)\n    }\n\n    // Fire enter listeners for the target state\n    const listeners = enterListeners.get(target)\n    if (listeners) {\n      for (const cb of listeners) {\n        cb(machineEvent)\n      }\n    }\n  }\n\n  machine.matches = (...matchStates: TState[]): boolean => {\n    const state = current()\n    return matchStates.includes(state)\n  }\n\n  machine.can = (event: TEvent): boolean => {\n    const stateConfig = states[current()]\n    if (!stateConfig?.on) return false\n\n    const transition = stateConfig.on[event]\n    if (!transition) return false\n\n    // For guarded transitions, we can't know without payload\n    // Return true if the event exists (guard may still reject)\n    return true\n  }\n\n  machine.nextEvents = (): TEvent[] => {\n    const stateConfig = states[current()]\n    if (!stateConfig?.on) return []\n    return Object.keys(stateConfig.on) as TEvent[]\n  }\n\n  machine.reset = (): void => {\n    current.set(initial)\n  }\n\n  machine.onEnter = (state: TState, callback: EnterCallback<TEvent>): (() => void) => {\n    if (!enterListeners.has(state)) {\n      enterListeners.set(state, new Set())\n    }\n    enterListeners.get(state)!.add(callback)\n\n    return () => {\n      enterListeners.get(state)?.delete(callback)\n    }\n  }\n\n  machine.onTransition = (callback: TransitionCallback<TState, TEvent>): (() => void) => {\n    transitionListeners.add(callback)\n    return () => {\n      transitionListeners.delete(callback)\n    }\n  }\n\n  machine.dispose = (): void => {\n    enterListeners.clear()\n    transitionListeners.clear()\n  }\n\n  return machine as Machine<TState, TEvent>\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyCA,SAAgB,cACd,QACqD;CAIrD,MAAM,EAAE,SAAS,WAAW;AAG5B,KAAI,EAAE,WAAW,QACf,OAAM,IAAI,MAAM,oCAAoC,QAAQ,4BAA4B;CAG1F,MAAM,UAAU,OAAe,QAAQ;CACvC,MAAM,iCAAiB,IAAI,KAAyC;CACpE,MAAM,sCAAsB,IAAI,KAAyC;CAEzE,SAAS,kBAAkB,OAAe,SAAkC;EAC1E,MAAM,cAAc,OAAO,QAAQ,MAAM;AACzC,MAAI,CAAC,aAAa,GAAI,QAAO;EAE7B,MAAM,aAAa,YAAY,GAAG;AAClC,MAAI,CAAC,WAAY,QAAO;AAExB,MAAI,OAAO,eAAe,SACxB,QAAO;AAIT,MAAI,WAAW,SAAS,CAAC,WAAW,MAAM,QAAQ,CAChD,QAAO;AAGT,SAAO,WAAW;;CAIpB,SAAS,UAAkB;AACzB,SAAO,SAAS;;AAGlB,SAAQ,QAAQ,OAAe,YAA4B;EACzD,MAAM,SAAS,kBAAkB,OAAO,QAAQ;AAChD,MAAI,WAAW,KAAM;EAErB,MAAM,OAAO,QAAQ,MAAM;EAC3B,MAAM,eAAqC;GAAE,MAAM;GAAO;GAAS;AAEnE,UAAQ,IAAI,OAAO;AAGnB,OAAK,MAAM,MAAM,oBACf,IAAG,MAAM,QAAQ,aAAa;EAIhC,MAAM,YAAY,eAAe,IAAI,OAAO;AAC5C,MAAI,UACF,MAAK,MAAM,MAAM,UACf,IAAG,aAAa;;AAKtB,SAAQ,WAAW,GAAG,gBAAmC;EACvD,MAAM,QAAQ,SAAS;AACvB,SAAO,YAAY,SAAS,MAAM;;AAGpC,SAAQ,OAAO,UAA2B;EACxC,MAAM,cAAc,OAAO,SAAS;AACpC,MAAI,CAAC,aAAa,GAAI,QAAO;AAG7B,MAAI,CADe,YAAY,GAAG,OACjB,QAAO;AAIxB,SAAO;;AAGT,SAAQ,mBAA6B;EACnC,MAAM,cAAc,OAAO,SAAS;AACpC,MAAI,CAAC,aAAa,GAAI,QAAO,EAAE;AAC/B,SAAO,OAAO,KAAK,YAAY,GAAG;;AAGpC,SAAQ,cAAoB;AAC1B,UAAQ,IAAI,QAAQ;;AAGtB,SAAQ,WAAW,OAAe,aAAkD;AAClF,MAAI,CAAC,eAAe,IAAI,MAAM,CAC5B,gBAAe,IAAI,uBAAO,IAAI,KAAK,CAAC;AAEtC,iBAAe,IAAI,MAAM,CAAE,IAAI,SAAS;AAExC,eAAa;AACX,kBAAe,IAAI,MAAM,EAAE,OAAO,SAAS;;;AAI/C,SAAQ,gBAAgB,aAA+D;AACrF,sBAAoB,IAAI,SAAS;AACjC,eAAa;AACX,uBAAoB,OAAO,SAAS;;;AAIxC,SAAQ,gBAAsB;AAC5B,iBAAe,OAAO;AACtB,sBAAoB,OAAO;;AAG7B,QAAO"}

package/lib/types/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index2.d.ts","names":[],"sources":["../../../src/types.ts","../../../src/machine.ts"],"mappings":";;AAGA;;KAAY,gBAAA,0BACR,MAAA;EACE,MAAA,EAAQ,MAAA;EAAQ,KAAA,GAAQ,OAAA;AAAA;;;;UAKb,WAAA;EACf,EAAA,GAAK,OAAA,CAAQ,MAAA,CAAO,MAAA,EAAQ,gBAAA,CAAiB,MAAA;AAAA;AAD/C;;;AAAA,UAOiB,aAAA;EACf,OAAA,EAAS,MAAA;EACT,MAAA,EAAQ,MAAA,CAAO,MAAA,EAAQ,WAAA,CAAY,MAAA,EAAQ,MAAA;AAAA;;;;UAM5B,YAAA;EACf,IAAA,EAAM,MAAA;EACN,OAAA;AAAA;;;;KAMU,aAAA,oCACV,KAAA,EAAO,YAAA,CAAa,MAAA;;;AAjBtB;KAuBY,kBAAA,oEAGP,IAAA,EAAM,MAAA,EAAQ,EAAA,EAAI,MAAA,EAAQ,KAAA,EAAO,YAAA,CAAa,MAAA;;;;UAKlC,OAAA;EA7B4B;EAAA,IA+BvC,MAAA;EA/BI;EAkCR,IAAA,GAAO,KAAA,EAAO,MAAA,EAAQ,OAAA;EAlCR;EAqCd,OAAA,MAAa,MAAA,EAAQ,MAAA;EAvC+B;EA0CpD,GAAA,GAAM,KAAA,EAAO,MAAA;EAzCJ;EA4CT,UAAA,QAAkB,MAAA;EA3CV;EA8CR,KAAA;EA9CuB;EAiDvB,OAAA,GAAU,KAAA,EAAO,MAAA,EAAQ,QAAA,EAAU,aAAA,CAAc,MAAA;EAjDN;EAoD3C,YAAA,GAAe,QAAA,EAAU,kBAAA,CAAmB,MAAA,EAAQ,MAAA;EApDH;EAuDjD,OAAA;AAAA;;KAMU,WAAA,MAAiB,CAAA;EAAY,MAAA,EAAQ,MAAA;AAAA,IAC7C,CAAA;;KAIQ,WAAA,MAAiB,CAAA;EAC3B,MAAA,EAAQ,MAAA;IAAiB,EAAA,GAAK,OAAA,CAAQ,MAAA;EAAA;AAAA,IAEpC,CAAA;;;AArFJ;;;;;;;;;;;;AAOA;;;;;;;;;;;;;;;;;AAPA,iBCsCgB,aAAA,uBACQ,aAAA,iBAAA,CACtB,MAAA,EAAQ,OAAA,GAAU,OAAA,CAAQ,WAAA,CAAY,OAAA,GAAU,WAAA,CAAY,OAAA"}
+{"version":3,"file":"index2.d.ts","names":[],"sources":["../../../src/types.ts","../../../src/machine.ts"],"mappings":";;AAGA;;KAAY,gBAAA,0BACR,MAAA;EACE,MAAA,EAAQ,MAAA;EAAQ,KAAA,GAAQ,OAAA;AAAA;;;;UAKb,WAAA;EACf,EAAA,GAAK,OAAA,CAAQ,MAAA,CAAO,MAAA,EAAQ,gBAAA,CAAiB,MAAA;AAAA;AAD/C;;;AAAA,UAOiB,aAAA;EACf,OAAA,EAAS,MAAA;EACT,MAAA,EAAQ,MAAA,CAAO,MAAA,EAAQ,WAAA,CAAY,MAAA,EAAQ,MAAA;AAAA;;;;UAM5B,YAAA;EACf,IAAA,EAAM,MAAA;EACN,OAAA;AAAA;;;;KAMU,aAAA,oCAAiD,KAAA,EAAO,YAAA,CAAa,MAAA;;;AAhBjF;KAqBY,kBAAA,oEACV,IAAA,EAAM,MAAA,EACN,EAAA,EAAI,MAAA,EACJ,KAAA,EAAO,YAAA,CAAa,MAAA;;;;UAML,OAAA;EA5B4B;EAAA,IA8BvC,MAAA;EA9BI;EAiCR,IAAA,GAAO,KAAA,EAAO,MAAA,EAAQ,OAAA;EAjCR;EAoCd,OAAA,MAAa,MAAA,EAAQ,MAAA;EAtC+B;EAyCpD,GAAA,GAAM,KAAA,EAAO,MAAA;EAxCJ;EA2CT,UAAA,QAAkB,MAAA;EA1CV;EA6CR,KAAA;EA7CuB;EAgDvB,OAAA,GAAU,KAAA,EAAO,MAAA,EAAQ,QAAA,EAAU,aAAA,CAAc,MAAA;EAhDN;EAmD3C,YAAA,GAAe,QAAA,EAAU,kBAAA,CAAmB,MAAA,EAAQ,MAAA;EAnDH;EAsDjD,OAAA;AAAA;;KAMU,WAAA,MAAiB,CAAA;EAAY,MAAA,EAAQ,MAAA;AAAA,IAA6B,CAAA;;KAGlE,WAAA,MAAiB,CAAA;EAC3B,MAAA,EAAQ,MAAA;IAAiB,EAAA,GAAK,OAAA,CAAQ,MAAA;EAAA;AAAA,IAEpC,CAAA;;;AAlFJ;;;;;;;;;;;;AAOA;;;;;;;;;;;;;;;;;AAPA,iBCsCgB,aAAA,uBAAoC,aAAA,iBAAA,CAClD,MAAA,EAAQ,OAAA,GACP,OAAA,CAAQ,WAAA,CAAY,OAAA,GAAU,WAAA,CAAY,OAAA"}

package/package.json

@@ -1,16 +1,16 @@
 {
   "name": "@pyreon/machine",
-  "version": "0.10.0",
+  "version": "0.11.0",
   "description": "Reactive state machines for Pyreon — constrained signals with type-safe transitions",
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/pyreon/fundamentals.git",
-    "directory": "packages/machine"
+    "url": "https://github.com/pyreon/pyreon.git",
+    "directory": "packages/fundamentals/machine"
   },
   "homepage": "https://github.com/pyreon/fundamentals/tree/main/packages/machine#readme",
   "bugs": {
-    "url": "https://github.com/pyreon/fundamentals/issues"
+    "url": "https://github.com/pyreon/pyreon/issues"
   },
   "publishConfig": {
     "access": "public"
@@ -37,9 +37,15 @@
     "build": "vl_rolldown_build",
     "dev": "vl_rolldown_build-watch",
     "test": "vitest run",
-    "typecheck": "tsc --noEmit"
+    "typecheck": "tsc --noEmit",
+    "lint": "biome check ."
   },
   "peerDependencies": {
-    "@pyreon/reactivity": ">=0.7.0 <0.8.0"
+    "@pyreon/reactivity": "^0.11.0"
+  },
+  "devDependencies": {
+    "@happy-dom/global-registrator": "^20.8.3",
+    "@pyreon/reactivity": "^0.11.0",
+    "@vitus-labs/tools-lint": "^1.11.0"
   }
 }

package/src/index.ts

@@ -25,7 +25,7 @@
  * ```
  */
 
-export { createMachine } from './machine'
+export { createMachine } from "./machine"
 
 // Types
 export type {
@@ -38,4 +38,4 @@ export type {
   StateConfig,
   TransitionCallback,
   TransitionConfig,
-} from './types'
+} from "./types"

package/src/machine.ts

@@ -1,4 +1,4 @@
-import { signal } from '@pyreon/reactivity'
+import { signal } from "@pyreon/reactivity"
 import type {
   EnterCallback,
   InferEvents,
@@ -8,7 +8,7 @@ import type {
   MachineEvent,
   TransitionCallback,
   TransitionConfig,
-} from './types'
+} from "./types"
 
 /**
  * Create a reactive state machine — a constrained signal with type-safe transitions.
@@ -39,9 +39,9 @@ import type {
  * {() => machine.matches('loading') && <Spinner />}
  * ```
  */
-export function createMachine<
-  const TConfig extends MachineConfig<string, string>,
->(config: TConfig): Machine<InferStates<TConfig>, InferEvents<TConfig>> {
+export function createMachine<const TConfig extends MachineConfig<string, string>>(
+  config: TConfig,
+): Machine<InferStates<TConfig>, InferEvents<TConfig>> {
   type TState = InferStates<TConfig>
   type TEvent = InferEvents<TConfig>
 
@@ -49,9 +49,7 @@ export function createMachine<
 
   // Validate initial state
   if (!(initial in states)) {
-    throw new Error(
-      `[@pyreon/machine] Initial state '${initial}' is not defined in states`,
-    )
+    throw new Error(`[@pyreon/machine] Initial state '${initial}' is not defined in states`)
   }
 
   const current = signal<TState>(initial)
@@ -62,12 +60,10 @@ export function createMachine<
     const stateConfig = states[current.peek()]
     if (!stateConfig?.on) return null
 
-    const transition = stateConfig.on[event] as
-      | TransitionConfig<TState>
-      | undefined
+    const transition = stateConfig.on[event] as TransitionConfig<TState> | undefined
     if (!transition) return null
 
-    if (typeof transition === 'string') {
+    if (typeof transition === "string") {
       return transition
     }
 
@@ -134,10 +130,7 @@ export function createMachine<
     current.set(initial)
   }
 
-  machine.onEnter = (
-    state: TState,
-    callback: EnterCallback<TEvent>,
-  ): (() => void) => {
+  machine.onEnter = (state: TState, callback: EnterCallback<TEvent>): (() => void) => {
     if (!enterListeners.has(state)) {
       enterListeners.set(state, new Set())
     }
@@ -148,9 +141,7 @@ export function createMachine<
     }
   }
 
-  machine.onTransition = (
-    callback: TransitionCallback<TState, TEvent>,
-  ): (() => void) => {
+  machine.onTransition = (callback: TransitionCallback<TState, TEvent>): (() => void) => {
     transitionListeners.add(callback)
     return () => {
       transitionListeners.delete(callback)

package/src/tests/machine.test.ts

@@ -1,167 +1,167 @@
-import { computed, effect, signal } from '@pyreon/reactivity'
-import { describe, expect, it, vi } from 'vitest'
-import { createMachine } from '../index'
+import { computed, effect, signal } from "@pyreon/reactivity"
+import { describe, expect, it, vi } from "vitest"
+import { createMachine } from "../index"
 
-describe('createMachine', () => {
+describe("createMachine", () => {
   // ─── Basic state and transitions ─────────────────────────────────────
 
-  describe('basic transitions', () => {
-    it('starts in initial state', () => {
+  describe("basic transitions", () => {
+    it("starts in initial state", () => {
       const m = createMachine({
-        initial: 'idle',
+        initial: "idle",
         states: {
-          idle: { on: { START: 'running' } },
+          idle: { on: { START: "running" } },
           running: {},
         },
       })
-      expect(m()).toBe('idle')
+      expect(m()).toBe("idle")
     })
 
-    it('transitions on valid event', () => {
+    it("transitions on valid event", () => {
       const m = createMachine({
-        initial: 'idle',
+        initial: "idle",
         states: {
-          idle: { on: { START: 'running' } },
-          running: { on: { STOP: 'idle' } },
+          idle: { on: { START: "running" } },
+          running: { on: { STOP: "idle" } },
         },
       })
-      m.send('START')
-      expect(m()).toBe('running')
+      m.send("START")
+      expect(m()).toBe("running")
     })
 
-    it('ignores invalid events (no-op)', () => {
+    it("ignores invalid events (no-op)", () => {
       const m = createMachine({
-        initial: 'idle',
+        initial: "idle",
         states: {
-          idle: { on: { START: 'running' } },
-          running: { on: { STOP: 'idle' } },
+          idle: { on: { START: "running" } },
+          running: { on: { STOP: "idle" } },
         },
       })
-      m.send('STOP' as any) // not valid in 'idle'
-      expect(m()).toBe('idle')
+      m.send("STOP" as any) // not valid in 'idle'
+      expect(m()).toBe("idle")
     })
 
-    it('supports self-transitions', () => {
+    it("supports self-transitions", () => {
       const m = createMachine({
-        initial: 'counting',
+        initial: "counting",
         states: {
-          counting: { on: { INCREMENT: 'counting' } },
+          counting: { on: { INCREMENT: "counting" } },
         },
       })
-      m.send('INCREMENT')
-      expect(m()).toBe('counting')
+      m.send("INCREMENT")
+      expect(m()).toBe("counting")
     })
 
-    it('supports multiple transitions from one state', () => {
+    it("supports multiple transitions from one state", () => {
       const m = createMachine({
-        initial: 'idle',
+        initial: "idle",
         states: {
-          idle: { on: { FETCH: 'loading', CANCEL: 'cancelled' } },
+          idle: { on: { FETCH: "loading", CANCEL: "cancelled" } },
           loading: {},
           cancelled: {},
         },
       })
 
-      m.send('CANCEL')
-      expect(m()).toBe('cancelled')
+      m.send("CANCEL")
+      expect(m()).toBe("cancelled")
     })
 
-    it('handles states with no transitions (final states)', () => {
+    it("handles states with no transitions (final states)", () => {
       const m = createMachine({
-        initial: 'idle',
+        initial: "idle",
         states: {
-          idle: { on: { DONE: 'finished' } },
+          idle: { on: { DONE: "finished" } },
           finished: {},
         },
       })
-      m.send('DONE')
-      expect(m()).toBe('finished')
-      m.send('DONE') // ignored — no transitions from 'finished'
-      expect(m()).toBe('finished')
+      m.send("DONE")
+      expect(m()).toBe("finished")
+      m.send("DONE") // ignored — no transitions from 'finished'
+      expect(m()).toBe("finished")
     })
 
-    it('throws on invalid initial state', () => {
+    it("throws on invalid initial state", () => {
       expect(() =>
         createMachine({
-          initial: 'nonexistent' as any,
+          initial: "nonexistent" as any,
           states: {
             idle: {},
           },
         }),
-      ).toThrow('[@pyreon/machine] Initial state')
+      ).toThrow("[@pyreon/machine] Initial state")
     })
   })
 
   // ─── Guards ──────────────────────────────────────────────────────────
 
-  describe('guards', () => {
-    it('transitions when guard returns true', () => {
+  describe("guards", () => {
+    it("transitions when guard returns true", () => {
       const m = createMachine({
-        initial: 'editing',
+        initial: "editing",
         states: {
           editing: {
             on: {
-              SUBMIT: { target: 'submitting', guard: () => true },
+              SUBMIT: { target: "submitting", guard: () => true },
             },
           },
           submitting: {},
         },
       })
-      m.send('SUBMIT')
-      expect(m()).toBe('submitting')
+      m.send("SUBMIT")
+      expect(m()).toBe("submitting")
     })
 
-    it('blocks transition when guard returns false', () => {
+    it("blocks transition when guard returns false", () => {
       const m = createMachine({
-        initial: 'editing',
+        initial: "editing",
         states: {
           editing: {
             on: {
-              SUBMIT: { target: 'submitting', guard: () => false },
+              SUBMIT: { target: "submitting", guard: () => false },
             },
           },
           submitting: {},
         },
       })
-      m.send('SUBMIT')
-      expect(m()).toBe('editing')
+      m.send("SUBMIT")
+      expect(m()).toBe("editing")
     })
 
-    it('guard receives event payload', () => {
+    it("guard receives event payload", () => {
       const guardFn = vi.fn((payload?: unknown) => {
         return (payload as any)?.valid === true
       })
 
       const m = createMachine({
-        initial: 'editing',
+        initial: "editing",
         states: {
           editing: {
             on: {
-              SUBMIT: { target: 'submitting', guard: guardFn },
+              SUBMIT: { target: "submitting", guard: guardFn },
             },
           },
           submitting: {},
         },
       })
 
-      m.send('SUBMIT', { valid: false })
-      expect(m()).toBe('editing')
+      m.send("SUBMIT", { valid: false })
+      expect(m()).toBe("editing")
       expect(guardFn).toHaveBeenCalledWith({ valid: false })
 
-      m.send('SUBMIT', { valid: true })
-      expect(m()).toBe('submitting')
+      m.send("SUBMIT", { valid: true })
+      expect(m()).toBe("submitting")
     })
 
-    it('guard with reactive signal', () => {
+    it("guard with reactive signal", () => {
       const isValid = signal(false)
 
       const m = createMachine({
-        initial: 'editing',
+        initial: "editing",
         states: {
           editing: {
             on: {
               SUBMIT: {
-                target: 'submitting',
+                target: "submitting",
                 guard: () => isValid.peek(),
               },
             },
@@ -170,154 +170,154 @@ describe('createMachine', () => {
         },
       })
 
-      m.send('SUBMIT')
-      expect(m()).toBe('editing')
+      m.send("SUBMIT")
+      expect(m()).toBe("editing")
 
       isValid.set(true)
-      m.send('SUBMIT')
-      expect(m()).toBe('submitting')
+      m.send("SUBMIT")
+      expect(m()).toBe("submitting")
     })
   })
 
   // ─── matches ─────────────────────────────────────────────────────────
 
-  describe('matches()', () => {
-    it('returns true for current state', () => {
+  describe("matches()", () => {
+    it("returns true for current state", () => {
       const m = createMachine({
-        initial: 'idle',
+        initial: "idle",
         states: {
-          idle: { on: { START: 'running' } },
+          idle: { on: { START: "running" } },
           running: {},
         },
       })
-      expect(m.matches('idle')).toBe(true)
-      expect(m.matches('running')).toBe(false)
+      expect(m.matches("idle")).toBe(true)
+      expect(m.matches("running")).toBe(false)
     })
 
-    it('supports multiple states', () => {
+    it("supports multiple states", () => {
       const m = createMachine({
-        initial: 'loading',
+        initial: "loading",
         states: {
           idle: {},
           loading: {},
           error: {},
         },
       })
-      expect(m.matches('loading', 'error')).toBe(true)
-      expect(m.matches('idle', 'error')).toBe(false)
+      expect(m.matches("loading", "error")).toBe(true)
+      expect(m.matches("idle", "error")).toBe(false)
     })
 
-    it('is reactive in effects', () => {
+    it("is reactive in effects", () => {
       const m = createMachine({
-        initial: 'idle',
+        initial: "idle",
         states: {
-          idle: { on: { START: 'running' } },
-          running: { on: { STOP: 'idle' } },
+          idle: { on: { START: "running" } },
+          running: { on: { STOP: "idle" } },
         },
       })
       const results: boolean[] = []
 
       effect(() => {
-        results.push(m.matches('running'))
+        results.push(m.matches("running"))
       })
 
       expect(results).toEqual([false])
 
-      m.send('START')
+      m.send("START")
       expect(results).toEqual([false, true])
 
-      m.send('STOP')
+      m.send("STOP")
       expect(results).toEqual([false, true, false])
     })
   })
 
   // ─── can ─────────────────────────────────────────────────────────────
 
-  describe('can()', () => {
-    it('returns true for valid events', () => {
+  describe("can()", () => {
+    it("returns true for valid events", () => {
       const m = createMachine({
-        initial: 'idle',
+        initial: "idle",
         states: {
-          idle: { on: { START: 'running' } },
-          running: { on: { STOP: 'idle' } },
+          idle: { on: { START: "running" } },
+          running: { on: { STOP: "idle" } },
         },
       })
-      expect(m.can('START')).toBe(true)
-      expect(m.can('STOP')).toBe(false)
+      expect(m.can("START")).toBe(true)
+      expect(m.can("STOP")).toBe(false)
     })
 
-    it('is reactive', () => {
+    it("is reactive", () => {
       const m = createMachine({
-        initial: 'idle',
+        initial: "idle",
         states: {
-          idle: { on: { START: 'running' } },
-          running: { on: { STOP: 'idle' } },
+          idle: { on: { START: "running" } },
+          running: { on: { STOP: "idle" } },
         },
       })
       const results: boolean[] = []
 
       effect(() => {
-        results.push(m.can('STOP'))
+        results.push(m.can("STOP"))
       })
 
       expect(results).toEqual([false])
 
-      m.send('START')
+      m.send("START")
       expect(results).toEqual([false, true])
     })
 
-    it('returns true for guarded transitions (guard not evaluated)', () => {
+    it("returns true for guarded transitions (guard not evaluated)", () => {
       const m = createMachine({
-        initial: 'editing',
+        initial: "editing",
         states: {
           editing: {
             on: {
-              SUBMIT: { target: 'submitting', guard: () => false },
+              SUBMIT: { target: "submitting", guard: () => false },
             },
           },
           submitting: {},
         },
       })
       // can() returns true because the event exists, even though guard would fail
-      expect(m.can('SUBMIT')).toBe(true)
+      expect(m.can("SUBMIT")).toBe(true)
     })
   })
 
   // ─── nextEvents ──────────────────────────────────────────────────────
 
-  describe('nextEvents()', () => {
-    it('returns available events from current state', () => {
+  describe("nextEvents()", () => {
+    it("returns available events from current state", () => {
       const m = createMachine({
-        initial: 'idle',
+        initial: "idle",
         states: {
-          idle: { on: { FETCH: 'loading', RESET: 'idle' } },
-          loading: { on: { SUCCESS: 'done', ERROR: 'error' } },
+          idle: { on: { FETCH: "loading", RESET: "idle" } },
+          loading: { on: { SUCCESS: "done", ERROR: "error" } },
           done: {},
           error: {},
         },
       })
-      expect(m.nextEvents()).toEqual(expect.arrayContaining(['FETCH', 'RESET']))
+      expect(m.nextEvents()).toEqual(expect.arrayContaining(["FETCH", "RESET"]))
     })
 
-    it('returns empty array for final states', () => {
+    it("returns empty array for final states", () => {
       const m = createMachine({
-        initial: 'idle',
+        initial: "idle",
         states: {
-          idle: { on: { DONE: 'finished' } },
+          idle: { on: { DONE: "finished" } },
           finished: {},
         },
       })
-      m.send('DONE')
+      m.send("DONE")
       expect(m.nextEvents()).toEqual([])
     })
 
-    it('is reactive', () => {
+    it("is reactive", () => {
       const m = createMachine({
-        initial: 'idle',
+        initial: "idle",
         states: {
-          idle: { on: { START: 'running' } },
-          running: { on: { STOP: 'idle', PAUSE: 'paused' } },
-          paused: { on: { RESUME: 'running' } },
+          idle: { on: { START: "running" } },
+          running: { on: { STOP: "idle", PAUSE: "paused" } },
+          paused: { on: { RESUME: "running" } },
         },
       })
       const results: string[][] = []
@@ -326,40 +326,40 @@ describe('createMachine', () => {
         results.push(m.nextEvents())
       })
 
-      m.send('START')
+      m.send("START")
       expect(results).toHaveLength(2)
-      expect(results[1]).toEqual(expect.arrayContaining(['STOP', 'PAUSE']))
+      expect(results[1]).toEqual(expect.arrayContaining(["STOP", "PAUSE"]))
     })
   })
 
   // ─── reset ───────────────────────────────────────────────────────────
 
-  describe('reset()', () => {
-    it('returns to initial state', () => {
+  describe("reset()", () => {
+    it("returns to initial state", () => {
       const m = createMachine({
-        initial: 'idle',
+        initial: "idle",
         states: {
-          idle: { on: { START: 'running' } },
-          running: { on: { STOP: 'idle' } },
+          idle: { on: { START: "running" } },
+          running: { on: { STOP: "idle" } },
         },
       })
-      m.send('START')
-      expect(m()).toBe('running')
+      m.send("START")
+      expect(m()).toBe("running")
 
       m.reset()
-      expect(m()).toBe('idle')
+      expect(m()).toBe("idle")
     })
   })
 
   // ─── Reactivity ────────────────────────────────────────────────────
 
-  describe('reactivity', () => {
-    it('machine() is reactive in effect', () => {
+  describe("reactivity", () => {
+    it("machine() is reactive in effect", () => {
       const m = createMachine({
-        initial: 'a',
+        initial: "a",
         states: {
-          a: { on: { NEXT: 'b' } },
-          b: { on: { NEXT: 'c' } },
+          a: { on: { NEXT: "b" } },
+          b: { on: { NEXT: "c" } },
           c: {},
         },
       })
@@ -369,141 +369,141 @@ describe('createMachine', () => {
         states.push(m())
       })
 
-      m.send('NEXT')
-      m.send('NEXT')
+      m.send("NEXT")
+      m.send("NEXT")
 
-      expect(states).toEqual(['a', 'b', 'c'])
+      expect(states).toEqual(["a", "b", "c"])
     })
 
-    it('machine() is reactive in computed', () => {
+    it("machine() is reactive in computed", () => {
       const m = createMachine({
-        initial: 'idle',
+        initial: "idle",
         states: {
-          idle: { on: { LOAD: 'loading' } },
-          loading: { on: { DONE: 'idle' } },
+          idle: { on: { LOAD: "loading" } },
+          loading: { on: { DONE: "idle" } },
         },
       })
 
-      const isLoading = computed(() => m() === 'loading')
+      const isLoading = computed(() => m() === "loading")
       expect(isLoading()).toBe(false)
 
-      m.send('LOAD')
+      m.send("LOAD")
       expect(isLoading()).toBe(true)
 
-      m.send('DONE')
+      m.send("DONE")
       expect(isLoading()).toBe(false)
     })
   })
 
   // ─── onEnter ─────────────────────────────────────────────────────────
 
-  describe('onEnter()', () => {
-    it('fires when entering a state', () => {
+  describe("onEnter()", () => {
+    it("fires when entering a state", () => {
       const m = createMachine({
-        initial: 'idle',
+        initial: "idle",
         states: {
-          idle: { on: { LOAD: 'loading' } },
-          loading: { on: { DONE: 'idle' } },
+          idle: { on: { LOAD: "loading" } },
+          loading: { on: { DONE: "idle" } },
         },
       })
       const entered: string[] = []
 
-      m.onEnter('loading', (event) => {
+      m.onEnter("loading", (event) => {
         entered.push(event.type)
       })
 
-      m.send('LOAD')
-      expect(entered).toEqual(['LOAD'])
+      m.send("LOAD")
+      expect(entered).toEqual(["LOAD"])
     })
 
-    it('does not fire for other states', () => {
+    it("does not fire for other states", () => {
       const m = createMachine({
-        initial: 'a',
+        initial: "a",
         states: {
-          a: { on: { GO: 'b' } },
-          b: { on: { GO: 'c' } },
+          a: { on: { GO: "b" } },
+          b: { on: { GO: "c" } },
           c: {},
         },
       })
       const fn = vi.fn()
 
-      m.onEnter('c', fn)
-      m.send('GO') // a → b
+      m.onEnter("c", fn)
+      m.send("GO") // a → b
       expect(fn).not.toHaveBeenCalled()
 
-      m.send('GO') // b → c
+      m.send("GO") // b → c
       expect(fn).toHaveBeenCalledOnce()
     })
 
-    it('receives event payload', () => {
+    it("receives event payload", () => {
       const m = createMachine({
-        initial: 'idle',
+        initial: "idle",
         states: {
-          idle: { on: { SELECT: 'selected' } },
+          idle: { on: { SELECT: "selected" } },
           selected: {},
         },
       })
       let received: unknown = null
 
-      m.onEnter('selected', (event) => {
+      m.onEnter("selected", (event) => {
         received = event.payload
       })
 
-      m.send('SELECT', { id: 42 })
+      m.send("SELECT", { id: 42 })
       expect(received).toEqual({ id: 42 })
     })
 
-    it('fires on self-transitions', () => {
+    it("fires on self-transitions", () => {
       const m = createMachine({
-        initial: 'counting',
+        initial: "counting",
         states: {
-          counting: { on: { INC: 'counting' } },
+          counting: { on: { INC: "counting" } },
         },
       })
       const fn = vi.fn()
 
-      m.onEnter('counting', fn)
-      m.send('INC')
-      m.send('INC')
+      m.onEnter("counting", fn)
+      m.send("INC")
+      m.send("INC")
 
       expect(fn).toHaveBeenCalledTimes(2)
     })
 
-    it('returns unsubscribe function', () => {
+    it("returns unsubscribe function", () => {
       const m = createMachine({
-        initial: 'a',
+        initial: "a",
         states: {
-          a: { on: { GO: 'b' } },
-          b: { on: { GO: 'a' } },
+          a: { on: { GO: "b" } },
+          b: { on: { GO: "a" } },
         },
       })
       const fn = vi.fn()
 
-      const unsub = m.onEnter('b', fn)
-      m.send('GO') // a → b
+      const unsub = m.onEnter("b", fn)
+      m.send("GO") // a → b
       expect(fn).toHaveBeenCalledOnce()
 
       unsub()
-      m.send('GO') // b → a
-      m.send('GO') // a → b again
+      m.send("GO") // b → a
+      m.send("GO") // a → b again
       expect(fn).toHaveBeenCalledOnce() // not called again
     })
 
-    it('multiple listeners for same state', () => {
+    it("multiple listeners for same state", () => {
       const m = createMachine({
-        initial: 'idle',
+        initial: "idle",
         states: {
-          idle: { on: { GO: 'active' } },
+          idle: { on: { GO: "active" } },
           active: {},
         },
       })
       const fn1 = vi.fn()
       const fn2 = vi.fn()
 
-      m.onEnter('active', fn1)
-      m.onEnter('active', fn2)
+      m.onEnter("active", fn1)
+      m.onEnter("active", fn2)
 
-      m.send('GO')
+      m.send("GO")
       expect(fn1).toHaveBeenCalledOnce()
       expect(fn2).toHaveBeenCalledOnce()
     })
@@ -511,13 +511,13 @@ describe('createMachine', () => {
 
   // ─── onTransition ────────────────────────────────────────────────────
 
-  describe('onTransition()', () => {
-    it('fires on every transition', () => {
+  describe("onTransition()", () => {
+    it("fires on every transition", () => {
       const m = createMachine({
-        initial: 'a',
+        initial: "a",
         states: {
-          a: { on: { NEXT: 'b' } },
-          b: { on: { NEXT: 'c' } },
+          a: { on: { NEXT: "b" } },
+          b: { on: { NEXT: "c" } },
           c: {},
         },
       })
@@ -527,70 +527,70 @@ describe('createMachine', () => {
         transitions.push([from, to, event.type])
       })
 
-      m.send('NEXT')
-      m.send('NEXT')
+      m.send("NEXT")
+      m.send("NEXT")
 
       expect(transitions).toEqual([
-        ['a', 'b', 'NEXT'],
-        ['b', 'c', 'NEXT'],
+        ["a", "b", "NEXT"],
+        ["b", "c", "NEXT"],
       ])
     })
 
-    it('does not fire when event is ignored', () => {
+    it("does not fire when event is ignored", () => {
       const m = createMachine({
-        initial: 'idle',
+        initial: "idle",
         states: {
-          idle: { on: { START: 'running' } },
+          idle: { on: { START: "running" } },
           running: {},
         },
       })
       const fn = vi.fn()
 
       m.onTransition(fn)
-      m.send('STOP' as any) // invalid event
+      m.send("STOP" as any) // invalid event
       expect(fn).not.toHaveBeenCalled()
     })
 
-    it('returns unsubscribe function', () => {
+    it("returns unsubscribe function", () => {
       const m = createMachine({
-        initial: 'a',
+        initial: "a",
         states: {
-          a: { on: { GO: 'b' } },
-          b: { on: { GO: 'a' } },
+          a: { on: { GO: "b" } },
+          b: { on: { GO: "a" } },
         },
       })
       const fn = vi.fn()
 
       const unsub = m.onTransition(fn)
-      m.send('GO')
+      m.send("GO")
       expect(fn).toHaveBeenCalledOnce()
 
       unsub()
-      m.send('GO')
+      m.send("GO")
       expect(fn).toHaveBeenCalledOnce() // not called again
     })
   })
 
   // ─── dispose ─────────────────────────────────────────────────────────
 
-  describe('dispose()', () => {
-    it('removes all listeners', () => {
+  describe("dispose()", () => {
+    it("removes all listeners", () => {
       const m = createMachine({
-        initial: 'a',
+        initial: "a",
         states: {
-          a: { on: { GO: 'b' } },
-          b: { on: { GO: 'a' } },
+          a: { on: { GO: "b" } },
+          b: { on: { GO: "a" } },
         },
       })
       const enterFn = vi.fn()
       const transitionFn = vi.fn()
 
-      m.onEnter('b', enterFn)
+      m.onEnter("b", enterFn)
       m.onTransition(transitionFn)
 
       m.dispose()
 
-      m.send('GO')
+      m.send("GO")
       expect(enterFn).not.toHaveBeenCalled()
       expect(transitionFn).not.toHaveBeenCalled()
     })
@@ -598,139 +598,139 @@ describe('createMachine', () => {
 
   // ─── Real-world patterns ───────────────────────────────────────────
 
-  describe('real-world patterns', () => {
-    it('multi-step wizard', () => {
+  describe("real-world patterns", () => {
+    it("multi-step wizard", () => {
       const m = createMachine({
-        initial: 'step1',
+        initial: "step1",
         states: {
-          step1: { on: { NEXT: 'step2' } },
-          step2: { on: { NEXT: 'step3', BACK: 'step1' } },
-          step3: { on: { SUBMIT: 'submitting', BACK: 'step2' } },
-          submitting: { on: { SUCCESS: 'done', ERROR: 'step3' } },
+          step1: { on: { NEXT: "step2" } },
+          step2: { on: { NEXT: "step3", BACK: "step1" } },
+          step3: { on: { SUBMIT: "submitting", BACK: "step2" } },
+          submitting: { on: { SUCCESS: "done", ERROR: "step3" } },
           done: {},
         },
       })
 
-      m.send('NEXT') // step1 → step2
-      m.send('NEXT') // step2 → step3
-      expect(m()).toBe('step3')
+      m.send("NEXT") // step1 → step2
+      m.send("NEXT") // step2 → step3
+      expect(m()).toBe("step3")
 
-      m.send('BACK') // step3 → step2
-      expect(m()).toBe('step2')
+      m.send("BACK") // step3 → step2
+      expect(m()).toBe("step2")
 
-      m.send('NEXT') // step2 → step3
-      m.send('SUBMIT') // step3 → submitting
-      expect(m()).toBe('submitting')
+      m.send("NEXT") // step2 → step3
+      m.send("SUBMIT") // step3 → submitting
+      expect(m()).toBe("submitting")
 
-      m.send('SUCCESS')
-      expect(m()).toBe('done')
+      m.send("SUCCESS")
+      expect(m()).toBe("done")
 
       // Final state — no more transitions
-      m.send('SUBMIT')
-      expect(m()).toBe('done')
+      m.send("SUBMIT")
+      expect(m()).toBe("done")
     })
 
-    it('async fetch with onEnter', () => {
+    it("async fetch with onEnter", () => {
       const m = createMachine({
-        initial: 'idle',
+        initial: "idle",
         states: {
-          idle: { on: { FETCH: 'loading' } },
-          loading: { on: { SUCCESS: 'done', ERROR: 'error' } },
-          done: { on: { REFETCH: 'loading' } },
-          error: { on: { RETRY: 'loading' } },
+          idle: { on: { FETCH: "loading" } },
+          loading: { on: { SUCCESS: "done", ERROR: "error" } },
+          done: { on: { REFETCH: "loading" } },
+          error: { on: { RETRY: "loading" } },
         },
       })
 
       const data = signal<string | null>(null)
 
-      m.onEnter('loading', () => {
+      m.onEnter("loading", () => {
         // Simulate async — in real code this would be an API call
-        data.set('loaded data')
-        m.send('SUCCESS')
+        data.set("loaded data")
+        m.send("SUCCESS")
       })
 
-      m.send('FETCH')
-      expect(m()).toBe('done')
-      expect(data()).toBe('loaded data')
+      m.send("FETCH")
+      expect(m()).toBe("done")
+      expect(data()).toBe("loaded data")
     })
 
-    it('toggle with reactive UI', () => {
+    it("toggle with reactive UI", () => {
       const m = createMachine({
-        initial: 'off',
+        initial: "off",
         states: {
-          off: { on: { TOGGLE: 'on' } },
-          on: { on: { TOGGLE: 'off' } },
+          off: { on: { TOGGLE: "on" } },
+          on: { on: { TOGGLE: "off" } },
         },
       })
 
       const labels: string[] = []
       effect(() => {
-        labels.push(m.matches('on') ? 'ON' : 'OFF')
+        labels.push(m.matches("on") ? "ON" : "OFF")
       })
 
-      m.send('TOGGLE')
-      m.send('TOGGLE')
-      m.send('TOGGLE')
+      m.send("TOGGLE")
+      m.send("TOGGLE")
+      m.send("TOGGLE")
 
-      expect(labels).toEqual(['OFF', 'ON', 'OFF', 'ON'])
+      expect(labels).toEqual(["OFF", "ON", "OFF", "ON"])
     })
 
-    it('form with validation guard', () => {
+    it("form with validation guard", () => {
       const isValid = signal(false)
 
       const m = createMachine({
-        initial: 'editing',
+        initial: "editing",
         states: {
           editing: {
             on: {
               SUBMIT: {
-                target: 'submitting',
+                target: "submitting",
                 guard: () => isValid.peek(),
               },
             },
           },
-          submitting: { on: { SUCCESS: 'done', ERROR: 'editing' } },
+          submitting: { on: { SUCCESS: "done", ERROR: "editing" } },
           done: {},
         },
       })
 
-      m.send('SUBMIT') // guard fails
-      expect(m()).toBe('editing')
+      m.send("SUBMIT") // guard fails
+      expect(m()).toBe("editing")
 
       isValid.set(true)
-      m.send('SUBMIT') // guard passes
-      expect(m()).toBe('submitting')
+      m.send("SUBMIT") // guard passes
+      expect(m()).toBe("submitting")
     })
 
-    it('player with pause/resume', () => {
+    it("player with pause/resume", () => {
       const m = createMachine({
-        initial: 'stopped',
+        initial: "stopped",
         states: {
-          stopped: { on: { PLAY: 'playing' } },
-          playing: { on: { PAUSE: 'paused', STOP: 'stopped' } },
-          paused: { on: { PLAY: 'playing', STOP: 'stopped' } },
+          stopped: { on: { PLAY: "playing" } },
+          playing: { on: { PAUSE: "paused", STOP: "stopped" } },
+          paused: { on: { PLAY: "playing", STOP: "stopped" } },
         },
       })
 
-      m.send('PLAY')
-      expect(m()).toBe('playing')
+      m.send("PLAY")
+      expect(m()).toBe("playing")
 
-      m.send('PAUSE')
-      expect(m()).toBe('paused')
+      m.send("PAUSE")
+      expect(m()).toBe("paused")
 
-      m.send('PLAY')
-      expect(m()).toBe('playing')
+      m.send("PLAY")
+      expect(m()).toBe("playing")
 
-      m.send('STOP')
-      expect(m()).toBe('stopped')
+      m.send("STOP")
+      expect(m()).toBe("stopped")
     })
 
-    it('analytics tracking via onTransition', () => {
+    it("analytics tracking via onTransition", () => {
       const m = createMachine({
-        initial: 'step1',
+        initial: "step1",
         states: {
-          step1: { on: { NEXT: 'step2' } },
-          step2: { on: { NEXT: 'step3' } },
+          step1: { on: { NEXT: "step2" } },
+          step2: { on: { NEXT: "step3" } },
           step3: {},
         },
       })
@@ -740,27 +740,27 @@ describe('createMachine', () => {
         tracked.push(`${from} → ${to}`)
       })
 
-      m.send('NEXT')
-      m.send('NEXT')
+      m.send("NEXT")
+      m.send("NEXT")
 
-      expect(tracked).toEqual(['step1 → step2', 'step2 → step3'])
+      expect(tracked).toEqual(["step1 → step2", "step2 → step3"])
     })
 
-    it('reusable machine definition', () => {
+    it("reusable machine definition", () => {
       const toggleDef = {
-        initial: 'off' as const,
+        initial: "off" as const,
         states: {
-          off: { on: { TOGGLE: 'on' as const } },
-          on: { on: { TOGGLE: 'off' as const } },
+          off: { on: { TOGGLE: "on" as const } },
+          on: { on: { TOGGLE: "off" as const } },
         },
       }
 
       const m1 = createMachine(toggleDef)
       const m2 = createMachine(toggleDef)
 
-      m1.send('TOGGLE')
-      expect(m1()).toBe('on')
-      expect(m2()).toBe('off') // independent instance
+      m1.send("TOGGLE")
+      expect(m1()).toBe("on")
+      expect(m2()).toBe("off") // independent instance
     })
   })
 })

package/src/types.ts

@@ -31,17 +31,16 @@ export interface MachineEvent<TEvent extends string = string> {
 /**
  * Callback for onEnter — receives the event that caused the transition.
  */
-export type EnterCallback<TEvent extends string = string> = (
-  event: MachineEvent<TEvent>,
-) => void
+export type EnterCallback<TEvent extends string = string> = (event: MachineEvent<TEvent>) => void
 
 /**
  * Callback for onTransition — receives from state, to state, and the event.
  */
-export type TransitionCallback<
-  TState extends string = string,
-  TEvent extends string = string,
-> = (from: TState, to: TState, event: MachineEvent<TEvent>) => void
+export type TransitionCallback<TState extends string = string, TEvent extends string = string> = (
+  from: TState,
+  to: TState,
+  event: MachineEvent<TEvent>,
+) => void
 
 /**
  * The machine instance returned by `createMachine()`.
@@ -78,9 +77,7 @@ export interface Machine<TState extends string, TEvent extends string> {
 // ─── Type inference helpers ──────────────────────────────────────────────────
 
 /** Extract state names from a machine config */
-export type InferStates<T> = T extends { states: Record<infer S, unknown> }
-  ? S & string
-  : never
+export type InferStates<T> = T extends { states: Record<infer S, unknown> } ? S & string : never
 
 /** Extract event names from a machine config */
 export type InferEvents<T> = T extends {