perf(node): lazy stdio + fix LazyEsmModuleLoader source consumption (#34440)

Results


  Snapshot size: 9,407,439 → 8,521,932 bytes (−885 KB, −9.4%)

  Startup time (100 runs, hyperfine -N, after 20 warmups):

```  

┌─────────────────────────────────────────────────┬──────────────────────────┬───────────────┬───────────────┐
│                     Command                     │ baseline (main@upstream) │  ollzspzs/1   │     delta     │
├─────────────────────────────────────────────────┼──────────────────────────┼───────────────┼───────────────┤
│ deno eval 1                                     │ 22.6 ± 0.4 ms            │ 21.7 ± 1.6 ms │ −0.9 ms (−4%) │
├─────────────────────────────────────────────────┼──────────────────────────┼───────────────┼───────────────┤
│ deno run hello.mjs                              │ 21.9 ± 4.4 ms            │ 20.9 ± 0.9 ms │ −1.0 ms (−5%) │
├─────────────────────────────────────────────────┼──────────────────────────┼───────────────┼───────────────┤
│ deno run -A hello.cjs                           │ 23.1 ± 0.7 ms            │ 22.5 ± 2.4 ms │ −0.6 ms (−3%) │
├─────────────────────────────────────────────────┼──────────────────────────┼───────────────┼───────────────┤
│ deno run stdout.mjs (uses process.stdout.write) │ 22.0 ± 2.7 ms            │ 23.6 ± 1.0 ms │ +1.6 ms (+7%) │
└─────────────────────────────────────────────────┴──────────────────────────┴───────────────┴───────────────┘
```
The regression on the last row is the expected tradeoff: scripts that
actually touch process.stdout/stderr/stdin pay the deferred construction
cost on first
access. Net win for the common case (deno run of a script that doesn't
immediately touch Node stdio) and across-the-board snapshot win.

Author: nathanwhit

ext/node/lib.rs

@@ -429,21 +429,17 @@ deno_core::extension!(deno_node,
     "internal_binding/mod.ts",
     "node:module" = "01_require.js",
     "node:process" = "process.ts",
-    // node:stream + node:stream/promises stay eager: every Deno program
-    // pays their parse/compile cost at runtime startup via
-    // `__bootstrapNodeProcess` -> `createWritableStdioStream` -> Writable,
-    // so keeping them in the snapshot is a net startup-time win even
-    // though most programs never directly require('stream').
+  ],
+  lazy_loaded_esm = [
+    dir "polyfills",
+    // Previously eager. Combined with the lazy stdio refactor in
+    // process.ts (process.stdout/stderr/stdin are accessor properties),
+    // these modules only load when a script actually touches stdio or
+    // requires node:stream/net/tty directly.
     "node:stream" = "stream.ts",
     "node:stream/promises" = "stream/promises.js",
-    // node:net and node:tty are needed at every TTY-stdout startup via
-    // internal/tty.js's TTYWriteStream constructor extending net.Socket.
-    // Keeping them eager is a startup-time win for interactive runs.
     "node:net" = "net_esm.ts",
     "node:tty" = "tty_esm.ts",
-  ],
-  lazy_loaded_esm = [
-    dir "polyfills",
     "internal/streams/compose.js",
     "internal/streams/duplexpair.js",
     "internal/streams/lazy_transform.js",

ext/node/polyfills/01_require.js

@@ -88,21 +88,9 @@ const _httpAgent = core.createLazyLoader("node:_http_agent");
 const _httpCommon = core.createLazyLoader("node:_http_common");
 const _httpOutgoing = core.createLazyLoader("node:_http_outgoing");
 const _httpServer = core.createLazyLoader("node:_http_server");
-const _streamDuplex = core.loadExtScript(
-  "ext:deno_node/internal/streams/duplex.js",
-).default;
-const _streamPassthrough = core.loadExtScript(
-  "ext:deno_node/internal/streams/passthrough.js",
-).default;
-const _streamReadable = core.loadExtScript(
-  "ext:deno_node/internal/streams/readable.js",
-).default;
-const _streamTransform = core.loadExtScript(
-  "ext:deno_node/internal/streams/transform.js",
-).default;
-const _streamWritable = core.loadExtScript(
-  "ext:deno_node/internal/streams/writable.js",
-).default;
+// Heavy stream class definitions. Lazified - only loaded if a script
+// actually `require('_stream_*')` or pulls them transitively via
+// `node:stream` after our lazy stdio refactor.
 // _tls_common, _tls_wrap are lazy-loaded via `lazyNodeModules` below: their
 // scripts extend net.Socket at module body, which pulls node:net (and then
 // node:stream) into the snapshot.
@@ -146,10 +134,6 @@ const fs = core.loadExtScript("ext:deno_node/fs.ts");
 // http/http2/https are lazy-loaded via `lazyNodeModules` below: their script
 // bodies eagerly chain into the entire node:_http_* / node:net / node:stream
 // graph, so running them at snapshot time defeats lazifying _http_*.
-const inspector = core.loadExtScript("ext:deno_node/inspector.js");
-const inspectorPromises = core.loadExtScript(
-  "ext:deno_node/inspector/promises.js",
-);
 const internalAssertMyersDiff = core.loadExtScript(
   "ext:deno_node/internal/assert/myers_diff.js",
 );
@@ -249,17 +233,16 @@ const internalStreamsState =
 const internalSocketAddress = core.loadExtScript(
   "ext:deno_node/internal/socketaddress.js",
 );
-const internalJsStreamSocket = core.loadExtScript(
-  "ext:deno_node/internal/js_stream_socket.js",
-).default;
 const internalNet = core.loadExtScript("ext:deno_node/internal/net.ts");
 const internalTestBinding = core.loadExtScript(
   "ext:deno_node/internal/test/binding.ts",
 );
 const internalTimers = core.loadExtScript(
   "ext:deno_node/internal/timers.mjs",
 );
-import * as internalTty from "ext:deno_node/internal/tty.js";
+const lazyInternalTty = core.createLazyLoader(
+  "ext:deno_node/internal/tty.js",
+);
 const internalUrl = core.loadExtScript("ext:deno_node/internal/url.ts");
 const internalUtil = core.loadExtScript("ext:deno_node/internal/util.mjs");
 const internalUtilDebuglog = core.loadExtScript(
@@ -286,54 +269,31 @@ const internalWorkerJsTransferable = core.loadExtScript(
 const internalConsole = core.loadExtScript(
   "ext:deno_node/internal/console/constructor.mjs",
 ).default;
-// net stays eager: internal/tty.js's TTYWriteStream extends net.Socket
-// inside its constructor, and process bootstrap creates a TTYWriteStream
-// for stdout/stderr whenever they're TTYs (every interactive run).
-import net from "node:net";
+// net, path, stream, tty lazified - see lazyNodeModules below.
+const lazyNet = core.createLazyLoader("node:net");
 const os = core.loadExtScript("ext:deno_node/os.ts").default;
-import pathPosix from "node:path/posix";
-import pathWin32 from "node:path/win32";
-import path from "node:path";
-const perfHooks = core.loadExtScript("ext:deno_node/perf_hooks.js").default;
-const punycode = core.loadExtScript("ext:deno_node/punycode.ts").default;
+const lazyPathPosix = core.createLazyLoader("node:path/posix");
+const lazyPathWin32 = core.createLazyLoader("node:path/win32");
+const lazyPath = core.createLazyLoader("node:path");
 import process from "node:process";
-const querystring = core.loadExtScript("ext:deno_node/querystring.js").default;
 const readline = core.createLazyLoader("node:readline");
 const readlinePromises = core.createLazyLoader("node:readline/promises");
 const repl = core.createLazyLoader("node:repl");
 const internalRepl = core.createLazyLoader(
   "ext:deno_node/internal/repl.ts",
 );
-const sqlite = core.loadExtScript("ext:deno_node/sqlite.ts");
-// node:stream and node:stream/promises are eager (`esm` in lib.rs): every
-// program pays their cost at startup via `__bootstrapNodeProcess` building
-// `process.stdout`/`stderr` via `new Writable(...)`, so having them in the
-// snapshot is a startup-time win. Static imports here ensure they end up
-// in v8's evaluation graph.
-import stream from "node:stream";
+const lazyStream = core.createLazyLoader("node:stream");
 const streamConsumers = core.loadExtScript("ext:deno_node/stream/consumers.js");
-import streamPromises from "node:stream/promises";
-// stream/web pulls ext:deno_web/14_compression.js -> 06_streams (208 KB).
-// Only loaded when `require("node:stream/web")` happens.
-const stringDecoder =
-  core.loadExtScript("ext:deno_node/string_decoder.ts").default;
+const lazyStreamPromises = core.createLazyLoader("node:stream/promises");
 const test = core.loadExtScript("ext:deno_node/testing.ts").default;
 const timers = core.loadExtScript("ext:deno_node/timers.ts");
-const timersPromises = core.loadExtScript(
-  "ext:deno_node/timers/promises.ts",
-);
 const tls = core.createLazyLoader("node:tls");
-const traceEvents = core.loadExtScript("ext:deno_node/trace_events.ts").default;
-import tty from "node:tty";
+const lazyTty = core.createLazyLoader("node:tty");
 const url = core.loadExtScript("ext:deno_node/url.ts");
-const utilTypes = core.loadExtScript("ext:deno_node/internal/util/types.ts");
 const util = core.loadExtScript("ext:deno_node/util.ts");
-const v8 = core.loadExtScript("ext:deno_node/v8.ts");
-const vm = core.loadExtScript("ext:deno_node/vm.js").default;
 const workerThreads = core.loadExtScript(
   "ext:deno_node/worker_threads.ts",
 );
-const wasi = core.loadExtScript("ext:deno_node/wasi.ts").default;
 // zlib is lazy-loaded via `lazyNodeModules` below: zlib.js extends
 // `Transform` from `node:stream` at module body, so loading it eagerly
 // pulls the stream subtree into the snapshot.
@@ -390,6 +350,47 @@ const lazyNodeModules = {
   "internal/child_process": () =>
     core.loadExtScript("ext:deno_node/internal/child_process.ts").default,
   "stream/web": () => core.loadExtScript("ext:deno_node/stream/web.js"),
+  "inspector": () => core.loadExtScript("ext:deno_node/inspector.js"),
+  "inspector/promises": () =>
+    core.loadExtScript("ext:deno_node/inspector/promises.js"),
+  "perf_hooks": () => core.loadExtScript("ext:deno_node/perf_hooks.js").default,
+  "querystring": () =>
+    core.loadExtScript("ext:deno_node/querystring.js").default,
+  "sqlite": () => core.loadExtScript("ext:deno_node/sqlite.ts"),
+  "string_decoder": () =>
+    core.loadExtScript("ext:deno_node/string_decoder.ts").default,
+  "timers/promises": () =>
+    core.loadExtScript("ext:deno_node/timers/promises.ts"),
+  "trace_events": () =>
+    core.loadExtScript("ext:deno_node/trace_events.ts").default,
+  "util/types": () =>
+    core.loadExtScript("ext:deno_node/internal/util/types.ts"),
+  "v8": () => core.loadExtScript("ext:deno_node/v8.ts"),
+  "vm": () => core.loadExtScript("ext:deno_node/vm.js").default,
+  "wasi": () => core.loadExtScript("ext:deno_node/wasi.ts").default,
+  "punycode": () => core.loadExtScript("ext:deno_node/punycode.ts").default,
+  // Previously eager via static imports. Lazified together with the
+  // process.stdio lazy-getter refactor.
+  "net": () => lazyNet().default,
+  "path": () => lazyPath().default,
+  "path/posix": () => lazyPathPosix().default,
+  "path/win32": () => lazyPathWin32().default,
+  "stream": () => lazyStream().default,
+  "stream/promises": () => lazyStreamPromises().default,
+  "tty": () => lazyTty().default,
+  "internal/tty": () => lazyInternalTty(),
+  "internal/js_stream_socket": () =>
+    core.loadExtScript("ext:deno_node/internal/js_stream_socket.js").default,
+  "_stream_duplex": () =>
+    core.loadExtScript("ext:deno_node/internal/streams/duplex.js").default,
+  "_stream_passthrough": () =>
+    core.loadExtScript("ext:deno_node/internal/streams/passthrough.js").default,
+  "_stream_readable": () =>
+    core.loadExtScript("ext:deno_node/internal/streams/readable.js").default,
+  "_stream_transform": () =>
+    core.loadExtScript("ext:deno_node/internal/streams/transform.js").default,
+  "_stream_writable": () =>
+    core.loadExtScript("ext:deno_node/internal/streams/writable.js").default,
 };
 
 function defineLazyNativeModule(name, loader) {
@@ -414,11 +415,6 @@ function defineLazyNativeModule(name, loader) {
 // NOTE(bartlomieju): keep this list in sync with `ext/node/lib.rs`
 function setupBuiltinModules() {
   const nodeModules = {
-    "_stream_duplex": _streamDuplex,
-    "_stream_passthrough": _streamPassthrough,
-    "_stream_readable": _streamReadable,
-    "_stream_transform": _streamTransform,
-    "_stream_writable": _streamWritable,
     assert,
     "async_hooks": asyncHooks,
     buffer,
@@ -431,8 +427,6 @@ function setupBuiltinModules() {
     domain,
     events,
     fs,
-    inspector,
-    "inspector/promises": inspectorPromises,
     "internal/assert/myers_diff": internalAssertMyersDiff.default,
     "internal/async_hooks": internalAsyncHooks,
     "internal/console/constructor": internalConsole,
@@ -459,12 +453,10 @@ function setupBuiltinModules() {
     "internal/streams/add-abort-signal": internalStreamsAddAbortSignal,
     "internal/streams/state": internalStreamsState,
     "internal/socketaddress": internalSocketAddress,
-    "internal/js_stream_socket": internalJsStreamSocket,
     "internal/net": internalNet,
     "internal/options": internalOptions,
     "internal/test/binding": internalTestBinding,
     "internal/timers": internalTimers,
-    "internal/tty": internalTty,
     "internal/url": internalUrl,
     "internal/util/debuglog": internalUtilDebuglog.default,
     "internal/util/inspect": internalUtilInspect,
@@ -475,40 +467,14 @@ function setupBuiltinModules() {
     "internal/webstreams/util": internalWebstreamsUtil,
     "internal/worker/js_transferable": internalWorkerJsTransferable,
     module: Module,
-    net,
     os,
-    "path/posix": pathPosix,
-    "path/win32": pathWin32,
-    path,
-    perf_hooks: perfHooks,
     process,
-    get punycode() {
-      process.emitWarning(
-        "The `punycode` module is deprecated. Please use a userland " +
-          "alternative instead.",
-        "DeprecationWarning",
-        "DEP0040",
-      );
-      return punycode;
-    },
-    querystring,
-    sqlite,
-    stream,
     "stream/consumers": streamConsumers,
-    "stream/promises": streamPromises,
-    string_decoder: stringDecoder,
     sys: util,
     test,
     timers,
-    "timers/promises": timersPromises,
-    trace_events: traceEvents,
-    tty,
     url,
     util,
-    "util/types": utilTypes,
-    v8,
-    vm,
-    wasi,
     worker_threads: workerThreads,
   };
   // Match Node's schemelessBlockList: these modules can only be imported
@@ -2470,6 +2436,11 @@ deprecatedNativeModules._stream_writable = [
   "The _stream_writable module is deprecated. Use `node:stream` instead.",
   "DEP0193",
 ];
+deprecatedNativeModules.punycode = [
+  "The `punycode` module is deprecated. Please use a userland " +
+  "alternative instead.",
+  "DEP0040",
+];
 
 const emittedNativeModuleDeprecations = new SafeSet();
 function maybeEmitNativeModuleDeprecation(request) {