nanoeffects 0.2.0 → 0.3.0

package/README.md

@@ -65,7 +65,7 @@ ESM only, no dependencies, types included.
 | `nanoeffects/policies`   | `latest`, `leading`, `debounce`, `throttle`, `queue`                          |
 | `nanoeffects/effects`    | `retry`, `timeout`, `poll`, `delay`, `take`, `all`, `allSettled`, `race`      |
 | `nanoeffects/actions`    | `createAction`, `createCommand`, `createJob`, `createModule`, `modulePlugin` |
-| `nanoeffects/redux`      | `createEffectsMiddleware`, `nanoeffectsMiddleware`                            |
+| `nanoeffects/redux`      | `createEffectsMiddleware`                                                     |
 | `nanoeffects/observable` | `createObserve`: an event as an Observable (RxJS)                             |
 | `nanoeffects/dev`        | `devPlugin`: warnings about listeners that pile up and messages about modules; a no-op in production |
 | `nanoeffects/trace`      | `createTracer` and the loggers                                                |

package/dist/{action-rqZEnRIp.d.ts → action-Bdfp-Wvd.d.ts}

@@ -88,7 +88,7 @@ type Command<P = never, R = unknown> = {
   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.
  */
@@ -183,7 +183,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;
 }

package/dist/actions.d.ts

@@ -1,5 +1,5 @@
-import { N as Task, c as Command, k as EventMap, n as FreeActionCreator, r as createAction, t as ActionCreator } from "./action-rqZEnRIp.js";
-import { a as modulePlugin, c as createCommand, i as createModule, l as createCommands, n as ModuleApi, o as Binding, r as ModuleContext, s as bindHandler, t as Module } from "./module-BSCdR9D1.js";
+import { N as Task, k as EventMap, n as FreeActionCreator, r as createAction, t as ActionCreator } from "./action-Bdfp-Wvd.js";
+import { a as modulePlugin, c as bindHandler, i as createModule, l as commandsPlugin, n as ModuleApi, o as Binding, r as ModuleContext, s as MadeCommand, t as Module, u as createCommand } from "./module-I1ixyJzx.js";
 //#region src/actions/job.d.ts
 type Creator = {
   (...args: never[]): {
@@ -9,22 +9,20 @@ 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
@@ -32,7 +30,7 @@ type Job<P, R, T extends string, S extends Outcome, F extends Outcome> = {
  * `<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
+ * 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
@@ -41,11 +39,13 @@ type Job<P, R, T extends string, S extends Outcome, F extends Outcome> = {
  *
  * @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?: {
@@ -55,4 +55,4 @@ export declare const createJob: <P = void, R = void, T extends string = string,
   fail?: F;
 }) => Job<P, R, T, S, F>;
 //#endregion
-export { type ActionCreator, type Binding, type FreeActionCreator, type Job, type Module, type ModuleApi, type ModuleContext, bindHandler, createAction, createCommand, createCommands, createModule, modulePlugin };
+export { type ActionCreator, type Binding, type FreeActionCreator, type Job, type Module, type ModuleApi, type ModuleContext, bindHandler, commandsPlugin, createAction, createCommand, createModule, modulePlugin };

package/dist/actions.js

@@ -1 +1 @@
-import{t as e}from"./onAbort-BgMfspK4.js";import{i as t,n}from"./context-DlA80GOA.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,t)=>Object.assign((r,i)=>{if(!t)throw new a(`No handler for command "${e}"`);return t(r,i??n({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=n({event:{type:`app`,payload:void 0},bus:i,tracer:i.trace}),l=n=>{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=t(n,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=(t,n)=>{let r=Reflect.apply(o.handle,null,[t,n]);return e(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{t as e}from"./onAbort-BgMfspK4.js";import{i as t,n}from"./context-DlA80GOA.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,t)=>Object.assign((r,i)=>{if(!t)throw new a(`No handler for command "${e}"`);return t(r,i??n({event:{type:e,payload:r}}).ctx)},{type:e,match:t=>t.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(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},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 Object.assign((e,t)=>t?s(r,e,t):d(()=>r(e)),{type:e,match:r.match,wrap:e=>(t,n)=>s(e,t,n),success:i,fail: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 `commandsPlugin()`");return Reflect.apply(a.handle,null,e)}},s=n({event:{type:`app`,payload:void 0},bus:i,tracer:i.trace}),l=n=>{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=t(n,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=(t,n)=>{let r=Reflect.apply(o.handle,null,[t,n]);return e(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,c as commandsPlugin,i as createAction,o as createCommand,f as createJob,p as createModule,m as modulePlugin};

package/dist/dev.d.ts

@@ -1,5 +1,5 @@
-import { L as UnsubscribeCallback, k as EventMap, o as Bus } from "./action-rqZEnRIp.js";
-import { n as ModuleApi } from "./module-BSCdR9D1.js";
+import { L as UnsubscribeCallback, k as EventMap, o as Bus } from "./action-Bdfp-Wvd.js";
+import { n as ModuleApi } from "./module-I1ixyJzx.js";
 //#region src/dev/types.d.ts
 /** The parts of what `modulePlugin` returned that the diagnostics report. */
 type ReportedApp<E extends EventMap> = Pick<ModuleApi<E>, "mount" | "unmount" | "isMounted">;

package/dist/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 { A as Keys, N as Task, k as EventMap, u as Context } from "./action-Bdfp-Wvd.js";
 //#region src/utils/delay.d.ts
 /**
  * Resolves after `ms`, or rejects early if `ctx.signal` aborts. `ms` can be a

package/dist/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";
+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-Bdfp-Wvd.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 };

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

@@ -1,5 +1,17 @@
-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 { L as UnsubscribeCallback, N as Task, c as Command, j as PayloadOf, k as EventMap, o as Bus, u as Context } from "./action-Bdfp-Wvd.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
@@ -7,11 +19,13 @@ import { L as UnsubscribeCallback, N as Task, c as Command, j as PayloadOf, k as
  *
  * 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.
+ * `command.match(action)` tells whether an action has the type of the command,
+ * as it does for an action creator.
  *
  * @example
  * ```ts
@@ -20,34 +34,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)]);
+ * bus.use(commandsPlugin([bindHandler(sendMail, smtpSend)]));
  * const bus = createBus({ commands });
  * 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 +68,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 +134,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 +150,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 +177,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-Bdfp-Wvd.d.ts}

@@ -88,7 +88,7 @@ type Command<P = never, R = unknown> = {
   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.
  */
@@ -183,7 +183,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;
 }

package/dist/notrace/actions.d.ts

@@ -1,5 +1,17 @@
-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 { 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-Bdfp-Wvd.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
@@ -7,11 +19,13 @@ import { L as UnsubscribeCallback, N as Task, c as Command, j as PayloadOf, k as
  *
  * 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.
+ * `command.match(action)` tells whether an action has the type of the command,
+ * as it does for an action creator.
  *
  * @example
  * ```ts
@@ -20,34 +34,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)]);
+ * bus.use(commandsPlugin([bindHandler(sendMail, smtpSend)]));
  * const bus = createBus({ commands });
  * 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 +68,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,22 +92,20 @@ 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
@@ -102,7 +113,7 @@ type Job<P, R, T extends string, S extends Outcome, F extends Outcome> = {
  * `<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
+ * 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
@@ -111,11 +122,13 @@ type Job<P, R, T extends string, S extends Outcome, F extends Outcome> = {
  *
  * @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 +189,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 +205,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

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{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,match:t=>t.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(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},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 Object.assign((e,t)=>t?s(r,e,t):d(()=>r(e)),{type:e,match:r.match,wrap:e=>(t,n)=>s(e,t,n),success:i,fail: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 `commandsPlugin()`");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,c as commandsPlugin,i as createAction,o as createCommand,f as createJob,p as createModule,m as modulePlugin};

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 { A as Keys, N as Task, k as EventMap, u as Context } from "./action-Bdfp-Wvd.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";
+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-Bdfp-Wvd.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 };

package/dist/notrace/policies.d.ts

@@ -1,4 +1,4 @@
-import { N as Task, k as EventMap } from "./action-rqZEnRIp.js";
+import { N as Task, k as EventMap } from "./action-Bdfp-Wvd.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 { k as EventMap, o as Bus, s as BusOptions } from "./action-Bdfp-Wvd.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 = {
@@ -9,32 +9,6 @@ type NanoeffectsMiddlewareOptions = {
   /** Return `false` for the actions that the bus should not get. Default: all of them. */
   filter?: (action: ReduxAction) => boolean;
 };
-/**
- * A Redux middleware that sends every action to the bus, after the reducers
- * have handled it, so a handler that reads the store sees the new state. It
- * does not depend on Redux: it only has the shape of a middleware. Values that
- * are not plain actions (the functions of redux-thunk) go through untouched.
- *
- * The other way needs no adapter: give the store to the tasks with
- * `createBus({ context: { store } })` and dispatch from a handler.
- *
- * Take care of loops: a handler must not dispatch the action it handles.
- * Errors of handlers reach the caller of `dispatch`, as for `bus.emit`; set
- * `onError` on the bus to isolate them.
- *
- * @example
- * ```ts
- * const store = configureStore({
- *   reducer,
- *   middleware: (getDefault) => getDefault().concat(nanoeffectsMiddleware(bus)),
- * });
- *
- * bus.on(userRequested, latest(async (id, { store, signal }) => {
- *   store.dispatch(userLoaded(await fetchUser(id, { signal })));
- * }));
- * ```
- */
-export declare const nanoeffectsMiddleware: <E extends EventMap>(bus: Bus<E>, options?: NanoeffectsMiddlewareOptions) => () => (next: (action: unknown) => unknown) => (action: unknown) => unknown;
 //#endregion
 //#region src/store/redux/effects.d.ts
 /** What Redux gives a middleware: the parts of the store that it may use. */
@@ -89,4 +63,4 @@ export declare const createEffectsMiddleware: <E extends EventMap = EventMap>(op
   middleware: (storeApi: ReduxStoreApi) => (next: (action: unknown) => unknown) => (action: unknown) => unknown;
 };
 //#endregion
-export type { EffectsMiddlewareOptions, NanoeffectsMiddlewareOptions, ReduxStoreApi };
+export type { EffectsMiddlewareOptions, ReduxStoreApi };

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,r as nanoeffectsMiddleware};
+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};

package/dist/observable.d.ts

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

package/dist/policies.d.ts

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

package/dist/redux.d.ts

@@ -1,4 +1,4 @@
-import { k as EventMap, o as Bus, s as BusOptions } from "./action-rqZEnRIp.js";
+import { k as EventMap, o as Bus, s as BusOptions } from "./action-Bdfp-Wvd.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 = {
@@ -9,32 +9,6 @@ type NanoeffectsMiddlewareOptions = {
   /** Return `false` for the actions that the bus should not get. Default: all of them. */
   filter?: (action: ReduxAction) => boolean;
 };
-/**
- * A Redux middleware that sends every action to the bus, after the reducers
- * have handled it, so a handler that reads the store sees the new state. It
- * does not depend on Redux: it only has the shape of a middleware. Values that
- * are not plain actions (the functions of redux-thunk) go through untouched.
- *
- * The other way needs no adapter: give the store to the tasks with
- * `createBus({ context: { store } })` and dispatch from a handler.
- *
- * Take care of loops: a handler must not dispatch the action it handles.
- * Errors of handlers reach the caller of `dispatch`, as for `bus.emit`; set
- * `onError` on the bus to isolate them.
- *
- * @example
- * ```ts
- * const store = configureStore({
- *   reducer,
- *   middleware: (getDefault) => getDefault().concat(nanoeffectsMiddleware(bus)),
- * });
- *
- * bus.on(userRequested, latest(async (id, { store, signal }) => {
- *   store.dispatch(userLoaded(await fetchUser(id, { signal })));
- * }));
- * ```
- */
-export declare const nanoeffectsMiddleware: <E extends EventMap>(bus: Bus<E>, options?: NanoeffectsMiddlewareOptions) => () => (next: (action: unknown) => unknown) => (action: unknown) => unknown;
 //#endregion
 //#region src/store/redux/effects.d.ts
 /** What Redux gives a middleware: the parts of the store that it may use. */
@@ -89,4 +63,4 @@ export declare const createEffectsMiddleware: <E extends EventMap = EventMap>(op
   middleware: (storeApi: ReduxStoreApi) => (next: (action: unknown) => unknown) => (action: unknown) => unknown;
 };
 //#endregion
-export type { EffectsMiddlewareOptions, NanoeffectsMiddlewareOptions, ReduxStoreApi };
+export type { EffectsMiddlewareOptions, ReduxStoreApi };

package/dist/redux.js

@@ -1 +1 @@
-import{n as e}from"./onAbort-BgMfspK4.js";import{t}from"./bus-CRnlwmQ4.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,r as nanoeffectsMiddleware};
+import{n as e}from"./onAbort-BgMfspK4.js";import{t}from"./bus-CRnlwmQ4.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/trace.d.ts

@@ -1,4 +1,4 @@
-import { E as Tracer, F as TraceEvent, I as TraceLogger, P as Trace } from "./action-rqZEnRIp.js";
+import { E as Tracer, F as TraceEvent, I as TraceLogger, P as Trace } from "./action-Bdfp-Wvd.js";
 //#region src/trace/console.d.ts
 type ConsoleLoggerOptions = {
   /** Defaults to `globalThis.console`. */

package/docs/actions.md

@@ -18,8 +18,8 @@ const getUser = createCommand("user/get", (id: string, { signal }) => fetchUser(
 // a contract without a handler: the code that sends mail is elsewhere
 const sendMail = createCommand<Mail, void>("mail/send");
 
-// a command whose outcome is sent on as actions: the command and its two actions together
-const { command: loadUser, successAction, failAction } = createJob("user/load", fetchUser, {
+// a command whose outcome is sent on as actions: they are its properties, loadUser.success and loadUser.fail
+const loadUser = createJob("user/load", fetchUser, {
   success: userLoaded, // an action creator that exists: used and returned as it is
   fail: "user/failed", // a string: the job makes the action creator
 });
@@ -27,26 +27,26 @@ const { command: loadUser, successAction, failAction } = createJob("user/load",
 
 **Actions.** `createAction(type)` returns a creator, with no generics: it keeps the literal type, and the bus checks the payload against its event map (`bus.emit(userLoaded(5))` is an error when `"user/loaded"` is a `User`). Without an event map give the payload type, `createAction<User>("user/loaded")`. The creator: `userLoaded(user)` is `{ type, payload }`, `userLoaded.type` is the type, `userLoaded.match(action)` narrows an action. `createAction(type, prepare)` builds the payload from several arguments. A creator works as the event of its type: `bus.emit(userLoaded(user))`, `bus.on(userLoaded, fn)`.
 
-**Commands.** `bus.emit(command, payload)` tells the listeners of the command's type, then runs its handler as a task, with a context, and returns the result. The handler can be wrapped in a policy, `createCommand("search", latest(fn))`. Calling `command(payload)` runs its own handler without a bus.
+**Commands.** `bus.emit(command, payload)` tells the listeners of the command's type, then runs its handler as a task, with a context, and returns the result. The handler can be wrapped in a policy, `createCommand("search", latest(fn))`. Calling `command(payload)` runs its own handler without a bus. `command.match(action)` tells whether an action has the command's type and narrows it, as `match` of an action creator does.
 
-**Where handlers are registered.** The command may carry a handler. The bus gets the handlers bound to commands from a registry, `createCommands`, and a handler bound there wins over the command's own. The registry belongs to one bus, as an effector scope does with `fork({ handlers })`, so each bus (each test) can have its own.
+**Where handlers are registered.** The command may carry a handler. The bus gets the handlers bound to commands from a registry, `commandsPlugin`, and a handler bound there wins over the command's own. The registry belongs to one bus, as an effector scope does with `fork({ handlers })`, so each bus (each test) can have its own.
 
 ```ts
-import { createCommands, bindHandler } from "nanoeffects/actions";
+import { commandsPlugin, bindHandler } from "nanoeffects/actions";
 
 const bus = createBus<Events>();
-const commands = createCommands(bus, [bindHandler(sendMail, smtpSend)]); // attached to the bus
+const commands = bus.use(commandsPlugin([bindHandler(sendMail, smtpSend)])); // attached to the bus
 
 const unbind = commands.handle(getUser, async () => fakeUser); // later, e.g. in a test
 unbind(); // the command's own handler is back; the latest binding wins
 ```
 
-A command with no handler anywhere throws `No handler for command "..."` from `emit`. The registry lives in `nanoeffects/actions`, so a bus without one carries none of this code; without it `emit(command, payload)` simply runs the command's own handler. `createCommands(bus)` sets the registry as `bus.commands`, and a second call on the same bus replaces it. There is no `commands` option in `createBus`; a custom runner is assigned, `bus.commands = { run }`.
+A command with no handler anywhere throws `No handler for command "..."` from `emit`. The registry lives in `nanoeffects/actions`, so a bus without one carries none of this code; without it `emit(command, payload)` simply runs the command's own handler. `bus.use(commandsPlugin())` sets the registry as `bus.commands`, and a second one on the same bus replaces it. There is no `commands` option in `createBus`; a custom runner is assigned, `bus.commands = { run }`.
 
-**Jobs.** `createJob(type, handler, { success, fail })` makes a command that sends its outcome on as actions, for when nobody waits for the result, and returns `{ command, successAction, failAction }`. When the handler succeeds, `successAction(result)` is emitted on the bus, and when it fails, `failAction(error)`.
+**Jobs.** `createJob(type, handler, { success, fail })` makes a command that sends its outcome on as actions, for when nobody waits for the result, and returns the command itself, with the two actions on it: `loadUser.success` and `loadUser.fail`. When the handler succeeds, `loadUser.success(result)` is emitted on the bus, and when it fails, `loadUser.fail(error)`.
 
 - `success` and `fail` are a string, from which the job makes an action creator with `createAction` (the payload is the result, or the error), 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 resolves with `undefined`. For a result that must reject, use a command.
+- `bus.emit(command, payload)` returns a promise of the result. An error of the handler always counts as handled: it goes to `loadUser.fail` and the promise resolves with `undefined`. For a result that must reject, use a command.
 - The actions are emitted as the task that ran the job, also for a handler bound with `commands.handle`, and are not sent once the task is aborted. A missing handler is not an outcome: `emit` throws `No handler for command "..."`.
 - Calling `command(payload)` directly runs only the handler.
 
@@ -72,7 +72,7 @@ app.dispose(); // unmounts every module
 
 - **Unmounting undoes everything** the module did: its subscriptions, its bound commands, its sub-modules and its background tasks, which are aborted.
 - **A module is known by its name.** Mounting a module whose name is taken replaces the mounted one. That is what hot reload needs: see [hmr.md](hmr.md).
-- **The registry.** If `createCommands(bus)` was called, that registry is used; otherwise the module plugin attaches its own. Either way it is `bus.commands` and `app.commands`, so the commands that modules bind are the ones the bus runs.
+- **The registry.** If `bus.use(commandsPlugin())` was called, that registry is used; otherwise the module plugin attaches its own. Either way it is `bus.commands` and `app.commands`, so the commands that modules bind are the ones the bus runs.
 - A disposed app cannot mount modules.
 - A module context is a task context plus `handle` (give a command a handler: for a contract, or to override), `use` (bring sub-modules and commands that carry a handler: `m.use(getUser, saveUser, subModule)`, in any order; the returned function undoes just that call) and `spawn` (a background task, aborted on unmount).
 - A command that carries a handler keeps answering after its module is unmounted: the handler is its own, and `use` only brings the command and tracks it in the registry. Use `handle` for a handler that should live only as long as the module.

package/docs/guide.md

@@ -85,12 +85,12 @@ Strings are for the plain case, objects for actions that other code already make
 A command made with a function carries its handler, as above. More often it is only a contract, a name with the types of the request and the result, and the code that does the work is registered separately: in another file, or a fake one in a test.
 
 ```ts
-import { createCommand, createCommands } from "nanoeffects/actions";
+import { createCommand, commandsPlugin } from "nanoeffects/actions";
 
 const getUser = createCommand<string, Promise<User>>("user/get"); // no handler yet
 
 const bus = createBus<Events>();
-const commands = createCommands(bus); // the handlers of this bus
+const commands = bus.use(commandsPlugin()); // the handlers of this bus
 
 bus.emit(getUser, "1"); // throws: No handler for command "user/get"
 

package/docs/stores.md

@@ -27,8 +27,6 @@ It looks after what is easy to get wrong:
 
 Options are those of `createBus` (except `context`, which adds fields next to `store`) and `filter`, which keeps the actions it rejects away from the bus. Values that are not plain actions (thunks) go through untouched. Nothing here depends on Redux.
 
-To use your own bus, `nanoeffectsMiddleware(bus, { filter })` is the middleware alone: it sends actions to the bus after the reducers and nothing more. Give the store to the tasks yourself with `createBus({ context: { store } })`, or lazily, `context: { get store() { return store; } }` (typed with `WithContext`), since the store needs the middleware and the middleware needs the bus.
-
 ## Zustand, MobX and other stores
 
 No adapter is needed: a store tells about its changes, and `bus.emit` is a call.

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "nanoeffects",
-	"version": "0.2.0",
+	"version": "0.3.0",
 	"description": "Typed event bus where every handler is a task with an AbortSignal, plus policies (latest, debounce, throttle, queue), effects (retry, timeout, poll) and tracing. About 1.2 kB gzip.",
 	"keywords": [
 		"event-bus",