ihsm 0.0.14 → 0.0.20

package/lib/cjs/index.js

@@ -0,0 +1,493 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FatalErrorState = exports.InitializationError = exports.FatalError = exports.InitialStateError = exports.UnhandledEventError = exports.EventHandlerError = exports.TransitionError = exports.RuntimeError = exports.HsmError = exports.TopState = exports.TraceLevel = void 0;
+exports.InitialState = InitialState;
+exports.defineStateName = defineStateName;
+exports.registerStateNames = registerStateNames;
+exports.makeHsm = makeHsm;
+const hsm_1 = require("./internal/hsm");
+const utils_1 = require("./internal/utils");
+// export type DispatchErrorCallback<Context, Protocol extends {} | undefined> = (hsm: Hsm<Context, Protocol>, traceWriter: TraceWriter, err: Error) => void;
+/**
+ * Controls how much diagnostic detail the runtime emits through {@link TraceWriter}.
+ *
+ * Set at construction via {@link makeHsm} or mutate {@link Properties.traceLevel} on a
+ * live instance. Changing the level swaps the internal dispatch tracer implementation.
+ *
+ * @category Factory
+ */
+var TraceLevel;
+(function (TraceLevel) {
+    /**
+     * Production mode: minimal tracing overhead, no verbose dispatch steps.
+     * Use in hot paths and shipped bundles when trace output is disabled.
+     */
+    TraceLevel[TraceLevel["PRODUCTION"] = 0] = "PRODUCTION";
+    /**
+     * Debug mode: transition boundaries, handler entry/exit, and error summaries.
+     * Default for {@link makeHsm}. Suitable for development and integration tests.
+     */
+    TraceLevel[TraceLevel["DEBUG"] = 1] = "DEBUG";
+    /**
+     * Verbose debug: includes prototype-chain lookup walks, cache hits/misses, and
+     * nested trace domains. Use when correlating handler code with tutorial trace panels.
+     */
+    TraceLevel[TraceLevel["VERBOSE_DEBUG"] = 2] = "VERBOSE_DEBUG";
+})(TraceLevel || (exports.TraceLevel = TraceLevel = {}));
+/**
+ * Abstract root class for every state in the hierarchy.
+ *
+ * States are **never constructed directly** — the runtime binds one instance object whose
+ * prototype moves along the class chain. Subclass `TopState` (or a child state), implement
+ * your `Protocol` methods, and pass the root class to {@link makeHsm}.
+ *
+ * Forwards {@link State} / {@link Properties} APIs and default {@link StateEvents} behavior.
+ *
+ * @category State machine
+ */
+class TopState {
+    /** Domain context (injected by runtime — do not assign in constructors). */
+    ctx;
+    /** Handler view of the machine (`this` inside methods delegates here for core operations). */
+    hsm;
+    constructor() {
+        throw new Error('Fatal error: States cannot be instantiated');
+    }
+    /** @inheritdoc Properties.eventName */
+    get eventName() {
+        return this.hsm.eventName;
+    }
+    /** @inheritdoc Properties.eventPayload */
+    get eventPayload() {
+        return this.hsm.eventPayload;
+    }
+    /** @inheritdoc Properties.traceHeader */
+    get traceHeader() {
+        return this.hsm.traceHeader;
+    }
+    /** @inheritdoc Properties.topState */
+    get topState() {
+        return this.hsm.topState;
+    }
+    /** @inheritdoc Properties.currentStateName */
+    get currentStateName() {
+        return this.hsm.currentStateName;
+    }
+    /** @inheritdoc Properties.currentState */
+    get currentState() {
+        return this.hsm.currentState;
+    }
+    /** @inheritdoc Properties.ctxTypeName */
+    get ctxTypeName() {
+        return this.hsm.ctxTypeName;
+    }
+    /** @inheritdoc Properties.traceLevel */
+    set traceLevel(value) {
+        this.hsm.traceLevel = value;
+    }
+    /** @inheritdoc Properties.traceLevel */
+    get traceLevel() {
+        return this.hsm.traceLevel;
+    }
+    /** @inheritdoc Properties.topStateName */
+    get topStateName() {
+        return this.hsm.topStateName;
+    }
+    /** @inheritdoc Properties.traceWriter */
+    get traceWriter() {
+        return this.hsm.traceWriter;
+    }
+    /** @inheritdoc Properties.traceWriter */
+    set traceWriter(value) {
+        this.hsm.traceWriter = value;
+    }
+    /** @inheritdoc Properties.dispatchErrorCallback */
+    get dispatchErrorCallback() {
+        return this.hsm.dispatchErrorCallback;
+    }
+    /** @inheritdoc Properties.dispatchErrorCallback */
+    set dispatchErrorCallback(value) {
+        this.hsm.dispatchErrorCallback = value;
+    }
+    /** @inheritdoc State.transition */
+    transition(nextState) {
+        this.hsm.transition(nextState);
+    }
+    /** @inheritdoc State.unhandled */
+    unhandled() {
+        this.hsm.unhandled();
+    }
+    /** @inheritdoc State.sleep */
+    sleep(millis) {
+        return this.hsm.sleep(millis);
+    }
+    /** @inheritdoc Base.post */
+    post(eventName, ...eventPayload) {
+        this.hsm.post(eventName, ...eventPayload);
+    }
+    /** @inheritdoc Base.deferredPost */
+    deferredPost(millis, eventName, ...eventPayload) {
+        this.hsm.deferredPost(millis, eventName, ...eventPayload);
+    }
+    /** @inheritdoc State.postNow */
+    postNow(eventName, ...eventPayload) {
+        this.hsm.postNow(eventName, ...eventPayload);
+    }
+    /** @inheritdoc StateEvents.onExit */
+    onExit() { }
+    /** @inheritdoc StateEvents.onEntry */
+    onEntry() { }
+    /** @inheritdoc StateEvents.onError */
+    onError(error) {
+        throw error;
+    }
+    /** @inheritdoc StateEvents.onUnhandled */
+    onUnhandled(error) {
+        throw error;
+    }
+}
+exports.TopState = TopState;
+/**
+ * Base class for all ihsm runtime errors carrying machine context.
+ *
+ * @typeParam Context - Domain context at failure time
+ * @typeParam Protocol - Vocabulary type (for typed subclasses)
+ *
+ * @category Error
+ */
+class HsmError extends Error {
+    /** Discriminator matching the class name (`EventHandlerError`, etc.). */
+    name;
+    /** {@link Properties.topStateName} when the error was constructed. */
+    topStateName;
+    /** {@link Properties.currentStateName} when the error was constructed. */
+    stateName;
+    /** Snapshot of {@link State.ctx} when the error was constructed. */
+    context;
+    /** Original thrown value when this error wraps a handler or lifecycle failure. */
+    cause;
+    constructor(name, hsm, message, cause) {
+        super(message);
+        this.name = name;
+        this.topStateName = hsm.topStateName;
+        this.stateName = hsm.currentStateName;
+        this.context = hsm.ctx;
+        this.cause = cause;
+    }
+}
+exports.HsmError = HsmError;
+/**
+ * Error base for failures during **event dispatch**, with correlated event metadata.
+ *
+ * @typeParam Context - Domain context
+ * @typeParam Protocol - Vocabulary interface
+ * @typeParam EventName - Event or service key being processed
+ *
+ * @category Error
+ */
+class RuntimeError extends HsmError {
+    /** Event or service name that was active when the failure occurred. */
+    eventName;
+    /** Client-supplied arguments (excluding resolve/reject for services). */
+    eventPayload;
+    constructor(errorName, hsm, message, cause) {
+        super(errorName, hsm, message, cause);
+        this.eventName = hsm.eventName;
+        this.eventPayload = hsm.eventPayload;
+    }
+}
+exports.RuntimeError = RuntimeError;
+/**
+ * Thrown when {@link StateEvents.onExit} or {@link StateEvents.onEntry} throws during a transition.
+ *
+ * @category Error
+ */
+class TransitionError extends RuntimeError {
+    failedStateName;
+    failedCallback;
+    fromStateName;
+    toStateName;
+    /**
+     * @param hsm - Machine view at failure time
+     * @param cause - Error thrown from the lifecycle hook
+     * @param failedStateName - Display name of the state whose hook failed
+     * @param failedCallback - Which hook failed (`onExit` or `onEntry`)
+     * @param fromStateName - Leaf state before the transition
+     * @param toStateName - Requested destination state
+     */
+    constructor(hsm, cause, failedStateName, failedCallback, fromStateName, toStateName) {
+        super('TransitionError', hsm, `${failedStateName}.${failedCallback}() has failed while executing a transition from ${fromStateName} to ${toStateName}`, cause);
+        this.failedStateName = failedStateName;
+        this.failedCallback = failedCallback;
+        this.fromStateName = fromStateName;
+        this.toStateName = toStateName;
+    }
+}
+exports.TransitionError = TransitionError;
+/**
+ * Thrown when an event handler body throws and {@link StateEvents.onError} does not recover.
+ *
+ * @category Error
+ */
+class EventHandlerError extends RuntimeError {
+    /**
+     * @param hsm - Machine view with {@link eventName} set to the failing handler
+     * @param cause - Error thrown from handler code
+     */
+    constructor(hsm, cause) {
+        super('EventHandlerError', hsm, `an error was thrown while executing event handler #${hsm.eventName} in state ${hsm.currentStateName}`, cause);
+    }
+}
+exports.EventHandlerError = EventHandlerError;
+/**
+ * Thrown when no handler matches the dispatched event and {@link StateEvents.onUnhandled} rethrows.
+ *
+ * @category Error
+ */
+class UnhandledEventError extends RuntimeError {
+    /** @param hsm - Machine view with the unmatched {@link eventName} */
+    constructor(hsm) {
+        super('UnhandledEventError', hsm, `event #${hsm.eventName} was unhandled in state ${hsm.currentStateName}`);
+    }
+}
+exports.UnhandledEventError = UnhandledEventError;
+/**
+ * Thrown at **class definition** time when {@link InitialState} is applied twice to one parent.
+ *
+ * @category Error
+ */
+class InitialStateError extends Error {
+    /** Display name of the state passed to the duplicate {@link InitialState} call. */
+    targetStateName;
+    /** @param targetState - The state class whose parent already has an initial substate */
+    constructor(targetState) {
+        super(`State '${(0, utils_1.getStateName)(Object.getPrototypeOf(targetState.prototype).constructor)}' must not have more than one initial state`);
+        this.name = 'InitialStateError';
+        this.targetStateName = (0, utils_1.getStateName)(targetState);
+    }
+}
+exports.InitialStateError = InitialStateError;
+/**
+ * Thrown when {@link StateEvents.onError} itself throws, leaving the machine unrecoverable.
+ *
+ * @category Error
+ */
+class FatalError extends RuntimeError {
+    /**
+     * @param hsm - Machine view at failure time
+     * @param cause - Error thrown from `onError`
+     */
+    constructor(hsm, cause) {
+        super('FatalError', hsm, `onError() has thrown ${(0, utils_1.quoteError)(cause)}`, cause);
+    }
+}
+exports.FatalError = FatalError;
+/**
+ * Thrown when {@link StateEvents.onEntry} fails during the initial `@InitialState` walk at startup.
+ *
+ * @category Error
+ */
+class InitializationError extends HsmError {
+    failedState;
+    /**
+     * @param hsm - Partially initialized machine
+     * @param failedState - State class whose `onEntry` threw
+     * @param cause - Original error from `onEntry`
+     */
+    constructor(hsm, failedState, cause) {
+        super('InitializationError', hsm, `state ${(0, utils_1.getStateName)(failedState)} has thrown ${(0, utils_1.quoteError)(cause)} during initialization`, cause);
+        this.failedState = failedState;
+    }
+}
+exports.InitializationError = InitializationError;
+/**
+ * Terminal sink state class used when the runtime cannot recover from an error.
+ *
+ * Assign or transition here from custom {@link StateEvents.onError} handlers when you need a
+ * well-defined quiescent state. Display name is pre-registered as `'FatalErrorState'`.
+ *
+ * @category State machine
+ */
+class FatalErrorState extends TopState {
+}
+exports.FatalErrorState = FatalErrorState;
+(0, utils_1.defineStateName)(TopState, 'TopState');
+(0, utils_1.defineStateName)(FatalErrorState, 'FatalErrorState');
+/**
+ * Declares `TargetState` as the **initial substate** of its direct parent composite.
+ *
+ * Apply as a TypeScript decorator or call as a function at class definition time. Exactly **one**
+ * initial child is allowed per parent; a second mark throws {@link InitialStateError}.
+ *
+ * @typeParam Context - Domain context type
+ * @typeParam Protocol - Vocabulary interface
+ * @param TargetState - Child state class whose **parent** is `Object.getPrototypeOf(TargetState.prototype).constructor`
+ *
+ * @throws {@link InitialStateError} when the parent already has an initial substate
+ *
+ * @remarks
+ * During {@link makeHsm} initialization, the runtime descends `@InitialState` chains from the
+ * root until the deepest initial leaf is active, running {@link StateEvents.onEntry} along the path.
+ *
+ * @example
+ * ```ts
+ * class Composite extends TopState {}
+ *
+ * @InitialState
+ * class Idle extends Composite {}
+ * ```
+ */
+function InitialState(TargetState) {
+    const ParentOfTargetState = Object.getPrototypeOf(TargetState.prototype).constructor;
+    if ((0, utils_1.hasInitialState)(ParentOfTargetState))
+        throw new InitialStateError(TargetState);
+    Object.defineProperty(TargetState, '_isInitialState', {
+        value: true,
+        writable: false,
+        configurable: false,
+        enumerable: false,
+    });
+    Object.defineProperty(ParentOfTargetState, '_initialState', {
+        value: TargetState,
+        writable: false,
+        configurable: false,
+        enumerable: false,
+    });
+}
+/**
+ * Assigns a stable **display name** to a single state class.
+ *
+ * Minifiers rewrite `Class.name` in production browser bundles; explicit registration keeps
+ * {@link Properties.currentStateName}, trace output, and error messages readable everywhere.
+ *
+ * @typeParam Context - Domain context type
+ * @typeParam Protocol - Vocabulary interface
+ * @param state - State class constructor to tag
+ * @param name - Non-empty display string used in traces and errors (not required to match `Class.name`)
+ *
+ * @remarks
+ * Stored as a non-enumerable own property — never inherited by subclasses from the prototype chain.
+ * {@link registerStateNames} is preferred when every state is a named export from one module.
+ *
+ * @example
+ * ```ts
+ * class Door extends TopState {}
+ * defineStateName(Door, 'Door');
+ * ```
+ *
+ * @category State machine
+ */
+function defineStateName(state, name) {
+    (0, utils_1.defineStateName)(state, name);
+}
+/**
+ * Registers display names for **every** state class in an exports object, using each **export key** as the name.
+ *
+ * @param exports - Module namespace (`import * as machine`) or object literal of state classes.
+ *   Non-constructor exports (constants, functions, types) are silently skipped
+ *
+ * @remarks
+ * Export keys survive minification even when class identifiers are mangled — this is the recommended
+ * approach for browser bundles without `keep_classnames`. Call once at module load after all state
+ * classes are defined.
+ *
+ * @example Single module
+ * ```ts
+ * export class DoorTop extends TopState {}
+ * export class Open extends DoorTop {}
+ * export class Closed extends DoorTop {}
+ * registerStateNames({ DoorTop, Open, Closed });
+ * ```
+ *
+ * @example Re-exporting namespace
+ * ```ts
+ * import * as machine from './machine';
+ * registerStateNames(machine);
+ * ```
+ *
+ * @category State machine
+ */
+function registerStateNames(exports) {
+    for (const [exportName, value] of Object.entries(exports)) {
+        if (isStateClass(value)) {
+            (0, utils_1.defineStateName)(value, exportName);
+        }
+    }
+}
+/** @internal — structural guard: a constructor whose prototype derives from {@link TopState}. */
+function isStateClass(value) {
+    if (typeof value !== 'function')
+        return false;
+    const prototype = value.prototype;
+    return typeof prototype === 'object' && prototype !== null && TopState.prototype.isPrototypeOf(prototype);
+}
+/** @internal */
+class ConsoleTraceWriter {
+    write(hsm, Message) {
+        if (typeof Message == 'string') {
+            console.log(`${hsm.traceHeader}${hsm.currentStateName}: ${Message}`);
+        }
+        else {
+            console.log(Message);
+        }
+    }
+}
+function defaultDispatchErrorCallback(hsm, err) {
+    const writer = hsm.traceWriter;
+    writer.write(hsm, `An event dispatch has failed; error ${err.name}: ${err.message} has not been managed`);
+    writer.write(hsm, err);
+    throw err;
+}
+const defaultTraceWriter = new ConsoleTraceWriter();
+const defaultTraceLevel = TraceLevel.DEBUG;
+const defaultInitialize = true;
+/**
+ * Creates and optionally initializes a hierarchical state machine **actor** bound to `ctx`.
+ *
+ * The returned {@link Hsm} is the single runtime object: external clients call `post` / `call` /
+ * `sync`; the active state is the instance prototype chain updated by {@link State.transition}.
+ *
+ * @typeParam Context - Domain context type (inferred from `ctx` when passed inline)
+ * @typeParam Protocol - Event/service vocabulary (inferred from `topState` when it implements `Protocol`)
+ * @param topState - Root state **class** constructor (must extend {@link TopState})
+ * @param ctx - Mutable domain object shared by all states; stored on the instance as {@link Hsm.ctx}
+ * @param initialize - When `true` (default), enqueue the initial walk: descend `@InitialState`
+ *   chains from `topState` and run {@link StateEvents.onEntry} on each entered state until the
+ *   initial leaf is active. When `false`, prototype starts at `topState` with **no** entry hooks
+ * @param traceLevel - Initial {@link TraceLevel} (default {@link TraceLevel.DEBUG})
+ * @param traceWriter - {@link TraceWriter} implementation (default: prefixes strings with state name and logs to `console`)
+ * @param dispatchErrorCallback - Last-resort error hook (default: trace + rethrow)
+ * @returns Client handle implementing {@link Hsm} for the same `Context` and `Protocol`
+ *
+ * @remarks
+ * - Await {@link Hsm.sync} after creation when `initialize: true` before asserting initial state
+ * - Zero runtime npm dependencies; safe to embed in browsers when state names are registered
+ * - Transition LCA paths are cached per machine instance for the lifetime of the actor
+ *
+ * @example Minimal door machine
+ * ```ts
+ * const door = makeHsm(DoorTop, { openCount: 0 });
+ * await door.sync();
+ * door.post('open');
+ * await door.sync();
+ * ```
+ *
+ * @example Custom tracing in tests
+ * ```ts
+ * const writer = { write: (_hsm, msg) => logs.push(msg) };
+ * const sm = makeHsm(Top, ctx, true, TraceLevel.VERBOSE_DEBUG, writer);
+ * await sm.sync();
+ * ```
+ *
+ * @category Factory
+ */
+function makeHsm(topState, ctx, initialize = defaultInitialize, traceLevel = defaultTraceLevel, traceWriter = defaultTraceWriter, dispatchErrorCallback = defaultDispatchErrorCallback) {
+    const instance = {
+        hsm: undefined,
+        ctx: ctx,
+    };
+    Object.setPrototypeOf(instance, topState.prototype);
+    instance.hsm = new hsm_1.HsmObject(topState, instance, traceWriter, traceLevel, dispatchErrorCallback, initialize);
+    return instance.hsm;
+}
+//# sourceMappingURL=index.js.map

package/lib/cjs/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"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"}

package/lib/cjs/internal/defs.private.d.ts

@@ -0,0 +1,31 @@
+import { PostedEvent, EventPayload, Hsm, StateClass, State } from '../';
+/** @internal */
+export interface Instance<Context, Protocol extends {} | undefined> {
+    ctx: Context;
+    hsm: HsmWithTracing<Context, Protocol>;
+}
+/** @internal */
+export interface Transition<Context, Protocol extends {} | undefined> {
+    execute(hsm: HsmWithTracing<Context, Protocol>, srcState: StateClass<Context, Protocol>, dstState: StateClass<Context, Protocol>): Promise<void>;
+}
+/** @internal */
+export type DoneCallback = () => void;
+/** @internal */
+export type Task = (done: DoneCallback) => void;
+/** @internal */
+export interface HsmWithTracing<Context, Protocol extends {} | undefined> extends Hsm<Context, Protocol>, State<Context, Protocol> {
+    _transitionCache: Map<string, Transition<Context, Protocol>>;
+    _createInitTask: <DispatchContext, DispatchProtocol extends {} | undefined>(hsm: HsmWithTracing<DispatchContext, DispatchProtocol>) => Task;
+    _createEventDispatchTask: <DispatchContext, DispatchProtocol extends {} | undefined, EventName extends keyof DispatchProtocol>(hsm: HsmWithTracing<DispatchContext, DispatchProtocol>, eventName: PostedEvent<DispatchProtocol, EventName>, ...eventPayload: EventPayload<DispatchProtocol, EventName>) => Task;
+    _instance: Instance<Context, Protocol>;
+    _transitionState?: StateClass<Context, Protocol>;
+    _currentEventName?: string;
+    _currentEventPayload?: any[];
+    currentState: StateClass<Context, Protocol>;
+    _tracePush(domain: string, msg: string): void;
+    _tracePopDone(msg: string): void;
+    _tracePopError(msg: string): void;
+    _traceWrite(msg: any): void;
+    unshiftHiPriorityTask(t: Task): void;
+    pushHiPriorityTask(t: Task): void;
+}

package/lib/cjs/internal/defs.private.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=defs.private.js.map

package/lib/cjs/internal/defs.private.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"defs.private.js","sourceRoot":"","sources":["../../../src/internal/defs.private.ts"],"names":[],"mappings":""}

package/lib/cjs/internal/dispatch.debug.d.ts

@@ -0,0 +1,4 @@
+import { PostedEvent, EventPayload } from '../';
+import { HsmWithTracing, Task } from './defs.private';
+export declare function createInitTask<DispatchContext, DispatchProtocol extends {} | undefined>(hsm: HsmWithTracing<DispatchContext, DispatchProtocol>): Task;
+export declare function createEventDispatchTask<DispatchContext, DispatchProtocol extends {} | undefined, EventName extends keyof DispatchProtocol>(hsm: HsmWithTracing<DispatchContext, DispatchProtocol>, eventName: PostedEvent<DispatchProtocol, EventName>, ...eventPayload: EventPayload<DispatchProtocol, EventName>): Task;