nanoeffects 0.28.0 → 0.30.1

package/dist/guard.d.ts

@@ -0,0 +1,59 @@
+import { H as EventMap, v as Bus } from "./action-creator-6rlBTmH9.js";
+//#region src/guard/plugin.d.ts
+/** What a guard found when it refused an emit. */
+type LimitFinding = {
+  /** `repeats`: one event is in the chain too often; `depth`: the chain is too long; `storm`: too many emits from outside any task. */
+  limit: "repeats" | "depth" | "storm";
+  /** The event names of the loop, from the earlier turn of the refused event to it; for a storm, the event. */
+  path: string[];
+};
+type LoopGuardOptions = {
+  /** How many times one event may be in a chain; the emit that would pass it is refused. Default 50. */
+  maxRepeats?: number;
+  /** How many emits long a chain may be, whatever the names are. Default 1000. */
+  maxDepth?: number;
+  /** Events from outside any task, per second, for each type; over it they are refused. Default: no limit. */
+  maxPerSecond?: number;
+  /** Event names (or a predicate) that the repeat count skips; `maxDepth` still applies. */
+  ignore?: readonly string[] | ((name: string) => boolean);
+  /** What to do with a refused emit: `"drop"` does not send it (default), `"throw"` throws a `LoopError` from it. */
+  onLimit?: "drop" | "throw";
+  /** Receives each finding once for a path. Default: `console.error` with the path. */
+  report?: (finding: LimitFinding) => void;
+  /** The clock for `maxPerSecond`, in ms. Default `performance.now`. */
+  now?: () => number;
+};
+/** Thrown by an emit that the guard refused, with `onLimit: "throw"`. */
+export declare class LoopError extends Error {
+  readonly limit: LimitFinding["limit"];
+  readonly path: string[];
+  constructor(finding: LimitFinding);
+}
+/**
+ * Cuts a loop while the app runs. It follows the chain of emits that `ctx.emit`
+ * makes, across `await` and timers, and refuses the emit that would pass a limit:
+ * the same event too often in one chain (`maxRepeats`), or a chain too long
+ * (`maxDepth`). Nothing else is touched: other chains go on, and the next emit
+ * from outside starts a fresh chain.
+ *
+ * A refused emit is not sent (`onLimit: "drop"`, the default) or throws a
+ * `LoopError`, and is always reported once for each path. The state of the app can
+ * be half done when a loop is cut. The plugin needs no tracer and nothing else, so
+ * it can stay on in production as a safety net. Returns the same bus.
+ *
+ * A chain that repeats on purpose (a handler that emits the same event again after
+ * a timer, forever) is cut too: list its event in `ignore`.
+ *
+ * @example
+ * ```ts
+ * import { createBus } from "nanoeffects";
+ * import { loopGuardPlugin } from "nanoeffects/guard";
+ *
+ * const bus = createBus().use(
+ *   loopGuardPlugin({ maxRepeats: 50, onLimit: "drop" }),
+ * );
+ * ```
+ */
+export declare const loopGuardPlugin: (options?: LoopGuardOptions) => <E extends EventMap>(bus: Bus<E>) => Bus<E>;
+//#endregion
+export type { LimitFinding, LoopGuardOptions };

package/dist/guard.js

@@ -0,0 +1 @@
+var e=class extends Error{limit;path;constructor(e){super(`event loop stopped (${e.limit}): ${e.path.join(` → `)}`),this.name=`LoopError`,this.limit=e.limit,this.path=e.path}};const t=e=>typeof e==`string`?e:String(Reflect.get(Object(e),`type`)),n=e=>{if(typeof e==`function`)return e;let t=new Set(e);return e=>t.has(e)},r=(e,t)=>{let n=0;for(let r=e;r;r=r.parent)!r.inner&&r.type===t&&(n+=1);return n},i=(e,t)=>{let n=[];for(let r=e;r&&!(!r.inner&&(n.push(r.type),r.type===t));r=r.parent);return[...n.reverse(),t]},a=(a={})=>s=>{let c=a.maxRepeats??50,l=a.maxDepth??1e3,u=a.onLimit??`drop`,d=n(a.ignore),f=a.now??(()=>globalThis.performance.now()),p=/* @__PURE__ */ new WeakMap,m=/* @__PURE__ */ new Set,h=/* @__PURE__ */ new Map,g,_=!1,v=e=>{let t=`${e.limit}:${e.path.join(`\0`)}`;if(!m.has(t)){m.add(t);try{(a.report??o)(e)}catch(e){globalThis.console?.error(`[nanoeffects] loop guard report failed`,e)}}},y=t=>{if(v(t),u===`throw`)throw new e(t)},b=e=>g?g.depth+1>l?(y({limit:`depth`,path:i(g,e).slice(-20)}),!1):!d(e)&&r(g,e)>=c?(y({limit:`repeats`,path:i(g,e)}),!1):!0:x(e),x=e=>{let t=a.maxPerSecond;if(t===void 0)return!0;let n=f(),r=(h.get(e)??[]).filter(e=>n-e<1e3);return r.length>=t?(h.set(e,r),y({limit:`storm`,path:[e]}),!1):(r.push(n),h.set(e,r),!0)},S=s.addContext;s.addContext=e=>{S?.(e);let t=e,n=g,r=_&&n!==void 0,i={type:t.type,parent:n,depth:n?n.depth+ +!r:0,inner:r};p.set(e,i);let a=t.emit;t.emit=(e,...t)=>{let n=g;g=i;try{return a(e,...t)}finally{g=n}};let o=t.run;t.run=(...e)=>{let t=g,n=_;g=i,_=!0;try{return o(...e)}finally{g=t,_=n}}};let C=s.emit;return s.emit=(e,...n)=>{if(!b(t(e)))return;let r=_;_=!1;try{return C(e,...n)}finally{_=r}},s},o=e=>{globalThis.console?.error(`[nanoeffects] loop guard: ${e.limit} limit reached: ${e.path.join(` → `)}. The emit was refused.`)};export{e as LoopError,a as loopGuardPlugin};

package/dist/index.d.ts

@@ -1,2 +1,2 @@
-import { A as EventsOf, C as ContextOf, D as EventKey, E as Emittable, F as WithContext, G as PayloadOf, H as EventMap, I as WithSignal, L as WithType, M as HandlerRef, N as Off, O as EventLike, P as On, S as Context, T as Emit, U as Keys, Z as UnsubscribeCallback, _ as AnyEvent, b as Command, g as Actions, h as Action, j as Handler, k as EventPayload, n as Call, o as WithPayload, q as Task, v as Bus, w as ContextOption, x as CommandCall, y as BusOptions, z as createBus } from "./action-creator-CcAEvUnw.js";
-export { type Action, type Actions, type AnyEvent, type Bus, type BusOptions, type Call, type Command, type CommandCall, type Context, type ContextOf, type ContextOption, type Emit, type Emittable, type EventKey, type EventLike, type EventMap, type EventPayload, type EventsOf, type Handler, type HandlerRef, type Keys, type Off, type On, type PayloadOf, type Task, type UnsubscribeCallback, type WithContext, type WithPayload, type WithSignal, type WithType, createBus };
+import { A as HandledCall, C as Emit, D as EventPayload, E as EventLike, F as WithContext, G as PayloadOf, H as EventMap, I as WithSignal, L as WithType, M as HandlerRef, N as Off, O as EventsOf, P as On, Q as UnsubscribeCallback, R as createBus, S as ContextOption, T as EventKey, U as Keys, _ as AnyEvent, b as Context, g as Actions, h as Action, j as Handler, k as Handled, n as Call, o as WithPayload, q as Task, v as Bus, w as Emittable, x as ContextOf, y as BusOptions } from "./action-creator-6rlBTmH9.js";
+export { type Action, type Actions, type AnyEvent, type Bus, type BusOptions, type Call, type Context, type ContextOf, type ContextOption, type Emit, type Emittable, type EventKey, type EventLike, type EventMap, type EventPayload, type EventsOf, type Handled, type HandledCall, type Handler, type HandlerRef, type Keys, type Off, type On, type PayloadOf, type Task, type UnsubscribeCallback, type WithContext, type WithPayload, type WithSignal, type WithType, createBus };

package/dist/index.js

@@ -1 +1 @@
-export{n as createBus}from"./bus-DlpEluzd.js";
+export{t as createBus}from"./bus-DFlmNJ6h.js";

package/dist/match.d.ts

@@ -1,4 +1,4 @@
-import { H as EventMap, Z as UnsubscribeCallback, h as Action, k as EventPayload, q as Task, v as Bus } from "./action-creator-CcAEvUnw.js";
+import { D as EventPayload, H as EventMap, Q as UnsubscribeCallback, h as Action, q as Task, v as Bus } from "./action-creator-6rlBTmH9.js";
 //#region src/match/plugin.d.ts
 /** A function over the action of an event: `{ type, payload }`. */
 type Predicate<E extends EventMap> = (action: Action<E>) => boolean;
@@ -23,8 +23,8 @@ type MatchApi<E extends EventMap> = {
  * to subscribe to the events that it picks instead of to one named event. The
  * predicate gets `{ type, payload }` of every event; when it returns true the
  * handler runs with the payload and the task context of that event. A type guard
- * narrows the payload of the handler. An action creator or a command, which have
- * a string `type`, keep their meaning. Returns the same bus.
+ * narrows the payload of the handler. An action creator, which has
+ * a string `type`, keeps its meaning. Returns the same bus.
  *
  * The subscription listens to `"*"`, so it runs after the listeners of the event
  * itself, makes a task for every event whether or not the predicate accepts it,

package/dist/match.js

@@ -1 +1 @@
-const e=e=>typeof e==`function`&&typeof Reflect.get(e,`type`)!=`string`,t=e=>e,n=()=>n=>{let{on:r,once:i,off:a}=n,o=/* @__PURE__ */ new Map,s=(e,t,i)=>{let a=Reflect.apply(r,n,[`*`,(n,r)=>{if(e({type:Reflect.get(r,`type`),payload:n}))return i&&c(),t(n,r)}]),s={handler:t,remove:c};o.set(e,[...o.get(e)??[],s]);function c(){a();let t=(o.get(e)??[]).filter(e=>e!==s);t.length>0?o.set(e,t):o.delete(e)}return c},c=(t,a,o,c)=>e(t)?s(t,a,o):Reflect.apply(o?i:r,n,[t,a,c]);return Object.assign(n,t({on:(e,t,n)=>c(e,t,!1,n),once:(e,t,n)=>c(e,t,!0,n),off:(t,r)=>{if(r===void 0&&(t===void 0||t===`*`)&&o.clear(),!e(t))return Reflect.apply(a,n,[t,r]);let i=o.get(t)??[],s=i.filter(e=>e.handler===r),c=r===void 0?i:s.slice(0,1);for(let e of c)e.remove()}}))};export{n as matchPlugin};
+const e=e=>typeof e==`function`&&typeof Reflect.get(e,`type`)!=`string`,t=e=>e,n=()=>n=>{let{on:r,once:i,off:a}=n,o=/* @__PURE__ */ new Map,s=(e,t,i,a)=>{let s=Reflect.apply(r,n,[`*`,(n,r)=>{if(e({type:Reflect.get(r,`type`),payload:n}))return i&&l(),t(n,r)},a]),c={handler:t,remove:l};o.set(e,[...o.get(e)??[],c]);function l(){s();let t=(o.get(e)??[]).filter(e=>e!==c);t.length>0?o.set(e,t):o.delete(e)}return l},c=(t,a,o,c)=>e(t)?s(t,a,o,c):Reflect.apply(o?i:r,n,[t,a,c]);return Object.assign(n,t({on:(e,t,n)=>c(e,t,!1,n),once:(e,t,n)=>c(e,t,!0,n),off:(t,r)=>{if(r===void 0&&(t===void 0||t===`*`)&&o.clear(),!e(t))return Reflect.apply(a,n,[t,r]);let i=o.get(t)??[],s=i.filter(e=>e.handler===r),c=r===void 0?i:s.slice(0,1);for(let e of c)e.remove()}}))};export{n as matchPlugin};

package/dist/{module-C_oEXw1n.d.ts → module-G39MaVOt.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, Q 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-6rlBTmH9.js";
+import { n as ScopeSlots, r as Scoped } from "./types-N_cdRr1r.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-BrMSO3RP.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
@@ -52,6 +54,7 @@ interface Tracer<Ref extends object = object> {
     type: string;
     payload?: unknown;
     traceGroupId?: string;
+    leaf?: boolean;
   }, parent?: Ref): Ref;
   /** Gives the task another `type`, for a task that is named after it was made (a named listener). A tracer may leave it out. */
   rename?(ref: Ref, type: string): void;
@@ -98,27 +101,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 +131,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 +148,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 +161,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 +188,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 +278,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 +297,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 +348,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 +457,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 };