machina 7.0.0 → 8.0.0

package/dist/index.d.mts

@@ -27,8 +27,13 @@ type Subscription = {
  * @typeParam TBubbles - String literal union of inputs this FSM declares via
  *   `bubbles`. Type-only — carried so `BubblesOfInstance` can extract it from
  *   a constructed instance; nothing at runtime reads this generic.
+ * @typeParam TInputs - The input payload map (#195). Defaults to the wide
+ *   map, under which `handle()`'s signature reduces to exactly the untyped
+ *   behavior: `keyof` of the wide map is `string`, so the key intersection
+ *   is `TInputNames` and the payload lookup is `unknown[]`. The typed
+ *   factory forms pass the user's map here.
  */
-declare class BehavioralFsm<TClient extends object, TStateNames extends string, TInputNames extends string, TBubbles extends string = never> {
+declare class BehavioralFsm<TClient extends object, TStateNames extends string, TInputNames extends string, TBubbles extends string = never, TInputs extends InputMapLike<TInputs> = InputMap> {
   readonly id: string;
   readonly initialState: TStateNames;
   readonly [MACHINA_TYPE]: "BehavioralFsm";
@@ -50,7 +55,14 @@ declare class BehavioralFsm<TClient extends object, TStateNames extends string,
    *
    * No-ops silently when disposed.
    */
-  handle(client: TClient, inputName: TInputNames, ...args: unknown[]): void;
+  handle(client: TClient, ...call: InputCall<TInputNames, TInputs>): void;
+  /**
+   * Untyped core of `handle()`, split out for internal callers (deferred
+   * replay). Replayed inputs were captured as `unknown[]`, and their
+   * payload types were already enforced at the original `handle()` call —
+   * so replay need not satisfy the payload-map generics.
+   */
+  private dispatch;
   /**
    * Returns true if the client's current state has a handler for `inputName`
    * (or a catch-all `"*"` handler), or if the current state's `_child` chain
@@ -353,9 +365,9 @@ declare class BehavioralFsm<TClient extends object, TStateNames extends string,
  * });
  * ```
  */
-declare function createBehavioralFsm<TClient extends object>(): <const TStates extends Record<string, Record<string, unknown>>, TStateNames extends string = keyof TStates & string, TBubbles extends string = never>(config: FsmConfig<TClient, TStates, TStateNames, TBubbles>) => BehavioralFsm<TClient, keyof TStates & string, Exclude<{ [S in keyof TStates]: keyof TStates[S] & string }[keyof TStates], SpecialStateKeys> | { [S in keyof TStates]: TStates[S] extends {
+declare function createBehavioralFsm<TClient extends object, TInputs extends InputMapLike<TInputs> = InputMap>(): <const TStates extends Record<string, Record<string, unknown>>, TStateNames extends string = keyof TStates & string, TBubbles extends keyof TInputs & string = never>(config: FsmConfig<TClient, TStates, TStateNames, TBubbles, TInputs>) => BehavioralFsm<TClient, keyof TStates & string, string extends keyof TInputs ? Exclude<{ [S in keyof TStates]: keyof TStates[S] & string }[keyof TStates], SpecialStateKeys> | { [S in keyof TStates]: TStates[S] extends {
   _child: infer C;
-} ? InputNamesOfInstance<C> : never }[keyof TStates] | TBubbles, TBubbles>;
+} ? InputNamesOfInstance<C> : never }[keyof TStates] | TBubbles : keyof TInputs & string, TBubbles, TInputs>;
 declare function createBehavioralFsm<TClient extends object, const TStates extends Record<string, Record<string, unknown>>, TStateNames extends string = keyof TStates & string, TBubbles extends string = never>(config: FsmConfig<TClient, TStates, TStateNames, TBubbles>): BehavioralFsm<TClient, keyof TStates & string, Exclude<{ [S in keyof TStates]: keyof TStates[S] & string }[keyof TStates], SpecialStateKeys> | { [S in keyof TStates]: TStates[S] extends {
   _child: infer C;
 } ? InputNamesOfInstance<C> : never }[keyof TStates] | TBubbles, TBubbles>;
@@ -466,6 +478,67 @@ type ClientOf<TFsm> = TFsm extends BehavioralFsm<infer TClient extends object, i
  * that declared no `bubbles` (the common case) or for a non-machina type.
  */
 type BubblesOfInstance<TFsm> = TFsm extends Fsm<infer _TCtx extends object, infer _TStateNames extends string, infer _TInputNames extends string, infer TBubbles extends string> ? TBubbles : TFsm extends BehavioralFsm<infer _TClient extends object, infer _TStateNames extends string, infer _TInputNames extends string, infer TBubbles extends string> ? TBubbles : never;
+/**
+ * Extracts the input payload map from a concrete machina FSM instance (#195).
+ *
+ * Falls back to the wide map — not `never` — for non-FSM types and for
+ * `any`: tooling (machina-test's walkAll) derives config types from this,
+ * and the wide map is what keeps the untyped path's config shape unchanged.
+ * The `0 extends 1 & TFsm` clause detects `any`, which would otherwise take
+ * both conditional branches and produce a useless union.
+ */
+type InputMapOfInstance<TFsm> = 0 extends 1 & TFsm ? InputMap : TFsm extends Fsm<infer _TCtx extends object, infer _TStateNames extends string, infer _TInputNames extends string, infer _TBubbles extends string, infer TInputs extends InputMapLike<TInputs>> ? TInputs : TFsm extends BehavioralFsm<infer _TClient extends object, infer _TStateNames extends string, infer _TInputNames extends string, infer _TBubbles extends string, infer TInputs extends InputMapLike<TInputs>> ? TInputs : InputMap;
+/**
+ * Constraint for input payload maps: input name → argument tuple.
+ *
+ * An empty tuple means the input carries no payload.
+ *
+ * @example
+ * ```ts
+ * type TrafficLightInputs = {
+ *   timeout: [];
+ *   emergency: [event: { severity: number }];
+ * };
+ *
+ * const light = createFsm<TrafficLightInputs>()({ ... });
+ * light.handle("emergency", { severity: 5 }); // payload enforced
+ * ```
+ */
+type InputMap = Record<string, unknown[]>;
+/**
+ * The constraint a user-supplied input map must satisfy: every declared
+ * property is an argument tuple. Self-mapped instead of `InputMap` because a
+ * named interface has no string index signature, and a bare
+ * `Record<string, unknown[]>` bound rejects it with TS2344.
+ */
+type InputMapLike<T> = { [K in keyof T]-?: unknown[] };
+/**
+ * The complete argument list of one `handle()` call: an input name paired
+ * with that input's own payload tuple. The union distributes over the map,
+ * which keeps the pair correlated when the caller's input name is itself a
+ * union — `handle(name, payload)` with `name: "a" | "b"` only accepts a
+ * payload that matches the member it is paired with, never a payload from
+ * the other member.
+ */
+type InputCall<TInputNames extends string, TInputs extends InputMapLike<TInputs>> = [TInputNames & keyof TInputs & string] extends [never] ? [inputName: never, ...args: unknown[]] : { [K in TInputNames & keyof TInputs & string]: [inputName: K, ...payload: TInputs[K]] }[TInputNames & keyof TInputs & string];
+/**
+ * Builds an input payload map from a discriminated event union, matching the
+ * common "dispatch the whole event" pattern: `handle(event.type, event)`.
+ *
+ * @example
+ * ```ts
+ * type TrafficLightEvent =
+ *   | { type: "emergency"; severity: number }
+ *   | { type: "pedestrianRequest"; crossingId: string };
+ *
+ * type TrafficLightInputs = InputMapFromUnion<TrafficLightEvent>;
+ * // => { emergency:         [event: { type: "emergency"; severity: number }];
+ * //      pedestrianRequest: [event: { type: "pedestrianRequest"; crossingId: string }] }
+ * ```
+ */
+type InputMapFromUnion<TEvent extends {
+  type: string;
+}> = { [E in TEvent as E["type"]]: [event: E] };
 /**
  * The single combined object passed to every handler.
  *
@@ -545,9 +618,11 @@ interface HandlerArgs<TCtx, TStateNames extends string = string> {
  * Guards are just `if` statements. Actions are just code before the return.
  *
  * The `...extra` rest parameter captures additional arguments passed through
- * `handle(inputName, ...extraArgs)`. These are untyped (`unknown[]`) because
- * correlating per-input arg types with handle() call sites would require
- * prohibitively complex mapped types for minimal benefit.
+ * `handle(inputName, ...extraArgs)`. By default these are untyped
+ * (`unknown[]`). An input payload map types them per input (#195): supply it
+ * through the curried factory form (`createFsm<TInputs>()`), and `TPayload`
+ * becomes that input's declared tuple. Handler parameters are then inferred —
+ * no annotation, no cast.
  *
  * @example
  * ```ts
@@ -569,7 +644,7 @@ interface HandlerArgs<TCtx, TStateNames extends string = string> {
  * success({ ctx }, data) { ctx.result = data; }
  * ```
  */
-type HandlerFn<TCtx, TStateNames extends string = string> = (args: HandlerArgs<TCtx, TStateNames>, ...extra: unknown[]) => TStateNames | void;
+type HandlerFn<TCtx, TStateNames extends string = string, TPayload extends unknown[] = unknown[]> = (args: HandlerArgs<TCtx, TStateNames>, ...extra: TPayload) => TStateNames | void;
 /**
  * The union of valid handler definition forms for a state input.
  *
@@ -597,7 +672,7 @@ type HandlerFn<TCtx, TStateNames extends string = string> = (args: HandlerArgs<T
  * }
  * ```
  */
-type HandlerDef<TCtx, TStateNames extends string = string> = TStateNames | HandlerFn<TCtx, TStateNames> | MachinaInstance;
+type HandlerDef<TCtx, TStateNames extends string = string, TPayload extends unknown[] = unknown[]> = TStateNames | HandlerFn<TCtx, TStateNames, TPayload> | MachinaInstance;
 /**
  * Validates and constrains the states object at the type level.
  *
@@ -622,15 +697,21 @@ type HandlerDef<TCtx, TStateNames extends string = string> = TStateNames | Handl
  * @typeParam TStateNames - The state-name union. Defaults to
  *   `keyof TStates & string`, but callers that already resolved it
  *   (the factory functions) pass it through explicitly.
+ * @typeParam TInputs - The input payload map (#195). Ordinary inputs are a
+ *   mapped type over its keys rather than an index signature, which is what
+ *   makes per-input payload typing possible. The wide default
+ *   (`keyof = string`) makes the mapped member degenerate to an index
+ *   signature, reproducing the untyped behavior exactly — one formulation
+ *   serves both paths. Lifecycle hooks and the catch-all keep `unknown[]`
+ *   either way: they can receive the arguments of ANY input, so no single
+ *   tuple fits them.
  */
-type ValidateStates<TCtx, TStates extends Record<string, Record<string, unknown>>, TStateNames extends string = keyof TStates & string> = Record<TStateNames, {
+type ValidateStates<TCtx, TStates extends Record<string, Record<string, unknown>>, TStateNames extends string = keyof TStates & string, TInputs extends InputMapLike<TInputs> = InputMap> = Record<TStateNames, {
   _onEnter?: HandlerFn<TCtx, NoInfer<TStateNames>>;
   _onExit?: HandlerFn<TCtx, NoInfer<TStateNames>>;
   _child?: MachinaInstance;
   "*"?: HandlerFn<TCtx, NoInfer<TStateNames>>;
-} & {
-  [input: string]: HandlerDef<TCtx, NoInfer<TStateNames>>;
-}>;
+} & { [I in keyof TInputs]?: HandlerDef<TCtx, NoInfer<TStateNames>, TInputs[I]> }>;
 /**
  * True when at least one state in `TStates` declares a `"*"` catch-all —
  * a catch-all absorbs every input, including any bubbled one, so it counts
@@ -673,6 +754,26 @@ type ChildCoverage<TStates extends Record<string, Record<string, unknown>>, TSta
     "child bubbles up inputs this FSM neither handles nor re-declares": UncoveredChildBubbles<NoInfer<TStates>, S, NoInfer<TBubbles>>;
   };
 } };
+/**
+ * For one state object, the handler keys that are not declared in the input
+ * map (special keys excluded). Resolves to `never` in three cases: every key
+ * is declared; the map is the wide untyped default (`keyof TInputs` is
+ * `string`, so the Exclude strips everything); or the evaluation ran against
+ * TStates' wide constraint (the `string extends keyof TState` short-circuit —
+ * see the module comment above).
+ */
+type UndeclaredInputsIn<TState, TInputs extends InputMapLike<TInputs>> = string extends keyof TState & string ? never : Exclude<keyof TState & string, (keyof TInputs & string) | SpecialStateKeys>;
+/**
+ * Enforces the input vocabulary contract across an entire `states` config.
+ * Intersected onto `FsmConfig.states` alongside `ValidateStates` and
+ * `ChildCoverage`. Inert (`unknown` per state) on the untyped path; on the
+ * typed path, a state declaring an undeclared input gets an
+ * impossible-to-satisfy member whose property name IS the error message,
+ * naming the offending keys.
+ */
+type InputVocabulary<TStates extends Record<string, Record<string, unknown>>, TStateNames extends string, TInputs extends InputMapLike<TInputs>> = { [S in TStateNames]: UndeclaredInputsIn<TStates[S], TInputs> extends never ? unknown : {
+  "state declares a handler for an input missing from the input map": UndeclaredInputsIn<TStates[S], TInputs>;
+} };
 /**
  * Configuration object for creating an FSM.
  *
@@ -695,6 +796,12 @@ type ChildCoverage<TStates extends Record<string, Record<string, unknown>>, TSta
  * @typeParam TBubbles - The union of inputs this FSM declares via `bubbles`.
  *   Defaults to `never` — most FSMs bubble nothing.
  *
+ * @typeParam TInputs - The input payload map (#195). The curried factory
+ *   forms fix it before inference starts, so it adds nothing to the
+ *   inference machinery above. Defaults to the wide map, which keeps
+ *   `ValidateStates` and `InputVocabulary` behaving exactly as the untyped
+ *   path always has.
+ *
  * @example
  * ```ts
  * // TCtx inferred as { tickCount: number }, TStates inferred from states object:
@@ -743,7 +850,7 @@ type ChildCoverage<TStates extends Record<string, Record<string, unknown>>, TSta
  * });
  * ```
  */
-interface FsmConfig<TCtx, TStates extends Record<string, Record<string, unknown>> = Record<string, Record<string, unknown>>, TStateNames extends string = keyof TStates & string, TBubbles extends string = never> {
+interface FsmConfig<TCtx, TStates extends Record<string, Record<string, unknown>> = Record<string, Record<string, unknown>>, TStateNames extends string = keyof TStates & string, TBubbles extends string = never, TInputs extends InputMapLike<TInputs> = InputMap> {
   /** Unique identifier for this FSM */
   id: string;
   /**
@@ -793,7 +900,7 @@ interface FsmConfig<TCtx, TStates extends Record<string, Record<string, unknown>
    * and the bubble-coverage contract on top without becoming the inference
    * source themselves.
    */
-  states: TStates & ValidateStates<TCtx, TStates, TStateNames> & ChildCoverage<TStates, TStateNames, TBubbles>;
+  states: TStates & ValidateStates<TCtx, TStates, TStateNames, TInputs> & ChildCoverage<TStates, TStateNames, TBubbles> & InputVocabulary<TStates, TStateNames, TInputs>;
 }
 /**
  * Symbol used as a property key to identify machina FSM instances at runtime.
@@ -983,8 +1090,11 @@ interface ClientSnapshot {
  * @typeParam TBubbles - String literal union of inputs this FSM declares via
  *   `bubbles`. Type-only — carried so `BubblesOfInstance` can extract it from
  *   a constructed instance; nothing at runtime reads this generic.
+ * @typeParam TInputs - The input payload map (#195). Defaults to the wide
+ *   map, under which `handle()`'s signature reduces to exactly the untyped
+ *   behavior. `createFsm<TInputs>()` passes the user's map here.
  */
-declare class Fsm<TCtx extends object, TStateNames extends string, TInputNames extends string, TBubbles extends string = never> {
+declare class Fsm<TCtx extends object, TStateNames extends string, TInputNames extends string, TBubbles extends string = never, TInputs extends InputMapLike<TInputs> = InputMap> {
   readonly id: string;
   readonly initialState: TStateNames;
   readonly [MACHINA_TYPE]: "Fsm";
@@ -1000,7 +1110,7 @@ declare class Fsm<TCtx extends object, TStateNames extends string, TInputNames e
    * there first; unhandled inputs bubble up to the parent.
    * No-ops silently when disposed.
    */
-  handle(inputName: TInputNames, ...args: unknown[]): void;
+  handle(...call: InputCall<TInputNames, TInputs>): void;
   /**
    * Returns true if the current state has a handler for `inputName`
    * (or a catch-all `"*"` handler), or if the current state's `_child`
@@ -1065,6 +1175,16 @@ declare class Fsm<TCtx extends object, TStateNames extends string, TInputNames e
  *
  * State names, input names, and all handler signatures derive from `TStates`.
  *
+ * To type each input's payload as well (#195), call the curried form with an
+ * input payload map: `createFsm<TInputs>()({...})`. The zero-argument call
+ * fixes `TInputs`; the returned function infers everything else from the
+ * config exactly as the direct form does. The split exists because TypeScript
+ * has no partial type-argument inference — the map can't ride along with the
+ * inferred parameters. Under a map, handler payload parameters are inferred
+ * from the map's tuples and `handle()` enforces them at the call site. The
+ * map is also the complete input vocabulary: handler keys outside it are
+ * compile errors.
+ *
  * @example
  * ```ts
  * const light = createFsm({
@@ -1080,10 +1200,39 @@ declare class Fsm<TCtx extends object, TStateNames extends string, TInputNames e
  *
  * light.handle("timeout"); // transitions green → yellow
  * ```
+ *
+ * @example Typed input payloads via the curried form
+ * ```ts
+ * type TrafficLightInputs = {
+ *   timeout: [];
+ *   emergency: [event: { severity: number }];
+ * };
+ *
+ * const light = createFsm<TrafficLightInputs>()({
+ *   id: "traffic-light",
+ *   initialState: "green",
+ *   context: { minSeverity: 3 },
+ *   states: {
+ *     green: {
+ *       timeout: "yellow",
+ *       // `event` is inferred as { severity: number }
+ *       emergency({ ctx }, event) {
+ *         if (event.severity < ctx.minSeverity) { return; }
+ *         return "red";
+ *       },
+ *     },
+ *     yellow: { timeout: "red" },
+ *     red: {},
+ *   },
+ * });
+ *
+ * light.handle("emergency", { severity: 5 }); // payload enforced
+ * ```
  */
+declare function createFsm<TInputs extends InputMapLike<TInputs>>(): <TCtx extends object, const TStates extends Record<string, Record<string, unknown>>, TStateNames extends string = keyof TStates & string, TBubbles extends keyof TInputs & string = never>(config: FsmConfig<TCtx, TStates, TStateNames, TBubbles, TInputs>) => Fsm<TCtx, keyof TStates & string, keyof TInputs & string, TBubbles, TInputs>;
 declare function createFsm<TCtx extends object = Record<string, never>, const TStates extends Record<string, Record<string, unknown>> = Record<string, Record<string, unknown>>, TStateNames extends string = keyof TStates & string, TBubbles extends string = never>(config: FsmConfig<TCtx, TStates, TStateNames, TBubbles>): Fsm<TCtx, keyof TStates & string, Exclude<{ [S in keyof TStates]: keyof TStates[S] & string }[keyof TStates], SpecialStateKeys> | { [S in keyof TStates]: TStates[S] extends {
   _child: infer C;
 } ? InputNamesOfInstance<C> : never }[keyof TStates] | TBubbles, TBubbles>;
 //#endregion
-export { BehavioralFsm, type BehavioralFsmEventMap, type BubblesOfInstance, type ChildLink, type ClientOf, type ClientSnapshot, type ContextOf, type DeferredInput, type DisposeOptions, Fsm, type FsmConfig, type FsmEventMap, type HandlerArgs, type HandlerDef, type HandlerFn, type InputNamesOf, type InputNamesOfInstance, MACHINA_TYPE, type MachinaInstance, type StateNamesOf, type StateNamesOfInstance, type Subscription, createBehavioralFsm, createFsm };
+export { BehavioralFsm, type BehavioralFsmEventMap, type BubblesOfInstance, type ChildLink, type ClientOf, type ClientSnapshot, type ContextOf, type DeferredInput, type DisposeOptions, Fsm, type FsmConfig, type FsmEventMap, type HandlerArgs, type HandlerDef, type HandlerFn, type InputCall, type InputMap, type InputMapFromUnion, type InputMapLike, type InputMapOfInstance, type InputNamesOf, type InputNamesOfInstance, MACHINA_TYPE, type MachinaInstance, type StateNamesOf, type StateNamesOfInstance, type Subscription, createBehavioralFsm, createFsm };
 //# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","names":[],"sources":["../src/emitter.ts","../src/behavioral-fsm.ts","../src/types.ts","../src/fsm.ts"],"mappings":"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"}
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/emitter.ts","../src/behavioral-fsm.ts","../src/types.ts","../src/fsm.ts"],"mappings":"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"}

package/dist/index.mjs

@@ -194,6 +194,11 @@ const MAX_TRANSITION_DEPTH = 20;
 * @typeParam TBubbles - String literal union of inputs this FSM declares via
 *   `bubbles`. Type-only — carried so `BubblesOfInstance` can extract it from
 *   a constructed instance; nothing at runtime reads this generic.
+* @typeParam TInputs - The input payload map (#195). Defaults to the wide
+*   map, under which `handle()`'s signature reduces to exactly the untyped
+*   behavior: `keyof` of the wide map is `string`, so the key intersection
+*   is `TInputNames` and the payload lookup is `unknown[]`. The typed
+*   factory forms pass the user's map here.
 */
 var BehavioralFsm = class {
 	id;
@@ -223,7 +228,17 @@ var BehavioralFsm = class {
 	*
 	* No-ops silently when disposed.
 	*/
-	handle(client, inputName, ...args) {
+	handle(client, ...call) {
+		const [inputName, ...args] = call;
+		this.dispatch(client, inputName, args);
+	}
+	/**
+	* Untyped core of `handle()`, split out for internal callers (deferred
+	* replay). Replayed inputs were captured as `unknown[]`, and their
+	* payload types were already enforced at the original `handle()` call —
+	* so replay need not satisfy the payload-map generics.
+	*/
+	dispatch(client, inputName, args) {
 		if (this.disposed) return;
 		const meta = this.getOrCreateClientMeta(client);
 		meta.currentActionArgs = args;
@@ -729,7 +744,7 @@ var BehavioralFsm = class {
 		for (const item of meta.deferredQueue) if (item.untilState === void 0 || item.untilState === meta.state) toReplay.push(item);
 		else remaining.push(item);
 		meta.deferredQueue = remaining;
-		for (const item of toReplay) this.handle(client, item.inputName, ...item.args);
+		for (const item of toReplay) this.dispatch(client, item.inputName, item.args);
 	}
 };
 /**
@@ -827,6 +842,9 @@ function createBehavioralFsm(config) {
 * @typeParam TBubbles - String literal union of inputs this FSM declares via
 *   `bubbles`. Type-only — carried so `BubblesOfInstance` can extract it from
 *   a constructed instance; nothing at runtime reads this generic.
+* @typeParam TInputs - The input payload map (#195). Defaults to the wide
+*   map, under which `handle()`'s signature reduces to exactly the untyped
+*   behavior. `createFsm<TInputs>()` passes the user's map here.
 */
 var Fsm = class {
 	id;
@@ -857,9 +875,10 @@ var Fsm = class {
 	* there first; unhandled inputs bubble up to the parent.
 	* No-ops silently when disposed.
 	*/
-	handle(inputName, ...args) {
+	handle(...call) {
 		if (this.disposed) return;
-		this.bfsm.handle(this.context, inputName, ...args);
+		const [inputName, ...args] = call;
+		this.bfsm.handle(this.context, ...[inputName, ...args]);
 	}
 	/**
 	* Returns true if the current state has a handler for `inputName`
@@ -929,34 +948,8 @@ var Fsm = class {
 		this.emitter.clear();
 	}
 };
-/**
-* Create a single-client FSM from a config object.
-*
-* Generic parameters are inferred automatically:
-* - `TCtx` comes from `config.context` (defaults to `{}` if omitted).
-* - `TStates` is captured with `const` inference to preserve string literal
-*   types, enabling compile-time validation of transition targets and `handle()`
-*   input names.
-*
-* State names, input names, and all handler signatures derive from `TStates`.
-*
-* @example
-* ```ts
-* const light = createFsm({
-*   id: "traffic-light",
-*   initialState: "green",
-*   context: { tickCount: 0 },
-*   states: {
-*     green:  { timeout: "yellow" },
-*     yellow: { timeout: "red" },
-*     red:    { timeout: "green" },
-*   },
-* });
-*
-* light.handle("timeout"); // transitions green → yellow
-* ```
-*/
 function createFsm(config) {
+	if (config === void 0) return (curriedConfig) => new Fsm(curriedConfig);
 	return new Fsm(config);
 }