nanoeffects 0.31.2 → 0.32.0

package/llms-full.txt

@@ -581,6 +581,7 @@ Each task below starts with the problem, then a short solution. Where the page h
   - [Do not leave subscriptions after a widget closes](#do-not-leave-subscriptions-after-a-widget-closes)
 - [Stop work on a server](#stop-work-on-a-server)
 - [Debugging: what ran and why](#debugging-what-ran-and-why)
+- [Test a policy with fake timers](#test-a-policy-with-fake-timers)
 - [Other libraries in the project](#other-libraries-in-the-project)
 - [Classes and TypeScript](#classes-and-typescript)
   - [Use the bus in a class](#use-the-bus-in-a-class)
@@ -1032,6 +1033,40 @@ bus.emit("search", "nano"); // the log shows: search · emit, then results · em
 
 More: [Trace tasks](tracing.md). To reload modules without a page refresh, see [Hot reload](hmr.md).
 
+## Test a policy with fake timers
+
+A test of `latest` or `debounce` is full of `advanceTimersByTime` numbers, and nobody can tell from them what the test proves. Write the emits and the phases as diagrams instead.
+
+```js
+import { it, vi } from "vitest";
+import { latest } from "nanoeffects/policies";
+import { createMarbleBus, fakeTimersClock } from "nanoeffects/testing";
+
+// a search that takes 50 ms
+function search(query) {
+  return new Promise((resolve) => setTimeout(resolve, 50));
+}
+
+it("latest cancels the search that is running", async () => {
+  vi.useFakeTimers();
+
+  // createMarbleBus: a bus that records its trace; a frame is 10 ms
+  const marbles = createMarbleBus({ clock: fakeTimersClock(vi) });
+  marbles.bus.on("search/changed", latest(search), { traceId: "search" });
+
+  // "a-b": two emits, at frame 0 and frame 2
+  const result = await marbles.run({
+    emits: { "search/changed": { marble: "a-b" } },
+    frames: 12,
+  });
+
+  // s start, c cancel, d done
+  result.expect({ "search/changed:latest": "s-(cs)----d----" });
+});
+```
+
+More: [Test time with diagrams](testing.md).
+
 ## Other libraries in the project
 
 - **Redux Toolkit, Zustand, MobX or Pinia.** [Connect a store](stores.md).
@@ -1287,6 +1322,7 @@ Each row is optional. The "when" column says what need brings you to it.
 | `nanoeffects/vue` | `vuePlugin`: adds `watchEmitter` and `useEventRef` to a bus (needs Vue 3.3 or newer) | Vue components |
 | `nanoeffects/dev` | `devPlugin` (no-op in production), `getLostSignalsCount` and `getLostSignals` for tests | you look for leaks and lost signals in development and in tests |
 | `nanoeffects/trace` | `createTracer`, the loggers (`graphLogger` finds event loops) and `tracePlugin` (names for the trace) | you want to see what ran and why |
+| `nanoeffects/testing` | `createMarbleBus`, `fakeTimersClock`: a bus for tests, with emits and phases as diagrams | you test `latest`, `debounce`, `queue`, `retry` or `timeout` with fake timers |
 | `nanoeffects/guard` | `loopGuardPlugin`: refuses the emit that would pass a limit of a chain | a loop must not take the app down |
 
 The `...Plugin` names above are used with `bus.use`. [Plugins](plugins.md) lists all of them, what each returns, and the order to use them in.
@@ -7317,7 +7353,7 @@ The subscription is not tied to a task. Call `subscription.unsubscribe()` when t
 - **Abort replaces unsubscribe for work in flight.** A stopped task is stopped through its `signal`. Pass it to `fetch` or to the client.
 - **Errors are not part of the stream.** A failed task rejects its own promise. Without `onError` on the bus nobody else hears it ([Errors](errors.md)).
 - **No completion.** An event bus does not end. A task ends when its work ends or its signal aborts.
-- **No marble tests.** Test with the real handler and fake timers.
+- **Marble tests are a smaller tool.** [`createMarbleBus`](testing.md) writes the emits and the phases of tasks as diagrams on fake timers. It has no hot or cold sources and no `|`.
 
 ---
 Source: docs/semantics.md
@@ -7695,6 +7731,102 @@ test("a newer search stops the older one at every step", async () => {
 - **A handler that never emits.** `devPlugin` sees a lost signal by an emit after the cancel; a handler that only writes elsewhere is seen by the linter alone.
 - **Shadowed names.** The rule uses no scope analysis, so an inner variable named `signal` can hide a lost signal.
 
+---
+Source: docs/testing.md
+
+# Test time with diagrams
+
+> **Level B.** Read first: [Policies](policies.md).
+
+A test of `latest`, `debounce`, `queue`, `retry` or `timeout` is a test of time. With fake timers the time hides in numbers (`advanceTimersByTime(30)`), and you check a list of calls by hand. This page shows how to write the schedule and the expectation as two short diagrams, as RxJS marble tests do.
+
+You need a test runner with fake timers (Vitest or Jest). The helper does not import one.
+
+## Test a policy with a diagram
+
+**Problem.** You want a test that says: a second search cancels the first one, and only the second finishes.
+
+**When.** A policy or an effect decides what runs when, and the answer depends on the time between events.
+
+1. Create a bus with `createMarbleBus`. It records the trace of its tasks and gives you `run`.
+2. Register the handler on `marbles.bus`, as you do in your app.
+3. Call `run` with a diagram of the emits. One character is one frame (10 ms by default).
+4. Call `expect` with a diagram of the phases that you expect.
+
+```js
+// search.test.js
+import { it, vi } from "vitest";
+import { latest } from "nanoeffects/policies";
+import { createMarbleBus, fakeTimersClock } from "nanoeffects/testing";
+
+// a search that takes 50 ms
+function search(query) {
+  return new Promise((resolve) => setTimeout(resolve, 50));
+}
+
+it("latest cancels the search that is running", async () => {
+  vi.useFakeTimers();
+
+  // createMarbleBus: a bus that records its trace, and a run that moves time frame by frame
+  const marbles = createMarbleBus({ clock: fakeTimersClock(vi) });
+
+  // latest: a new search cancels the one that is running
+  marbles.bus.on("search/changed", latest(search), { traceId: "search" });
+
+  // "a-b": emit "x" at frame 0 and "xy" at frame 2
+  const result = await marbles.run({
+    emits: { "search/changed": { marble: "a-b", values: { a: "x", b: "xy" } } },
+    frames: 12,
+  });
+
+  // s start, c cancel, d done: at frame 2 the second search cancels the first, and it is done at frame 7
+  result.expect({ "search/changed:latest": "s-(cs)----d----" });
+});
+```
+
+When a row differs, `expect` throws an error with both diagrams one under the other:
+
+```
+marble row "search/changed:latest" differs
+  expected  s-(cs)----d----
+  received  s-(cs)---d-----
+```
+
+The same test for `queue` and `debounce` is in [`examples/testing`](../examples/testing). Run it with `pnpm vitest run examples/testing`.
+
+## Read the diagrams
+
+A diagram has one character, or one group in parentheses, for each frame.
+
+| Character | In `emits` | In the result |
+| --------- | ---------- | ------------- |
+| `-` | nothing happens | nothing happens |
+| a letter or digit | emits the event with `values[character]` (the character itself without `values`) | `s` start, `d` done, `e` error, `c` cancel, `x` drop |
+| `(ab)` | two emits in one frame, in this order | two phases in one frame, in the order they happened |
+
+Other characters (`|`, spaces) throw an error that names the diagram and the position.
+
+A task has a row in the result named `type:effect`: `search/changed:latest` is the task of the `latest` policy, `search:run` is the listener named `search`. Call `result.rows()` to print every row, then copy the ones you want into `expect`. In `expect` you can write the effect alone (`latest`) when one row has it. If two rows have it, the error asks for the full key.
+
+## Set the frame and the number of frames
+
+A frame is 10 ms. Pass `frame` to `createMarbleBus` to change it. The frame of an event is its time divided by the frame, rounded down: a timer of 100 ms that starts at frame 0 ends in frame 10, so `frames` must be 11 or more to show it.
+
+`frames` is the number of frames to run. Without it the helper runs as many as the longest `emits` diagram has. Work that outlives the diagram is cut, so set `frames` when a handler takes time.
+
+## Use another clock
+
+`fakeTimersClock(vi)` moves fake timers and reads `Date.now()`. A test turns fake timers on itself (`vi.useFakeTimers()`) and leaves `Date` faked, which is the default. Jest works the same way: `fakeTimersClock(jest)`.
+
+Any object with `advance(ms)` and `now()` is a clock. `advance` may return a promise.
+
+## Know what is not there
+
+- **It needs a tracer.** The helper reads the trace of the bus, so there is no `notrace` build of `nanoeffects/testing`.
+- **One row for all calls.** Two calls of one listener share a row, so `(sd)` shows the order in which phases happened, not which call they belong to.
+- **No payloads in diagrams.** The diagram shows when, not what. Check the values with your test runner as usual.
+- **Not the RxJS alphabet.** There are no hot or cold sources and no `|` for the end of a stream.
+
 ---
 Source: docs/tracing.md
 
@@ -7713,6 +7845,8 @@ Tracing is optional. A bus works the same without it, and it costs almost nothin
 - [Show which subscription began a chain](#show-which-subscription-began-a-chain)
 - [Follow one flow with a traceGroupId](#follow-one-flow-with-a-tracegroupid)
 - [Name a listener](#name-a-listener)
+- [List who listens](#list-who-listens)
+- [Find the line of a listener](#find-the-line-of-a-listener)
 - [Keep the chain: `ctx.emit`, not `bus.emit`](#keep-the-chain-ctxemit-not-busemit)
 - [Turn the names off](#turn-the-names-off)
 - [Use built-in loggers](#use-built-in-loggers)
@@ -7886,7 +8020,7 @@ The emitters take it too: `useEmitter(cartChanged, cart, { traceId: "Cart", trac
 
 **When.** An event has more than one listener and you read the trace to see which one did the work.
 
-Give the listener a `traceId` when you register it. The plugin makes each call of it a task with that name, and what it emits with `ctx.emit` is below it. `off` works as before. It also works in a module (`m.on(event, handler, { traceId })`) and on an instance made by `extendBus`.
+A listener is named by its function when you register one with a name (`function saveName() {}`), so a log of an app that nobody annotated is already readable. An inline arrow has no name and stays as it is. To choose the name, or to name an arrow, give the listener a `traceId` when you register it; it wins over the function name. The plugin makes each call of a named listener a task with that name, and what it emits with `ctx.emit` is below it. A minifier can shorten function names in a production build: use `traceId` where a name must stay stable, and for a handler that a policy returns (`latest(fn)`), which has no name of its own. `off` works as before. It also works in a module (`m.on(event, handler, { traceId })`) and on an instance made by `extendBus`.
 
 ```js
 import { createBus } from "nanoeffects";
@@ -7909,6 +8043,88 @@ bus.once("name/changed", (name) => console.log(name), { traceId: "auditLog" });
 [nanoeffects] saveNotifier · run done
 ```
 
+## List who listens
+
+**Problem.** To know what an emit will start, you search the code for every `bus.on` of that event.
+
+**When.** You read an app that you did not write, or a test must guard the wiring of the bus.
+
+`describeBus(bus)` returns the listeners that each event has right now, by name and in the order they were added. A name is the `traceId`, else the function name, else `"<anonymous>"`. It reads what `tracePlugin` keeps, so it returns `{}` on a bus without the plugin or a tracer, and in the `notrace` build. It does not run anything and does not change the bus.
+
+```js
+import { createBus } from "nanoeffects";
+import { consoleLogger, createTracer, describeBus, tracePlugin } from "nanoeffects/trace";
+
+function saveName(name) {
+  console.log("save", name);
+}
+
+function audit(name) {
+  console.log("audit", name);
+}
+
+const trace = createTracer(consoleLogger());
+
+const bus = createBus({ trace })
+  .use(tracePlugin());
+
+bus.on("name/changed", saveName);
+bus.on("name/changed", audit);
+bus.on("saved", () => {}, { traceId: "refreshView" });
+
+// describeBus: the map of events to listener names
+console.log(describeBus(bus));
+```
+
+```
+{ "name/changed": ["saveName", "audit"], saved: ["refreshView"] }
+```
+
+## Find the line of a listener
+
+**Problem.** The log says that `saveNotifier` ran, and you must search the code for the `bus.on` that registered it. An inline arrow has no name at all, so it is not in the log.
+
+**When.** You debug in development and want to jump from a log line to the code.
+
+Pass `source: true` to `tracePlugin`. It reads the place of each `bus.on` and `bus.once` call once, when the listener is registered, and never on `emit`. The events of the listener get a `source` (`file:line:column`), `consoleLogger({ source: true })` prints it, and `describeBus(bus, { source: true })` lists it. An anonymous listener is reported too, under the type of its event.
+
+```js
+import { createBus } from "nanoeffects";
+import { consoleLogger, createTracer, describeBus, tracePlugin } from "nanoeffects/trace";
+
+// source: print where the listener was registered
+const trace = createTracer(consoleLogger({ source: true }));
+
+// source: read the place of each bus.on, once at registration
+const bus = createBus({ trace })
+  .use(tracePlugin({ source: true }));
+
+function saveName(name) {
+  console.log("save", name);
+}
+
+bus.on("name/changed", saveName);
+bus.on("name/changed", (name) => console.log("audit", name));
+
+bus.emit("name/changed", "Eva");
+
+// describeBus: the same places, without running anything
+console.log(describeBus(bus, { source: true }));
+```
+
+```
+[nanoeffects] saveName · run start (file:///app/src/user.js:13:5)
+[nanoeffects] name/changed · run start (file:///app/src/user.js:14:5)
+{ "name/changed": ["saveName (file:///app/src/user.js:13:5)", "<anonymous> (file:///app/src/user.js:14:5)"] }
+```
+
+Know the limits:
+
+- **Minified or bundled code** gives the line of the bundle. Turn on source maps (`node --enable-source-maps`, or the browser's) to see the original line.
+- **`ctx.on` called by hand** inside a handler shows the line in the library as its place. The `on` of a module and of an instance made by `extendBus`, and the `on` of `matchPlugin`, `signalPlugin` and `devPlugin`, show your line, in any order of plugins and in a bundle.
+- **No stack**, as with `Error.stackTraceLimit = 0`, gives no `source`. The listener runs as usual.
+- **The default is off.** Reading a stack costs a little for each registration, so turn it on in development.
+
 ## Keep the chain: `ctx.emit`, not `bus.emit`
 
 Inside a handler, emit with `ctx.emit`. It keeps the chain: what it starts is below the handler, and its events have the `rootId` of the chain. A plain `bus.emit` inside a handler starts a new root with no `parentId` and no `rootId`, so the trace loses the link. The bus cannot warn about it, because it does not know which handler is running.
@@ -8165,6 +8381,146 @@ conditions: ["notrace"]
 
 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.
 
+---
+Source: docs/debugging-compared.md
+
+# Debugging compared with RxJS, Effector and mitt
+
+> **Level F.** Read first: [Trace tasks](tracing.md#attach-a-tracer).
+
+Read this page if you know RxJS, Effector or mitt and want to know what nanoeffects gives you when something goes wrong, and what it does not. It compares what each tool shows, then answers three questions you ask in a debugger. It is not a migration guide: for that, see [RxJS](migrating-from-rxjs.md), [Effector](migrating-from-effector.md) and [mitt](migrating-from-mitt.md).
+
+## On this page
+
+- [Compare what you can see](#compare-what-you-can-see)
+- [Find who listens to an event](#find-who-listens-to-an-event)
+- [Find which task began a chain](#find-which-task-began-a-chain)
+- [Find out why a request stopped](#find-out-why-a-request-stopped)
+- [Know what is missing](#know-what-is-missing)
+
+## Compare what you can see
+
+| Question | nanoeffects | RxJS | Effector | mitt / nanoevents |
+| -------- | ----------- | ---- | -------- | ----------------- |
+| Which task started which? | Yes: every task has `parentId` and `rootId` ([Trace tasks](tracing.md)) | You add `tap` per stream, or a tool such as [rxjs-spy](https://github.com/cartant/rxjs-spy) | Yes, through [`effector-logger`](https://github.com/effector/logger) and the [inspector](https://github.com/effector/inspector) | No |
+| Was a call cancelled or dropped? | Yes: the phases `cancel` and `drop` | An unsubscribe shows no event unless you add one | — | No |
+| A log of every emit | `tracePlugin` reports each emit, also with no listener | `tap` per stream | A logger over the units | A `"*"` listener |
+| A map of the app | `describeBus` before a run, `graphLogger` after ([Find and cut event loops](debugging-loops.md)) | Not built in | The graph of units, with names from the Babel/SWC plugin | `emitter.all` holds the handlers of each event (mitt) |
+| Find a loop | `graphLogger`, then `loopGuardPlugin` cuts it | — | — | No |
+| Test a flow | [`createMarbleBus`](testing.md): emits and phases as diagrams on fake timers; [`createTraceRecorder`](tracing.md#keep-the-last-events-for-an-incident) keeps the events | [Marble tests](https://rxjs.dev/guide/testing/marble-testing) | `fork` gives an isolated scope | You wire it yourself |
+
+A dash means that this page does not compare it. Read the table as a map of where to look, not as a score. Effector and RxJS also hold state and streams, which nanoeffects does not, so their tools cover more ground. nanoeffects covers one thing in depth: why an async handler ran, and why it stopped.
+
+## Find who listens to an event
+
+**Problem.** You read an emit and want to know what it starts.
+
+Name the listeners with functions or a `traceId`, use `tracePlugin`, and call `describeBus`:
+
+```js
+import { createBus } from "nanoeffects";
+import { consoleLogger, createTracer, describeBus, tracePlugin } from "nanoeffects/trace";
+
+function saveName(name) {
+  console.log("save", name);
+}
+
+function audit(name) {
+  console.log("audit", name);
+}
+
+const trace = createTracer(consoleLogger());
+
+const bus = createBus({ trace })
+  .use(tracePlugin());
+
+bus.on("name/changed", saveName);
+bus.on("name/changed", audit);
+
+// describeBus: the listeners of each event, in the order they run
+console.log(describeBus(bus));
+```
+
+```
+{ "name/changed": ["saveName", "audit"] }
+```
+
+Details: [List who listens](tracing.md#list-who-listens).
+
+## Find which task began a chain
+
+**Problem.** A request ran and you do not know what asked for it.
+
+Every task of a trace has a `rootId` and a `parentId`. The recorder keeps them, so you can walk up from the request to the emit that began it:
+
+```js
+import { createBus } from "nanoeffects";
+import { createTraceRecorder, createTracer, tracePlugin } from "nanoeffects/trace";
+
+// createTraceRecorder: keeps the last events in memory
+const recorder = createTraceRecorder();
+const trace = createTracer(recorder);
+
+const bus = createBus({ trace })
+  .use(tracePlugin());
+
+function loadUser(id, ctx) {
+  ctx.emit("user/loading", id);
+}
+
+bus.on("user/open", loadUser);
+bus.emit("user/open", 7);
+
+// each event says which task is its parent
+for (const event of recorder.events) {
+  console.log(event.id, event.parentId, event.type, event.phase);
+}
+```
+
+Details: [Show which subscription began a chain](tracing.md#show-which-subscription-began-a-chain) and [Keep the chain: `ctx.emit`, not `bus.emit`](tracing.md#keep-the-chain-ctxemit-not-busemit).
+
+## Find out why a request stopped
+
+**Problem.** A search request never finished and no error appeared.
+
+A policy that stops a call reports `cancel` or `drop` in the trace. Pick the call and read its last phase:
+
+```js
+import { createBus } from "nanoeffects";
+import { latest } from "nanoeffects/policies";
+import { createTraceRecorder, createTracer, tracePlugin } from "nanoeffects/trace";
+
+const recorder = createTraceRecorder();
+const trace = createTracer(recorder);
+
+const bus = createBus({ trace })
+  .use(tracePlugin());
+
+// latest: a new search stops the one that is still running
+const search = latest(async (query, ctx) => {
+  await new Promise((resolve) => setTimeout(resolve, 100));
+  ctx.emit("search/loaded", query);
+});
+
+bus.on("search/changed", search, { traceId: "search" });
+bus.emit("search/changed", "a");
+bus.emit("search/changed", "ab");
+
+// a "cancel" phase on the first call says that the second one stopped it
+const phases = recorder.events.map((event) => `${event.type}:${event.phase}`);
+console.log(phases);
+```
+
+Details: [Trace tasks](tracing.md) and [Cancel stale requests](cancel-stale-requests.md).
+
+## Know what is missing
+
+- **No browser extension or UI of its own.** Use [Redux DevTools](tracing.md#configure-redux-devtools), the console or the Performance panel. Effector has an inspector for this.
+- **No map from the source code.** `describeBus` lists the listeners registered so far, and `graphLogger` shows the events that happened. A listener that is not registered yet is not on the map.
+- **No click-through from the log to the code.** With `tracePlugin({ source: true })` an event carries the `file:line:column` of its listener ([Find the line of a listener](tracing.md#find-the-line-of-a-listener)), but a link in a UI is yours to build.
+- **No names from a compiler.** Function names give a name for free; a minifier can shorten them, so use `traceId` where a name must stay stable.
+- **No replay and no time travel.** The recorder keeps what happened and cannot run it again.
+
 ---
 Source: docs/debugging-loops.md
 

package/llms.txt

@@ -60,7 +60,9 @@ Rules that generated code often gets wrong:
 
 - [Semantics](docs/semantics.md): exact rules of emit, abort and ordering
 - [Keep the signal through a handler](docs/pass-the-signal.md): every way a policy handler loses `ctx.signal`, and the lint rules and `devPlugin` check that find it
+- [Test time with diagrams](docs/testing.md): `createMarbleBus` and `fakeTimersClock`; emits and phases as diagrams on fake timers
 - [Trace tasks](docs/tracing.md): loggers, Redux DevTools, `graphLogger`, the `notrace` build
+- [Debugging compared with RxJS, Effector and mitt](docs/debugging-compared.md): what you can see in each, and three debugging cases
 - [Find and cut event loops](docs/debugging-loops.md): symptoms, `graphLogger`, the graph as Mermaid, Graphviz or JSON, Redux DevTools
 - [Cut a loop with loopGuardPlugin](docs/loop-guard.md): limits on repeats, depth and emits from outside
 - [Turn events into Observables](docs/observable.md): `createObserve`, `Subject`, `events` (an event as a `for await` loop)

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "nanoeffects",
-	"version": "0.31.2",
+	"version": "0.32.0",
 	"description": "Business logic and side effects outside UI components, as plain async functions. Tiny, no dependencies.",
 	"keywords": [
 		"event-bus",
@@ -114,6 +114,10 @@
 			"types": "./dist/trace.d.ts",
 			"import": "./dist/trace.js"
 		},
+		"./testing": {
+			"types": "./dist/testing.d.ts",
+			"import": "./dist/testing.js"
+		},
 		"./redux": {
 			"notrace": {
 				"types": "./dist/notrace/redux.d.ts",
@@ -232,7 +236,7 @@
 		{
 			"name": "actions (all)",
 			"path": "dist/actions.js",
-			"limit": "3.31 kB"
+			"limit": "3.4 kB"
 		},
 		{
 			"name": "match (plugin)",
@@ -254,6 +258,11 @@
 			"path": "dist/guard.js",
 			"limit": "1 kB"
 		},
+		{
+			"name": "testing (marble bus)",
+			"path": "dist/testing.js",
+			"limit": "4.1 kB"
+		},
 		{
 			"name": "trace: graphLogger",
 			"path": "dist/trace.js",
@@ -263,7 +272,7 @@
 		{
 			"name": "oop (class entry)",
 			"path": "dist/oop.js",
-			"limit": "2.6 kB"
+			"limit": "2.62 kB"
 		},
 		{
 			"name": "scope (plugin and effect)",

package/dist/context-B5Z2RpJt.js

@@ -1 +0,0 @@
-import{t as e}from"./onAbort-BgMfspK4.js";import{t}from"./emit-key-C6FL7Ewn.js";const n=t=>{let n=new AbortController;return{controller:n,unlink:e({signal:t},e=>n.abort(e))}},r=typeof __NANOEFFECTS_TRACE__>`u`||__NANOEFFECTS_TRACE__,i=/* @__PURE__ */ new WeakMap;let a;const o=()=>a,s=()=>{},c=(e,t,n,a)=>{let o=r&&i.get(e);o&&o.tracer.report(o.ref,t,n,a)},l=(e,t)=>{let n=r&&i.get(e);n&&n.tracer.rename?.(n.ref,t)},u=(e,t)=>{let n=r&&i.get(e);return n?n.tracer.settler(n.ref,t):s},d=(e,t,n)=>{let a=r&&i.get(e);return a?a.tracer.run(a.ref,t,e.signal,n):n()},f=Symbol(`nanoeffects.addContext`),p=(e,t)=>typeof e==`function`?e(t):e,m=({event:o,bus:c,tracer:l,parent:u})=>{let{controller:h,unlink:g}=n(u?.signal),{signal:_}=h,v=r&&l?{tracer:l,ref:l.task(o,u?.ref)}:void 0,y=(...e)=>{if(_.aborted&&!S[t])return;let n=c?.emit,r=a;a=v?.ref;try{return n?.(...e)}finally{a=r}},b=(...t)=>{if(_.aborted)return s;let n=c?.on,r=n?.(...t);if(!r)return s;let i=e({signal:_},r);return()=>{i(),r()}},x=async(e,...t)=>{_.throwIfAborted();let n=t[0],r=m({event:{type:o.type,payload:n},bus:c,tracer:l,parent:{signal:_,ref:v?.ref}});try{return await d(r.ctx,`run`,()=>e(n,r.ctx))}finally{r.unlink()}},S={...p(c?.ctx,o),type:o.type,payload:o.payload,signal:_,abort:e=>h.abort(e),emit:y,on:b,off:c?.off??s,run:x,[f]:c?.addContext};return c?.addContext?.(S),v&&i.set(S,v),{ctx:S,unlink:g}},h=(e,t)=>{let n=r?i.get(e):void 0;return m({event:{type:t??e.type??``,payload:e.payload},bus:{emit:e.emit,on:e.on,off:e.off,ctx:e,addContext:Reflect.get(e,f)},tracer:n?.tracer,parent:{signal:e.signal,ref:n?.ref}})};export{l as a,r as c,h as i,m as n,d as o,o as r,c as s,u as t};