@camcima/finita 4.2.0 → 4.3.0

package/dist/index.d.cts

@@ -135,6 +135,8 @@ declare class State implements StateInterface {
      */
     _initTransitions(key: InternalConstructionKey, transitions: Iterable<TransitionInterface>): void;
     getName(): string;
+    /** Snapshot — the graph is shared by every machine built from the
+     *  process, so callers must never receive the collection itself. */
     getTransitions(): Iterable<TransitionInterface>;
     getEventNames(): string[];
     hasEvent(name: string): boolean;
@@ -189,7 +191,9 @@ declare class ProcessBuilder<TSubject = unknown> {
     private findInitialStateName;
     private validateTransitionEndpoints;
     /** Transition identity: (fromState, eventName, toState). Used by both the
-     *  conflict check and the build-time dedup — keep them in lockstep. */
+     *  conflict check and the build-time dedup — keep them in lockstep.
+     *  Encoded as a JSON tuple, not a delimiter join: names may contain any
+     *  character, so no delimiter can keep distinct tuples distinct. */
     private static transitionKey;
     private validateNoConflictingDuplicates;
     private collectEventNamesByState;
@@ -351,8 +355,11 @@ interface StatemachineOptions<TSubject = unknown> {
      * Called when an operation chained via EnqueueContext.enqueue() fails.
      * Chained operations are not awaited by the caller whose transition
      * enqueued them, so without this hook their errors are discarded.
-     * Exceptions thrown by the hook itself are swallowed — it must not be
-     * able to break the machine's drain loop.
+     * The hook may be async. It is not awaited, and both exceptions it throws
+     * and rejections of the promise it returns are swallowed — it must not be
+     * able to break the machine's drain loop or surface as an unhandled
+     * rejection. (The return type stays `void`, which already admits async
+     * functions, so callbacks returning incidental values keep compiling.)
      */
     onChainedOperationError?: (error: unknown, info: {
         eventName: string;
@@ -374,7 +381,8 @@ interface StatemachineOptions<TSubject = unknown> {
      * release throws — including when the operation itself also failed, in
      * which case the caller's rejection carries the operation error and the
      * release error would otherwise be discarded. Does not change rejection
-     * behavior. Exceptions thrown by the hook itself are swallowed.
+     * behavior. The hook may be async; it is not awaited, and both exceptions
+     * it throws and rejections of the promise it returns are swallowed.
      */
     onReleaseError?: (error: unknown) => void;
 }
@@ -393,6 +401,8 @@ declare class Statemachine<TSubject = unknown> implements StatemachineInterface<
     private running;
     private idleWaiters;
     private inSyncCallback;
+    /** Set when releasing a held lock fails; see LockOwnershipUncertainError. */
+    private ownershipUncertainty;
     private readonly beforeObservers;
     private readonly afterObservers;
     private readonly onChainedOperationError?;
@@ -418,6 +428,9 @@ declare class Statemachine<TSubject = unknown> implements StatemachineInterface<
      * so manual lock management keeps its existing control flow. Inspect
      * isLockAcquired() (or the hook) to learn whether the lock was actually
      * freed.
+     *
+     * A failed release of a held lock makes every later operation reject with
+     * LockOwnershipUncertainError; a successful call here is how to recover.
      */
     releaseLock(): Promise<void>;
     isLockAcquired(): boolean;
@@ -461,9 +474,22 @@ declare class Statemachine<TSubject = unknown> implements StatemachineInterface<
      * operation also failed, the rejection carries the operation error and this
      * hook is the only place the release error appears.
      *
+     * A failure while the mutex claimed to hold the lock leaves ownership
+     * uncertain and blocks later operations; a success clears that state. A
+     * failed release of a lock the mutex did not claim (a defensive manual
+     * release) is still reported but changes nothing.
+     *
      * @returns null on success, or the failure wrapped for the caller to raise.
      */
     private releaseMutex;
+    /**
+     * Runs a user diagnostic hook in isolation. Neither a synchronous throw nor
+     * a rejection of a returned promise may reach the drain loop or the host:
+     * an unavailable telemetry backend must not fail an operation or, via an
+     * unhandled rejection, terminate the process. A returned promise is
+     * deliberately not awaited — a slow reporter must not stall the runner.
+     */
+    private callDiagnosticHook;
     private resolveEvent;
     /**
      * Drive transitions starting from the current state, following automatic
@@ -563,26 +589,37 @@ declare abstract class CompositeCondition<TSubject = unknown> implements Conditi
     constructor(joinWord: string, condition: ConditionInterface<TSubject>);
     protected addCondition(condition: ConditionInterface<TSubject>): this;
     getName(): string;
-    abstract checkCondition(subject: TSubject, context: Map<string, unknown>): Promise<boolean>;
+    abstract checkCondition(subject: TSubject, context: Map<string, unknown>): MaybePromise<boolean>;
+    /**
+     * Evaluates children in order, stopping at the first whose result equals
+     * `shortCircuitOn`. A child that returns a plain boolean is consumed
+     * synchronously; only a returned promise is awaited. Awaiting plain values
+     * would yield between children and end the machine's synchronous
+     * re-entrancy guard, so a re-entrant later child would deadlock instead of
+     * throwing ReentrancyError. For the same reason the composite itself
+     * returns a plain boolean when every child it evaluated did.
+     */
+    protected evaluate(subject: TSubject, context: Map<string, unknown>, shortCircuitOn: boolean): MaybePromise<boolean>;
 }
 
 declare class AndComposite<TSubject = unknown> extends CompositeCondition<TSubject> {
     constructor(condition: ConditionInterface<TSubject>);
     addAnd(condition: ConditionInterface<TSubject>): this;
-    checkCondition(subject: TSubject, context: Map<string, unknown>): Promise<boolean>;
+    checkCondition(subject: TSubject, context: Map<string, unknown>): MaybePromise<boolean>;
 }
 
 declare class OrComposite<TSubject = unknown> extends CompositeCondition<TSubject> {
     constructor(condition: ConditionInterface<TSubject>);
     addOr(condition: ConditionInterface<TSubject>): this;
-    checkCondition(subject: TSubject, context: Map<string, unknown>): Promise<boolean>;
+    checkCondition(subject: TSubject, context: Map<string, unknown>): MaybePromise<boolean>;
 }
 
 declare class Not<TSubject = unknown> implements ConditionInterface<TSubject> {
     private readonly condition;
     constructor(condition: ConditionInterface<TSubject>);
     getName(): string;
-    checkCondition(subject: TSubject, context: Map<string, unknown>): Promise<boolean>;
+    /** Stays synchronous for a synchronous child — see CompositeCondition. */
+    checkCondition(subject: TSubject, context: Map<string, unknown>): MaybePromise<boolean>;
 }
 
 /**
@@ -705,6 +742,11 @@ declare class LockAdapterMutex implements MutexInterface {
      * pass the check and acquire twice on a non-idempotent adapter (database
      * advisory locks, redis SET NX). The pending promise is cleared once it
      * settles, so a failed acquire can still be retried.
+     *
+     * The clearing is attached to the attempt only after it is stored: an
+     * adapter that throws synchronously settles the attempt before the
+     * assignment would otherwise run, and clearing inside the attempt itself
+     * would then leave the rejected promise cached forever.
      */
     acquireLock(): Promise<boolean>;
     releaseLock(): Promise<boolean>;
@@ -810,7 +852,7 @@ declare class GraphBuilder {
 
 declare abstract class FinitaError extends Error {
     abstract readonly code: string;
-    constructor(message?: string);
+    constructor(message?: string, options?: ErrorOptions);
 }
 
 declare class WrongEventForStateError extends FinitaError {
@@ -839,6 +881,23 @@ declare class LockCanNotBeReleasedError extends FinitaError {
     constructor(message?: string);
 }
 
+/**
+ * A lock release failed earlier, so the machine can no longer tell whether it
+ * still holds the lock: the unlock may have taken effect remotely with its
+ * reply lost, or may never have happened. Running further operations on the
+ * old ownership flag could violate mutual exclusion, so every operation is
+ * rejected with this error until a manual Statemachine.releaseLock()
+ * succeeds.
+ *
+ * `cause` carries the release failure. When the release cannot be confirmed
+ * — typically because the lock was in fact already freed — discard the
+ * machine and build a new one from persisted state.
+ */
+declare class LockOwnershipUncertainError extends FinitaError {
+    readonly code = "lockOwnershipUncertain";
+    constructor(cause: unknown);
+}
+
 declare class DuplicateStateError extends FinitaError {
     readonly code = "duplicateState";
     readonly stateName: string;
@@ -933,4 +992,4 @@ declare class QueueLimitExceededError extends FinitaError {
     constructor(limit: number, eventName: string | null);
 }
 
-export { AbstractNamedProcessDetector, ActiveTransitionFilter, type AddStateOptions, type AddTransitionOptions, type AfterTransitionObserver, type AmbiguousTransitionCandidate, AmbiguousTransitionError, AndComposite, AutomaticTransitionCycleError, type BeforeTransitionObserver, type BuildOptions, CallbackCondition, type CallbackInterface, CallbackObserver, type ConditionCallbackFn, type ConditionInterface, Contradiction, type DispatcherInterface, type DotOptions, DuplicateStateError, type DuplicateTransitionConflict, DuplicateTransitionError, type EnqueueContext, Event, type EventInterface, Factory, type FactoryInterface, type FactoryStatemachineOptions, FilterStateByEvent, FilterStateByFinalState, FilterStateByTransition, FilterTransitionByEvent, FinitaError, type Graph, GraphBuilder, type GraphDirection, type GraphEdge, type GraphNode, type GraphValidationCode, GraphValidationError, InvalidSubjectError, type LastStateHasChangedDateInterface, type LockAdapterInterface, LockAdapterMutex, LockCanNotBeAcquiredError, LockCanNotBeReleasedError, type LoggerInterface, type MaybePromise, type MermaidOptions, type Metadata, MutexFactory, type MutexFactoryInterface, type MutexInterface, type Named, Not, NullMutex, type ObservableSubject, type Observer, OnEnterObserver, OneOrNoneActiveTransition, OrComposite, Process, ProcessBuilder, type ProcessDetectorInterface, ProcessFinalizedError, type ProcessInterface, ProcessNotFoundError, type ProposedTransitionFrame, QueueLimitExceededError, ReentrancyError, ScoreTransition, SingleProcessDetector, State, type StateCollectionInterface, StateEventNotFoundError, type StateInterface, type StateNameDetectorInterface, StateNotFoundError, type StatefulInterface, StatefulStateNameDetector, StatefulStatusChanger, Statemachine, type StatemachineInterface, type StatemachineOptions, type StringConverter, Tautology, Timeout, Transition, type TransitionFrame, type TransitionInterface, TransitionLogger, type TransitionSelectorInterface, WeightTransition, type Weighted, WrongEventForStateError };
+export { AbstractNamedProcessDetector, ActiveTransitionFilter, type AddStateOptions, type AddTransitionOptions, type AfterTransitionObserver, type AmbiguousTransitionCandidate, AmbiguousTransitionError, AndComposite, AutomaticTransitionCycleError, type BeforeTransitionObserver, type BuildOptions, CallbackCondition, type CallbackInterface, CallbackObserver, type ConditionCallbackFn, type ConditionInterface, Contradiction, type DispatcherInterface, type DotOptions, DuplicateStateError, type DuplicateTransitionConflict, DuplicateTransitionError, type EnqueueContext, Event, type EventInterface, Factory, type FactoryInterface, type FactoryStatemachineOptions, FilterStateByEvent, FilterStateByFinalState, FilterStateByTransition, FilterTransitionByEvent, FinitaError, type Graph, GraphBuilder, type GraphDirection, type GraphEdge, type GraphNode, type GraphValidationCode, GraphValidationError, InvalidSubjectError, type LastStateHasChangedDateInterface, type LockAdapterInterface, LockAdapterMutex, LockCanNotBeAcquiredError, LockCanNotBeReleasedError, LockOwnershipUncertainError, type LoggerInterface, type MaybePromise, type MermaidOptions, type Metadata, MutexFactory, type MutexFactoryInterface, type MutexInterface, type Named, Not, NullMutex, type ObservableSubject, type Observer, OnEnterObserver, OneOrNoneActiveTransition, OrComposite, Process, ProcessBuilder, type ProcessDetectorInterface, ProcessFinalizedError, type ProcessInterface, ProcessNotFoundError, type ProposedTransitionFrame, QueueLimitExceededError, ReentrancyError, ScoreTransition, SingleProcessDetector, State, type StateCollectionInterface, StateEventNotFoundError, type StateInterface, type StateNameDetectorInterface, StateNotFoundError, type StatefulInterface, StatefulStateNameDetector, StatefulStatusChanger, Statemachine, type StatemachineInterface, type StatemachineOptions, type StringConverter, Tautology, Timeout, Transition, type TransitionFrame, type TransitionInterface, TransitionLogger, type TransitionSelectorInterface, WeightTransition, type Weighted, WrongEventForStateError };

package/dist/index.d.ts

@@ -135,6 +135,8 @@ declare class State implements StateInterface {
      */
     _initTransitions(key: InternalConstructionKey, transitions: Iterable<TransitionInterface>): void;
     getName(): string;
+    /** Snapshot — the graph is shared by every machine built from the
+     *  process, so callers must never receive the collection itself. */
     getTransitions(): Iterable<TransitionInterface>;
     getEventNames(): string[];
     hasEvent(name: string): boolean;
@@ -189,7 +191,9 @@ declare class ProcessBuilder<TSubject = unknown> {
     private findInitialStateName;
     private validateTransitionEndpoints;
     /** Transition identity: (fromState, eventName, toState). Used by both the
-     *  conflict check and the build-time dedup — keep them in lockstep. */
+     *  conflict check and the build-time dedup — keep them in lockstep.
+     *  Encoded as a JSON tuple, not a delimiter join: names may contain any
+     *  character, so no delimiter can keep distinct tuples distinct. */
     private static transitionKey;
     private validateNoConflictingDuplicates;
     private collectEventNamesByState;
@@ -351,8 +355,11 @@ interface StatemachineOptions<TSubject = unknown> {
      * Called when an operation chained via EnqueueContext.enqueue() fails.
      * Chained operations are not awaited by the caller whose transition
      * enqueued them, so without this hook their errors are discarded.
-     * Exceptions thrown by the hook itself are swallowed — it must not be
-     * able to break the machine's drain loop.
+     * The hook may be async. It is not awaited, and both exceptions it throws
+     * and rejections of the promise it returns are swallowed — it must not be
+     * able to break the machine's drain loop or surface as an unhandled
+     * rejection. (The return type stays `void`, which already admits async
+     * functions, so callbacks returning incidental values keep compiling.)
      */
     onChainedOperationError?: (error: unknown, info: {
         eventName: string;
@@ -374,7 +381,8 @@ interface StatemachineOptions<TSubject = unknown> {
      * release throws — including when the operation itself also failed, in
      * which case the caller's rejection carries the operation error and the
      * release error would otherwise be discarded. Does not change rejection
-     * behavior. Exceptions thrown by the hook itself are swallowed.
+     * behavior. The hook may be async; it is not awaited, and both exceptions
+     * it throws and rejections of the promise it returns are swallowed.
      */
     onReleaseError?: (error: unknown) => void;
 }
@@ -393,6 +401,8 @@ declare class Statemachine<TSubject = unknown> implements StatemachineInterface<
     private running;
     private idleWaiters;
     private inSyncCallback;
+    /** Set when releasing a held lock fails; see LockOwnershipUncertainError. */
+    private ownershipUncertainty;
     private readonly beforeObservers;
     private readonly afterObservers;
     private readonly onChainedOperationError?;
@@ -418,6 +428,9 @@ declare class Statemachine<TSubject = unknown> implements StatemachineInterface<
      * so manual lock management keeps its existing control flow. Inspect
      * isLockAcquired() (or the hook) to learn whether the lock was actually
      * freed.
+     *
+     * A failed release of a held lock makes every later operation reject with
+     * LockOwnershipUncertainError; a successful call here is how to recover.
      */
     releaseLock(): Promise<void>;
     isLockAcquired(): boolean;
@@ -461,9 +474,22 @@ declare class Statemachine<TSubject = unknown> implements StatemachineInterface<
      * operation also failed, the rejection carries the operation error and this
      * hook is the only place the release error appears.
      *
+     * A failure while the mutex claimed to hold the lock leaves ownership
+     * uncertain and blocks later operations; a success clears that state. A
+     * failed release of a lock the mutex did not claim (a defensive manual
+     * release) is still reported but changes nothing.
+     *
      * @returns null on success, or the failure wrapped for the caller to raise.
      */
     private releaseMutex;
+    /**
+     * Runs a user diagnostic hook in isolation. Neither a synchronous throw nor
+     * a rejection of a returned promise may reach the drain loop or the host:
+     * an unavailable telemetry backend must not fail an operation or, via an
+     * unhandled rejection, terminate the process. A returned promise is
+     * deliberately not awaited — a slow reporter must not stall the runner.
+     */
+    private callDiagnosticHook;
     private resolveEvent;
     /**
      * Drive transitions starting from the current state, following automatic
@@ -563,26 +589,37 @@ declare abstract class CompositeCondition<TSubject = unknown> implements Conditi
     constructor(joinWord: string, condition: ConditionInterface<TSubject>);
     protected addCondition(condition: ConditionInterface<TSubject>): this;
     getName(): string;
-    abstract checkCondition(subject: TSubject, context: Map<string, unknown>): Promise<boolean>;
+    abstract checkCondition(subject: TSubject, context: Map<string, unknown>): MaybePromise<boolean>;
+    /**
+     * Evaluates children in order, stopping at the first whose result equals
+     * `shortCircuitOn`. A child that returns a plain boolean is consumed
+     * synchronously; only a returned promise is awaited. Awaiting plain values
+     * would yield between children and end the machine's synchronous
+     * re-entrancy guard, so a re-entrant later child would deadlock instead of
+     * throwing ReentrancyError. For the same reason the composite itself
+     * returns a plain boolean when every child it evaluated did.
+     */
+    protected evaluate(subject: TSubject, context: Map<string, unknown>, shortCircuitOn: boolean): MaybePromise<boolean>;
 }
 
 declare class AndComposite<TSubject = unknown> extends CompositeCondition<TSubject> {
     constructor(condition: ConditionInterface<TSubject>);
     addAnd(condition: ConditionInterface<TSubject>): this;
-    checkCondition(subject: TSubject, context: Map<string, unknown>): Promise<boolean>;
+    checkCondition(subject: TSubject, context: Map<string, unknown>): MaybePromise<boolean>;
 }
 
 declare class OrComposite<TSubject = unknown> extends CompositeCondition<TSubject> {
     constructor(condition: ConditionInterface<TSubject>);
     addOr(condition: ConditionInterface<TSubject>): this;
-    checkCondition(subject: TSubject, context: Map<string, unknown>): Promise<boolean>;
+    checkCondition(subject: TSubject, context: Map<string, unknown>): MaybePromise<boolean>;
 }
 
 declare class Not<TSubject = unknown> implements ConditionInterface<TSubject> {
     private readonly condition;
     constructor(condition: ConditionInterface<TSubject>);
     getName(): string;
-    checkCondition(subject: TSubject, context: Map<string, unknown>): Promise<boolean>;
+    /** Stays synchronous for a synchronous child — see CompositeCondition. */
+    checkCondition(subject: TSubject, context: Map<string, unknown>): MaybePromise<boolean>;
 }
 
 /**
@@ -705,6 +742,11 @@ declare class LockAdapterMutex implements MutexInterface {
      * pass the check and acquire twice on a non-idempotent adapter (database
      * advisory locks, redis SET NX). The pending promise is cleared once it
      * settles, so a failed acquire can still be retried.
+     *
+     * The clearing is attached to the attempt only after it is stored: an
+     * adapter that throws synchronously settles the attempt before the
+     * assignment would otherwise run, and clearing inside the attempt itself
+     * would then leave the rejected promise cached forever.
      */
     acquireLock(): Promise<boolean>;
     releaseLock(): Promise<boolean>;
@@ -810,7 +852,7 @@ declare class GraphBuilder {
 
 declare abstract class FinitaError extends Error {
     abstract readonly code: string;
-    constructor(message?: string);
+    constructor(message?: string, options?: ErrorOptions);
 }
 
 declare class WrongEventForStateError extends FinitaError {
@@ -839,6 +881,23 @@ declare class LockCanNotBeReleasedError extends FinitaError {
     constructor(message?: string);
 }
 
+/**
+ * A lock release failed earlier, so the machine can no longer tell whether it
+ * still holds the lock: the unlock may have taken effect remotely with its
+ * reply lost, or may never have happened. Running further operations on the
+ * old ownership flag could violate mutual exclusion, so every operation is
+ * rejected with this error until a manual Statemachine.releaseLock()
+ * succeeds.
+ *
+ * `cause` carries the release failure. When the release cannot be confirmed
+ * — typically because the lock was in fact already freed — discard the
+ * machine and build a new one from persisted state.
+ */
+declare class LockOwnershipUncertainError extends FinitaError {
+    readonly code = "lockOwnershipUncertain";
+    constructor(cause: unknown);
+}
+
 declare class DuplicateStateError extends FinitaError {
     readonly code = "duplicateState";
     readonly stateName: string;
@@ -933,4 +992,4 @@ declare class QueueLimitExceededError extends FinitaError {
     constructor(limit: number, eventName: string | null);
 }
 
-export { AbstractNamedProcessDetector, ActiveTransitionFilter, type AddStateOptions, type AddTransitionOptions, type AfterTransitionObserver, type AmbiguousTransitionCandidate, AmbiguousTransitionError, AndComposite, AutomaticTransitionCycleError, type BeforeTransitionObserver, type BuildOptions, CallbackCondition, type CallbackInterface, CallbackObserver, type ConditionCallbackFn, type ConditionInterface, Contradiction, type DispatcherInterface, type DotOptions, DuplicateStateError, type DuplicateTransitionConflict, DuplicateTransitionError, type EnqueueContext, Event, type EventInterface, Factory, type FactoryInterface, type FactoryStatemachineOptions, FilterStateByEvent, FilterStateByFinalState, FilterStateByTransition, FilterTransitionByEvent, FinitaError, type Graph, GraphBuilder, type GraphDirection, type GraphEdge, type GraphNode, type GraphValidationCode, GraphValidationError, InvalidSubjectError, type LastStateHasChangedDateInterface, type LockAdapterInterface, LockAdapterMutex, LockCanNotBeAcquiredError, LockCanNotBeReleasedError, type LoggerInterface, type MaybePromise, type MermaidOptions, type Metadata, MutexFactory, type MutexFactoryInterface, type MutexInterface, type Named, Not, NullMutex, type ObservableSubject, type Observer, OnEnterObserver, OneOrNoneActiveTransition, OrComposite, Process, ProcessBuilder, type ProcessDetectorInterface, ProcessFinalizedError, type ProcessInterface, ProcessNotFoundError, type ProposedTransitionFrame, QueueLimitExceededError, ReentrancyError, ScoreTransition, SingleProcessDetector, State, type StateCollectionInterface, StateEventNotFoundError, type StateInterface, type StateNameDetectorInterface, StateNotFoundError, type StatefulInterface, StatefulStateNameDetector, StatefulStatusChanger, Statemachine, type StatemachineInterface, type StatemachineOptions, type StringConverter, Tautology, Timeout, Transition, type TransitionFrame, type TransitionInterface, TransitionLogger, type TransitionSelectorInterface, WeightTransition, type Weighted, WrongEventForStateError };
+export { AbstractNamedProcessDetector, ActiveTransitionFilter, type AddStateOptions, type AddTransitionOptions, type AfterTransitionObserver, type AmbiguousTransitionCandidate, AmbiguousTransitionError, AndComposite, AutomaticTransitionCycleError, type BeforeTransitionObserver, type BuildOptions, CallbackCondition, type CallbackInterface, CallbackObserver, type ConditionCallbackFn, type ConditionInterface, Contradiction, type DispatcherInterface, type DotOptions, DuplicateStateError, type DuplicateTransitionConflict, DuplicateTransitionError, type EnqueueContext, Event, type EventInterface, Factory, type FactoryInterface, type FactoryStatemachineOptions, FilterStateByEvent, FilterStateByFinalState, FilterStateByTransition, FilterTransitionByEvent, FinitaError, type Graph, GraphBuilder, type GraphDirection, type GraphEdge, type GraphNode, type GraphValidationCode, GraphValidationError, InvalidSubjectError, type LastStateHasChangedDateInterface, type LockAdapterInterface, LockAdapterMutex, LockCanNotBeAcquiredError, LockCanNotBeReleasedError, LockOwnershipUncertainError, type LoggerInterface, type MaybePromise, type MermaidOptions, type Metadata, MutexFactory, type MutexFactoryInterface, type MutexInterface, type Named, Not, NullMutex, type ObservableSubject, type Observer, OnEnterObserver, OneOrNoneActiveTransition, OrComposite, Process, ProcessBuilder, type ProcessDetectorInterface, ProcessFinalizedError, type ProcessInterface, ProcessNotFoundError, type ProposedTransitionFrame, QueueLimitExceededError, ReentrancyError, ScoreTransition, SingleProcessDetector, State, type StateCollectionInterface, StateEventNotFoundError, type StateInterface, type StateNameDetectorInterface, StateNotFoundError, type StatefulInterface, StatefulStateNameDetector, StatefulStatusChanger, Statemachine, type StatemachineInterface, type StatemachineOptions, type StringConverter, Tautology, Timeout, Transition, type TransitionFrame, type TransitionInterface, TransitionLogger, type TransitionSelectorInterface, WeightTransition, type Weighted, WrongEventForStateError };