small-state 0.0.0-stage → 0.2.0

package/dist/index.d.mts

@@ -0,0 +1,389 @@
+//#region src/shared/general.types.d.ts
+type Expand<T> = { [K in keyof T]: T[K]; } & {};
+type LowInfer<T> = T & NonNullable<unknown>;
+type Values<T> = T[keyof T];
+type Merge<A, B> = Omit<A, keyof B> & B;
+type IsAny<T> = 0 extends (1 & T) ? true : false;
+type IsUnknown<T> = IsAny<T> extends true ? false : unknown extends T ? true : false;
+type IsEqual<X, Y> = (<T>() => T extends X ? 1 : 2) extends (<T>() => T extends Y ? 1 : 2) ? ((<T>() => T extends Y ? 1 : 2) extends (<T>() => T extends X ? 1 : 2) ? true : false) : false;
+type EmptyRecord = Record<PropertyKey, never>;
+type AnyFn<R = unknown> = (...arg: any[]) => R;
+type OneOrMany<T> = T | T[];
+type Placeholder = {} | null | undefined;
+//#endregion
+//#region src/machine/m.types.d.ts
+declare const EntrySymbol: unique symbol;
+declare const ExitSymbol: unique symbol;
+declare const SubStatesSymbol: unique symbol;
+declare const ParallelSymbol: unique symbol;
+declare const InvokeSymbol: unique symbol;
+type ChildDoneEBody = {
+  type: ':childDone:';
+  output: unknown;
+};
+type BuiltinEType = ':always:' | ChildDoneEBody['type'];
+type BuiltinSendableEvent = {
+  type: BuiltinEType;
+  [key: string]: any;
+};
+type DoneEBody<O> = {
+  type: ':done:';
+  output: O;
+};
+type ErrorEBody = {
+  type: ':error:';
+  error: unknown;
+};
+declare const SystemEventSymbol: unique symbol;
+type SystemSendableEvent = {
+  type: `invoke/${string}[${number}]`;
+  [SystemEventSymbol]: true;
+  payload: {
+    type: string;
+    [key: string]: any;
+  };
+} | {
+  type: `system/${string}`;
+};
+type InternalEType = BuiltinEType | SystemSendableEvent['type'];
+type InternalEPayload = {
+  path: string;
+} | EmptyRecord;
+type MContext = Record<string, any>;
+type SendableEvent = {
+  type: string;
+  [key: string]: any;
+};
+type EmittableEvent = {
+  type: string;
+  [key: string]: any;
+};
+type StateName = string;
+type PureETypeString<E extends SendableEvent> = E extends unknown ? Exclude<keyof E, "type"> extends never ? E['type'] : never : any;
+type FnBaseParams<C extends MContext, Ex extends SendableEvent, I, Additional = unknown, Prm = any> = [arg: Expand<{
+  c: C;
+  context: C;
+  e: Ex;
+  event: Ex;
+  input: I;
+} & Additional>, params: Prm];
+type ActionFnParams<C extends MContext, Ex extends SendableEvent, I, EM extends EmittableEvent, G extends Record<string, Placeholder>, A extends Record<string, Placeholder>, S extends ServiceRecord> = FnBaseParams<C, Ex, I, {
+  check: CheckFn<C, Ex, I, G>;
+  enqueue: EnqueueFn<C, Ex, I, EM, A>;
+  update: UpdateFn<C>;
+  emit: EmitFn<EM>;
+  sendTo: SendToFn<S>;
+}>;
+type LimitedActionFnParams<C extends MContext, E extends SendableEvent, I, EM extends EmittableEvent, Prm = any> = FnBaseParams<C, E, I, {
+  update: UpdateFn<C>;
+  emit: EmitFn<EM>;
+}, Prm>;
+/**
+ * check(type: {[guardName: keyof G]: ParamsOfGuard}): boolean
+ * check(type: keyof G, params?: ParamsOfGuard): boolean
+ */
+type CheckFn<C extends MContext, Ex extends SendableEvent, I, G extends Record<string, Placeholder>> = {
+  (type: Values<{ [K in keyof G & string as unknown extends G[K] ? never : K]: { [K3 in K]: ParamsInput<G[K], C, Ex, I>; }; }>): boolean;
+  <Gk extends keyof G & string | never>(type: Gk, ...args: ParamsInputArgsOf<G, Gk, C, Ex, I>): boolean;
+};
+/**
+ * enqueue(type: {[actionName: keyof A]: ParamsOfTheAction}): void
+ * enqueue(type: keyof A, params?: ParamsOfTheAction): void
+ * enqueue(fn: (arg: FnBaseParams & {update: UpdateFn, emit: EmitFn}) => void): void
+ */
+type EnqueueFn<C extends MContext, Ex extends SendableEvent, I, EM extends EmittableEvent, A extends Record<string, Placeholder>> = {
+  (type: Values<{ [K in keyof A & string as unknown extends A[K] ? never : K]: { [K2 in K]: ParamsInput<A[K], C, Ex, I>; }; }>): void;
+  <Ak extends keyof A & string | never>(type: Ak, ...args: ParamsInputArgsOf<A, Ak, C, Ex, I>): void;
+  (fn: (arg: LimitedActionFnParams<C, Ex, I, EM>[0]) => void): void;
+};
+type UpdateFnParam<C extends MContext> = { [K in keyof C]?: C[K] | (() => (C[K])); };
+type UpdateFn<C extends MContext> = (updates: UpdateFnParam<C>) => unknown;
+type O_InferSendableEvent<S extends ServiceRecord[string]> = S extends Machine<any, infer E, any, any, any, any, any, any, any> ? E : S extends AnyFn ? (Parameters<S>[2] extends ListenFn<infer Er> ? Er : never) : never;
+type SendToFn<S extends ServiceRecord> = {
+  <Sk extends keyof S>(serviceName: Sk, subKey: string | number, event: O_InferSendableEvent<S[Sk]>): void;
+  <Sk extends keyof S>(serviceName: Sk, event: O_InferSendableEvent<S[Sk]>): void;
+};
+type EmitFn<EM extends EmittableEvent> = (event: EM) => void;
+type ListenFn<E extends SendableEvent> = (listener: (event: E) => void) => void;
+type X_NormalizedGuard<C extends MContext = any, Ex extends SendableEvent = any, I = any> = ((arg: FnBaseParams<C, Ex, I>[0]) => boolean) | string | Record<string, ParamsInput<unknown, C, Ex, I>>;
+type NormalizedAction<C extends MContext = any, Ex extends SendableEvent = any, I = any, EM extends EmittableEvent = any, G extends Record<string, Placeholder> = any, A extends Record<string, Placeholder> = any, S extends ServiceRecord = ServiceRecord> = ((arg: ActionFnParams<C, Ex, I, EM, G, A, S>[0]) => unknown) | string | Record<string, ParamsInput<unknown, C, Ex, I>>;
+type NormalizedTransition = {
+  to?: StateName;
+  fullTo?: string;
+  guards: X_NormalizedGuard[];
+  actions: NormalizedAction[];
+};
+type NormalizedSrc = {
+  type: 'function';
+  value: ServiceFn;
+} | {
+  type: 'string';
+  value: string;
+} | {
+  type: 'machine';
+  value: AnyMachine;
+};
+type NormalizedInvocation = {
+  mainKey: string;
+  subKey?: string | number;
+  input?: AnyFn;
+  emittableETypesToListen: string[];
+  src: NormalizedSrc;
+};
+type InternalEvent = {
+  cond?: (payload: InternalEPayload) => boolean;
+  transitions: NormalizedTransition[];
+};
+type NStateItemDef<Et extends string> = {
+  pPath: string;
+  final: boolean | AnyFn;
+  entryHooks: NormalizedAction[] | null;
+  exitHooks: NormalizedAction[] | null;
+  invocations: Array<NormalizedInvocation>;
+  internalEvents: { [K in InternalEType]?: InternalEvent; };
+  events: { [K in Et]?: NormalizedTransition[]; };
+};
+type NormalizedStateItem = {
+  def: NStateItemDef<string>;
+  sub: null | NormalizedDefinition | ParallelNormalizedDefinition;
+};
+type ParallelNormalizedStateItem = {
+  def: NStateItemDef<string>;
+  sub: NormalizedDefinition;
+};
+type NormalizedStateItemBoth = NormalizedStateItem | ParallelNormalizedStateItem;
+type NormalizedDefinition = {
+  dType?: 'normal';
+  initial: string | undefined;
+  stateOf: Record<string, NormalizedStateItem>;
+};
+type ParallelNormalizedDefinition = {
+  dType: 'regions';
+  stateOf: Record<string, ParallelNormalizedStateItem>;
+};
+type ParamsInput<Prm, C extends MContext, Ex extends SendableEvent, I> = Prm | ((arg: FnBaseParams<C, Ex, I>[0]) => Prm);
+type ParamsInputArgsOf<IR extends Record<string, Placeholder>, IRk extends keyof IR, C extends MContext, Ex extends SendableEvent, I> = unknown extends IR[IRk] ? [] : [params: ParamsInput<IR[IRk], C, Ex, I>];
+type ServiceFn<TInput = any> = (input: TInput, emit: EmitFn<EmittableEvent>, listen: ListenFn<any>, signal: AbortSignal) => unknown;
+type ServiceRecord = Record<string, ServiceFn | AnyMachine>;
+type MachineConfig<C extends MContext, E extends SendableEvent, I, EM extends EmittableEvent, O, G extends Record<string, Placeholder>, A extends Record<string, Placeholder>, S extends ServiceRecord> = {
+  types?: {
+    context?: C;
+    events?: E;
+    emittable?: EM;
+    input?: I;
+    output?: O;
+  };
+  name?: string;
+  initialState?: StateName;
+  initContext?: (input: I) => LowInfer<C>;
+  output?: (arg: FnBaseParams<C, DoneEBody<unknown>, I>[0]) => O;
+  guards?: { [K in keyof G]: (arg: FnBaseParams<C, E, I>[0], params: G[K]) => boolean; };
+  actions?: { [K in keyof A & string]: (arg: LimitedActionFnParams<C, E, I, EM>[0], params: A[K]) => unknown; };
+  services?: S;
+};
+type TopLvStDefItem<Et extends string> = {
+  events: { [K in Et]?: NormalizedTransition[]; };
+  internalEvents: { [K in InternalEType]?: InternalEvent; };
+};
+type AnyMachine = Machine<any, any, any, any, any, any, any, any, any>;
+declare const MachineSymbol: unique symbol;
+type Machine<C extends MContext, E extends SendableEvent, I, EM extends EmittableEvent, O, G extends Record<string, Placeholder>, A extends Record<string, Placeholder>, S extends ServiceRecord, ND extends NormalizedDefinition> = {
+  name: string;
+  internal: {
+    [MachineSymbol]: true;
+    initContext: undefined | ((input: I) => C);
+    output: undefined | ((arg: FnBaseParams<C, DoneEBody<unknown>, I, unknown>[0]) => O);
+    guards: { [K in keyof G]: (arg: FnBaseParams<C, E | BuiltinSendableEvent, I>[0], params: G[K]) => boolean; };
+    actions: { [K in keyof A]: (arg: LimitedActionFnParams<C, E | BuiltinSendableEvent, I, EM>[0], params: A[K]) => unknown; };
+    services: S;
+    definition: ND;
+    topLvDefItem: TopLvStDefItem<E['type']>;
+    stateCatalog: Map<string, NormalizedStateItemBoth>;
+  };
+  provide: <const nS extends ServiceRecord, const nG extends Record<string, Placeholder> = Record<string, Placeholder>, const nA extends Record<string, Placeholder> = Record<string, Placeholder>>(implementations: {
+    guards?: { [K in keyof nG]: (arg: FnBaseParams<C, E | BuiltinSendableEvent, I>[0], params: nG[K]) => boolean; };
+    actions?: { [K in keyof nA]: (arg: LimitedActionFnParams<C, E | BuiltinSendableEvent, I, EM>[0], params: nA[K]) => unknown; };
+    services?: nS;
+  }) => Readonly<Machine<C, E, I, EM, O, Merge<G, nG>, Merge<A, nA>, Merge<S, nS>, ND>>;
+};
+//#endregion
+//#region src/machine/machine.d.ts
+type X_HiddenImpl = any & {
+  __brand: 'HiddenImpl';
+};
+type X_DefTypeRefluxer<C extends MContext, E extends SendableEvent, I // Input
+, EM extends EmittableEvent, G extends Record<string, Placeholder>, A extends Record<string, Placeholder>, S extends ServiceRecord = ServiceRecord, Eb extends BuiltinEType = BuiltinEType, R = unknown> = () => R;
+type X_DefineStatesTools = {
+  on: typeof on;
+  entryHook: typeof entryHook;
+  exitHook: typeof exitHook;
+  subStates: typeof subStates;
+  parallel: typeof parallel;
+  invoke: typeof invoke;
+};
+type X_ExtractEType<TStateDefinition> = TStateDefinition extends Array<infer El> ? El extends readonly [infer Et, AnyFn, any] ? Exclude<Et, BuiltinEType> : never : never;
+type X_ExtractSubStDefinition<TStateDefinition> = TStateDefinition extends Array<infer El> ? [El] extends [never] ? null : El extends readonly [AnyFn<typeof SubStatesSymbol | typeof ParallelSymbol>, infer Sub] ? [Sub] extends [never] ? null : Sub extends NormalizedDefinition | ParallelNormalizedDefinition ? Sub : null : null : null;
+type X_ImplKeys<IpR extends Record<string, Placeholder>> = Values<{ [K in keyof IpR]: unknown extends IpR[K] ? K : never; }>;
+type Guard<C extends MContext, Ex extends SendableEvent, I, G extends Record<string, Placeholder>> = Expand<X_ImplKeys<G>> | Values<{ [K in keyof G & string as unknown extends G[K] ? never : K]: { [K2 in K]: ParamsInput<G[K], C, Ex, I>; }; }> | ((arg: FnBaseParams<C, Ex, I>[0]) => boolean);
+type Action<C extends MContext, Ex extends SendableEvent, I, EM extends EmittableEvent, G extends Record<string, Placeholder>, A extends Record<string, Placeholder>, S extends ServiceRecord> = Expand<X_ImplKeys<A>> | Values<{ [K in keyof A & string as unknown extends A[K] ? never : K]: { [K2 in K]: ParamsInput<A[K], C, Ex, I>; }; }> | ((arg: ActionFnParams<C, Ex, I, EM, G, A, S>[0]) => unknown);
+type StDefMetaInfo<C extends MContext, E extends SendableEvent, I> = {
+  final?: boolean | ((args: FnBaseParams<C, E, I>[0]) => unknown);
+};
+type StDefCoreItem<C extends MContext, E extends SendableEvent, I, EM extends EmittableEvent, G extends Record<string, Placeholder>, A extends Record<string, Placeholder>, S extends ServiceRecord> = StDefMetaInfo<C, E, I> | readonly [E['type'] | BuiltinEType, X_DefTypeRefluxer<C, E, I, EM, G, A, S>, X_HiddenImpl] | readonly [typeof EntrySymbol, X_DefTypeRefluxer<C, E, I, EM, G, A, S>, null, X_HiddenImpl] | readonly [typeof ExitSymbol, X_DefTypeRefluxer<C, E, I, EM, G, A, S>, null, X_HiddenImpl];
+type StateDefinition<C extends MContext, E extends SendableEvent, I, EM extends EmittableEvent, G extends Record<string, Placeholder>, A extends Record<string, Placeholder>, S extends ServiceRecord> = null | Array<StDefCoreItem<C, E, I, EM, G, A, S> | readonly [X_DefTypeRefluxer<C, E, I, EM, G, A, S, BuiltinEType, any>, unknown] | readonly [typeof InvokeSymbol, X_DefTypeRefluxer<C, E, I, EM, G, A, S, never>, null, unknown, any, any]>;
+declare function entryHook<C extends MContext, E extends SendableEvent, I, EM extends EmittableEvent, const G extends Record<string, Placeholder>, const A extends Record<string, Placeholder>, S extends ServiceRecord>(...actions: Array<Action<C, E, I, EM, G, A, S>>): readonly [typeof EntrySymbol, X_DefTypeRefluxer<C, E, I, EM, G, A, S, BuiltinEType, unknown>, null, Action<C, E, I, EM, G, A, S>[]];
+declare function exitHook<C extends MContext, E extends SendableEvent, I, EM extends EmittableEvent, const G extends Record<string, Placeholder>, const A extends Record<string, Placeholder>, S extends ServiceRecord>(...actions: Array<Action<C, E, I, EM, G, A, S>>): readonly [typeof ExitSymbol, X_DefTypeRefluxer<C, E, I, EM, G, A, S, BuiltinEType, unknown>, null, Action<C, E, I, EM, G, A, S>[]];
+type O_ExtractEvent<E extends SendableEvent, Et extends E['type']> = Et extends ChildDoneEBody['type'] ? Expand<ChildDoneEBody> : Et extends BuiltinEType ? E : E extends {
+  type: Et;
+} ? E : Et extends E['type'] ? E : never;
+type O_Transition<C extends MContext, Ex extends SendableEvent, I, EM extends EmittableEvent, G extends Record<string, Placeholder>, A extends Record<string, Placeholder>, S extends ServiceRecord> = {
+  to?: StateName;
+  guard?: OneOrMany<Guard<C, Ex, I, G>>;
+  actions?: OneOrMany<Action<C, Ex, I, EM, G, A, S>>;
+};
+declare function on<C extends MContext, E extends SendableEvent, I, EM extends EmittableEvent, const G extends Record<string, Placeholder>, const A extends Record<string, Placeholder>, S extends ServiceRecord, Et extends [E] extends [never] ? string : E['type'] | Eb | never, Eb extends BuiltinEType = BuiltinEType>(eventType: Et, config: OneOrMany<Expand<O_Transition<C, O_ExtractEvent<E, Et>, I, EM, G, A, S>>>): readonly [Et, X_DefTypeRefluxer<C, E, I, EM, G, A, S, Eb, unknown>, any];
+declare function subStates<C extends MContext, E extends SendableEvent, I, EM extends EmittableEvent, const G extends Record<string, Placeholder>, const A extends Record<string, Placeholder>, S extends ServiceRecord, const D extends { [K in string]: StateDefinition<C, E, I, EM, G, A, S>; }, const Initial extends keyof D & string>(statesDefinition: D, initialState?: Initial): readonly [X_DefTypeRefluxer<C, E, I, EM, G, A, S, BuiltinEType, typeof SubStatesSymbol>, {
+  initial: [Initial] extends [never] ? undefined : Initial;
+  stateOf: { [K in keyof D]: {
+    def: NStateItemDef<X_ExtractEType<D[K]>>;
+    sub: X_ExtractSubStDefinition<D[K]>;
+  }; };
+}];
+type O_ExtractRegionEType<De> = De extends [infer U, Record<string, StateDefinition<any, any, any, any, any, any, any>>] ? U extends Array<infer El> ? El extends readonly [infer Et, AnyFn, any] ? Exclude<Et, BuiltinEType> : never : never : never;
+type O_InnerDict<T> = T extends [...any[], infer Last] ? Last : never;
+declare function parallel<C extends MContext, E extends SendableEvent, I, EM extends EmittableEvent, G extends Record<string, Placeholder>, A extends Record<string, Placeholder>, S extends ServiceRecord, const PD extends { [K in string]: [Array<StDefCoreItem<C, E, I, EM, G, A, S>>, { [L in string]: StateDefinition<C, E, I, EM, G, A, S>; }] | [{ [L in string]: StateDefinition<C, E, I, EM, G, A, S>; }?]; }>(parallelDefinition: PD): readonly [X_DefTypeRefluxer<C, E, I, EM, G, A, S, BuiltinEType, typeof ParallelSymbol>, {
+  dType: "regions";
+  stateOf: { [K in keyof PD]: {
+    def: NStateItemDef<O_ExtractRegionEType<PD[K]>>;
+    sub: {
+      initial: string | undefined;
+      stateOf: { [L in keyof O_InnerDict<PD[K]>]: {
+        def: NStateItemDef<X_ExtractEType<O_InnerDict<PD[K]>[L]>>;
+        sub: X_ExtractSubStDefinition<O_InnerDict<PD[K]>[L]>;
+      }; };
+    };
+  }; };
+}];
+type InvokeSrcExpr<TInput> = ServiceFn<TInput> | Machine<any, any, TInput, any, any, any, any, any, any>;
+type InvokeConfig<C extends MContext, E extends SendableEvent, I, S extends ServiceRecord, Src extends keyof S | InvokeSrcExpr<[SrcInput] extends [never] ? any : SrcInput>, SrcInput> = {
+  subKey?: string | number;
+  input?: (arg: FnBaseParams<C, E, I>[0]) => Src extends keyof S ? (S[Src] extends AnyFn ? Parameters<S[Src]>[0] : SrcInput) : SrcInput;
+};
+type InvocationEvents<C extends MContext, I, EM extends EmittableEvent, G extends Record<string, Placeholder>, A extends Record<string, Placeholder>, S extends ServiceRecord, TSrcTypes extends {
+  Type: 'm' | 'f';
+  EM: EmittableEvent;
+  O: unknown;
+}> = Array<readonly [string, NoInfer<X_DefTypeRefluxer<C, Expand<DoneEBody<TSrcTypes['O']>>, I, EM, G, A, S, never>>, X_HiddenImpl] | readonly [string, X_DefTypeRefluxer<C, ErrorEBody, I, EM, G, A, S, never>, X_HiddenImpl] | (TSrcTypes['Type'] extends 'm' ? IsAny<TSrcTypes['EM']> extends false ? IsEqual<TSrcTypes['EM'], EmittableEvent> extends false ? readonly [string, X_DefTypeRefluxer<C, TSrcTypes['EM'], I, EM, G, A, S, never>, X_HiddenImpl] : never : never : never) | (TSrcTypes['Type'] extends 'f' ? IsEqual<TSrcTypes['EM'], EmittableEvent> extends false ? readonly [string, X_DefTypeRefluxer<C, TSrcTypes['EM'], I, EM, G, A, S, never>, X_HiddenImpl] : never : never)>;
+type OO_ResolveSrc<Src, S extends ServiceRecord> = Src extends keyof S ? S[Src] : Src;
+type O_InferIvkSrcTypes<Src, S extends ServiceRecord> = OO_ResolveSrc<Src, S> extends (infer T) ? T extends Machine<any, any, any, infer EM, infer O, any, any, any, any> ? {
+  EM: EM;
+  O: O;
+  Type: 'm';
+} : T extends ServiceFn ? Parameters<T>[1] extends EmitFn<infer EM> ? IsUnknown<ReturnType<T>> extends false ? {
+  EM: NonNullable<EM>;
+  O: Awaited<ReturnType<T>>;
+  Type: 'f';
+} : never : {
+  EM: EmittableEvent;
+  O: Awaited<ReturnType<T>>;
+  Type: 'f';
+} : never : never;
+declare function invoke<C extends MContext, E extends SendableEvent, I, EM extends EmittableEvent, const G extends Record<string, Placeholder>, const A extends Record<string, Placeholder>, S extends ServiceRecord, Src extends keyof S | InvokeSrcExpr<[SrcInput] extends [never] ? any : SrcInput>, SrcInput = never>(service: Src, ...events: InvocationEvents<C, I, EM, G, A, S, O_InferIvkSrcTypes<Src, S>>): readonly [typeof InvokeSymbol, X_DefTypeRefluxer<C, E, I, EM, G, A, S, BuiltinEType, unknown>, null, X_HiddenImpl, X_HiddenImpl, InvocationEvents<C, I, EM, G, A, S, O_InferIvkSrcTypes<Src, S>>];
+declare function invoke<C extends MContext, E extends SendableEvent, I, EM extends EmittableEvent, const G extends Record<string, Placeholder>, const A extends Record<string, Placeholder>, S extends ServiceRecord, Src extends keyof S | InvokeSrcExpr<[SrcInput] extends [never] ? any : SrcInput>, SrcInput = never>(service: Src, config: InvokeConfig<C, E, I, S, Src, SrcInput>, ...events: InvocationEvents<C, I, EM, G, A, S, O_InferIvkSrcTypes<Src, S>>): readonly [typeof InvokeSymbol, X_DefTypeRefluxer<C, E, I, EM, G, A, S, BuiltinEType, unknown>, null, X_HiddenImpl, X_HiddenImpl, InvocationEvents<C, I, EM, G, A, S, O_InferIvkSrcTypes<Src, S>>];
+type X_GlobalEvents<C extends MContext, E extends SendableEvent, I, EM extends EmittableEvent, G extends Record<string, Placeholder>, A extends Record<string, Placeholder>> = Array<readonly [E['type'] | BuiltinEType, X_DefTypeRefluxer<C, E, I, EM, G, A>, X_HiddenImpl]>;
+export declare function defServiceFn<TFn extends ServiceFn>(fn: TFn): TFn;
+export declare function makeMachine<C extends MContext, const E extends SendableEvent, const I, const EM extends EmittableEvent, const O, const S extends ServiceRecord, const D extends { [K in string]: StateDefinition<C, E, I, EM, G, A, S>; }, const G extends Record<string, Placeholder> = Record<string, Placeholder>, const A extends Record<string, Placeholder> = Record<string, Placeholder>>(config: Expand<MachineConfig<C, E, I, EM, O, G, A, S>>, defineStates: (defineStatesTools: Expand<X_DefineStatesTools>) => readonly [X_GlobalEvents<C, E, I, EM, G, A>, D] | readonly [D] | D): Readonly<Machine<C, E, I, EM, O, G, A, S, {
+  initial: string;
+  stateOf: { [K in keyof D]: {
+    def: NStateItemDef<X_ExtractEType<D[K]>>;
+    sub: X_ExtractSubStDefinition<D[K]>;
+  }; };
+}>>;
+//#endregion
+//#region src/runtime/r.types.d.ts
+type Child<TService> = TService extends AnyMachine ? Runtime<TService> : TService extends AnyFn ? {
+  stop: () => void;
+  send: (event: SendableEvent) => void;
+} : never;
+type Children<S extends ServiceRecord> = { [K in keyof S & string as K | `${K}:${string | number}`]?: Child<S[K]>; } & {
+  [key: string]: Child<any>;
+};
+type InferredMachineTypes<M extends AnyMachine> = IsAny<M> extends true ? {
+  C: any;
+  E: any;
+  I: any;
+  EM: any;
+  O: any;
+  G: any;
+  A: any;
+  S: any;
+  ND: any;
+  M: AnyMachine;
+} : M extends Machine<infer C, infer E, infer I, infer EM, infer O, infer G, infer A, infer S, infer ND> ? {
+  C: C;
+  E: E;
+  I: I;
+  EM: EM;
+  O: O;
+  G: G;
+  A: A;
+  S: S;
+  ND: ND;
+  M: Machine<C, E, I, EM, O, G, A, S, ND>;
+} : never;
+type InferMInput<M extends AnyMachine> = M extends Machine<any, any, infer I, any, any, any, any, any, any> ? I : never;
+type SnapshotFrom<RT extends Runtime<any>> = RT extends Runtime<any, infer Mt> ? Snapshot<Mt['C'], Mt['O'], Mt['S']> : never;
+//#endregion
+//#region src/runtime/Runtime.d.ts
+type RuntimeStatus = 'notStarted' | 'active' | 'stopped' | 'done' | 'error';
+type Snapshot<C extends MContext, O, S extends ServiceRecord> = {
+  runtimeId: string;
+  states: string[];
+  stateValue: string | string[] | undefined;
+  context: Expand<X_RemovePrivateKeys<C>>;
+  c: Expand<X_RemovePrivateKeys<C>>;
+  runtimeStatus: RuntimeStatus;
+  output: O | undefined;
+  error: unknown;
+  _children: Children<S>;
+};
+type Subscriber<C extends MContext, O, S extends ServiceRecord> = {
+  onSnapshot?: (current: Expand<Snapshot<C, O, S>>, prev: Expand<Snapshot<C, O, S>>) => void;
+  onError?: (err: unknown) => void;
+};
+type RuntimeOptions<I> = {
+  id?: string;
+  input?: () => I;
+};
+type X_RemovePrivateKeys<T extends Record<string, unknown>> = { [K in keyof T as K extends `_${string}` ? never : K]: T[K]; };
+export declare function makeRuntime<M extends AnyMachine>(machine: M, options?: RuntimeOptions<InferMInput<M>>): Runtime<M, InferredMachineTypes<M>>;
+type C$1<Mt extends InferredMachineTypes<any>> = Mt['C'];
+type E$1<Mt extends InferredMachineTypes<any>> = Mt['E'];
+type I$1<Mt extends InferredMachineTypes<any>> = Mt['I'];
+type EM$1<Mt extends InferredMachineTypes<any>> = Mt['EM'];
+type O$1<Mt extends InferredMachineTypes<any>> = Mt['O'];
+type S$1<Mt extends InferredMachineTypes<any>> = Mt['S'];
+declare class Runtime<M extends AnyMachine, Mt extends InferredMachineTypes<M> = InferredMachineTypes<M>> {
+  #private;
+  readonly id: string;
+  readonly machine: Mt['M'];
+  get states(): string[];
+  get stateValue(): string | string[] | undefined;
+  get context(): X_RemovePrivateKeys<C$1<Mt>> extends (infer T) ? { [K in keyof T]: X_RemovePrivateKeys<C$1<Mt>>[K]; } : never;
+  get runtimeStatus(): RuntimeStatus;
+  get output(): O$1<Mt> | undefined;
+  getSnapshot(): Snapshot<C$1<Mt>, O$1<Mt>, S$1<Mt>>;
+  constructor(machine: M, { id, input }?: RuntimeOptions<I$1<Mt>>);
+  subscribe(onSnapshot: Subscriber<C$1<Mt>, O$1<Mt>, S$1<Mt>>['onSnapshot'], onError?: Subscriber<C$1<Mt>, O$1<Mt>, S$1<Mt>>['onError']): () => void;
+  start(): this;
+  send(event: E$1<Mt> | PureETypeString<E$1<Mt>>): this;
+  stop(): this;
+  onEmitted(emittedEventType: EM$1<Mt>['type'], handler: (emittedEvent: EM$1<Mt>) => void): () => void;
+}
+//#endregion
+//#region src/tools/waitFor.d.ts
+export declare function waitFor<RT extends Runtime<any>>(runtime: RT, cond: (snapshot: SnapshotFrom<RT>) => boolean, options?: {
+  timeout?: number;
+}): Promise<SnapshotFrom<RT>>;
+//#endregion
+export type { AnyMachine, BuiltinEType, EmitFn as Emit, EmittableEvent, ListenFn as Listen, MContext, Runtime, RuntimeOptions, RuntimeStatus, SendableEvent, ServiceFn };