posipaki 0.6.3 → 0.7.0

package/dist/index.d.ts

@@ -1,3 +1,7 @@
-import Process, { spawn, Message, ProcessCtx, ProcessFn } from './process';
-import { ExitMessage, runDispatch } from './util';
-export { Process, spawn, runDispatch, Message, ExitMessage, ProcessCtx, ProcessFn };
+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,4 +1,245 @@
-import Process, { spawn } from './process';
-import { runDispatch } from './util';
-export { Process, spawn, runDispatch };
+import { i as runDispatch, n as defer, r as makeWaiter, t as debugLog } from "./util-Cw64MseZ.js";
+//#region src/process.async.ts
+/**
+* Async equivalent of `runDispatch`. Loops, yielding `null` and feeding
+* each incoming message to an `async` reducer. Exits when `readyFn()`
+* returns true.
+*/
+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 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 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.state = null;
+		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 async generator. The first `yield` sets the initial
+	* state; for async generators this happens in a microtask.
+	*/
+	start(arg0) {
+		const ctx = {
+			pname: this.pname,
+			fork: this.fork.bind(this),
+			send: this.send.bind(this),
+			toParent: this.toParent
+		};
+		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 AsyncProcess(fn, pname, this.fromChild.bind(this));
+			this.children.push(child);
+			child.start(args);
+			return child;
+		};
+	}
+	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
+			};
+		}
+	}
+	_eatResult(ret) {
+		if (!ret) return;
+		Promise.resolve(ret).then((r) => {
+			if (r.done) this.exitWaiter.resolve();
+		});
+	}
+	/** Broadcast a message to all children. */
+	toAllChildren(msg) {
+		this.children.forEach((p) => p.send(msg));
+	}
+	/** Enqueue a message. Processing is async (microtask). */
+	send(msg) {
+		this.buffer.push(msg);
+		this._scheduleTick();
+	}
+	/**
+	* 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;
+	}
+	_scheduleTick() {
+		if (this._isPaused) return;
+		this.nextTick?.cancel();
+		this.nextTick = defer(() => {
+			this.nextTick = null;
+			this._tick();
+		});
+	}
+	notify() {
+		this.subscribers.forEach((f) => f());
+	}
+	get isListenedTo() {
+		return this.subscribers.length > 0;
+	}
+	subscribe(f) {
+		this.subscribers.push(f);
+		return () => {
+			const idx = this.subscribers.indexOf(f);
+			if (idx < 0) return;
+			this.subscribers.splice(idx, 1);
+		};
+	}
+	pause() {
+		this.nextTick?.cancel();
+		this.nextTick = null;
+		this._isPaused = true;
+	}
+	resume() {
+		this._isPaused = false;
+		this._scheduleTick();
+	}
+	/**
+	* Returns a promise that resolves when the generator completes, or
+	* rejects if an unhandled error occurs during message processing.
+	*/
+	wait() {
+		return new Promise((resolve, reject) => {
+			this._exitReject = reject;
+			this.exitWaiter.promise.then(() => {
+				this._exitReject = null;
+				resolve();
+			}, (e) => {
+				this._exitReject = null;
+				reject(e);
+			});
+		});
+	}
+	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
+/**
+* Posipaki — Erlang-inspired lightweight actor processes built on
+* generator functions. Processes communicate via message-passing,
+* can fork children, and expose their state reactively.
+*
+* @module
+*/
+//#endregion
+export { AsyncProcess, Process, asyncify, runDispatch, runDispatchAsync, spawn, spawnAsync };
+
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,OAAO,EAAE,EAAE,KAAK,EAAkC,MAAM,WAAW,CAAC;AAC3E,OAAO,EAAe,WAAW,EAAE,MAAM,QAAQ,CAAC;AAElD,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,WAAW,EAA+C,CAAA"}
+{"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

@@ -0,0 +1,22 @@
+import { c as ExitMessage, f as ProcessFn, l as Message } from "./process-jEWRVEFG.js";
+
+//#region src/pipe.d.ts
+/**
+ * State yielded by the pipe process. `params` starts as a copy of the
+ * initial args and is updated after each child exits by merging the
+ * child's `state.result` into it.
+ */
+interface PipeState<Params, Result> {
+  params: Params | null;
+  result: Result | null;
+  running: boolean;
+}
+/**
+ * Chain process functions so each runs after the previous one exits.
+ * The `.state.result` of each completed child is spread into the params
+ * of the next.
+ */
+declare function pipe<Params, Result>(fns: ProcessFn<Params, any, any, any>[]): ProcessFn<Params, PipeState<Params, Result>, Message, Message | ExitMessage>;
+//#endregion
+export { PipeState, pipe };
+//# sourceMappingURL=pipe.d.ts.map

package/dist/pipe.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pipe.d.ts","names":[],"sources":["../src/pipe.ts"],"mappings":";;;AAWA;;;;;AAAA,UAAiB,SAAA;EACf,MAAA,EAAQ,MAAA;EACR,MAAA,EAAQ,MAAM;EACd,OAAA;AAAA;;;AAAO;AACR;;iBAOQ,IAAA,iBACP,GAAA,EAAK,SAAA,CAAU,MAAA,qBACd,SAAA,CACD,MAAA,EACA,SAAA,CAAU,MAAA,EAAQ,MAAA,GAClB,OAAA,EACA,OAAA,GAAU,WAAA"}

package/dist/pipe.js

@@ -0,0 +1,49 @@
+import { i as runDispatch } from "./util-Cw64MseZ.js";
+//#region src/pipe.ts
+/**
+* Chain process functions so each runs after the previous one exits.
+* The `.state.result` of each completed child is spread into the params
+* of the next.
+*/
+function pipe(fns) {
+	return function* ({ pname, fork }, params) {
+		const state = {
+			params: { ...params },
+			result: null,
+			running: false
+		};
+		yield state;
+		const queue = [...fns];
+		let task;
+		function spawnNext() {
+			const fn = queue.shift();
+			task = fork(fn, `${pname} [${fn.name || "<anonymous>"}]`)(state.params);
+		}
+		function hasNext() {
+			return queue.length > 0;
+		}
+		spawnNext();
+		state.running = hasNext();
+		yield* runDispatch(pname, (msg) => {
+			if (msg.type === "STOP") {
+				state.params = null;
+				state.running = false;
+				return;
+			}
+			if (msg.type === "EXIT" && msg.pid === task.id) if (hasNext()) {
+				state.params = {
+					...state.params,
+					...task.state?.result
+				};
+				spawnNext();
+			} else {
+				state.running = false;
+				state.result = task.state?.result;
+			}
+		}, () => !state.running, true);
+	};
+}
+//#endregion
+export { pipe };
+
+//# sourceMappingURL=pipe.js.map

package/dist/pipe.js.map

@@ -0,0 +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 \"./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

@@ -0,0 +1,45 @@
+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;
+interface RunMsg {
+  type: "RUN";
+  fn: ProcessFn<any, any, any, any>;
+  args: any[];
+  pname: string;
+}
+interface StopMsg {
+  type: "STOP";
+}
+interface ErrorMsg {
+  type: "ERROR";
+}
+interface OkMsg {
+  type: "OK";
+  [key: string]: unknown;
+}
+interface SupervisorState {
+  processes: Process<any, any, any, any>[];
+  phase: "wait" | "running" | "stopping";
+}
+/**
+ * A supervisor process. Call `attach` to send it `RUN` messages —
+ * it will fork the given function as a child. The supervisor exits
+ * when it enters `'stopping'` phase (triggered by `ERROR` or `STOP`).
+ *
+ * @param wrap  optional transformation applied to the state before
+ *              each yield (e.g. `reactive` from Vue)
+ */
+declare function supervise({
+  pname,
+  toParent,
+  fork
+}: ProcessCtx<SupMsg, SupMsg>, wrap?: (s: SupervisorState) => SupervisorState, debugLevel?: boolean): Generator<SupervisorState | null, void, SupMsg>;
+/**
+ * Bind a process function to a supervisor. The returned function,
+ * when called, sends a `RUN` message so the supervisor forks the child.
+ */
+declare function attach<Args extends any[]>(supervisor: Process<any, any, SupMsg, SupMsg>, fn: ProcessFn<Args, any, any, any>, pname: string): (...args: Args) => void;
+//#endregion
+export { SupervisorState, attach, supervise };
+//# sourceMappingURL=supervisor.d.ts.map

package/dist/supervisor.d.ts.map

@@ -0,0 +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,CAAW,MAAA,EAAQ,MAAA,GAC9C,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"}

package/dist/supervisor.js

@@ -0,0 +1,53 @@
+import { i as runDispatch } from "./util-Cw64MseZ.js";
+//#region src/supervisor.ts
+/**
+* A supervisor process. Call `attach` to send it `RUN` messages —
+* it will fork the given function as a child. The supervisor exits
+* when it enters `'stopping'` phase (triggered by `ERROR` or `STOP`).
+*
+* @param wrap  optional transformation applied to the state before
+*              each yield (e.g. `reactive` from Vue)
+*/
+function* supervise({ pname, toParent, fork }, wrap = (a) => a, debugLevel = false) {
+	const state = wrap({
+		processes: [],
+		phase: "wait"
+	});
+	yield state;
+	yield* runDispatch(pname, (msg) => {
+		switch (msg.type) {
+			case "RUN":
+				fork(msg.fn, msg.pname)(...msg.args);
+				state.phase = "running";
+				break;
+			case "ERROR":
+			case "STOP":
+				state.phase = "stopping";
+				break;
+			case "EXIT":
+				state.processes = state.processes.filter((p) => p.id !== msg.pid);
+				break;
+			case "OK":
+				toParent(msg);
+				break;
+		}
+	}, () => state.phase === "stopping", debugLevel);
+}
+/**
+* Bind a process function to a supervisor. The returned function,
+* when called, sends a `RUN` message so the supervisor forks the child.
+*/
+function attach(supervisor, fn, pname) {
+	return (...args) => {
+		supervisor.send({
+			type: "RUN",
+			fn,
+			args,
+			pname
+		});
+	};
+}
+//#endregion
+export { attach, supervise };
+
+//# sourceMappingURL=supervisor.js.map

package/dist/supervisor.js.map

@@ -0,0 +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<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"}