@statewalker/fsm 0.28.0 → 0.30.0

package/dist/index.d.ts

@@ -1,11 +1,12 @@
+type Handler<P extends unknown[] = unknown[], R = unknown> = (...args: P) => R;
 declare class FsmBaseClass {
-    handlers: Record<string, Function[]>;
+    handlers: Record<string, Handler[]>;
     data: Record<string, unknown>;
     constructor();
     setData<T>(key: string, value: T): this;
     getData<T>(key: string): T | undefined;
-    _addHandler(type: string, handler: Function, direct?: boolean): () => void;
-    _removeHandler(type: string, handler: Function): void;
+    protected _addHandler<T>(type: string, handler: T, direct?: boolean): () => void;
+    protected _removeHandler<T>(type: string, handler: T): void;
     _runHandlerParallel(type: string, ...args: unknown[]): Promise<void>;
     _runHandler(type: string, ...args: unknown[]): Promise<void>;
     _handleError(error: Error | unknown): Promise<void>;
@@ -92,6 +93,171 @@ declare class FsmProcess extends FsmBaseClass {
     _update(): boolean;
 }
 
+type Module<C = unknown> = (context: C) => void | (() => void | Promise<void>) | Promise<void | (() => void | Promise<void>)> | Generator<string> | AsyncGenerator<string>;
+declare function newFsmProcess<C>(context: C, config: FsmStateConfig, load: (state: string, event: undefined | string) => undefined | Module<C> | Module<C>[] | Promise<undefined | Module<C> | Module<C>[]>): [
+    dispatch: (event: string) => Promise<boolean>,
+    shutdown: () => Promise<void>
+];
+
+/**
+ * Key used to bind the dispatch function to the process context.
+ * The dispatch function allows triggering state transitions by dispatching events.
+ *
+ * Example usage:
+ * ```typescript
+ * const context: Record<string, unknown> = {};
+ * // Initialize the FSM process using `startFsmProcess`
+ * const dispatch = context["fsm:dispatch"] as (event: string) => Promise<void>;
+ * await dispatch("someEvent");
+ */
+declare const KEY_DISPATCH: "fsm:dispatch";
+/**
+ * Key used to bind the terminate function to the process context.
+ * The terminate function is used to gracefully shut down the FSM process.
+ * It returns a Promise that resolves when the process has been fully terminated.
+ * Example usage:
+ * ```typescript
+ * const context: Record<string, unknown> = {};
+ * // Initialize the FSM process using `startFsmProcess`
+ * const terminate = context["fsm:terminate"] as () => Promise<void>;
+ * await terminate();
+ * ```
+ */
+declare const KEY_TERMINATE: "fsm:terminate";
+/**
+ * Key used to bind the current stack of active states to the process context.
+ * This provides a snapshot of the states the FSM process has entered.
+ * It is represented as an array of strings -- state keys.
+ *
+ * Example usage:
+ * ```typescript
+ * const context: Record<string, unknown> = {};
+ * // Initialize the FSM process using `startFsmProcess`
+ * const states = context["fsm:states"] as string[];
+ * console.log("Current active states:", states);
+ * ```
+ */
+declare const KEY_STATES: "fsm:states";
+/**
+ * Key used to bind the current event being processed to the process context.
+ * This represents the event that triggered the current state transition.
+ * It is represented as a string.
+ * Example usage:
+ * ```typescript
+ * const context: Record<string, unknown> = {};
+ * // Initialize the FSM process using `startFsmProcess`
+ * const event = context["fsm:event"] as string;
+ * console.log("Current event:", event);
+ * ```
+ */
+declare const KEY_EVENT: "fsm:event";
+/**
+ * Key used to register a new FSM process configuration in the process context.
+ * This key is associated with a function that allows adding new FSM configurations.
+ * The function takes a process name and its configuration, and returns a cleanup function
+ * to remove the registered configuration.
+ * Example usage:
+ * ```typescript
+ * const context: Record<string, unknown> = {};
+ * initProcessManager(context); // Initialize the process manager in the context
+ * ...
+ * type StateConfig = { key: string; transitions?: string[][]; states?: StateConfig[] };
+ * const registerConfig = context["fsm:sys:registerConfig"] as (name: string, config: StateConfig) => () => void;
+ * const unregister = registerConfig("myProcess", { key: "Main", transitions: [...] });
+ * // To unregister the configuration later
+ * unregister();
+ * ```
+ */
+declare const KEY_REGISTER_CONFIG: "fsm:sys:registerConfig";
+/**
+ * Key used to register state and event handlers for FSM processes in the process context.
+ * This key is associated with a function that allows adding handler modules for a specific process.
+ * The function takes a process name and a variable number of handler modules, returning a cleanup function
+ * to remove the registered handlers.
+ * Example usage:
+ * ```typescript
+ * const context: Record<string, unknown> = {};
+ * initProcessManager(context); // Initialize the process manager in the context
+ * ...
+ * const registerHandlers = context["fsm:sys:registerHandlers"] as (name: string, ...modules: unknown[]) => () => void;
+ * const handlerModule1 = {
+ *   Main: async (context) => { ... },
+ *   SomeState: async (context) => { ... },
+ * }
+ * // Views layer can be defined in the same or separate modules
+ * const handlerModule3 = {
+ *  MainView: async (context) => { ... },
+ *  SomeStateView: async (context) => { ... },
+ * }
+ * // A common handler function to call for all states
+ * const handlerModule2 = (context) => { ... };
+ * const unregister = registerHandlers(
+ *  "myProcess",
+ *  handlerModule1,
+ *  handlerModule2,
+ *  handlerModule3
+ * );
+ * // To unregister the handlers later
+ * unregister();
+ * ```
+ */
+declare const KEY_REGISTER_HANDLERS: "fsm:sys:registerHandlers";
+/**
+ * Key used to launch an FSM process in the process context.
+ * This key is associated with a function that initiates the FSM process based on its name and context.
+ * The function takes the process name and context, returning either nothing, a cleanup function,
+ * or a Promise that resolves to either nothing or a cleanup function.
+ * Example usage:
+ * ```typescript
+ * const context: Record<string, unknown> = {};
+ * initProcessManager(context); // Initialize the process manager in the context
+ * // Register process configurations and handlers as needed
+ *
+ * const launchProcess = context["fsm:sys:launch"] as (name: string, context: Record<string, unknown>) => () => Promise<void>;
+ * const terminate = await launchProcess("myProcess", context);
+ * // To terminate the process later
+ * terminate?.();
+ * ```
+ */
+declare const KEY_LAUNCH_PROCESS: "fsm:sys:launch";
+
+type StageHandler<C = Record<string, unknown>> = (context: C) => void | (() => void | Promise<void>) | Promise<void | (() => void | Promise<void>)> | AsyncGenerator<string, void, unknown> | Generator<string, void, unknown>;
+declare function toStageHandlers<C>(value: unknown, accept: (key: string, value: unknown) => boolean): StageHandler<C>[];
+
+type ProcessConfig = {
+    name: string;
+    config?: FsmStateConfig;
+    handlers?: (StageHandler | {
+        [state: string]: StageHandler | StageHandler[];
+    })[];
+};
+type ProcessLauncherConfig = {
+    start: string[];
+    context?: Record<string, unknown>;
+    processes: ProcessConfig[];
+};
+type LauncherRootContext = Record<string, unknown> & {
+    launch: (processName: string, context: Record<string, unknown>, startEvent?: string) => Promise<() => Promise<void>>;
+};
+declare function launcher(init: (root: LauncherRootContext) => ProcessLauncherConfig | Promise<ProcessLauncherConfig>): Promise<() => Promise<void>>;
+
+interface IProcessConfigManager {
+    getProcessConfig(processName: string): FsmStateConfig;
+    getHandlersLoader<C = unknown>(processName: string): (state: string, event: undefined | string) => StageHandler<C>[];
+    registerConfig(name: string, config: FsmStateConfig): () => void;
+    registerHandlers(name: string, ...modules: unknown[]): () => void;
+}
+declare class ProcessConfigManager implements IProcessConfigManager {
+    protected configs: Record<string, FsmStateConfig>;
+    protected handlers: Record<string, unknown[]>;
+    getProcessConfig(processName: string): FsmStateConfig;
+    getHandlersLoader<C = unknown>(processName: string): (state: string, event: undefined | string) => StageHandler<C>[];
+    registerConfig(name: string, config: FsmStateConfig): () => void;
+    registerHandlers(name: string, ...modules: unknown[]): () => void;
+}
+
+declare function startFsmProcess<C = unknown>(context: C, config: FsmStateConfig, load: (state: string, event: undefined | string) => StageHandler<C>[] | Promise<StageHandler<C>[]>, startEvent?: string): Promise<() => Promise<void>>;
+
 type Printer = (...args: unknown[]) => void;
 type PrinterConfig = {
     prefix?: string;
@@ -117,13 +283,4 @@ declare function setStateTracer(state: FsmState, print?: Printer): void;
 declare function isStateTransitionEnabled(process: FsmProcess, event: string): boolean;
 declare function getStateTransitions(state?: FsmState): [from: string, event: string, to: string][];
 
-type Module<C = unknown> = (context: C) => void | (() => void | Promise<void>) | Promise<void | (() => void | Promise<void>)>;
-declare function newFsmProcess<C>(context: C, config: FsmStateConfig, load: (state: string, event: undefined | string) => undefined | Module<C> | Module<C>[] | Promise<undefined | Module<C> | Module<C>[]>): [
-    dispatch: (event: string) => Promise<boolean>,
-    shutdown: () => Promise<void>
-];
-
-type ModuleOrTrigger<C = unknown> = (context: C) => void | (() => void | Promise<void>) | Promise<void | (() => void | Promise<void>)> | AsyncGenerator<string, void, unknown> | Generator<string, void, unknown>;
-declare function startFsmProcess<C>(context: C, config: FsmStateConfig, load: (state: string, event: undefined | string) => undefined | ModuleOrTrigger<C> | ModuleOrTrigger<C>[] | Promise<undefined | ModuleOrTrigger<C> | ModuleOrTrigger<C>[]>, startEvent?: string): () => Promise<void>;
-
-export { EVENT_ANY, EVENT_EMPTY, type FsmEventKey, FsmProcess, type FsmProcessDump, type FsmProcessDumpHandler, type FsmProcessHandler, FsmState, type FsmStateConfig, FsmStateDescriptor, type FsmStateDump, type FsmStateDumpHandler, type FsmStateErrorHandler, type FsmStateHandler, type FsmStateKey, KEY_PRINTER, type Module, type ModuleOrTrigger, type Printer, type PrinterConfig, STATE_ANY, STATE_FINAL, STATE_INITIAL, STATUS_ENTER, STATUS_EXIT, STATUS_FINISHED, STATUS_FIRST, STATUS_LAST, STATUS_LEAF, STATUS_NEXT, STATUS_NONE, getPrinter, getProcessPrinter, getStateTransitions, isStateTransitionEnabled, newFsmProcess, newProcess, preparePrinter, setPrinter, setProcessPrinter, setProcessTracer, setStateTracer, startFsmProcess };
+export { EVENT_ANY, EVENT_EMPTY, type FsmEventKey, FsmProcess, type FsmProcessDump, type FsmProcessDumpHandler, type FsmProcessHandler, FsmState, type FsmStateConfig, FsmStateDescriptor, type FsmStateDump, type FsmStateDumpHandler, type FsmStateErrorHandler, type FsmStateHandler, type FsmStateKey, type IProcessConfigManager, KEY_DISPATCH, KEY_EVENT, KEY_LAUNCH_PROCESS, KEY_PRINTER, KEY_REGISTER_CONFIG, KEY_REGISTER_HANDLERS, KEY_STATES, KEY_TERMINATE, type LauncherRootContext, type Module, type Printer, type PrinterConfig, type ProcessConfig, ProcessConfigManager, type ProcessLauncherConfig, STATE_ANY, STATE_FINAL, STATE_INITIAL, STATUS_ENTER, STATUS_EXIT, STATUS_FINISHED, STATUS_FIRST, STATUS_LAST, STATUS_LEAF, STATUS_NEXT, STATUS_NONE, type StageHandler, getPrinter, getProcessPrinter, getStateTransitions, isStateTransitionEnabled, launcher, newFsmProcess, newProcess, preparePrinter, setPrinter, setProcessPrinter, setProcessTracer, setStateTracer, startFsmProcess, toStageHandlers };

package/dist/index.js

@@ -15,9 +15,13 @@ var FsmBaseClass = class {
   // ----------------------------------------------
   // internal methods
   _addHandler(type, handler, direct = true) {
-    const list = this.handlers[type] = this.handlers[type] || [];
-    direct ? list.push(handler) : list.unshift(handler);
-    return () => this._removeHandler(type, handler);
+    let list = this.handlers[type];
+    if (!list) {
+      list = this.handlers[type] = [];
+    }
+    const h = handler;
+    direct ? list.push(h) : list.unshift(h);
+    return () => this._removeHandler(type, h);
   }
   _removeHandler(type, handler) {
     let list = this.handlers[type];
@@ -129,12 +133,15 @@ var FsmStateDescriptor = class _FsmStateDescriptor {
   static build(config) {
     const descriptor = new _FsmStateDescriptor();
     for (const [from, event, to] of config.transitions || []) {
-      const index = descriptor.transitions[from] = descriptor.transitions[from] || {};
+      let index = descriptor.transitions[from];
+      if (!index) {
+        index = descriptor.transitions[from] = {};
+      }
       index[event] = to;
     }
     if (config.states) {
       for (const substateConfig of config.states) {
-        descriptor.states[substateConfig.key] = this.build(substateConfig);
+        descriptor.states[substateConfig.key] = _FsmStateDescriptor.build(substateConfig);
       }
     }
     return descriptor;
@@ -299,13 +306,192 @@ var FsmProcess = class extends FsmBaseClass {
   }
 };
 
+// src/utils/transitions.ts
+function isStateTransitionEnabled(process, event) {
+  const transitions = getStateTransitions(process.state);
+  let active = false;
+  for (const [from, ev, to] of transitions) {
+    if (ev === event) {
+      active = true;
+      break;
+    }
+  }
+  return active;
+}
+function getStateTransitions(state) {
+  const result = [];
+  let index = {};
+  if (state) {
+    let prevStateKey = state.key;
+    for (let parent = state?.parent; parent; parent = parent.parent) {
+      if (!parent.descriptor) continue;
+      result.push(
+        ...getTransitionsFromDescriptor(parent.descriptor, prevStateKey, index)
+      );
+      prevStateKey = parent.key;
+    }
+  }
+  return result.reverse();
+}
+function getTransitionsFromDescriptor(descriptor, prevStateKey, index = {}) {
+  const result = [];
+  const prevStateKeys = [prevStateKey, "*"];
+  for (const prevKey of prevStateKeys) {
+    const targets = descriptor.transitions[prevKey];
+    if (targets) {
+      for (const [event, target] of Object.entries(targets)) {
+        if (index[event]) continue;
+        if (target) {
+          index[event] = true;
+        }
+        result.push([prevStateKey, event, target]);
+      }
+    }
+  }
+  return result;
+}
+
+// src/newFsmProcess.ts
+function newFsmProcess(context, config, load) {
+  let started = false;
+  let terminated = false;
+  const process = new FsmProcess(config);
+  async function dispatch(event) {
+    return terminated || event !== void 0 && (!started || isStateTransitionEnabled(process, event)) ? process.dispatch(event) : false;
+  }
+  process.onStateCreate((state) => {
+    started = true;
+    state.onEnter(async () => {
+      const modules = await load(state.key, process.event) ?? [];
+      for (const module of Array.isArray(modules) ? modules : [modules]) {
+        const result = await module?.(context);
+        if (isGenerator2(result)) {
+          state.onExit(() => {
+            result.return?.(void 0);
+          });
+          (async () => {
+            for await (const event of result) {
+              if (terminated) {
+                break;
+              }
+              await dispatch(event);
+              if (terminated) {
+                break;
+              }
+            }
+          })();
+        } else if (typeof result === "function") {
+          state.onExit(result);
+        }
+      }
+    });
+  });
+  async function shutdown() {
+    await process.shutdown();
+    terminated = true;
+  }
+  return [dispatch, shutdown];
+  function isGenerator2(value) {
+    return typeof value === "object" && value !== null && "next" in value && typeof value.next === "function";
+  }
+}
+
+// src/orchestrator/constants.ts
+var KEY_DISPATCH = "fsm:dispatch";
+var KEY_TERMINATE = "fsm:terminate";
+var KEY_STATES = "fsm:states";
+var KEY_EVENT = "fsm:event";
+var KEY_REGISTER_CONFIG = "fsm:sys:registerConfig";
+var KEY_REGISTER_HANDLERS = "fsm:sys:registerHandlers";
+var KEY_LAUNCH_PROCESS = "fsm:sys:launch";
+
+// src/orchestrator/types.ts
+function toStageHandlers(value, accept) {
+  return visit(value);
+  function visit(val) {
+    if (!val) {
+      return [];
+    }
+    if (typeof val === "function") {
+      return [val];
+    }
+    if (typeof val !== "object") {
+      return [];
+    }
+    if (Array.isArray(val)) {
+      return val.flatMap(visit);
+    }
+    const modulesIndex = val;
+    return Object.entries(modulesIndex).flatMap(([key, value2]) => {
+      return accept(key, value2) ? visit(value2) : [];
+    });
+  }
+}
+
+// src/orchestrator/ProcessConfigManager.ts
+var ProcessConfigManager = class {
+  constructor() {
+    this.configs = {};
+    this.handlers = {};
+  }
+  getProcessConfig(processName) {
+    return this.configs[processName] ?? { key: "Main" };
+  }
+  getHandlersLoader(processName) {
+    const config = this.getProcessConfig(processName);
+    return (stateKey) => {
+      const modulesKeys = [];
+      if (stateKey === config.key) {
+        modulesKeys.push("default");
+      }
+      modulesKeys.push(
+        stateKey,
+        `${stateKey}Controller`,
+        `${stateKey}StateController`,
+        `${stateKey}View`,
+        `${stateKey}StateView`,
+        `${stateKey}Trigger`,
+        `${stateKey}StateTrigger`,
+        `${stateKey}Test`,
+        `${stateKey}StateTest`
+      );
+      const keysSet = new Set(modulesKeys);
+      const processHandlers = this.handlers[processName] ?? [];
+      const handlers = toStageHandlers(
+        processHandlers,
+        (key) => keysSet.has(key)
+      );
+      return handlers;
+    };
+  }
+  registerConfig(name, config) {
+    this.configs[name] = config;
+    return () => {
+      delete this.configs[name];
+    };
+  }
+  registerHandlers(name, ...modules) {
+    let list = this.handlers[name];
+    if (!list) {
+      list = this.handlers[name] = [];
+    }
+    list.push(modules);
+    return () => {
+      list = list.filter((v) => v !== modules);
+      if (list.length === 0) {
+        delete this.handlers[name];
+      }
+    };
+  }
+};
+
 // src/utils/printer.ts
 var KEY_PRINTER = "printer";
 function preparePrinter(process, { prefix = "", print = console.log, lineNumbers = false }) {
   let lineCounter = 0;
   const shift = () => {
     let prefix2 = "";
-    for (let s = process.state?.parent; !!s; s = s.parent) {
+    for (let s = process.state?.parent; s; s = s.parent) {
       prefix2 += "  ";
     }
     return prefix2;
@@ -364,101 +550,37 @@ function newProcess(config, {
   return process;
 }
 
-// src/utils/transitions.ts
-function isStateTransitionEnabled(process, event) {
-  const transitions = getStateTransitions(process.state);
-  let active = false;
-  for (const [from, ev, to] of transitions) {
-    if (ev === event) {
-      active = true;
-      break;
-    }
-  }
-  return active;
-}
-function getStateTransitions(state) {
-  const result = [];
-  let index = {};
-  if (state) {
-    let prevStateKey = state.key;
-    for (let parent = state?.parent; parent; parent = parent.parent) {
-      if (!parent.descriptor) continue;
-      result.push(
-        ...getTransitionsFromDescriptor(parent.descriptor, prevStateKey, index)
-      );
-      prevStateKey = parent.key;
-    }
-  }
-  return result.reverse();
-}
-function getTransitionsFromDescriptor(descriptor, prevStateKey, index = {}) {
-  const result = [];
-  const prevStateKeys = [prevStateKey, "*"];
-  for (const prevKey of prevStateKeys) {
-    const targets = descriptor.transitions[prevKey];
-    if (targets) {
-      for (const [event, target] of Object.entries(targets)) {
-        if (index[event]) continue;
-        if (target) {
-          index[event] = true;
-        }
-        result.push([prevStateKey, event, target]);
-      }
-    }
-  }
-  return result;
+// src/orchestrator/isGenerator.ts
+function isGenerator(value) {
+  return typeof value === "object" && value !== null && "next" in value && typeof value.next === "function";
 }
 
-// src/newFsmProcess.ts
-function newFsmProcess(context, config, load) {
-  let started = false;
+// src/orchestrator/startFsmProcess.ts
+async function startFsmProcess(context, config, load, startEvent = "") {
   let terminated = false;
+  const ctx = context;
   const process = new FsmProcess(config);
+  const statesStack = [];
   process.onStateCreate((state) => {
-    started = true;
     state.onEnter(async () => {
+      statesStack.push(state.key);
+      ctx[KEY_STATES] = [...statesStack];
+      ctx[KEY_EVENT] = process.event;
       const modules = await load(state.key, process.event) ?? [];
       for (const module of Array.isArray(modules) ? modules : [modules]) {
-        const handler = await module(context);
-        if (typeof handler === "function") {
-          state.onExit(handler);
-        }
-      }
-    });
-  });
-  async function dispatch(event) {
-    return terminated || event !== void 0 && (!started || isStateTransitionEnabled(process, event)) ? process.dispatch(event) : false;
-  }
-  async function shutdown() {
-    await process.shutdown();
-    terminated = true;
-  }
-  return [dispatch, shutdown];
-}
-
-// src/startFsmProcess.ts
-function startFsmProcess(context, config, load, startEvent = "") {
-  let started = false;
-  let terminated = false;
-  const process = new FsmProcess(config);
-  process.onStateCreate((state) => {
-    started = true;
-    state.onEnter(async () => {
-      const ModuleOrTriggers = await load(state.key, process.event) ?? [];
-      for (const ModuleOrTrigger of Array.isArray(ModuleOrTriggers) ? ModuleOrTriggers : [ModuleOrTriggers]) {
-        const result = await ModuleOrTrigger?.(context);
+        const result = await module?.(context);
         if (isGenerator(result)) {
+          let stateExited = false;
           state.onExit(() => {
+            stateExited = true;
             result.return?.(void 0);
           });
           (async () => {
             for await (const event of result) {
-              if (terminated) {
+              if (stateExited || terminated) {
                 break;
               }
-              if (event !== void 0 && isStateTransitionEnabled(process, event)) {
-                await process.dispatch(event);
-              }
+              await dispatch(event);
             }
           })();
         } else if (typeof result === "function") {
@@ -466,16 +588,59 @@ function startFsmProcess(context, config, load, startEvent = "") {
         }
       }
     });
+    state.onExit(() => {
+      statesStack.pop();
+      ctx[KEY_STATES] = [...statesStack];
+      ctx[KEY_EVENT] = process.event;
+    });
   });
-  function isGenerator(value) {
-    return typeof value === "object" && value !== null && "next" in value && typeof value.next === "function";
-  }
-  async function shutdown() {
-    await process.shutdown();
+  async function terminate() {
     terminated = true;
+    await process.shutdown();
   }
-  process.dispatch(startEvent);
-  return shutdown;
+  async function dispatch(event) {
+    if (event !== void 0 && isStateTransitionEnabled(process, event)) {
+      await process.dispatch(event);
+    }
+  }
+  ctx[KEY_DISPATCH] = dispatch;
+  ctx[KEY_TERMINATE] = terminate;
+  await process.dispatch(startEvent);
+  return terminate;
+}
+
+// src/orchestrator/launcher.ts
+async function launcher(init) {
+  const configsManager = new ProcessConfigManager();
+  async function launch(processName, context, startEvent = "start") {
+    const config2 = configsManager.getProcessConfig(processName);
+    const load = configsManager.getHandlersLoader(processName);
+    return startFsmProcess(context, config2, load, startEvent);
+  }
+  const rootContext = {
+    launch
+  };
+  const config = await init(rootContext);
+  for (const process of config.processes) {
+    if (process.config) {
+      configsManager.registerConfig(process.name, process.config);
+    }
+    if (process.handlers) {
+      configsManager.registerHandlers(process.name, ...process.handlers);
+    }
+  }
+  const shutdowns = [];
+  for (const processName of config.start ?? []) {
+    const parent = config.context ?? rootContext;
+    const context = { parent };
+    const shutdown = await launch(processName, context);
+    shutdowns.push(shutdown);
+  }
+  return async () => {
+    for (const shutdown of shutdowns) {
+      await shutdown();
+    }
+  };
 }
 export {
   EVENT_ANY,
@@ -483,7 +648,15 @@ export {
   FsmProcess,
   FsmState,
   FsmStateDescriptor,
+  KEY_DISPATCH,
+  KEY_EVENT,
+  KEY_LAUNCH_PROCESS,
   KEY_PRINTER,
+  KEY_REGISTER_CONFIG,
+  KEY_REGISTER_HANDLERS,
+  KEY_STATES,
+  KEY_TERMINATE,
+  ProcessConfigManager,
   STATE_ANY,
   STATE_FINAL,
   STATE_INITIAL,
@@ -499,6 +672,7 @@ export {
   getProcessPrinter,
   getStateTransitions,
   isStateTransitionEnabled,
+  launcher,
   newFsmProcess,
   newProcess,
   preparePrinter,
@@ -506,5 +680,6 @@ export {
   setProcessPrinter,
   setProcessTracer,
   setStateTracer,
-  startFsmProcess
+  startFsmProcess,
+  toStageHandlers
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@statewalker/fsm",
-  "version": "0.28.0",
+  "version": "0.30.0",
   "description": "HFSM Implementation",
   "keywords": [],
   "homepage": "https://github.com/statewalker/statewalker-fsm",
@@ -27,13 +27,10 @@
     }
   },
   "devDependencies": {
-    "@changesets/cli": "^2.27.7",
-    "@statewalker/eslint-config": "*",
-    "@statewalker/typescript-config": "*",
-    "eslint": "^9.0.0",
-    "tsup": "^8.0.2",
-    "typescript": "^5.4.4",
-    "vitest": "^1.4.0"
+    "@biomejs/biome": "^2.2.2",
+    "tsup": "^8.5.0",
+    "typescript": "^5.9.2",
+    "vitest": "^3.2.4"
   },
   "repository": {
     "type": "git",
@@ -44,7 +41,9 @@
     "build": "yarn dist",
     "watch": "tsup --watch",
     "clean": "rm -rf dist",
-    "lint": "eslint \"**/*.(js|ts)\"",
+    "format": "biome format . --write",
+    "check": "biome check .",
+    "fix": "yarn format && biome check . --fix --unsafe",
     "test": "vitest --run",
     "test:watch": "vitest",
     "prepublish": "yarn dist"