posipaki 0.6.2 → 0.6.4

package/dist/index.d.ts

@@ -1,3 +1,2 @@
-import Process, { spawn, Message, ProcessCtx, ProcessFn } from './process';
-import { ExitMessage, runDispatch } from './util';
-export { Process, spawn, runDispatch, Message, ExitMessage, ProcessCtx, ProcessFn };
+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 };

package/dist/index.js

@@ -1,4 +1,166 @@
-import Process, { spawn } from './process';
-import { runDispatch } from './util';
-export { Process, spawn, runDispatch };
+import { i as watchExit, n as makeWaiter, r as runDispatch, t as defer } from "./util-5PSJsovA.js";
+//#region src/process.ts
+/**
+* Spawn a new process from a process function. Returns a curried
+* function: call it with initial args to start execution.
+*/
+function spawn(fn, pname, toParent) {
+	return (args) => {
+		const process = new Process(fn, pname, toParent);
+		process.start(args);
+		return process;
+	};
+}
+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.
+*/
+var Process = class Process {
+	constructor(fn, pname, toParent) {
+		this._isPaused = false;
+		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();
+	}
+	/** Kick off the generator with initial arguments. */
+	start(arg0) {
+		const ctx = {
+			pname: this.pname,
+			fork: this.fork.bind(this),
+			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. */
+	fork(fn, pname) {
+		return (args) => {
+			const child = new Process(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;
+		}
+		this.notify();
+		this._eatResult(ret);
+	}
+	_eatResult(ret) {
+		if (ret && ret.done) this.exitWaiter.resolve();
+	}
+	/** Send a message to every child process (used for `STOP` propagation). */
+	toAllChildren(msg) {
+		this.children.forEach((p) => p.send(msg));
+	}
+	/** Send a message to this process. Messages are buffered and
+	* processed asynchronously via a microtask. */
+	send(msg) {
+		this.buffer.push(msg);
+		this._scheduleTick();
+	}
+	/** Synchronously flush the message buffer. Useful in tests. */
+	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());
+	}
+	/** 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 () => {
+			const idx = this.subscribers.indexOf(f);
+			if (idx < 0) return;
+			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. */
+	wait() {
+		return this.exitWaiter.promise;
+	}
+	/** 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);
+	}
+};
+//#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.
+*
+* ## 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 };
+
 //# 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.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"}

package/dist/pipe.d.ts

@@ -0,0 +1,22 @@
+import { i as ProcessFn, o as ExitMessage, t as Message } from "./process-BlUe6Luh.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 { r as runDispatch } from "./util-5PSJsovA.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 \"./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"}

package/dist/process-BlUe6Luh.d.ts

@@ -0,0 +1,100 @@
+//#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

@@ -0,0 +1 @@
+{"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/supervisor.d.ts

@@ -0,0 +1,45 @@
+import { i as ProcessFn, n as Process, o as ExitMessage, r as ProcessCtx } from "./process-BlUe6Luh.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 { r as runDispatch } from "./util-5PSJsovA.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"}

package/dist/util-5PSJsovA.js

@@ -0,0 +1,64 @@
+//#region src/util.ts
+function debugLog(level, ...args) {
+	if (level) console.log(...args);
+}
+/**
+* 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.
+*/
+function* runDispatch(name, fn, readyFn = () => false, debugLevel = false) {
+	let msg;
+	while (!readyFn()) {
+		msg = yield null;
+		debugLog(debugLevel, "msg", name, " <- ", msg);
+		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) {
+	const g = globalThis;
+	function schedule(deferFn, cancelFn) {
+		const taskId = deferFn(fn);
+		return () => cancelFn(taskId);
+	}
+	let cancel;
+	if (g.setImmediate && g.clearImmediate) cancel = schedule(g.setImmediate, g.clearImmediate);
+	else if (g.requestIdleCallback && g.cancelIdleCallback) cancel = schedule(g.requestIdleCallback, g.cancelIdleCallback);
+	else cancel = schedule((f) => setTimeout(f, 0), clearTimeout);
+	function flush() {
+		cancel();
+		fn();
+	}
+	return {
+		flush,
+		cancel
+	};
+}
+/** Create a new {@link Waiter}. */
+function makeWaiter() {
+	let resolve;
+	return {
+		promise: new Promise((_resolve) => {
+			resolve = _resolve;
+		}),
+		resolve
+	};
+}
+//#endregion
+export { watchExit as i, makeWaiter as n, runDispatch as r, defer as t };
+
+//# sourceMappingURL=util-5PSJsovA.js.map

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

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

package/package.json

@@ -1,25 +1,23 @@
 {
   "type": "module",
   "name": "posipaki",
-  "version": "0.6.2",
+  "version": "0.6.4",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
-  "scripts": {
-    "build": "tsc",
-    "test": "jest"
-  },
   "files": [
-    "dist/*js",
-    "dist/*map",
-    "dist/*d.ts",
-    "src/*ts"
+    "dist"
   ],
+  "scripts": {
+    "build": "tsdown",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "lint": "oxlint"
+  },
   "devDependencies": {
-    "@babel/parser": "^7.22.5",
-    "@babel/types": "^7.22.5",
-    "@types/jest": "^29.5.2",
-    "jest": "^29.5.0",
-    "ts-jest": "^29.1.0",
-    "typescript": "^5.1.3"
+    "@types/node": "^25.9.1",
+    "oxlint": "^1.67.0",
+    "tsdown": "^0.22.1",
+    "typescript": "^6.0.3",
+    "vitest": "^4.1.7"
   }
 }