@uuxxx/fsm 1.2.4 → 1.3.1

package/README.md

@@ -2,7 +2,16 @@
 
 [![npm version](https://badge.fury.io/js/@uuxxx%2Ffsm.svg)](https://badge.fury.io/js/@uuxxx%2Ffsm)
 
-A lightweight, type-safe finite state machine library for JavaScript/TypeScript with plugin support and lifecycle hooks.
+A lightweight, type-safe finite state machine library for TypeScript with plugin support, lifecycle hooks, and full type inference.
+
+## Features
+
+- **Full type inference** — transition methods, states, and plugin APIs are auto-generated from config
+- **Multiple transition types** — static, dynamic, async, wildcard (`*`), and multi-source
+- **Lifecycle hooks** — `onBeforeTransition` (with veto) and `onAfterTransition`
+- **Plugin system** — extend your FSM with custom APIs
+- **Custom error handling** — provide an `onError` callback or let errors throw
+- **Zero dependencies** aside from `@uuxxx/utils`
 
 ## Installation
 
@@ -21,11 +30,9 @@ import { makeFsm } from '@uuxxx/fsm';
 
 type State = 'idle' | 'loading' | 'success' | 'error';
 
-const STATES: State[] = ['idle', 'loading', 'success', 'error'];
-
 const fsm = makeFsm({
 	init: 'idle',
-	states: STATES,
+	states: ['idle', 'loading', 'success', 'error'],
 	transitions: {
 		start: {
 			from: 'idle',
@@ -50,41 +57,39 @@ const fsm = makeFsm({
 	},
 });
 
-// Check current state
-console.log(fsm.state()); // 'idle'
-
-// Perform transitions
-fsm.start();
-console.log(fsm.state()); // 'loading'
-
-fsm.succeed();
-console.log(fsm.state()); // 'success'
-
-fsm.reset();
-console.log(fsm.state()); // 'idle'
-
-fsm.goto('error');
-console.log(fsm.state()); // 'error'
+fsm.state(); // 'idle'
+fsm.start(); // 'loading'
+fsm.succeed(); // 'success'
+fsm.reset(); // 'idle'
+fsm.goto('error'); // 'error'
 ```
 
+Each transition key becomes a method on the FSM instance with the correct type signature inferred from config.
+
 ## API Reference
 
 ### `makeFsm(config)`
 
 Creates a new finite state machine instance.
 
-#### Parameters
+#### Config
 
-- `config`: Configuration object with the following properties:
-  - `init`: Initial state
-  - `states`: Array of all possible states
-  - `transitions`: Object defining state transitions
-  - `methods?`: Optional lifecycle methods
-  - `plugins?`: Optional array of plugins
+| Property      | Type                                          | Required | Description                                                                   |
+| ------------- | --------------------------------------------- | -------- | ----------------------------------------------------------------------------- |
+| `init`        | `TState`                                      | Yes      | Initial state                                                                 |
+| `states`      | `TState[]`                                    | Yes      | All valid states                                                              |
+| `transitions` | `Record<string, Transition<TState>>`          | Yes      | Transition definitions (keys become methods)                                  |
+| `methods`     | `{ onBeforeTransition?, onAfterTransition? }` | No       | Lifecycle hooks                                                               |
+| `plugins`     | `Plugin[]`                                    | No       | Array of plugins                                                              |
+| `onError`     | `(msg: string) => void`                       | No       | Custom error handler. By default, errors throw `Error` with a `[FSM]:` prefix |
 
 #### Returns
 
-An FSM instance with transition methods, state methods, and plugin APIs.
+An FSM instance combining:
+
+- **State methods** — `state()`, `allStates()`
+- **Transition methods** — one per key in `transitions`
+- **Plugin APIs** — one namespace per plugin
 
 ### State Methods
 
@@ -92,17 +97,9 @@ An FSM instance with transition methods, state methods, and plugin APIs.
 
 Returns the current state.
 
-```typescript
-const currentState = fsm.state();
-```
-
 #### `fsm.allStates()`
 
-Returns an array of all possible states.
-
-```typescript
-const allStates = fsm.allStates();
-```
+Returns an array of all valid states.
 
 ### Transitions
 
@@ -115,21 +112,36 @@ type Transition<TState> = {
 };
 ```
 
-- `from`: The state(s) this transition can occur from
-  - Single state: `'idle'`
-  - Multiple states: `['loading', 'error']`
-  - Any state: `'*'`
-- `to`: The target state or a function returning the target state
-  - Static: `'loading'`
-  - Dynamic: `(userId: string) => \`user\_\${userId}\``
-  - Async: `async (data) => await apiCall(data)`
+#### `from` — source state(s)
+
+| Form            | Example                | Description           |
+| --------------- | ---------------------- | --------------------- |
+| Single state    | `'idle'`               | Only from this state  |
+| Multiple states | `['loading', 'error']` | From any listed state |
+| Wildcard        | `'*'`                  | From any state        |
+
+#### `to` — target state
+
+| Form    | Example                           | Description                      |
+| ------- | --------------------------------- | -------------------------------- |
+| Static  | `'loading'`                       | Always transitions to this state |
+| Dynamic | `(id: string) => \`user\_${id}\`` | Compute target from arguments    |
+| Async   | `async () => await fetchState()`  | Returns `Promise<TState>`        |
+
+#### Transition behavior
+
+- **Circular transitions are skipped** — if `from === to`, the transition is silently canceled with a warning.
+- **Concurrent async transitions are blocked** — starting a new transition while an async one is pending triggers an error.
+- **Invalid target states** — transitioning to a state not in `states` triggers an error.
+- **Forbidden transitions** — calling a transition from a state not matching `from` triggers an error.
+- **Return value** — every transition method returns the new state (or `Promise<TState>` for async transitions).
 
 #### Examples
 
 ```typescript
 const transitions = {
-	// Simple transition
-	'idle -> loading': {
+	// Static transition
+	start: {
 		from: 'idle',
 		to: 'loading',
 	},
@@ -143,84 +155,113 @@ const transitions = {
 	// Wildcard (from any state)
 	goto: {
 		from: '*',
-		to: (targetState: State) => targetState,
+		to: (target: State) => target,
 	},
 
 	// Async transition
-	'async fetch': {
+	fetch: {
 		from: 'idle',
 		to: async () => {
 			const result = await fetchData();
-			return result.success ? 'success' : 'error';
+			return result.ok ? 'success' : 'error';
 		},
 	},
 };
 ```
 
+### Error Handling
+
+By default, the FSM throws on errors (forbidden transitions, invalid states, concurrent transitions). You can provide a custom `onError` handler to change this behavior:
+
+```typescript
+const fsm = makeFsm({
+	init: 'idle',
+	states: ['idle', 'loading'],
+	transitions: {
+		start: { from: 'idle', to: 'loading' },
+		stop: { from: 'loading', to: 'idle' },
+	},
+	onError: (msg) => {
+		console.warn(msg); // Handle gracefully instead of throwing
+	},
+});
+
+// Won't throw — calls onError instead
+fsm.stop(); // "idle" → "idle" via "stop" is forbidden (from doesn't match)
+```
+
+When `onError` is provided, the FSM state remains unchanged after an error.
+
 ### Lifecycle Methods
 
-Lifecycle methods can be attached to the FSM configuration:
+Lifecycle methods hook into the transition process:
 
 ```typescript
-const config = {
-	// ... other config
+const fsm = makeFsm({
+	// ...
 	methods: {
 		onBeforeTransition: (event) => {
-			console.log('About to transition:', event);
-			// Return false to cancel the transition
-			return true;
+			console.log(`${event.from} → ${event.to} via ${event.transition}`);
+			return false; // Return false to cancel the transition
 		},
 		onAfterTransition: (event) => {
-			console.log('Transition completed:', event);
+			console.log('Transition complete:', event.transition);
 		},
 	},
-};
+});
 ```
 
-#### `onBeforeTransition(event)`
+#### Lifecycle event object
 
-Called before a transition occurs. Return `false` to cancel the transition.
+| Property     | Type                 | Description                             |
+| ------------ | -------------------- | --------------------------------------- |
+| `transition` | `string`             | Name of the transition (the config key) |
+| `from`       | `TState`             | State before the transition             |
+| `to`         | `TState`             | Target state                            |
+| `args`       | `any[] \| undefined` | Arguments passed to dynamic transitions |
 
-**Parameters:**
+#### `onBeforeTransition(event)`
 
-- `event`: Object with `transition`, `from`, `to`, and optional `args`
+Called before a transition. Return `false` to veto (cancel) the transition.
 
 #### `onAfterTransition(event)`
 
-Called after a successful transition.
-
-**Parameters:**
-
-- `event`: Object with `transition`, `from`, `to`, and optional `args`
+Called after a successful transition. The FSM state is already updated at this point.
 
 ## Plugins
 
-Plugins extend the FSM with additional functionality. Each plugin receives an API object and returns a plugin definition.
+Plugins extend the FSM with additional methods, grouped under a namespace.
 
 ### Plugin API
 
-Plugins have access to:
+Each plugin receives an `api` object with:
 
-- `api.state()`: Get current state
-- `api.allStates()`: Get all states
-- `api.init(callback)`: Register initialization callback
-- `api.onBeforeTransition(callback)`: Register before transition callback
-- `api.onAfterTransition(callback)`: Register after transition callback
+| Method                             | Description                                                       |
+| ---------------------------------- | ----------------------------------------------------------------- |
+| `api.state()`                      | Get current state                                                 |
+| `api.allStates()`                  | Get all valid states                                              |
+| `api.init(callback)`               | Run callback when FSM is created (receives initial state)         |
+| `api.onBeforeTransition(callback)` | Register before-transition listener. Returns unsubscribe function |
+| `api.onAfterTransition(callback)`  | Register after-transition listener. Returns unsubscribe function  |
+| `api.onError(callback)`            | Register error listener. Returns unsubscribe function             |
 
 ### Creating a Plugin
 
 ```typescript
 import type { FsmLabel, FsmPlugin, FsmTransition } from '@uuxxx/fsm';
 
-export const somePlugin = <TState extends FsmLabel, TTransitions extends Record<string, FsmTransition<TState>>>() =>
+export const myPlugin = <TState extends FsmLabel, TTransitions extends Record<string, FsmTransition<TState>>>() =>
 	((api) => {
-		// ... plugin code
+		let count = 0;
+
+		api.onAfterTransition(() => {
+			count++;
+		});
 
 		return {
-			// replace with your plugin name
-			name: 'plugin-name' as const,
+			name: 'counter' as const,
 			api: {
-				// ... plugin methods
+				getCount: () => count,
 			},
 		};
 	}) satisfies FsmPlugin<TState, TTransitions>;
@@ -229,54 +270,79 @@ export const somePlugin = <TState extends FsmLabel, TTransitions extends Record<
 ### Using Plugins
 
 ```typescript
-const config = {
-	// ... other config
-	plugins: [somePlugin({ someOption: true })],
-};
-
-const fsm = makeFsm(config);
+const fsm = makeFsm({
+	// ...
+	plugins: [myPlugin()],
+});
 
-// Access plugin API
-const currentState = fsm['plugin-name'].doSomething();
+fsm.start();
+fsm.counter.getCount(); // 1
 ```
 
+Plugin names must be unique — registering two plugins with the same name triggers an error.
+
 ## Built-in Plugins
 
 ### History Plugin
 
-Tracks state history and provides navigation methods.
+Read-only state history tracking with pointer-based navigation.
+
+`back()` and `forward()` move an internal pointer and return the state at that position — they do **not** change the FSM state. Use transition methods to actually navigate (e.g. `fsm.goto(fsm.history.back(1))`).
 
 ```typescript
 import { makeFsm } from '@uuxxx/fsm';
-import { fsmHistoryPlugin } from '@uuxxx/fsm/history-plugin';
+import { historyPlugin } from '@uuxxx/fsm-plugins/history';
 
-const config = {
-	// ... config
-	plugins: [fsmHistoryPlugin()],
-};
+const fsm = makeFsm({
+	init: 'a',
+	states: ['a', 'b', 'c'],
+	transitions: {
+		goto: { from: '*', to: (s: 'a' | 'b' | 'c') => s },
+	},
+	plugins: [historyPlugin()],
+});
 
-const fsm = makeFsm(config);
+fsm.goto('b');
+fsm.goto('c');
+fsm.history.get(); // ['a', 'b', 'c'] (returns a copy)
 
-// Navigate
-fsm.goto('state1');
-fsm.goto('state2');
+fsm.history.back(1); // returns 'b' (pointer moved, FSM state unchanged)
+fsm.history.current(); // 'b'
+fsm.history.canBack(); // true
+fsm.history.canForward(); // true
+fsm.history.forward(1); // returns 'c'
+fsm.goto(fsm.history.current()); // actually transition to 'c'
+```
 
-// History API
-console.log(fsm.history.get()); // Get all history
+#### History API
 
-fsm.history.back(1); // Get 1 step back
-fsm.history.forward(1); // Get 1 step forward
-```
+| Method                       | Returns    | Description                                                                                                     |
+| ---------------------------- | ---------- | --------------------------------------------------------------------------------------------------------------- |
+| `fsm.history.get()`          | `TState[]` | Returns a copy of the full history array                                                                        |
+| `fsm.history.current()`      | `TState`   | Returns the state at the current pointer position                                                               |
+| `fsm.history.back(steps)`    | `TState`   | Move pointer back by `steps`, returns the state at that position. Clamps to start. Ignores non-positive values  |
+| `fsm.history.forward(steps)` | `TState`   | Move pointer forward by `steps`, returns the state at that position. Clamps to end. Ignores non-positive values |
+| `fsm.history.canBack()`      | `boolean`  | Whether the pointer can move back (pointer > 0)                                                                 |
+| `fsm.history.canForward()`   | `boolean`  | Whether the pointer can move forward (pointer < end)                                                            |
 
-#### History API Methods
+When a transition occurs, any forward history after the current pointer is discarded (like browser navigation).
 
-- `fsm.history.get()`: Get the full history array
-- `fsm.history.back(steps?)`: Get N step back (default: 1)
-- `fsm.history.forward(steps?)`: Get N step forward (default: 1)
+## Exported Types
+
+The library exports the following types for use in plugins and generic code:
+
+```typescript
+import type {
+	FsmConfig, // Config<TState, TTransitions, TPlugins>
+	FsmTransition, // Transition<TState>
+	FsmPlugin, // Plugin<TState, TTransitions>
+	FsmLabel, // string (state label type)
+} from '@uuxxx/fsm';
+```
 
 ## TypeScript Support
 
-The library is fully typed. Type inference works automatically:
+The library is built with TypeScript-first design. All types are inferred from config — no manual type annotations needed:
 
 ```typescript
 const fsm = makeFsm({
@@ -287,5 +353,12 @@ const fsm = makeFsm({
 		stop: { from: 'running', to: 'stopped' },
 	},
 });
-// fsm is fully typed - autocomplete works for transitions and states
+
+fsm.start(); // ✓ typed — only callable from 'idle'
+fsm.stop(); // ✓ typed — only callable from 'running'
+fsm.state(); // ✓ returns 'idle' | 'running' | 'stopped'
 ```
+
+## License
+
+[MIT](./LICENSE)

package/dist/index.d.ts

@@ -1,10 +1,61 @@
-import { a as Transition, c as KeyOf, i as LifecycleMethods, l as Rec, n as Plugin, o as Label, r as StateMethods, s as EmptyArray } from "./Plugin-Dx6AAZEC.js";
+type AnyFn = (...args: any[]) => any; //#endregion
+type Rec<T = unknown> = Record<string, T>; //#endregion
+type KeyOf<T extends Rec> = keyof T; //#endregion
+type Noop = () => void; //#endregion
+type Key = string | number | symbol; //#endregion
+type Vdx<T> = T | void; //#endregion
+type EmptyArray = []; //#endregion
+type Entries<T extends Rec> = { [K in KeyOf<T>]: [K, T[K]] }[KeyOf<T>]; //#endregion
+type Label = string;
+/**
+ * Defines a single state transition.
+ *
+ * - `from` — source state(s): a single state, an array of states, or `'*'` for any state.
+ * - `to` — target: a static state, a function returning a state, or an async function returning `Promise<TState>`.
+ */
+type Transition<TState extends Label> = {
+  from: '*' | TState | TState[];
+  to: TState | ((...args: any[]) => TState | Promise<TState>);
+};
+/** Event object passed to lifecycle hooks during a transition. */
+type Lifecycle<TState extends Label, TEntry extends [Key, Transition<Label>]> = {
+  args?: Parameters<Extract<TEntry[1]['to'], AnyFn>>;
+  transition: TEntry[0];
+  from: TState;
+  to: TState;
+};
+type LifecycleMethod<TState extends Label, TTransitions extends Rec<Transition<TState>>> = (lifecycle: Lifecycle<TState, Entries<TTransitions>>) => void;
+type CancelableLifecycleMethod<TState extends Label, TTransitions extends Rec<Transition<TState>>> = (lifecycle: Lifecycle<TState, Entries<TTransitions>>) => Vdx<boolean>;
+type LifecycleMethods<TState extends Label, TTransitions extends Rec<Transition<TState>>> = {
+  onBeforeTransition?: CancelableLifecycleMethod<TState, TTransitions>;
+  onAfterTransition?: LifecycleMethod<TState, TTransitions>;
+};
+type StateMethods<TState extends Label> = {
+  state: () => TState;
+  allStates: () => TState[];
+};
+/** API object passed to each plugin during registration. Provides state access, lifecycle hooks, and error listeners. */
+type ApiForPlugin<TState extends Label, TTransitions extends Rec<Transition<TState>>> = {
+  init: (listener: (state: TState) => void) => void;
+  onError: (listener: (msg: string) => void) => Noop;
+} & StateMethods<TState> & { [K in KeyOf<LifecycleMethods<TState, TTransitions>>]-?: (listener: LifecycleMethods<TState, TTransitions>[K]) => Noop };
+type PluginApi = {
+  name: string;
+  api: Rec<AnyFn>;
+};
+/**
+ * A plugin is a function that receives the {@link ApiForPlugin} and returns
+ * `{ name, api }` — the name becomes a namespace on the FSM instance,
+ * and `api` methods are accessible under that namespace.
+ */
+type Plugin<TState extends Label = Label, TTransitions extends Rec<Transition<TState>> = Rec<Transition<TState>>> = (api: ApiForPlugin<TState, TTransitions>) => PluginApi;
+/** Configuration object for {@link makeFsm}. */
 type Config<TState extends Label, TTransitions extends Rec<Transition<TState>>, TPlugins extends Array<Plugin<TState, TTransitions>> = EmptyArray> = {
-  init: TState;
-  states: TState[];
-  transitions: TTransitions;
-  methods?: LifecycleMethods<TState, TTransitions>;
-  plugins?: TPlugins;
+  /** Initial state of the FSM. */init: TState; /** All valid states. The FSM will reject transitions to states not in this list. */
+  states: TState[]; /** Transition definitions. Each key becomes a method on the FSM instance. */
+  transitions: TTransitions; /** Optional lifecycle hooks (`onBeforeTransition`, `onAfterTransition`). */
+  methods?: LifecycleMethods<TState, TTransitions>; /** Optional plugins to extend the FSM with additional APIs. */
+  plugins?: TPlugins; /** Custom error handler. By default, errors throw with a `[FSM]:` prefix. */
   onError?: (msg: string) => void;
 };
 type TransitionMethods<TTransitions extends Rec<Transition<Label>>> = { [K in KeyOf<TTransitions>]: TTransitions[K]['to'] extends Label ? () => TTransitions[K]['to'] : TTransitions[K]['to'] };
@@ -12,5 +63,27 @@ type PluginsMethods<TState extends Label, TTransitions extends Rec<Transition<TS
   name: K;
 }>['api'] };
 type Methods<TState extends Label, TTransitions extends Rec<Transition<TState>>, TPlugins extends Array<Plugin<TState, TTransitions>>> = TransitionMethods<TTransitions> & StateMethods<TState> & PluginsMethods<TState, TTransitions, TPlugins>;
+/**
+ * Creates a finite state machine instance from the given configuration.
+ *
+ * Returns an object combining state methods (`state()`, `allStates()`),
+ * auto-generated transition methods (one per key in `config.transitions`),
+ * and plugin APIs (one namespace per plugin).
+ *
+ * @example
+ * ```ts
+ * const fsm = makeFsm({
+ *   init: 'idle',
+ *   states: ['idle', 'loading', 'done'],
+ *   transitions: {
+ *     start: { from: 'idle', to: 'loading' },
+ *     finish: { from: 'loading', to: 'done' },
+ *   },
+ * });
+ *
+ * fsm.start();  // 'loading'
+ * fsm.finish(); // 'done'
+ * ```
+ */
 declare const makeFsm: <TState extends Label, TTransitions extends Rec<Transition<TState>>, TPlugins extends Array<Plugin<TState, TTransitions>>>(config: Config<TState, TTransitions, TPlugins>) => Methods<TState, TTransitions, TPlugins>;
 export { type Config as FsmConfig, type Label as FsmLabel, type Plugin as FsmPlugin, type Transition as FsmTransition, makeFsm };

package/package.json

@@ -1,17 +1,23 @@
 {
   "name": "@uuxxx/fsm",
-  "version": "1.2.4",
-  "description": "Javascript library for creating finite state machine",
+  "version": "1.3.1",
+  "description": "Lightweight, type-safe finite state machine for TypeScript with plugin support and lifecycle hooks",
   "keywords": [
     "finite state machine",
-    "fsm"
+    "fsm",
+    "lifecycle",
+    "plugins",
+    "state machine",
+    "type-safe",
+    "typescript"
   ],
-  "homepage": "https://github.com/uuxxx/fsm/blob/main/README.md",
+  "homepage": "https://github.com/uuxxx/fsm/blob/main/packages/core/README.md",
   "license": "MIT",
   "author": "Artem Tryapichnikov <golysheeet@gmail.com>",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/uuxxx/fsm.git"
+    "url": "git+https://github.com/uuxxx/fsm.git",
+    "directory": "packages/core"
   },
   "files": [
     "dist",
@@ -23,49 +29,20 @@
     ".": {
       "types": "./dist/index.d.ts",
       "default": "./dist/index.js"
-    },
-    "./history-plugin": {
-      "types": "./dist/history-plugin.d.ts",
-      "default": "./dist/history-plugin.js"
     }
   },
   "publishConfig": {
     "access": "public"
   },
-  "dependencies": {
-    "@uuxxx/utils": "^0.0.3"
-  },
   "devDependencies": {
-    "@babel/core": "^7.28.4",
-    "@babel/preset-env": "^7.28.3",
-    "@babel/preset-typescript": "^7.27.1",
-    "@changesets/cli": "^2.29.7",
     "@swc/core": "^1.13.5",
-    "lefthook": "^2.0.2",
-    "oxfmt": "^0.41.0",
-    "oxlint": "^1.0.0",
-    "oxlint-tsgolint": "^0.17.0",
     "rolldown": "^1.0.0-beta.41",
     "rolldown-plugin-dts": "^0.22.1",
     "rollup-plugin-swc3": "^0.12.1",
-    "ts-node": "^10.9.2",
-    "tslib": "^2.8.1",
-    "typescript": "^5.9.3",
-    "vitest": "^4.0.18"
-  },
-  "engines": {
-    "node": ">= 20",
-    "pnpm": ">= 10"
+    "tslib": "^2.8.1"
   },
   "scripts": {
     "build": "rolldown -c rolldown.config.ts",
-    "changeset:version": "changeset version && git add --all && git commit -m 'chore: bump'",
-    "changeset:publish": "changeset publish",
-    "test": "vitest run",
-    "lint": "oxlint",
-    "lint:fix": "oxlint --fix",
-    "fmt": "oxfmt --write .",
-    "fmt:check": "oxfmt --check .",
     "check:types": "tsc --noEmit"
   }
 }

package/dist/Plugin-Dx6AAZEC.d.ts

@@ -1,39 +0,0 @@
-type AnyFn = (...args: any[]) => any; //#endregion
-type Rec<T = unknown> = Record<string, T>; //#endregion
-type KeyOf<T extends Rec> = keyof T; //#endregion
-type Noop = () => void; //#endregion
-type Key = string | number | symbol; //#endregion
-type Vdx<T> = T | void; //#endregion
-type EmptyArray = []; //#endregion
-type Entries<T extends Rec> = { [K in KeyOf<T>]: [K, T[K]] }[KeyOf<T>]; //#endregion
-type Label = string;
-type Transition<TState extends Label> = {
-  from: '*' | TState | TState[];
-  to: TState | ((...args: any[]) => TState | Promise<TState>);
-};
-type Lifecycle<TState extends Label, TEntry extends [Key, Transition<Label>]> = {
-  args?: Parameters<Extract<TEntry[1]['to'], AnyFn>>;
-  transition: TEntry[0];
-  from: TState;
-  to: TState;
-};
-type LifecycleMethod<TState extends Label, TTransitions extends Rec<Transition<TState>>> = (lifecycle: Lifecycle<TState, Entries<TTransitions>>) => void;
-type CancelableLifecycleMethod<TState extends Label, TTransitions extends Rec<Transition<TState>>> = (lifecycle: Lifecycle<TState, Entries<TTransitions>>) => Vdx<boolean>;
-type LifecycleMethods<TState extends Label, TTransitions extends Rec<Transition<TState>>> = {
-  onBeforeTransition?: CancelableLifecycleMethod<TState, TTransitions>;
-  onAfterTransition?: LifecycleMethod<TState, TTransitions>;
-};
-type StateMethods<TState extends Label> = {
-  state: () => TState;
-  allStates: () => TState[];
-};
-type ApiForPlugin<TState extends Label, TTransitions extends Rec<Transition<TState>>> = {
-  init: (listener: (state: TState) => void) => void;
-  onError: (listener: (msg: string) => void) => Noop;
-} & StateMethods<TState> & { [K in KeyOf<LifecycleMethods<TState, TTransitions>>]-?: (listener: LifecycleMethods<TState, TTransitions>[K]) => Noop };
-type PluginApi = {
-  name: string;
-  api: Rec<AnyFn>;
-};
-type Plugin<TState extends Label = Label, TTransitions extends Rec<Transition<TState>> = Rec<Transition<TState>>> = (api: ApiForPlugin<TState, TTransitions>) => PluginApi;
-export { Transition as a, KeyOf as c, LifecycleMethods as i, Rec as l, Plugin as n, Label as o, StateMethods as r, EmptyArray as s, ApiForPlugin as t };

package/dist/history-plugin.d.ts

@@ -1,10 +0,0 @@
-import { a as Transition, l as Rec, o as Label, t as ApiForPlugin } from "./Plugin-Dx6AAZEC.js";
-declare const historyPlugin: <TState extends Label, TTransitions extends Rec<Transition<TState>>>() => (api: ApiForPlugin<TState, TTransitions>) => {
-  name: "history";
-  api: {
-    get(): TState[];
-    back(steps: number): TState;
-    forward(steps: number): TState;
-  };
-};
-export { historyPlugin as fsmHistoryPlugin };

package/dist/history-plugin.js

@@ -1 +0,0 @@
-let t=()=>t=>{let i=[],n=0;return t.init(t=>i.push(t)),t.onAfterTransition(({to:t})=>{n++,i.splice(n,i.length-n,t)}),{name:"history",api:{get:()=>i,back:t=>i[n=Math.max(0,n-t)],forward:t=>(n=Math.min(i.length-1,n+t),i[n])}}};export{t as fsmHistoryPlugin};