posipaki 0.6.4 → 0.7.0

package/dist/index.d.ts

@@ -1,2 +1,7 @@
-import { a as spawn, i as ProcessFn, n as Process, o as ExitMessage, r as ProcessCtx, s as runDispatch, t as Message } from "./process-BlUe6Luh.js";
-export { type ExitMessage, type Message, Process, type ProcessCtx, type ProcessFn, runDispatch, spawn };
+import { a as runDispatchAsync, c as ExitMessage, d as ProcessCtx, f as ProcessFn, i as AsyncProcess, l as Message, n as spawn, o as spawnAsync, p as SupervisorState, r as runDispatch, s as AsyncProcessFn, t as Process, u as PipeState } from "./process-jEWRVEFG.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>;
+//#endregion
+export { AsyncProcess, type AsyncProcessFn, type ExitMessage, type Message, type PipeState, Process, type ProcessCtx, type ProcessFn, type SupervisorState, asyncify, runDispatch, runDispatchAsync, spawn, spawnAsync };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/adapters.ts"],"mappings":";;;iBAEgB,QAAA,kBAA0B,OAAA,aAAoB,OAAA,EAC5D,EAAA,EAAI,SAAA,CAAU,CAAA,EAAG,CAAA,EAAG,EAAA,EAAI,EAAA,IACvB,cAAA,CAAe,CAAA,EAAG,CAAA,EAAG,EAAA,EAAI,EAAA"}

package/dist/index.js

@@ -1,38 +1,54 @@
-import { i as watchExit, n as makeWaiter, r as runDispatch, t as defer } from "./util-5PSJsovA.js";
-//#region src/process.ts
+import { i as runDispatch, n as defer, r as makeWaiter, t as debugLog } from "./util-Cw64MseZ.js";
+//#region src/process.async.ts
 /**
-* Spawn a new process from a process function. Returns a curried
-* function: call it with initial args to start execution.
+* Async equivalent of `runDispatch`. Loops, yielding `null` and feeding
+* each incoming message to an `async` reducer. Exits when `readyFn()`
+* returns true.
 */
-function spawn(fn, pname, toParent) {
-	return (args) => {
-		const process = new Process(fn, pname, toParent);
-		process.start(args);
-		return process;
-	};
+async function* runDispatchAsync(name, fn, readyFn = () => false, debugLevel = false) {
+	let msg;
+	while (!readyFn()) {
+		msg = yield null;
+		debugLog(debugLevel, "msg", name, " <- ", msg);
+		await fn(msg);
+	}
 }
 const noop = () => null;
 /**
-* A running process — an actor with message-passing, child processes,
-* and observable state. Driven by a generator function that yields
-* state snapshots and receives messages via `yield` expressions.
+* A process driven by an async generator. Functionally identical to
+* {@link Process} but supports `await` inside reducers.
+*
+* Messages are processed **one at a time** — if a tick is already
+* in-flight, new messages are buffered and processed when the current
+* tick completes.
 */
-var Process = class Process {
+var AsyncProcess = class AsyncProcess {
 	constructor(fn, pname, toParent) {
+		this.current = null;
+		this.buffer = [];
+		this.nextTick = null;
+		this.children = [];
+		this.subscribers = [];
 		this._isPaused = false;
+		this._tickInProgress = false;
+		this._exitReject = null;
 		this.pgenerator = fn;
 		this.pname = pname;
 		this.toParent = toParent || noop;
 		this.id = Symbol(pname);
-		this.current = null;
 		this.state = null;
-		this.buffer = [];
-		this.nextTick = null;
-		this.children = [];
-		this.subscribers = [];
 		this.exitWaiter = makeWaiter();
+		this._ready = makeWaiter();
+		this._resolveReady = this._ready.resolve;
+	}
+	/** Promise that resolves once the initial state is available. */
+	ready() {
+		return this._ready.promise;
 	}
-	/** Kick off the generator with initial arguments. */
+	/**
+	* Kick off the async generator. The first `yield` sets the initial
+	* state; for async generators this happens in a microtask.
+	*/
 	start(arg0) {
 		const ctx = {
 			pname: this.pname,
@@ -40,47 +56,89 @@ var Process = class Process {
 			send: this.send.bind(this),
 			toParent: this.toParent
 		};
-		const task = watchExit(this)(ctx, arg0);
-		this.current = task;
-		let ret = task.next();
-		this.state = ret.value || null;
-		this._eatResult(task.next());
-	}
-	/** Fork a child process. Children forward messages to this process
-	* and send `EXIT` when they terminate. */
+		this.current = this._watchExit(ctx, arg0);
+		this.current.next().then((ret) => {
+			this.state = ret.value ?? null;
+			this._resolveReady();
+			if (ret.done) {
+				this.exitWaiter.resolve();
+				return;
+			}
+			this._eatResult(this.current.next({ type: "__ADVANCE__" }));
+		});
+	}
+	/** Wrap the user's generator so EXIT/STOP logic fires on completion. */
+	async *_watchExit(ctx, arg0) {
+		try {
+			yield* this.pgenerator(ctx, arg0);
+		} finally {
+			this.toAllChildren({ type: "STOP" });
+			this.toParent({
+				type: "EXIT",
+				pid: this.id
+			});
+		}
+	}
 	fork(fn, pname) {
 		return (args) => {
-			const child = new Process(fn, pname, this.fromChild.bind(this));
+			const child = new AsyncProcess(fn, pname, this.fromChild.bind(this));
 			this.children.push(child);
 			child.start(args);
 			return child;
 		};
 	}
-	_tick() {
-		if (!this.current) return;
-		let msg;
-		let ret = null;
-		while (msg = this.buffer.shift()) {
-			ret = this.current.next(msg);
-			if (ret.done) break;
+	async _tick() {
+		if (!this.current || this._tickInProgress) return;
+		this._tickInProgress = true;
+		try {
+			let msg;
+			let ret = null;
+			while ((msg = this.buffer.shift()) !== void 0) {
+				ret = await this._safeNext(msg);
+				if (!ret || ret.done) break;
+			}
+			this.notify();
+			this._eatResult(ret);
+		} catch (e) {
+			this._exitReject?.(e);
+			this._exitReject = null;
+		} finally {
+			this._tickInProgress = false;
+		}
+	}
+	/** Call `.next()` and redirect unhandled rejections. */
+	async _safeNext(msg) {
+		try {
+			return await this.current.next(msg);
+		} catch (e) {
+			this._exitReject?.(e);
+			this._exitReject = null;
+			return {
+				done: true,
+				value: void 0
+			};
 		}
-		this.notify();
-		this._eatResult(ret);
 	}
 	_eatResult(ret) {
-		if (ret && ret.done) this.exitWaiter.resolve();
+		if (!ret) return;
+		Promise.resolve(ret).then((r) => {
+			if (r.done) this.exitWaiter.resolve();
+		});
 	}
-	/** Send a message to every child process (used for `STOP` propagation). */
+	/** Broadcast a message to all children. */
 	toAllChildren(msg) {
 		this.children.forEach((p) => p.send(msg));
 	}
-	/** Send a message to this process. Messages are buffered and
-	* processed asynchronously via a microtask. */
+	/** Enqueue a message. Processing is async (microtask). */
 	send(msg) {
 		this.buffer.push(msg);
 		this._scheduleTick();
 	}
-	/** Synchronously flush the message buffer. Useful in tests. */
+	/**
+	* Synchronously flush the buffer. For sync processes use {@link Process.tick};
+	* for async processes this is **not guaranteed** to process everything
+	* immediately if reducers contain `await`. Prefer `send()` + `await proc.wait()`.
+	*/
 	tick() {
 		this.nextTick?.flush();
 		this.nextTick = null;
@@ -96,11 +154,9 @@ var Process = class Process {
 	notify() {
 		this.subscribers.forEach((f) => f());
 	}
-	/** Whether any subscribers are watching for state changes. */
 	get isListenedTo() {
 		return this.subscribers.length > 0;
 	}
-	/** Subscribe to state changes. Returns an unsubscribe function. */
 	subscribe(f) {
 		this.subscribers.push(f);
 		return () => {
@@ -109,29 +165,71 @@ var Process = class Process {
 			this.subscribers.splice(idx, 1);
 		};
 	}
-	/** Pause message processing. Incoming messages are buffered
-	* but not processed until {@link resume} is called. */
 	pause() {
 		this.nextTick?.cancel();
 		this.nextTick = null;
 		this._isPaused = true;
 	}
-	/** Resume processing after a {@link pause}. */
 	resume() {
 		this._isPaused = false;
 		this._scheduleTick();
 	}
-	/** Return a promise that resolves when the generator completes. */
+	/**
+	* Returns a promise that resolves when the generator completes, or
+	* rejects if an unhandled error occurs during message processing.
+	*/
 	wait() {
-		return this.exitWaiter.promise;
+		return new Promise((resolve, reject) => {
+			this._exitReject = reject;
+			this.exitWaiter.promise.then(() => {
+				this._exitReject = null;
+				resolve();
+			}, (e) => {
+				this._exitReject = null;
+				reject(e);
+			});
+		});
 	}
-	/** Handle a message forwarded from a child process. `EXIT` removes
-	* the child; all other messages are forwarded to `send`. */
 	fromChild(msg) {
 		if (msg.type === "EXIT") this.children = this.children.filter((p) => p.id !== msg.pid);
 		this.send(msg);
 	}
 };
+/**
+* Spawn a new async process. Accepts both sync and async process
+* functions — sync ones are automatically wrapped with {@link asyncify}.
+*/
+function spawnAsync(fn, pname, toParent) {
+	return (args) => {
+		const proc = new AsyncProcess(fn, pname, toParent);
+		proc.start(args);
+		return proc;
+	};
+}
+//#endregion
+//#region src/adapters.ts
+function asyncify(fn) {
+	return async function* (ctx, args) {
+		yield* fn(ctx, args);
+	};
+}
+//#endregion
+//#region src/process.ts
+function spawn(fn, pname, tp) {
+	return (a) => new Process(fn, pname, tp).start(a);
+}
+var Process = class extends AsyncProcess {
+	constructor(fn, pname, tp) {
+		super(asyncify(fn), pname, tp);
+	}
+	start(a) {
+		super.start(a);
+		return this;
+	}
+	tick() {
+		return super._tick();
+	}
+};
 //#endregion
 //#region src/index.ts
 /**
@@ -139,28 +237,9 @@ var Process = class Process {
 * generator functions. Processes communicate via message-passing,
 * can fork children, and expose their state reactively.
 *
-* ## Quick start
-*
-* ```ts
-* import { spawn, runDispatch } from 'posipaki'
-*
-* function* hello({ pname }) {
-*   const state = { count: 0 }
-*   yield state
-*   yield* runDispatch(pname, (msg) => {
-*     if (msg.type === 'POKE') state.count++
-*   }, () => false)
-* }
-*
-* const proc = spawn(hello, 'hello')(null)
-* proc.send({ type: 'POKE' })
-* proc.tick()
-* console.log(proc.state.count) // 1
-* ```
-*
 * @module
 */
 //#endregion
-export { Process, runDispatch, spawn };
+export { AsyncProcess, Process, asyncify, runDispatch, runDispatchAsync, spawn, spawnAsync };
 
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":[],"sources":["../src/process.ts","../src/index.ts"],"sourcesContent":["import {\n  ExitMessage,\n  watchExit,\n  Waiter,\n  defer,\n  DeferredCall,\n  makeWaiter,\n} from \"./util\";\n\n/**\n * Base message type. All messages must include a `type` field\n * for discrimination in reducers.\n */\nexport interface Message {\n  type: string;\n}\n\ntype ProcessGenerator<ProcessState, InMessage> = Generator<\n  ProcessState | null,\n  void,\n  InMessage\n>;\ntype Fork = <\n  ChildArgs,\n  ChildState,\n  InMessage extends Message,\n  OutMessage extends Message,\n>(\n  fn: ProcessFn<ChildArgs, ChildState, InMessage, OutMessage>,\n  pname: string,\n) => (args: ChildArgs) => Process<ChildArgs, ChildState, InMessage, OutMessage>;\n\n/**\n * A process generator function. Receives a {@link ProcessCtx} and\n * initial args, yields state (or `null`) at each step.\n */\nexport type ProcessFn<Args, State, InMessage, OutMessage> = (\n  ctx: ProcessCtx<InMessage, OutMessage>,\n  args: Args,\n) => ProcessGenerator<State, InMessage>;\ntype ProcessMessageCb<M> = (msg: M) => void;\n\n/**\n * Context injected into every running process. Provides the process\n * name, ability to fork children, and I/O channels.\n */\nexport type ProcessCtx<IM, OM> = {\n  pname: string;\n  fork: Fork;\n  send: (msg: IM) => void;\n  toParent: ProcessMessageCb<OM>;\n};\n\ntype NotifyFn = () => void;\ntype _UnsubscibeFn = () => void;\n\n/**\n * Spawn a new process from a process function. Returns a curried\n * function: call it with initial args to start execution.\n */\nexport function spawn<\n  Args,\n  State,\n  InMessage extends Message = Message,\n  OutMessage extends Message = ExitMessage,\n>(\n  fn: ProcessFn<Args, State, InMessage, OutMessage>,\n  pname: string,\n  toParent?: ProcessMessageCb<OutMessage>,\n) {\n  return (args: Args): Process<Args, State, InMessage, OutMessage> => {\n    const process = new Process<Args, State, InMessage, OutMessage>(\n      fn,\n      pname,\n      toParent,\n    );\n    process.start(args);\n    return process;\n  };\n}\nconst noop = () => null;\n\n/**\n * A running process — an actor with message-passing, child processes,\n * and observable state. Driven by a generator function that yields\n * state snapshots and receives messages via `yield` expressions.\n */\nclass Process<\n  Args,\n  State,\n  InMessage extends Message,\n  OutMessage extends Message,\n> {\n  pgenerator: ProcessFn<Args, State, InMessage, OutMessage>;\n  pname: string;\n  toParent: ProcessMessageCb<OutMessage>;\n  id: symbol;\n  state: State | null;\n\n  private current: ProcessGenerator<State, InMessage> | null;\n  private buffer: Array<InMessage>;\n  private nextTick: DeferredCall | null;\n  private children: Array<Process<unknown, unknown, Message, Message>>;\n  private subscribers: Array<NotifyFn>;\n  private exitWaiter: Waiter;\n  private _isPaused: boolean = false;\n\n  constructor(\n    fn: ProcessFn<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;\n    this.id = Symbol(pname);\n\n    this.current = null;\n    this.state = null;\n    this.buffer = [];\n    this.nextTick = null;\n\n    this.children = [];\n    this.subscribers = [];\n    this.exitWaiter = makeWaiter();\n  }\n\n  /** Kick off the generator with initial arguments. */\n  start(arg0: Args) {\n    const ctx: ProcessCtx<InMessage, OutMessage> = {\n      pname: this.pname,\n      fork: this.fork.bind(this),\n      send: this.send.bind(this),\n      toParent: this.toParent,\n    };\n    const task = watchExit<Args, State, InMessage, OutMessage>(this)(ctx, arg0);\n    this.current = task;\n    let ret = task.next();\n    this.state = ret.value || null;\n    this._eatResult(task.next());\n  }\n\n  /** Fork a child process. Children forward messages to this process\n   * and send `EXIT` when they terminate. */\n  fork<ChildArgs, ChildState, ChildIM extends Message, ChildOM extends Message>(\n    fn: ProcessFn<ChildArgs, ChildState, ChildIM, ChildOM>,\n    pname: string,\n  ) {\n    return (\n      args: ChildArgs,\n    ): Process<ChildArgs, ChildState, ChildIM, ChildOM> => {\n      // not enough typescript power in this one\n      const fromChild = this.fromChild.bind(this) as unknown;\n      const child = new Process<ChildArgs, ChildState, ChildIM, ChildOM>(\n        fn,\n        pname,\n        fromChild as ProcessMessageCb<ChildOM>,\n      );\n      // we don't keep track of what is happening down there\n      this.children.push(\n        child as unknown as Process<unknown, unknown, Message, Message>,\n      );\n      child.start(args);\n      return child;\n    };\n  }\n\n  _tick() {\n    if (!this.current) {\n      return;\n    }\n    let msg: InMessage | undefined;\n    let ret: IteratorResult<State | null, void> | null = null;\n    while ((msg = this.buffer.shift())) {\n      ret = this.current.next(msg);\n      if (ret.done) {\n        break;\n      }\n    }\n    this.notify();\n    this._eatResult(ret);\n  }\n\n  _eatResult(ret: IteratorResult<State | null, void> | null) {\n    if (ret && ret.done) {\n      this.exitWaiter.resolve();\n    }\n  }\n\n  /** Send a message to every child process (used for `STOP` propagation). */\n  toAllChildren(msg: Message) {\n    this.children.forEach((p) => p.send(msg));\n  }\n\n  /** Send a message to this process. Messages are buffered and\n   * processed asynchronously via a microtask. */\n  send(msg: InMessage) {\n    this.buffer.push(msg);\n    this._scheduleTick();\n  }\n\n  /** Synchronously flush the message buffer. Useful in tests. */\n  tick() {\n    this.nextTick?.flush();\n    this.nextTick = null;\n  }\n\n  _scheduleTick() {\n    if (this._isPaused) {\n      return;\n    }\n\n    this.nextTick?.cancel();\n    this.nextTick = defer(() => {\n      this.nextTick = null;\n      this._tick();\n    });\n  }\n\n  notify() {\n    this.subscribers.forEach((f) => f());\n  }\n\n  /** Whether any subscribers are watching for state changes. */\n  get isListenedTo() {\n    return this.subscribers.length > 0;\n  }\n\n  /** Subscribe to state changes. Returns an unsubscribe function. */\n  subscribe(f: NotifyFn) {\n    this.subscribers.push(f);\n    return () => {\n      const idx = this.subscribers.indexOf(f);\n      if (idx < 0) {\n        return;\n      }\n      this.subscribers.splice(idx, 1);\n    };\n  }\n\n  /** Pause message processing. Incoming messages are buffered\n   * but not processed until {@link resume} is called. */\n  pause() {\n    this.nextTick?.cancel();\n    this.nextTick = null;\n    this._isPaused = true;\n  }\n\n  /** Resume processing after a {@link pause}. */\n  resume() {\n    this._isPaused = false;\n    this._scheduleTick();\n  }\n\n  /** Return a promise that resolves when the generator completes. */\n  wait() {\n    return this.exitWaiter.promise;\n  }\n\n  /** Handle a message forwarded from a child process. `EXIT` removes\n   * the child; all other messages are forwarded to `send`. */\n  fromChild(msg: InMessage) {\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\nexport { Process };\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 * ## Quick start\n *\n * ```ts\n * import { spawn, runDispatch } from 'posipaki'\n *\n * function* hello({ pname }) {\n *   const state = { count: 0 }\n *   yield state\n *   yield* runDispatch(pname, (msg) => {\n *     if (msg.type === 'POKE') state.count++\n *   }, () => false)\n * }\n *\n * const proc = spawn(hello, 'hello')(null)\n * proc.send({ type: 'POKE' })\n * proc.tick()\n * console.log(proc.state.count) // 1\n * ```\n *\n * @module\n */\n\nimport { Process, spawn } from \"./process\";\nimport type { Message, ProcessCtx, ProcessFn } from \"./process\";\nimport { runDispatch } from \"./util\";\nimport type { ExitMessage } from \"./util\";\n\nexport { Process, spawn, runDispatch };\nexport type { Message, ExitMessage, ProcessCtx, ProcessFn };\n"],"mappings":";;;;;;AA4DA,SAAgB,MAMd,IACA,OACA,UACA;CACA,QAAQ,SAA4D;EAClE,MAAM,UAAU,IAAI,QAClB,IACA,OACA,QACF;EACA,QAAQ,MAAM,IAAI;EAClB,OAAO;CACT;AACF;AACA,MAAM,aAAa;;;;;;AAOnB,IAAM,UAAN,MAAM,QAKJ;CAeA,YACE,IACA,OACA,UACA;mBAN2B;EAO3B,KAAK,aAAa;EAClB,KAAK,QAAQ;EACb,KAAK,WAAW,YAAY;EAC5B,KAAK,KAAK,OAAO,KAAK;EAEtB,KAAK,UAAU;EACf,KAAK,QAAQ;EACb,KAAK,SAAS,CAAC;EACf,KAAK,WAAW;EAEhB,KAAK,WAAW,CAAC;EACjB,KAAK,cAAc,CAAC;EACpB,KAAK,aAAa,WAAW;CAC/B;;CAGA,MAAM,MAAY;EAChB,MAAM,MAAyC;GAC7C,OAAO,KAAK;GACZ,MAAM,KAAK,KAAK,KAAK,IAAI;GACzB,MAAM,KAAK,KAAK,KAAK,IAAI;GACzB,UAAU,KAAK;EACjB;EACA,MAAM,OAAO,UAA8C,IAAI,EAAE,KAAK,IAAI;EAC1E,KAAK,UAAU;EACf,IAAI,MAAM,KAAK,KAAK;EACpB,KAAK,QAAQ,IAAI,SAAS;EAC1B,KAAK,WAAW,KAAK,KAAK,CAAC;CAC7B;;;CAIA,KACE,IACA,OACA;EACA,QACE,SACqD;GAGrD,MAAM,QAAQ,IAAI,QAChB,IACA,OAHgB,KAAK,UAAU,KAAK,IAI5B,CACV;GAEA,KAAK,SAAS,KACZ,KACF;GACA,MAAM,MAAM,IAAI;GAChB,OAAO;EACT;CACF;CAEA,QAAQ;EACN,IAAI,CAAC,KAAK,SACR;EAEF,IAAI;EACJ,IAAI,MAAiD;EACrD,OAAQ,MAAM,KAAK,OAAO,MAAM,GAAI;GAClC,MAAM,KAAK,QAAQ,KAAK,GAAG;GAC3B,IAAI,IAAI,MACN;EAEJ;EACA,KAAK,OAAO;EACZ,KAAK,WAAW,GAAG;CACrB;CAEA,WAAW,KAAgD;EACzD,IAAI,OAAO,IAAI,MACb,KAAK,WAAW,QAAQ;CAE5B;;CAGA,cAAc,KAAc;EAC1B,KAAK,SAAS,SAAS,MAAM,EAAE,KAAK,GAAG,CAAC;CAC1C;;;CAIA,KAAK,KAAgB;EACnB,KAAK,OAAO,KAAK,GAAG;EACpB,KAAK,cAAc;CACrB;;CAGA,OAAO;EACL,KAAK,UAAU,MAAM;EACrB,KAAK,WAAW;CAClB;CAEA,gBAAgB;EACd,IAAI,KAAK,WACP;EAGF,KAAK,UAAU,OAAO;EACtB,KAAK,WAAW,YAAY;GAC1B,KAAK,WAAW;GAChB,KAAK,MAAM;EACb,CAAC;CACH;CAEA,SAAS;EACP,KAAK,YAAY,SAAS,MAAM,EAAE,CAAC;CACrC;;CAGA,IAAI,eAAe;EACjB,OAAO,KAAK,YAAY,SAAS;CACnC;;CAGA,UAAU,GAAa;EACrB,KAAK,YAAY,KAAK,CAAC;EACvB,aAAa;GACX,MAAM,MAAM,KAAK,YAAY,QAAQ,CAAC;GACtC,IAAI,MAAM,GACR;GAEF,KAAK,YAAY,OAAO,KAAK,CAAC;EAChC;CACF;;;CAIA,QAAQ;EACN,KAAK,UAAU,OAAO;EACtB,KAAK,WAAW;EAChB,KAAK,YAAY;CACnB;;CAGA,SAAS;EACP,KAAK,YAAY;EACjB,KAAK,cAAc;CACrB;;CAGA,OAAO;EACL,OAAO,KAAK,WAAW;CACzB;;;CAIA,UAAU,KAAgB;EACxB,IAAI,IAAI,SAAS,QACf,KAAK,WAAW,KAAK,SAAS,QAC3B,MAAM,EAAE,OAAQ,IAA+B,GAClD;EAEF,KAAK,KAAK,GAAG;CACf;AACF"}
+{"version":3,"file":"index.js","names":[],"sources":["../src/process.async.ts","../src/adapters.ts","../src/process.ts","../src/index.ts"],"sourcesContent":["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} from \"./types.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): void {\n    const ctx: ProcessCtx<InMessage, OutMessage> = {\n      pname: this.pname,\n      fork: this.fork.bind(this) as any,\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) { this.exitWaiter.resolve(); return; }\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  }\n\n  /** Wrap the user's generator so EXIT/STOP logic fires on completion. */\n  private async *_watchExit(\n    ctx: ProcessCtx<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      } 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  // ---- 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 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 { 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): this {\n    super.start(a);\n    return this;\n  }\n  tick(): Promise<void> {\n    return super._tick();\n  }\n}\n\nexport { Process };\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, ExitMessage, ProcessFn, ProcessCtx,\n  AsyncProcessFn, PipeState, SupervisorState,\n} from \"./types\"\n"],"mappings":"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"}

package/dist/pipe.d.ts

@@ -1,4 +1,4 @@
-import { i as ProcessFn, o as ExitMessage, t as Message } from "./process-BlUe6Luh.js";
+import { c as ExitMessage, f as ProcessFn, l as Message } from "./process-jEWRVEFG.js";
 
 //#region src/pipe.d.ts
 /**

package/dist/pipe.js

@@ -1,4 +1,4 @@
-import { r as runDispatch } from "./util-5PSJsovA.js";
+import { i as runDispatch } from "./util-Cw64MseZ.js";
 //#region src/pipe.ts
 /**
 * Chain process functions so each runs after the previous one exits.

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 { Process } from \"./process.js\";\nimport type { Message } from \"./process.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<Params, any, any, any>[],\n): ProcessFn<\n  Params,\n  PipeState<Params, Result>,\n  Message,\n  Message | ExitMessage\n> {\n  return function* (\n    { pname, fork }: ProcessCtx<Message, Message | ExitMessage>,\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: Process<any, any, any, any>;\n\n    function spawnNext(): void {\n      const fn = queue.shift()!;\n      task = fork(\n        fn,\n        `${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      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,EAAE,OAAO,QACT,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,KACL,IACA,GAAG,MAAM,IAAI,GAAG,QAAQ,cAAc,EACxC,EAAE,MAAM,MAAgB;EAC1B;EAEA,SAAS,UAAmB;GAC1B,OAAO,MAAM,SAAS;EACxB;EAEA,UAAU;EACV,MAAM,UAAU,QAAQ;EAExB,OAAO,YACL,QACC,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 { Process } from \"./process.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<Params, any, any, any>[],\n): ProcessFn<\n  Params,\n  PipeState<Params, Result>,\n  Message,\n  Message | ExitMessage\n> {\n  return function* (\n    { pname, fork }: ProcessCtx<Message, Message | ExitMessage>,\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: Process<any, any, any, any>;\n\n    function spawnNext(): void {\n      const fn = queue.shift()!;\n      task = fork(\n        fn,\n        `${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      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,EAAE,OAAO,QACT,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,KACL,IACA,GAAG,MAAM,IAAI,GAAG,QAAQ,cAAc,EACxC,EAAE,MAAM,MAAgB;EAC1B;EAEA,SAAS,UAAmB;GAC1B,OAAO,MAAM,SAAS;EACxB;EAEA,UAAU;EACV,MAAM,UAAU,QAAQ;EAExB,OAAO,YACL,QACC,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"}

package/dist/process-jEWRVEFG.d.ts

@@ -0,0 +1,147 @@
+//#region src/types.d.ts
+/**
+ * Public API types for Posipaki.
+ *
+ * @module
+ */
+/** Base message type. All messages must include a `type` field
+ * for discrimination in reducers. */
+interface Message {
+  type: string;
+}
+/** Message emitted by a process to its parent when it terminates. */
+type ExitMessage = {
+  type: "EXIT";
+  pid: symbol;
+};
+type ProcessFn<Args, State, InMessage extends Message, OutMessage extends Message> = (ctx: ProcessCtx<InMessage, OutMessage>, args: Args) => Generator<State | null, void, InMessage>;
+type AsyncProcessFn<Args, State, InMessage extends Message, OutMessage extends Message> = (ctx: ProcessCtx<InMessage, OutMessage>, args: Args) => AsyncGenerator<State | null, void, InMessage>;
+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. */
+type Fork<_IM extends Message, _OM extends Message> = <CA, CS, CIM extends Message, COM extends Message>(fn: ProcessFn<CA, CS, CIM, COM>, pname: string) => (a: CA) => any;
+/** Context injected into every running process. */
+type ProcessCtx<IM extends Message, OM extends Message> = {
+  pname: string;
+  fork: Fork<IM, OM>;
+  send: (msg: IM) => void;
+  toParent: ProcessMessageCb$1<OM>;
+};
+/** State yielded by the pipe process. */
+interface PipeState<Params, Result> {
+  params: Params | null;
+  result: Result | null;
+  running: boolean;
+}
+/** State yielded by the supervisor process. */
+interface SupervisorState {
+  processes: any[];
+  phase: "wait" | "running" | "stopping";
+}
+//#endregion
+//#region src/process.async.d.ts
+type NotifyFn = () => void;
+type AsyncReducer<M> = (msg: M) => Promise<void>;
+type ReadyFn$1 = () => boolean;
+/**
+ * Async equivalent of `runDispatch`. Loops, yielding `null` and feeding
+ * each incoming message to an `async` reducer. Exits when `readyFn()`
+ * returns true.
+ */
+declare function runDispatchAsync<M>(name: string, fn: AsyncReducer<M>, readyFn?: ReadyFn$1, debugLevel?: boolean): AsyncGenerator<null, void, M>;
+type ProcessMessageCb<M> = (msg: M) => void;
+/**
+ * A process driven by an async generator. Functionally identical to
+ * {@link Process} but supports `await` inside reducers.
+ *
+ * Messages are processed **one at a time** — if a tick is already
+ * in-flight, new messages are buffered and processed when the current
+ * tick completes.
+ */
+declare class AsyncProcess<Args, State, InMessage extends Message, OutMessage extends Message> {
+  pgenerator: AsyncProcessFn<Args, State, InMessage, OutMessage>;
+  pname: string;
+  toParent: ProcessMessageCb<OutMessage>;
+  id: symbol;
+  state: State | null;
+  private current;
+  private buffer;
+  private nextTick;
+  private children;
+  private subscribers;
+  private exitWaiter;
+  private _isPaused;
+  private _tickInProgress;
+  private _exitReject;
+  private _ready;
+  private _resolveReady;
+  constructor(fn: AsyncProcessFn<Args, State, InMessage, OutMessage>, pname: string, toParent: ProcessMessageCb<OutMessage> | undefined);
+  /** Promise that resolves once the initial state is available. */
+  ready(): Promise<void>;
+  /**
+   * Kick off the async generator. The first `yield` sets the initial
+   * state; for async generators this happens in a microtask.
+   */
+  start(arg0: Args): void;
+  /** Wrap the user's generator so EXIT/STOP logic fires on completion. */
+  private _watchExit;
+  fork<ChildArgs, ChildState, ChildIM extends Message, ChildOM extends Message>(fn: AsyncProcessFn<ChildArgs, ChildState, ChildIM, ChildOM>, pname: string): (args: ChildArgs) => AsyncProcess<ChildArgs, ChildState, ChildIM, ChildOM>;
+  protected _tick(): Promise<void>;
+  /** Call `.next()` and redirect unhandled rejections. */
+  private _safeNext;
+  private _eatResult;
+  /** Broadcast a message to all children. */
+  toAllChildren(msg: Message): void;
+  /** Enqueue a message. Processing is async (microtask). */
+  send(msg: InMessage): void;
+  /**
+   * Synchronously flush the buffer. For sync processes use {@link Process.tick};
+   * for async processes this is **not guaranteed** to process everything
+   * immediately if reducers contain `await`. Prefer `send()` + `await proc.wait()`.
+   */
+  tick(): void;
+  private _scheduleTick;
+  notify(): void;
+  get isListenedTo(): boolean;
+  subscribe(f: NotifyFn): () => void;
+  pause(): void;
+  resume(): void;
+  /**
+   * Returns a promise that resolves when the generator completes, or
+   * rejects if an unhandled error occurs during message processing.
+   */
+  wait(): Promise<void>;
+  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>;
+//#endregion
+//#region src/util.d.ts
+type ReducerClosure<M> = (msg: M) => void;
+type ReadyFn = () => boolean;
+/**
+ * Generator helper that loops, yielding `null` and feeding incoming
+ * messages to `fn` until `readyFn()` returns true. Used inside
+ * process generators to build the main message loop.
+ */
+declare function runDispatch<M>(name: string, fn: ReducerClosure<M>, readyFn?: ReadyFn, debugLevel?: boolean): Generator<null, void, M>;
+/**
+ * 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
+ * AsyncProcess.
+ */
+//#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>;
+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);
+  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, spawn as n, spawnAsync as o, SupervisorState as p, runDispatch as r, AsyncProcessFn as s, Process as t, PipeState as u };
+//# sourceMappingURL=process-jEWRVEFG.d.ts.map

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

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

package/dist/supervisor.d.ts

@@ -1,4 +1,4 @@
-import { i as ProcessFn, n as Process, o as ExitMessage, r as ProcessCtx } from "./process-BlUe6Luh.js";
+import { c as ExitMessage, d as ProcessCtx, f as ProcessFn, t as Process } from "./process-jEWRVEFG.js";
 
 //#region src/supervisor.d.ts
 type SupMsg = ExitMessage | RunMsg | StopMsg | ErrorMsg | OkMsg;

package/dist/supervisor.js

@@ -1,4 +1,4 @@
-import { r as runDispatch } from "./util-5PSJsovA.js";
+import { i as runDispatch } from "./util-Cw64MseZ.js";
 //#region src/supervisor.ts
 /**
 * A supervisor process. Call `attach` to send it `RUN` messages —

package/dist/{util-5PSJsovA.js → util-Cw64MseZ.js}

@@ -15,18 +15,6 @@ function* runDispatch(name, fn, readyFn = () => false, debugLevel = false) {
 		fn(msg);
 	}
 }
-/** Wrap a process generator so that on completion it sends `STOP`
-* to all children and `EXIT` to the parent. */
-function watchExit(process) {
-	return function* (ctx, arg0) {
-		yield* process.pgenerator(ctx, arg0);
-		process.toAllChildren({ type: "STOP" });
-		process.toParent({
-			type: "EXIT",
-			pid: process.id
-		});
-	};
-}
 /** Schedule a function to run on the next microtask. Returns an
 * object with `cancel()` and `flush()` methods. */
 function defer(fn) {
@@ -59,6 +47,6 @@ function makeWaiter() {
 	};
 }
 //#endregion
-export { watchExit as i, makeWaiter as n, runDispatch as r, defer as t };
+export { runDispatch as i, defer as n, makeWaiter as r, debugLog as t };
 
-//# sourceMappingURL=util-5PSJsovA.js.map
+//# sourceMappingURL=util-Cw64MseZ.js.map

package/dist/util-Cw64MseZ.js.map

@@ -0,0 +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  },\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({ type: \"EXIT\", pid: proc.id } 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;;;AAkDA,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

@@ -0,0 +1,46 @@
+import { c as ExitMessage, d as ProcessCtx, t as Process } from "./process-jEWRVEFG.js";
+
+//#region src/xfetch.d.ts
+/** State of an in-flight or completed fetch. */
+type FetchState<T> = {
+  code: "pending" | "loading" | "aborted" | "failed" | "ok";
+  data: T | null;
+  text: string | null;
+};
+/** Arguments for a fetch process. */
+type FetchArgs<T> = {
+  url: URL;
+  method?: "GET";
+  body?: undefined;
+} | {
+  url: URL;
+  method?: "POST" | "PUT" | "PATCH";
+  body: T;
+};
+/** Messages emitted by a fetch process during its lifecycle. */
+type FetchMessage<T> = {
+  type: "OK";
+  data?: T | null;
+  text?: string | null;
+} | {
+  type: "ERROR" | "LOADING" | "ABORTED" | "STOP";
+} | ExitMessage;
+/** A process that performs an HTTP fetch. */
+type FetchProcess<D> = Process<FetchArgs<D>, FetchState<D>, FetchMessage<D>, FetchMessage<D>>;
+/**
+ * A fetch wrapper implemented as a process. Supports GET/POST/PUT/PATCH,
+ * JSON detection, abort via AbortController, and yields a
+ * {@link FetchState} with the current status.
+ */
+declare function xfetch<Type>({
+  pname,
+  toParent,
+  send
+}: ProcessCtx<FetchMessage<Type>, FetchMessage<Type>>, {
+  method,
+  url,
+  body
+}: FetchArgs<Type>): Generator<FetchState<Type> | null, void, FetchMessage<Type>>;
+//#endregion
+export { FetchArgs, FetchMessage, FetchProcess, FetchState, xfetch };
+//# sourceMappingURL=xfetch.d.ts.map

package/dist/xfetch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"xfetch.d.ts","names":[],"sources":["../src/xfetch.ts"],"mappings":";;;;KAOY,UAAA;EACV,IAAA;EACA,IAAA,EAAM,CAAC;EACP,IAAA;AAAA;;KAIU,SAAA;EACN,GAAA,EAAK,GAAA;EAAK,MAAA;EAAgB,IAAA;AAAA;EAC1B,GAAA,EAAK,GAAA;EAAK,MAAA;EAAmC,IAAA,EAAM,CAAA;AAAA;;KAG7C,YAAA;EACN,IAAA;EAAY,IAAA,GAAO,CAAA;EAAU,IAAA;AAAA;EAC7B,IAAA;AAAA,IACF,WAAW;;KAGH,YAAA,MAAkB,OAAA,CAC5B,SAAA,CAAU,CAAA,GACV,UAAA,CAAW,CAAA,GACX,YAAA,CAAa,CAAA,GACb,YAAA,CAAa,CAAA;;;;;;iBAiBL,MAAA;EACN,KAAA;EAAO,QAAA;EAAU;AAAA,GAAQ,UAAA,CAAW,YAAA,CAAa,IAAA,GAAO,YAAA,CAAa,IAAA;EACrE,MAAA;EAAgB,GAAA;EAAK;AAAA,GAAQ,SAAA,CAAU,IAAA,IACxC,SAAA,CAAU,UAAA,CAAW,IAAA,gBAAoB,YAAA,CAAa,IAAA"}

package/dist/xfetch.js

@@ -0,0 +1,69 @@
+import { i as runDispatch } from "./util-Cw64MseZ.js";
+//#region src/xfetch.ts
+function isJsonHelper(res) {
+	return res.headers.get("content-type") === "application/json";
+}
+/**
+* A fetch wrapper implemented as a process. Supports GET/POST/PUT/PATCH,
+* JSON detection, abort via AbortController, and yields a
+* {@link FetchState} with the current status.
+*/
+function* xfetch({ pname, toParent, send }, { method = "GET", url, body }) {
+	const state = {
+		code: "pending",
+		data: null,
+		text: null
+	};
+	yield state;
+	const controller = new AbortController();
+	const signal = controller.signal;
+	const toSelf = send;
+	(async function doRequest() {
+		try {
+			toSelf({ type: "LOADING" });
+			const serializedBody = method === "GET" ? void 0 : JSON.stringify(body);
+			const headers = new Headers({});
+			if (serializedBody) headers.set("content-type", "application/json");
+			const res = await fetch(url.href, {
+				method,
+				signal,
+				body: serializedBody,
+				headers
+			});
+			if (isJsonHelper(res)) toSelf({
+				type: "OK",
+				data: await res.json()
+			});
+			else toSelf({
+				type: "OK",
+				text: await res.text()
+			});
+		} catch (e) {
+			if (e instanceof DOMException && e.name === "AbortError") toSelf({ type: "ABORTED" });
+			else toSelf({ type: "ERROR" });
+		}
+	})();
+	const isDone = () => !(state.code === "pending" || state.code === "loading");
+	yield* runDispatch(pname, (msg) => {
+		if (msg.type === "STOP") controller.abort();
+		if (msg.type === "ABORTED") {
+			toParent(msg);
+			state.code = "aborted";
+		}
+		if (msg.type === "ERROR") {
+			toParent(msg);
+			state.code = "failed";
+		}
+		if (msg.type === "LOADING") state.code = "loading";
+		if (msg.type === "OK") {
+			toParent(msg);
+			state.code = "ok";
+			state.data = msg.data || null;
+			state.text = msg.text || null;
+		}
+	}, isDone, true);
+}
+//#endregion
+export { xfetch };
+
+//# sourceMappingURL=xfetch.js.map

package/dist/xfetch.js.map

@@ -0,0 +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};\n\n/** Arguments for a fetch process. */\nexport type FetchArgs<T> =\n  | { url: URL; method?: \"GET\"; body?: undefined }\n  | { url: URL; method?: \"POST\" | \"PUT\" | \"PATCH\"; body: T };\n\n/** Messages emitted by a fetch process during its lifecycle. */\nexport type FetchMessage<T> =\n  | { type: \"OK\"; data?: T | null; text?: string | null }\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// ---- 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  { pname, toParent, send }: ProcessCtx<FetchMessage<Type>, FetchMessage<Type>>,\n  { method = \"GET\", url, body }: FetchArgs<Type>,\n): Generator<FetchState<Type> | null, void, FetchMessage<Type>> {\n  const state: FetchState<Type> = { code: \"pending\", data: null, text: null };\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({});\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      if (isJsonHelper(res)) {\n        const data = await res.json();\n        toSelf({ type: \"OK\", data });\n      } else {\n        const text = await res.text();\n        toSelf({ type: \"OK\", text });\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      }\n    },\n    isDone,\n    true,\n  );\n}\n\nexport { xfetch };\n"],"mappings":";;AAkCA,SAAS,aAAa,KAAwB;CAE5C,OADW,IAAI,QAAQ,IAAI,cACnB,MAAM;AAChB;;;;;;AASA,UAAU,OACR,EAAE,OAAO,UAAU,QACnB,EAAE,SAAS,OAAO,KAAK,QACuC;CAC9D,MAAM,QAA0B;EAAE,MAAM;EAAW,MAAM;EAAM,MAAM;CAAK;CAC1E,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,CAAC,CAAC;GAC9B,IAAI,gBACF,QAAQ,IAAI,gBAAgB,kBAAkB;GAEhD,MAAM,MAAgB,MAAM,MAAM,IAAI,MAAM;IAC1C;IACA;IACA,MAAM;IACN;GACF,CAAC;GACD,IAAI,aAAa,GAAG,GAElB,OAAO;IAAE,MAAM;IAAM,MAAA,MADF,IAAI,KAAK;GACF,CAAC;QAG3B,OAAO;IAAE,MAAM;IAAM,MAAA,MADF,IAAI,KAAK;GACF,CAAC;EAE/B,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;EAC3B;CACF,GACA,QACA,IACF;AACF"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "type": "module",
   "name": "posipaki",
-  "version": "0.6.4",
+  "version": "0.7.0",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "files": [
@@ -19,5 +19,15 @@
     "tsdown": "^0.22.1",
     "typescript": "^6.0.3",
     "vitest": "^4.1.7"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./xfetch": {
+      "types": "./dist/xfetch.d.ts",
+      "default": "./dist/xfetch.js"
+    }
   }
 }

package/dist/process-BlUe6Luh.d.ts

@@ -1,100 +0,0 @@
-//#region src/util.d.ts
-type ReducerClosure<M> = (msg: M) => void;
-type ReadyFn = () => boolean;
-/**
- * Generator helper that loops, yielding `null` and feeding incoming
- * messages to `fn` until `readyFn()` returns true. Used inside
- * process generators to build the main message loop.
- */
-declare function runDispatch<M>(name: string, fn: ReducerClosure<M>, readyFn?: ReadyFn, debugLevel?: boolean): Generator<null, void, M>;
-/** Message emitted by a process to its parent when it terminates. */
-type ExitMessage = {
-  type: 'EXIT';
-  pid: symbol;
-};
-//#endregion
-//#region src/process.d.ts
-/**
- * Base message type. All messages must include a `type` field
- * for discrimination in reducers.
- */
-interface Message {
-  type: string;
-}
-type ProcessGenerator<ProcessState, InMessage> = Generator<ProcessState | null, void, InMessage>;
-type Fork = <ChildArgs, ChildState, InMessage extends Message, OutMessage extends Message>(fn: ProcessFn<ChildArgs, ChildState, InMessage, OutMessage>, pname: string) => (args: ChildArgs) => Process<ChildArgs, ChildState, InMessage, OutMessage>;
-/**
- * A process generator function. Receives a {@link ProcessCtx} and
- * initial args, yields state (or `null`) at each step.
- */
-type ProcessFn<Args, State, InMessage, OutMessage> = (ctx: ProcessCtx<InMessage, OutMessage>, args: Args) => ProcessGenerator<State, InMessage>;
-type ProcessMessageCb<M> = (msg: M) => void;
-/**
- * Context injected into every running process. Provides the process
- * name, ability to fork children, and I/O channels.
- */
-type ProcessCtx<IM, OM> = {
-  pname: string;
-  fork: Fork;
-  send: (msg: IM) => void;
-  toParent: ProcessMessageCb<OM>;
-};
-type NotifyFn = () => void;
-/**
- * Spawn a new process from a process function. Returns a curried
- * function: call it with initial args to start execution.
- */
-declare function spawn<Args, State, InMessage extends Message = Message, OutMessage extends Message = ExitMessage>(fn: ProcessFn<Args, State, InMessage, OutMessage>, pname: string, toParent?: ProcessMessageCb<OutMessage>): (args: Args) => Process<Args, State, InMessage, OutMessage>;
-/**
- * A running process — an actor with message-passing, child processes,
- * and observable state. Driven by a generator function that yields
- * state snapshots and receives messages via `yield` expressions.
- */
-declare class Process<Args, State, InMessage extends Message, OutMessage extends Message> {
-  pgenerator: ProcessFn<Args, State, InMessage, OutMessage>;
-  pname: string;
-  toParent: ProcessMessageCb<OutMessage>;
-  id: symbol;
-  state: State | null;
-  private current;
-  private buffer;
-  private nextTick;
-  private children;
-  private subscribers;
-  private exitWaiter;
-  private _isPaused;
-  constructor(fn: ProcessFn<Args, State, InMessage, OutMessage>, pname: string, toParent: ProcessMessageCb<OutMessage> | undefined);
-  /** Kick off the generator with initial arguments. */
-  start(arg0: Args): void;
-  /** Fork a child process. Children forward messages to this process
-   * and send `EXIT` when they terminate. */
-  fork<ChildArgs, ChildState, ChildIM extends Message, ChildOM extends Message>(fn: ProcessFn<ChildArgs, ChildState, ChildIM, ChildOM>, pname: string): (args: ChildArgs) => Process<ChildArgs, ChildState, ChildIM, ChildOM>;
-  _tick(): void;
-  _eatResult(ret: IteratorResult<State | null, void> | null): void;
-  /** Send a message to every child process (used for `STOP` propagation). */
-  toAllChildren(msg: Message): void;
-  /** Send a message to this process. Messages are buffered and
-   * processed asynchronously via a microtask. */
-  send(msg: InMessage): void;
-  /** Synchronously flush the message buffer. Useful in tests. */
-  tick(): void;
-  _scheduleTick(): void;
-  notify(): void;
-  /** Whether any subscribers are watching for state changes. */
-  get isListenedTo(): boolean;
-  /** Subscribe to state changes. Returns an unsubscribe function. */
-  subscribe(f: NotifyFn): () => void;
-  /** Pause message processing. Incoming messages are buffered
-   * but not processed until {@link resume} is called. */
-  pause(): void;
-  /** Resume processing after a {@link pause}. */
-  resume(): void;
-  /** Return a promise that resolves when the generator completes. */
-  wait(): Promise<void>;
-  /** Handle a message forwarded from a child process. `EXIT` removes
-   * the child; all other messages are forwarded to `send`. */
-  fromChild(msg: InMessage): void;
-}
-//#endregion
-export { spawn as a, ProcessFn as i, Process as n, ExitMessage as o, ProcessCtx as r, runDispatch as s, Message as t };
-//# sourceMappingURL=process-BlUe6Luh.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"process-BlUe6Luh.d.ts","names":[],"sources":["../src/util.ts","../src/process.ts"],"mappings":";KASK,cAAA,OAAqB,GAAA,EAAK,CAAC;AAAA,KAC3B,OAAA;;;;;AAD2B;iBAStB,WAAA,IAAe,IAAA,UAAc,EAAA,EAAK,cAAA,CAAe,CAAA,GAAI,OAAA,GAAS,OAAA,EAAsB,UAAA,aAAsB,SAAA,aAAsB,CAAA;;KAU9H,WAAA;EACV,IAAA;EACA,GAAG;AAAA;;;AA7BmD;;;;AAAA,UCYvC,OAAA;EACf,IAAI;AAAA;AAAA,KAGD,gBAAA,4BAA4C,SAAA,CAC/C,YAAA,eAEA,SAAA;AAAA,KAEG,IAAA,6CAGe,OAAA,qBACC,OAAA,EAEnB,EAAA,EAAI,SAAA,CAAU,SAAA,EAAW,UAAA,EAAY,SAAA,EAAW,UAAA,GAChD,KAAA,cACI,IAAA,EAAM,SAAA,KAAc,OAAA,CAAQ,SAAA,EAAW,UAAA,EAAY,SAAA,EAAW,UAAA;ADrBpC;;;;AAAA,KC2BpB,SAAA,wCACV,GAAA,EAAK,UAAA,CAAW,SAAA,EAAW,UAAA,GAC3B,IAAA,EAAM,IAAA,KACH,gBAAA,CAAiB,KAAA,EAAO,SAAA;AAAA,KACxB,gBAAA,OAAuB,GAAA,EAAK,CAAC;;;;;KAMtB,UAAA;EACV,KAAA;EACA,IAAA,EAAM,IAAA;EACN,IAAA,GAAO,GAAA,EAAK,EAAA;EACZ,QAAA,EAAU,gBAAA,CAAiB,EAAA;AAAA;AAAA,KAGxB,QAAA;;;;;iBAOW,KAAA,gCAGI,OAAA,GAAU,OAAA,qBACT,OAAA,GAAU,WAAA,EAE7B,EAAA,EAAI,SAAA,CAAU,IAAA,EAAM,KAAA,EAAO,SAAA,EAAW,UAAA,GACtC,KAAA,UACA,QAAA,GAAW,gBAAA,CAAiB,UAAA,KAEpB,IAAA,EAAM,IAAA,KAAO,OAAA,CAAQ,IAAA,EAAM,KAAA,EAAO,SAAA,EAAW,UAAA;;;;;ADpDoF;cCqErI,OAAA,gCAGc,OAAA,qBACC,OAAA;EAEnB,UAAA,EAAY,SAAA,CAAU,IAAA,EAAM,KAAA,EAAO,SAAA,EAAW,UAAA;EAC9C,KAAA;EACA,QAAA,EAAU,gBAAA,CAAiB,UAAA;EAC3B,EAAA;EACA,KAAA,EAAO,KAAA;EAAA,QAEC,OAAA;EAAA,QACA,MAAA;EAAA,QACA,QAAA;EAAA,QACA,QAAA;EAAA,QACA,WAAA;EAAA,QACA,UAAA;EAAA,QACA,SAAA;cAGN,EAAA,EAAI,SAAA,CAAU,IAAA,EAAM,KAAA,EAAO,SAAA,EAAW,UAAA,GACtC,KAAA,UACA,QAAA,EAAU,gBAAA,CAAiB,UAAA;EA7FV;EA+GnB,KAAA,CAAM,IAAA,EAAM,IAAA;EA9GZ;;EA8HA,IAAA,wCAA4C,OAAA,kBAAyB,OAAA,EACnE,EAAA,EAAI,SAAA,CAAU,SAAA,EAAW,UAAA,EAAY,OAAA,EAAS,OAAA,GAC9C,KAAA,YAGE,IAAA,EAAM,SAAA,KACL,OAAA,CAAQ,SAAA,EAAW,UAAA,EAAY,OAAA,EAAS,OAAA;EAiB7C,KAAA;EAgBA,UAAA,CAAW,GAAA,EAAK,cAAA,CAAe,KAAA;EAtKX;EA6KpB,aAAA,CAAc,GAAA,EAAK,OAAA;EA7K4B;;EAmL/C,IAAA,CAAK,GAAA,EAAK,SAAA;EAhLD;EAsLT,IAAA;EAKA,aAAA;EAYA,MAAA;EArMO;EAAA,IA0MH,YAAA;EAtMe;EA2MnB,SAAA,CAAU,CAAA,EAAG,QAAA;EAzMY;;EAsNzB,KAAA;EAtNI;EA6NJ,MAAA;EA3NgC;EAiOhC,IAAA,IAAI,OAAA;EAjOmD;;EAuOvD,SAAA,CAAU,GAAA,EAAK,SAAA;AAAA"}

package/dist/util-5PSJsovA.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"util-5PSJsovA.js","names":[],"sources":["../src/util.ts"],"sourcesContent":["import type { Process } from './process.js';\nimport type { ProcessCtx, Message } from './process.js';\n\nfunction 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>(name: string, fn : ReducerClosure<M>, readyFn: ReadyFn = ()=> false, debugLevel = false) : 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/** Message emitted by a process to its parent when it terminates. */\nexport type ExitMessage = {\n  type: 'EXIT';\n  pid: symbol;\n};\n\n/** Wrap a process generator so that on completion it sends `STOP`\n * to all children and `EXIT` to the parent. */\nfunction watchExit<Args, State, InMessage extends Message, OutMessage extends (Message | ExitMessage)>(process: Process<Args, State, InMessage, OutMessage>) {\n  return function* (ctx: ProcessCtx<InMessage, OutMessage>, arg0: Args) {\n    yield* process.pgenerator(ctx, arg0);\n    process.toAllChildren({ type: 'STOP' });\n    process.toParent({ type: 'EXIT', pid: process.id} as OutMessage);\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, watchExit, defer, makeWaiter };\n"],"mappings":";AAGA,SAAS,SAAS,OAAgB,GAAG,MAAsB;CACzD,IAAI,OACF,QAAQ,IAAI,GAAG,IAAI;AAEvB;;;;;;AAWA,UAAU,YAAe,MAAc,IAAwB,gBAAwB,OAAO,aAAa,OAAkC;CAC3I,IAAI;CACJ,OAAM,CAAC,QAAQ,GAAG;EAChB,MAAM,MAAM;EACZ,SAAS,YAAY,OAAO,MAAM,QAAQ,GAAG;EAC7C,GAAG,GAAG;CACR;AACF;;;AAUA,SAAS,UAA8F,SAAsD;CAC3J,OAAO,WAAW,KAAwC,MAAY;EACpE,OAAO,QAAQ,WAAW,KAAK,IAAI;EACnC,QAAQ,cAAc,EAAE,MAAM,OAAO,CAAC;EACtC,QAAQ,SAAS;GAAE,MAAM;GAAQ,KAAK,QAAQ;EAAE,CAAe;CACjE;AACF;;;AAqBA,SAAS,MAAM,IAA4B;CACzC,MAAM,IAAI;CACV,SAAS,SAAS,SAAgB,UAAkB;EAClD,MAAM,SAAS,QAAQ,EAAE;EACzB,aAAY,SAAS,MAAM;CAC7B;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,aAAsB;CAC7B,IAAI;CAIJ,OAAO;EAAC,SAAA,IAHU,SAAc,aAAY;GAC1C,UAAU;EACZ,CACc;EAAY;CAAmB;AAC/C"}