nanoeffects 0.3.0 → 0.4.0

package/docs/policies.md

@@ -1,41 +1,92 @@
 # Policies
 
-A policy wraps a handler and decides what happens when calls overlap. Every policy takes `key` in its options (see below), so each key has its own state.
+Use this page when handlers overlap in a SPA (search-as-you-type, double submit, leave page). A **policy** wraps a handler and decides what happens then.
 
-| Policy                         | Overlapping calls                                                          |
-| ------------------------------ | -------------------------------------------------------------------------- |
-| `latest(fn)`                   | the previous run is aborted and its result dropped                        |
-| `leading(fn)`                  | new calls are dropped while a run is going                                |
-| `debounce(ms, fn, options?)`   | run after `ms` of quiet                                                    |
-| `throttle(ms, fn, options?)`   | at most one run per `ms`                                                   |
-| `queue(fn, options?)`          | one after another, in order                                                |
+Start with `latest`. The table and sections below are the rest of the reference.
 
-`debounce` and `throttle` take `leading` and `trailing`:
+## Abort the previous run
 
-- `throttle(ms, fn)` works like lodash `throttle` (and patronum): a call made when the throttle is idle, at least `ms` after the previous call and the previous run, runs at once (`leading`, default `true`); calls made while it waits are held, and the latest of them runs when the window closes (`trailing`, default `true`). Under a steady stream of calls it runs every `ms`. `leading: false` makes even the first call wait for the end of its window; `trailing: false` drops the calls made during a window.
-- `debounce(ms, fn)` runs the last call after `ms` of quiet (`trailing`, default `true`). `leading: true` also runs the first call of a burst at once, and then the trailing run happens only if more calls follow it. `leading: true, trailing: false` runs only the first call of a burst.
-- With both options `false` nothing runs.
-- `throttle` and `debounce` are checked against lodash itself: the tests feed random sequences of calls to both and compare the moments `fn` runs.
+```js
+import { createBus } from "nanoeffects";
+import { latest } from "nanoeffects/policies";
 
-`key` gives each key its own state, so calls with different keys do not affect each other:
+const bus = createBus();
 
-```ts
-// one latest run per user instead of one for all of them
-bus.on("load", latest(loadUser, { key: (user) => user.id }));
-
-// uploads of the same file go one after another, different files in parallel
-bus.on("upload", queue(upload, { key: (file) => file.name }));
+// latest — a newer run aborts the older one
+bus.on(
+  "search",
+  latest(async (query, { signal }) => {
+    await api.search(query, { signal });
+  }),
+);
 ```
 
-The state of a key is dropped when that key goes idle, so keys can be unbounded (ids, urls).
+Pass `signal` to `fetch` (and the like) so the request cancels.
+
+## Choose a policy
+
+Every policy accepts `key` in its options (see [Isolate state by key](#isolate-state-by-key)).
+
+| Policy | Overlapping calls |
+| ------ | ----------------- |
+| `latest(fn)` | previous run aborted, result dropped |
+| `leading(fn)` | new calls dropped while a run is going |
+| `debounce(ms, fn, options?)` | run after `ms` of quiet |
+| `throttle(ms, fn, options?)` | at most one run per `ms` |
+| `queue(fn, options?)` | one after another, in order |
+
+## Configure debounce and throttle
+
+`debounce` and `throttle` take `leading` and `trailing`. Behavior matches lodash (and patronum); tests compare random call sequences to lodash itself.
+
+**Throttle** (`throttle(ms, fn)`):
+
+- Default `leading: true`, `trailing: true`.
+- A call when the throttle is idle (at least `ms` after the previous call and run) runs at once.
+- Calls made while it waits are held; the latest runs when the window closes.
+- Under a steady stream it runs every `ms`.
+- `leading: false` — even the first call waits for the end of its window.
+- `trailing: false` — drop calls made during a window.
+
+**Debounce** (`debounce(ms, fn)`):
+
+- Default `trailing: true` — run the last call after `ms` of quiet.
+- `leading: true` — also run the first call of a burst at once; the trailing run happens only if more calls follow.
+- `leading: true, trailing: false` — only the first call of a burst.
+- Both `false` — nothing runs.
+
+## Isolate state by key
 
-## Queue
+`key` gives each key its own state. Calls with different keys do not affect each other. Idle keys are dropped, so keys can be unbounded (ids, urls).
 
-`queue(fn, options?)` runs the calls of a handler one after another, in the order they arrived, instead of dropping or replacing them like `leading` and `latest` do:
+```js
+import { createBus } from "nanoeffects";
+import { latest, queue } from "nanoeffects/policies";
 
-```ts
+const bus = createBus();
+
+// one latest run per user id
+bus.on(
+  "load",
+  latest(loadUser, { key: (user) => user.id }),
+);
+
+// uploads of the same file go one after another
+bus.on(
+  "upload",
+  queue(upload, { key: (file) => file.name }),
+);
+```
+
+## Run calls one after another with `queue`
+
+```js
+import { createBus } from "nanoeffects";
 import { queue } from "nanoeffects/policies";
 
+const bus = createBus();
+
+// queue — one after another, in order
 bus.on(
   "save",
   queue(async (draft, { signal }) => {
@@ -43,11 +94,22 @@ bus.on(
   }),
 );
 
-bus.emit("save", a); // runs now
-bus.emit("save", b); // waits for a, then runs
+bus.emit("save", draftA); // runs now
+bus.emit("save", draftB); // waits for draftA, then runs
 ```
 
-- `concurrency` (default 1) is how many calls may run at the same time.
-- `limit` caps how many calls may wait, and `overflow` says what to drop when the line is full: the new call (`"drop-new"`, the default) or the oldest waiting one (`"drop-old"`). A dropped call resolves with `undefined`. `queue(fn, { limit: 1, overflow: "drop-old" })` keeps only the latest call while one is running and runs it when the current one is done; `limit: 0` lets nothing wait.
-- Every call returns a promise with the result of its own run. An error rejects only that call and the queue goes on.
-- A waiting call whose task aborts is skipped and resolves with `undefined`. When the task of a running call aborts, its slot is freed at once and its result is dropped, so pass `signal` to what `fn` does: a `fn` that ignores it can overlap with the next run.
+| Option | Meaning |
+| ------ | ------- |
+| `concurrency` | how many calls may run at once (default `1`) |
+| `limit` | how many calls may wait |
+| `overflow` | when the line is full: `"drop-new"` (default) or `"drop-old"` |
+
+A dropped call resolves with `undefined`. `queue(fn, { limit: 1, overflow: "drop-old" })` keeps only the latest waiting call. `limit: 0` lets nothing wait.
+
+Every call returns a promise with the result of its own run. An error rejects only that call; the queue continues.
+
+**Abort:**
+
+- A waiting call whose task aborts is skipped and resolves with `undefined`.
+- When a running call aborts, its slot is freed at once and its result is dropped.
+- Pass `signal` into what `fn` does. A `fn` that ignores it can overlap with the next run.

package/docs/semantics.md

@@ -1,7 +1,9 @@
 # Semantics
 
-- **An aborted task delivers no result.** If the task aborts before a promise settles, the promise rejects with the abort reason, even if the value was just produced in the same tick. `latest`, `debounce`, `all`, `race`, `take` and the rest follow this rule.
-- **`emit` is a plain, synchronous loop** (see "Errors in handlers"). A `ctx.emit` inside a handler is the same call: without `onError` an error of a nested handler is thrown into the handler that emitted; with `onError` it goes there and `ctx.emit` does not throw.
+Guarantees and sharp edges. Read when something surprises you; not required to start.
+
+- **An aborted task delivers no result.** If the task aborts before a promise settles, the promise rejects with the abort reason, even if the value was just produced in the same tick. `latest`, `debounce`, `all`, `race`, `take`, and the rest follow this rule.
+- **`emit` is a plain, synchronous loop** (see [Errors](errors.md)). A `ctx.emit` inside a handler is the same call: without `onError`, an error of a nested handler is thrown into the handler that emitted; with `onError` it goes there and `ctx.emit` does not throw.
 - **Rejections of async handlers** are not handled for you. Without `onError` they are unhandled rejections, which end a Node process by default. Use `onError` for async handlers.
-- **`leading` releases its lock when the task aborts**, not only when `fn` settles. A `fn` that ignores the abort signal can then overlap with the next run, so pass `ctx.signal` to what `fn` does.
+- **`leading` releases its lock when the task aborts**, not only when `fn` settles. A `fn` that ignores the abort signal can then overlap with the next run — pass `ctx.signal` to what `fn` does.
 - **Effects start their function synchronously**, so an event emitted right after the call reaches a `take` inside it.

package/docs/stores.md

@@ -1,48 +1,122 @@
-# Redux, Zustand, MobX
+# Connect Redux, Zustand, or MobX
 
-## Redux
+Use this page when you **already have a store** and want async work with cancellation and policies next to it. It is not a reason to pick Redux (or any store).
 
-`createEffectsMiddleware()` from `nanoeffects/redux` gives you a bus and the Redux middleware that feeds it: the effects of an app in one place, without sagas. Every action goes to the bus after the reducers have handled it, so a handler that reads the store sees the new state, and every task gets `ctx.store` (`dispatch` and `getState`).
+If you do not have a store yet, use `createBus` from the [Guide](guide.md). Recipe: [`examples/redux.ts`](../examples/redux.ts).
 
-```ts
-type Events = { userRequested: string } & WithContext<{ store: ReduxStoreApi<RootState> }>;
+## Wire Redux Toolkit to a bus
 
-const effects = createEffectsMiddleware<Events>();
+Redux’s `dispatch` → reducers updates **state**. It does not give you first-class **tasks** (abort in-flight work, `latest` / `debounce` / `queue`, `retry` / `timeout`). People usually reach for thunks, RTK listener middleware, or sagas for that.
+
+`createEffectsMiddleware` does the same job: after the reducer runs, the action also hits a nanoeffects bus. Keep RTK for state; use policies and effects for async.
+
+Skip this section if you are not already on Redux.
+
+```js
+import { configureStore, createAction } from "@reduxjs/toolkit";
+import { createEffectsMiddleware } from "nanoeffects/redux";
+import { latest } from "nanoeffects/policies";
+
+const userRequested = createAction("user/requested"); // RTK
+const userLoaded = createAction("user/loaded");
+
+// bus + middleware: actions reach the bus after reducers; tasks get ctx.store
+const effects = createEffectsMiddleware();
 
 const store = configureStore({
   reducer,
   middleware: (getDefault) => getDefault().concat(effects.middleware),
 });
 
-effects.bus.on(userRequested, latest(async (id, { store, signal }) => {
-  store.dispatch(userLoaded(await fetchUser(id, { signal })));
-}));
+// latest — a newer run aborts the older one
+effects.bus.on(
+  userRequested,
+  latest(async (id, { store, signal }) => {
+    const user = await fetchUser(id, { signal });
+    store.dispatch(userLoaded(user));
+  }),
+);
 ```
 
-It looks after what is easy to get wrong:
+String event names (`"user/requested"`) work the same. Use your usual RTK actions (`createSlice` / `createAction`). nanoeffects adds the middleware and policies; it does not replace RTK actions.
+
+### What the middleware guarantees
 
-- **A handler does not loop on its own action.** An action that a handler dispatches through `ctx.store` and that has the type the handler works on does not go back to the bus. The action is not marked or changed: the middleware remembers which task dispatched it. Other handlers of that type do not get it either. Longer cycles, `a` to `b` to `a`, are yours to avoid.
-- **A failing handler does not break `dispatch`.** Errors go to `onError` (default `console.error`), as in Redux Toolkit listeners. Reducers still throw to the caller.
-- **The store gets to the tasks by itself**, though the bus is made before the store: `ctx.store` appears when the middleware is added.
+- **No self-loop.** An action that a handler dispatches through `ctx.store` and that has the type the handler works on does not go back to the bus. Other handlers of that type do not get it either. Longer cycles (`a` → `b` → `a`) are yours to avoid.
+- **A failing handler does not break `dispatch`.** Errors go to `onError` (default `console.error`), as in RTK listeners. Reducers still throw to the caller.
+- **`store` reaches tasks when the middleware is installed**, even though the bus is created before `configureStore`.
 
-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.
+Options are those of `createBus` (except `context`, which adds fields next to `store`) and `filter`, which keeps rejected actions away from the bus. Values that are not plain actions (thunks) go through untouched. Nothing here depends on the `redux` package at runtime.
 
-## Zustand, MobX and other stores
+### Type `ctx.store` (optional)
 
-No adapter is needed: a store tells about its changes, and `bus.emit` is a call.
+Only if you want TypeScript to know `store` on handlers. **Skip this in JavaScript** — the middleware already puts `store` on the task at runtime. These lines do not connect the store across the app.
 
 ```ts
-// Zustand
+import type { WithContext } from "nanoeffects";
+import {
+  createEffectsMiddleware,
+  type ReduxStoreApi,
+} from "nanoeffects/redux";
+
+// RootState — your Redux state shape (for getState)
+type RootState = { user: string | null };
+
+// Events — event name → payload for this bus
+// WithContext — checker-only: handlers also have ctx.store
+type Events = {
+  "user/requested": string;
+} & WithContext<{ store: ReduxStoreApi<RootState> }>;
+
+const effects = createEffectsMiddleware<Events>();
+```
+
+## Emit from Zustand
+
+No adapter: the store notifies, you `emit` onto a normal bus.
+
+```js
+import { createBus } from "nanoeffects";
+import { latest } from "nanoeffects/policies";
+
+const bus = createBus(); // plain bus; no Redux middleware
+
 const stop = store.subscribe((state, previous) => {
-  if (state.user !== previous.user) bus.emit(userChanged, state.user);
+  if (state.user === previous.user) return;
+  bus.emit("user/changed", state.user);
 });
 
-// MobX
-const stop = reaction(() => store.user, (user) => bus.emit(userChanged, user));
+// latest — drop in-flight sync when the user changes again
+bus.on(
+  "user/changed",
+  latest(async (user, { signal }) => {
+    await sync(user, { signal });
+  }),
+);
+```
+
+## Emit from MobX
+
+```js
+import { createBus } from "nanoeffects";
+import { latest } from "nanoeffects/policies";
+import { reaction } from "mobx";
+
+const bus = createBus();
+
+const stop = reaction(
+  () => store.user,
+  (user) => bus.emit("user/changed", user),
+);
 
-bus.on(userChanged, latest((user, { signal }) => sync(user, { signal })));
+bus.on(
+  "user/changed",
+  latest(async (user, { signal }) => {
+    await sync(user, { signal });
+  }),
+);
 ```
 
 Stop watching with what the store returned: `onAbort(ctx, stop)` inside a task, or `m.signal.addEventListener("abort", stop)` in a module.
 
-The other way, give the store to the tasks, `createBus({ context: { store } })`, and change it from a handler: `setState` for Zustand, an action of the MobX store (it wraps `runInAction`). A handler that changes the value it was started by emits the event again, so watch the smallest part of the state. For a MobX `flow`, `onAbort(ctx, () => promise.cancel())` cancels it with the task.
+The other way: give the store to tasks with `createBus({ context: { store } })`, and change it from a handler (`setState`, MobX action). A handler that changes the value it was started by emits again, so watch the smallest slice. For a MobX `flow`, `onAbort(ctx, () => promise.cancel())` cancels it with the task.

package/docs/tracing.md

@@ -1,111 +1,126 @@
-# Tracing
+# Trace tasks
 
-## Tracing
+Reference for long-lived apps that need to observe task phases, Redux DevTools, or a build without tracing. Not part of onboarding.
 
-Pass `trace` to `createBus` to observe every task phase. Make it with `createTracer` from `nanoeffects/trace`, which takes a logger (a function) or an array of them. The tracing code lives in that entry, so a bus without `trace` does not carry it.
+## Attach a tracer
 
-```ts
+Pass `trace` to `createBus`. Make it with `createTracer` from `nanoeffects/trace`, which takes a logger (a function) or an array of them. The tracing code lives in that entry, so a bus without `trace` does not carry it.
+
+```js
 import { createBus } from "nanoeffects";
 import { createTracer } from "nanoeffects/trace";
 
-const bus = createBus<Events>({
+const bus = createBus({
+  // createTracer — observe every task phase
   trace: createTracer((event) => console.log(event)),
 });
 ```
 
 Each `TraceEvent` has:
 
-| Field     | Meaning                                                              |
-| --------- | -------------------------------------------------------------------- |
-| `id`      | Unique task id within the bus.                                       |
-| `parent`  | Id of the task that started this one (absent for handler tasks).     |
-| `type`    | Event type the task works on.                                        |
-| `effect`  | `latest`, `debounce`, `throttle`, `leading`, `run`, `all` or `race`. |
-| `phase`   | `start`, `done`, `error`, `cancel` or `drop`.                        |
-| `payload` | Event payload.                                                       |
-| `error`   | Thrown value, only for `error`.                                      |
+| Field | Meaning |
+| ----- | ------- |
+| `id` | Unique task id within the bus |
+| `parent` | Id of the task that started this one (absent for handler tasks) |
+| `type` | Event type the task works on |
+| `effect` | `latest`, `debounce`, `throttle`, `leading`, `run`, `all`, `race`, … |
+| `phase` | `start`, `done`, `error`, `cancel`, or `drop` |
+| `payload` | Event payload |
+| `error` | Thrown value, only for `error` |
 
 Phases:
 
-- `start`: the work began.
-- `done` / `error`: it finished or threw.
-- `cancel`: it was aborted after it started (superseded by `latest`, parent aborted, lost a `race`).
-- `drop`: it never started (`leading` while busy, a `throttle` call replaced by a newer one, a `debounce` call replaced before its delay ended).
+- `start` — the work began.
+- `done` / `error` — it finished or threw.
+- `cancel` — aborted after it started (superseded by `latest`, parent aborted, lost a `race`).
+- `drop` — never started (`leading` while busy, a `throttle` call replaced by a newer one, a `debounce` call replaced before its delay ended).
 
-`all` and `race` are traced when you pass them the handler `ctx`: the group is one task, every starter is a child `run` task.
+`all` and `race` are traced when you pass them the handler `ctx`: the group is one task; every starter is a child `run` task.
+
+```js
+import { createBus } from "nanoeffects";
+import { all } from "nanoeffects/effects";
+
+const bus = createBus();
 
-```ts
 bus.on("load", async (id, ctx) => {
-  await all(ctx, { user: () => fetchUser(id), posts: () => fetchPosts(id) });
+  await all(ctx, {
+    user: () => fetchUser(id),
+    posts: () => fetchPosts(id),
+  });
 });
 ```
 
-## Loggers
+## Use built-in loggers
 
-A logger is a function `(event: TraceEvent) => void` (the `TraceLogger` type). `createTracer` takes one logger or an array; a logger that throws is reported to `console.error` and never breaks the task or the other loggers.
+A logger is `(event) => void`. `createTracer` takes one logger or an array. A logger that throws is reported to `console.error` and never breaks the task or the other loggers.
 
-```ts
+```js
 import { createBus } from "nanoeffects";
 import { consoleLogger, createTracer, reduxDevtools } from "nanoeffects/trace";
 
-const bus = createBus<Events>({
+const bus = createBus({
   trace: createTracer([reduxDevtools({ name: "app" }), consoleLogger()]),
 });
 ```
 
-`nanoeffects/trace` ships `createTracer` and these loggers, each a factory that returns a `TraceLogger`:
-
-| Logger                  | What it does                                                                         |
-| ----------------------- | ------------------------------------------------------------------------------------ |
-| `reduxDevtools()`       | Sends tasks to Redux DevTools as `type/effect/phase`; state is `{ running }`.        |
-| `consoleLogger()`       | Prints one line per phase, indented by task depth.                                   |
-| `performanceLogger()`   | Records User Timing measures for the Timings track of the browser Performance panel. |
-| `createTraceRecorder()` | Keeps events in `recorder.events`, for tests.                                        |
+| Logger | What it does |
+| ------ | ------------ |
+| `reduxDevtools()` | Sends tasks to Redux DevTools as `type/effect/phase`; state is `{ running }` |
+| `consoleLogger()` | Prints one line per phase, indented by task depth |
+| `performanceLogger()` | User Timing measures for the browser Performance panel |
+| `createTraceRecorder()` | Keeps events in `recorder.events`, for tests |
 
-### Production: filter and sampling
+### Cut volume in production
 
-`createTracer(loggers, options)` can cut the volume:
+```js
+import { createTracer } from "nanoeffects/trace";
 
-```ts
 createTracer(logger, {
-  sample: 0.05, // trace 5% of the handler calls (a share, or a function of { type, payload })
-  filter: (event) => event.phase === "error", // and keep only failures
+  sample: 0.05, // trace 5% of handler calls (share, or function of { type, payload })
+  filter: (event) => event.phase === "error", // keep only failures
 });
 ```
 
-- `sample` is decided once per root task (one handler call) and every task below it follows, so a trace is never cut in the middle. Tasks that are not sampled cost almost nothing: their effects run without tracing.
+- `sample` is decided once per root task; every task below it follows, so a trace is never cut in the middle. Unsampled tasks cost almost nothing.
 - `filter` runs on each event before any logger sees it.
 
-Notes on `reduxDevtools`: it is read-only (the bus owns no state, so there is no time travel) and does nothing when the extension is not installed. It has its own instance in the DevTools picker, apart from your store.
+### Configure Redux DevTools
 
-It is quiet by default, so the log stays readable:
+Read-only (the bus owns no state, so there is no time travel). Does nothing when the extension is not installed. Has its own instance in the DevTools picker, apart from your store.
 
-- **A task is one action**, sent when it ends (`done`, `error`, `cancel`, `drop`). The tasks that are running are in the state, `{ running }`. `starts: true` also sends every start.
-- **Only the top is shown**: the handler tasks and the effects they start (`retry`, `timeout`, ...). The attempts and starters under them are hidden. `depth: 0` shows the handler tasks only, `depth: 3` more, `Infinity` everything.
-- `maxAge: 200` sets how many actions DevTools keeps (its own default is 50).
+Quiet by default:
+
+- **A task is one action**, sent when it ends (`done`, `error`, `cancel`, `drop`). Running tasks are in `{ running }`. `starts: true` also sends every start.
+- **Only the top is shown**: handler tasks and the effects they start. Attempts and starters under them are hidden. `depth: 0` — handlers only; `depth: 3` — more; `Infinity` — everything.
+- `maxAge: 200` — how many actions DevTools keeps (its default is 50).
+
+```js
+import { reduxDevtools } from "nanoeffects/trace";
 
-```ts
 reduxDevtools({ name: "app", depth: 0 }); // one line per handler call
-reduxDevtools({ name: "app", starts: true, depth: Infinity }); // everything, for a hunt for a bug
+reduxDevtools({ name: "app", starts: true, depth: Infinity }); // everything
 ```
 
-For more control, `createTracer(logger, { filter, sample })` cuts events before any logger sees them.
-
-To write your own, return a `TraceLogger`:
+### Write your own logger
 
 ```ts
 import type { TraceLogger } from "nanoeffects";
 
 const errorsOnly = (): TraceLogger => (event) => {
-  if (event.phase === "error") report(event.error);
+  if (event.phase === "error") {
+    report(event.error);
+  }
 };
 ```
 
-## Removing tracing from a build
+## Drop tracing from a build
 
-Without a tracer the hooks cost almost nothing (a lookup that finds no tracer), and `nanoeffects/trace` is a separate entry that is only bundled when imported. To also drop the tracing code from the core, use the `notrace` export condition: the package ships a second build of `index`, `effects`, `policies` and `actions` made with `__NANOEFFECTS_TRACE__` set to `false`, so the bundler removes the tracer calls.
+Without a tracer the hooks cost almost nothing. `nanoeffects/trace` is only bundled when imported.
 
-```ts
+To also drop tracing code from the core, use the `notrace` export condition. The package ships a second build of `index`, `effects`, `policies`, and `actions` with `__NANOEFFECTS_TRACE__` set to `false`.
+
+```js
 // vite / rolldown
 resolve: { conditions: ["notrace"] }
 // webpack
@@ -114,4 +129,4 @@ resolve: { conditionNames: ["notrace", "import", "..."] }
 conditions: ["notrace"]
 ```
 
-In a build of your own from the sources, `define: { __NANOEFFECTS_TRACE__: "false" }` does the same. With the condition set, the types of that build have no `trace` option: `createBus({ trace })` is a type error, so tracing cannot be left on by mistake (`scripts/notrace-types.mjs` makes `BusOptions.trace` `never` there). `nanoeffects/trace` has no `notrace` build. The saving is about 0.4 kB gzip of the whole library.
+In a build from the sources, `define: { __NANOEFFECTS_TRACE__: "false" }` does the same. With the condition set, that build’s types have no `trace` option: `createBus({ trace })` is a type error. `nanoeffects/trace` has no `notrace` build. The saving is about 0.4 kB gzip of the whole library.

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "nanoeffects",
-	"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.",
+	"version": "0.4.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.3 kB gzip.",
 	"keywords": [
 		"event-bus",
 		"event-emitter",
@@ -121,6 +121,7 @@
 		"@reduxjs/toolkit": "^2.13.0",
 		"@size-limit/esbuild": "^14.2.0",
 		"@size-limit/file": "^14.2.0",
+		"archunit": "^2.5.4",
 		"jotai": "^3.0.1",
 		"lefthook": "2.2.1",
 		"lodash": "4.17.21",
@@ -144,7 +145,7 @@
 			"name": "createBus",
 			"path": "dist/index.js",
 			"import": "{ createBus }",
-			"limit": "1.2 kB"
+			"limit": "1.3 kB"
 		},
 		{
 			"name": "policies (all)",
@@ -164,7 +165,7 @@
 		{
 			"name": "redux",
 			"path": "dist/redux.js",
-			"limit": "1.5 kB"
+			"limit": "1.55 kB"
 		},
 		{
 			"name": "observable",

package/dist/bus-CRnlwmQ4.js

@@ -1 +0,0 @@
-import{n as e}from"./onAbort-BgMfspK4.js";import{a as t,n,r}from"./context-DlA80GOA.js";import{n as i}from"./promise-CSLpzwSR.js";import{n as a,t as o}from"./event-0RIBGYqS.js";const s=`*`,c=()=>{let e={},t=/* @__PURE__ */ new WeakSet,n=n=>{let r=e[n]??[];if(!t.has(r))return e[n]=r,r;let i=[...r];return e[n]=i,i},r=(t,r)=>{if(!r){e[t]=[];return}let i=(e[t]??[]).indexOf(r);i>=0&&n(t).splice(i,1)};return{get:n=>{let r=e[n]??[];return t.add(r),r},add:(e,t)=>(n(e).push(t),()=>{r(e,t)}),remove:r}},l=(e,t,n)=>Reflect.apply(e,null,[t,n]),u=(s={})=>{let u=c(),d=(e,t)=>u.add(o(e),t),f=(e,t)=>u.remove(o(e),t),p=(t,a)=>{let{onError:o}=s,{ctx:c}=n({event:a,bus:m,tracer:s.trace,parent:{ref:r()}});if(!o){t(a.payload,c);return}let l=t=>{try{o(t,a)}catch(t){e(`onError failed`,t)}};try{let e=t(a.payload,c);i(e)&&Promise.resolve(e).catch(l)}catch(e){l(e)}},m={on:d,off:f,emit:(e,i)=>{let c=o(e),d=a(e,i),f={type:c,payload:d},h=[...u.get(c),...u.get(`*`)];h.length===0&&typeof e!=`function`&&s.onUnhandled?.(f);for(let e of h)p(e,f);if(typeof e==`function`){let{ctx:i}=n({event:f,bus:m,tracer:s.trace,parent:{ref:r()}}),a=m.commands?.run??l;return t(i,`command`,()=>a(e,d,i))}},use:e=>e(m),context:s.context,trace:s.trace};return m};export{s as n,u as t};

package/dist/notrace/bus-Dx0l9X6h.js

@@ -1 +0,0 @@
-import{a as e,c as t,n,r}from"./context-yAWj0BFZ.js";import{n as i}from"./promise-CSLpzwSR.js";import{n as a,t as o}from"./event-0RIBGYqS.js";const s=`*`,c=()=>{let e={},t=/* @__PURE__ */ new WeakSet,n=n=>{let r=e[n]??[];if(!t.has(r))return e[n]=r,r;let i=[...r];return e[n]=i,i},r=(t,r)=>{if(!r){e[t]=[];return}let i=(e[t]??[]).indexOf(r);i>=0&&n(t).splice(i,1)};return{get:n=>{let r=e[n]??[];return t.add(r),r},add:(e,t)=>(n(e).push(t),()=>{r(e,t)}),remove:r}},l=(e,t,n)=>Reflect.apply(e,null,[t,n]),u=(s={})=>{let u=c(),d=(e,t)=>u.add(o(e),t),f=(e,t)=>u.remove(o(e),t),p=(e,a)=>{let{onError:o}=s,{ctx:c}=n({event:a,bus:m,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)}},m={on:d,off:f,emit:(t,i)=>{let c=o(t),d=a(t,i),f={type:c,payload:d},h=[...u.get(c),...u.get(`*`)];h.length===0&&typeof t!=`function`&&s.onUnhandled?.(f);for(let e of h)p(e,f);if(typeof t==`function`){let{ctx:i}=n({event:f,bus:m,tracer:s.trace,parent:{ref:r()}}),a=m.commands?.run??l;return e(i,`command`,()=>a(t,d,i))}},use:e=>e(m),context:s.context,trace:s.trace};return m};export{s as n,u as t};

package/dist/notrace/event-0RIBGYqS.js

@@ -1 +0,0 @@
-const e=e=>typeof e==`string`?e:e.type,t=(e,t)=>typeof e==`object`?e.payload:t;export{t as n,e as t};