nanoeffects 0.28.0 → 0.29.0

package/dist/{module-C_oEXw1n.d.ts → module-BWMW83qk.d.ts}

@@ -1,10 +1,10 @@
-import { G as PayloadOf, H as EventMap, R as commandCall, S as Context, Z as UnsubscribeCallback, b as Command, c as Scope, g as Actions, q as Task, u as WithScope, v as Bus, x as CommandCall } from "./action-creator-CcAEvUnw.js";
-import { n as ScopeSlots, r as Scoped } from "./types-FV8fuvI9.js";
-//#region src/actions/command.d.ts
-/** What `createCommand` returns: a command that also tells whether an action is of its type. */
-type MadeCommand<P, R, T extends string> = Command<P, R> & {
+import { A as HandledCall, G as PayloadOf, H as EventMap, Z as UnsubscribeCallback, b as Context, c as Scope, g as Actions, k as Handled, q as Task, u as WithScope, v as Bus, z as handledCall } from "./action-creator-jeEqIKgK.js";
+import { n as ScopeSlots, r as Scoped } from "./types-D5xsR37j.js";
+//#region src/actions/handled.d.ts
+/** What `createAction` returns: an action that also tells whether an action is of its type. */
+type MadeHandled<P, R, T extends string> = Handled<P, R> & {
   readonly type: T;
-  /** Tells whether an action has the type of this command, and narrows its type. */
+  /** Tells whether an action has the type of this action, and narrows its type. */
   match(action: {
     type: string;
     payload?: unknown;
@@ -14,14 +14,14 @@ type MadeCommand<P, R, T extends string> = Command<P, R> & {
   };
 };
 /** `Made`, called so that its calls carry the scope fields `F`; `Made` itself when there are none. */
-type CarryingCalls<Made, P, R, F> = [unknown] extends [F] ? Made : ((payload: P) => CommandCall<P, R> & WithScope<F>) & Made & WithScope<F>;
-/** A command made with a scope: its calls carry the fields of that scope, for the checker. */
-type ScopedCommand<P, R, T extends string, F> = ((payload: P) => CommandCall<P, R> & WithScope<F>) & MadeCommand<P, R, T> & WithScope<F>;
-/** A command (or its type) with the handler to bind to it; `setHandler` makes one. */
-type Binding<E extends EventMap = EventMap> = readonly [Command<never, unknown> | string, Task<never, E, unknown>];
+type CarryingCalls<Made, P, R, F> = [unknown] extends [F] ? Made : ((payload: P) => HandledCall<P, R> & WithScope<F>) & Made & WithScope<F>;
+/** An action made with a scope: its calls carry the fields of that scope, for the checker. */
+type ScopedHandled<P, R, T extends string, F> = ((payload: P) => HandledCall<P, R> & WithScope<F>) & MadeHandled<P, R, T> & WithScope<F>;
+/** An action (or its type) with the handler to bind to it; `setHandler` makes one. */
+type Binding<E extends EventMap = EventMap> = readonly [Handled<never, unknown> | string, Task<never, E, unknown>];
 /**
  * Pairs an action with the handler to bind to it, for `actionsPlugin`. For a
- * command (an action made with a handler, or with a `Call` type) it checks that
+ * action (an action made with a handler, or with a `Call` type) it checks that
  * the handler fits; any other action is accepted with a handler of any payload.
  *
  * @example
@@ -29,21 +29,21 @@ type Binding<E extends EventMap = EventMap> = readonly [Command<never, unknown>
  * bus.use(actionsPlugin([setHandler(sendMail, smtpSend)]));
  * ```
  */
-declare function setHandler<P, R, E extends EventMap>(command: Command<P, R>, fn: Task<P, E, R>): Binding<E>;
+declare function setHandler<P, R, E extends EventMap>(handled: Handled<P, R>, fn: Task<P, E, R>): Binding<E>;
 declare function setHandler<A extends {
   readonly type: string;
 }, E extends EventMap>(action: A, fn: LooseHandler<A, E>): Binding<E>;
 /**
- * The handler an action that is not a command can have: any. A command
- * (a creator whose calls are command calls) is not accepted here, so its own
+ * The handler an action that is not an action can have: any. An action
+ * (a creator whose calls are calls of an action with a handler) is not accepted here, so its own
  * overload checks the handler against its payload and result.
  */
 type LooseHandler<A, E extends EventMap> = A extends ((...args: never[]) => {
-  readonly [commandCall]: unknown;
+  readonly [handledCall]: unknown;
 }) ? never : Task<never, E, unknown>;
 /** The registry of handlers that `actionsPlugin` returns: `run` for the bus, `handle` to bind more. */
 interface Registry$1<E extends EventMap> extends Actions {
-  handle<P, R>(command: Command<P, R>, fn: Task<P, E, R>): UnsubscribeCallback;
+  handle<P, R>(handled: Handled<P, R>, fn: Task<P, E, R>): UnsubscribeCallback;
   /** Also an action made without a handler: what is emitted for its type runs `fn` and returns its result. */
   handle<A extends {
     readonly type: string;
@@ -52,25 +52,25 @@ interface Registry$1<E extends EventMap> extends Actions {
   handle(bindings: readonly Binding<E>[]): UnsubscribeCallback;
 }
 /**
- * The plugin that gives a bus the handlers bound to commands:
+ * The plugin that gives a bus the handlers bound to actions:
  * `bus.use(actionsPlugin(bindings))` makes the registry, sets it as the
- * commands of the bus and returns it. Each bus has its own, so each test can
+ * actions of the bus and returns it. Each bus has its own, so each test can
  * have its own implementation. `handle` binds more later and returns the
  * function that unbinds. A second `actionsPlugin` on the same bus binds its
  * list in the registry that is there and returns it, so the order of the
- * plugins does not matter. A `commands` that is not such a registry (a custom
+ * plugins does not matter. A `actions` that is not such a registry (a custom
  * runner) is replaced.
  *
- * What the bus runs for a command: the handler bound last, else the one the
- * command was created with, else it throws `No handler for command "..."`.
+ * What the bus runs for an action: the handler bound last, else the one the
+ * action was created with, else it throws `No handler for action "..."`.
  *
  * @example
  * ```ts
  * const bus = createBus<Events>();
- * const commands = bus.use(actionsPlugin([setHandler(sendMail, smtpSend)]));
+ * const actions = bus.use(actionsPlugin([setHandler(sendMail, smtpSend)]));
  *
- * const unbind = commands.handle(getUser, async () => fakeUser);
- * unbind(); // the command's own handler is back
+ * const unbind = actions.handle(getUser, async () => fakeUser);
+ * unbind(); // the action's own handler is back
  * ```
  */
 declare const actionsPlugin: <E extends EventMap>(bindings?: readonly Binding<E>[]) => (bus: Bus<E>) => Registry$1<E>;
@@ -78,23 +78,23 @@ declare const actionsPlugin: <E extends EventMap>(bindings?: readonly Binding<E>
 //#region src/actions/module.d.ts
 /**
  * What a module's `setup` gets: the context of the module's task, so `on`,
- * `emit` and `run` work as in a handler, plus `handle` to bind commands, `use`
+ * `emit` and `run` work as in a handler, plus `handle` to bind actions, `use`
  * to mount sub-modules and `spawn` to start a background task. Everything the
  * module does is undone when it is unmounted.
  */
 type ModuleContext<E extends EventMap = EventMap> = Context<E> & {
-  /** Binds the handler of a command, or a list of them; undone on unmount. */
-  handle<P, R>(command: Command<P, R>, fn: Task<P, E, R>): UnsubscribeCallback;
-  /** Also an action made without a handler: the handler answers it as it would a command. */
+  /** Binds the handler of an action, or a list of them; undone on unmount. */
+  handle<P, R>(handled: Handled<P, R>, fn: Task<P, E, R>): UnsubscribeCallback;
+  /** Also an action made without a handler: the handler answers it as it would one made with a handler. */
   handle<A extends {
     readonly type: string;
   }>(action: A, fn: LooseHandler<A, E>): UnsubscribeCallback;
   handle(type: string, fn: Task<never, E, unknown>): UnsubscribeCallback;
   handle(bindings: readonly Binding<E>[]): UnsubscribeCallback;
   /**
-   * Brings sub-modules and commands, in any order. A sub-module is mounted and
-   * unmounted with this one. A command is bound to the handler it carries, for
-   * as long as this module is mounted; a command that answers by itself keeps
+   * Brings sub-modules and actions, in any order. A sub-module is mounted and
+   * unmounted with this one. An action is bound to the handler it carries, for
+   * as long as this module is mounted; an action that answers by itself keeps
    * answering after the module is gone, since the handler is its own. The
    * returned function undoes just this call, e.g. for what was added later from
    * a listener.
@@ -116,7 +116,7 @@ type Module<E extends EventMap = EventMap> = {
   readonly scope?: Scope;
 };
 /**
- * Describes one domain of an app: the commands it handles, the events it
+ * Describes one domain of an app: the actions it handles, the events it
  * listens to, its sub-modules and its background tasks. The `name` shows up as
  * the type of the module's tasks in the trace.
  *
@@ -158,7 +158,7 @@ interface WithApp {
 }
 /** What `modulePlugin` returns. */
 type ModuleApi<E extends EventMap = EventMap> = {
-  /** The registry of command handlers of the bus: the one it was made with, or the app's own. */
+  /** The registry of action handlers of the bus: the one it was made with, or the app's own. */
   actions: Registry<E>;
   /**
    * Mounts modules, in the order given, and returns the function that unmounts them, last
@@ -187,17 +187,17 @@ type ModuleApi<E extends EventMap = EventMap> = {
  * of one of its methods. By then every plugin is on the bus, so the plugins can
  * be used in any order. The `on`, `once` and `off` calls made in between are
  * held and made right after the modules, so the listeners of a module stay
- * ahead of them. The bus runs the commands that the modules bind: the registry
+ * ahead of them. The bus runs the actions that the modules bind: the registry
  * that the bus has is used (a later `actionsPlugin` binds in it), otherwise the
  * app attaches its own, as `app.actions`. The app is also `bus.app`.
  *
  * A module is known by its `name`: mounting a module whose name is taken
  * replaces the mounted one, which is unmounted first. That is what hot reload
  * needs (see `docs/hmr.md`): the new version of a module file mounts again and
- * the old version goes away with its subscriptions, commands and tasks.
+ * the old version goes away with its subscriptions, actions and tasks.
  *
  * Unmounting undoes everything the module did: its subscriptions, its bound
- * commands, its sub-modules and its background tasks. `dispose` unmounts them
+ * actions, its sub-modules and its background tasks. `dispose` unmounts them
  * all, and a disposed app cannot mount modules.
  *
  * @example
@@ -220,4 +220,4 @@ type ModuleApi<E extends EventMap = EventMap> = {
  */
 declare const modulePlugin: <E extends EventMap>(modules?: readonly Module<E>[]) => (bus: Bus<E> & ScopeSlots & WithApp) => ModuleApi<E>;
 //#endregion
-export { createModule as a, CarryingCalls as c, actionsPlugin as d, setHandler as f, WithApp as i, MadeCommand as l, ModuleApi as n, modulePlugin as o, ModuleContext as r, Binding as s, Module as t, ScopedCommand as u };
+export { createModule as a, CarryingCalls as c, actionsPlugin as d, setHandler as f, WithApp as i, MadeHandled as l, ModuleApi as n, modulePlugin as o, ModuleContext as r, Binding as s, Module as t, ScopedHandled as u };

package/dist/notrace/{action-creator-DxOvVo8I.d.ts → action-creator-xpQ_I2h8.d.ts}

@@ -1,14 +1,16 @@
 //#region src/core/types.d.ts
-/** The third argument of `on` and `once`: read by `tracePlugin`, ignored without it. */
+/** The third argument of `on` and `once`: each field is read by the plugin that names it, ignored without it. */
 type ListenerOptions = {
-  /** Names the listener in the trace: each call of it is a task with this `type`. */
+  /** Names the listener in the trace: each call of it is a task with this `type`. Read by `tracePlugin`. */
   traceId?: string;
+  /** Removes the listener when this aborts, and adds none if it aborted already. Read by `signalPlugin`. */
+  signal?: AbortSignal;
 };
 type PayloadOf<P> = undefined extends P ? [payload?: P] : [payload: P];
 type EventMap = Record<string, unknown>;
 type Keys<E> = keyof E & string;
 type Task<P, E extends EventMap, R = unknown> = (payload: P, ctx: Context<E>) => R;
-type EffectName = "every" | "latest" | "leading" | "debounce" | "throttle" | "run" | "all" | "race" | "retry" | "timeout" | "poll" | "take" | "queue" | "allSettled" | "command" | "emit";
+type EffectName = "every" | "latest" | "leading" | "debounce" | "throttle" | "run" | "all" | "race" | "retry" | "timeout" | "poll" | "take" | "queue" | "allSettled" | "action" | "emit";
 type Phase = "start" | "done" | "error" | "cancel" | "drop";
 type UnsubscribeCallback = () => void;
 //#endregion
@@ -98,27 +100,27 @@ type Action<E extends EventMap> = {
 };
 type EventLike<E extends EventMap> = { [K in EventKey<E>]: WithPayload<E, K>; }[Keys<E>];
 /**
- * Brands `{ type, payload }` from a command call so `emit` can run the command.
+ * Brands `{ type, payload }` from a call of an action with a handler so `emit` can run the action.
  * Not enumerable on the object.
  */
-declare const commandCall: unique symbol;
+declare const handledCall: unique symbol;
 /**
- * What `command(payload)` returns: an action-shaped value that `emit` runs as
- * that command. A plain `{ type, payload }` without this brand is notify-only.
+ * What `action(payload)` returns: an action-shaped value that `emit` runs as
+ * that action. A plain `{ type, payload }` without this brand is notify-only.
  */
-type CommandCall<P = unknown, R = unknown> = {
+type HandledCall<P = unknown, R = unknown> = {
   type: string;
   payload: P;
-  readonly [commandCall]: Command<P, R>;
+  readonly [handledCall]: Handled<P, R>;
 };
 /**
  * A typed request for a result. Calling it builds `{ type, payload }` like
- * `createAction`; `bus.emit(command(payload))` (or `bus.emit(command, payload)`)
+ * `createAction`; `bus.emit(action(payload))` (or `bus.emit(action, payload)`)
  * runs the handler as a task and returns what it returns. Made by
- * `createCommand` in `nanoeffects/actions`.
+ * `createAction` in `nanoeffects/actions`.
  */
-type Command<P = never, R = unknown> = {
-  (payload: P): CommandCall<P, R>;
+type Handled<P = never, R = unknown> = {
+  (payload: P): HandledCall<P, R>;
   readonly type: string;
   /** Wraps the handler that really runs, e.g. to route its outcome. */
   readonly wrap?: (run: (payload: never, ctx: never) => unknown) => (payload: never, ctx: never) => unknown;
@@ -128,15 +130,15 @@ type Command<P = never, R = unknown> = {
  * `actionsPlugin` in `nanoeffects/actions`, holds the handlers bound to
  * actions and runs the right one, so a bus without `actions` carries none of
  * that. `bound` tells, for an event type, whether a handler is bound to it: an
- * action with no handler of its own is a command only then. A runner that has
- * no `bound` runs commands only.
+ * action with no handler of its own is an action only then. A runner that has
+ * no `bound` runs actions only.
  */
 interface Actions {
-  run(command: Command, payload: unknown, ctx: unknown): unknown;
-  bound?(type: string): Command | undefined;
+  run(handled: Handled, payload: unknown, ctx: unknown): unknown;
+  bound?(type: string): Handled | undefined;
 }
-/** Anything `emit` takes as its first argument: an event type, an action or a command. */
-type Emittable<E extends EventMap> = EventKey<E> | Command | CommandCall | EventLike<E>;
+/** Anything `emit` takes as its first argument: an event type, an action creator or a call of one. */
+type Emittable<E extends EventMap> = EventKey<E> | Handled | HandledCall | EventLike<E>;
 type Emit<E extends EventMap> = {
   /**
    * On a bus without an event map the caller can say what a handler bound for
@@ -145,11 +147,11 @@ type Emit<E extends EventMap> = {
    */
   <R = void>(type: string extends EventKey<E> ? string : never, ...payload: unknown[]): R;
   <K extends EventKey<E>>(event: K, ...payload: PayloadOf<DataOf<E[K]>>): ResultOf<E[K]>;
-  /** Before Handler: a command is callable too, and must return its result type. */
-  <P, R>(command: Command<P, R>, ...payload: PayloadOf<P>): R;
+  /** Before Handler: an action is callable too, and must return its result type. */
+  <P, R>(handled: Handled<P, R>, ...payload: PayloadOf<P>): R;
   /** A scope as the second argument replaces context fields for the tasks of this emit; see `scopePlugin`. */
-  <P, R, F>(call: CommandCall<P, R> & WithScope<F>, scope?: EmitScope<E, F>): R;
-  <P, R>(call: CommandCall<P, R>, scope?: EmitScope<E>): R;
+  <P, R, F>(call: HandledCall<P, R> & WithScope<F>, scope?: EmitScope<E, F>): R;
+  <P, R>(call: HandledCall<P, R>, scope?: EmitScope<E>): R;
   <K extends EventKey<E>, R>(event: Handler<E, R, K>, ...payload: PayloadOf<DataOf<E[K]>>): R;
   <F>(event: EventLike<E> & WithScope<F>, scope?: EmitScope<E, F>): void;
   (event: EventLike<E>, scope?: EmitScope<E>): void;
@@ -158,15 +160,15 @@ type On<E extends EventMap> = {
   (event: AnyEvent, fn: Task<EventPayload<E>, E>, options?: ListenerOptions): UnsubscribeCallback;
   <K extends EventKey<E>>(event: K, fn: Task<DataOf<E[K]>, E>, options?: ListenerOptions): UnsubscribeCallback;
   /** An action creator without a payload type: the payload comes from the event map. */
-  /** The creators and commands that carry a scope come first: the handler sees their fields. */
+  /** The creators and actions that carry a scope come first: the handler sees their fields. */
   <K extends EventKey<E>, F>(creator: FreeActionCreator<K, F> & WithScope<F>, fn: Task<DataOf<E[K]>, WithFields<E, F>>, options?: ListenerOptions): UnsubscribeCallback;
   <P, F>(creator: ActionCreator<P, string, PayloadOf<P>, F> & WithScope<F>, fn: Task<P, WithFields<E, F>>, options?: ListenerOptions): UnsubscribeCallback;
-  <P, F>(command: Command<P, unknown> & WithScope<F>, fn: Task<P, WithFields<E, F>>, options?: ListenerOptions): UnsubscribeCallback;
+  <P, F>(handled: Handled<P, unknown> & WithScope<F>, fn: Task<P, WithFields<E, F>>, options?: ListenerOptions): UnsubscribeCallback;
   <K extends EventKey<E>>(creator: FreeActionCreator<K>, fn: Task<DataOf<E[K]>, E>, options?: ListenerOptions): UnsubscribeCallback;
   /** An action creator: the payload comes from it, so an event map is not needed. */
   <P>(creator: ActionCreator<P>, fn: Task<P, E>, options?: ListenerOptions): UnsubscribeCallback;
-  /** A command: the payload comes from it too. */
-  <P>(command: Command<P, unknown>, fn: Task<P, E>, options?: ListenerOptions): UnsubscribeCallback;
+  /** An action: the payload comes from it too. */
+  <P>(handled: Handled<P, unknown>, fn: Task<P, E>, options?: ListenerOptions): UnsubscribeCallback;
   <K extends EventKey<E>, Event extends {
     type: K;
   }>(event: Event & {
@@ -185,7 +187,7 @@ type Off<E extends EventMap> = {
   }>(event: Event & {
     type: K;
   }, fn: Task<DataOf<E[K]>, E>): void;
-  <P>(command: Command<P, unknown>, fn?: Task<P, E>): void;
+  <P>(handled: Handled<P, unknown>, fn?: Task<P, E>): void;
 };
 declare const contextKey: unique symbol;
 /**
@@ -275,7 +277,7 @@ interface Bus<E extends EventMap> {
   use<R>(plugin: (bus: Bus<E>) => R): R;
   /** `BusOptions.context` and `.trace`, and `actions`, for what makes tasks of its own, like `modulePlugin`. */
   readonly ctx?: ContextOption<E> | undefined;
-  /** What runs the handlers of actions; `actionsPlugin` and `modulePlugin` set it. Without one a command runs its own handler. */
+  /** What runs the handlers of actions; `actionsPlugin` and `modulePlugin` set it. Without one an action runs its own handler. */
   actions?: Actions | undefined;
   readonly trace?: Tracer | undefined;
   /** Called with every new task context to add fields to it, for what needs the task, like `effectsPlugin`. Chain to the previous one. */
@@ -294,7 +296,7 @@ type BusOptions<E extends EventMap> = {
   onError?: (error: unknown, event: Action<E>) => void;
   /**
    * Called when an event is emitted and nobody listens to it: the usual sign
-   * of a typo in an event name. Not called for commands, nor for an action with
+   * of a typo in an event name. Not called for actions, nor for an action with
    * a handler bound in `actions`, which always have a handler to run. Typically a warning in development only.
    *
    * @example
@@ -345,7 +347,7 @@ type BoundForm<F> = typeof bound extends keyof F ? NonNullable<F[typeof bound &
 //#endregion
 //#region src/core/scope-types.d.ts
 declare const scopeFields: unique symbol;
-/** What an action creator, a command or a call knows of the scope it was made with: its fields, for the checker. */
+/** What an action creator or a call knows of the scope it was made with: its fields, for the checker. */
 type WithScope<F> = {
   readonly [scopeFields]: F;
 };
@@ -454,4 +456,4 @@ interface ActionCreator<P = void, T extends string = string, A extends unknown[]
   toString(): T;
 }
 //#endregion
-export { Off as A, Task as B, Emittable as C, EventsOf as D, EventPayload as E, commandCall as F, createBus as I, EventMap as L, WithContext as M, WithSignal as N, Handler as O, WithType as P, Keys as R, Emit as S, EventLike as T, UnsubscribeCallback as V, Command as _, WithPayload as a, ContextOf as b, WithScope as c, Effects as d, Action as f, BusOptions as g, Bus as h, FreeActionCreator as i, On as j, HandlerRef as k, BoundForm as l, AnyEvent as m, Call as n, Scope as o, Actions as p, Free as r, WithFields as s, ActionCreator as t, Effect as u, CommandCall as v, EventKey as w, ContextOption as x, Context as y, PayloadOf as z };
+export { Off as A, Task as B, EventLike as C, HandledCall as D, Handled as E, createBus as F, handledCall as I, EventMap as L, WithContext as M, WithSignal as N, Handler as O, WithType as P, Keys as R, EventKey as S, EventsOf as T, UnsubscribeCallback as V, Context as _, WithPayload as a, Emit as b, WithScope as c, Effects as d, Action as f, BusOptions as g, Bus as h, FreeActionCreator as i, On as j, HandlerRef as k, BoundForm as l, AnyEvent as m, Call as n, Scope as o, Actions as p, Free as r, WithFields as s, ActionCreator as t, Effect as u, ContextOf as v, EventPayload as w, Emittable as x, ContextOption as y, PayloadOf as z };

package/dist/notrace/actions.d.ts

@@ -1,5 +1,5 @@
-import { B as Task, F as commandCall, L as EventMap, V as UnsubscribeCallback, _ as Command, c as WithScope, d as Effects, h as Bus, i as FreeActionCreator, n as Call, o as Scope, p as Actions, r as Free, s as WithFields, t as ActionCreator, v as CommandCall, w as EventKey, y as Context, z as PayloadOf } from "./action-creator-DxOvVo8I.js";
-import { t as BoundOf } from "./plugin-lJjjd-SN.js";
+import { B as Task, D as HandledCall, E as Handled, I as handledCall, L as EventMap, S as EventKey, V as UnsubscribeCallback, _ as Context, c as WithScope, d as Effects, h as Bus, i as FreeActionCreator, n as Call, o as Scope, p as Actions, r as Free, s as WithFields, t as ActionCreator, z as PayloadOf } from "./action-creator-xpQ_I2h8.js";
+import { t as BoundOf } from "./plugin-6LhNx0th.js";
 import { t as OriginOptions } from "./origin-key-CxK0SkeG.js";
 //#region src/scope/types.d.ts
 /**
@@ -23,11 +23,11 @@ type FieldsOfScope<E extends EventMap, S extends Scope> = [keyof S] extends [nev
  */
 type Scoped<E extends EventMap, S extends Scope> = WithFields<E, FieldsOfScope<E, S>>;
 //#endregion
-//#region src/actions/command.d.ts
-/** What `createCommand` returns: a command that also tells whether an action is of its type. */
-type MadeCommand<P, R, T extends string> = Command<P, R> & {
+//#region src/actions/handled.d.ts
+/** What `createAction` returns: an action that also tells whether an action is of its type. */
+type MadeHandled<P, R, T extends string> = Handled<P, R> & {
   readonly type: T;
-  /** Tells whether an action has the type of this command, and narrows its type. */
+  /** Tells whether an action has the type of this action, and narrows its type. */
   match(action: {
     type: string;
     payload?: unknown;
@@ -37,14 +37,14 @@ type MadeCommand<P, R, T extends string> = Command<P, R> & {
   };
 };
 /** `Made`, called so that its calls carry the scope fields `F`; `Made` itself when there are none. */
-type CarryingCalls<Made, P, R, F> = [unknown] extends [F] ? Made : ((payload: P) => CommandCall<P, R> & WithScope<F>) & Made & WithScope<F>;
-/** A command made with a scope: its calls carry the fields of that scope, for the checker. */
-type ScopedCommand<P, R, T extends string, F> = ((payload: P) => CommandCall<P, R> & WithScope<F>) & MadeCommand<P, R, T> & WithScope<F>;
-/** A command (or its type) with the handler to bind to it; `setHandler` makes one. */
-type Binding<E extends EventMap = EventMap> = readonly [Command<never, unknown> | string, Task<never, E, unknown>];
+type CarryingCalls<Made, P, R, F> = [unknown] extends [F] ? Made : ((payload: P) => HandledCall<P, R> & WithScope<F>) & Made & WithScope<F>;
+/** An action made with a scope: its calls carry the fields of that scope, for the checker. */
+type ScopedHandled<P, R, T extends string, F> = ((payload: P) => HandledCall<P, R> & WithScope<F>) & MadeHandled<P, R, T> & WithScope<F>;
+/** An action (or its type) with the handler to bind to it; `setHandler` makes one. */
+type Binding<E extends EventMap = EventMap> = readonly [Handled<never, unknown> | string, Task<never, E, unknown>];
 /**
  * Pairs an action with the handler to bind to it, for `actionsPlugin`. For a
- * command (an action made with a handler, or with a `Call` type) it checks that
+ * action (an action made with a handler, or with a `Call` type) it checks that
  * the handler fits; any other action is accepted with a handler of any payload.
  *
  * @example
@@ -52,21 +52,21 @@ type Binding<E extends EventMap = EventMap> = readonly [Command<never, unknown>
  * bus.use(actionsPlugin([setHandler(sendMail, smtpSend)]));
  * ```
  */
-export declare function setHandler<P, R, E extends EventMap>(command: Command<P, R>, fn: Task<P, E, R>): Binding<E>;
+export declare function setHandler<P, R, E extends EventMap>(handled: Handled<P, R>, fn: Task<P, E, R>): Binding<E>;
 export declare function setHandler<A extends {
   readonly type: string;
 }, E extends EventMap>(action: A, fn: LooseHandler<A, E>): Binding<E>;
 /**
- * The handler an action that is not a command can have: any. A command
- * (a creator whose calls are command calls) is not accepted here, so its own
+ * The handler an action that is not an action can have: any. An action
+ * (a creator whose calls are calls of an action with a handler) is not accepted here, so its own
  * overload checks the handler against its payload and result.
  */
 type LooseHandler<A, E extends EventMap> = A extends ((...args: never[]) => {
-  readonly [commandCall]: unknown;
+  readonly [handledCall]: unknown;
 }) ? never : Task<never, E, unknown>;
 /** The registry of handlers that `actionsPlugin` returns: `run` for the bus, `handle` to bind more. */
 interface Registry$1<E extends EventMap> extends Actions {
-  handle<P, R>(command: Command<P, R>, fn: Task<P, E, R>): UnsubscribeCallback;
+  handle<P, R>(handled: Handled<P, R>, fn: Task<P, E, R>): UnsubscribeCallback;
   /** Also an action made without a handler: what is emitted for its type runs `fn` and returns its result. */
   handle<A extends {
     readonly type: string;
@@ -75,38 +75,38 @@ interface Registry$1<E extends EventMap> extends Actions {
   handle(bindings: readonly Binding<E>[]): UnsubscribeCallback;
 }
 /**
- * The plugin that gives a bus the handlers bound to commands:
+ * The plugin that gives a bus the handlers bound to actions:
  * `bus.use(actionsPlugin(bindings))` makes the registry, sets it as the
- * commands of the bus and returns it. Each bus has its own, so each test can
+ * actions of the bus and returns it. Each bus has its own, so each test can
  * have its own implementation. `handle` binds more later and returns the
  * function that unbinds. A second `actionsPlugin` on the same bus binds its
  * list in the registry that is there and returns it, so the order of the
- * plugins does not matter. A `commands` that is not such a registry (a custom
+ * plugins does not matter. A `actions` that is not such a registry (a custom
  * runner) is replaced.
  *
- * What the bus runs for a command: the handler bound last, else the one the
- * command was created with, else it throws `No handler for command "..."`.
+ * What the bus runs for an action: the handler bound last, else the one the
+ * action was created with, else it throws `No handler for action "..."`.
  *
  * @example
  * ```ts
  * const bus = createBus<Events>();
- * const commands = bus.use(actionsPlugin([setHandler(sendMail, smtpSend)]));
+ * const actions = bus.use(actionsPlugin([setHandler(sendMail, smtpSend)]));
  *
- * const unbind = commands.handle(getUser, async () => fakeUser);
- * unbind(); // the command's own handler is back
+ * const unbind = actions.handle(getUser, async () => fakeUser);
+ * unbind(); // the action's own handler is back
  * ```
  */
 export declare const actionsPlugin: <E extends EventMap>(bindings?: readonly Binding<E>[]) => (bus: Bus<E>) => Registry$1<E>;
 //#endregion
 //#region src/actions/action.d.ts
 type Reserved = "handle" | "prepare";
-type Made<P, T extends string> = [P] extends [Free] ? FreeActionCreator<T> : [P] extends [Call<infer Q, infer R>] ? MadeCommand<Q, R, T> : ActionCreator<P, T>;
+type Made<P, T extends string> = [P] extends [Free] ? FreeActionCreator<T> : [P] extends [Call<infer Q, infer R>] ? MadeHandled<Q, R, T> : ActionCreator<P, T>;
 type ScopedCreator<P, T extends string, F> = [P] extends [Free] ? FreeActionCreator<T, F> & WithScope<F> : ActionCreator<P, T, PayloadOf<P>, F> & WithScope<F>;
 type ScopeOf<S> = Omit<S, Reserved>;
-type PreparedCommand<P, R, T extends string, A extends unknown[], F> = ((...args: A) => ReturnType<MadeCommand<P, R, T>> & WithScope<F>) & Omit<MadeCommand<P, R, T>, never> & WithScope<F>;
+type PreparedHandled<P, R, T extends string, A extends unknown[], F> = ((...args: A) => ReturnType<MadeHandled<P, R, T>> & WithScope<F>) & Omit<MadeHandled<P, R, T>, never> & WithScope<F>;
 /**
  * Creates an action creator, as in Redux Toolkit. With a handler it makes a
- * command: `bus.emit(getUser("1"))` runs the handler and returns its result.
+ * action: `bus.emit(getUser("1"))` runs the handler and returns its result.
  *
  * - `createAction("user/loaded")` needs no generics: the payload type comes
  *   from the event map of the bus that the action goes to, and the literal
@@ -150,22 +150,22 @@ type PreparedCommand<P, R, T extends string, A extends unknown[], F> = ((...args
  * ```
  */
 export declare function createAction<P = Free, T extends string = string>(type: T): Made<P, T>;
-export declare function createAction<P = void, R = void, T extends string = string, E extends EventMap = EventMap>(type: T, handler: Task<P, E, R>): MadeCommand<P, R, T>;
+export declare function createAction<P = void, R = void, T extends string = string, E extends EventMap = EventMap>(type: T, handler: Task<P, E, R>): MadeHandled<P, R, T>;
 export declare function createAction<P, R, A extends unknown[], T extends string, S extends Scope = Record<never, never>>(type: T, handler: Task<P, Scoped<EventMap, ScopeOf<S>>, R>, options: {
   prepare: (...args: A) => {
     payload: P;
   };
-} & S): PreparedCommand<P, R, T, A, FieldsOfScope<EventMap, ScopeOf<S>>>;
+} & S): PreparedHandled<P, R, T, A, FieldsOfScope<EventMap, ScopeOf<S>>>;
 export declare function createAction<P, R, A extends unknown[], T extends string, S extends Scope = Record<never, never>>(type: T, options: {
   handle: Task<P, Scoped<EventMap, ScopeOf<S>>, R>;
   prepare: (...args: A) => {
     payload: P;
   };
-} & S): PreparedCommand<P, R, T, A, FieldsOfScope<EventMap, ScopeOf<S>>>;
-export declare function createAction<P, R, T extends string, S extends Scope = Record<never, never>>(type: T, handler: Task<P, Scoped<EventMap, S>, R>, scope: S): ScopedCommand<P, R, T, FieldsOfScope<EventMap, S>>;
+} & S): PreparedHandled<P, R, T, A, FieldsOfScope<EventMap, ScopeOf<S>>>;
+export declare function createAction<P, R, T extends string, S extends Scope = Record<never, never>>(type: T, handler: Task<P, Scoped<EventMap, S>, R>, scope: S): ScopedHandled<P, R, T, FieldsOfScope<EventMap, S>>;
 export declare function createAction<P, R, T extends string, S extends Scope = Record<never, never>>(type: T, options: {
   handle: Task<P, Scoped<EventMap, ScopeOf<S>>, R>;
-} & S): ScopedCommand<P, R, T, FieldsOfScope<EventMap, ScopeOf<S>>>;
+} & S): ScopedHandled<P, R, T, FieldsOfScope<EventMap, ScopeOf<S>>>;
 export declare function createAction<A extends unknown[], P, T extends string, S extends Scope = Record<never, never>>(type: T, options: {
   prepare: (...args: A) => {
     payload: P;
@@ -223,8 +223,8 @@ type Creator = {
   readonly type: string;
 };
 type Outcome = string | Creator;
-/** What `createJob` returns: the command of the job, with its four actions as properties. */
-type Job<P, R, T extends string, S extends Outcome, F extends Outcome, PE extends Outcome = `${T}/pending`, CE extends Outcome = `${T}/cancel`> = MadeCommand<P, Promise<Awaited<R> | undefined>, T> & {
+/** What `createJob` returns: the action of the job, with its four outcome creators as properties. */
+type Job<P, R, T extends string, S extends Outcome, F extends Outcome, PE extends Outcome = `${T}/pending`, CE extends Outcome = `${T}/cancel`> = MadeHandled<P, Promise<Awaited<R> | undefined>, T> & {
   /** Made from a string with the payload of the call as its payload, or the creator that was given. */
   readonly pending: PE extends string ? ActionCreator<P, PE> : PE;
   /** Made from a string with the result as its payload, or the creator that was given. */
@@ -235,13 +235,13 @@ type Job<P, R, T extends string, S extends Outcome, F extends Outcome, PE extend
   readonly cancel: CE extends string ? ActionCreator<unknown, CE> : CE;
 };
 /**
- * Creates a job: a command whose outcome is sent on as actions. When the
+ * Creates a job: an action whose outcome is sent on as actions. When the
  * handler starts, `job.pending(payload)` is emitted on the bus. When it
  * succeeds, `job.success(result)` follows, and when it fails, `job.fail(error)`.
  * When the task is aborted after it started, `job.cancel(reason)` follows
  * instead. After `pending`, exactly one of the three closes the call. A job is
  * made for the case where nobody waits for the result and the bus carries it
- * on, like `createAsyncThunk` or an effector effect. It returns the command,
+ * on, like `createAsyncThunk` or an effector effect. It returns the action,
  * with the four actions on it.
  *
  * A scope as the last argument, `{ cache, $effects: { race } }`, gives the handler
@@ -255,14 +255,14 @@ type Job<P, R, T extends string, S extends Outcome, F extends Outcome, PE extend
  *
  * `bus.emit(job(payload))` returns a promise of the result. An error of the
  * handler always counts as handled: it goes to `job.fail` and the promise
- * resolves with `undefined`; a command is the tool for a result that must reject.
+ * resolves with `undefined`; an action is the tool for a result that must reject.
  * The actions are emitted as the task that ran the job, also for a handler bound
- * with `commands.handle`. Once the task is aborted, `success` and `fail` are
+ * with `actions.handle`. Once the task is aborted, `success` and `fail` are
  * skipped and `cancel` is sent when the handler settles (a handler that never
  * settles sends nothing). A call that does not start, because a policy drops it
  * or it is aborted while it waits in a `queue`, sends none of the four. A
  * missing handler is not an outcome: `emit` throws `MissingHandlerError`.
- * Calling the job builds `{ type, payload }` like a command; it does not run
+ * Calling the job builds `{ type, payload }` like an action; it does not run
  * the handler.
  *
  * @example
@@ -293,23 +293,23 @@ scope?: X) => CarryingCalls<Job<P, R, T, S, F, PE, CE>, P, Promise<Awaited<R> |
 //#region src/actions/module.d.ts
 /**
  * What a module's `setup` gets: the context of the module's task, so `on`,
- * `emit` and `run` work as in a handler, plus `handle` to bind commands, `use`
+ * `emit` and `run` work as in a handler, plus `handle` to bind actions, `use`
  * to mount sub-modules and `spawn` to start a background task. Everything the
  * module does is undone when it is unmounted.
  */
 type ModuleContext<E extends EventMap = EventMap> = Context<E> & {
-  /** Binds the handler of a command, or a list of them; undone on unmount. */
-  handle<P, R>(command: Command<P, R>, fn: Task<P, E, R>): UnsubscribeCallback;
-  /** Also an action made without a handler: the handler answers it as it would a command. */
+  /** Binds the handler of an action, or a list of them; undone on unmount. */
+  handle<P, R>(handled: Handled<P, R>, fn: Task<P, E, R>): UnsubscribeCallback;
+  /** Also an action made without a handler: the handler answers it as it would one made with a handler. */
   handle<A extends {
     readonly type: string;
   }>(action: A, fn: LooseHandler<A, E>): UnsubscribeCallback;
   handle(type: string, fn: Task<never, E, unknown>): UnsubscribeCallback;
   handle(bindings: readonly Binding<E>[]): UnsubscribeCallback;
   /**
-   * Brings sub-modules and commands, in any order. A sub-module is mounted and
-   * unmounted with this one. A command is bound to the handler it carries, for
-   * as long as this module is mounted; a command that answers by itself keeps
+   * Brings sub-modules and actions, in any order. A sub-module is mounted and
+   * unmounted with this one. An action is bound to the handler it carries, for
+   * as long as this module is mounted; an action that answers by itself keeps
    * answering after the module is gone, since the handler is its own. The
    * returned function undoes just this call, e.g. for what was added later from
    * a listener.
@@ -331,7 +331,7 @@ type Module<E extends EventMap = EventMap> = {
   readonly scope?: Scope;
 };
 /**
- * Describes one domain of an app: the commands it handles, the events it
+ * Describes one domain of an app: the actions it handles, the events it
  * listens to, its sub-modules and its background tasks. The `name` shows up as
  * the type of the module's tasks in the trace.
  *
@@ -373,7 +373,7 @@ interface WithApp {
 }
 /** What `modulePlugin` returns. */
 type ModuleApi<E extends EventMap = EventMap> = {
-  /** The registry of command handlers of the bus: the one it was made with, or the app's own. */
+  /** The registry of action handlers of the bus: the one it was made with, or the app's own. */
   actions: Registry<E>;
   /**
    * Mounts modules, in the order given, and returns the function that unmounts them, last
@@ -402,17 +402,17 @@ type ModuleApi<E extends EventMap = EventMap> = {
  * of one of its methods. By then every plugin is on the bus, so the plugins can
  * be used in any order. The `on`, `once` and `off` calls made in between are
  * held and made right after the modules, so the listeners of a module stay
- * ahead of them. The bus runs the commands that the modules bind: the registry
+ * ahead of them. The bus runs the actions that the modules bind: the registry
  * that the bus has is used (a later `actionsPlugin` binds in it), otherwise the
  * app attaches its own, as `app.actions`. The app is also `bus.app`.
  *
  * A module is known by its `name`: mounting a module whose name is taken
  * replaces the mounted one, which is unmounted first. That is what hot reload
  * needs (see `docs/hmr.md`): the new version of a module file mounts again and
- * the old version goes away with its subscriptions, commands and tasks.
+ * the old version goes away with its subscriptions, actions and tasks.
  *
  * Unmounting undoes everything the module did: its subscriptions, its bound
- * commands, its sub-modules and its background tasks. `dispose` unmounts them
+ * actions, its sub-modules and its background tasks. `dispose` unmounts them
  * all, and a disposed app cannot mount modules.
  *
  * @example