posipaki 0.10.4 → 0.11.0

package/README.md

@@ -1,19 +1,148 @@
-# Wat
+# Posipaki
 
-When you want to do some Erlang, but you can only have reactive composable stores instead
+The missing primitive: actor processes for JavaScript, built on generator functions
+and the `[msg, sender]` tuple.
 
-# Wat?
+## Why
 
-It's like a promise but worse -- you can abort it and have more undebuggable things to figure out.
+JavaScript has three ways to model async work:
 
-# Do I need vue3 to use it?
+- **Promises** — model a single eventual value. Great for request/response, useless
+  for something with more than one outcome.
+- **Observables / Streams** — model a sequence of values over time. Great for
+  events, but every subscriber sees the same events and there's no back-and-forth.
+- **Stores / Reactive state** — model a value that changes over time. Great for UI
+  state, but they're passive — you read them, they don't talk back.
 
-No.
+What's missing is a primitive for something that **receives messages, updates its
+own state, and sends messages back** — a thing with its own lifecycle, can be started
+and aborted before it resolves. 
 
-# Is this about Public Key Infrastructure?
+A **process**.
 
-No.
+```ts
+const counter = defineActor({
+  initialState: { count: 0 },
+  handlers: {
+    POKE(msg, sender) {
+      this.state.count++;
+      if (this.state.count >= 10) {
+        this.emit({ type: "FULL" });
+        this.exit("limit reached");
+      }
+    },
+    RESET(msg, sender) {
+      this.state.count = 0;
+    },
+  },
+});
 
-# Are you sure it's not another halfbroken X509 parser?
+const proc = counter.spawn(null);
+await proc.ready();
+proc.send({ type: "POKE" });
 
-Yes, it's not another halfbroken X509 parser
+A process can do everything a promise, a stream, or a store can do —
+but it can also fork children, pause/resume, and exit on its own terms.
+And every handler receives the sender's identity in the `[msg, sender]` tuple,
+so you always know *who* sent what.
+Of course processes are composable into trees.
+
+## Quick start
+
+```ts
+import { spawnAsync, defineActor } from "posipaki";
+
+const counter = defineActor({
+  initialState: { count: 0 },
+  handlers: {
+    POKE(msg, sender) {
+      this.state.count++;
+    },
+  },
+});
+
+const proc = counter.spawn(null);
+await proc.ready();           // state is available
+proc.send({ type: "POKE" });  // delivers [msg, sender] to the generator
+// proc.state.count === 1
+```
+
+For full control, drop to generators:
+
+```ts
+import { spawnAsync, runDispatchAsync } from "posipaki";
+
+async function* counter(ctx, { max }) {
+  const state = { count: 0 };
+  yield state;
+
+  yield* runDispatchAsync(ctx.pname, async ([msg, sender]) => {
+    if (msg.type === "POKE" && state.count < max) state.count++;
+  });
+  // ... or wait for the signal to replace it with another generator
+}
+
+const proc = spawnAsync(counter, "counter")({ max: 3 });
+await proc.ready();
+proc.send({ type: "POKE" });
+await proc.wait();
+```
+
+## Features
+
+- **Processes** — sync or async, same API
+- **Child processes** — `ctx.fork(fn, name)(args)` spawns supervised children
+- **Supervisor** — run and monitor named workers
+- **Reactive state** — `proc.subscribe(cb)` notifies on every state change
+- **Pause/resume** — buffer messages while idle
+- **Pipe** — chain processes so each runs after the previous exits
+- **xfetch** — HTTP requests as processes, with abort support
+- **defineActor** — declarative config for structured actors
+
+## Sender provenance
+
+Every message the generator receives is a `[msg, sender]` tuple:
+
+```ts
+const [msg, sender] = yield state;
+// msg:    your discriminated message
+// sender: { fromName: string, fromId: symbol }
+```
+
+Messages you send via `ctx.sendSelf()` or `ctx.toParent()` are stamped automatically.
+
+## Install
+
+```sh
+npm install posipaki
+```
+
+## API
+
+### Processes
+
+- `spawnAsync(fn, name)(args)` — create an async process
+- `proc.ready()` — wait for initial state
+- `proc.state` — current reactive state
+- `proc.send(msg, sender)` — inject a message from a named sender
+- `proc.subscribe(cb)` — react to state changes
+- `proc.pause()` / `proc.resume()` — buffer or process messages
+- `proc.wait()` — resolve when the generator completes
+
+### Generator context
+
+- `ctx.pname` — process name
+- `ctx.id` — unique symbol
+- `ctx.sendSelf(msg)` — enqueue a message to yourself
+- `ctx.toParent(msg)` — send a message to the parent process
+- `ctx.fork(fn, name)(args)` — spawn a child process
+
+### Sender types
+
+- `SenderInfo` — `{ fromName: string, fromId: symbol }`
+- `WithSender<M>` — `[M, SenderInfo]`
+- `WithoutSender<T>` — extracts `M` from `WithSender<M>`
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { a as runDispatchAsync, c as ExitMessage, d as ProcessCtx, f as ProcessFn, i as AsyncProcess, l as Message, m as SupervisorState, n as spawn, o as spawnAsync, p as StopMessage, r as runDispatch, s as AsyncProcessFn, t as Process, u as PipeState } from "./process-C-ERBQY5.js";
+import { _ as WithSender, a as runDispatchAsync, c as ExitMessage, d as ProcessCtx, f as ProcessFn, g as SupervisorState, h as StopMessage, i as AsyncProcess, l as Message, m as SenderOrigin, n as spawn, o as spawnAsync, p as SenderInfo, r as runDispatch, s as AsyncProcessFn, t as Process, u as PipeState, v as WithoutSender } from "./process-BiX7Ena4.js";
 
 //#region src/adapters.d.ts
 declare function asyncify<A, S, IM extends Message, OM extends Message>(fn: ProcessFn<A, S, IM, OM>): AsyncProcessFn<A, S, IM, OM>;
@@ -10,13 +10,17 @@ type ActorMessages<M extends Message> = {
 interface MethodOptions {
   [key: string]: Function;
 }
-type HandlerFn<InMsg extends Message> = (msg: InMsg) => void | Promise<void>;
+type HandlerFn<InMsg extends Message> = (msg: InMsg, sender: SenderInfo) => void | Promise<void>;
 type HandlerOptions<InMsg extends Message> = Omit<{ [K in InMsg["type"]]: HandlerFn<Extract<InMsg, {
   type: K;
 }>> }, "STOP">;
 interface ActorDefinition<Args, ExposedState, InMsg extends Message, OutMsg extends Message, Handlers extends HandlerOptions<InMsg>> {
   fn: AsyncProcessFn<Args, ExposedState, InMsg, OutMsg>;
   config: ActorConfig<Args, any, ExposedState, InMsg, OutMsg, {}, Handlers>;
+  /** Spawn this actor as a standalone process. */
+  spawn(args: Args): AsyncProcess<Args, ExposedState, InMsg, OutMsg>;
+  /** Spawn this actor as a child of the calling process. */
+  spawnAsChild(ctx: ProcessCtx<any, any, any, any>, name: string, args: Args): AsyncProcess<Args, ExposedState, InMsg, OutMsg>;
 }
 interface ActorConfig<Args, InternalState, ExposedState, InMsg extends Message, OutMsg extends Message, Methods extends MethodOptions, Handlers extends HandlerOptions<InMsg>> {
   initialState: InternalState | ((this: void, args: Args, ctx: ActorContext<Args, InternalState, InMsg, OutMsg, Methods, Handlers>["ctx"]) => InternalState);
@@ -28,7 +32,7 @@ interface ActorConfig<Args, InternalState, ExposedState, InMsg extends Message,
   onEnd?: (this: ActorContext<Args, InternalState, InMsg, OutMsg, Methods, Handlers>, reason?: unknown) => void | Promise<void>;
   handlers: Handlers & ThisType<ActorContext<Args, InternalState, InMsg, OutMsg, Methods, Handlers>>;
   methods?: Methods & ThisType<ActorContext<Args, InternalState, InMsg, OutMsg, Methods, Handlers>>;
-  onUnhandled?: (this: ActorContext<Args, InternalState, InMsg, OutMsg, Methods, Handlers>, msg: InMsg) => void | Promise<void>;
+  onUnhandled?: (this: ActorContext<Args, InternalState, InMsg, OutMsg, Methods, Handlers>, msg: InMsg, sender: SenderInfo) => void | Promise<void>;
   onChildExit?: (this: ActorContext<Args, InternalState, InMsg, OutMsg, Methods, Handlers>, name: string, reason: ExitMessage) => void | Promise<void>;
 }
 type ActorContext<Args, InternalState, InMsg extends Message, OutMsg extends Message, Methods extends MethodOptions, Handlers extends HandlerOptions<InMsg>> = Methods & {
@@ -47,5 +51,5 @@ type ActorContext<Args, InternalState, InMsg extends Message, OutMsg extends Mes
 declare function defineMessages<OutMsg extends Message = Message>(): ActorMessages<OutMsg>;
 declare function defineActor<Args, InternalState, ExposedState, InMsg extends Message, OutMsg extends Message, Methods extends MethodOptions, Handlers extends HandlerOptions<InMsg>>(config: ActorConfig<Args, InternalState, ExposedState, InMsg, OutMsg, Methods, Handlers>): ActorDefinition<Args, ExposedState, InMsg, OutMsg, Handlers>;
 //#endregion
-export { type ActorConfig, type ActorContext, type ActorDefinition, AsyncProcess, type AsyncProcessFn, type ExitMessage, type HandlerFn, type HandlerOptions, type Message, type MethodOptions, type PipeState, Process, type ProcessCtx, type ProcessFn, type StopMessage, type SupervisorState, asyncify, defineActor, defineMessages, runDispatch, runDispatchAsync, spawn, spawnAsync };
+export { type ActorConfig, type ActorContext, type ActorDefinition, AsyncProcess, type AsyncProcessFn, type ExitMessage, type HandlerFn, type HandlerOptions, type Message, type MethodOptions, type PipeState, Process, type ProcessCtx, type ProcessFn, type SenderInfo, type SenderOrigin, type StopMessage, type SupervisorState, type WithSender, type WithoutSender, asyncify, defineActor, defineMessages, runDispatch, runDispatchAsync, spawn, spawnAsync };
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../src/adapters.ts","../src/actor-types.ts","../src/define-actor.ts"],"mappings":"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"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/adapters.ts","../src/actor-types.ts","../src/define-actor.ts"],"mappings":"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"}

package/dist/index.js

@@ -57,13 +57,21 @@ var AsyncProcess = class AsyncProcess {
 	* state; for async generators this happens in a microtask.
 	*/
 	start(arg0) {
+		const selfCtx = {
+			fromName: this.pname,
+			fromId: this.id
+		};
 		const ctx = {
 			pname: this.pname,
 			id: this.id,
 			fork: this.fork.bind(this),
 			forkSync: this.forkSync.bind(this),
-			send: this.send.bind(this),
-			toParent: this.toParent
+			sendSelf: (msg) => {
+				this.send([msg, selfCtx]);
+			},
+			toParent: (msg) => {
+				this.toParent([msg, selfCtx]);
+			}
 		};
 		this.current = this._watchExit(ctx, arg0);
 		this.current.next().then((ret) => {
@@ -73,7 +81,11 @@ var AsyncProcess = class AsyncProcess {
 				this.exitWaiter.resolve();
 				return;
 			}
-			this._eatResult(this.current.next({ type: "__ADVANCE__" }));
+			const advance = [{ type: "__ADVANCE__" }, {
+				fromName: "__internal__",
+				fromId: Symbol("__internal__")
+			}];
+			this._eatResult(this.current.next(advance));
 		});
 		return this;
 	}
@@ -83,12 +95,7 @@ var AsyncProcess = class AsyncProcess {
 			yield* this.pgenerator(ctx, arg0);
 		} finally {
 			this.toAllChildren({ type: "STOP" });
-			this.toParent({
-				type: "EXIT",
-				pid: this.id,
-				fromName: this.pname,
-				fromId: this.id
-			});
+			ctx.toParent({ type: "EXIT" });
 		}
 	}
 	fork(fn, pname) {
@@ -106,10 +113,10 @@ var AsyncProcess = class AsyncProcess {
 		if (!this.current || this._tickInProgress) return;
 		this._tickInProgress = true;
 		try {
-			let msg;
+			let msgAndSender;
 			let ret = null;
-			while ((msg = this.buffer.shift()) !== void 0) {
-				ret = await this._safeNext(msg);
+			while ((msgAndSender = this.buffer.shift()) !== void 0) {
+				ret = await this._safeNext(msgAndSender);
 				if (!ret || ret.done) break;
 			}
 			this.notify();
@@ -122,9 +129,9 @@ var AsyncProcess = class AsyncProcess {
 		}
 	}
 	/** Call `.next()` and redirect unhandled rejections. */
-	async _safeNext(msg) {
+	async _safeNext(msgAndSender) {
 		try {
-			return await this.current.next(msg);
+			return await this.current.next(msgAndSender);
 		} catch (e) {
 			this._exitReject?.(e);
 			this._exitReject = null;
@@ -142,11 +149,15 @@ var AsyncProcess = class AsyncProcess {
 	}
 	/** Broadcast a message to all children. */
 	toAllChildren(msg) {
-		this.children.forEach((p) => p.send(msg));
+		const stamp = {
+			fromName: this.pname,
+			fromId: this.id
+		};
+		this.children.forEach((p) => p.send([msg, stamp]));
 	}
-	/** Enqueue a message. Processing is async (microtask). */
-	send(msg) {
-		this.buffer.push(msg);
+	send(msgOrTuple, from) {
+		if (from !== void 0) this.buffer.push([msgOrTuple, from]);
+		else this.buffer.push(msgOrTuple);
 		this._scheduleTick();
 	}
 	/**
@@ -205,9 +216,12 @@ var AsyncProcess = class AsyncProcess {
 			});
 		});
 	}
-	fromChild(msg) {
-		if (msg.type === "EXIT") this.children = this.children.filter((p) => p.id !== msg.pid);
-		this.send(msg);
+	/** Relays a child's message to this process. The message already carries
+	*  sender provenance (stamped by the child's `ctx.toParent` wrapper). */
+	fromChild(msgAndSender) {
+		const [msg, sender] = msgAndSender;
+		if (msg.type === "EXIT") this.children = this.children.filter((p) => p.id !== sender.fromId);
+		this.send(msgAndSender);
 	}
 };
 /**
@@ -223,9 +237,12 @@ function spawnAsync(fn, pname, toParent) {
 }
 //#endregion
 //#region src/process.ts
+/** @deprecated Use {@link spawnAsync} instead. */
 function spawn(fn, pname, tp) {
 	return (a) => new Process(fn, pname, tp).start(a);
 }
+/** @deprecated Use {@link AsyncProcess} instead. Sync processes are
+*  wrapped via asyncify internally; spawnAsync handles both. */
 var Process = class extends AsyncProcess {
 	constructor(fn, pname, tp) {
 		super(asyncify(fn), pname, tp);
@@ -254,11 +271,7 @@ function defineActor(config) {
 			name: ctx.pname,
 			id: ctx.id,
 			emit(msg) {
-				ctx.toParent({
-					...msg,
-					fromName: ctx.pname,
-					fromId: ctx.id
-				});
+				ctx.toParent(msg);
 			},
 			agreeToStop() {
 				exitReason = "stopped";
@@ -279,7 +292,8 @@ function defineActor(config) {
 		};
 		yield exposedState;
 		if (config.onStart) await config.onStart.call(self, args);
-		yield* runDispatchAsync(ctx.pname, async (msg) => {
+		yield* runDispatchAsync(ctx.pname, async (stamped) => {
+			const [msg, sender] = stamped;
 			if (msg.type === "STOP") {
 				if (config.onStopRequested) {
 					await config.onStopRequested.call(self);
@@ -297,15 +311,14 @@ function defineActor(config) {
 				}
 			}
 			if (msg.type === "EXIT") {
-				const exitMsg = msg;
-				const childName = exitMsg.fromName;
+				const childName = sender.fromName;
 				if (childName && self.$child[childName]) delete self.$child[childName];
-				if (config.onChildExit) await config.onChildExit.call(self, childName, exitMsg);
+				if (config.onChildExit) await config.onChildExit.call(self, childName, msg);
 			}
 			if (msg.type !== "STOP") {
 				const handler = config.handlers[msg.type];
-				if (handler) await handler.call(self, msg);
-				else if (config.onUnhandled) await config.onUnhandled.call(self, msg);
+				if (handler) await handler.call(self, msg, sender);
+				else if (config.onUnhandled) await config.onUnhandled.call(self, msg, sender);
 			}
 			if (done) return;
 		}, () => done);
@@ -313,7 +326,13 @@ function defineActor(config) {
 	};
 	return {
 		fn,
-		config
+		config,
+		spawn(args) {
+			return spawnAsync(fn, "actor")(args);
+		},
+		spawnAsChild(ctx, name, args) {
+			return ctx.fork(fn, name)(args);
+		}
 	};
 }
 //#endregion

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":[],"sources":["../src/adapters.ts","../src/process.async.ts","../src/process.ts","../src/define-actor.ts","../src/index.ts"],"sourcesContent":["import type { ProcessFn, AsyncProcessFn, Message } from \"./types.js\"\n\nexport function asyncify<A, S, IM extends Message, OM extends Message>(\n  fn: ProcessFn<A, S, IM, OM>,\n): AsyncProcessFn<A, S, IM, OM> {\n  return async function* (ctx, args) {\n    yield* fn(ctx, args) as any\n  }\n}\n","import { defer, makeWaiter, debugLog } from \"./util.js\";\nimport type { DeferredCall, Waiter } from \"./util.js\";\nimport type {\n  Message,\n  ExitMessage,\n  ProcessCtx,\n  AsyncProcessFn,\n  ProcessFn,\n  Fork,\n} from \"./types.js\";\nimport { asyncify } from \"./adapters.js\";\n\n// ---- types ------------------------------------------------------------------\n\n/** An async iterator over process state. */\ntype AsyncProcessGenerator<ProcessState, InMessage> = AsyncGenerator<\n  ProcessState | null,\n  void,\n  InMessage\n>;\n\ntype NotifyFn = () => void;\n\n// ---- runDispatchAsync -------------------------------------------------------\n\ntype AsyncReducer<M> = (msg: M) => Promise<void>;\ntype ReadyFn = () => boolean;\n\n/**\n * Async equivalent of `runDispatch`. Loops, yielding `null` and feeding\n * each incoming message to an `async` reducer. Exits when `readyFn()`\n * returns true.\n */\nexport async function* runDispatchAsync<M>(\n  name: string,\n  fn: AsyncReducer<M>,\n  readyFn: ReadyFn = () => false,\n  debugLevel = false,\n): AsyncGenerator<null, void, M> {\n  let msg: M;\n  while (!readyFn()) {\n    msg = yield null;\n    debugLog(debugLevel, \"msg\", name, \" <- \", msg);\n    await fn(msg);\n  }\n}\n\n// ---- AsyncProcess -----------------------------------------------------------\n\ntype ProcessMessageCb<M> = (msg: M) => void;\n\nconst noop = () => null;\n\n/**\n * A process driven by an async generator. Functionally identical to\n * {@link Process} but supports `await` inside reducers.\n *\n * Messages are processed **one at a time** — if a tick is already\n * in-flight, new messages are buffered and processed when the current\n * tick completes.\n */\nexport class AsyncProcess<\n  Args,\n  State,\n  InMessage extends Message,\n  OutMessage extends Message,\n> {\n  pgenerator: AsyncProcessFn<Args, State, InMessage, OutMessage>;\n  pname: string;\n  toParent: ProcessMessageCb<OutMessage>;\n  id: symbol;\n  state: State | null;\n\n  private current: AsyncProcessGenerator<State, InMessage> | null = null;\n  private buffer: Array<InMessage> = [];\n  private nextTick: DeferredCall | null = null;\n  private children: Array<AsyncProcess<unknown, unknown, Message, Message>> =\n    [];\n  private subscribers: Array<NotifyFn> = [];\n  private exitWaiter: Waiter;\n  private _isPaused: boolean = false;\n  private _tickInProgress: boolean = false;\n  private _exitReject: ((e: unknown) => void) | null = null;\n  private _ready!: Waiter;\n  private _resolveReady!: () => void;\n\n  constructor(\n    fn: AsyncProcessFn<Args, State, InMessage, OutMessage>,\n    pname: string,\n    toParent: ProcessMessageCb<OutMessage> | undefined,\n  ) {\n    this.pgenerator = fn;\n    this.pname = pname;\n    this.toParent = toParent || (noop as ProcessMessageCb<OutMessage>);\n    this.id = Symbol(pname);\n    this.state = null;\n    this.exitWaiter = makeWaiter();\n    this._ready = makeWaiter();\n    this._resolveReady = this._ready.resolve;\n  }\n\n  /** Promise that resolves once the initial state is available. */\n  ready(): Promise<void> {\n    return this._ready.promise;\n  }\n\n  // ---- lifecycle ------------------------------------------------------------\n\n  /**\n   * Kick off the async generator. The first `yield` sets the initial\n   * state; for async generators this happens in a microtask.\n   */\n  start(arg0: Args) {\n    const ctx: ProcessCtx<Args, State, InMessage, OutMessage> = {\n      pname: this.pname,\n        id: this.id,\n      fork: this.fork.bind(this),\n      forkSync: this.forkSync.bind(this),\n      send: this.send.bind(this),\n      toParent: this.toParent,\n    };\n\n    this.current = this._watchExit(ctx, arg0);\n    void this.current.next().then((ret: IteratorResult<State | null, void>) => {\n      this.state = ret.value ?? null;\n      this._resolveReady();\n      if (ret.done) {\n        this.exitWaiter.resolve();\n        return;\n      }\n      // Advance past the initial yield so the _watchExit generator\n      // runs its finally block (EXIT/STOP) and the inner generator\n      // enters its dispatch loop. The second .next() sends no\n      // message — it just consumes the _watchExit wrapper's own\n      // yield, not the user's generator.\n      this._eatResult(this.current!.next({ type: \"__ADVANCE__\" } as any));\n    });\n    return this;\n  }\n\n  /** Wrap the user's generator so EXIT/STOP logic fires on completion. */\n  private async *_watchExit(\n    ctx: ProcessCtx<Args, State, InMessage, OutMessage>,\n    arg0: Args,\n  ): AsyncProcessGenerator<State, InMessage> {\n    try {\n      yield* this.pgenerator(ctx, arg0);\n    } finally {\n      this.toAllChildren({ type: \"STOP\" } as Message);\n      this.toParent({\n        type: \"EXIT\",\n        pid: this.id,\n        fromName: this.pname,\n        fromId: this.id,\n      } as unknown as OutMessage);\n    }\n  }\n\n  // ---- fork -----------------------------------------------------------------\n\n  fork<ChildArgs, ChildState, ChildIM extends Message, ChildOM extends Message>(\n    fn: AsyncProcessFn<ChildArgs, ChildState, ChildIM, ChildOM>,\n    pname: string,\n  ): (\n    args: ChildArgs,\n  ) => AsyncProcess<ChildArgs, ChildState, ChildIM, ChildOM> {\n    return (args: ChildArgs) => {\n      const child = new AsyncProcess<ChildArgs, ChildState, ChildIM, ChildOM>(\n        fn,\n        pname,\n        this.fromChild.bind(this) as unknown as ProcessMessageCb<ChildOM>,\n      );\n      this.children.push(\n        child as unknown as AsyncProcess<unknown, unknown, Message, Message>,\n      );\n      child.start(args);\n      return child;\n    };\n  }\n\n  forkSync<\n    ChildArgs,\n    ChildState,\n    ChildIM extends Message,\n    ChildOM extends Message,\n  >(\n    fn: ProcessFn<ChildArgs, ChildState, ChildIM, ChildOM>,\n    pname: string,\n  ): (\n    args: ChildArgs,\n  ) => AsyncProcess<ChildArgs, ChildState, ChildIM, ChildOM> {\n    return this.fork(asyncify(fn), pname);\n  }\n\n  // ---- message processing ---------------------------------------------------\n\n  protected async _tick(): Promise<void> {\n    if (!this.current || this._tickInProgress) return;\n\n    this._tickInProgress = true;\n    try {\n      let msg: InMessage | undefined;\n      let ret: IteratorResult<State | null, void> | null = null;\n      while ((msg = this.buffer.shift()) !== undefined) {\n        ret = await this._safeNext(msg);\n        if (!ret || ret.done) break;\n      }\n      this.notify();\n      this._eatResult(ret);\n    } catch (e) {\n      this._exitReject?.(e);\n      this._exitReject = null;\n    } finally {\n      this._tickInProgress = false;\n    }\n  }\n\n  /** Call `.next()` and redirect unhandled rejections. */\n  private async _safeNext(\n    msg: InMessage,\n  ): Promise<IteratorResult<State | null, void> | null> {\n    try {\n      return await this.current!.next(msg);\n    } catch (e) {\n      this._exitReject?.(e);\n      this._exitReject = null;\n      return { done: true, value: undefined };\n    }\n  }\n\n  private _eatResult(\n    ret:\n      | IteratorResult<State | null, void>\n      | Promise<IteratorResult<State | null, void>>\n      | null,\n  ): void {\n    if (!ret) return;\n    Promise.resolve(ret).then((r) => {\n      if (r.done) {\n        this.exitWaiter.resolve();\n      }\n    });\n  }\n\n  /** Broadcast a message to all children. */\n  toAllChildren(msg: Message): void {\n    this.children.forEach((p) => p.send(msg));\n  }\n\n  /** Enqueue a message. Processing is async (microtask). */\n  send(msg: InMessage): void {\n    this.buffer.push(msg);\n    this._scheduleTick();\n  }\n\n  /**\n   * Synchronously flush the buffer. For sync processes use {@link Process.tick};\n   * for async processes this is **not guaranteed** to process everything\n   * immediately if reducers contain `await`. Prefer `send()` + `await proc.wait()`.\n   */\n  tick(): void {\n    this.nextTick?.flush();\n    this.nextTick = null;\n  }\n\n  private _scheduleTick(): void {\n    if (this._isPaused) return;\n\n    this.nextTick?.cancel();\n    this.nextTick = defer(() => {\n      this.nextTick = null;\n      void this._tick();\n    });\n  }\n\n  // ---- subscribers ----------------------------------------------------------\n\n  notify(): void {\n    this.subscribers.forEach((f) => f());\n  }\n\n  get isListenedTo(): boolean {\n    return this.subscribers.length > 0;\n  }\n\n  subscribe(f: NotifyFn): () => void {\n    this.subscribers.push(f);\n    return () => {\n      const idx = this.subscribers.indexOf(f);\n      if (idx < 0) return;\n      this.subscribers.splice(idx, 1);\n    };\n  }\n\n  // ---- pause / resume -------------------------------------------------------\n\n  pause(): void {\n    this.nextTick?.cancel();\n    this.nextTick = null;\n    this._isPaused = true;\n  }\n\n  resume(): void {\n    this._isPaused = false;\n    this._scheduleTick();\n  }\n\n  // ---- waiting --------------------------------------------------------------\n\n  /**\n   * Returns a promise that resolves when the generator completes, or\n   * rejects if an unhandled error occurs during message processing.\n   */\n  wait(): Promise<void> {\n    return new Promise<void>((resolve, reject) => {\n      this._exitReject = reject;\n\n      this.exitWaiter.promise.then(\n        () => {\n          this._exitReject = null;\n          resolve();\n        },\n        (e) => {\n          this._exitReject = null;\n          reject(e);\n        },\n      );\n    });\n  }\n\n  // ---- child messages -------------------------------------------------------\n\n  private fromChild(msg: InMessage): void {\n    if (msg.type === \"EXIT\") {\n      this.children = this.children.filter(\n        (p) => p.id !== (msg as unknown as ExitMessage).pid,\n      );\n    }\n    this.send(msg);\n  }\n}\n\n// ---- spawnAsync -------------------------------------------------------------\n\n/**\n * Spawn a new async process. Accepts both sync and async process\n * functions — sync ones are automatically wrapped with {@link asyncify}.\n */\nexport function spawnAsync<\n  Args,\n  State,\n  InMessage extends Message = Message,\n  OutMessage extends Message = ExitMessage,\n>(\n  fn: AsyncProcessFn<Args, State, InMessage, OutMessage>,\n  pname: string,\n  toParent?: ProcessMessageCb<OutMessage>,\n): (args: Args) => AsyncProcess<Args, State, InMessage, OutMessage> {\n  return (args: Args) => {\n    const proc = new AsyncProcess<Args, State, InMessage, OutMessage>(\n      fn,\n      pname,\n      toParent,\n    );\n    proc.start(args);\n    return proc;\n  };\n}\n","import { AsyncProcess } from \"./process.async.js\";\nimport { asyncify } from \"./adapters.js\";\nimport type { Message, ExitMessage, ProcessFn } from \"./types.js\";\n\nexport type { Message, ProcessFn, ProcessCtx } from \"./types.js\";\nexport { runDispatch } from \"./util.js\";\n\nexport function spawn<\n  A,\n  S,\n  IM extends Message = Message,\n  OM extends Message = ExitMessage,\n>(\n  fn: ProcessFn<A, S, IM, OM>,\n  pname: string,\n  tp?: (m: OM) => void,\n): (a: A) => Process<A, S, IM, OM> {\n  return (a: A) => new Process(fn, pname, tp).start(a) as Process<A, S, IM, OM>;\n}\n\nclass Process<\n  A,\n  S,\n  IM extends Message,\n  OM extends Message,\n> extends AsyncProcess<A, S, IM, OM> {\n  constructor(\n    fn: ProcessFn<A, S, IM, OM>,\n    pname: string,\n    tp?: (m: OM) => void,\n  ) {\n    super(asyncify(fn), pname, tp);\n  }\n\n  start(a: A) {\n    super.start(a);\n    return this;\n  }\n  tick(): Promise<void> {\n    return super._tick();\n  }\n}\n\nexport { Process };\n","// ── defineActor — high-level actor wrapper ───────────────────────────────────\n//\n// Compiles a declarative config into an AsyncProcessFn.  Built on top of\n// the existing runDispatchAsync / spawnAsync primitives.\n//\n// See docs/proposals/define-actor-proposal.md for the full design.\n\nimport { runDispatchAsync } from \"./process.async.js\";\nimport type { AsyncProcessFn, Message, ExitMessage } from \"./types.js\";\nimport type { AsyncProcess } from \"./process.async.js\";\nimport type {\n  ActorDefinition,\n  ActorConfig,\n  ActorContext,\n  MethodOptions,\n  ActorMessages,\n  HandlerOptions,\n  HandlerFn,\n} from \"./actor-types.js\";\n\n// ═══════════════════════════════════════════════════════════════════════════════\n// Implementation\n// ═══════════════════════════════════════════════════════════════════════════════\n\nexport function defineMessages<\n  OutMsg extends Message = Message,\n>(): ActorMessages<OutMsg> {\n  return undefined as unknown as ActorMessages<OutMsg>;\n}\n\nexport function defineActor<\n  Args,\n  InternalState,\n  ExposedState,\n  InMsg extends Message,\n  OutMsg extends Message,\n  Methods extends MethodOptions,\n  Handlers extends HandlerOptions<InMsg>,\n>(\n  config: ActorConfig<\n    Args,\n    InternalState,\n    ExposedState,\n    InMsg,\n    OutMsg,\n    Methods,\n    Handlers\n  >,\n): ActorDefinition<Args, ExposedState, InMsg, OutMsg, Handlers> {\n  const fn: AsyncProcessFn<Args, ExposedState, InMsg, OutMsg> =\n    async function* (ctx, args) {\n      let done = false;\n      let exitReason: unknown;\n      let stopRequested = false;\n\n      // Resolve internal state — literal or function of args.\n      const rawState: InternalState =\n        typeof config.initialState === \"function\"\n          ? (\n              config.initialState as (\n                args: Args,\n                ictx: typeof ctx,\n              ) => InternalState\n            )(args, ctx)\n          : config.initialState;\n\n      // Apply expose if provided, otherwise identity.\n      const exposedState: ExposedState = config.expose\n        ? config.expose(rawState)\n        : (rawState as unknown as ExposedState);\n\n      // Build the actor context.\n      const self: ActorContext<\n        Args,\n        InternalState,\n        InMsg,\n        OutMsg,\n        Methods,\n        Handlers\n      > = {\n        ...((config.methods || {}) as Methods),\n        state: rawState,\n        name: ctx.pname,\n        id: ctx.id,\n        emit(msg) {\n          ctx.toParent({\n            ...msg,\n            fromName: ctx.pname,\n            fromId: ctx.id,\n          } as OutMsg);\n        },\n        agreeToStop() {\n          exitReason = \"stopped\";\n          done = true;\n        },\n        exit(reason) {\n          exitReason = reason;\n          done = true;\n        },\n        $child: {},\n        fork(childFn, name, childArgs) {\n          // Unwrap ActorDefinition, pass to ctx.fork.\n          const resolved = typeof childFn === \"function\" ? childFn : childFn.fn;\n          const child = ctx.fork(resolved, name)(childArgs!);\n          self.$child[name] = child as unknown as AsyncProcess<\n            unknown,\n            unknown,\n            Message,\n            Message\n          >;\n          return child;\n        },\n        ctx,\n      };\n\n      // Yield the exposed state — external consumers see this.\n      yield exposedState;\n\n      // Call onStart with args.\n      if (config.onStart) {\n        await config.onStart.call(self, args);\n      }\n\n      // Dispatch loop.\n      yield* runDispatchAsync(\n        ctx.pname,\n        async (msg: InMsg) => {\n          // ── Built-in STOP handling ──────────────────────────────────\n          if (msg.type === \"STOP\") {\n            if (config.onStopRequested) {\n              await config.onStopRequested.call(self);\n              if (!done) {\n                stopRequested = true;\n              }\n            } else {\n              // Default: agree immediately.\n              exitReason = \"stopped\";\n              done = true;\n            }\n            return;\n          }\n\n          // ── Re-offer deferred STOP ──────────────────────────────────\n          if (stopRequested && !done) {\n            if (config.onStopRequested) {\n              await config.onStopRequested.call(self);\n              if (!done) {\n                stopRequested = true;\n              }\n            }\n          }\n\n          // ── Built-in EXIT handling ──────────────────────────────────\n          if (msg.type === \"EXIT\") {\n            const exitMsg = msg as unknown as ExitMessage;\n            const childName = exitMsg.fromName;\n\n            if (childName && self.$child[childName]) {\n              // Recognized child — consume EXIT here.\n              delete self.$child[childName];\n            }\n            if (config.onChildExit) {\n              await config.onChildExit.call(self, childName, exitMsg);\n            }\n            // Unrecognized EXIT — fall through to handlers/onUnhandled.\n          }\n\n          // ── Named handlers ──────────────────────────────────────────\n          if (msg.type !== \"STOP\") {\n            const handler = config.handlers[\n              msg.type as keyof Handlers\n            ] as HandlerFn<InMsg>;\n            if (handler) {\n              await handler.call(self, msg);\n            } else if (config.onUnhandled) {\n              await config.onUnhandled.call(self, msg);\n            }\n            // No onUnhandled: silently drop.\n          }\n\n          if (done) return;\n        },\n        () => done,\n      );\n\n      // Call onEnd.\n      if (config.onEnd) {\n        await config.onEnd.call(self, exitReason ?? \"done\");\n      }\n    };\n\n  return {\n    fn,\n    config: config as unknown as ActorConfig<\n      Args,\n      InternalState,\n      ExposedState,\n      InMsg,\n      OutMsg,\n      {},\n      Handlers\n    >,\n  };\n}\n","/**\n * Posipaki — Erlang-inspired lightweight actor processes built on\n * generator functions. Processes communicate via message-passing,\n * can fork children, and expose their state reactively.\n *\n * @module\n */\n\nimport { Process, spawn } from \"./process\";\nimport { runDispatch } from \"./util\";\nimport { AsyncProcess, spawnAsync, runDispatchAsync } from \"./process.async\";\nimport { asyncify } from \"./adapters\";\n\nexport { Process, spawn, runDispatch };\nexport { AsyncProcess, spawnAsync, runDispatchAsync, asyncify };\n\nexport type {\n  Message,\n  ExitMessage,\n  StopMessage,\n  ProcessFn,\n  ProcessCtx,\n  AsyncProcessFn,\n  PipeState,\n  SupervisorState,\n} from \"./types\";\n\nexport { defineActor, defineMessages } from \"./define-actor.js\";\nexport type {\n  ActorDefinition,\n  ActorConfig,\n  ActorContext,\n  MethodOptions,\n  HandlerOptions,\n  HandlerFn,\n} from \"./actor-types.js\";\n"],"mappings":"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"}
+{"version":3,"file":"index.js","names":[],"sources":["../src/adapters.ts","../src/process.async.ts","../src/process.ts","../src/define-actor.ts","../src/index.ts"],"sourcesContent":["import type { ProcessFn, AsyncProcessFn, Message } from \"./types.js\"\n\nexport function asyncify<A, S, IM extends Message, OM extends Message>(\n  fn: ProcessFn<A, S, IM, OM>,\n): AsyncProcessFn<A, S, IM, OM> {\n  return async function* (ctx, args) {\n    yield* fn(ctx, args) as any\n  }\n}\n","import { defer, makeWaiter, debugLog } from \"./util.js\";\nimport type { DeferredCall, Waiter } from \"./util.js\";\nimport type {\n  Message,\n  WithSender,\n  SenderInfo,\n  ExitMessage,\n  ProcessCtx,\n  AsyncProcessFn,\n  ProcessFn,\n  Fork,\n} from \"./types.js\";\nimport { asyncify } from \"./adapters.js\";\n\n// ---- types ------------------------------------------------------------------\n\n/** An async iterator over process state. Receives `WithSender<InMessage>`. */\ntype AsyncProcessGenerator<ProcessState, InMessage extends Message> =\n  AsyncGenerator<ProcessState | null, void, WithSender<InMessage>>;\n\ntype NotifyFn = () => void;\n\n// ---- runDispatchAsync -------------------------------------------------------\n\ntype AsyncReducer<M> = (msg: M) => Promise<void>;\ntype ReadyFn = () => boolean;\n\n/**\n * Async equivalent of `runDispatch`. Loops, yielding `null` and feeding\n * each incoming message to an `async` reducer. Exits when `readyFn()`\n * returns true.\n */\nexport async function* runDispatchAsync<M>(\n  name: string,\n  fn: AsyncReducer<M>,\n  readyFn: ReadyFn = () => false,\n  debugLevel = false,\n): AsyncGenerator<null, void, M> {\n  let msg: M;\n  while (!readyFn()) {\n    msg = yield null;\n    debugLog(debugLevel, \"msg\", name, \" <- \", msg);\n    await fn(msg);\n  }\n}\n\n// ---- AsyncProcess -----------------------------------------------------------\n\ntype ProcessMessageCb<M> = (msg: M) => void;\n\nconst noop = () => null;\n\n/**\n * A process driven by an async generator. Functionally identical to\n * {@link Process} but supports `await` inside reducers.\n *\n * Messages are processed **one at a time** — if a tick is already\n * in-flight, new messages are buffered and processed when the current\n * tick completes.\n */\nexport class AsyncProcess<\n  Args,\n  State,\n  InMessage extends Message,\n  OutMessage extends Message,\n> {\n  pgenerator: AsyncProcessFn<Args, State, InMessage, OutMessage>;\n  pname: string;\n  /** Called for every message sent via `ctx.toParent`. Receives `WithSender<OutMessage>`. */\n  toParent: ProcessMessageCb<WithSender<OutMessage>>;\n  id: symbol;\n  state: State | null;\n\n  private current: AsyncProcessGenerator<State, InMessage> | null = null;\n  /** Every buffered message carries sender provenance. */\n  private buffer: Array<WithSender<InMessage>> = [];\n  private nextTick: DeferredCall | null = null;\n  private children: Array<AsyncProcess<unknown, unknown, Message, Message>> =\n    [];\n  private subscribers: Array<NotifyFn> = [];\n  private exitWaiter: Waiter;\n  private _isPaused: boolean = false;\n  private _tickInProgress: boolean = false;\n  private _exitReject: ((e: unknown) => void) | null = null;\n  private _ready!: Waiter;\n  private _resolveReady!: () => void;\n\n  constructor(\n    fn: AsyncProcessFn<Args, State, InMessage, OutMessage>,\n    pname: string,\n    toParent: ProcessMessageCb<WithSender<OutMessage>> | undefined,\n  ) {\n    this.pgenerator = fn;\n    this.pname = pname;\n    this.toParent = toParent || (noop as ProcessMessageCb<WithSender<OutMessage>>);\n    this.id = Symbol(pname);\n    this.state = null;\n    this.exitWaiter = makeWaiter();\n    this._ready = makeWaiter();\n    this._resolveReady = this._ready.resolve;\n  }\n\n  /** Promise that resolves once the initial state is available. */\n  ready(): Promise<void> {\n    return this._ready.promise;\n  }\n\n  // ---- lifecycle ------------------------------------------------------------\n\n  /**\n   * Kick off the async generator. The first `yield` sets the initial\n   * state; for async generators this happens in a microtask.\n   */\n  start(arg0: Args) {\n    const selfCtx: SenderInfo = { fromName: this.pname, fromId: this.id };\n\n    const ctx: ProcessCtx<Args, State, InMessage, OutMessage> = {\n      pname: this.pname,\n      id: this.id,\n      fork: this.fork.bind(this),\n      forkSync: this.forkSync.bind(this),\n      sendSelf: (msg) => {\n        this.send([msg, selfCtx]);\n      },\n      toParent: (msg) => {\n        this.toParent([msg, selfCtx] as WithSender<OutMessage>);\n      },\n    };\n\n    this.current = this._watchExit(ctx, arg0);\n    void this.current.next().then((ret: IteratorResult<State | null, void>) => {\n      this.state = ret.value ?? null;\n      this._resolveReady();\n      if (ret.done) {\n        this.exitWaiter.resolve();\n        return;\n      }\n      // Advance past the initial yield so the _watchExit generator\n      // runs its finally block (EXIT/STOP) and the inner generator\n      // enters its dispatch loop.\n      const advance: WithSender<InMessage> = [\n        { type: \"__ADVANCE__\" } as InMessage,\n        { fromName: \"__internal__\", fromId: Symbol(\"__internal__\") } as SenderInfo,\n      ];\n      this._eatResult(this.current!.next(advance));\n    });\n    return this;\n  }\n\n  /** Wrap the user's generator so EXIT/STOP logic fires on completion. */\n  private async *_watchExit(\n    ctx: ProcessCtx<Args, State, InMessage, OutMessage>,\n    arg0: Args,\n  ): AsyncProcessGenerator<State, InMessage> {\n    try {\n      yield* this.pgenerator(ctx, arg0);\n    } finally {\n      this.toAllChildren({ type: \"STOP\" });\n      // ctx.toParent stamps sender info into a WithSender tuple\n      ctx.toParent({ type: \"EXIT\" } as unknown as OutMessage);\n    }\n  }\n\n  // ---- fork -----------------------------------------------------------------\n\n  fork<ChildArgs, ChildState, ChildIM extends Message, ChildOM extends Message>(\n    fn: AsyncProcessFn<ChildArgs, ChildState, ChildIM, ChildOM>,\n    pname: string,\n  ): (\n    args: ChildArgs,\n  ) => AsyncProcess<ChildArgs, ChildState, ChildIM, ChildOM> {\n    return (args: ChildArgs) => {\n      const child = new AsyncProcess<ChildArgs, ChildState, ChildIM, ChildOM>(\n        fn,\n        pname,\n        this.fromChild.bind(this) as unknown as ProcessMessageCb<\n          WithSender<ChildOM>\n        >,\n      );\n      this.children.push(\n        child as unknown as AsyncProcess<unknown, unknown, Message, Message>,\n      );\n      child.start(args);\n      return child;\n    };\n  }\n\n  forkSync<\n    ChildArgs,\n    ChildState,\n    ChildIM extends Message,\n    ChildOM extends Message,\n  >(\n    fn: ProcessFn<ChildArgs, ChildState, ChildIM, ChildOM>,\n    pname: string,\n  ): (\n    args: ChildArgs,\n  ) => AsyncProcess<ChildArgs, ChildState, ChildIM, ChildOM> {\n    return this.fork(asyncify(fn), pname);\n  }\n\n  // ---- message processing ---------------------------------------------------\n\n  protected async _tick(): Promise<void> {\n    if (!this.current || this._tickInProgress) return;\n\n    this._tickInProgress = true;\n    try {\n      let msgAndSender: WithSender<InMessage> | undefined;\n      let ret: IteratorResult<State | null, void> | null = null;\n      while ((msgAndSender = this.buffer.shift()) !== undefined) {\n        ret = await this._safeNext(msgAndSender);\n        if (!ret || ret.done) break;\n      }\n      this.notify();\n      this._eatResult(ret);\n    } catch (e) {\n      this._exitReject?.(e);\n      this._exitReject = null;\n    } finally {\n      this._tickInProgress = false;\n    }\n  }\n\n  /** Call `.next()` and redirect unhandled rejections. */\n  private async _safeNext(\n    msgAndSender: WithSender<InMessage>,\n  ): Promise<IteratorResult<State | null, void> | null> {\n    try {\n      return await this.current!.next(msgAndSender);\n    } catch (e) {\n      this._exitReject?.(e);\n      this._exitReject = null;\n      return { done: true, value: undefined };\n    }\n  }\n\n  private _eatResult(\n    ret:\n      | IteratorResult<State | null, void>\n      | Promise<IteratorResult<State | null, void>>\n      | null,\n  ): void {\n    if (!ret) return;\n    Promise.resolve(ret).then((r) => {\n      if (r.done) {\n        this.exitWaiter.resolve();\n      }\n    });\n  }\n\n  /** Broadcast a message to all children. */\n  toAllChildren(msg: Message): void {\n    const stamp: SenderInfo = { fromName: this.pname, fromId: this.id };\n    this.children.forEach((p) => p.send([msg, stamp] as WithSender<Message>));\n  }\n\n  /** Stamp and enqueue a message from a named sender (external API). */\n  send(msg: InMessage, from: SenderInfo): void;\n  /** Enqueue a pre-stamped message (internal: fromChild, toAllChildren). */\n  send(msgAndSender: WithSender<InMessage>): void;\n  send(msgOrTuple: InMessage | WithSender<InMessage>, from?: SenderInfo): void {\n    if (from !== undefined) {\n      this.buffer.push([msgOrTuple as InMessage, from]);\n    } else {\n      this.buffer.push(msgOrTuple as WithSender<InMessage>);\n    }\n    this._scheduleTick();\n  }\n\n  /**\n   * Synchronously flush the buffer. For sync processes use {@link Process.tick};\n   * for async processes this is **not guaranteed** to process everything\n   * immediately if reducers contain `await`. Prefer `send()` + `await proc.wait()`.\n   */\n  tick(): void {\n    this.nextTick?.flush();\n    this.nextTick = null;\n  }\n\n  private _scheduleTick(): void {\n    if (this._isPaused) return;\n\n    this.nextTick?.cancel();\n    this.nextTick = defer(() => {\n      this.nextTick = null;\n      void this._tick();\n    });\n  }\n\n  // ---- subscribers ----------------------------------------------------------\n\n  notify(): void {\n    this.subscribers.forEach((f) => f());\n  }\n\n  get isListenedTo(): boolean {\n    return this.subscribers.length > 0;\n  }\n\n  subscribe(f: NotifyFn): () => void {\n    this.subscribers.push(f);\n    return () => {\n      const idx = this.subscribers.indexOf(f);\n      if (idx < 0) return;\n      this.subscribers.splice(idx, 1);\n    };\n  }\n\n  // ---- pause / resume -------------------------------------------------------\n\n  pause(): void {\n    this.nextTick?.cancel();\n    this.nextTick = null;\n    this._isPaused = true;\n  }\n\n  resume(): void {\n    this._isPaused = false;\n    this._scheduleTick();\n  }\n\n  // ---- waiting --------------------------------------------------------------\n\n  /**\n   * Returns a promise that resolves when the generator completes, or\n   * rejects if an unhandled error occurs during message processing.\n   */\n  wait(): Promise<void> {\n    return new Promise<void>((resolve, reject) => {\n      this._exitReject = reject;\n\n      this.exitWaiter.promise.then(\n        () => {\n          this._exitReject = null;\n          resolve();\n        },\n        (e) => {\n          this._exitReject = null;\n          reject(e);\n        },\n      );\n    });\n  }\n\n  // ---- child messages -------------------------------------------------------\n\n  /** Relays a child's message to this process. The message already carries\n   *  sender provenance (stamped by the child's `ctx.toParent` wrapper). */\n  private fromChild(msgAndSender: WithSender<InMessage>): void {\n    const [msg, sender] = msgAndSender;\n    if (msg.type === \"EXIT\") {\n      // sender.fromId === child's id (set by child's ctx.toParent wrapper)\n      this.children = this.children.filter((p) => p.id !== sender.fromId);\n    }\n    this.send(msgAndSender);\n  }\n}\n\n// ---- spawnAsync -------------------------------------------------------------\n\n/**\n * Spawn a new async process. Accepts both sync and async process\n * functions — sync ones are automatically wrapped with {@link asyncify}.\n */\nexport function spawnAsync<\n  Args,\n  State,\n  InMessage extends Message = Message,\n  OutMessage extends Message = ExitMessage,\n>(\n  fn: AsyncProcessFn<Args, State, InMessage, OutMessage>,\n  pname: string,\n  toParent?: ProcessMessageCb<WithSender<OutMessage>>,\n): (args: Args) => AsyncProcess<Args, State, InMessage, OutMessage> {\n  return (args: Args) => {\n    const proc = new AsyncProcess<Args, State, InMessage, OutMessage>(\n      fn,\n      pname,\n      toParent,\n    );\n    proc.start(args);\n    return proc;\n  };\n}\n","import { AsyncProcess } from \"./process.async.js\";\nimport { asyncify } from \"./adapters.js\";\nimport type { Message, WithSender, ExitMessage, ProcessFn } from \"./types.js\";\n\nexport type { Message, ProcessFn, ProcessCtx } from \"./types.js\";\nexport { runDispatch } from \"./util.js\";\n\n/** @deprecated Use {@link spawnAsync} instead. */\nexport function spawn<\n  A,\n  S,\n  IM extends Message = Message,\n  OM extends Message = ExitMessage,\n>(\n  fn: ProcessFn<A, S, IM, OM>,\n  pname: string,\n  tp?: (m: WithSender<OM>) => void,\n): (a: A) => Process<A, S, IM, OM> {\n  return (a: A) => new Process(fn, pname, tp).start(a) as Process<A, S, IM, OM>;\n}\n\n/** @deprecated Use {@link AsyncProcess} instead. Sync processes are\n *  wrapped via asyncify internally; spawnAsync handles both. */\nclass Process<\n  A,\n  S,\n  IM extends Message,\n  OM extends Message,\n> extends AsyncProcess<A, S, IM, OM> {\n  constructor(\n    fn: ProcessFn<A, S, IM, OM>,\n    pname: string,\n    tp?: (m: WithSender<OM>) => void,\n  ) {\n    super(asyncify(fn), pname, tp);\n  }\n\n  start(a: A) {\n    super.start(a);\n    return this;\n  }\n  tick(): Promise<void> {\n    return super._tick();\n  }\n}\n\nexport { Process };\n","// ── defineActor — high-level actor wrapper ───────────────────────────────────\n//\n// Compiles a declarative config into an AsyncProcessFn.  Built on top of\n// the existing runDispatchAsync / spawnAsync primitives.\n//\n// See docs/proposals/define-actor-proposal.md for the full design.\n\nimport { runDispatchAsync, spawnAsync } from \"./process.async.js\";\nimport type {\n  SenderInfo,\n  WithSender,\n  AsyncProcessFn,\n  Message,\n  ExitMessage,\n  ProcessCtx,\n} from \"./types.js\";\nimport type { AsyncProcess } from \"./process.async.js\";\nimport type {\n  ActorDefinition,\n  ActorConfig,\n  ActorContext,\n  MethodOptions,\n  ActorMessages,\n  HandlerOptions,\n  HandlerFn,\n} from \"./actor-types.js\";\n\n// ═══════════════════════════════════════════════════════════════════════════════\n// Implementation\n// ═══════════════════════════════════════════════════════════════════════════════\n\nexport function defineMessages<\n  OutMsg extends Message = Message,\n>(): ActorMessages<OutMsg> {\n  return undefined as unknown as ActorMessages<OutMsg>;\n}\n\nexport function defineActor<\n  Args,\n  InternalState,\n  ExposedState,\n  InMsg extends Message,\n  OutMsg extends Message,\n  Methods extends MethodOptions,\n  Handlers extends HandlerOptions<InMsg>,\n>(\n  config: ActorConfig<\n    Args,\n    InternalState,\n    ExposedState,\n    InMsg,\n    OutMsg,\n    Methods,\n    Handlers\n  >,\n): ActorDefinition<Args, ExposedState, InMsg, OutMsg, Handlers> {\n  // Internal generator receives WithSender<InMsg> so sender identity\n  // is directly accessible in the dispatch loop with zero casts.\n  const fn = async function* (\n    ctx: ProcessCtx<Args, ExposedState, InMsg, OutMsg>,\n    args: Args,\n  ): AsyncGenerator<ExposedState | null, void, WithSender<InMsg>> {\n    let done = false;\n    let exitReason: unknown;\n    let stopRequested = false;\n\n    // Resolve internal state — literal or function of args.\n    const rawState: InternalState =\n      typeof config.initialState === \"function\"\n        ? (\n            config.initialState as (\n              args: Args,\n              ictx: typeof ctx,\n            ) => InternalState\n          )(args, ctx)\n        : config.initialState;\n\n    // Apply expose if provided, otherwise identity.\n    const exposedState: ExposedState = config.expose\n      ? config.expose(rawState)\n      : (rawState as unknown as ExposedState);\n\n    // Build the actor context.\n    const self: ActorContext<\n      Args,\n      InternalState,\n      InMsg,\n      OutMsg,\n      Methods,\n      Handlers\n    > = {\n      ...((config.methods || {}) as Methods),\n      state: rawState,\n      name: ctx.pname,\n      id: ctx.id,\n      emit(msg) {\n        ctx.toParent(msg);\n      },\n      agreeToStop() {\n        exitReason = \"stopped\";\n        done = true;\n      },\n      exit(reason) {\n        exitReason = reason;\n        done = true;\n      },\n      $child: {},\n      fork(childFn, name, childArgs) {\n        // Unwrap ActorDefinition, pass to ctx.fork.\n        const resolved = typeof childFn === \"function\" ? childFn : childFn.fn;\n        const child = ctx.fork(resolved, name)(childArgs!);\n        self.$child[name] = child as unknown as AsyncProcess<\n          unknown,\n          unknown,\n          Message,\n          Message\n        >;\n        return child;\n      },\n      ctx,\n    };\n\n    // Yield the exposed state — external consumers see this.\n    yield exposedState;\n\n    // Call onStart with args.\n    if (config.onStart) {\n      await config.onStart.call(self, args);\n    }\n\n    // Dispatch loop..\n    yield* runDispatchAsync<WithSender<InMsg | ExitMessage>>(\n      ctx.pname,\n      async (stamped) => {\n        const [msg, sender] = stamped;\n\n        // ── Built-in STOP handling ──────────────────────────────────\n        if (msg.type === \"STOP\") {\n          if (config.onStopRequested) {\n            await config.onStopRequested.call(self);\n            if (!done) {\n              stopRequested = true;\n            }\n          } else {\n            // Default: agree immediately.\n            exitReason = \"stopped\";\n            done = true;\n          }\n          return;\n        }\n\n        // ── Re-offer deferred STOP ──────────────────────────────────\n        if (stopRequested && !done) {\n          if (config.onStopRequested) {\n            await config.onStopRequested.call(self);\n            if (!done) {\n              stopRequested = true;\n            }\n          }\n        }\n\n        // ── Built-in EXIT handling ──────────────────────────────────\n        if (msg.type === \"EXIT\") {\n          const childName = sender.fromName;\n\n          if (childName && self.$child[childName]) {\n            // Recognized child — consume EXIT here.\n            delete self.$child[childName];\n          }\n          if (config.onChildExit) {\n            await config.onChildExit.call(self, childName, msg as ExitMessage);\n          }\n          // Unrecognized EXIT — fall through to handlers/onUnhandled.\n        }\n\n        // ── Named handlers ──────────────────────────────────────────\n        if (msg.type !== \"STOP\") {\n          const handler = config.handlers[\n            msg.type as keyof Handlers\n          ] as HandlerFn<InMsg>;\n          if (handler) {\n            await handler.call(self, msg as InMsg, sender);\n          } else if (config.onUnhandled) {\n            await config.onUnhandled.call(self, msg as InMsg, sender);\n          }\n          // No onUnhandled: silently drop.\n        }\n\n        if (done) return;\n      },\n      () => done,\n    );\n\n    // Call onEnd.\n    if (config.onEnd) {\n      await config.onEnd.call(self, exitReason ?? \"done\");\n    }\n  };\n\n  return {\n    fn: fn as AsyncProcessFn<Args, ExposedState, InMsg, OutMsg>,\n    config: config as unknown as ActorConfig<\n      Args,\n      InternalState,\n      ExposedState,\n      InMsg,\n      OutMsg,\n      {},\n      Handlers\n    >,\n    spawn(args: Args) {\n      return spawnAsync(\n        fn as AsyncProcessFn<Args, ExposedState, InMsg, OutMsg>,\n        \"actor\",\n      )(args);\n    },\n    spawnAsChild(\n      ctx: ProcessCtx<any, any, any, any>,\n      name: string,\n      args: Args,\n    ) {\n      return ctx.fork(\n        fn as AsyncProcessFn<Args, ExposedState, InMsg, OutMsg>,\n        name,\n      )(args);\n    },\n  };\n}\n","/**\n * Posipaki — Erlang-inspired lightweight actor processes built on\n * generator functions. Processes communicate via message-passing,\n * can fork children, and expose their state reactively.\n *\n * @module\n */\n\nimport { Process, spawn } from \"./process\";\nimport { runDispatch } from \"./util\";\nimport { AsyncProcess, spawnAsync, runDispatchAsync } from \"./process.async\";\nimport { asyncify } from \"./adapters\";\n\nexport { Process, spawn, runDispatch };\nexport { AsyncProcess, spawnAsync, runDispatchAsync, asyncify };\n\nexport type {\n  Message,\n  WithSender,\n  WithoutSender,\n  ExitMessage,\n  StopMessage,\n  ProcessFn,\n  ProcessCtx,\n  AsyncProcessFn,\n  PipeState,\n  SupervisorState,\n  SenderOrigin,\n  SenderInfo,\n} from \"./types\";\n\nexport { defineActor, defineMessages } from \"./define-actor.js\";\nexport type {\n  ActorDefinition,\n  ActorConfig,\n  ActorContext,\n  MethodOptions,\n  HandlerOptions,\n  HandlerFn,\n} from \"./actor-types.js\";\n"],"mappings":";;AAEA,SAAgB,SACd,IAC8B;CAC9B,OAAO,iBAAiB,KAAK,MAAM;EACjC,OAAO,GAAG,KAAK,IAAI;CACrB;AACF;;;;;;;;ACwBA,gBAAuB,iBACrB,MACA,IACA,gBAAyB,OACzB,aAAa,OACkB;CAC/B,IAAI;CACJ,OAAO,CAAC,QAAQ,GAAG;EACjB,MAAM,MAAM;EACZ,SAAS,YAAY,OAAO,MAAM,QAAQ,GAAG;EAC7C,MAAM,GAAG,GAAG;CACd;AACF;AAMA,MAAM,aAAa;;;;;;;;;AAUnB,IAAa,eAAb,MAAa,aAKX;CAsBA,YACE,IACA,OACA,UACA;iBAlBgE;gBAEnB,CAAC;kBACR;kBAEtC,CAAC;qBACoC,CAAC;mBAEX;yBACM;qBACkB;EASnD,KAAK,aAAa;EAClB,KAAK,QAAQ;EACb,KAAK,WAAW,YAAa;EAC7B,KAAK,KAAK,OAAO,KAAK;EACtB,KAAK,QAAQ;EACb,KAAK,aAAa,WAAW;EAC7B,KAAK,SAAS,WAAW;EACzB,KAAK,gBAAgB,KAAK,OAAO;CACnC;;CAGA,QAAuB;EACrB,OAAO,KAAK,OAAO;CACrB;;;;;CAQA,MAAM,MAAY;EAChB,MAAM,UAAsB;GAAE,UAAU,KAAK;GAAO,QAAQ,KAAK;EAAG;EAEpE,MAAM,MAAsD;GAC1D,OAAO,KAAK;GACZ,IAAI,KAAK;GACT,MAAM,KAAK,KAAK,KAAK,IAAI;GACzB,UAAU,KAAK,SAAS,KAAK,IAAI;GACjC,WAAW,QAAQ;IACjB,KAAK,KAAK,CAAC,KAAK,OAAO,CAAC;GAC1B;GACA,WAAW,QAAQ;IACjB,KAAK,SAAS,CAAC,KAAK,OAAO,CAA2B;GACxD;EACF;EAEA,KAAK,UAAU,KAAK,WAAW,KAAK,IAAI;EACxC,KAAU,QAAQ,KAAK,EAAE,MAAM,QAA4C;GACzE,KAAK,QAAQ,IAAI,SAAS;GAC1B,KAAK,cAAc;GACnB,IAAI,IAAI,MAAM;IACZ,KAAK,WAAW,QAAQ;IACxB;GACF;GAIA,MAAM,UAAiC,CACrC,EAAE,MAAM,cAAc,GACtB;IAAE,UAAU;IAAgB,QAAQ,OAAO,cAAc;GAAE,CAC7D;GACA,KAAK,WAAW,KAAK,QAAS,KAAK,OAAO,CAAC;EAC7C,CAAC;EACD,OAAO;CACT;;CAGA,OAAe,WACb,KACA,MACyC;EACzC,IAAI;GACF,OAAO,KAAK,WAAW,KAAK,IAAI;EAClC,UAAU;GACR,KAAK,cAAc,EAAE,MAAM,OAAO,CAAC;GAEnC,IAAI,SAAS,EAAE,MAAM,OAAO,CAA0B;EACxD;CACF;CAIA,KACE,IACA,OAGyD;EACzD,QAAQ,SAAoB;GAC1B,MAAM,QAAQ,IAAI,aAChB,IACA,OACA,KAAK,UAAU,KAAK,IAAI,CAG1B;GACA,KAAK,SAAS,KACZ,KACF;GACA,MAAM,MAAM,IAAI;GAChB,OAAO;EACT;CACF;CAEA,SAME,IACA,OAGyD;EACzD,OAAO,KAAK,KAAK,SAAS,EAAE,GAAG,KAAK;CACtC;CAIA,MAAgB,QAAuB;EACrC,IAAI,CAAC,KAAK,WAAW,KAAK,iBAAiB;EAE3C,KAAK,kBAAkB;EACvB,IAAI;GACF,IAAI;GACJ,IAAI,MAAiD;GACrD,QAAQ,eAAe,KAAK,OAAO,MAAM,OAAO,KAAA,GAAW;IACzD,MAAM,MAAM,KAAK,UAAU,YAAY;IACvC,IAAI,CAAC,OAAO,IAAI,MAAM;GACxB;GACA,KAAK,OAAO;GACZ,KAAK,WAAW,GAAG;EACrB,SAAS,GAAG;GACV,KAAK,cAAc,CAAC;GACpB,KAAK,cAAc;EACrB,UAAU;GACR,KAAK,kBAAkB;EACzB;CACF;;CAGA,MAAc,UACZ,cACoD;EACpD,IAAI;GACF,OAAO,MAAM,KAAK,QAAS,KAAK,YAAY;EAC9C,SAAS,GAAG;GACV,KAAK,cAAc,CAAC;GACpB,KAAK,cAAc;GACnB,OAAO;IAAE,MAAM;IAAM,OAAO,KAAA;GAAU;EACxC;CACF;CAEA,WACE,KAIM;EACN,IAAI,CAAC,KAAK;EACV,QAAQ,QAAQ,GAAG,EAAE,MAAM,MAAM;GAC/B,IAAI,EAAE,MACJ,KAAK,WAAW,QAAQ;EAE5B,CAAC;CACH;;CAGA,cAAc,KAAoB;EAChC,MAAM,QAAoB;GAAE,UAAU,KAAK;GAAO,QAAQ,KAAK;EAAG;EAClE,KAAK,SAAS,SAAS,MAAM,EAAE,KAAK,CAAC,KAAK,KAAK,CAAwB,CAAC;CAC1E;CAMA,KAAK,YAA+C,MAAyB;EAC3E,IAAI,SAAS,KAAA,GACX,KAAK,OAAO,KAAK,CAAC,YAAyB,IAAI,CAAC;OAEhD,KAAK,OAAO,KAAK,UAAmC;EAEtD,KAAK,cAAc;CACrB;;;;;;CAOA,OAAa;EACX,KAAK,UAAU,MAAM;EACrB,KAAK,WAAW;CAClB;CAEA,gBAA8B;EAC5B,IAAI,KAAK,WAAW;EAEpB,KAAK,UAAU,OAAO;EACtB,KAAK,WAAW,YAAY;GAC1B,KAAK,WAAW;GAChB,KAAU,MAAM;EAClB,CAAC;CACH;CAIA,SAAe;EACb,KAAK,YAAY,SAAS,MAAM,EAAE,CAAC;CACrC;CAEA,IAAI,eAAwB;EAC1B,OAAO,KAAK,YAAY,SAAS;CACnC;CAEA,UAAU,GAAyB;EACjC,KAAK,YAAY,KAAK,CAAC;EACvB,aAAa;GACX,MAAM,MAAM,KAAK,YAAY,QAAQ,CAAC;GACtC,IAAI,MAAM,GAAG;GACb,KAAK,YAAY,OAAO,KAAK,CAAC;EAChC;CACF;CAIA,QAAc;EACZ,KAAK,UAAU,OAAO;EACtB,KAAK,WAAW;EAChB,KAAK,YAAY;CACnB;CAEA,SAAe;EACb,KAAK,YAAY;EACjB,KAAK,cAAc;CACrB;;;;;CAQA,OAAsB;EACpB,OAAO,IAAI,SAAe,SAAS,WAAW;GAC5C,KAAK,cAAc;GAEnB,KAAK,WAAW,QAAQ,WAChB;IACJ,KAAK,cAAc;IACnB,QAAQ;GACV,IACC,MAAM;IACL,KAAK,cAAc;IACnB,OAAO,CAAC;GACV,CACF;EACF,CAAC;CACH;;;CAMA,UAAkB,cAA2C;EAC3D,MAAM,CAAC,KAAK,UAAU;EACtB,IAAI,IAAI,SAAS,QAEf,KAAK,WAAW,KAAK,SAAS,QAAQ,MAAM,EAAE,OAAO,OAAO,MAAM;EAEpE,KAAK,KAAK,YAAY;CACxB;AACF;;;;;AAQA,SAAgB,WAMd,IACA,OACA,UACkE;CAClE,QAAQ,SAAe;EACrB,MAAM,OAAO,IAAI,aACf,IACA,OACA,QACF;EACA,KAAK,MAAM,IAAI;EACf,OAAO;CACT;AACF;;;;ACxXA,SAAgB,MAMd,IACA,OACA,IACiC;CACjC,QAAQ,MAAS,IAAI,QAAQ,IAAI,OAAO,EAAE,EAAE,MAAM,CAAC;AACrD;;;AAIA,IAAM,UAAN,cAKU,aAA2B;CACnC,YACE,IACA,OACA,IACA;EACA,MAAM,SAAS,EAAE,GAAG,OAAO,EAAE;CAC/B;CAEA,MAAM,GAAM;EACV,MAAM,MAAM,CAAC;EACb,OAAO;CACT;CACA,OAAsB;EACpB,OAAO,MAAM,MAAM;CACrB;AACF;;;ACbA,SAAgB,iBAEW,CAE3B;AAEA,SAAgB,YASd,QAS8D;CAG9D,MAAM,KAAK,iBACT,KACA,MAC8D;EAC9D,IAAI,OAAO;EACX,IAAI;EACJ,IAAI,gBAAgB;EAGpB,MAAM,WACJ,OAAO,OAAO,iBAAiB,aAEzB,OAAO,aAIP,MAAM,GAAG,IACX,OAAO;EAGb,MAAM,eAA6B,OAAO,SACtC,OAAO,OAAO,QAAQ,IACrB;EAGL,MAAM,OAOF;GACF,GAAK,OAAO,WAAW,CAAC;GACxB,OAAO;GACP,MAAM,IAAI;GACV,IAAI,IAAI;GACR,KAAK,KAAK;IACR,IAAI,SAAS,GAAG;GAClB;GACA,cAAc;IACZ,aAAa;IACb,OAAO;GACT;GACA,KAAK,QAAQ;IACX,aAAa;IACb,OAAO;GACT;GACA,QAAQ,CAAC;GACT,KAAK,SAAS,MAAM,WAAW;IAE7B,MAAM,WAAW,OAAO,YAAY,aAAa,UAAU,QAAQ;IACnE,MAAM,QAAQ,IAAI,KAAK,UAAU,IAAI,EAAE,SAAU;IACjD,KAAK,OAAO,QAAQ;IAMpB,OAAO;GACT;GACA;EACF;EAGA,MAAM;EAGN,IAAI,OAAO,SACT,MAAM,OAAO,QAAQ,KAAK,MAAM,IAAI;EAItC,OAAO,iBACL,IAAI,OACJ,OAAO,YAAY;GACjB,MAAM,CAAC,KAAK,UAAU;GAGtB,IAAI,IAAI,SAAS,QAAQ;IACvB,IAAI,OAAO,iBAAiB;KAC1B,MAAM,OAAO,gBAAgB,KAAK,IAAI;KACtC,IAAI,CAAC,MACH,gBAAgB;IAEpB,OAAO;KAEL,aAAa;KACb,OAAO;IACT;IACA;GACF;GAGA,IAAI,iBAAiB,CAAC;QAChB,OAAO,iBAAiB;KAC1B,MAAM,OAAO,gBAAgB,KAAK,IAAI;KACtC,IAAI,CAAC,MACH,gBAAgB;IAEpB;;GAIF,IAAI,IAAI,SAAS,QAAQ;IACvB,MAAM,YAAY,OAAO;IAEzB,IAAI,aAAa,KAAK,OAAO,YAE3B,OAAO,KAAK,OAAO;IAErB,IAAI,OAAO,aACT,MAAM,OAAO,YAAY,KAAK,MAAM,WAAW,GAAkB;GAGrE;GAGA,IAAI,IAAI,SAAS,QAAQ;IACvB,MAAM,UAAU,OAAO,SACrB,IAAI;IAEN,IAAI,SACF,MAAM,QAAQ,KAAK,MAAM,KAAc,MAAM;SACxC,IAAI,OAAO,aAChB,MAAM,OAAO,YAAY,KAAK,MAAM,KAAc,MAAM;GAG5D;GAEA,IAAI,MAAM;EACZ,SACM,IACR;EAGA,IAAI,OAAO,OACT,MAAM,OAAO,MAAM,KAAK,MAAM,cAAc,MAAM;CAEtD;CAEA,OAAO;EACD;EACI;EASR,MAAM,MAAY;GAChB,OAAO,WACL,IACA,OACF,EAAE,IAAI;EACR;EACA,aACE,KACA,MACA,MACA;GACA,OAAO,IAAI,KACT,IACA,IACF,EAAE,IAAI;EACR;CACF;AACF"}

package/dist/pipe.d.ts

@@ -1,4 +1,4 @@
-import { c as ExitMessage, f as ProcessFn, l as Message } from "./process-C-ERBQY5.js";
+import { c as ExitMessage, f as ProcessFn, l as Message } from "./process-BiX7Ena4.js";
 
 //#region src/pipe.d.ts
 /**

package/dist/pipe.js

@@ -24,13 +24,14 @@ function pipe(fns) {
 		}
 		spawnNext();
 		state.running = hasNext();
-		yield* runDispatch(ctx.pname, (msg) => {
+		yield* runDispatch(ctx.pname, (maybe) => {
+			const [msg, _sender] = maybe;
 			if (msg.type === "STOP") {
 				state.params = null;
 				state.running = false;
 				return;
 			}
-			if (msg.type === "EXIT" && msg.pid === task.id) if (hasNext()) {
+			if (msg.type === "EXIT" && _sender.fromId === task.id) if (hasNext()) {
 				state.params = {
 					...state.params,
 					...task.state?.result

package/dist/pipe.js.map

@@ -1 +1 @@
-{"version":3,"file":"pipe.js","names":[],"sources":["../src/pipe.ts"],"sourcesContent":["import { runDispatch } from \"./util.js\";\nimport type { ExitMessage } from \"./util.js\";\nimport type { ProcessFn, ProcessCtx } from \"./process.js\";\nimport type { AsyncProcess } from \"./process.async.js\";\nimport type { Message } from \"./types.js\";\n\n/**\n * State yielded by the pipe process. `params` starts as a copy of the\n * initial args and is updated after each child exits by merging the\n * child's `state.result` into it.\n */\nexport interface PipeState<Params, Result> {\n  params: Params | null;\n  result: Result | null;\n  running: boolean;\n}\n\n/**\n * Chain process functions so each runs after the previous one exits.\n * The `.state.result` of each completed child is spread into the params\n * of the next.\n */\nfunction pipe<Params, Result>(\n  fns: ProcessFn<unknown, unknown, Message, Message>[],\n): ProcessFn<\n  Params,\n  PipeState<Params, Result>,\n  Message,\n  Message | ExitMessage\n> {\n  return function* (\n    ctx: ProcessCtx<\n      Params,\n      PipeState<Params, Result>,\n      Message,\n      Message | ExitMessage\n    >,\n    params: Params,\n  ) {\n    const state: PipeState<Params, Result> = {\n      params: { ...params },\n      result: null,\n      running: false,\n    };\n    yield state;\n\n    const queue = [...fns];\n    let task: AsyncProcess<any, any, any, any>;\n\n    function spawnNext(): void {\n      const fn = queue.shift()!;\n      task = ctx.forkSync(\n        fn,\n        `${ctx.pname} [${fn.name || \"<anonymous>\"}]`,\n      )(state.params as Params);\n    }\n\n    function hasNext(): boolean {\n      return queue.length > 0;\n    }\n\n    spawnNext();\n    state.running = hasNext();\n\n    yield* runDispatch<Message | ExitMessage>(\n      ctx.pname,\n      (msg) => {\n        if (msg.type === \"STOP\") {\n          state.params = null;\n          state.running = false;\n          return;\n        }\n\n        if (msg.type === \"EXIT\" && (msg as ExitMessage).pid === task.id) {\n          if (hasNext()) {\n            state.params = {\n              ...state.params!,\n              ...task.state?.result,\n            } as Params;\n            spawnNext();\n          } else {\n            state.running = false;\n            state.result = task.state?.result as Result;\n          }\n        }\n      },\n      () => !state.running,\n      true,\n    );\n  };\n}\n\nexport { pipe };\n"],"mappings":";;;;;;;AAsBA,SAAS,KACP,KAMA;CACA,OAAO,WACL,KAMA,QACA;EACA,MAAM,QAAmC;GACvC,QAAQ,EAAE,GAAG,OAAO;GACpB,QAAQ;GACR,SAAS;EACX;EACA,MAAM;EAEN,MAAM,QAAQ,CAAC,GAAG,GAAG;EACrB,IAAI;EAEJ,SAAS,YAAkB;GACzB,MAAM,KAAK,MAAM,MAAM;GACvB,OAAO,IAAI,SACT,IACA,GAAG,IAAI,MAAM,IAAI,GAAG,QAAQ,cAAc,EAC5C,EAAE,MAAM,MAAgB;EAC1B;EAEA,SAAS,UAAmB;GAC1B,OAAO,MAAM,SAAS;EACxB;EAEA,UAAU;EACV,MAAM,UAAU,QAAQ;EAExB,OAAO,YACL,IAAI,QACH,QAAQ;GACP,IAAI,IAAI,SAAS,QAAQ;IACvB,MAAM,SAAS;IACf,MAAM,UAAU;IAChB;GACF;GAEA,IAAI,IAAI,SAAS,UAAW,IAAoB,QAAQ,KAAK,IAC3D,IAAI,QAAQ,GAAG;IACb,MAAM,SAAS;KACb,GAAG,MAAM;KACT,GAAG,KAAK,OAAO;IACjB;IACA,UAAU;GACZ,OAAO;IACL,MAAM,UAAU;IAChB,MAAM,SAAS,KAAK,OAAO;GAC7B;EAEJ,SACM,CAAC,MAAM,SACb,IACF;CACF;AACF"}
+{"version":3,"file":"pipe.js","names":[],"sources":["../src/pipe.ts"],"sourcesContent":["import { runDispatch } from \"./util.js\";\nimport type { ExitMessage } from \"./util.js\";\nimport type { ProcessFn, ProcessCtx } from \"./process.js\";\nimport type { AsyncProcess } from \"./process.async.js\";\nimport type { Message, WithSender, SenderInfo } from \"./types.js\";\n\n/**\n * State yielded by the pipe process. `params` starts as a copy of the\n * initial args and is updated after each child exits by merging the\n * child's `state.result` into it.\n */\nexport interface PipeState<Params, Result> {\n  params: Params | null;\n  result: Result | null;\n  running: boolean;\n}\n\n/**\n * Chain process functions so each runs after the previous one exits.\n * The `.state.result` of each completed child is spread into the params\n * of the next.\n */\nfunction pipe<Params, Result>(\n  fns: ProcessFn<unknown, unknown, Message, Message>[],\n): ProcessFn<\n  Params,\n  PipeState<Params, Result>,\n  Message,\n  Message | ExitMessage\n> {\n  return function* (\n    ctx: ProcessCtx<\n      Params,\n      PipeState<Params, Result>,\n      Message,\n      Message | ExitMessage\n    >,\n    params: Params,\n  ) {\n    const state: PipeState<Params, Result> = {\n      params: { ...params },\n      result: null,\n      running: false,\n    };\n    yield state;\n\n    const queue = [...fns];\n    let task: AsyncProcess<any, any, any, any>;\n\n    function spawnNext(): void {\n      const fn = queue.shift()!;\n      task = ctx.forkSync(\n        fn,\n        `${ctx.pname} [${fn.name || \"<anonymous>\"}]`,\n      )(state.params as Params);\n    }\n\n    function hasNext(): boolean {\n      return queue.length > 0;\n    }\n\n    spawnNext();\n    state.running = hasNext();\n\n    yield* runDispatch<WithSender<Message | ExitMessage>>(\n      ctx.pname,\n      (maybe) => {\n        const [msg, _sender] = maybe;\n\n        if (msg.type === \"STOP\") {\n          state.params = null;\n          state.running = false;\n          return;\n        }\n\n        if (msg.type === \"EXIT\" && _sender.fromId === task.id) {\n          if (hasNext()) {\n            state.params = {\n              ...state.params!,\n              ...task.state?.result,\n            } as Params;\n            spawnNext();\n          } else {\n            state.running = false;\n            state.result = task.state?.result as Result;\n          }\n        }\n      },\n      () => !state.running,\n      true,\n    );\n  };\n}\n\nexport { pipe };\n"],"mappings":";;;;;;;AAsBA,SAAS,KACP,KAMA;CACA,OAAO,WACL,KAMA,QACA;EACA,MAAM,QAAmC;GACvC,QAAQ,EAAE,GAAG,OAAO;GACpB,QAAQ;GACR,SAAS;EACX;EACA,MAAM;EAEN,MAAM,QAAQ,CAAC,GAAG,GAAG;EACrB,IAAI;EAEJ,SAAS,YAAkB;GACzB,MAAM,KAAK,MAAM,MAAM;GACvB,OAAO,IAAI,SACT,IACA,GAAG,IAAI,MAAM,IAAI,GAAG,QAAQ,cAAc,EAC5C,EAAE,MAAM,MAAgB;EAC1B;EAEA,SAAS,UAAmB;GAC1B,OAAO,MAAM,SAAS;EACxB;EAEA,UAAU;EACV,MAAM,UAAU,QAAQ;EAExB,OAAO,YACL,IAAI,QACH,UAAU;GACT,MAAM,CAAC,KAAK,WAAW;GAEvB,IAAI,IAAI,SAAS,QAAQ;IACvB,MAAM,SAAS;IACf,MAAM,UAAU;IAChB;GACF;GAEA,IAAI,IAAI,SAAS,UAAU,QAAQ,WAAW,KAAK,IACjD,IAAI,QAAQ,GAAG;IACb,MAAM,SAAS;KACb,GAAG,MAAM;KACT,GAAG,KAAK,OAAO;IACjB;IACA,UAAU;GACZ,OAAO;IACL,MAAM,UAAU;IAChB,MAAM,SAAS,KAAK,OAAO;GAC7B;EAEJ,SACM,CAAC,MAAM,SACb,IACF;CACF;AACF"}

package/dist/{process-C-ERBQY5.d.ts → process-BiX7Ena4.d.ts}

@@ -4,24 +4,30 @@
 interface Message {
   type: string;
 }
-/** Message emitted by a process to its parent when it terminates.
- *
- * `fromId` and `pid` carry the same symbol value.  `fromName` is the
- * process name (same as `ctx.pname`).  These fields mirror what
- * `this.emit()` / `ctx.toParent()` stamp on normal messages, so
- * callers can identify the sender of any child message — application
- * or EXIT — by reading `msg.fromName` or `msg.fromId`. */
-type ExitMessage = {
-  type: "EXIT"; /** @deprecated Use {@link fromId} instead. */
-  pid: symbol;
+/** Sender identity.  `fromName` is the process name, `fromId` its symbol. */
+interface SenderInfo {
   fromName: string;
   fromId: symbol;
+}
+/** A message paired with its sender.  This is the currency inside the
+ *  framework — every message in the buffer and every value the generator
+ *  receives is `WithSender<M>`. */
+type WithSender<M extends Message> = [M, SenderInfo];
+/** Extract the message type from a stamped tuple. */
+type WithoutSender<T extends WithSender<any>> = T[0];
+/** Message emitted by a process to its parent when it terminates.
+ *  The sender's identity is carried in the {@link SenderInfo} tuple. */
+type ExitMessage = {
+  type: "EXIT";
 };
 type StopMessage = {
   type: "STOP";
 };
-type ProcessFn<Args, State, InMessage extends Message, OutMessage extends Message> = (ctx: ProcessCtx<Args, State, InMessage, OutMessage>, args: Args) => Generator<State | null, void, InMessage>;
-type AsyncProcessFn<Args, State, InMessage extends Message, OutMessage extends Message> = (ctx: ProcessCtx<Args, State, InMessage, OutMessage>, args: Args) => AsyncGenerator<State | null, void, InMessage>;
+type ProcessFn<Args, State, InMessage extends Message, OutMessage extends Message> = (ctx: ProcessCtx<Args, State, InMessage, OutMessage>, args: Args) => Generator<State | null, void, WithSender<InMessage>>;
+type AsyncProcessFn<Args, State, InMessage extends Message, OutMessage extends Message> = (ctx: ProcessCtx<Args, State, InMessage, OutMessage>, args: Args) => AsyncGenerator<State | null, void, WithSender<InMessage>>;
+/** Origin of a message — either a process context or the literal "root"
+ *  (used by the system harness to inject messages from outside). */
+type SenderOrigin = ProcessCtx<unknown, unknown, Message, Message> | "root";
 type ProcessMessageCb$1<M> = (msg: M) => void;
 /** Fork a child process. Takes a ProcessFn and a name, returns a
  *  curried function that accepts the child's initial args. */
@@ -29,7 +35,7 @@ type ProcessMessageCb$1<M> = (msg: M) => void;
 type ProcessCtx<Args, State, IM extends Message, OM extends Message> = {
   pname: string;
   id: symbol;
-  send: (msg: IM) => void;
+  sendSelf: (msg: IM) => void;
   toParent: ProcessMessageCb$1<OM>;
 } & Pick<AsyncProcess<Args, State, IM, OM>, "fork" | "forkSync">;
 /** State yielded by the pipe process. */
@@ -66,10 +72,12 @@ type ProcessMessageCb<M> = (msg: M) => void;
 declare class AsyncProcess<Args, State, InMessage extends Message, OutMessage extends Message> {
   pgenerator: AsyncProcessFn<Args, State, InMessage, OutMessage>;
   pname: string;
-  toParent: ProcessMessageCb<OutMessage>;
+  /** Called for every message sent via `ctx.toParent`. Receives `WithSender<OutMessage>`. */
+  toParent: ProcessMessageCb<WithSender<OutMessage>>;
   id: symbol;
   state: State | null;
   private current;
+  /** Every buffered message carries sender provenance. */
   private buffer;
   private nextTick;
   private children;
@@ -80,7 +88,7 @@ declare class AsyncProcess<Args, State, InMessage extends Message, OutMessage ex
   private _exitReject;
   private _ready;
   private _resolveReady;
-  constructor(fn: AsyncProcessFn<Args, State, InMessage, OutMessage>, pname: string, toParent: ProcessMessageCb<OutMessage> | undefined);
+  constructor(fn: AsyncProcessFn<Args, State, InMessage, OutMessage>, pname: string, toParent: ProcessMessageCb<WithSender<OutMessage>> | undefined);
   /** Promise that resolves once the initial state is available. */
   ready(): Promise<void>;
   /**
@@ -98,8 +106,10 @@ declare class AsyncProcess<Args, State, InMessage extends Message, OutMessage ex
   private _eatResult;
   /** Broadcast a message to all children. */
   toAllChildren(msg: Message): void;
-  /** Enqueue a message. Processing is async (microtask). */
-  send(msg: InMessage): void;
+  /** Stamp and enqueue a message from a named sender (external API). */
+  send(msg: InMessage, from: SenderInfo): void;
+  /** Enqueue a pre-stamped message (internal: fromChild, toAllChildren). */
+  send(msgAndSender: WithSender<InMessage>): void;
   /**
    * Synchronously flush the buffer. For sync processes use {@link Process.tick};
    * for async processes this is **not guaranteed** to process everything
@@ -117,13 +127,15 @@ declare class AsyncProcess<Args, State, InMessage extends Message, OutMessage ex
    * rejects if an unhandled error occurs during message processing.
    */
   wait(): Promise<void>;
+  /** Relays a child's message to this process. The message already carries
+   *  sender provenance (stamped by the child's `ctx.toParent` wrapper). */
   private fromChild;
 }
 /**
  * Spawn a new async process. Accepts both sync and async process
  * functions — sync ones are automatically wrapped with {@link asyncify}.
  */
-declare function spawnAsync<Args, State, InMessage extends Message = Message, OutMessage extends Message = ExitMessage>(fn: AsyncProcessFn<Args, State, InMessage, OutMessage>, pname: string, toParent?: ProcessMessageCb<OutMessage>): (args: Args) => AsyncProcess<Args, State, InMessage, OutMessage>;
+declare function spawnAsync<Args, State, InMessage extends Message = Message, OutMessage extends Message = ExitMessage>(fn: AsyncProcessFn<Args, State, InMessage, OutMessage>, pname: string, toParent?: ProcessMessageCb<WithSender<OutMessage>>): (args: Args) => AsyncProcess<Args, State, InMessage, OutMessage>;
 //#endregion
 //#region src/util.d.ts
 type ReducerClosure<M> = (msg: M) => void;
@@ -135,6 +147,8 @@ type ReadyFn = () => boolean;
  */
 declare function runDispatch<M>(name: string, fn: ReducerClosure<M>, readyFn?: ReadyFn, debugLevel?: boolean): Generator<null, void, M>;
 /**
+* @deprecated Use AsyncProcess._watchExit instead.
+ *
  * Wrap a process generator so that on completion it sends STOP to
  * all children and EXIT to the parent. Useful for custom process
  * wrappers that need lifecycle management without extending
@@ -142,12 +156,15 @@ declare function runDispatch<M>(name: string, fn: ReducerClosure<M>, readyFn?: R
  */
 //#endregion
 //#region src/process.d.ts
-declare function spawn<A, S, IM extends Message = Message, OM extends Message = ExitMessage>(fn: ProcessFn<A, S, IM, OM>, pname: string, tp?: (m: OM) => void): (a: A) => Process<A, S, IM, OM>;
+/** @deprecated Use {@link spawnAsync} instead. */
+declare function spawn<A, S, IM extends Message = Message, OM extends Message = ExitMessage>(fn: ProcessFn<A, S, IM, OM>, pname: string, tp?: (m: WithSender<OM>) => void): (a: A) => Process<A, S, IM, OM>;
+/** @deprecated Use {@link AsyncProcess} instead. Sync processes are
+ *  wrapped via asyncify internally; spawnAsync handles both. */
 declare class Process<A, S, IM extends Message, OM extends Message> extends AsyncProcess<A, S, IM, OM> {
-  constructor(fn: ProcessFn<A, S, IM, OM>, pname: string, tp?: (m: OM) => void);
+  constructor(fn: ProcessFn<A, S, IM, OM>, pname: string, tp?: (m: WithSender<OM>) => void);
   start(a: A): this;
   tick(): Promise<void>;
 }
 //#endregion
-export { runDispatchAsync as a, ExitMessage as c, ProcessCtx as d, ProcessFn as f, AsyncProcess as i, Message as l, SupervisorState as m, spawn as n, spawnAsync as o, StopMessage as p, runDispatch as r, AsyncProcessFn as s, Process as t, PipeState as u };
-//# sourceMappingURL=process-C-ERBQY5.d.ts.map
+export { WithSender as _, runDispatchAsync as a, ExitMessage as c, ProcessCtx as d, ProcessFn as f, SupervisorState as g, StopMessage as h, AsyncProcess as i, Message as l, SenderOrigin as m, spawn as n, spawnAsync as o, SenderInfo as p, runDispatch as r, AsyncProcessFn as s, Process as t, PipeState as u, WithoutSender as v };
+//# sourceMappingURL=process-BiX7Ena4.d.ts.map

package/dist/process-BiX7Ena4.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"process-BiX7Ena4.d.ts","names":[],"sources":["../src/types.ts","../src/process.async.ts","../src/util.ts","../src/process.ts"],"mappings":";AAkBA;;AAAA,UAPiB,OAAA;EACf,IAAI;AAAA;AAgBN;AAAA,UAViB,UAAA;EACf,QAAA;EACA,MAAM;AAAA;;;;KAQI,UAAA,WAAqB,OAAA,KAAY,CAAA,EAAG,UAAA;;KAGpC,aAAA,WAAwB,UAAA,SAAmB,CAAC;;;KAM5C,WAAA;EACV,IAAI;AAAA;AAAA,KAGM,WAAA;EACV,IAAI;AAAA;AAAA,KAKM,SAAA,gCAGQ,OAAA,qBACC,OAAA,KAEnB,GAAA,EAAK,UAAA,CAAW,IAAA,EAAM,KAAA,EAAO,SAAA,EAAW,UAAA,GACxC,IAAA,EAAM,IAAA,KACH,SAAA,CAAU,KAAA,eAAoB,UAAA,CAAW,SAAA;AAAA,KAIlC,cAAA,gCAGQ,OAAA,qBACC,OAAA,KAEnB,GAAA,EAAK,UAAA,CAAW,IAAA,EAAM,KAAA,EAAO,SAAA,EAAW,UAAA,GACxC,IAAA,EAAM,IAAA,KACH,cAAA,CAAe,KAAA,eAAoB,UAAA,CAAW,SAAA;;AApCK;KA0C5C,YAAA,GACR,UAAA,mBAA6B,OAAA,EAAS,OAAA;AAAA,KAKrC,kBAAA,OAAuB,GAAA,EAAK,CAAC;;;;KAyBtB,UAAA,yBAAmC,OAAA,aAAoB,OAAA;EACjE,KAAA;EACA,EAAA;EACA,QAAA,GAAW,GAAA,EAAK,EAAA;EAChB,QAAA,EAAU,kBAAA,CAAiB,EAAA;AAAA,IACzB,IAAA,CAAK,YAAA,CAAa,IAAA,EAAM,KAAA,EAAO,EAAA,EAAI,EAAA;;UAKtB,SAAA;EACf,MAAA,EAAQ,MAAA;EACR,MAAA,EAAQ,MAAM;EACd,OAAA;AAAA;;UAMe,eAAA;EACf,SAAA;EACA,KAAK;AAAA;;;KCzGF,QAAA;AAAA,KAIA,YAAA,OAAmB,GAAA,EAAK,CAAA,KAAM,OAAO;AAAA,KACrC,SAAA;;ADbC;AAMN;;;iBCcuB,gBAAA,IACrB,IAAA,UACA,EAAA,EAAI,YAAA,CAAa,CAAA,GACjB,OAAA,GAAS,SAAA,EACT,UAAA,aACC,cAAA,aAA2B,CAAA;AAAA,KAWzB,gBAAA,OAAuB,GAAA,EAAK,CAAC;ADpBlC;;;;;;;;AAAA,cCgCa,YAAA,gCAGO,OAAA,qBACC,OAAA;EAEnB,UAAA,EAAY,cAAA,CAAe,IAAA,EAAM,KAAA,EAAO,SAAA,EAAW,UAAA;EACnD,KAAA;EDvC8C;ECyC9C,QAAA,EAAU,gBAAA,CAAiB,UAAA,CAAW,UAAA;EACtC,EAAA;EACA,KAAA,EAAO,KAAA;EAAA,QAEC,OAAA;ED1Ce;EAAA,QC4Cf,MAAA;EAAA,QACA,QAAA;EAAA,QACA,QAAA;EAAA,QAEA,WAAA;EAAA,QACA,UAAA;EAAA,QACA,SAAA;EAAA,QACA,eAAA;EAAA,QACA,WAAA;EAAA,QACA,MAAA;EAAA,QACA,aAAA;cAGN,EAAA,EAAI,cAAA,CAAe,IAAA,EAAM,KAAA,EAAO,SAAA,EAAW,UAAA,GAC3C,KAAA,UACA,QAAA,EAAU,gBAAA,CAAiB,UAAA,CAAW,UAAA;EDjD9B;EC8DV,KAAA,IAAS,OAAA;;;AD7DL;AAKN;ECkEE,KAAA,CAAM,IAAA,EAAM,IAAA;EDlEO;EAAA,QCuGJ,UAAA;EAef,IAAA,wCAA4C,OAAA,kBAAyB,OAAA,EACnE,EAAA,EAAI,cAAA,CAAe,SAAA,EAAW,UAAA,EAAY,OAAA,EAAS,OAAA,GACnD,KAAA,YAEA,IAAA,EAAM,SAAA,KACH,YAAA,CAAa,SAAA,EAAW,UAAA,EAAY,OAAA,EAAS,OAAA;EAiBlD,QAAA,wCAGkB,OAAA,kBACA,OAAA,EAEhB,EAAA,EAAI,SAAA,CAAU,SAAA,EAAW,UAAA,EAAY,OAAA,EAAS,OAAA,GAC9C,KAAA,YAEA,IAAA,EAAM,SAAA,KACH,YAAA,CAAa,SAAA,EAAW,UAAA,EAAY,OAAA,EAAS,OAAA;EAAA,UAMlC,KAAA,IAAS,OAAA;EDtJI;EAAA,QC4Kf,SAAA;EAAA,QAYN,UAAA;EDvLF;ECsMN,aAAA,CAAc,GAAA,EAAK,OAAA;EDrMyB;EC2M5C,IAAA,CAAK,GAAA,EAAK,SAAA,EAAW,IAAA,EAAM,UAAA;ED3MxB;EC6MH,IAAA,CAAK,YAAA,EAAc,UAAA,CAAW,SAAA;ED7MlB;;;;;EC4NZ,IAAA;EAAA,QAKQ,aAAA;EAYR,MAAA;EAAA,IAII,YAAA;EAIJ,SAAA,CAAU,CAAA,EAAG,QAAA;EAWb,KAAA;EAMA,MAAA;EDxQA;;;;ECmRA,IAAA,IAAQ,OAAA;EDjRyB;;EAAA,QCsSzB,SAAA;AAAA;ADlSV;;;;AAAA,iBCkTgB,UAAA,gCAGI,OAAA,GAAU,OAAA,qBACT,OAAA,GAAU,WAAA,EAE7B,EAAA,EAAI,cAAA,CAAe,IAAA,EAAM,KAAA,EAAO,SAAA,EAAW,UAAA,GAC3C,KAAA,UACA,QAAA,GAAW,gBAAA,CAAiB,UAAA,CAAW,UAAA,MACrC,IAAA,EAAM,IAAA,KAAS,YAAA,CAAa,IAAA,EAAM,KAAA,EAAO,SAAA,EAAW,UAAA;;;KC/WnD,cAAA,OAAqB,GAAA,EAAK,CAAC;AAAA,KAC3B,OAAA;AFIC;AAMN;;;;AANM,iBEII,WAAA,IACR,IAAA,UACA,EAAA,EAAI,cAAA,CAAe,CAAA,GACnB,OAAA,GAAS,OAAA,EACT,UAAA,aACC,SAAA,aAAsB,CAAA;AFOzB;;;;;;;;;;;iBGpBgB,KAAA,kBAGH,OAAA,GAAU,OAAA,aACV,OAAA,GAAU,WAAA,EAErB,EAAA,EAAI,SAAA,CAAU,CAAA,EAAG,CAAA,EAAG,EAAA,EAAI,EAAA,GACxB,KAAA,UACA,EAAA,IAAM,CAAA,EAAG,UAAA,CAAW,EAAA,cAClB,CAAA,EAAG,CAAA,KAAM,OAAA,CAAQ,CAAA,EAAG,CAAA,EAAG,EAAA,EAAI,EAAA;AHC/B;;AAAA,cGKM,OAAA,kBAGO,OAAA,aACA,OAAA,UACH,YAAA,CAAa,CAAA,EAAG,CAAA,EAAG,EAAA,EAAI,EAAA;cAE7B,EAAA,EAAI,SAAA,CAAU,CAAA,EAAG,CAAA,EAAG,EAAA,EAAI,EAAA,GACxB,KAAA,UACA,EAAA,IAAM,CAAA,EAAG,UAAA,CAAW,EAAA;EAKtB,KAAA,CAAM,CAAA,EAAG,CAAA;EAIT,IAAA,IAAQ,OAAA;AAAA"}

package/dist/supervisor.d.ts

@@ -1,4 +1,4 @@
-import { c as ExitMessage, d as ProcessCtx, f as ProcessFn, t as Process } from "./process-C-ERBQY5.js";
+import { _ as WithSender, c as ExitMessage, d as ProcessCtx, f as ProcessFn, t as Process } from "./process-BiX7Ena4.js";
 
 //#region src/supervisor.d.ts
 type SupMsg = ExitMessage | RunMsg | StopMsg | ErrorMsg | OkMsg;
@@ -34,7 +34,7 @@ declare function supervise({
   pname,
   toParent,
   fork
-}: ProcessCtx<null, SupervisorState, SupMsg, SupMsg>, wrap?: (s: SupervisorState) => SupervisorState, debugLevel?: boolean): Generator<SupervisorState | null, void, SupMsg>;
+}: ProcessCtx<null, SupervisorState, SupMsg, SupMsg>, wrap?: (s: SupervisorState) => SupervisorState, debugLevel?: boolean): Generator<SupervisorState | null, void, WithSender<SupMsg>>;
 /**
  * Bind a process function to a supervisor. The returned function,
  * when called, sends a `RUN` message so the supervisor forks the child.

package/dist/supervisor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"supervisor.d.ts","names":[],"sources":["../src/supervisor.ts"],"mappings":";;;KAMK,MAAA,GAAS,WAAA,GAAc,MAAA,GAAS,OAAA,GAAU,QAAA,GAAW,KAAA;AAAA,UAEhD,MAAA;EACR,IAAA;EACA,EAAA,EAAI,SAAS;EACb,IAAA;EACA,KAAA;AAAA;AAAA,UAGQ,OAAA;EACR,IAAI;AAAA;AAAA,UAGI,QAAA;EACR,IAAI;AAAA;AAAA,UAGI,KAAA;EACR,IAAA;EAAA,CACC,GAAW;AAAA;AAAA,UAKG,eAAA;EACf,SAAA,EAAW,OAAO;EAClB,KAAA;AAAA;;;;;;;;AApBK;iBAiCG,SAAA;EACN,KAAA;EAAO,QAAA;EAAU;AAAA,GAAQ,UAAA,OAAiB,eAAA,EAAiB,MAAA,EAAQ,MAAA,GACrE,IAAA,IAAO,CAAA,EAAG,eAAA,KAAoB,eAAA,EAC9B,UAAA,aACC,SAAA,CAAU,eAAA,eAA8B,MAAA;;;;AAjCrC;iBAoEG,MAAA,qBACP,UAAA,EAAY,OAAA,WAAkB,MAAA,EAAQ,MAAA,GACtC,EAAA,EAAI,SAAA,CAAU,IAAA,kBACd,KAAA,eACK,IAAA,EAAM,IAAA"}
+{"version":3,"file":"supervisor.d.ts","names":[],"sources":["../src/supervisor.ts"],"mappings":";;;KAOK,MAAA,GAAS,WAAA,GAAc,MAAA,GAAS,OAAA,GAAU,QAAA,GAAW,KAAA;AAAA,UAEhD,MAAA;EACR,IAAA;EACA,EAAA,EAAI,SAAS;EACb,IAAA;EACA,KAAA;AAAA;AAAA,UAGQ,OAAA;EACR,IAAI;AAAA;AAAA,UAGI,QAAA;EACR,IAAI;AAAA;AAAA,UAGI,KAAA;EACR,IAAA;EAAA,CACC,GAAW;AAAA;AAAA,UAKG,eAAA;EACf,SAAA,EAAW,OAAO;EAClB,KAAA;AAAA;;;;;;;AApBK;AAAA;iBAiCG,SAAA;EACN,KAAA;EAAO,QAAA;EAAU;AAAA,GAAQ,UAAA,OAAiB,eAAA,EAAiB,MAAA,EAAQ,MAAA,GACrE,IAAA,IAAO,CAAA,EAAG,eAAA,KAAoB,eAAA,EAC9B,UAAA,aACC,SAAA,CAAU,eAAA,eAA8B,UAAA,CAAW,MAAA;;;AAjChD;AAAA;iBAqEG,MAAA,qBACP,UAAA,EAAY,OAAA,WAAkB,MAAA,EAAQ,MAAA,GACtC,EAAA,EAAI,SAAA,CAAU,IAAA,kBACd,KAAA,eACK,IAAA,EAAM,IAAA"}

package/dist/supervisor.js

@@ -14,7 +14,8 @@ function* supervise({ pname, toParent, fork }, wrap = (a) => a, debugLevel = fal
 		phase: "wait"
 	});
 	yield state;
-	yield* runDispatch(pname, (msg) => {
+	yield* runDispatch(pname, (maybe) => {
+		const [msg, _sender] = maybe;
 		switch (msg.type) {
 			case "RUN":
 				fork(msg.fn, msg.pname)(...msg.args);
@@ -25,7 +26,7 @@ function* supervise({ pname, toParent, fork }, wrap = (a) => a, debugLevel = fal
 				state.phase = "stopping";
 				break;
 			case "EXIT":
-				state.processes = state.processes.filter((p) => p.id !== msg.pid);
+				state.processes = state.processes.filter((p) => p.id !== _sender.fromId);
 				break;
 			case "OK":
 				toParent(msg);
@@ -44,6 +45,9 @@ function attach(supervisor, fn, pname) {
 			fn,
 			args,
 			pname
+		}, {
+			fromName: "external",
+			fromId: Symbol("external")
 		});
 	};
 }

package/dist/supervisor.js.map

@@ -1 +1 @@
-{"version":3,"file":"supervisor.js","names":[],"sources":["../src/supervisor.ts"],"sourcesContent":["import { runDispatch } from \"./util.js\";\nimport type { Process, ProcessFn, ProcessCtx } from \"./process.js\";\nimport type { ExitMessage } from \"./util.js\";\n\n// ---- messages ---------------------------------------------------------------\n\ntype SupMsg = ExitMessage | RunMsg | StopMsg | ErrorMsg | OkMsg;\n\ninterface RunMsg {\n  type: \"RUN\";\n  fn: ProcessFn<any, any, any, any>;\n  args: any[];\n  pname: string;\n}\n\ninterface StopMsg {\n  type: \"STOP\";\n}\n\ninterface ErrorMsg {\n  type: \"ERROR\";\n}\n\ninterface OkMsg {\n  type: \"OK\";\n  [key: string]: unknown;\n}\n\n// ---- state ------------------------------------------------------------------\n\nexport interface SupervisorState {\n  processes: Process<any, any, any, any>[];\n  phase: \"wait\" | \"running\" | \"stopping\";\n}\n\n// ---- supervise --------------------------------------------------------------\n\n/**\n * A supervisor process. Call `attach` to send it `RUN` messages —\n * it will fork the given function as a child. The supervisor exits\n * when it enters `'stopping'` phase (triggered by `ERROR` or `STOP`).\n *\n * @param wrap  optional transformation applied to the state before\n *              each yield (e.g. `reactive` from Vue)\n */\nfunction* supervise(\n  { pname, toParent, fork }: ProcessCtx<null, SupervisorState, SupMsg, SupMsg>,\n  wrap: (s: SupervisorState) => SupervisorState = (a) => a,\n  debugLevel = false,\n): Generator<SupervisorState | null, void, SupMsg> {\n  const state = wrap({ processes: [], phase: \"wait\" });\n  yield state;\n\n  yield* runDispatch<SupMsg>(\n    pname,\n    (msg) => {\n      switch (msg.type) {\n        case \"RUN\":\n          (fork as (...a: any[]) => any)(msg.fn, msg.pname)(...msg.args);\n          state.phase = \"running\";\n          break;\n        case \"ERROR\":\n        case \"STOP\":\n          state.phase = \"stopping\";\n          break;\n        case \"EXIT\":\n          state.processes = state.processes.filter((p) => p.id !== msg.pid);\n          break;\n        case \"OK\":\n          toParent(msg);\n          break;\n      }\n    },\n    () => state.phase === \"stopping\",\n    debugLevel,\n  );\n}\n\n// ---- attach -----------------------------------------------------------------\n\n/**\n * Bind a process function to a supervisor. The returned function,\n * when called, sends a `RUN` message so the supervisor forks the child.\n */\nfunction attach<Args extends any[]>(\n  supervisor: Process<any, any, SupMsg, SupMsg>,\n  fn: ProcessFn<Args, any, any, any>,\n  pname: string,\n): (...args: Args) => void {\n  return (...args) => {\n    supervisor.send({ type: \"RUN\", fn, args, pname } as SupMsg);\n  };\n}\n\nexport { attach, supervise };\n"],"mappings":";;;;;;;;;;AA6CA,UAAU,UACR,EAAE,OAAO,UAAU,QACnB,QAAiD,MAAM,GACvD,aAAa,OACoC;CACjD,MAAM,QAAQ,KAAK;EAAE,WAAW,CAAC;EAAG,OAAO;CAAO,CAAC;CACnD,MAAM;CAEN,OAAO,YACL,QACC,QAAQ;EACP,QAAQ,IAAI,MAAZ;GACE,KAAK;IACH,KAA+B,IAAI,IAAI,IAAI,KAAK,EAAE,GAAG,IAAI,IAAI;IAC7D,MAAM,QAAQ;IACd;GACF,KAAK;GACL,KAAK;IACH,MAAM,QAAQ;IACd;GACF,KAAK;IACH,MAAM,YAAY,MAAM,UAAU,QAAQ,MAAM,EAAE,OAAO,IAAI,GAAG;IAChE;GACF,KAAK;IACH,SAAS,GAAG;IACZ;EACJ;CACF,SACM,MAAM,UAAU,YACtB,UACF;AACF;;;;;AAQA,SAAS,OACP,YACA,IACA,OACyB;CACzB,QAAQ,GAAG,SAAS;EAClB,WAAW,KAAK;GAAE,MAAM;GAAO;GAAI;GAAM;EAAM,CAAW;CAC5D;AACF"}
+{"version":3,"file":"supervisor.js","names":[],"sources":["../src/supervisor.ts"],"sourcesContent":["import { runDispatch } from \"./util.js\";\nimport type { Process, ProcessFn, ProcessCtx } from \"./process.js\";\nimport type { WithSender } from \"./types.js\";\nimport type { ExitMessage } from \"./util.js\";\n\n// ---- messages ---------------------------------------------------------------\n\ntype SupMsg = ExitMessage | RunMsg | StopMsg | ErrorMsg | OkMsg;\n\ninterface RunMsg {\n  type: \"RUN\";\n  fn: ProcessFn<any, any, any, any>;\n  args: any[];\n  pname: string;\n}\n\ninterface StopMsg {\n  type: \"STOP\";\n}\n\ninterface ErrorMsg {\n  type: \"ERROR\";\n}\n\ninterface OkMsg {\n  type: \"OK\";\n  [key: string]: unknown;\n}\n\n// ---- state ------------------------------------------------------------------\n\nexport interface SupervisorState {\n  processes: Process<any, any, any, any>[];\n  phase: \"wait\" | \"running\" | \"stopping\";\n}\n\n// ---- supervise --------------------------------------------------------------\n\n/**\n * A supervisor process. Call `attach` to send it `RUN` messages —\n * it will fork the given function as a child. The supervisor exits\n * when it enters `'stopping'` phase (triggered by `ERROR` or `STOP`).\n *\n * @param wrap  optional transformation applied to the state before\n *              each yield (e.g. `reactive` from Vue)\n */\nfunction* supervise(\n  { pname, toParent, fork }: ProcessCtx<null, SupervisorState, SupMsg, SupMsg>,\n  wrap: (s: SupervisorState) => SupervisorState = (a) => a,\n  debugLevel = false,\n): Generator<SupervisorState | null, void, WithSender<SupMsg>> {\n  const state = wrap({ processes: [], phase: \"wait\" });\n  yield state;\n\n  yield* runDispatch<WithSender<SupMsg>>(\n    pname,\n    (maybe) => {\n      const [msg, _sender] = maybe;\n      switch (msg.type) {\n        case \"RUN\":\n          (fork as (...a: any[]) => any)(msg.fn, msg.pname)(...msg.args);\n          state.phase = \"running\";\n          break;\n        case \"ERROR\":\n        case \"STOP\":\n          state.phase = \"stopping\";\n          break;\n        case \"EXIT\":\n          state.processes = state.processes.filter((p) => p.id !== _sender.fromId);\n          break;\n        case \"OK\":\n          toParent(msg);\n          break;\n      }\n    },\n    () => state.phase === \"stopping\",\n    debugLevel,\n  );\n}\n\n// ---- attach -----------------------------------------------------------------\n\n/**\n * Bind a process function to a supervisor. The returned function,\n * when called, sends a `RUN` message so the supervisor forks the child.\n */\nfunction attach<Args extends any[]>(\n  supervisor: Process<any, any, SupMsg, SupMsg>,\n  fn: ProcessFn<Args, any, any, any>,\n  pname: string,\n): (...args: Args) => void {\n  return (...args) => {\n    supervisor.send({ type: \"RUN\", fn, args, pname } as SupMsg, { fromName: \"external\", fromId: Symbol(\"external\") });\n  };\n}\n\nexport { attach, supervise };\n"],"mappings":";;;;;;;;;;AA8CA,UAAU,UACR,EAAE,OAAO,UAAU,QACnB,QAAiD,MAAM,GACvD,aAAa,OACgD;CAC7D,MAAM,QAAQ,KAAK;EAAE,WAAW,CAAC;EAAG,OAAO;CAAO,CAAC;CACnD,MAAM;CAEN,OAAO,YACL,QACC,UAAU;EACT,MAAM,CAAC,KAAK,WAAW;EACvB,QAAQ,IAAI,MAAZ;GACE,KAAK;IACH,KAA+B,IAAI,IAAI,IAAI,KAAK,EAAE,GAAG,IAAI,IAAI;IAC7D,MAAM,QAAQ;IACd;GACF,KAAK;GACL,KAAK;IACH,MAAM,QAAQ;IACd;GACF,KAAK;IACH,MAAM,YAAY,MAAM,UAAU,QAAQ,MAAM,EAAE,OAAO,QAAQ,MAAM;IACvE;GACF,KAAK;IACH,SAAS,GAAG;IACZ;EACJ;CACF,SACM,MAAM,UAAU,YACtB,UACF;AACF;;;;;AAQA,SAAS,OACP,YACA,IACA,OACyB;CACzB,QAAQ,GAAG,SAAS;EAClB,WAAW,KAAK;GAAE,MAAM;GAAO;GAAI;GAAM;EAAM,GAAa;GAAE,UAAU;GAAY,QAAQ,OAAO,UAAU;EAAE,CAAC;CAClH;AACF"}

package/dist/util-Cw64MseZ.js.map

@@ -1 +1 @@
-{"version":3,"file":"util-Cw64MseZ.js","names":[],"sources":["../src/util.ts"],"sourcesContent":["import type { ExitMessage } from \"./types.js\";\nexport function debugLog(level: boolean, ...args: Array<unknown>) {\n  if (level) {\n    console.log(...args);\n  }\n}\n\ntype ReducerClosure<M> = (msg: M) => void;\ntype ReadyFn = () => boolean;\ntype NotifyFn = () => void;\n\n/**\n * Generator helper that loops, yielding `null` and feeding incoming\n * messages to `fn` until `readyFn()` returns true. Used inside\n * process generators to build the main message loop.\n */\nfunction* runDispatch<M>(\n  name: string,\n  fn: ReducerClosure<M>,\n  readyFn: ReadyFn = () => false,\n  debugLevel = false,\n): Generator<null, void, M> {\n  let msg: M;\n  while (!readyFn()) {\n    msg = yield null;\n    debugLog(debugLevel, \"msg\", name, \" <- \", msg);\n    fn(msg);\n  }\n}\n\n/**\n * Wrap a process generator so that on completion it sends STOP to\n * all children and EXIT to the parent. Useful for custom process\n * wrappers that need lifecycle management without extending\n * AsyncProcess.\n */\nfunction watchExit<\n  A,\n  S,\n  IM extends { type: string },\n  OM extends { type: string } | ExitMessage,\n>(\n  proc: {\n    toAllChildren: (m: { type: string }) => void;\n    toParent: (m: OM) => void;\n    id: symbol;\n    pname: string;\n  },\n  gen: (ctx: any, args: A) => Generator<S | null, void, IM>,\n): (ctx: any, args: A) => Generator<S | null, void, IM> {\n  return function* (ctx, args) {\n    try {\n      yield* gen(ctx, args);\n    } finally {\n      proc.toAllChildren({ type: \"STOP\" });\n      proc.toParent({\n        type: \"EXIT\",\n        pid: proc.id,\n        fromName: proc.pname,\n        fromId: proc.id,\n      } as OM);\n    }\n  };\n}\n\ntype DeferCb = () => void;\ntype Defer = (fn: DeferCb) => unknown;\ntype Cancel = (taskId: any) => void;\ntype WindowGlobal = {\n  setImmediate?: Defer;\n  clearImmediate?: Cancel;\n  requestIdleCallback?: Defer;\n  cancelIdleCallback?: Cancel;\n  setTimeout: Defer;\n  clearTimeout: Cancel;\n};\n\n/** Handle to a scheduled (but not yet executed) callback. */\nexport type DeferredCall = {\n  cancel: () => void;\n  flush: () => void;\n};\n/** Schedule a function to run on the next microtask. Returns an\n * object with `cancel()` and `flush()` methods. */\nfunction defer(fn: DeferCb): DeferredCall {\n  const g = globalThis as WindowGlobal;\n  function schedule(deferFn: Defer, cancelFn: Cancel) {\n    const taskId = deferFn(fn);\n    return () => cancelFn(taskId);\n  }\n  let cancel: () => void;\n  if (g.setImmediate && g.clearImmediate) {\n    cancel = schedule(g.setImmediate, g.clearImmediate);\n  } else if (g.requestIdleCallback && g.cancelIdleCallback) {\n    cancel = schedule(g.requestIdleCallback, g.cancelIdleCallback);\n  } else {\n    cancel = schedule((f) => setTimeout(f, 0), clearTimeout);\n  }\n\n  function flush() {\n    cancel();\n    fn();\n  }\n\n  return { flush, cancel };\n}\n/** A promise paired with its resolve function — used to signal\n * process completion. */\nexport type Waiter = {\n  promise: Promise<void>;\n  resolve: NotifyFn;\n};\n/** Create a new {@link Waiter}. */\nfunction makeWaiter(): Waiter {\n  let resolve: unknown;\n  let promise = new Promise<void>((_resolve) => {\n    resolve = _resolve;\n  });\n  return { promise, resolve: resolve as NotifyFn };\n}\n\nexport { runDispatch, defer, makeWaiter, watchExit };\nexport type { ExitMessage };\n"],"mappings":";AACA,SAAgB,SAAS,OAAgB,GAAG,MAAsB;CAChE,IAAI,OACF,QAAQ,IAAI,GAAG,IAAI;AAEvB;;;;;;AAWA,UAAU,YACR,MACA,IACA,gBAAyB,OACzB,aAAa,OACa;CAC1B,IAAI;CACJ,OAAO,CAAC,QAAQ,GAAG;EACjB,MAAM,MAAM;EACZ,SAAS,YAAY,OAAO,MAAM,QAAQ,GAAG;EAC7C,GAAG,GAAG;CACR;AACF;;;AAwDA,SAAS,MAAM,IAA2B;CACxC,MAAM,IAAI;CACV,SAAS,SAAS,SAAgB,UAAkB;EAClD,MAAM,SAAS,QAAQ,EAAE;EACzB,aAAa,SAAS,MAAM;CAC9B;CACA,IAAI;CACJ,IAAI,EAAE,gBAAgB,EAAE,gBACtB,SAAS,SAAS,EAAE,cAAc,EAAE,cAAc;MAC7C,IAAI,EAAE,uBAAuB,EAAE,oBACpC,SAAS,SAAS,EAAE,qBAAqB,EAAE,kBAAkB;MAE7D,SAAS,UAAU,MAAM,WAAW,GAAG,CAAC,GAAG,YAAY;CAGzD,SAAS,QAAQ;EACf,OAAO;EACP,GAAG;CACL;CAEA,OAAO;EAAE;EAAO;CAAO;AACzB;;AAQA,SAAS,aAAqB;CAC5B,IAAI;CAIJ,OAAO;EAAE,SAAA,IAHS,SAAe,aAAa;GAC5C,UAAU;EACZ,CACe;EAAY;CAAoB;AACjD"}
+{"version":3,"file":"util-Cw64MseZ.js","names":[],"sources":["../src/util.ts"],"sourcesContent":["import type { ExitMessage } from \"./types.js\";\nexport function debugLog(level: boolean, ...args: Array<unknown>) {\n  if (level) {\n    console.log(...args);\n  }\n}\n\ntype ReducerClosure<M> = (msg: M) => void;\ntype ReadyFn = () => boolean;\ntype NotifyFn = () => void;\n\n/**\n * Generator helper that loops, yielding `null` and feeding incoming\n * messages to `fn` until `readyFn()` returns true. Used inside\n * process generators to build the main message loop.\n */\nfunction* runDispatch<M>(\n  name: string,\n  fn: ReducerClosure<M>,\n  readyFn: ReadyFn = () => false,\n  debugLevel = false,\n): Generator<null, void, M> {\n  let msg: M;\n  while (!readyFn()) {\n    msg = yield null;\n    debugLog(debugLevel, \"msg\", name, \" <- \", msg);\n    fn(msg);\n  }\n}\n\n/**\n* @deprecated Use AsyncProcess._watchExit instead.\n *\n * Wrap a process generator so that on completion it sends STOP to\n * all children and EXIT to the parent. Useful for custom process\n * wrappers that need lifecycle management without extending\n * AsyncProcess.\n */\nfunction watchExit<\n  A,\n  S,\n  IM extends { type: string },\n  OM extends { type: string } | ExitMessage,\n>(\n  proc: {\n    toAllChildren: (m: { type: string }) => void;\n    toParent: (m: OM) => void;\n    id: symbol;\n    pname: string;\n  },\n  gen: (ctx: any, args: A) => Generator<S | null, void, IM>,\n): (ctx: any, args: A) => Generator<S | null, void, IM> {\n  return function* (ctx, args) {\n    try {\n      yield* gen(ctx, args);\n    } finally {\n      proc.toAllChildren({ type: \"STOP\" });\n      proc.toParent({\n        type: \"EXIT\",\n      } as OM);\n    }\n  };\n}\n\ntype DeferCb = () => void;\ntype Defer = (fn: DeferCb) => unknown;\ntype Cancel = (taskId: any) => void;\ntype WindowGlobal = {\n  setImmediate?: Defer;\n  clearImmediate?: Cancel;\n  requestIdleCallback?: Defer;\n  cancelIdleCallback?: Cancel;\n  setTimeout: Defer;\n  clearTimeout: Cancel;\n};\n\n/** Handle to a scheduled (but not yet executed) callback. */\nexport type DeferredCall = {\n  cancel: () => void;\n  flush: () => void;\n};\n/** Schedule a function to run on the next microtask. Returns an\n * object with `cancel()` and `flush()` methods. */\nfunction defer(fn: DeferCb): DeferredCall {\n  const g = globalThis as WindowGlobal;\n  function schedule(deferFn: Defer, cancelFn: Cancel) {\n    const taskId = deferFn(fn);\n    return () => cancelFn(taskId);\n  }\n  let cancel: () => void;\n  if (g.setImmediate && g.clearImmediate) {\n    cancel = schedule(g.setImmediate, g.clearImmediate);\n  } else if (g.requestIdleCallback && g.cancelIdleCallback) {\n    cancel = schedule(g.requestIdleCallback, g.cancelIdleCallback);\n  } else {\n    cancel = schedule((f) => setTimeout(f, 0), clearTimeout);\n  }\n\n  function flush() {\n    cancel();\n    fn();\n  }\n\n  return { flush, cancel };\n}\n/** A promise paired with its resolve function — used to signal\n * process completion. */\nexport type Waiter = {\n  promise: Promise<void>;\n  resolve: NotifyFn;\n};\n/** Create a new {@link Waiter}. */\nfunction makeWaiter(): Waiter {\n  let resolve: unknown;\n  let promise = new Promise<void>((_resolve) => {\n    resolve = _resolve;\n  });\n  return { promise, resolve: resolve as NotifyFn };\n}\n\nexport { runDispatch, defer, makeWaiter, watchExit };\nexport type { ExitMessage };\n"],"mappings":";AACA,SAAgB,SAAS,OAAgB,GAAG,MAAsB;CAChE,IAAI,OACF,QAAQ,IAAI,GAAG,IAAI;AAEvB;;;;;;AAWA,UAAU,YACR,MACA,IACA,gBAAyB,OACzB,aAAa,OACa;CAC1B,IAAI;CACJ,OAAO,CAAC,QAAQ,GAAG;EACjB,MAAM,MAAM;EACZ,SAAS,YAAY,OAAO,MAAM,QAAQ,GAAG;EAC7C,GAAG,GAAG;CACR;AACF;;;AAuDA,SAAS,MAAM,IAA2B;CACxC,MAAM,IAAI;CACV,SAAS,SAAS,SAAgB,UAAkB;EAClD,MAAM,SAAS,QAAQ,EAAE;EACzB,aAAa,SAAS,MAAM;CAC9B;CACA,IAAI;CACJ,IAAI,EAAE,gBAAgB,EAAE,gBACtB,SAAS,SAAS,EAAE,cAAc,EAAE,cAAc;MAC7C,IAAI,EAAE,uBAAuB,EAAE,oBACpC,SAAS,SAAS,EAAE,qBAAqB,EAAE,kBAAkB;MAE7D,SAAS,UAAU,MAAM,WAAW,GAAG,CAAC,GAAG,YAAY;CAGzD,SAAS,QAAQ;EACf,OAAO;EACP,GAAG;CACL;CAEA,OAAO;EAAE;EAAO;CAAO;AACzB;;AAQA,SAAS,aAAqB;CAC5B,IAAI;CAIJ,OAAO;EAAE,SAAA,IAHS,SAAe,aAAa;GAC5C,UAAU;EACZ,CACe;EAAY;CAAoB;AACjD"}

package/dist/xfetch.d.ts

@@ -1,4 +1,4 @@
-import { c as ExitMessage, d as ProcessCtx, t as Process } from "./process-C-ERBQY5.js";
+import { _ as WithSender, c as ExitMessage, d as ProcessCtx, t as Process } from "./process-BiX7Ena4.js";
 
 //#region src/xfetch.d.ts
 /** State of an in-flight or completed fetch. */
@@ -41,13 +41,13 @@ type FetchProcess<D> = Process<FetchArgs<D>, FetchState<D>, FetchMessage<D>, Fet
 declare function xfetch<Type>({
   pname,
   toParent,
-  send
+  sendSelf
 }: ProcessCtx<FetchArgs<Type>, FetchState<Type>, FetchMessage<Type>, FetchMessage<Type>>, {
   method,
   url,
   body,
   headers: callerHeaders
-}: FetchArgs<Type>): Generator<FetchState<Type> | null, void, FetchMessage<Type>>;
+}: FetchArgs<Type>): Generator<FetchState<Type> | null, void, WithSender<FetchMessage<Type>>>;
 //#endregion
 export { FetchArgs, FetchMessage, FetchProcess, FetchState, xfetch };
 //# sourceMappingURL=xfetch.d.ts.map

package/dist/xfetch.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"xfetch.d.ts","names":[],"sources":["../src/xfetch.ts"],"mappings":";;;;KAOY,UAAA;EACV,IAAA;EACA,IAAA,EAAM,CAAA;EACN,IAAA;EACA,MAAA;EACA,eAAA,EAAiB,MAAM;AAAA;;KAIb,SAAA;EAEN,GAAA,EAAK,GAAA;EACL,MAAA;EACA,IAAA;EACA,OAAA,GAAU,MAAA;AAAA;EAGV,GAAA,EAAK,GAAA;EACL,MAAA;EACA,IAAA,EAAM,CAAA;EACN,OAAA,GAAU,MAAA;AAAA;;KAIJ,YAAA;EAEN,IAAA;EACA,IAAA,GAAO,CAAA;EACP,IAAA;EACA,MAAA;EACA,eAAA,EAAiB,MAAA;AAAA;EAEjB,IAAA;AAAA,IACF,WAAA;;KAGQ,YAAA,MAAkB,OAAA,CAC5B,SAAA,CAAU,CAAA,GACV,UAAA,CAAW,CAAA,GACX,YAAA,CAAa,CAAA,GACb,YAAA,CAAa,CAAA;;;;;;iBA0BL,MAAA;EAEN,KAAA;EACA,QAAA;EACA;AAAA,GACC,UAAA,CACD,SAAA,CAAU,IAAA,GACV,UAAA,CAAW,IAAA,GACX,YAAA,CAAa,IAAA,GACb,YAAA,CAAa,IAAA;EAEb,MAAA;EAAgB,GAAA;EAAK,IAAA;EAAM,OAAA,EAAS;AAAA,GAAiB,SAAA,CAAU,IAAA,IAChE,SAAA,CAAU,UAAA,CAAW,IAAA,gBAAoB,YAAA,CAAa,IAAA"}
+{"version":3,"file":"xfetch.d.ts","names":[],"sources":["../src/xfetch.ts"],"mappings":";;;;KAOY,UAAA;EACV,IAAA;EACA,IAAA,EAAM,CAAA;EACN,IAAA;EACA,MAAA;EACA,eAAA,EAAiB,MAAM;AAAA;;KAIb,SAAA;EAEN,GAAA,EAAK,GAAA;EACL,MAAA;EACA,IAAA;EACA,OAAA,GAAU,MAAA;AAAA;EAGV,GAAA,EAAK,GAAA;EACL,MAAA;EACA,IAAA,EAAM,CAAA;EACN,OAAA,GAAU,MAAA;AAAA;;KAIJ,YAAA;EAEN,IAAA;EACA,IAAA,GAAO,CAAA;EACP,IAAA;EACA,MAAA;EACA,eAAA,EAAiB,MAAA;AAAA;EAEjB,IAAA;AAAA,IACF,WAAA;;KAGQ,YAAA,MAAkB,OAAA,CAC5B,SAAA,CAAU,CAAA,GACV,UAAA,CAAW,CAAA,GACX,YAAA,CAAa,CAAA,GACb,YAAA,CAAa,CAAA;;;;;;iBA0BL,MAAA;EAEN,KAAA;EACA,QAAA;EACA;AAAA,GACC,UAAA,CACD,SAAA,CAAU,IAAA,GACV,UAAA,CAAW,IAAA,GACX,YAAA,CAAa,IAAA,GACb,YAAA,CAAa,IAAA;EAEb,MAAA;EAAgB,GAAA;EAAK,IAAA;EAAM,OAAA,EAAS;AAAA,GAAiB,SAAA,CAAU,IAAA,IAChE,SAAA,CAAU,UAAA,CAAW,IAAA,gBAAoB,UAAA,CAAW,YAAA,CAAa,IAAA"}

package/dist/xfetch.js

@@ -16,7 +16,7 @@ function headersToRecord(h) {
 * JSON detection, abort via AbortController, and yields a
 * {@link FetchState} with the current status.
 */
-function* xfetch({ pname, toParent, send }, { method = "GET", url, body, headers: callerHeaders }) {
+function* xfetch({ pname, toParent, sendSelf }, { method = "GET", url, body, headers: callerHeaders }) {
 	const state = {
 		code: "pending",
 		data: null,
@@ -27,7 +27,7 @@ function* xfetch({ pname, toParent, send }, { method = "GET", url, body, headers
 	yield state;
 	const controller = new AbortController();
 	const signal = controller.signal;
-	const toSelf = send;
+	const toSelf = sendSelf;
 	(async function doRequest() {
 		try {
 			toSelf({ type: "LOADING" });
@@ -60,7 +60,8 @@ function* xfetch({ pname, toParent, send }, { method = "GET", url, body, headers
 		}
 	})();
 	const isDone = () => !(state.code === "pending" || state.code === "loading");
-	yield* runDispatch(pname, (msg) => {
+	yield* runDispatch(pname, (maybe) => {
+		const [msg, _sender] = maybe;
 		if (msg.type === "STOP") controller.abort();
 		if (msg.type === "ABORTED") {
 			toParent(msg);

package/dist/xfetch.js.map

@@ -1 +1 @@
-{"version":3,"file":"xfetch.js","names":[],"sources":["../src/xfetch.ts"],"sourcesContent":["import { runDispatch } from \"./util.js\";\nimport type { ExitMessage, ProcessCtx } from \"./types.js\";\nimport type { Process } from \"./process.js\";\n\n// ---- types ------------------------------------------------------------------\n\n/** State of an in-flight or completed fetch. */\nexport type FetchState<T> = {\n  code: \"pending\" | \"loading\" | \"aborted\" | \"failed\" | \"ok\";\n  data: T | null;\n  text: string | null;\n  status: number;\n  responseHeaders: Record<string, string>;\n};\n\n/** Arguments for a fetch process. */\nexport type FetchArgs<T> =\n  | {\n      url: URL;\n      method?: \"GET\";\n      body?: undefined;\n      headers?: Record<string, string>;\n    }\n  | {\n      url: URL;\n      method?: \"POST\" | \"PUT\" | \"PATCH\";\n      body: T;\n      headers?: Record<string, string>;\n    };\n\n/** Messages emitted by a fetch process during its lifecycle. */\nexport type FetchMessage<T> =\n  | {\n      type: \"OK\";\n      data?: T | null;\n      text?: string | null;\n      status: number;\n      responseHeaders: Record<string, string>;\n    }\n  | { type: \"ERROR\" | \"LOADING\" | \"ABORTED\" | \"STOP\" }\n  | ExitMessage;\n\n/** A process that performs an HTTP fetch. */\nexport type FetchProcess<D> = Process<\n  FetchArgs<D>,\n  FetchState<D>,\n  FetchMessage<D>,\n  FetchMessage<D>\n>;\n\n// ---- helpers ----------------------------------------------------------------\n\nfunction isJsonHelper(res: Response): boolean {\n  const ct = res.headers.get(\"content-type\");\n  return ct === \"application/json\";\n}\n\n/** Convert a Headers object to a plain Record. */\nfunction headersToRecord(h: Headers): Record<string, string> {\n  const out: Record<string, string> = {};\n  h.forEach((v, k) => {\n    out[k] = v;\n  });\n  return out;\n}\n\n// ---- xfetch -----------------------------------------------------------------\n\n/**\n * A fetch wrapper implemented as a process. Supports GET/POST/PUT/PATCH,\n * JSON detection, abort via AbortController, and yields a\n * {@link FetchState} with the current status.\n */\nfunction* xfetch<Type>(\n  {\n    pname,\n    toParent,\n    send,\n  }: ProcessCtx<\n    FetchArgs<Type>,\n    FetchState<Type>,\n    FetchMessage<Type>,\n    FetchMessage<Type>\n  >,\n  { method = \"GET\", url, body, headers: callerHeaders }: FetchArgs<Type>,\n): Generator<FetchState<Type> | null, void, FetchMessage<Type>> {\n  const state: FetchState<Type> = {\n    code: \"pending\",\n    data: null,\n    text: null,\n    status: 0,\n    responseHeaders: {},\n  };\n  yield state;\n\n  const controller = new AbortController();\n  const signal = controller.signal;\n  const toSelf = send;\n\n  (async function doRequest() {\n    try {\n      toSelf({ type: \"LOADING\" });\n      const serializedBody =\n        method === \"GET\" ? undefined : JSON.stringify(body);\n      const headers = new Headers(callerHeaders ?? {});\n      if (serializedBody) {\n        headers.set(\"content-type\", \"application/json\");\n      }\n      const res: Response = await fetch(url.href, {\n        method,\n        signal,\n        body: serializedBody,\n        headers,\n      });\n      const status = res.status;\n      const responseHeaders = headersToRecord(res.headers);\n      if (isJsonHelper(res)) {\n        const data = await res.json();\n        toSelf({ type: \"OK\", data, status, responseHeaders });\n      } else {\n        const text = await res.text();\n        toSelf({ type: \"OK\", text, status, responseHeaders });\n      }\n    } catch (e) {\n      const isAborted = e instanceof DOMException && e.name === \"AbortError\";\n      if (isAborted) {\n        toSelf({ type: \"ABORTED\" });\n      } else {\n        toSelf({ type: \"ERROR\" });\n      }\n    }\n  })();\n\n  const isDone = (): boolean =>\n    !(state.code === \"pending\" || state.code === \"loading\");\n\n  yield* runDispatch<FetchMessage<Type>>(\n    pname,\n    (msg: FetchMessage<Type>) => {\n      if (msg.type === \"STOP\") {\n        controller.abort();\n      }\n      if (msg.type === \"ABORTED\") {\n        toParent(msg);\n        state.code = \"aborted\";\n      }\n      if (msg.type === \"ERROR\") {\n        toParent(msg);\n        state.code = \"failed\";\n      }\n      if (msg.type === \"LOADING\") {\n        state.code = \"loading\";\n      }\n      if (msg.type === \"OK\") {\n        toParent(msg);\n        state.code = \"ok\";\n        state.data = msg.data || null;\n        state.text = msg.text || null;\n        state.status = msg.status;\n        state.responseHeaders = msg.responseHeaders;\n      }\n    },\n    isDone,\n    false,\n  );\n}\n\nexport { xfetch };\n"],"mappings":";;AAoDA,SAAS,aAAa,KAAwB;CAE5C,OADW,IAAI,QAAQ,IAAI,cACnB,MAAM;AAChB;;AAGA,SAAS,gBAAgB,GAAoC;CAC3D,MAAM,MAA8B,CAAC;CACrC,EAAE,SAAS,GAAG,MAAM;EAClB,IAAI,KAAK;CACX,CAAC;CACD,OAAO;AACT;;;;;;AASA,UAAU,OACR,EACE,OACA,UACA,QAOF,EAAE,SAAS,OAAO,KAAK,MAAM,SAAS,iBACwB;CAC9D,MAAM,QAA0B;EAC9B,MAAM;EACN,MAAM;EACN,MAAM;EACN,QAAQ;EACR,iBAAiB,CAAC;CACpB;CACA,MAAM;CAEN,MAAM,aAAa,IAAI,gBAAgB;CACvC,MAAM,SAAS,WAAW;CAC1B,MAAM,SAAS;CAEf,CAAC,eAAe,YAAY;EAC1B,IAAI;GACF,OAAO,EAAE,MAAM,UAAU,CAAC;GAC1B,MAAM,iBACJ,WAAW,QAAQ,KAAA,IAAY,KAAK,UAAU,IAAI;GACpD,MAAM,UAAU,IAAI,QAAQ,iBAAiB,CAAC,CAAC;GAC/C,IAAI,gBACF,QAAQ,IAAI,gBAAgB,kBAAkB;GAEhD,MAAM,MAAgB,MAAM,MAAM,IAAI,MAAM;IAC1C;IACA;IACA,MAAM;IACN;GACF,CAAC;GACD,MAAM,SAAS,IAAI;GACnB,MAAM,kBAAkB,gBAAgB,IAAI,OAAO;GACnD,IAAI,aAAa,GAAG,GAElB,OAAO;IAAE,MAAM;IAAM,MAAA,MADF,IAAI,KAAK;IACD;IAAQ;GAAgB,CAAC;QAGpD,OAAO;IAAE,MAAM;IAAM,MAAA,MADF,IAAI,KAAK;IACD;IAAQ;GAAgB,CAAC;EAExD,SAAS,GAAG;GAEV,IADkB,aAAa,gBAAgB,EAAE,SAAS,cAExD,OAAO,EAAE,MAAM,UAAU,CAAC;QAE1B,OAAO,EAAE,MAAM,QAAQ,CAAC;EAE5B;CACF,GAAG;CAEH,MAAM,eACJ,EAAE,MAAM,SAAS,aAAa,MAAM,SAAS;CAE/C,OAAO,YACL,QACC,QAA4B;EAC3B,IAAI,IAAI,SAAS,QACf,WAAW,MAAM;EAEnB,IAAI,IAAI,SAAS,WAAW;GAC1B,SAAS,GAAG;GACZ,MAAM,OAAO;EACf;EACA,IAAI,IAAI,SAAS,SAAS;GACxB,SAAS,GAAG;GACZ,MAAM,OAAO;EACf;EACA,IAAI,IAAI,SAAS,WACf,MAAM,OAAO;EAEf,IAAI,IAAI,SAAS,MAAM;GACrB,SAAS,GAAG;GACZ,MAAM,OAAO;GACb,MAAM,OAAO,IAAI,QAAQ;GACzB,MAAM,OAAO,IAAI,QAAQ;GACzB,MAAM,SAAS,IAAI;GACnB,MAAM,kBAAkB,IAAI;EAC9B;CACF,GACA,QACA,KACF;AACF"}
+{"version":3,"file":"xfetch.js","names":[],"sources":["../src/xfetch.ts"],"sourcesContent":["import { runDispatch } from \"./util.js\";\nimport type { ExitMessage, WithSender, ProcessCtx } from \"./types.js\";\nimport type { Process } from \"./process.js\";\n\n// ---- types ------------------------------------------------------------------\n\n/** State of an in-flight or completed fetch. */\nexport type FetchState<T> = {\n  code: \"pending\" | \"loading\" | \"aborted\" | \"failed\" | \"ok\";\n  data: T | null;\n  text: string | null;\n  status: number;\n  responseHeaders: Record<string, string>;\n};\n\n/** Arguments for a fetch process. */\nexport type FetchArgs<T> =\n  | {\n      url: URL;\n      method?: \"GET\";\n      body?: undefined;\n      headers?: Record<string, string>;\n    }\n  | {\n      url: URL;\n      method?: \"POST\" | \"PUT\" | \"PATCH\";\n      body: T;\n      headers?: Record<string, string>;\n    };\n\n/** Messages emitted by a fetch process during its lifecycle. */\nexport type FetchMessage<T> =\n  | {\n      type: \"OK\";\n      data?: T | null;\n      text?: string | null;\n      status: number;\n      responseHeaders: Record<string, string>;\n    }\n  | { type: \"ERROR\" | \"LOADING\" | \"ABORTED\" | \"STOP\" }\n  | ExitMessage;\n\n/** A process that performs an HTTP fetch. */\nexport type FetchProcess<D> = Process<\n  FetchArgs<D>,\n  FetchState<D>,\n  FetchMessage<D>,\n  FetchMessage<D>\n>;\n\n// ---- helpers ----------------------------------------------------------------\n\nfunction isJsonHelper(res: Response): boolean {\n  const ct = res.headers.get(\"content-type\");\n  return ct === \"application/json\";\n}\n\n/** Convert a Headers object to a plain Record. */\nfunction headersToRecord(h: Headers): Record<string, string> {\n  const out: Record<string, string> = {};\n  h.forEach((v, k) => {\n    out[k] = v;\n  });\n  return out;\n}\n\n// ---- xfetch -----------------------------------------------------------------\n\n/**\n * A fetch wrapper implemented as a process. Supports GET/POST/PUT/PATCH,\n * JSON detection, abort via AbortController, and yields a\n * {@link FetchState} with the current status.\n */\nfunction* xfetch<Type>(\n  {\n    pname,\n    toParent,\n    sendSelf,\n  }: ProcessCtx<\n    FetchArgs<Type>,\n    FetchState<Type>,\n    FetchMessage<Type>,\n    FetchMessage<Type>\n  >,\n  { method = \"GET\", url, body, headers: callerHeaders }: FetchArgs<Type>,\n): Generator<FetchState<Type> | null, void, WithSender<FetchMessage<Type>>> {\n  const state: FetchState<Type> = {\n    code: \"pending\",\n    data: null,\n    text: null,\n    status: 0,\n    responseHeaders: {},\n  };\n  yield state;\n\n  const controller = new AbortController();\n  const signal = controller.signal;\n  const toSelf = sendSelf;\n\n  (async function doRequest() {\n    try {\n      toSelf({ type: \"LOADING\" });\n      const serializedBody =\n        method === \"GET\" ? undefined : JSON.stringify(body);\n      const headers = new Headers(callerHeaders ?? {});\n      if (serializedBody) {\n        headers.set(\"content-type\", \"application/json\");\n      }\n      const res: Response = await fetch(url.href, {\n        method,\n        signal,\n        body: serializedBody,\n        headers,\n      });\n      const status = res.status;\n      const responseHeaders = headersToRecord(res.headers);\n      if (isJsonHelper(res)) {\n        const data = await res.json();\n        toSelf({ type: \"OK\", data, status, responseHeaders });\n      } else {\n        const text = await res.text();\n        toSelf({ type: \"OK\", text, status, responseHeaders });\n      }\n    } catch (e) {\n      const isAborted = e instanceof DOMException && e.name === \"AbortError\";\n      if (isAborted) {\n        toSelf({ type: \"ABORTED\" });\n      } else {\n        toSelf({ type: \"ERROR\" });\n      }\n    }\n  })();\n\n  const isDone = (): boolean =>\n    !(state.code === \"pending\" || state.code === \"loading\");\n\n  yield* runDispatch<WithSender<FetchMessage<Type>>>(\n    pname,\n    (maybe: WithSender<FetchMessage<Type>>) => {\n      const [msg, _sender] = maybe;\n      if (msg.type === \"STOP\") {\n        controller.abort();\n      }\n      if (msg.type === \"ABORTED\") {\n        toParent(msg);\n        state.code = \"aborted\";\n      }\n      if (msg.type === \"ERROR\") {\n        toParent(msg);\n        state.code = \"failed\";\n      }\n      if (msg.type === \"LOADING\") {\n        state.code = \"loading\";\n      }\n      if (msg.type === \"OK\") {\n        toParent(msg);\n        state.code = \"ok\";\n        state.data = msg.data || null;\n        state.text = msg.text || null;\n        state.status = msg.status;\n        state.responseHeaders = msg.responseHeaders;\n      }\n    },\n    isDone,\n    false,\n  );\n}\n\nexport { xfetch };\n"],"mappings":";;AAoDA,SAAS,aAAa,KAAwB;CAE5C,OADW,IAAI,QAAQ,IAAI,cACnB,MAAM;AAChB;;AAGA,SAAS,gBAAgB,GAAoC;CAC3D,MAAM,MAA8B,CAAC;CACrC,EAAE,SAAS,GAAG,MAAM;EAClB,IAAI,KAAK;CACX,CAAC;CACD,OAAO;AACT;;;;;;AASA,UAAU,OACR,EACE,OACA,UACA,YAOF,EAAE,SAAS,OAAO,KAAK,MAAM,SAAS,iBACoC;CAC1E,MAAM,QAA0B;EAC9B,MAAM;EACN,MAAM;EACN,MAAM;EACN,QAAQ;EACR,iBAAiB,CAAC;CACpB;CACA,MAAM;CAEN,MAAM,aAAa,IAAI,gBAAgB;CACvC,MAAM,SAAS,WAAW;CAC1B,MAAM,SAAS;CAEf,CAAC,eAAe,YAAY;EAC1B,IAAI;GACF,OAAO,EAAE,MAAM,UAAU,CAAC;GAC1B,MAAM,iBACJ,WAAW,QAAQ,KAAA,IAAY,KAAK,UAAU,IAAI;GACpD,MAAM,UAAU,IAAI,QAAQ,iBAAiB,CAAC,CAAC;GAC/C,IAAI,gBACF,QAAQ,IAAI,gBAAgB,kBAAkB;GAEhD,MAAM,MAAgB,MAAM,MAAM,IAAI,MAAM;IAC1C;IACA;IACA,MAAM;IACN;GACF,CAAC;GACD,MAAM,SAAS,IAAI;GACnB,MAAM,kBAAkB,gBAAgB,IAAI,OAAO;GACnD,IAAI,aAAa,GAAG,GAElB,OAAO;IAAE,MAAM;IAAM,MAAA,MADF,IAAI,KAAK;IACD;IAAQ;GAAgB,CAAC;QAGpD,OAAO;IAAE,MAAM;IAAM,MAAA,MADF,IAAI,KAAK;IACD;IAAQ;GAAgB,CAAC;EAExD,SAAS,GAAG;GAEV,IADkB,aAAa,gBAAgB,EAAE,SAAS,cAExD,OAAO,EAAE,MAAM,UAAU,CAAC;QAE1B,OAAO,EAAE,MAAM,QAAQ,CAAC;EAE5B;CACF,GAAG;CAEH,MAAM,eACJ,EAAE,MAAM,SAAS,aAAa,MAAM,SAAS;CAE/C,OAAO,YACL,QACC,UAA0C;EACzC,MAAM,CAAC,KAAK,WAAW;EACvB,IAAI,IAAI,SAAS,QACf,WAAW,MAAM;EAEnB,IAAI,IAAI,SAAS,WAAW;GAC1B,SAAS,GAAG;GACZ,MAAM,OAAO;EACf;EACA,IAAI,IAAI,SAAS,SAAS;GACxB,SAAS,GAAG;GACZ,MAAM,OAAO;EACf;EACA,IAAI,IAAI,SAAS,WACf,MAAM,OAAO;EAEf,IAAI,IAAI,SAAS,MAAM;GACrB,SAAS,GAAG;GACZ,MAAM,OAAO;GACb,MAAM,OAAO,IAAI,QAAQ;GACzB,MAAM,OAAO,IAAI,QAAQ;GACzB,MAAM,SAAS,IAAI;GACnB,MAAM,kBAAkB,IAAI;EAC9B;CACF,GACA,QACA,KACF;AACF"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "type": "module",
   "name": "posipaki",
-  "version": "0.10.4",
+  "version": "0.11.0",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "files": [

package/dist/process-C-ERBQY5.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"process-C-ERBQY5.d.ts","names":[],"sources":["../src/types.ts","../src/process.async.ts","../src/util.ts","../src/process.ts"],"mappings":"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"}