nanoeffects 0.2.1 → 0.4.0

package/dist/{module-BSCdR9D1.d.ts → module-DVX8aYlq.d.ts}

@@ -1,17 +1,32 @@
-import { L as UnsubscribeCallback, N as Task, c as Command, j as PayloadOf, k as EventMap, o as Bus, u as Context } from "./action-rqZEnRIp.js";
+import { S as Context, _ as Bus, c as PayloadOf, m as UnsubscribeCallback, o as EventMap, u as Task, y as Command } from "./action-creator-D48fp13T.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> & {
+  readonly type: T;
+  /** Tells whether an action has the type of this command, and narrows its type. */
+  match(action: {
+    type: string;
+    payload?: unknown;
+  }): action is {
+    type: T;
+    payload: P;
+  };
+};
 /**
- * Creates a command: a typed request for a result. `bus.emit(command, payload)`
- * runs its handler as a task, with a context, and returns what the handler
- * returns. Listeners of the command's type are told first, as for any event.
+ * Creates a command: a typed request for a result. Calling it builds
+ * `{ type, payload }` like `createAction`. `bus.emit(command(payload))` (or
+ * `bus.emit(command, payload)`) runs its handler as a task, with a context, and
+ * returns what the handler returns. Listeners of the command's type are told
+ * first, as for any event.
  *
  * The handler is optional. A command without one is only a contract, and the
  * bus gets its implementation from the `commands` registry (see
- * `createCommands` and `bindHandler`). A handler bound there wins over the one
+ * `commandsPlugin` and `bindHandler`). A handler bound there wins over the one
  * the command was created with, so a test can give a bus its own implementation.
  *
- * A handler can be wrapped in a policy, e.g. `latest(fn)`. Calling the command
- * directly, `command(payload)`, runs its own handler outside of any bus.
+ * A handler can be wrapped in a policy, e.g. `latest(fn)`.
+ * `command.match(action)` tells whether an action has the type of the command,
+ * as it does for an action creator.
  *
  * @example
  * ```ts
@@ -20,34 +35,33 @@ import { L as UnsubscribeCallback, N as Task, c as Command, j as PayloadOf, k as
  * );
  * const sendMail = createCommand<Mail, void>("mail/send"); // implemented elsewhere
  *
- * const commands = createCommands([bindHandler(sendMail, smtpSend)]);
- * const bus = createBus({ commands });
- * const user = await bus.emit(getUser, "1");
+ * const bus = createBus<Events>();
+ * bus.use(commandsPlugin([bindHandler(sendMail, smtpSend)]));
+ * const user = await bus.emit(getUser("1"));
  *
  * commands.handle(getUser, async () => fakeUser); // in a test
  * ```
  */
-declare const createCommand: <P = void, R = void, T extends string = string, E extends EventMap = EventMap>(type: T, handler?: Task<P, E, R>) => Command<P, R> & {
-  readonly type: T;
-};
+declare const createCommand: <P = void, R = void, T extends string = string, E extends EventMap = EventMap>(type: T, handler?: Task<P, E, R>) => MadeCommand<P, R, T>;
 /** A command (or its type) with the handler to bind to it; `bindHandler` makes one. */
 type Binding<E extends EventMap = EventMap> = readonly [Command<never, unknown> | string, Task<never, E, unknown>];
 /**
- * Pairs a command with the handler to bind to it, for `createCommands`. It
+ * Pairs a command with the handler to bind to it, for `commandsPlugin`. It
  * checks that the handler fits the command.
  *
  * @example
  * ```ts
- * createCommands([bindHandler(sendMail, smtpSend)]);
+ * bus.use(commandsPlugin([bindHandler(sendMail, smtpSend)]));
  * ```
  */
 declare const bindHandler: <P, R, E extends EventMap>(command: Command<P, R>, fn: Task<P, E, R>) => Binding<E>;
 /**
- * The handlers bound to commands of `bus`: it makes the registry, sets it as
- * the commands 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 `createCommands(bus)` replaces the registry
- * of that bus.
+ * The plugin that gives a bus the handlers bound to commands:
+ * `bus.use(commandsPlugin(bindings))` makes the registry, sets it as the
+ * commands 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 `commandsPlugin` on the same bus replaces
+ * the registry of that bus.
  *
  * 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 "..."`.
@@ -55,13 +69,13 @@ declare const bindHandler: <P, R, E extends EventMap>(command: Command<P, R>, fn
  * @example
  * ```ts
  * const bus = createBus<Events>();
- * const commands = createCommands(bus, [bindHandler(sendMail, smtpSend)]);
+ * const commands = bus.use(commandsPlugin([bindHandler(sendMail, smtpSend)]));
  *
  * const unbind = commands.handle(getUser, async () => fakeUser);
  * unbind(); // the command's own handler is back
  * ```
  */
-declare const createCommands: <E extends EventMap>(bus: Bus<E>, bindings?: readonly Binding<E>[]) => {
+declare const commandsPlugin: <E extends EventMap>(bindings?: readonly Binding<E>[]) => (bus: Bus<E>) => {
   run: (command: Command, payload: unknown, ctx: unknown) => unknown;
   handle: {
     <P, R>(command: Command<P, R>, fn: Task<P, E, R>): UnsubscribeCallback;
@@ -121,7 +135,7 @@ type Module<E extends EventMap = EventMap> = {
  * ```
  */
 declare const createModule: <E extends EventMap = EventMap>(name: string, setup: (m: ModuleContext<E>) => void) => Module<E>;
-type Registry<E extends EventMap> = ReturnType<typeof createCommands<E>>;
+type Registry<E extends EventMap> = ReturnType<ReturnType<typeof commandsPlugin<E>>>;
 /** 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. */
@@ -137,7 +151,7 @@ type ModuleApi<E extends EventMap = EventMap> = {
  * The plugin that assembles an app from modules: `bus.use(modulePlugin(modules))`
  * mounts `modules` at once, in the order given, and returns `mount`, `unmount`,
  * `isMounted`, `dispose` and `commands` for the modules that come and go later. The bus runs the commands that the
- * modules bind: if `createCommands(bus)` was called before, that registry is
+ * modules bind: if `bus.use(commandsPlugin())` was called before, that registry is
  * used, otherwise the app attaches its own, as `app.commands`.
  *
  * A module is known by its `name`: mounting a module whose name is taken
@@ -164,4 +178,4 @@ type ModuleApi<E extends EventMap = EventMap> = {
  */
 declare const modulePlugin: <E extends EventMap>(modules?: readonly Module<E>[]) => (bus: Bus<E>) => ModuleApi<E>;
 //#endregion
-export { modulePlugin as a, createCommand as c, createModule as i, createCommands as l, ModuleApi as n, Binding as o, ModuleContext as r, bindHandler as s, Module as t };
+export { modulePlugin as a, bindHandler as c, createModule as i, commandsPlugin as l, ModuleApi as n, Binding as o, ModuleContext as r, MadeCommand as s, Module as t, createCommand as u };

package/dist/notrace/{action-rqZEnRIp.d.ts → action-creator-D48fp13T.d.ts}

@@ -1,29 +1,3 @@
-//#region src/core/types.d.ts
-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";
-type Phase = "start" | "done" | "error" | "cancel" | "drop";
-type TraceEvent<E = Record<string, unknown>> = { [K in Keys<E>]: {
-  id: number;
-  parent?: number;
-  type: K;
-  effect: EffectName;
-  phase: Phase;
-  payload: E[K];
-  error?: unknown;
-}; }[Keys<E>];
-/**
- * The contract of every trace logger: receives each task phase of a bus.
- * Adapters in `nanoeffects/trace` are factories that return one; pass it
- * through `createTracer` to `createBus({ trace })`.
- */
-type TraceLogger<E = Record<string, unknown>> = (event: TraceEvent<E>) => void;
-/** One logger or several; a throwing logger never breaks the task or the others. */
-type Trace<E = Record<string, unknown>> = TraceLogger<E> | readonly TraceLogger<E>[];
-type UnsubscribeCallback = () => void;
-//#endregion
 //#region src/core/store.d.ts
 declare const anyEventType = "*";
 //#endregion
@@ -68,27 +42,35 @@ type Action<E extends EventMap> = {
   type: EventKey<E>;
   payload: EventPayload<E>;
 };
-type WithPayload<E extends EventMap, K extends EventKey<E>> = undefined extends E[K] ? {
-  type: K;
-  payload?: E[K];
-} : {
-  type: K;
-  payload: E[K];
-};
 type EventLike<E extends EventMap> = { [K in EventKey<E>]: WithPayload<E, K>; }[Keys<E>];
 /**
- * A typed request for a result. `bus.emit(command, payload)` runs the handler
- * of the command as a task and returns what it returns. Made by
+ * Brands `{ type, payload }` from a command call so `emit` can run the command.
+ * Not enumerable on the object.
+ */
+declare const commandCall: 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.
+ */
+type CommandCall<P = unknown, R = unknown> = {
+  type: string;
+  payload: P;
+  readonly [commandCall]: Command<P, R>;
+};
+/**
+ * A typed request for a result. Calling it builds `{ type, payload }` like
+ * `createAction`; `bus.emit(command(payload))` (or `bus.emit(command, payload)`)
+ * runs the handler as a task and returns what it returns. Made by
  * `createCommand` in `nanoeffects/actions`.
  */
 type Command<P = never, R = unknown> = {
-  (payload: P, ctx?: never): R;
+  (payload: P): CommandCall<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;
 };
 /**
- * What the bus needs to run commands. The implementation, `createCommands` in
+ * What the bus needs to run commands. The implementation, `commandsPlugin` in
  * `nanoeffects/actions`, holds the handlers bound to commands and runs the
  * right one, so a bus without `commands` carries none of that.
  */
@@ -96,11 +78,13 @@ interface Commands {
   run(command: Command, payload: unknown, ctx: unknown): unknown;
 }
 /** Anything `emit` takes as its first argument: an event type, an action or a command. */
-type Emittable<E extends EventMap> = EventKey<E> | Command | EventLike<E>;
+type Emittable<E extends EventMap> = EventKey<E> | Command | CommandCall | EventLike<E>;
 type Emit<E extends EventMap> = {
   <K extends EventKey<E>>(event: K, ...payload: PayloadOf<E[K]>): void;
-  <K extends EventKey<E>, R>(event: Handler<E, R, K>, ...payload: PayloadOf<E[K]>): R;
+  /** Before Handler: a command is callable too, and must return its result type. */
   <P, R>(command: Command<P, R>, ...payload: PayloadOf<P>): R;
+  <P, R>(call: CommandCall<P, R>): R;
+  <K extends EventKey<E>, R>(event: Handler<E, R, K>, ...payload: PayloadOf<E[K]>): R;
   (event: EventLike<E>): void;
 };
 type On<E extends EventMap> = {
@@ -119,6 +103,8 @@ type On<E extends EventMap> = {
   }, fn: Task<E[K], E>): UnsubscribeCallback;
 };
 type Off<E extends EventMap> = {
+  /** Removes every listener of every event (including `"*"`). */
+  (): void;
   (event: AnyEvent): void;
   (event: AnyEvent, fn: Task<EventPayload<E>, E>): void;
   <K extends EventKey<E>>(event: K): void;
@@ -173,6 +159,11 @@ type Context<E extends EventMap> = EventLike<E> & ContextOf<E> & {
 };
 interface Bus<E extends EventMap> {
   on: On<E>;
+  /**
+   * Like `on`, but the handler runs at most once: it is removed before it is
+   * invoked, so a nested emit of the same event does not re-enter it.
+   */
+  once: On<E>;
   off: Off<E>;
   emit: Emit<E>;
   /**
@@ -183,7 +174,7 @@ interface Bus<E extends EventMap> {
   use<R>(plugin: (bus: Bus<E>) => R): R;
   /** `BusOptions.context` and `.trace`, and `commands`, for what makes tasks of its own, like `modulePlugin`. */
   readonly context?: ContextOption<E> | undefined;
-  /** What runs the commands; `createCommands(bus)` and `modulePlugin` set it. Without one a command runs its own handler. */
+  /** What runs the commands; `commandsPlugin` and `modulePlugin` set it. Without one a command runs its own handler. */
   commands?: Commands | undefined;
   readonly trace?: Tracer | undefined;
 }
@@ -223,7 +214,40 @@ type BusOptions<E extends EventMap> = {
 };
 declare const createBus: <Events extends EventMap>(options?: BusOptions<Events>) => Bus<Events>;
 //#endregion
-//#region src/actions/action.d.ts
+//#region src/core/types.d.ts
+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";
+type Phase = "start" | "done" | "error" | "cancel" | "drop";
+type TraceEvent<E = Record<string, unknown>> = { [K in Keys<E>]: {
+  id: number;
+  parent?: number;
+  type: K;
+  effect: EffectName;
+  phase: Phase;
+  payload: E[K];
+  error?: unknown;
+}; }[Keys<E>];
+/**
+ * The contract of every trace logger: receives each task phase of a bus.
+ * Adapters in `nanoeffects/trace` are factories that return one; pass it
+ * through `createTracer` to `createBus({ trace })`.
+ */
+type TraceLogger<E = Record<string, unknown>> = (event: TraceEvent<E>) => void;
+/** One logger or several; a throwing logger never breaks the task or the others. */
+type Trace<E = Record<string, unknown>> = TraceLogger<E> | readonly TraceLogger<E>[];
+type UnsubscribeCallback = () => void;
+//#endregion
+//#region src/core/action-creator.d.ts
+type WithPayload<E extends EventMap, K extends Keys<E>> = undefined extends E[K] ? {
+  type: K;
+  payload?: E[K];
+} : {
+  type: K;
+  payload: E[K];
+};
 type Absent<P> = [P] extends [void] ? undefined : P;
 type Made<P, T extends string> = WithPayload<{ [K in T]: Absent<P>; }, T>;
 declare const free: unique symbol;
@@ -267,37 +291,5 @@ interface ActionCreator<P = void, T extends string = string, A extends unknown[]
   }): action is Made<P, T>;
   toString(): T;
 }
-/**
- * Creates an action creator, as in Redux Toolkit.
- *
- * - `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
- *   type of the action is kept.
- * - `createAction<User>("user/loaded")` gives the payload type, for a bus
- *   without an event map or to check the calls of the creator. The type of
- *   the action is then `string`; to keep the literal, give it as the second
- *   generic: `createAction<User, "user/loaded">("user/loaded")`.
- * - With `prepare` the arguments of the creator can differ from the payload,
- *   and both types are inferred.
- *
- * @example
- * ```ts
- * const added = createAction<number>("counter/added");
- * added(2); // { type: "counter/added", payload: 2 }
- * added.type; // "counter/added"
- * added.match(action); // true for actions of this type
- *
- * const renamed = createAction("user/renamed", (id: string, name: string) => ({
- *   payload: { id, name },
- * }));
- *
- * bus.emit(added(2));
- * bus.on(added, (n) => console.log(n));
- * ```
- */
-declare function createAction<P = Free, T extends string = string>(type: T): [P] extends [Free] ? FreeActionCreator<T> : ActionCreator<P, T>;
-declare function createAction<A extends unknown[], P, T extends string = string>(type: T, prepare: (...args: A) => {
-  payload: P;
-}): ActionCreator<P, T, A>;
 //#endregion
-export { Keys as A, WithPayload as C, anyEventType as D, Tracer as E, TraceEvent as F, TraceLogger as I, UnsubscribeCallback as L, Phase as M, Task as N, EffectName as O, Trace as P, WithContext as S, createBus as T, EventPayload as _, AnyEvent as a, Off as b, Command as c, ContextOf as d, ContextOption as f, EventLike as g, EventKey as h, Action as i, PayloadOf as j, EventMap as k, Commands as l, Emittable as m, FreeActionCreator as n, Bus as o, Emit as p, createAction as r, BusOptions as s, ActionCreator as t, Context as u, Handler as v, WithType as w, On as x, HandlerRef as y };
+export { Handler as A, ContextOf as C, EventKey as D, Emittable as E, WithType as F, commandCall as I, createBus as L, Off as M, On as N, EventLike as O, WithContext as P, Tracer as R, Context as S, Emit as T, Bus as _, EffectName as a, CommandCall as b, PayloadOf as c, Trace as d, TraceEvent as f, AnyEvent as g, Action as h, WithPayload as i, HandlerRef as j, EventPayload as k, Phase as l, UnsubscribeCallback as m, Free as n, EventMap as o, TraceLogger as p, FreeActionCreator as r, Keys as s, ActionCreator as t, Task as u, BusOptions as v, ContextOption as w, Commands as x, Command as y, anyEventType as z };

package/dist/notrace/actions.d.ts

@@ -1,17 +1,66 @@
-import { L as UnsubscribeCallback, N as Task, c as Command, j as PayloadOf, k as EventMap, n as FreeActionCreator, o as Bus, r as createAction, t as ActionCreator, u as Context } from "./action-rqZEnRIp.js";
+import { S as Context, _ as Bus, c as PayloadOf, m as UnsubscribeCallback, n as Free, o as EventMap, r as FreeActionCreator, t as ActionCreator, u as Task, y as Command } from "./action-creator-D48fp13T.js";
+//#region src/actions/action.d.ts
+/**
+ * Creates an action creator, as in Redux Toolkit.
+ *
+ * - `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
+ *   type of the action is kept.
+ * - `createAction<User>("user/loaded")` gives the payload type, for a bus
+ *   without an event map or to check the calls of the creator. The type of
+ *   the action is then `string`; to keep the literal, give it as the second
+ *   generic: `createAction<User, "user/loaded">("user/loaded")`.
+ * - With `prepare` the arguments of the creator can differ from the payload,
+ *   and both types are inferred.
+ *
+ * @example
+ * ```ts
+ * const added = createAction<number>("counter/added");
+ * added(2); // { type: "counter/added", payload: 2 }
+ * added.type; // "counter/added"
+ * added.match(action); // true for actions of this type
+ *
+ * const renamed = createAction("user/renamed", (id: string, name: string) => ({
+ *   payload: { id, name },
+ * }));
+ *
+ * bus.emit(added(2));
+ * bus.on(added, (n) => console.log(n));
+ * ```
+ */
+export declare function createAction<P = Free, T extends string = string>(type: T): [P] extends [Free] ? FreeActionCreator<T> : ActionCreator<P, T>;
+export declare function createAction<A extends unknown[], P, T extends string = string>(type: T, prepare: (...args: A) => {
+  payload: P;
+}): ActionCreator<P, T, A>;
+//#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> & {
+  readonly type: T;
+  /** Tells whether an action has the type of this command, and narrows its type. */
+  match(action: {
+    type: string;
+    payload?: unknown;
+  }): action is {
+    type: T;
+    payload: P;
+  };
+};
 /**
- * Creates a command: a typed request for a result. `bus.emit(command, payload)`
- * runs its handler as a task, with a context, and returns what the handler
- * returns. Listeners of the command's type are told first, as for any event.
+ * Creates a command: a typed request for a result. Calling it builds
+ * `{ type, payload }` like `createAction`. `bus.emit(command(payload))` (or
+ * `bus.emit(command, payload)`) runs its handler as a task, with a context, and
+ * returns what the handler returns. Listeners of the command's type are told
+ * first, as for any event.
  *
  * The handler is optional. A command without one is only a contract, and the
  * bus gets its implementation from the `commands` registry (see
- * `createCommands` and `bindHandler`). A handler bound there wins over the one
+ * `commandsPlugin` and `bindHandler`). A handler bound there wins over the one
  * the command was created with, so a test can give a bus its own implementation.
  *
- * A handler can be wrapped in a policy, e.g. `latest(fn)`. Calling the command
- * directly, `command(payload)`, runs its own handler outside of any bus.
+ * A handler can be wrapped in a policy, e.g. `latest(fn)`.
+ * `command.match(action)` tells whether an action has the type of the command,
+ * as it does for an action creator.
  *
  * @example
  * ```ts
@@ -20,34 +69,33 @@ import { L as UnsubscribeCallback, N as Task, c as Command, j as PayloadOf, k as
  * );
  * const sendMail = createCommand<Mail, void>("mail/send"); // implemented elsewhere
  *
- * const commands = createCommands([bindHandler(sendMail, smtpSend)]);
- * const bus = createBus({ commands });
- * const user = await bus.emit(getUser, "1");
+ * const bus = createBus<Events>();
+ * bus.use(commandsPlugin([bindHandler(sendMail, smtpSend)]));
+ * const user = await bus.emit(getUser("1"));
  *
  * commands.handle(getUser, async () => fakeUser); // in a test
  * ```
  */
-export declare const createCommand: <P = void, R = void, T extends string = string, E extends EventMap = EventMap>(type: T, handler?: Task<P, E, R>) => Command<P, R> & {
-  readonly type: T;
-};
+export declare const createCommand: <P = void, R = void, T extends string = string, E extends EventMap = EventMap>(type: T, handler?: Task<P, E, R>) => MadeCommand<P, R, T>;
 /** A command (or its type) with the handler to bind to it; `bindHandler` makes one. */
 type Binding<E extends EventMap = EventMap> = readonly [Command<never, unknown> | string, Task<never, E, unknown>];
 /**
- * Pairs a command with the handler to bind to it, for `createCommands`. It
+ * Pairs a command with the handler to bind to it, for `commandsPlugin`. It
  * checks that the handler fits the command.
  *
  * @example
  * ```ts
- * createCommands([bindHandler(sendMail, smtpSend)]);
+ * bus.use(commandsPlugin([bindHandler(sendMail, smtpSend)]));
  * ```
  */
 export declare const bindHandler: <P, R, E extends EventMap>(command: Command<P, R>, fn: Task<P, E, R>) => Binding<E>;
 /**
- * The handlers bound to commands of `bus`: it makes the registry, sets it as
- * the commands 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 `createCommands(bus)` replaces the registry
- * of that bus.
+ * The plugin that gives a bus the handlers bound to commands:
+ * `bus.use(commandsPlugin(bindings))` makes the registry, sets it as the
+ * commands 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 `commandsPlugin` on the same bus replaces
+ * the registry of that bus.
  *
  * 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 "..."`.
@@ -55,13 +103,13 @@ export declare const bindHandler: <P, R, E extends EventMap>(command: Command<P,
  * @example
  * ```ts
  * const bus = createBus<Events>();
- * const commands = createCommands(bus, [bindHandler(sendMail, smtpSend)]);
+ * const commands = bus.use(commandsPlugin([bindHandler(sendMail, smtpSend)]));
  *
  * const unbind = commands.handle(getUser, async () => fakeUser);
  * unbind(); // the command's own handler is back
  * ```
  */
-export declare const createCommands: <E extends EventMap>(bus: Bus<E>, bindings?: readonly Binding<E>[]) => {
+export declare const commandsPlugin: <E extends EventMap>(bindings?: readonly Binding<E>[]) => (bus: Bus<E>) => {
   run: (command: Command, payload: unknown, ctx: unknown) => unknown;
   handle: {
     <P, R>(command: Command<P, R>, fn: Task<P, E, R>): UnsubscribeCallback;
@@ -79,43 +127,43 @@ type Creator = {
   readonly type: string;
 };
 type Outcome = string | Creator;
-/** What `createJob` returns: the command of the job and the actions of its outcome. */
-type Job<P, R, T extends string, S extends Outcome, F extends Outcome> = {
-  command: Command<P, Promise<Awaited<R> | undefined>> & {
-    readonly type: T;
-  };
+/** What `createJob` returns: the command of the job, with its two actions as properties. */
+type Job<P, R, T extends string, S extends Outcome, F extends Outcome> = MadeCommand<P, Promise<Awaited<R> | undefined>, T> & {
   /** Made from a string with the result as its payload, or the creator that was given. */
-  successAction: S extends string ? ActionCreator<Awaited<R>, S> : S;
+  readonly success: S extends string ? ActionCreator<Awaited<R>, S> : S;
   /** Made from a string with the error as its payload, or the creator that was given. */
-  failAction: F extends string ? ActionCreator<unknown, F> : F;
+  readonly fail: F extends string ? ActionCreator<unknown, F> : F;
 };
 /**
  * Creates a job: a command whose outcome is sent on as actions. When the
- * handler succeeds, `successAction(result)` is emitted on the bus, and when it
- * fails, `failAction(error)`. It is made for the case where nobody waits for
+ * handler succeeds, `job.success(result)` is emitted on the bus, and when it
+ * fails, `job.fail(error)`. It 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 three together: `{ command, successAction, failAction }`.
+ * effect. It returns the command, with the two actions on it: `job.success` and
+ * `job.fail`.
  *
  * `success` and `fail` are a type string, from which the job makes an action
  * creator with `createAction`, or an action creator that exists already, which
  * is used and returned as it is. A missing one is made with the type
  * `<type>/success` or `<type>/fail`.
  *
- * `bus.emit(command, payload)` returns a promise of the result. An error of the
- * handler always counts as handled: it goes to `failAction` and the promise
+ * `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.
  * The actions are emitted as the task that ran the job, also for a handler bound
  * with `commands.handle`, and are skipped once the task is aborted. A missing
  * handler is not an outcome: `emit` throws `MissingHandlerError`. Calling the
- * command directly runs only its handler.
+ * job builds `{ type, payload }` like a command; it does not run the handler.
  *
  * @example
  * ```ts
- * const { command: loadUser, successAction: userLoaded, failAction: userFailed } =
- *   createJob("user/load", fetchUser, { success: "user/loaded", fail: "user/failed" });
+ * const loadUser = createJob("user/load", fetchUser, {
+ *   success: "user/loaded",
+ *   fail: "user/failed",
+ * });
  *
- * bus.on(userLoaded, (user) => render(user));
- * bus.emit(loadUser, "1"); // userLoaded(user) or userFailed(error) comes later
+ * bus.on(loadUser.success, (user) => render(user));
+ * bus.emit(loadUser("1")); // loadUser.success(user) or loadUser.fail(error) comes later
  * ```
  */
 export declare const createJob: <P = void, R = void, T extends string = string, E extends EventMap = EventMap, S extends Outcome = `${T}/success`, F extends Outcome = `${T}/fail`>(type: T, handler?: Task<P, E, R>, outcomes?: {
@@ -176,7 +224,7 @@ type Module<E extends EventMap = EventMap> = {
  * ```
  */
 export declare const createModule: <E extends EventMap = EventMap>(name: string, setup: (m: ModuleContext<E>) => void) => Module<E>;
-type Registry<E extends EventMap> = ReturnType<typeof createCommands<E>>;
+type Registry<E extends EventMap> = ReturnType<ReturnType<typeof commandsPlugin<E>>>;
 /** 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. */
@@ -192,7 +240,7 @@ type ModuleApi<E extends EventMap = EventMap> = {
  * The plugin that assembles an app from modules: `bus.use(modulePlugin(modules))`
  * mounts `modules` at once, in the order given, and returns `mount`, `unmount`,
  * `isMounted`, `dispose` and `commands` for the modules that come and go later. The bus runs the commands that the
- * modules bind: if `createCommands(bus)` was called before, that registry is
+ * modules bind: if `bus.use(commandsPlugin())` was called before, that registry is
  * used, otherwise the app attaches its own, as `app.commands`.
  *
  * A module is known by its `name`: mounting a module whose name is taken
@@ -219,4 +267,4 @@ type ModuleApi<E extends EventMap = EventMap> = {
  */
 export declare const modulePlugin: <E extends EventMap>(modules?: readonly Module<E>[]) => (bus: Bus<E>) => ModuleApi<E>;
 //#endregion
-export { type ActionCreator, type Binding, type FreeActionCreator, type Job, type Module, type ModuleApi, type ModuleContext, createAction };
+export type { ActionCreator, Binding, FreeActionCreator, Job, Module, ModuleApi, ModuleContext };

package/dist/notrace/actions.js

@@ -1 +1 @@
-import{i as e,n as t,s as n}from"./context-yAWj0BFZ.js";import{t as r}from"./event-0RIBGYqS.js";function i(e,t){return Object.assign((...n)=>({type:e,payload:t?t(...n).payload:n[0]}),{type:e,match:t=>t.type===e,toString:()=>e})}var a=class extends Error{};const o=(e,n)=>Object.assign((r,i)=>{if(!n)throw new a(`No handler for command "${e}"`);return n(r,i??t({event:{type:e,payload:r}}).ctx)},{type:e}),s=(e,t)=>[e,t],c=(e,t=[])=>{let n=/* @__PURE__ */ new Map,i=(e,t)=>{let r={fn:t};return n.set(e,[...n.get(e)??[],r]),()=>{let t=(n.get(e)??[]).filter(e=>e!==r);t.length>0?n.set(e,t):n.delete(e)}};function a(e,t){if(t)return i(r(e),t);let n=e.map(([e,t])=>i(r(e),t));return()=>{for(let e of n)e()}}a(t);let o={run:(e,t,r)=>{let i=(n.get(e.type)??[]).at(-1)?.fn,a=i&&e.wrap?e.wrap(i):i??e;return Reflect.apply(a,null,[t,r])},handle:a};return e.commands=o,o},l=e=>typeof e==`string`?i(e):e,u=(e,t,n)=>{let r=e.emit;r(Reflect.apply(t,null,[n]))},d=e=>{try{return Promise.resolve(e())}catch(e){if(e instanceof a)throw e;return Promise.reject(e)}},f=(e,t,n={})=>{let r=o(e,t),i=l(n.success??`${e}/success`),a=l(n.fail??`${e}/fail`),s=(e,t,n)=>{let r=n;return d(()=>Reflect.apply(e,null,[t,n])).then(e=>(u(r,i,e),e),e=>{u(r,a,e)})};return{command:Object.assign((e,t)=>t?s(r,e,t):d(()=>r(e)),{type:e,wrap:e=>(t,n)=>s(e,t,n)}),successAction:i,failAction:a}},p=(e,t)=>({name:e,setup:t}),m=(r=[])=>i=>{let a=i.commands??c(i),o={handle:(...e)=>{if(!a.handle)throw Error("modulePlugin: the `commands` of the bus is not a registry from `createCommands()`");return Reflect.apply(a.handle,null,e)}},s=t({event:{type:`app`,payload:void 0},bus:i,tracer:i.trace}),l=t=>{let r=/* @__PURE__ */ new Map,i=/* @__PURE__ */ new Map;return{mount:a=>{let s=r.get(a);if(s)return s;let c=i.get(a.name);c&&r.get(c)?.();let u=e(t,a.name),d=u.ctx,f=l(d),p=()=>{r.delete(a),i.get(a.name)===a&&i.delete(a.name),d.abort(),u.unlink()};r.set(a,p),i.set(a.name,a);let m=(e,t)=>{let r=Reflect.apply(o.handle,null,[e,t]);return n(d,r),r},h=(...e)=>{let t=e.map(e=>typeof e==`function`?m(e,e):f.mount(e));return()=>{for(let e of t)e()}},g=(e,...t)=>{d.run(e,...t).catch(e=>{if(!d.signal.aborted)throw e})};try{a.setup(Object.assign(d,{handle:m,use:h,spawn:g}))}catch(e){throw p(),e}return p},unmount:e=>r.get(e)?.(),isMounted:e=>r.has(e)}},u=l(s.ctx);for(let e of r)u.mount(e);return{commands:a,mount:e=>(s.ctx.signal.throwIfAborted(),u.mount(e)),unmount:u.unmount,isMounted:u.isMounted,dispose:()=>s.ctx.abort()}};export{s as bindHandler,i as createAction,o as createCommand,c as createCommands,f as createJob,p as createModule,m as modulePlugin};
+import{i as e,n as t,s as n}from"./context-yAWj0BFZ.js";import{a as r,r as i}from"./bus-B12SvxLv.js";function a(e,t){return Object.assign((...n)=>({type:e,payload:t?t(...n).payload:n[0]}),{type:e,match:t=>t.type===e,toString:()=>e})}var o=class extends Error{};const s=(e,t)=>{let n=t=>t.type===e;function r(n,r){if(typeof r==`object`){if(!t)throw new o(`No handler for command "${e}"`);return t(n,r)}return i(a,e,n)}let a=Object.assign(r,{type:e,match:n});return a},c=(e,t)=>[e,t],l=(e=[])=>t=>{let n=/* @__PURE__ */ new Map,i=(e,t)=>{let r={fn:t};return n.set(e,[...n.get(e)??[],r]),()=>{let t=(n.get(e)??[]).filter(e=>e!==r);t.length>0?n.set(e,t):n.delete(e)}};function a(e,t){if(t)return i(r(e),t);let n=e.map(([e,t])=>i(r(e),t));return()=>{for(let e of n)e()}}a(e);let o={run:(e,t,r)=>{let i=(n.get(e.type)??[]).at(-1)?.fn,a=i&&e.wrap?e.wrap(i):i??e;return Reflect.apply(a,null,[t,r])},handle:a};return t.commands=o,o},u=e=>typeof e==`string`?a(e):e,d=(e,t,n)=>{let r=e.emit;r(Reflect.apply(t,null,[n]))},f=e=>{try{return Promise.resolve(e())}catch(e){if(e instanceof o)throw e;return Promise.reject(e)}},p=(e,t,n={})=>{let r=s(e,t),a=u(n.success??`${e}/success`),o=u(n.fail??`${e}/fail`),c=(e,t,n)=>{let r=n;return f(()=>Reflect.apply(e,null,[t,n])).then(e=>(d(r,a,e),e),e=>{d(r,o,e)})},l=e=>(t,n)=>c(e,t,n);function p(t,n){return typeof n==`object`?c(r,t,n):i(m,e,t)}let m=Object.assign(p,{type:e,match:r.match,wrap:l,success:a,fail:o});return m},m=(e,t)=>({name:e,setup:t}),h=(r=[])=>i=>{let a=i.commands??l()(i),o={handle:(...e)=>{if(!a.handle)throw Error("modulePlugin: the `commands` of the bus is not a registry from `commandsPlugin()`");return Reflect.apply(a.handle,null,e)}},s=t({event:{type:`app`,payload:void 0},bus:i,tracer:i.trace}),c=t=>{let r=/* @__PURE__ */ new Map,i=/* @__PURE__ */ new Map;return{mount:a=>{let s=r.get(a);if(s)return s;let l=i.get(a.name);l&&r.get(l)?.();let u=e(t,a.name),d=u.ctx,f=c(d),p=()=>{r.delete(a),i.get(a.name)===a&&i.delete(a.name),d.abort(),u.unlink()};r.set(a,p),i.set(a.name,a);let m=(e,t)=>{let r=Reflect.apply(o.handle,null,[e,t]);return n(d,r),r},h=(...e)=>{let t=e.map(e=>typeof e==`function`?m(e,e):f.mount(e));return()=>{for(let e of t)e()}},g=(e,...t)=>{d.run(e,...t).catch(e=>{if(!d.signal.aborted)throw e})};try{a.setup(Object.assign(d,{handle:m,use:h,spawn:g}))}catch(e){throw p(),e}return p},unmount:e=>r.get(e)?.(),isMounted:e=>r.has(e)}},u=c(s.ctx);for(let e of r)u.mount(e);return{commands:a,mount:e=>(s.ctx.signal.throwIfAborted(),u.mount(e)),unmount:u.unmount,isMounted:u.isMounted,dispose:()=>s.ctx.abort()}};export{c as bindHandler,l as commandsPlugin,a as createAction,s as createCommand,p as createJob,m as createModule,h as modulePlugin};

package/dist/notrace/bus-B12SvxLv.js

@@ -0,0 +1 @@
+import{a as e,c as t,n,r}from"./context-yAWj0BFZ.js";import{n as i}from"./promise-CSLpzwSR.js";const a=e=>typeof e==`string`?e:e.type,o=(e,t)=>typeof e==`object`?e.payload:t,s=`*`,c=()=>{let e={},t={},n=n=>(t[n]=void 0,e[n]??=/* @__PURE__ */ new Map,e[n]),r=(e,t)=>{let r=n(e),i=r.get(t)??0;i>1?r.set(t,i-1):t?r.delete(t):r.clear()};return{get:n=>(t[n]??=[...e[n]??[]].flatMap(([e,t])=>Array(t).fill(e)),t[n]),add:(e,t)=>{let i=n(e);return i.set(t,(i.get(t)??0)+1),()=>{r(e,t)}},remove:r,clear:()=>{for(let t of Reflect.ownKeys(e))delete e[t];for(let e of Reflect.ownKeys(t))delete t[e]}}},l=Symbol(`nanoeffects.commandCall`),u=(e,t,n)=>{let r={type:t,payload:n};return Object.defineProperty(r,l,{value:e,enumerable:!1}),r},d=e=>{if(typeof e==`function`)return e;if(typeof e==`object`&&e&&l in e)return e[l]},f=(e,t,n)=>Reflect.apply(e,null,[t,n]),p=(s={})=>{let l=c(),u=(e,t)=>l.add(a(e),t),p=(e,t)=>{let n=u(e,(e,r)=>(n(),t(e,r)));return n},m=(e,t)=>{e===void 0?l.clear():l.remove(a(e),t)},h=(e,a)=>{let{onError:o}=s,{ctx:c}=n({event:a,bus:g,tracer:s.trace,parent:{ref:r()}});if(!o){e(a.payload,c);return}let l=e=>{try{o(e,a)}catch(e){t(`onError failed`,e)}};try{let t=e(a.payload,c);i(t)&&Promise.resolve(t).catch(l)}catch(e){l(e)}},g={on:u,once:p,off:m,emit:(t,i)=>{let c=a(t),u=o(t,i),p={type:c,payload:u},m=d(t),_=[...l.get(c),...l.get(`*`)];_.length===0&&!m&&s.onUnhandled?.(p);for(let e of _)h(e,p);if(m){let{ctx:t}=n({event:p,bus:g,tracer:s.trace,parent:{ref:r()}}),i=g.commands?.run??f;return e(t,`command`,()=>i(m,u,t))}},use:e=>e(g),context:s.context,trace:s.trace};return g};export{a,s as i,p as n,u as r,l as t};

package/dist/notrace/effects.d.ts

@@ -1,4 +1,4 @@
-import { A as Keys, N as Task, k as EventMap, u as Context } from "./action-rqZEnRIp.js";
+import { S as Context, o as EventMap, s as Keys, u as Task } from "./action-creator-D48fp13T.js";
 //#region src/utils/delay.d.ts
 /**
  * Resolves after `ms`, or rejects early if `ctx.signal` aborts. `ms` can be a

package/dist/notrace/index.d.ts

@@ -1,2 +1,2 @@
-import { A as Keys, C as WithPayload, D as anyEventType, E as Tracer, F as TraceEvent, I as TraceLogger, L as UnsubscribeCallback, M as Phase, N as Task, O as EffectName, P as Trace, S as WithContext, T as createBus, _ as EventPayload, a as AnyEvent, b as Off, c as Command, d as ContextOf, f as ContextOption, g as EventLike, h as EventKey, i as Action, j as PayloadOf, k as EventMap, l as Commands, m as Emittable, o as Bus, p as Emit, s as BusOptions, u as Context, v as Handler, w as WithType, x as On, y as HandlerRef } from "./action-rqZEnRIp.js";
-export { type Action, type AnyEvent, type Bus, type BusOptions, type Command, type Commands, type Context, type ContextOf, type ContextOption, type EffectName, type Emit, type Emittable, type EventKey, type EventLike, type EventMap, type EventPayload, type Handler, type HandlerRef, type Keys, type Off, type On, type PayloadOf, type Phase, type Task, type Trace, type TraceEvent, type TraceLogger, type Tracer, type UnsubscribeCallback, type WithContext, type WithPayload, type WithType, anyEventType, createBus };
+import { A as Handler, C as ContextOf, D as EventKey, E as Emittable, F as WithType, I as commandCall, L as createBus, M as Off, N as On, O as EventLike, P as WithContext, R as Tracer, S as Context, T as Emit, _ as Bus, a as EffectName, b as CommandCall, c as PayloadOf, d as Trace, f as TraceEvent, g as AnyEvent, h as Action, i as WithPayload, j as HandlerRef, k as EventPayload, l as Phase, m as UnsubscribeCallback, o as EventMap, p as TraceLogger, s as Keys, u as Task, v as BusOptions, w as ContextOption, x as Commands, y as Command, z as anyEventType } from "./action-creator-D48fp13T.js";
+export { type Action, type AnyEvent, type Bus, type BusOptions, type Command, type CommandCall, type Commands, type Context, type ContextOf, type ContextOption, type EffectName, type Emit, type Emittable, type EventKey, type EventLike, type EventMap, type EventPayload, type Handler, type HandlerRef, type Keys, type Off, type On, type PayloadOf, type Phase, type Task, type Trace, type TraceEvent, type TraceLogger, type Tracer, type UnsubscribeCallback, type WithContext, type WithPayload, type WithType, anyEventType, commandCall, createBus };

package/dist/notrace/index.js

@@ -1 +1 @@
-export{n as anyEventType,t as createBus}from"./bus-Dx0l9X6h.js";
+export{i as anyEventType,t as commandCall,n as createBus}from"./bus-B12SvxLv.js";

package/dist/notrace/policies.d.ts

@@ -1,4 +1,4 @@
-import { N as Task, k as EventMap } from "./action-rqZEnRIp.js";
+import { o as EventMap, u as Task } from "./action-creator-D48fp13T.js";
 //#region src/policies/keyed.d.ts
 /** Options shared by every policy that can keep its state per key. */
 type KeyOption<P> = {

package/dist/notrace/redux.d.ts

@@ -1,4 +1,4 @@
-import { k as EventMap, o as Bus, s as BusOptions } from "./action-rqZEnRIp.js";
+import { _ as Bus, o as EventMap, v as BusOptions } from "./action-creator-D48fp13T.js";
 //#region src/store/redux/middleware.d.ts
 /** What Redux passes through a middleware: an action is a plain object with a `type`. */
 type ReduxAction = {

package/dist/notrace/redux.js

@@ -1 +1 @@
-import{c as e}from"./context-yAWj0BFZ.js";import{t}from"./bus-Dx0l9X6h.js";const n=e=>typeof e==`object`&&!!e&&`type`in e,r=(e,t={})=>{let r=e.emit;return()=>e=>i=>{let a=e(i);return n(i)&&(t.filter?.(i)??!0)&&r(i),a}},i=(n={})=>{let{filter:i,context:a,onError:o,...s}=n,c,l=/* @__PURE__ */ new WeakMap,u=e=>({...a,store:c&&{getState:c.getState,dispatch:t=>{typeof t==`object`&&t&&l.set(t,e.type);let n=t;return c?.dispatch(n)}}}),d=t({...s,onError:o??((t,{type:n})=>{e(`handler of "${n}" failed`,t)}),context:u}),f=r(d,{filter:e=>l.get(e)!==e.type&&(i?.(e)??!0)});return{bus:d,middleware:e=>(c=e,f())}};export{i as createEffectsMiddleware};
+import{c as e}from"./context-yAWj0BFZ.js";import{n as t}from"./bus-B12SvxLv.js";const n=e=>typeof e==`object`&&!!e&&`type`in e,r=(e,t={})=>{let r=e.emit;return()=>e=>i=>{let a=e(i);return n(i)&&(t.filter?.(i)??!0)&&r(i),a}},i=(n={})=>{let{filter:i,context:a,onError:o,...s}=n,c,l=/* @__PURE__ */ new WeakMap,u=e=>({...a,store:c&&{getState:c.getState,dispatch:t=>{typeof t==`object`&&t&&l.set(t,e.type);let n=t;return c?.dispatch(n)}}}),d=t({...s,onError:o??((t,{type:n})=>{e(`handler of "${n}" failed`,t)}),context:u}),f=r(d,{filter:e=>l.get(e)!==e.type&&(i?.(e)??!0)});return{bus:d,middleware:e=>(c=e,f())}};export{i as createEffectsMiddleware};

package/dist/observable.d.ts

@@ -1,4 +1,4 @@
-import { A as Keys, k as EventMap, o as Bus } from "./action-rqZEnRIp.js";
+import { _ as Bus, o as EventMap, s as Keys } from "./action-creator-D48fp13T.js";
 //#region src/observable.d.ts
 declare global {
   interface SymbolConstructor {