process

Elide installs the Node-style process object on globalThis. The fields documented below are stable; everything else is either Node-specific (and not yet implemented) or a host hook reserved for Elide internals.

Events

• beforeExit — fired with the exit code when the event loop empties. A handler may schedule more asynchronous work, which the loop then drains.
• exit — fired with the final exit code as the process terminates (process.exitCode if set, else 0, or the fatal code on an uncaught exception). Handlers run synchronously; async work scheduled from them is dropped.
• uncaughtException — fired with (error, origin) when an exception escapes an asynchronous callback (a nextTick callback, a timer, …). With a handler registered the loop continues; with none, the error is printed to stderr and the process exits with code 1, as in Node.
• unhandledRejection — fired with (reason, promise) for a rejected Promise with no rejection handler. A registered handler suppresses the default stderr report.
• warning — fired with the warning object by process.emitWarning. A default listener prints unhandled warnings to stderr.

process.on("exit", (code) => console.log("exiting with", code));
process.on("uncaughtException", (err) => console.error("caught", err.message));

process.nextTick

process.stdout / process.stderr

Writable streams backed by the realm's output and error sinks (fds 1 and 2). Each is an EventEmitter exposing the Writable surface (write, end, cork/uncork, …) plus fd. console.log / console.error write through these streams, so replacing process.stdout.write intercepts console output (as in Node).

When the output is attached to a terminal, the stream also exposes isTTY (true), columns, rows, and getWindowSize(); for piped output these are absent (undefined), matching Node.

process.stdin

A Readable stream over fd 0. It is an EventEmitter supporting the usual consumption modes — on('data') / on('end'), read(), and async iteration (for await (const chunk of process.stdin)). Reads are performed off-thread so they never block the event loop, and an unconsumed stdin does not keep the process alive. When attached to a terminal, isTTY is true.

process.emitWarning

process.env semantics

• First access: Elide reads the visible host environment names through dev.elide.cfg.HostEnvironment and installs each entry as a writable, configurable, enumerable own data property.
• Subsequent reads: return whatever is currently on the cached object — so guest mutations (process.env.FOO = "bar") are observable to later reads inside the same realm.
• Spawned children: Elide does not propagate guest mutations back to the OS environment. A future child_process.spawn will inherit the pre-mutation host environment unless the call passes an explicit env.

The visible name set is whatever the host layer chooses to expose. The default layer is a passthrough of the OS environment, matching Node. When Elide runs under a sandbox policy or a secrets provider, the host layer filters or overlays the values before they reach process.env — guest code cannot tell the difference between an "absent" name and a "denied" name, and cannot distinguish an OS-backed value from an Elide-managed secret.

process.exitCode

A mutable numeric slot. Setting it from inside the script changes the host process exit code at script termination:

if (failed) {
  process.exitCode = 1;
}

Limitations

• process.kill, process.send, process.disconnect, the child_process namespace, and process.binding are not implemented.
• process.versions exposes Elide's runtime version; the Node, V8, and OpenSSL sub-versions are best-effort surrogates.
• process.env cannot be reassigned wholesale (process.env = {...}); the binding is an own data property of process and individual entries remain writable.