@statewalker/fsm 0.36.0 → 0.37.0

package/dist/index.js

@@ -1,786 +1,45 @@
-// src/core/fsm-base-class.ts
-var FsmBaseClass = class {
-  constructor() {
-    this.handlers = {};
-    this.data = {};
-    bindMethods(this, "setData", "getData");
-  }
-  setData(key, value) {
-    this.data[key] = value;
-    return this;
-  }
-  getData(key) {
-    return this.data[key];
-  }
-  // ----------------------------------------------
-  // internal methods
-  _addHandler(type, handler, direct = true) {
-    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];
-    if (!list) return;
-    list = list.filter((h) => h !== handler);
-    if (list.length > 0) {
-      this.handlers[type] = list;
-    } else {
-      delete this.handlers[type];
-    }
-  }
-  async _runHandlerParallel(type, ...args) {
-    const list = this.handlers[type] || [];
-    await Promise.all(
-      list.map(async (handler) => {
-        try {
-          await handler(...args);
-        } catch (error) {
-          this._handleError(error);
-        }
-      })
-    );
-  }
-  async _runHandler(type, ...args) {
-    const list = this.handlers[type] || [];
-    for (const handler of list) {
-      try {
-        await handler(...args);
-      } catch (error) {
-        await this._handleError(error);
-      }
-    }
-  }
-  async _handleError(error) {
-    console.error(error);
-  }
-};
-function bindMethods(obj, ...methods) {
-  const o = obj;
-  for (const methodName of methods) {
-    const method = o[methodName];
-    if (typeof method !== "function") continue;
-    o[methodName] = method.bind(o);
-  }
-  return obj;
-}
-
-// src/core/fsm-state.ts
-var FsmState = class extends FsmBaseClass {
-  constructor(process2, parent, key, descriptor) {
-    super();
-    this.process = process2;
-    this.key = key;
-    this.parent = parent;
-    this.descriptor = descriptor;
-    bindMethods(
-      this,
-      "onEnter",
-      "onExit",
-      "dump",
-      "restore",
-      "useData",
-      "onStateError"
-    );
-  }
-  onEnter(handler) {
-    return this._addHandler("onEnter", handler, true);
-  }
-  onExit(handler) {
-    return this._addHandler("onExit", handler, false);
-  }
-  onStateError(handler) {
-    return this._addHandler("onStateError", handler);
-  }
-  dump(handler) {
-    return this._addHandler("dump", handler, true);
-  }
-  restore(handler) {
-    return this._addHandler("restore", handler, true);
-  }
-  getData(key, recursive = true) {
-    return this.data[key] ?? (recursive ? this.parent?.getData(key, recursive) : void 0);
-  }
-  useData(key) {
-    return [
-      (recursive = true) => this.getData(key, recursive),
-      (value) => this.setData(key, value)
-    ];
-  }
-  async _handleError(error) {
-    await this._runHandler("onStateError", this, error);
-    await this.process._handleStateError(this, error);
-  }
-};
-
-// src/core/fsm-state-config.ts
-var STATE_ANY = "*";
-var STATE_INITIAL = "";
-var STATE_FINAL = "";
-var EVENT_ANY = "*";
-var EVENT_EMPTY = "";
-
-// src/core/fsm-state-descriptor.ts
-var FsmStateDescriptor = class _FsmStateDescriptor {
-  constructor() {
-    this.transitions = {};
-    this.states = {};
-  }
-  static build(config) {
-    const descriptor = new _FsmStateDescriptor();
-    for (const [from, event, to] of config.transitions || []) {
-      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] = _FsmStateDescriptor.build(substateConfig);
-      }
-    }
-    return descriptor;
-  }
-  getTargetStateKey(stateKey, eventKey) {
-    const pairs = [
-      [stateKey, eventKey],
-      [STATE_ANY, eventKey],
-      [stateKey, EVENT_ANY],
-      [STATE_ANY, EVENT_ANY]
-    ];
-    let targetKey;
-    for (let i = 0, len = pairs.length; targetKey === void 0 && i < len; i++) {
-      const [stateKey2, eventKey2] = pairs[i];
-      const stateTransitions = this.transitions[stateKey2];
-      if (!stateTransitions) continue;
-      targetKey = stateTransitions[eventKey2];
-    }
-    return targetKey !== void 0 ? targetKey : STATE_FINAL;
-  }
-};
-
-// src/core/fsm-process.ts
-var STATUS_NONE = 0;
-var STATUS_FIRST = 1;
-var STATUS_NEXT = 2;
-var STATUS_LEAF = 4;
-var STATUS_LAST = 8;
-var STATUS_FINISHED = 16;
-var STATUS_ENTER = STATUS_FIRST | STATUS_NEXT;
-var STATUS_EXIT = STATUS_LEAF | STATUS_LAST;
-var FsmProcess = class extends FsmBaseClass {
-  constructor(config) {
-    super();
-    this.running = false;
-    this.mask = STATUS_LEAF;
-    this.status = 0;
-    this.rootDescriptor = FsmStateDescriptor.build(config);
-    this.config = config;
-    bindMethods(this, "dispatch", "dump", "restore");
-  }
-  async shutdown(event) {
-    while (this.state) {
-      this.event = event;
-      this.status = STATUS_FINISHED;
-      await this.state?._runHandler("onExit", this.state);
-      this.state = this.state.parent;
-    }
-  }
-  async dispatch(event) {
-    this.nextEvent = event;
-    if (!this.running && !(this.status & STATUS_FINISHED)) {
-      this.running = true;
-      try {
-        this.event = this.nextEvent;
-        this.nextEvent = void 0;
-        while (true) {
-          if (this.status & STATUS_EXIT) {
-            await this.state?._runHandler("onExit", this.state);
-          }
-          if (!this._update()) break;
-          if (this.status & STATUS_ENTER) {
-            await this.state?._runHandler("onEnter", this.state);
-          }
-          if (this.status & this.mask) break;
-        }
-      } finally {
-        this.running = false;
-      }
-      const nextEvent = this.nextEvent;
-      if (nextEvent !== void 0) {
-        return Promise.resolve().then(() => this.dispatch(nextEvent));
-      }
-    }
-    return !(this.status & STATUS_FINISHED);
-  }
-  async dump(...args) {
-    const dumpState = async (state) => {
-      const stateDump = {
-        key: state.key,
-        data: {}
-      };
-      await state._runHandler("dump", state, stateDump.data, ...args);
-      return stateDump;
-    };
-    const dumpStates = async (state, stack = []) => {
-      if (!state) return stack;
-      state.parent && await dumpStates(state.parent, stack);
-      stack.push(await dumpState(state));
-      return stack;
-    };
-    const dump = {
-      status: this.status,
-      event: this.event,
-      stack: await dumpStates(this.state)
-    };
-    return dump;
-  }
-  async restore(dump, ...args) {
-    this.status = dump.status || 0;
-    this.event = dump.event;
-    this.state = void 0;
-    for (let i = 0; i < dump.stack.length; i++) {
-      const stateDump = dump.stack[i];
-      this.state = this.state ? this._newSubstate(this.state, stateDump.key) : this._newState(void 0, stateDump.key, this.rootDescriptor);
-      await this.state._runHandler(
-        "restore",
-        this.state,
-        stateDump.data,
-        ...args
-      );
-    }
-    return this;
-  }
-  onStateCreate(handler) {
-    return this._addHandler("onStateCreate", handler, true);
-  }
-  onStateError(handler) {
-    return this._addHandler("onStateError", handler);
-  }
-  async _handleStateError(state, error) {
-    await this._runHandler("onStateError", state, error);
-    this._handleError(error);
-  }
-  _newState(parent, key, descriptor) {
-    const state = new FsmState(this, parent, key, descriptor);
-    this._runHandlerParallel("onStateCreate", state);
-    return state;
-  }
-  _getSubstate(parent, prevStateKey) {
-    if (!parent) return;
-    const toState = parent.descriptor?.getTargetStateKey(
-      prevStateKey || STATE_INITIAL,
-      this.event || EVENT_EMPTY
-    ) || STATE_FINAL;
-    if (!toState) return;
-    return this._newSubstate(parent, toState);
-  }
-  _newSubstate(parent, toState) {
-    let descriptor;
-    for (let state = parent; !descriptor && state; state = state.parent) {
-      descriptor = state.descriptor?.states[toState];
-    }
-    return this._newState(parent, toState, descriptor);
-  }
-  _update() {
-    if (this.status & STATUS_FINISHED) return false;
-    const nextState = this.status !== STATUS_NONE ? this.status & STATUS_ENTER ? this._getSubstate(this.state, STATE_INITIAL) : this._getSubstate(this.state?.parent, this.state?.key) : this._newState(void 0, this.config.key, this.rootDescriptor);
-    if (nextState !== void 0) {
-      this.state = nextState;
-      this.status = this.status & STATUS_EXIT ? STATUS_NEXT : STATUS_FIRST;
-    } else {
-      if (this.status & STATUS_EXIT) {
-        this.state = this.state?.parent;
-        this.status = STATUS_LAST;
-      } else {
-        this.status = STATUS_LEAF;
-      }
-      if (!this.state) this.status = STATUS_FINISHED;
-    }
-    return !(this.status & STATUS_FINISHED);
-  }
-};
-
-// src/utils/transitions.ts
-function isStateTransitionEnabled(process2, event) {
-  const transitions = getStateTransitions(process2.state);
-  let active = false;
-  for (const [from, ev, to] of transitions) {
-    if (ev === event) {
-      active = true;
-      break;
-    }
-  }
-  return active;
-}
-function getStateTransitions(state) {
-  const result = [];
-  const 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/core/new-fsm-process.ts
-function newFsmProcess(context, config, load) {
-  let started = false;
-  let terminated = false;
-  const process2 = new FsmProcess(config);
-  async function dispatch(event) {
-    return terminated || event !== void 0 && (!started || isStateTransitionEnabled(process2, event)) ? process2.dispatch(event) : false;
-  }
-  process2.onStateCreate((state) => {
-    started = true;
-    state.onEnter(async () => {
-      const modules = await load(state.key, process2.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 process2.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/process-config-manager.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(process2, { prefix = "", print = console.log, lineNumbers = false }) {
-  let lineCounter = 0;
-  const shift = () => {
-    let prefix2 = "";
-    for (let s = process2.state?.parent; s; s = s.parent) {
-      prefix2 += "  ";
-    }
-    return prefix2;
-  };
-  const getPrefix = lineNumbers ? () => `[${++lineCounter}]${shift()}` : shift;
-  const printer = (...args) => print(prefix, getPrefix(), ...args);
-  return printer;
-}
-function setPrinter(state, config = {}) {
-  const printer = preparePrinter(state.process, config);
-  state.setData(KEY_PRINTER, printer);
-}
-function setProcessPrinter(process2, config = {}) {
-  const printer = preparePrinter(process2, config);
-  process2.setData(KEY_PRINTER, printer);
-}
-function getProcessPrinter(process2) {
-  return process2.getData(KEY_PRINTER) || console.log;
+import { A as bindMethods, C as EVENT_ANY, D as STATE_INITIAL, E as STATE_FINAL, O as FsmState, S as FsmStateDescriptor, T as STATE_ANY, _ as STATUS_FIRST, a as KEY_STATES, b as STATUS_NEXT, c as isStateTransitionEnabled, d as createHandlerRegistry, f as toStageHandlers, g as STATUS_FINISHED, h as STATUS_EXIT, i as KEY_EVENT, k as FsmBaseClass, l as startFsmProcess, m as STATUS_ENTER, n as launcher, o as KEY_TERMINATE, p as FsmProcess, r as KEY_DISPATCH, s as getStateTransitions, t as KEY_LAUNCH_PROCESS, u as startProcess, v as STATUS_LAST, w as EVENT_EMPTY, x as STATUS_NONE, y as STATUS_LEAF } from "./launcher-CASrMAOa.js";
+//#region src/utils/printer.ts
+const printerStore = /* @__PURE__ */ new WeakMap();
+function preparePrinter(process, { prefix = "", print = console.log, lineNumbers = false }) {
+	let lineCounter = 0;
+	const shift = () => {
+		let prefix = "";
+		for (let s = process.state?.parent; s; s = s.parent) prefix += "  ";
+		return prefix;
+	};
+	const getPrefix = lineNumbers ? () => `[${++lineCounter}]${shift()}` : shift;
+	const printer = (...args) => print(prefix, getPrefix(), ...args);
+	return printer;
+}
+function setProcessPrinter(process, config = {}) {
+	const printer = preparePrinter(process, config);
+	printerStore.set(process, printer);
+}
+function getProcessPrinter(process) {
+	return printerStore.get(process) || console.log;
 }
 function getPrinter(state) {
-  return state.getData(KEY_PRINTER, true) || getProcessPrinter(state.process);
+	return printerStore.get(state) || getProcessPrinter(state.process);
 }
-
-// src/utils/tracer.ts
-function setProcessTracer(process2, print) {
-  return process2.onStateCreate((state) => {
-    setStateTracer(state, print);
-  });
+//#endregion
+//#region src/utils/tracer.ts
+function setProcessTracer(process, print) {
+	return process.onStateCreate((state) => {
+		setStateTracer(state, print);
+	});
 }
 function setStateTracer(state, print) {
-  state.onEnter(() => {
-    const printLine = print || getPrinter(state);
-    printLine(`<${state?.key} event="${state.process.event}">`);
-  });
-  state.onExit(async () => {
-    await Promise.resolve().then(async () => {
-      const printLine = print || getPrinter(state);
-      printLine(`</${state.key}> <!-- event="${state.process.event}" -->`);
-    });
-  });
-}
-
-// src/utils/process.ts
-function newProcess(config, {
-  prefix,
-  print,
-  lineNumbers = true
-}) {
-  const process2 = new FsmProcess(config);
-  setProcessPrinter(process2, {
-    prefix,
-    print,
-    lineNumbers
-  });
-  setProcessTracer(process2);
-  return process2;
-}
-
-// src/orchestrator/is-generator.ts
-function isGenerator(value) {
-  return typeof value === "object" && value !== null && "next" in value && typeof value.next === "function";
-}
-
-// src/orchestrator/start-process.ts
-async function startFsmProcess(context, config, load, startEvent = "") {
-  let terminated = false;
-  const ctx = context;
-  const process2 = new FsmProcess(config);
-  const statesStack = [];
-  process2.onStateCreate((state) => {
-    state.onEnter(async () => {
-      statesStack.push(state.key);
-      ctx[KEY_STATES] = [...statesStack];
-      ctx[KEY_EVENT] = process2.event;
-      const modules = await load(state.key, process2.event) ?? [];
-      for (const module of Array.isArray(modules) ? modules : [modules]) {
-        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 (stateExited || terminated) {
-                break;
-              }
-              await dispatch(event);
-            }
-          })();
-        } else if (typeof result === "function") {
-          state.onExit(result);
-        }
-      }
-    });
-    state.onExit(() => {
-      statesStack.pop();
-      ctx[KEY_STATES] = [...statesStack];
-      ctx[KEY_EVENT] = process2.event;
-    });
-  });
-  async function terminate() {
-    terminated = true;
-    await process2.shutdown();
-  }
-  async function dispatch(event) {
-    if (event !== void 0 && isStateTransitionEnabled(process2, event)) {
-      await process2.dispatch(event);
-    }
-  }
-  ctx[KEY_DISPATCH] = dispatch;
-  ctx[KEY_TERMINATE] = terminate;
-  await process2.dispatch(startEvent);
-  return terminate;
-}
-
-// src/orchestrator/launcher.ts
-function asArray(value, filter = (v) => v) {
-  if (value === void 0) return [];
-  const array = Array.isArray(value) ? value : [value];
-  return array.filter(Boolean).map(filter).filter(Boolean);
-}
-async function launcher(options) {
-  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);
-  }
-  function registerProcess(configsManager2, process2) {
-    if (!process2 || typeof process2 !== "object") {
-      throw new Error("Invalid process configuration: not an object");
-    }
-    const processName = process2.name;
-    if (!processName || typeof processName !== "string") {
-      throw new Error("Invalid process configuration: missing or invalid name");
-    }
-    const processConfig = process2.config;
-    if (processConfig && typeof processConfig !== "object") {
-      throw new Error(
-        `Invalid process configuration: config is not an object in process ${process2.name}`
-      );
-    }
-    if (processConfig) {
-      configsManager2.registerConfig(processName, processConfig);
-    }
-    const processHandlers = asArray(
-      process2.handlers ?? process2.handler ?? process2.default,
-      (v, idx) => {
-        if (typeof v === "function") return v;
-        if (typeof v === "object" && v !== null) return v;
-        throw new Error(
-          [
-            `Invalid process configuration:`,
-            `a process handler is not object nor function in process ${processName} at index ${idx}`,
-            `Recieved: ${v === null ? "null" : typeof v}`
-          ].join("\n")
-        );
-      }
-    );
-    if (processHandlers.length > 0) {
-      configsManager2.registerHandlers(processName, ...processHandlers);
-    }
-  }
-  const rootContext = { "fsm:launch": launch };
-  const init = typeof options === "function" ? options : async () => options;
-  const config = await init(rootContext);
-  if (typeof config !== "object" || !config) {
-    throw new Error("Invalid launcher configuration");
-  }
-  const processes = asArray(
-    config.processes ?? config.process ?? config.default,
-    (v) => {
-      if (typeof v === "function") {
-        return {
-          name: v.name || "",
-          handler: v
-        };
-      }
-      if (typeof v !== "object") {
-        throw new Error(
-          "Invalid launcher configuration: process is not an object"
-        );
-      }
-      return v;
-    }
-  );
-  const processesToStart = {};
-  for (const process2 of processes) {
-    const processName = process2.name;
-    const start = process2.start;
-    if (start === void 0) {
-      if (!(processName in processesToStart)) {
-        processesToStart[processName] = void 0;
-      }
-    } else {
-      processesToStart[processName] = start;
-    }
-    registerProcess(configsManager, process2);
-  }
-  const shutdowns = [];
-  let initContext = (context) => context;
-  const configContext = config.context ?? config.init;
-  if (configContext) {
-    if (typeof configContext === "function") {
-      initContext = configContext;
-    } else if (typeof configContext === "object") {
-      initContext = () => ({ parent: configContext });
-    } else {
-      throw new Error("Invalid launcher configuration: context");
-    }
-  }
-  for (const [processName, start] of Object.entries(processesToStart)) {
-    if (start === false) continue;
-    let context = {
-      parent: rootContext,
-      "fsm:name": processName
-    };
-    context = initContext(context) ?? context;
-    if (typeof context !== "object") {
-      throw new Error(
-        `Invalid launcher context for process "${processName}". Expected an object, but recieved ${typeof context}.`
-      );
-    }
-    const shutdown = await launch(processName, context);
-    shutdowns.push(shutdown);
-  }
-  return async () => {
-    for (const shutdown of shutdowns) {
-      await shutdown();
-    }
-  };
-}
-
-// src/orchestrator/resolve-module-refs.ts
-function resolveModulesUrls(baseUrl, ...refs) {
-  return refs.map((ref) => new URL(ref, baseUrl).href);
-}
-function resolveModulesPaths(baseUrl, ...refs) {
-  return refs.map((ref) => new URL(ref, baseUrl).pathname);
-}
-
-// src/orchestrator/start-processes.ts
-async function startProcesses({
-  onExit,
-  modules,
-  init
-}) {
-  const modulesList = [];
-  for (const module of modules) {
-    modulesList.push(
-      typeof module === "string" || module instanceof URL ? await import(String(module)) : module
-    );
-  }
-  return await launcher({
-    init,
-    processes: [
-      ...modulesList,
-      // This function is called on exit at the end of the process chain
-      function Exit() {
-        return onExit;
-      }
-    ]
-  });
-}
-
-// src/orchestrator/start-node-processes.ts
-async function startNodeProcesses(modules) {
-  try {
-    if (!modules) {
-      modules = process.argv.slice(2);
-    }
-    const terminate = await startProcesses({
-      modules: resolveModulesPaths(`file://${process.cwd()}/`, ...modules),
-      onExit: () => process.exit(0)
-    });
-    process.on("SIGINT", terminate);
-    process.on("SIGTERM", terminate);
-    process.stdin.resume();
-  } catch (err) {
-    console.error("Fatal error:", err);
-    process.exit(1);
-  }
-}
-
-// src/index.ts
-var index_default = startNodeProcesses;
+	state.onEnter(() => {
+		(print || getPrinter(state))(`<${state?.key} event="${state.process.event}">`);
+	});
+	state.onExit(async () => {
+		await Promise.resolve().then(async () => {
+			(print || getPrinter(state))(`</${state.key}> <!-- event="${state.process.event}" -->`);
+		});
+	});
+}
+//#endregion
+export { EVENT_ANY, EVENT_EMPTY, FsmBaseClass, FsmProcess, FsmState, FsmStateDescriptor, KEY_DISPATCH, KEY_EVENT, KEY_LAUNCH_PROCESS, KEY_STATES, KEY_TERMINATE, STATE_ANY, STATE_FINAL, STATE_INITIAL, STATUS_ENTER, STATUS_EXIT, STATUS_FINISHED, STATUS_FIRST, STATUS_LAST, STATUS_LEAF, STATUS_NEXT, STATUS_NONE, bindMethods, createHandlerRegistry, getPrinter, getProcessPrinter, getStateTransitions, isStateTransitionEnabled, launcher, preparePrinter, setProcessPrinter, setProcessTracer, setStateTracer, startFsmProcess, startProcess, toStageHandlers };
 
-export { EVENT_ANY, EVENT_EMPTY, 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, STATUS_ENTER, STATUS_EXIT, STATUS_FINISHED, STATUS_FIRST, STATUS_LAST, STATUS_LEAF, STATUS_NEXT, STATUS_NONE, index_default as default, getPrinter, getProcessPrinter, getStateTransitions, isStateTransitionEnabled, launcher, newFsmProcess, newProcess, preparePrinter, resolveModulesPaths, resolveModulesUrls, setPrinter, setProcessPrinter, setProcessTracer, setStateTracer, startFsmProcess, startNodeProcesses, startProcesses, toStageHandlers };
-//# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map