Concurrency & workers

Spawns a real OS thread running one of the program's worker modules as an isolate: on its thread it evaluates every builtin module and the modules the file imports afresh, then the file. The Worker is Node's (an EventEmitter with 'online', 'message', 'error', 'exit', postMessage, terminate() resolving the exit code, ref/unref, threadId); the web's onmessage/onerror shape and a worker's self.onmessage/self.postMessage work too. Messages are structured clones of any value; a SharedArrayBuffer keeps its memory, and a MessagePort in the transfer list moves to the other thread. An uncaught error in the worker reaches the parent's 'error', then 'exit' with code 1.

filenamestring | URL

A path literal (or __filename) naming a worker module; resolved relative to the file it is written in.

optionsWorkerOptions

workerData (any cloneable value), transferList, name.

Worker — An EventEmitter with postMessage, terminate, ref/unref and threadId.

const a = new Worker('./sum_worker.ts', { workerData: "left" });
a.on('message', (partial: number) => { total += partial; a.terminate(); });
a.postMessage(left);

Name-keyed pub/sub across threads through a process-wide registry: each other open channel of the name gets its own structured clone of the message, delivered on its own thread's loop. An open channel holds the loop until close(), as Node's does; onmessage, addEventListener/removeEventListener and ref()/unref() work same-thread and across workers.

namestring

The channel name (any string).

BroadcastChannel — An endpoint with postMessage, onmessage, addEventListener and close.

const bc = new BroadcastChannel('news');
setTimeout(() => {
  bc.postMessage("markets up in Thessaloniki");
  bc.close();
}, 100);

An entangled port pair. A port is Node's NodeEventTarget: on('message') or onmessage starts it, addEventListener works, close() closes both ends and each emits 'close', and ref()/unref()/hasRef() control whether it holds the loop. A port moves to another thread in a postMessage transfer list or a Worker's transferList, and is detached on the sending side; one outside the transfer list is a DataCloneError. Globals, and importable from worker_threads.

{ port1, port2 } — A pair of entangled MessagePorts.

const ch = new MessageChannel();
const w = new Worker('./port_worker.ts', { workerData: ch.port2, transferList: [ch.port2] });
ch.port1.onmessage = (e: MessageEvent) => { console.log("shouted back: " + e.data); };

An explicitly-non-Node opt-in: Go's concurrency model, not a JS approximation. go(fn) spawns a cheap goroutine onto a GMP work-stealing scheduler (one logical processor + pinned OS thread per GOMAXPROCS, global run-queue backstop, half-queue stealing) in an embedded C runtime linked only when klain:sync is imported. Channel<T> is a Go channel: synchronous blocking send/receive (not await) that parks the goroutine — the OS thread keeps running others — as an unbuffered rendezvous or buffered ring, with close() and `for (const v of ch)` range. select(...) is Go's random-fair select over recvCase/sendCase/defaultCase. Cooperative preemption is complete: a sysmon thread flags an over-budget goroutine and compiler-inserted safepoints at every function entry and loop back-edge yield it, so no goroutine can starve the others.

fn() => void

go(fn): the goroutine body; captures channels from its enclosing scope.

capacitynumber

new Channel<T>(capacity): 0/omitted is an unbuffered rendezvous; >0 is a buffered ring.

...casesSelectCase[]

select(...): ch.recvCase(handler) / ch.sendCase(value, handler) / defaultCase(handler); runs one ready case, or blocks until one fires (unless a defaultCase is present).

void | Channel<T> — go returns nothing; new Channel<T> returns a channel with .send(v: T)/.receive(): T/.close(); receive() gives undefined once the channel is closed and drained.