Global objects

esrun's global scope tracks the WinterTC Minimum Common Web Platform API. These are standard Web globals — the same names you would use in a browser or other server runtimes. Host capabilities (filesystem, process, network access) are not globals; they live in runtime: modules.

Core

console

Format specifiers: %s, %d/%i, %f, %o/%O, %j, %%, %c.

console.table([{ id: 1, name: "a" }, { id: 2, name: "b" }]);
console.time("query"); await db.run(); console.timeEnd("query");

Timers

URL

Fetch & networking

Encoding

Streams

Crypto

Events

Unhandled failures

A failure with nothing left to catch it is offered to the global scope first. preventDefault() claims it; anything unclaimed is printed and exits non-zero.

globalThis.addEventListener("unhandledrejection", (event) => {
  logger.warn("unhandled", event.reason);
  event.preventDefault(); // mine now — do not fail the process
});

onerror / onunhandledrejection / onrejectionhandled are single-handler slots over the same events. rejectionhandled does not retract a report that has already gone out.

Messaging

Messages are structured-cloned at postMessage, delivered in order, and reach other agents — a worker is a second isolate on its own thread. See Workers.

A MessagePort may be transferred and may not be cloned — two ends of a channel cannot become three — and arrives through event.ports. ArrayBuffer and streams transfer too; a SharedArrayBuffer is shared rather than transferred, which is what makes Atomics between agents mean anything.

Inside a worker the global scope is a DedicatedWorkerGlobalScope, with WorkerNavigator and WorkerLocation alongside it.

Data

Performance

WebAssembly

No capability required — a module is as privileged as the imports you pass it.

const { instance } = await WebAssembly.instantiate(bytes, {
  env: { log: (n) => console.log(n) },
});
instance.exports.add(2, 3); // 5

import { add } from "./add.wasm"; // .wasm files import directly

Full surface, proposal matrix, and caveats: WebAssembly & WASI.

Streaming upload

Passing a ReadableStream as the fetch body uploads it as a chunked transfer with backpressure — the body is never fully buffered, so large or open-ended uploads stay memory-bounded. Response bodies stream too.

// A ReadableStream body streams to the server (chunked upload, backpressured).
const body = new ReadableStream({
  async pull(c) {
    const next = await source.read();        // your data source
    if (next.done) c.close();
    else c.enqueue(next.value);              // Uint8Array chunks
  },
});

await fetch("https://example.com/upload", { method: "POST", body });
// Anything else (string, Blob, FormData, Uint8Array) is sent buffered.

Timeouts

await fetch(url, { signal: AbortSignal.timeout(5000) }); // TimeoutError

Compressed responses

Requests carry User-Agent: ES-Runtime/<version> unless you set your own. Both are properties of the default transport.

Redirects

const r = await fetch(url, { redirect: "manual" });
r.status;                      // 302
r.headers.get("location");     // where it would have gone
r.redirected;                  // false — nothing was followed

An unknown mode throws TypeError from new Request. Under "manual" the real response is returned, not the spec's opaque-redirect filtered one — same as Node, Deno and Bun.

Not available