nanoeffects 0.0.0-stage → 0.1.0

package/docs/effects.md

@@ -0,0 +1,119 @@
+# Effects and cancellation
+
+An abort only raises a flag: your code decides to stop. `nanoeffects/effects` has helpers for the usual cases.
+
+`delay(ctx, ms)` waits and rejects on abort (`ms` can be a function). `cancellable(ctx, executor)` is a promise tied to the task signal; it works like `new Promise`, but the executor gets one object, `{ resolve, reject, onCancel }`, with `onCancel` for cleanups:
+
+```ts
+import { cancellable } from "nanoeffects/effects";
+
+bus.on(
+	"wait",
+	latest((_, ctx) =>
+		cancellable(ctx, ({ resolve, onCancel }) => {
+			const timer = setTimeout(resolve, 5000);
+			onCancel(() => clearTimeout(timer));
+		}),
+	),
+);
+```
+
+- If the task aborts before the promise settles, cleanups run (last registered first) and the promise rejects with the abort reason.
+- If the task is already aborted, the executor does not run.
+- After the promise settles, the abort listener is removed and cleanups are dropped.
+
+`onAbort(ctx, fn)` runs `fn(reason)` on abort (at once if already aborted) and returns a function that unsubscribes:
+
+```ts
+import { onAbort } from "nanoeffects/effects";
+
+bus.on("connect", (url, ctx) => {
+	const socket = new WebSocket(url);
+	onAbort(ctx, () => socket.close());
+});
+```
+
+## allSettled
+
+`allSettled(ctx, effects)` is `all` that waits for every starter and never fails because of one: each result is `{ status: "fulfilled", value }` or `{ status: "rejected", reason }`, in the shape of the input (object or array). Nothing is cancelled when a starter fails. Only an abort of `ctx` rejects it.
+
+```ts
+const { user, posts } = await allSettled(ctx, {
+	user: ({ signal }) => fetchUser(id, { signal }),
+	posts: ({ signal }) => fetchPosts(id, { signal }),
+});
+
+if (user.status === "fulfilled") render(user.value);
+```
+
+## Subscribing from a task: ctx.on, ctx.off, take
+
+A task context has `on` and `off`, like the bus. A subscription made with `ctx.on` ends when the task aborts, so it cannot outlive the work that needed it:
+
+```ts
+bus.on("watch", (_, ctx) => {
+	ctx.on("tick", (n) => console.log(n)); // gone when this task aborts
+});
+```
+
+- The returned function unsubscribes sooner. After the task is aborted, `ctx.on` does nothing.
+- A policy passes its handler a child context, so under `latest` the subscriptions of a superseded run end with it.
+- `ctx.off` is the bus `off`: `ctx.off(event)` clears every handler of the event, not only the task's.
+
+`take(ctx, event, options?)` waits for the next `event` and resolves with its payload:
+
+```ts
+import { take, timeout } from "nanoeffects/effects";
+
+bus.on("login", async (user, ctx) => {
+	const reason = await take(ctx, "logout"); // resolves on the next logout
+	cleanup(user, reason);
+
+	// wait for a matching event, but not longer than 5 s
+	const id = await timeout(ctx, 5000, ({ signal }) =>
+		take(ctx, "saved", { signal, predicate: (id) => id === draft.id }),
+	);
+});
+```
+
+- It sees only events emitted after the call, takes one, and unsubscribes.
+- `options.predicate` skips payloads it rejects; `options.signal` stops the wait, which is how a `race` or `timeout` starter cancels it.
+- On abort of the task or of `options.signal` it unsubscribes and rejects with the abort reason. It is traced as a `take` group.
+
+## retry, timeout, poll
+
+```ts
+import { poll, retry, timeout } from "nanoeffects/effects";
+
+bus.on("load", async (id, ctx) => {
+	// up to 4 attempts, backoff between them; stops when the task aborts
+	const user = await retry(ctx, () => fetchUser(id, { signal: ctx.signal }), {
+		times: 4,
+		delay: (attempt) => 2 ** attempt * 100,
+		shouldRetry: (error) => !isFatal(error),
+	});
+
+	// aborts the starter's signal and rejects with a TimeoutError after 5 s
+	const data = await timeout(ctx, 5000, ({ signal }) => fetchData(id, { signal }));
+
+	// calls refresh every 10 s; resolves when the task aborts
+	await poll(ctx, () => refresh(), 10_000);
+});
+```
+
+- `retry`: `times` is the total number of attempts (default 3), `delay` is a number or `(attempt, error) => ms`, `shouldRetry(error, attempt)` can stop early. `fn` gets the attempt number, starting at 1. On abort it rejects with the abort reason.
+- `timeout`: the error is a `DOMException` named `TimeoutError`, like `AbortSignal.timeout`. It rejects even if the starter ignores its signal.
+- `poll`: like patronum `interval`. The first call comes after `ms` (`leading: true` also calls at once), and the next ticks keep a steady rate whatever the duration of `fn`, so a slow `fn` can overlap with the next call; `waitForFn: true` starts each pause when the call ends instead, so calls never overlap. `fn` gets the call number from 0. An error from `fn` stops polling and rejects; an abort ends it normally and clears the timer.
+- A pause can be a function wherever a time is given, for backoff or jitter: `retry`'s `delay` gets `(attempt, error)`, `poll`'s `ms` gets the number of the call the pause leads to, and `delay` itself takes a function called once when it starts:
+
+```ts
+retry(ctx, load, { times: 5, delay: (attempt) => 2 ** attempt * 100 }); // 200, 400, 800, ...
+poll(ctx, refresh, (call) => Math.min(1000 * 2 ** call, 60_000)); // slows down to once a minute
+await delay(ctx, () => 200 + Math.random() * 200); // 200 to 400 ms
+```
+
+- All three are traced: the effect is a group (`retry`, `timeout`, `poll`) and each attempt or call is a `run` child.
+
+In every effect `ctx` is the first argument: `delay(ctx, ms)`, `all(ctx, effects)`, `allSettled(ctx, effects)`, `race(ctx, effects)`, `cancellable(ctx, executor)`, `onAbort(ctx, fn)`, `retry(ctx, fn, options)`, `timeout(ctx, ms, starter)`, `poll(ctx, fn, ms, options)`, `take(ctx, event, options)`. It is required; outside a task pass `{}` or any object with a `signal`.
+
+For `fetch` and other APIs that take a signal, pass `ctx.signal`. A timeout without `race`: `AbortSignal.any([ctx.signal, AbortSignal.timeout(5000)])`.

package/docs/errors.md

@@ -0,0 +1,23 @@
+# Errors and unheard events
+
+`emit` is a plain loop over the handlers, like in nanoevents: if a handler throws, the remaining handlers are skipped and the error reaches the caller of `emit`. A rejected promise of an async handler is left unhandled.
+
+Pass `onError` to isolate handlers instead. Then every handler runs, and thrown errors and rejections of async handlers (including ones wrapped in `latest`, `debounce` and the like) go to `onError`; an `onError` that throws is logged to `console.error`.
+
+```ts
+const bus = createBus<Events>({
+	onError: (error, { type, payload }) => report(error, type, payload),
+});
+```
+
+## Events that nobody listens to
+
+A typo in an event name, `emit("serch")`, does nothing and says nothing. `onUnhandled` is called when an event is emitted and nobody listens to it (a listener of every event, `"*"`, counts). It is not called for commands, which always have a handler to run. Use it as a warning in development:
+
+```ts
+const bus = createBus<Events>({
+	onUnhandled: import.meta.env.DEV
+		? ({ type }) => console.warn(`Nobody listens to "${type}"`)
+		: void 0,
+});
+```

package/docs/hmr.md

@@ -0,0 +1,74 @@
+# Hot reload (HMR)
+
+When a file is edited in development, the bundler loads its new version and runs it again, while the page and the rest of the code stay alive. For a bus that means three things can go wrong:
+
+1. **Handlers pile up.** The file that calls `bus.on(...)` runs again, and the old handlers are still subscribed: every event is handled twice, then three times.
+2. **The bus is made again.** A file that has `createBus()` runs again: the new bus has none of the subscriptions of the files that did not reload.
+3. **Old work goes on.** Tasks that the old code started keep running with the old logic.
+
+Tasks that are tied to a signal can be ended, and modules are the unit that does it, so the answer is modules.
+
+## Modules are replaced by name
+
+Mounting a module whose name is taken replaces the mounted one: the old module is unmounted first, and with it its subscriptions, its bound commands, its sub-modules and its background tasks (their signals abort). So the new version of a module file only has to mount again.
+
+```ts
+// bus.ts: made once, kept across reloads
+import { createBus } from "nanoeffects";
+import { registerModules } from "nanoeffects/actions";
+
+const hot = import.meta.hot;
+
+export const bus: Bus<Events> = hot?.data.bus ?? createBus<Events>();
+export const app: ModuleApi<Events> = hot?.data.app ?? registerModules(bus);
+if (hot) {
+	hot.data.bus = bus;
+	hot.data.app = app;
+}
+```
+
+On the first run `hot.data` is empty and the bus and the app are made; on a reload the same ones are taken back. The same code is in `examples/hmr.ts`, which is type-checked with the rest of the project.
+
+```ts
+// user.module.ts: the module, and nothing else
+export const userModule = createModule<Events>("user", (m) => {
+	m.handle(getUser, fetchUser);
+	m.on("login", latest(loadProfile));
+});
+```
+
+```ts
+// main.ts: mounts the modules, and takes the new version of a module on reload
+import { app } from "./bus";
+import { userModule } from "./user.module";
+
+app.mount(userModule);
+
+// replaces the old "user" module with the new version
+import.meta.hot?.accept("./user.module", (next) => next && app.mount(next.userModule));
+```
+
+Vite calls the callback with the new version of `./user.module`, `main.ts` stays alive, and `app.mount` swaps the module. With webpack, `module.hot.accept("./user.module", () => app.mount(require("./user.module").userModule))` does the same.
+
+## What to keep in mind
+
+- **Keep the bus and the app in `import.meta.hot.data`** (or in a file that never reloads), as above. Otherwise a reload of that file makes a new bus, and the modules that did not reload talk to the old one.
+- **Names must be unique.** The name is what says "this is the new version of that module", so two different modules with one name replace each other. The name is also the type of the module's tasks in the trace.
+- **Pass `signal` to what the module does.** An unmount aborts the tasks, but a `fetch` or a loop that ignores `ctx.signal` runs on. This is the same advice as everywhere else, and in development it also stops old code from writing to the new state.
+- **Sub-modules** (`m.use(...)`) are replaced by name inside their parent. A reload of the parent module replaces it with all its children.
+
+## Handlers without modules
+
+A plain `bus.on` returns the function that unsubscribes. Give it to the dispose hook of the file:
+
+```ts
+if (import.meta.hot) {
+	import.meta.hot.dispose(bus.on("search", latest(runSearch)));
+}
+```
+
+Several: `import.meta.hot.dispose(() => { off1(); off2(); })`. Handlers inside modules do not need this.
+
+## Redux and stores
+
+With `createEffectsMiddleware`, keep the effects object in `import.meta.hot.data` as well, so the store keeps the same middleware, and register the effects in modules. For a new reducer use `store.replaceReducer(...)` as usual. A store of Zustand or MobX that lives in its own file and is passed in `context` can keep its state across reloads with the means of that library.

package/docs/observable.md

@@ -0,0 +1,22 @@
+# Observable: events as streams
+
+`createObserve(bus)` from `nanoeffects/observable` turns an event of the bus into an Observable that follows the TC39 proposal (`subscribe`, `unsubscribe`, `Symbol.observable`). RxJS and other stream libraries take it as it is, and nothing here depends on them.
+
+```ts
+import { from } from "rxjs";
+import { debounceTime, distinctUntilChanged, switchMap } from "rxjs/operators";
+import { createObserve } from "nanoeffects/observable";
+
+const observe = createObserve(bus);
+
+// events of the bus as a stream
+from(observe("typed"))
+  .pipe(debounceTime(300), distinctUntilChanged(), switchMap(searchRequest))
+  .subscribe((items) => bus.emit("results", items));
+```
+
+- `observe(event)` returns an Observable of the payloads of that event. Each `subscribe` is a `bus.on` of its own, and `unsubscribe()` removes it.
+- `subscribe` takes a function or an object with `next`.
+- The stream never completes and never fails: events are the only thing that arrives. Errors of the handler of the subscriber belong to the subscriber.
+- A subscription made this way is not tied to a task, so end it yourself: `onAbort(ctx, subscription.unsubscribe)` inside a task, or with the signal of a module.
+- For cancellation, policies and tracing keep to `bus.on` with `latest`, `debounce`, `queue`: they know about tasks. The Observable is for the places where a stream is already the way you work.

package/docs/policies.md

@@ -0,0 +1,53 @@
+# 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.
+
+| 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                                                |
+
+`debounce` and `throttle` take `leading` and `trailing`:
+
+- `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.
+
+`key` gives each key its own state, so calls with different keys do not affect each other:
+
+```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 }));
+```
+
+The state of a key is dropped when that key goes idle, so keys can be unbounded (ids, urls).
+
+## Queue
+
+`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:
+
+```ts
+import { queue } from "nanoeffects/policies";
+
+bus.on(
+	"save",
+	queue(async (draft, { signal }) => {
+		await api.save(draft, { signal });
+	}),
+);
+
+bus.emit("save", a); // runs now
+bus.emit("save", b); // waits for a, 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.

package/docs/semantics.md

@@ -0,0 +1,7 @@
+# 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.
+- **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.
+- **Effects start their function synchronously**, so an event emitted right after the call reaches a `take` inside it.

package/docs/stores.md

@@ -0,0 +1,50 @@
+# Redux, Zustand, MobX
+
+## Redux
+
+`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`).
+
+```ts
+type Events = { userRequested: string } & WithContext<{ store: ReduxStoreApi<RootState> }>;
+
+const effects = createEffectsMiddleware<Events>();
+
+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 })));
+}));
+```
+
+It looks after what is easy to get wrong:
+
+- **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.
+
+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.
+
+```ts
+// Zustand
+const stop = store.subscribe((state, previous) => {
+  if (state.user !== previous.user) bus.emit(userChanged, state.user);
+});
+
+// MobX
+const stop = reaction(() => store.user, (user) => bus.emit(userChanged, user));
+
+bus.on(userChanged, latest((user, { signal }) => 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.

package/docs/tracing.md

@@ -0,0 +1,104 @@
+# Tracing
+
+## Tracing
+
+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.
+
+```ts
+import { createBus } from "nanoeffects";
+import { createTracer } from "nanoeffects/trace";
+
+const bus = createBus<Events>({
+	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`.                                      |
+
+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).
+
+`all` and `race` are traced when you pass them the handler `ctx`: the group is one task, every starter is a child `run` task.
+
+```ts
+bus.on("load", async (id, ctx) => {
+	await all(ctx, { user: () => fetchUser(id), posts: () => fetchPosts(id) });
+});
+```
+
+## 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.
+
+```ts
+import { createBus } from "nanoeffects";
+import { consoleLogger, createTracer, reduxDevtools } from "nanoeffects/trace";
+
+const bus = createBus<Events>({
+	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 each phase 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.                                        |
+
+### Production: filter and sampling
+
+`createTracer(loggers, options)` can cut the volume:
+
+```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` 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.
+- `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.
+
+To write your own, return a `TraceLogger`:
+
+```ts
+import type { TraceLogger } from "nanoeffects";
+
+const errorsOnly = (): TraceLogger => (event) => {
+	if (event.phase === "error") report(event.error);
+};
+```
+
+## Removing 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.
+
+```ts
+// vite / rolldown
+resolve: { conditions: ["notrace"] }
+// webpack
+resolve: { conditionNames: ["notrace", "import", "..."] }
+// esbuild
+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.

package/package.json

@@ -1,6 +1,165 @@
 {
-  "name": "nanoeffects",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+	"name": "nanoeffects",
+	"version": "0.1.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",
+		"event-emitter",
+		"effects",
+		"abort-signal",
+		"abortcontroller",
+		"debounce",
+		"throttle",
+		"queue",
+		"retry",
+		"side-effects",
+		"typescript"
+	],
+	"license": "MIT",
+	"author": "Vladimir Yazykov <neizerth@gmail.com>",
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/nanoeffects/nanoeffects.git"
+	},
+	"bugs": {
+		"url": "https://github.com/nanoeffects/nanoeffects/issues"
+	},
+	"homepage": "https://github.com/nanoeffects/nanoeffects#readme",
+	"engines": {
+		"node": ">=18"
+	},
+	"type": "module",
+	"packageManager": "pnpm@11.13.0",
+	"sideEffects": false,
+	"files": [
+		"dist",
+		"README.md",
+		"LICENSE",
+		"docs"
+	],
+	"module": "./dist/index.js",
+	"types": "./dist/index.d.ts",
+	"exports": {
+		".": {
+			"notrace": {
+				"types": "./dist/notrace/index.d.ts",
+				"default": "./dist/notrace/index.js"
+			},
+			"types": "./dist/index.d.ts",
+			"import": "./dist/index.js"
+		},
+		"./effects": {
+			"notrace": {
+				"types": "./dist/notrace/effects.d.ts",
+				"default": "./dist/notrace/effects.js"
+			},
+			"types": "./dist/effects.d.ts",
+			"import": "./dist/effects.js"
+		},
+		"./policies": {
+			"notrace": {
+				"types": "./dist/notrace/policies.d.ts",
+				"default": "./dist/notrace/policies.js"
+			},
+			"types": "./dist/policies.d.ts",
+			"import": "./dist/policies.js"
+		},
+		"./actions": {
+			"notrace": {
+				"types": "./dist/notrace/actions.d.ts",
+				"default": "./dist/notrace/actions.js"
+			},
+			"types": "./dist/actions.d.ts",
+			"import": "./dist/actions.js"
+		},
+		"./trace": {
+			"types": "./dist/trace.d.ts",
+			"import": "./dist/trace.js"
+		},
+		"./redux": {
+			"notrace": {
+				"types": "./dist/notrace/redux.d.ts",
+				"default": "./dist/notrace/redux.js"
+			},
+			"types": "./dist/redux.d.ts",
+			"import": "./dist/redux.js"
+		},
+		"./observable": {
+			"types": "./dist/observable.d.ts",
+			"import": "./dist/observable.js"
+		}
+	},
+	"scripts": {
+		"build": "tsdown && node scripts/notrace-types.mjs",
+		"prepublishOnly": "pnpm build",
+		"check": "biome check ./src ./examples ./integration",
+		"format": "npx @biomejs/biome check --write --unsafe ./src ./examples ./integration",
+		"tsgo": "tsc --noEmit",
+		"test": "vitest run",
+		"test:watch": "vitest",
+		"prepare": "lefthook install",
+		"lint:package": "publint && attw --pack . --profile esm-only",
+		"size": "size-limit",
+		"verify": "pnpm tsgo && pnpm check && pnpm test && pnpm build && pnpm test:integration && pnpm lint:package && pnpm size",
+		"test:integration": "vitest run --config vitest.integration.config.ts"
+	},
+	"devDependencies": {
+		"@arethetypeswrong/cli": "^0.18.5",
+		"@biomejs/biome": "2.5.15",
+		"@commitlint/cli": "21.2.3",
+		"@commitlint/config-conventional": "21.2.3",
+		"@reduxjs/toolkit": "^2.13.0",
+		"@size-limit/esbuild": "^14.2.0",
+		"@size-limit/file": "^14.2.0",
+		"jotai": "^3.0.1",
+		"lefthook": "2.2.1",
+		"lodash": "4.17.21",
+		"mobx": "^7.0.6",
+		"publint": "^0.3.25",
+		"redux": "^5.0.1",
+		"size-limit": "^14.2.0",
+		"tsdown": "0.23.1",
+		"typescript": "7.0.2",
+		"unplugin-unused": "^0.6.0",
+		"vite": "^8.3.4",
+		"vitest": "5.0.5",
+		"webpack": "^5.112.0",
+		"zustand": "^5.0.15"
+	},
+	"publishConfig": {
+		"access": "public"
+	},
+	"size-limit": [
+		{
+			"name": "createBus",
+			"path": "dist/index.js",
+			"import": "{ createBus }",
+			"limit": "1.2 kB"
+		},
+		{
+			"name": "policies (all)",
+			"path": "dist/policies.js",
+			"limit": "2.6 kB"
+		},
+		{
+			"name": "effects (all)",
+			"path": "dist/effects.js",
+			"limit": "2.3 kB"
+		},
+		{
+			"name": "actions (all)",
+			"path": "dist/actions.js",
+			"limit": "1.8 kB"
+		},
+		{
+			"name": "redux",
+			"path": "dist/redux.js",
+			"limit": "1.5 kB"
+		},
+		{
+			"name": "observable",
+			"path": "dist/observable.js",
+			"limit": "0.5 kB"
+		}
+	]
+}