@hurum/core 0.0.1

package/dist/store-BrPM22fc.d.ts

@@ -0,0 +1,467 @@
+declare const EVENT_CREATOR_BRAND: unique symbol;
+/** Marker type for event payload definition */
+interface EventDefinition<T> {
+    readonly __payload?: T;
+}
+/** An event instance: has a `type` string and payload properties */
+type EventInstance<TType extends string = string, TPayload = unknown> = {
+    readonly type: TType;
+} & TPayload;
+/** An event creator function that produces typed event instances */
+interface EventCreator<TType extends string = string, TPayload = unknown> {
+    (payload: TPayload): EventInstance<TType, TPayload>;
+    readonly type: TType;
+    readonly [EVENT_CREATOR_BRAND]: true;
+}
+/**
+ * Define an event payload type. Used within `Events()` to declare event shapes.
+ *
+ * @example
+ * ```ts
+ * const MyEvent = Events('My', {
+ *   happened: Event<{ value: number }>(),
+ * })
+ * ```
+ */
+declare function Event<T = {}>(): EventDefinition<T>;
+type EventCreatorMap<TPrefix extends string, TDefs extends Record<string, EventDefinition<unknown>>> = {
+    readonly [K in keyof TDefs & string]: TDefs[K] extends EventDefinition<infer P> ? EventCreator<`${TPrefix}/${K}`, P> : never;
+};
+/**
+ * Create a namespaced group of event creators.
+ *
+ * @example
+ * ```ts
+ * const PurchaseEvent = Events('Purchase', {
+ *   saved: Event<{ purchase: Purchase }>(),
+ *   saveFailed: Event<{ error: Error }>(),
+ * })
+ *
+ * PurchaseEvent.saved({ purchase }) // { type: 'Purchase/saved', purchase: ... }
+ * PurchaseEvent.saved.type          // 'Purchase/saved' (string literal type)
+ * ```
+ */
+declare function Events<TPrefix extends string, TDefs extends Record<string, EventDefinition<unknown>>>(prefix: TPrefix, events: TDefs): EventCreatorMap<TPrefix, TDefs>;
+
+declare const COMMAND_BRAND: unique symbol;
+declare const EXECUTOR_BRAND: unique symbol;
+/** A branded command type. Commands are identified by their unique symbol. */
+interface Command<TInput = unknown> {
+    readonly [COMMAND_BRAND]: symbol;
+    readonly name?: string;
+    readonly __inputType?: TInput;
+}
+/** Context provided to executor functions */
+interface ExecutorContext<TDeps = unknown, TState = unknown> {
+    readonly deps: TDeps;
+    readonly emit: (event: EventInstance) => void;
+    readonly getState: () => TState;
+    readonly signal: AbortSignal;
+    /** Access nested child store instances. Available when the store has Nested fields. */
+    readonly scope: Record<string, unknown>;
+}
+/** The executor function type */
+type ExecutorFn<TInput, TDeps, TState> = (command: TInput, context: ExecutorContext<TDeps, TState>) => void | Promise<void>;
+/** An executor registered with a Store.
+ *  __fn is type-erased (never params) to keep Executor covariant in TInput/TDeps/TState. */
+interface Executor<TInput = unknown, TDeps = unknown, TState = unknown> {
+    readonly [EXECUTOR_BRAND]: true;
+    readonly __command: Command<TInput>;
+    readonly __fn: (command: never, context: never) => void | Promise<void>;
+    readonly __inputType?: TInput;
+    readonly __depsType?: TDeps;
+    readonly __stateType?: TState;
+}
+/**
+ * Create a CommandExecutor pair: [Command, Executor].
+ *
+ * Optionally provide a name as the first argument for devtools visibility.
+ *
+ * @example
+ * ```ts
+ * // With explicit name
+ * const [SaveCmd, SaveExec] = CommandExecutor<
+ *   { purchase: Purchase },
+ *   { repo: PurchaseRepo },
+ * >('SavePurchase', async (command, { deps, emit }) => {
+ *   const result = await deps.repo.save(command.purchase)
+ *   result.match(
+ *     (saved) => emit(PurchaseEvent.saved({ purchase: saved })),
+ *     (error) => emit(PurchaseEvent.saveFailed({ error })),
+ *   )
+ * })
+ *
+ * // Without name (fn.name used as fallback for named functions)
+ * const [SaveCmd, SaveExec] = CommandExecutor<{ purchase: Purchase }>(
+ *   async function SavePurchase(command, { emit }) => { ... }
+ * )
+ * ```
+ */
+declare function CommandExecutor<TInput, TDeps = Record<string, never>, TState = unknown>(nameOrFn: string | ExecutorFn<TInput, TDeps, TState>, maybeFn?: ExecutorFn<TInput, TDeps, TState>): [Command<TInput>, Executor<TInput, TDeps, TState>];
+declare namespace CommandExecutor {
+    var passthrough: {
+        <TType extends string, TPayload>(eventCreator: EventCreator<TType, TPayload>): [Command<TPayload>, Executor<TPayload, Record<string, never>, unknown>];
+        <TType extends string, TPayload, TInput>(eventCreator: EventCreator<TType, TPayload>, transform: (input: TInput) => TPayload): [Command<TInput>, Executor<TInput, Record<string, never>, unknown>];
+        <TType extends string, TPayload>(name: string, eventCreator: EventCreator<TType, TPayload>): [Command<TPayload>, Executor<TPayload, Record<string, never>, unknown>];
+        <TType extends string, TPayload, TInput>(name: string, eventCreator: EventCreator<TType, TPayload>, transform: (input: TInput) => TPayload): [Command<TInput>, Executor<TInput, Record<string, never>, unknown>];
+    };
+}
+
+declare const INTENT_BRAND: unique symbol;
+declare const INTENTS_BRAND: unique symbol;
+declare const PREPARED_INTENT_BRAND: unique symbol;
+/** Execution mode for an intent */
+type IntentMode = 'sequential' | 'all' | 'allSettled';
+/** An intent descriptor: references commands and their execution mode */
+interface IntentDescriptor<TInput = unknown> {
+    readonly [INTENT_BRAND]: true;
+    readonly commands: ReadonlyArray<Command<TInput>>;
+    readonly mode: IntentMode;
+    readonly name?: string;
+    readonly __inputType?: TInput;
+}
+/** A callable intent descriptor. Calling with payload produces a PreparedIntent. */
+interface IntentAction<TInput = unknown> extends IntentDescriptor<TInput> {
+    (payload: TInput): PreparedIntent<TInput>;
+}
+/** An intent paired with its payload, ready to dispatch via store.send(). */
+interface PreparedIntent<TInput = unknown> {
+    readonly [PREPARED_INTENT_BRAND]: true;
+    readonly intent: IntentDescriptor<TInput>;
+    readonly payload: TInput;
+}
+/** An intents container: a namespaced group of intent descriptors */
+interface IntentsContainer {
+    readonly [INTENTS_BRAND]: true;
+    readonly __prefix: string;
+}
+/**
+ * Create a callable intent with sequential execution (default).
+ * If any executor throws, subsequent commands are skipped.
+ *
+ * @example
+ * ```ts
+ * const MyIntents = Intents('Purchase', {
+ *   submitClicked: Intent(ValidateCommand, SaveCommand),
+ *   pageOpened: Intent(LoadCommand),
+ * })
+ *
+ * // Call to create a PreparedIntent
+ * store.send(MyIntents.submitClicked({ formData }))
+ *
+ * // Or use shorthand
+ * store.send.submitClicked({ formData })
+ * ```
+ */
+declare function Intent<TInput>(...commands: Command<TInput>[]): IntentAction<TInput>;
+declare namespace Intent {
+    var all: <TInput>(...commands: Command<TInput>[]) => IntentAction<TInput>;
+    var allSettled: <TInput>(...commands: Command<TInput>[]) => IntentAction<TInput>;
+}
+/**
+ * Create a namespaced group of intents.
+ *
+ * @example
+ * ```ts
+ * const PurchaseIntents = Intents('Purchase', {
+ *   submitClicked: Intent(ValidateCommand, SaveCommand),
+ *   pageOpened: Intent(LoadCommand),
+ * })
+ * ```
+ */
+declare function Intents<TPrefix extends string, TDefs extends Record<string, IntentDescriptor>>(prefix: TPrefix, intents: TDefs): TDefs & IntentsContainer;
+/** Check if a value is a PreparedIntent (intent + payload pair) */
+declare function isPreparedIntent(value: unknown): value is PreparedIntent;
+
+declare const NESTED_BRAND: unique symbol;
+type NestedKind = 'single' | 'array' | 'map';
+interface NestedMarker<TStore = unknown, TKind extends NestedKind = NestedKind> {
+    readonly [NESTED_BRAND]: true;
+    readonly kind: TKind;
+    readonly store: TStore;
+}
+/**
+ * Declare a single nested child store.
+ *
+ * @example
+ * ```ts
+ * Store({ state: { transaction: Nested(TransactionStore) } })
+ * ```
+ */
+declare function Nested<TStore>(store: TStore): NestedMarker<TStore, 'single'>;
+declare namespace Nested {
+    var array: <TStore>(store: TStore) => NestedMarker<TStore, "array">;
+    var map: <TStore>(store: TStore) => NestedMarker<TStore, "map">;
+}
+
+/**
+ * Middleware interface for observing store lifecycle events.
+ * Middlewares are pure observers — they must NOT modify state or emit events.
+ *
+ * @example
+ * ```ts
+ * const myMiddleware: Middleware = {
+ *   name: 'my-middleware',
+ *   onEvent: (event, state) => console.log(event.type, state),
+ *   onError: (error) => reportError(error),
+ * }
+ * ```
+ */
+type Middleware = {
+    /** Unique name for this middleware instance */
+    name: string;
+    /** Called when the middleware is attached to a store instance (during Store.create or singleton init). */
+    onAttach?: (store: {
+        getState: () => Record<string, unknown>;
+        meta?: {
+            computedKeys?: readonly string[];
+            nestedKeys?: readonly {
+                key: string;
+                kind: 'single' | 'array' | 'map';
+            }[];
+        };
+    }) => void;
+    /** Called when an event is applied to the store */
+    onEvent?: (event: EventInstance, state: Record<string, unknown>) => void;
+    /** Called after state changes, with previous and next state */
+    onStateChange?: (prev: Record<string, unknown>, next: Record<string, unknown>) => void;
+    /** Called when an intent starts execution */
+    onIntentStart?: (intent: IntentDescriptor, payload: unknown) => void;
+    /** Called when an intent finishes execution */
+    onIntentEnd?: (intent: IntentDescriptor, payload: unknown) => void;
+    /** Called when an executor throws an error */
+    onError?: (error: Error, context: {
+        intent: IntentDescriptor;
+        payload?: unknown;
+        command?: Command;
+    }) => void;
+};
+/**
+ * Factory for creating typed middleware instances.
+ * The `.create()` method is called by the store builder to produce
+ * a concrete Middleware. This pattern avoids the need for generic
+ * type parameters at middleware definition time.
+ *
+ * @example
+ * ```ts
+ * function myMiddleware(options?: MyOptions): MiddlewareFactory {
+ *   return {
+ *     name: 'my-middleware',
+ *     create() {
+ *       return {
+ *         name: 'my-middleware',
+ *         onEvent: (event, state) => console.log(event.type, state),
+ *       }
+ *     },
+ *   }
+ * }
+ * ```
+ */
+interface MiddlewareFactory {
+    create(): Middleware;
+    readonly name: string;
+}
+
+/** A memoized derived state accessor with structural equality. */
+interface Selector<T> {
+    /** Get the current derived value (memoized). */
+    get(): T;
+    /** Subscribe to changes. Only fires when derived value actually changes. Returns unsubscribe. */
+    subscribe(cb: (value: T) => void): () => void;
+    /** @internal brand for type discrimination */
+    readonly __selectorBrand: true;
+}
+/** Type guard for Selector objects. */
+declare function isSelector(value: unknown): value is Selector<unknown>;
+
+declare const STORE_DEF_BRAND: unique symbol;
+/** Resolve nested markers in raw state to their runtime types (includes child computed) */
+type ResolvedState<T> = {
+    [K in keyof T]: T[K] extends NestedMarker<infer S, 'single'> ? ResolvedStateOf<S> : T[K] extends NestedMarker<infer S, 'array'> ? ResolvedStateOf<S>[] : T[K] extends NestedMarker<infer S, 'map'> ? Record<string, ResolvedStateOf<S>> : T[K];
+};
+/** Extract resolved state (raw + computed) from a store definition */
+type ResolvedStateOf<S> = S extends StoreDefinition<any, infer R, infer C> ? C extends Record<string, never> ? ResolvedState<R> : ResolvedState<R> & C : never;
+/** Resolve nested markers to raw state only (no child computed). Used for on() handlers. */
+type ReducerState<T> = {
+    [K in keyof T]: T[K] extends NestedMarker<infer S, 'single'> ? ReducerStateOf<S> : T[K] extends NestedMarker<infer S, 'array'> ? ReducerStateOf<S>[] : T[K] extends NestedMarker<infer S, 'map'> ? Record<string, ReducerStateOf<S>> : T[K];
+};
+/** Extract raw state (without computed) from a store definition */
+type ReducerStateOf<S> = S extends StoreDefinition<any, infer R, any> ? ReducerState<R> : never;
+/** Extract typed scope from raw state: maps nested keys to their store instance types */
+type ScopeOf<T> = {
+    [K in keyof T as T[K] extends NestedMarker ? K : never]: T[K] extends NestedMarker<infer S, 'single'> ? StoreInstanceOf<S> : T[K] extends NestedMarker<infer S, 'array'> ? NestedArrayScope<StoreInstanceOf<S>> : T[K] extends NestedMarker<infer S, 'map'> ? Map<string, StoreInstanceOf<S>> : never;
+};
+/** Scope type for Nested.array — supports ID-based O(1) lookup */
+interface NestedArrayScope<T extends StoreInstance = StoreInstance> {
+    /** O(1) lookup by the child's state.id */
+    get(id: string): T | undefined;
+    /** Returns all child instances as an array */
+    values(): T[];
+    /** Number of child instances */
+    readonly size: number;
+    [Symbol.iterator](): Iterator<T>;
+}
+/** Extract store instance type from a store definition */
+type StoreInstanceOf<S> = S extends StoreDefinition<infer D, infer R, infer C, infer I> ? StoreInstance<D, R, C, I> : never;
+/** Extract intent key → input type mapping from an IntentsContainer */
+type IntentMap<T> = {
+    [K in keyof T as T[K] extends IntentDescriptor ? K : never]: T[K] extends IntentDescriptor<infer TInput> ? TInput : never;
+};
+/** The send function type: callable (2 overloads) + named intent shorthand properties */
+type SendFn<TIntents extends Record<string, unknown> = Record<string, never>> = {
+    /** Send a PreparedIntent (from calling an IntentAction) */
+    <TInput>(prepared: PreparedIntent<TInput>): IntentRef;
+    /** Send an IntentDescriptor with explicit payload (legacy) */
+    <TInput>(intent: IntentDescriptor<TInput>, payload: TInput): IntentRef;
+} & {
+    /** Named intent shortcuts: store.send.intentName(payload) */
+    readonly [K in keyof TIntents]: (payload: TIntents[K]) => IntentRef;
+};
+/** Extract child store deps type from a nested marker */
+type ChildDepsOf<T> = T extends NestedMarker<infer S, NestedKind> ? S extends StoreDefinition<infer D, any, any> ? D : Record<string, never> : Record<string, never>;
+/** Handler map for namespace-style .on() */
+type EventHandlerMap<TNamespace, TState> = {
+    [K in keyof TNamespace]?: TNamespace[K] extends EventCreator<string, infer P> ? (state: TState, payload: P) => TState : never;
+};
+/** Handler map for namespace-style .on() — state input includes computed, return is raw only */
+type ReducerEventHandlerMap<TNamespace, TStateIn, TStateOut> = {
+    [K in keyof TNamespace]?: TNamespace[K] extends EventCreator<string, infer P> ? (state: TStateIn, payload: P) => TStateOut : never;
+};
+/** Opaque reference returned by `store.send()` for cancellation via `store.cancel(ref)`. */
+interface IntentRef {
+    readonly __intentRefBrand: symbol;
+}
+interface NestedMeta {
+    source: {
+        instanceId: string;
+        index: number;
+        parentKey: string;
+    };
+}
+type InternalOnHandler = (state: Record<string, unknown>, payload: Record<string, unknown>, meta?: NestedMeta) => Record<string, unknown>;
+type InternalOnHandlerMap = Record<string, InternalOnHandler>;
+type InternalRelayHandler = (event: EventInstance, state: Record<string, unknown>) => EventInstance[];
+type InternalRelayMap = Record<string, InternalRelayHandler>;
+/** Internal configuration accumulated by StoreBuilder. */
+interface StoreConfig<TDeps = unknown, TState = unknown, TComputed = unknown> {
+    intents?: IntentsContainer;
+    executors?: Executor[];
+    state: TState;
+    computed?: Record<string, (state: Record<string, unknown>) => unknown>;
+    on?: InternalOnHandlerMap;
+    relay?: InternalRelayMap;
+    middleware?: Middleware[];
+    childDepsMap?: Record<string, (parentDeps: Record<string, unknown>) => Record<string, unknown>>;
+    /** @internal phantom type for computed inference */
+    readonly __computedPhantom?: TComputed;
+    /** @internal phantom type for deps inference */
+    readonly __depsPhantom?: TDeps;
+}
+/** Options for `StoreDefinition.create()`. Supports initial state override and deps injection. */
+interface StoreCreateOptions<TRawState = unknown, TDeps = unknown> {
+    initialState?: Partial<ResolvedState<TRawState>>;
+    deps?: Partial<TDeps>;
+}
+/** A store definition (blueprint). Call `.create()` to instantiate. */
+interface StoreDefinition<TDeps = unknown, TRawState = unknown, TComputed = unknown, TIntents extends Record<string, unknown> = Record<string, never>> {
+    readonly [STORE_DEF_BRAND]: true;
+    readonly __config: StoreConfig<TDeps, TRawState, TComputed>;
+    readonly __stateType?: ResolvedState<TRawState> & TComputed;
+    readonly __rawStateType?: TRawState;
+    readonly __depsType?: TDeps;
+    readonly __intentsType?: TIntents;
+    create(options?: StoreCreateOptions<TRawState, TDeps>): StoreInstance<TDeps, TRawState, TComputed, TIntents>;
+}
+/** A live store instance. Created by `StoreDefinition.create()`. */
+interface StoreInstance<TDeps = unknown, TRawState = unknown, TComputed = unknown, TIntents extends Record<string, unknown> = Record<string, never>> {
+    /** Dispatch intents. Callable with PreparedIntent or (descriptor, payload). Also supports store.send.intentName(payload) shorthand. */
+    send: SendFn<TIntents>;
+    /** Cancel a specific running intent by its ref. */
+    cancel(ref: IntentRef): void;
+    /** Cancel all running intents. */
+    cancelAll(): void;
+    /** Get the current combined state (raw + computed). */
+    getState(): ResolvedState<TRawState> & TComputed;
+    /** Subscribe to state changes. Returns an unsubscribe function. */
+    subscribe(cb: (state: ResolvedState<TRawState> & TComputed) => void): () => void;
+    /** Subscribe to raw event emissions. Returns an unsubscribe function. */
+    subscribe(type: 'events', cb: (event: EventInstance) => void): () => void;
+    /** Dispose the store, cancelling all intents and clearing listeners. */
+    dispose(): void;
+    /** Create a memoized derived state selector. */
+    selector<T>(fn: (state: ResolvedState<TRawState> & TComputed) => T): Selector<T>;
+    /** Nested store scope for accessing child store instances. */
+    readonly scope: ScopeOf<TRawState>;
+    /** @internal phantom type for deps inference */
+    readonly __depsPhantom?: TDeps;
+}
+interface StoreInternalFields {
+    __eventLog: EventInstance[];
+    __stateSnapshots: Array<{
+        event: EventInstance;
+        state: Record<string, unknown>;
+    }>;
+    __runningCount: () => number;
+    __rawState: () => Record<string, unknown>;
+    /** Apply event to this store (for event forwarding from parent to children). */
+    __applyEvent: (event: EventInstance, options?: {
+        skipEventLog?: boolean;
+    }) => void;
+    /** Execute a single command (for parent → child delegation). */
+    __executeCommand: (command: Command, payload: unknown, signal: AbortSignal) => Promise<void>;
+    /** Returns the nestedExecutorIndex for recursive delegation (root → child → grandchild). */
+    __getHandleableCommands: () => Map<symbol, StoreInstance & StoreInternalFields>;
+}
+/** @deprecated Use StoreInstance & StoreInternalFields instead */
+type StoreInstanceInternal = StoreInstance & StoreInternalFields;
+/** The return type of Store() — a builder that is also a StoreDefinition. */
+type StoreBuilder<TDeps extends Record<string, unknown>, TRawState extends Record<string, unknown>, TComputed extends Record<string, unknown>, TIntents extends Record<string, unknown> = Record<string, never>> = {
+    /** Per-event handler: full payload type inference from EventCreator */
+    on<TType extends string, TPayload>(event: EventCreator<TType, TPayload>, handler: (state: ResolvedState<TRawState>, payload: TPayload) => ReducerState<TRawState>): StoreBuilder<TDeps, TRawState, TComputed, TIntents>;
+    /** Namespace handler: grouped handlers with per-key payload type inference */
+    on<TNamespace extends object>(events: TNamespace, handlers: ReducerEventHandlerMap<TNamespace, ResolvedState<TRawState>, ReducerState<TRawState>>): StoreBuilder<TDeps, TRawState, TComputed, TIntents>;
+    computed<C extends Record<string, (state: ResolvedState<TRawState>) => unknown>>(def: C): StoreBuilder<TDeps, TRawState, {
+        [K in keyof C]: ReturnType<C[K]>;
+    }, TIntents>;
+    intents<TContainer extends IntentsContainer>(container: TContainer): StoreBuilder<TDeps, TRawState, TComputed, TIntents & IntentMap<TContainer>>;
+    executors(...execs: Executor[]): StoreBuilder<TDeps, TRawState, TComputed, TIntents>;
+    deps<D extends Record<string, unknown>>(): StoreBuilder<D, TRawState, TComputed, TIntents>;
+    childDeps<K extends keyof TRawState & string>(key: K, mapper: (deps: TDeps) => ChildDepsOf<TRawState[K]>): StoreBuilder<TDeps, TRawState, TComputed, TIntents>;
+    /** Per-event relay: transform one event type into other events */
+    relay<TType extends string, TPayload>(event: EventCreator<TType, TPayload>, handler: (event: EventInstance<TType, TPayload>, state: ResolvedState<TRawState>) => EventInstance[]): StoreBuilder<TDeps, TRawState, TComputed, TIntents>;
+    middleware(...mws: (Middleware | MiddlewareFactory)[]): StoreBuilder<TDeps, TRawState, TComputed, TIntents>;
+    create(options?: StoreCreateOptions<TRawState, TDeps>): StoreInstance<TDeps, TRawState, TComputed, TIntents>;
+} & StoreDefinition<TDeps, TRawState, TComputed, TIntents>;
+/**
+ * Create a store builder from an initial state.
+ * Returns a chainable builder with `.on()`, `.computed()`, `.intents()`,
+ * `.executors()`, `.deps()`, `.childDeps()`, `.relay()`, `.middleware()`, and `.create()`.
+ *
+ * The builder is also a `StoreDefinition` — you can call `.create()` directly
+ * or pass it to testing APIs like `TestStore()`, `TestReducer()`, etc.
+ *
+ * @example
+ * ```ts
+ * const CounterStore = Store({ state: { count: 0, multiplier: 2 } })
+ *   .on(CounterEvent.incremented, (state, { amount }) => ({
+ *     ...state, count: state.count + amount,
+ *   }))
+ *   .computed({
+ *     doubled: (state) => state.count * 2,
+ *     product: (state) => state.count * state.multiplier,
+ *   })
+ *   .intents(CounterIntents)
+ *   .executors(IncrementExecutor, DecrementExecutor)
+ *   .middleware(logger())
+ *
+ * const store = CounterStore.create()
+ * store.send(CounterIntents.increment, {})
+ * ```
+ */
+declare function Store<TState extends Record<string, unknown>>(config: {
+    state: TState;
+}): StoreBuilder<Record<string, never>, TState, Record<string, never>>;
+declare function isStoreDefinition(value: unknown): value is StoreDefinition;
+declare function isStoreInstance(value: unknown): value is StoreInstance;
+
+export { type StoreCreateOptions as A, type StoreInstanceInternal as B, type ChildDepsOf as C, type StoreInternalFields as D, type EventInstance as E, isPreparedIntent as F, isSelector as G, isStoreDefinition as H, Intent as I, isStoreInstance as J, type Middleware as M, Nested as N, type PreparedIntent as P, type ResolvedState as R, type StoreDefinition as S, type StoreInstance as a, type Command as b, CommandExecutor as c, Event as d, type EventCreator as e, type EventDefinition as f, type EventHandlerMap as g, Events as h, type Executor as i, type ExecutorContext as j, type IntentAction as k, type IntentDescriptor as l, type IntentMap as m, type IntentMode as n, type IntentRef as o, Intents as p, type MiddlewareFactory as q, type NestedArrayScope as r, type NestedKind as s, type NestedMarker as t, type ResolvedStateOf as u, type ScopeOf as v, type Selector as w, type SendFn as x, Store as y, type StoreBuilder as z };