4N parallel V8 isolates per Worker request.

Each item: a SHA-256 chain (5,000 iterations over a 64-byte buffer). ~80–150 ms of CPU per item on workerd. Pick a fan-out size; the library picks the topology.

await pool.map(sha256Chain, items)

The auto-selector reads items.length and picks one of three shapes. Hover any row to see the math; click Run to fan out and update the live numbers.

Each card runs against the live test worker. The code shown is the actual call being made.

Enqueue a CPU-bound burst (each job: 1M LCG iterations). Reactive dispatch starts work the moment a slot frees — no alarm-batched delay. Fair round-robin across tenantId.

await scheduler.enqueue({ fn, args, tenantId, idempotencyKey })

A counter Actor whose state lives in a Coordinator DO's SQLite. Each submit mutates the state in place; the runtime structured-clones it after each call. Close the Actor; the state is gone.

await actor.submit((state) => ++state.count)

Paste a function expression. It runs in a fresh sandboxed V8 isolate with globalOutbound: null (no fetch) and zero bindings exposed. Bearer-auth required. Don't try to bypass the sandbox — it's load-bearing.

click Submit to run

Start a 1M-iteration SHA chain inside an isolate. Hit Cancel; the request closes; env.signal.aborted trips inside the loaded isolate; the loop returns early. Watch the iteration counter stop.

const cancel = new CancelToken();
await pool.submit(longLoop, iters, { cancel });
// hit /demo/cancel-start; close the SSE to fire cancel.

The honest curve. Each row: SHA-256-chain over N items, parallel via pool.map vs sequential baseline. Speedup grows with size as the dispatch overhead amortizes; tree topology kicks in at 256.