@volter/tabnode 0.2.14-volter.88

package/src/node-lib/sources.ts

@@ -0,0 +1,200 @@
+/**
+ * The vendored Node files, by the name Node's own `require` calls each one.
+ *
+ * Every file here is `nodejs/node` v22.18.0's, byte for byte. None is edited,
+ * ever: a bug in one is fixed by moving the file to a newer Node, and a thing
+ * one needs that the engine lacks is supplied by the binding or by a
+ * hand-bound internal, never by a change here. Vite's `?raw` reads each as
+ * text; `load.ts` evaluates it in the scope Node's `BuiltinModule` gives a
+ * builtin.
+ */
+import NET from './net.js?raw';
+import BUFFER from './buffer.js?raw';
+import INTERNAL_BUFFER from './internal/buffer.js?raw';
+import STREAM from './stream.js?raw';
+import STREAM_PROMISES from './stream/promises.js?raw';
+import STREAMS_ADD_ABORT_SIGNAL from './internal/streams/add-abort-signal.js?raw';
+import STREAMS_COMPOSE from './internal/streams/compose.js?raw';
+import STREAMS_DESTROY from './internal/streams/destroy.js?raw';
+import STREAMS_DUPLEX from './internal/streams/duplex.js?raw';
+import STREAMS_DUPLEXIFY from './internal/streams/duplexify.js?raw';
+import STREAMS_DUPLEXPAIR from './internal/streams/duplexpair.js?raw';
+import STREAMS_END_OF_STREAM from './internal/streams/end-of-stream.js?raw';
+import STREAMS_FROM from './internal/streams/from.js?raw';
+import STREAMS_LAZY_TRANSFORM from './internal/streams/lazy_transform.js?raw';
+import STREAMS_LEGACY from './internal/streams/legacy.js?raw';
+import STREAMS_OPERATORS from './internal/streams/operators.js?raw';
+import STREAMS_PASSTHROUGH from './internal/streams/passthrough.js?raw';
+import STREAMS_PIPELINE from './internal/streams/pipeline.js?raw';
+import STREAMS_READABLE from './internal/streams/readable.js?raw';
+import STREAMS_STATE from './internal/streams/state.js?raw';
+import STREAMS_TRANSFORM from './internal/streams/transform.js?raw';
+import STREAMS_UTILS from './internal/streams/utils.js?raw';
+import STREAMS_WRITABLE from './internal/streams/writable.js?raw';
+import CHILD_PROCESS from './child_process.js?raw';
+import INTERNAL_NET from './internal/net.js?raw';
+import INTERNAL_CHILD_PROCESS from './internal/child_process.js?raw';
+import INTERNAL_STREAM_BASE_COMMONS from './internal/stream_base_commons.js?raw';
+import INTERNAL_SOCKET_LIST from './internal/socket_list.js?raw';
+import INTERNAL_ERRORS from './internal/errors.js?raw';
+import INTERNAL_VALIDATORS from './internal/validators.js?raw';
+import INTERNAL_ABORT_LISTENER from './internal/events/abort_listener.js?raw';
+import INTERNAL_CHILD_PROCESS_SERIALIZATION from './internal/child_process/serialization.js?raw';
+import INTERNAL_MODULES_CUSTOMIZATION_HOOKS from './internal/modules/customization_hooks.js?raw';
+import EVENTS from './events.js?raw';
+import INTERNAL_CONSTANTS from './internal/constants.js?raw';
+import INTERNAL_MIME from './internal/mime.js?raw';
+import HTTP from './http.js?raw';
+import HTTPS from './https.js?raw';
+import HTTP_COMMON from './_http_common.js?raw';
+import HTTP_INCOMING from './_http_incoming.js?raw';
+import HTTP_OUTGOING from './_http_outgoing.js?raw';
+import HTTP_SERVER from './_http_server.js?raw';
+import HTTP_CLIENT from './_http_client.js?raw';
+import HTTP_AGENT from './_http_agent.js?raw';
+import INTERNAL_HTTP from './internal/http.js?raw';
+import INTERNAL_FREELIST from './internal/freelist.js?raw';
+import READLINE from './readline.js?raw';
+import READLINE_PROMISES from './readline/promises.js?raw';
+import INTERNAL_READLINE_CALLBACKS from './internal/readline/callbacks.js?raw';
+import INTERNAL_READLINE_EMITKEYPRESSEVENTS from './internal/readline/emitKeypressEvents.js?raw';
+import INTERNAL_READLINE_INTERFACE from './internal/readline/interface.js?raw';
+import INTERNAL_READLINE_PROMISES from './internal/readline/promises.js?raw';
+import INTERNAL_READLINE_UTILS from './internal/readline/utils.js?raw';
+import ZLIB from './zlib.js?raw';
+import OS from './os.js?raw';
+import TTY from './tty.js?raw';
+import INTERNAL_TTY from './internal/tty.js?raw';
+import ASSERT from './assert.js?raw';
+import ASSERT_STRICT from './assert/strict.js?raw';
+import QUERYSTRING from './querystring.js?raw';
+import PUNYCODE from './punycode.js?raw';
+import NODE_CONSTANTS from './constants.js?raw';
+import DIAGNOSTICS_CHANNEL from './diagnostics_channel.js?raw';
+import INTERNAL_QUERYSTRING from './internal/querystring.js?raw';
+import INTERNAL_ASSERTION_ERROR from './internal/assert/assertion_error.js?raw';
+import INTERNAL_CALLTRACKER from './internal/assert/calltracker.js?raw';
+import INTERNAL_ASSERT_UTILS from './internal/assert/utils.js?raw';
+import INTERNAL_MYERS_DIFF from './internal/assert/myers_diff.js?raw';
+import FS from './fs.js?raw';
+import INTERNAL_FS_UTILS from './internal/fs/utils.js?raw';
+import INTERNAL_FS_PROMISES from './internal/fs/promises.js?raw';
+import INTERNAL_FS_DIR from './internal/fs/dir.js?raw';
+import INTERNAL_FS_WATCHERS from './internal/fs/watchers.js?raw';
+import INTERNAL_FS_STREAMS from './internal/fs/streams.js?raw';
+import INTERNAL_FS_RIMRAF from './internal/fs/rimraf.js?raw';
+import INTERNAL_FS_SYNC_WRITE_STREAM from './internal/fs/sync_write_stream.js?raw';
+import INTERNAL_FS_RECURSIVE_WATCH from './internal/fs/recursive_watch.js?raw';
+import INTERNAL_FS_GLOB from './internal/fs/glob.js?raw';
+import INTERNAL_DEPS_MINIMATCH from './internal/deps/minimatch/index.js?raw';
+import INTERNAL_FS_READ_CONTEXT from './internal/fs/read/context.js?raw';
+import INTERNAL_FS_CP_CP_SYNC from './internal/fs/cp/cp-sync.js?raw';
+import INTERNAL_FS_CP_CP from './internal/fs/cp/cp.js?raw';
+import INTERNAL_PARSE_ARGS from './internal/util/parse_args/parse_args.js?raw';
+import INTERNAL_PARSE_ARGS_UTILS from './internal/util/parse_args/utils.js?raw';
+import UTIL from './util.js?raw';
+import INTERNAL_UTIL from './internal/util.js?raw';
+import INTERNAL_UTIL_INSPECT from './internal/util/inspect.js?raw';
+import INTERNAL_UTIL_COMPARISONS from './internal/util/comparisons.js?raw';
+import INTERNAL_UTIL_DEBUGLOG from './internal/util/debuglog.js?raw';
+import INTERNAL_UTIL_COLORS from './internal/util/colors.js?raw';
+import INTERNAL_FIXED_QUEUE from './internal/fixed_queue.js?raw';
+import INTERNAL_EVENTS_SYMBOLS from './internal/events/symbols.js?raw';
+
+/** The Node the vendored files come from, reported in `FORK.md`'s table. */
+export const NODE_LIB_VERSION = 'v22.18.0';
+
+export const NODE_LIB_SOURCES: Record<string, string> = {
+  'net': NET,
+  'buffer': BUFFER,
+  'internal/buffer': INTERNAL_BUFFER,
+  'stream': STREAM,
+  'stream/promises': STREAM_PROMISES,
+  'internal/streams/add-abort-signal': STREAMS_ADD_ABORT_SIGNAL,
+  'internal/streams/compose': STREAMS_COMPOSE,
+  'internal/streams/destroy': STREAMS_DESTROY,
+  'internal/streams/duplex': STREAMS_DUPLEX,
+  'internal/streams/duplexify': STREAMS_DUPLEXIFY,
+  'internal/streams/duplexpair': STREAMS_DUPLEXPAIR,
+  'internal/streams/end-of-stream': STREAMS_END_OF_STREAM,
+  'internal/streams/from': STREAMS_FROM,
+  'internal/streams/lazy_transform': STREAMS_LAZY_TRANSFORM,
+  'internal/streams/legacy': STREAMS_LEGACY,
+  'internal/streams/operators': STREAMS_OPERATORS,
+  'internal/streams/passthrough': STREAMS_PASSTHROUGH,
+  'internal/streams/pipeline': STREAMS_PIPELINE,
+  'internal/streams/readable': STREAMS_READABLE,
+  'internal/streams/state': STREAMS_STATE,
+  'internal/streams/transform': STREAMS_TRANSFORM,
+  'internal/streams/utils': STREAMS_UTILS,
+  'internal/streams/writable': STREAMS_WRITABLE,
+  'child_process': CHILD_PROCESS,
+  'internal/net': INTERNAL_NET,
+  'internal/child_process': INTERNAL_CHILD_PROCESS,
+  'internal/stream_base_commons': INTERNAL_STREAM_BASE_COMMONS,
+  'internal/socket_list': INTERNAL_SOCKET_LIST,
+  'internal/errors': INTERNAL_ERRORS,
+  'internal/validators': INTERNAL_VALIDATORS,
+  'internal/events/abort_listener': INTERNAL_ABORT_LISTENER,
+  'internal/child_process/serialization': INTERNAL_CHILD_PROCESS_SERIALIZATION,
+  'internal/modules/customization_hooks': INTERNAL_MODULES_CUSTOMIZATION_HOOKS,
+  'events': EVENTS,
+  'internal/constants': INTERNAL_CONSTANTS,
+  'internal/mime': INTERNAL_MIME,
+  'http': HTTP,
+  'https': HTTPS,
+  '_http_common': HTTP_COMMON,
+  '_http_incoming': HTTP_INCOMING,
+  '_http_outgoing': HTTP_OUTGOING,
+  '_http_server': HTTP_SERVER,
+  '_http_client': HTTP_CLIENT,
+  '_http_agent': HTTP_AGENT,
+  'internal/http': INTERNAL_HTTP,
+  'internal/freelist': INTERNAL_FREELIST,
+  'readline': READLINE,
+  'readline/promises': READLINE_PROMISES,
+  'internal/readline/callbacks': INTERNAL_READLINE_CALLBACKS,
+  'internal/readline/emitKeypressEvents': INTERNAL_READLINE_EMITKEYPRESSEVENTS,
+  'internal/readline/interface': INTERNAL_READLINE_INTERFACE,
+  'internal/readline/promises': INTERNAL_READLINE_PROMISES,
+  'internal/readline/utils': INTERNAL_READLINE_UTILS,
+  'zlib': ZLIB,
+  'os': OS,
+  'tty': TTY,
+  'internal/tty': INTERNAL_TTY,
+  'assert': ASSERT,
+  'assert/strict': ASSERT_STRICT,
+  'querystring': QUERYSTRING,
+  'punycode': PUNYCODE,
+  'constants': NODE_CONSTANTS,
+  'diagnostics_channel': DIAGNOSTICS_CHANNEL,
+  'internal/querystring': INTERNAL_QUERYSTRING,
+  'internal/assert/assertion_error': INTERNAL_ASSERTION_ERROR,
+  'internal/assert/calltracker': INTERNAL_CALLTRACKER,
+  'internal/assert/utils': INTERNAL_ASSERT_UTILS,
+  'internal/assert/myers_diff': INTERNAL_MYERS_DIFF,
+  'fs': FS,
+  'internal/fs/utils': INTERNAL_FS_UTILS,
+  'internal/fs/promises': INTERNAL_FS_PROMISES,
+  'internal/fs/dir': INTERNAL_FS_DIR,
+  'internal/fs/watchers': INTERNAL_FS_WATCHERS,
+  'internal/fs/streams': INTERNAL_FS_STREAMS,
+  'internal/fs/rimraf': INTERNAL_FS_RIMRAF,
+  'internal/fs/sync_write_stream': INTERNAL_FS_SYNC_WRITE_STREAM,
+  'internal/fs/recursive_watch': INTERNAL_FS_RECURSIVE_WATCH,
+  'internal/fs/glob': INTERNAL_FS_GLOB,
+  'internal/deps/minimatch/index': INTERNAL_DEPS_MINIMATCH,
+  'internal/fs/read/context': INTERNAL_FS_READ_CONTEXT,
+  'internal/fs/cp/cp-sync': INTERNAL_FS_CP_CP_SYNC,
+  'internal/fs/cp/cp': INTERNAL_FS_CP_CP,
+  'internal/util/parse_args/parse_args': INTERNAL_PARSE_ARGS,
+  'internal/util/parse_args/utils': INTERNAL_PARSE_ARGS_UTILS,
+  'util': UTIL,
+  'internal/util': INTERNAL_UTIL,
+  'internal/util/inspect': INTERNAL_UTIL_INSPECT,
+  'internal/util/comparisons': INTERNAL_UTIL_COMPARISONS,
+  'internal/util/debuglog': INTERNAL_UTIL_DEBUGLOG,
+  'internal/util/colors': INTERNAL_UTIL_COLORS,
+  'internal/fixed_queue': INTERNAL_FIXED_QUEUE,
+  'internal/events/symbols': INTERNAL_EVENTS_SYMBOLS,
+};

package/src/node-lib/stream/promises.js

@@ -0,0 +1,44 @@
+'use strict';
+
+const {
+  ArrayPrototypePop,
+  Promise,
+} = primordials;
+
+const {
+  isIterable,
+  isNodeStream,
+  isWebStream,
+} = require('internal/streams/utils');
+
+const { pipelineImpl: pl } = require('internal/streams/pipeline');
+const { finished } = require('internal/streams/end-of-stream');
+
+require('stream');
+
+function pipeline(...streams) {
+  return new Promise((resolve, reject) => {
+    let signal;
+    let end;
+    const lastArg = streams[streams.length - 1];
+    if (lastArg && typeof lastArg === 'object' &&
+        !isNodeStream(lastArg) && !isIterable(lastArg) && !isWebStream(lastArg)) {
+      const options = ArrayPrototypePop(streams);
+      signal = options.signal;
+      end = options.end;
+    }
+
+    pl(streams, (err, value) => {
+      if (err) {
+        reject(err);
+      } else {
+        resolve(value);
+      }
+    }, { signal, end });
+  });
+}
+
+module.exports = {
+  finished,
+  pipeline,
+};

package/src/node-lib/stream-module.ts

@@ -0,0 +1,101 @@
+/**
+ * `stream`, as Node's own `lib/stream.js`.
+ *
+ * What died: the engine's streams were hand-written, 2,281 lines inside
+ * `shims/stream.ts`, an imitation of `Readable`, `Writable`, `Duplex` and
+ * `Transform` that lane A had already had to patch so `net.js` could run on
+ * it. Node's own `test-stream-*`: 70 of 171 passed.
+ *
+ * What this is: Node's `lib/stream.js`, `lib/stream/promises.js` and all of
+ * `lib/internal/streams/*.js` v22.18.0, vendored unmodified. There is no
+ * binding underneath: Node's streams are pure JavaScript over `events`,
+ * `buffer` and `string_decoder`, which is why this module is only a loader.
+ *
+ * The rule for this file: it binds, it does not implement. A stream bug is
+ * fixed by moving the vendored files to a newer Node, never by editing them.
+ */
+import { lazyModule, lazyExport } from './lazy';
+
+/** Node's `stream` module object, as the engine's own parts read it. */
+export interface StreamModule {
+  Stream: new (options?: unknown) => unknown;
+  Readable: new (options?: unknown) => ReadableLike;
+  Writable: new (options?: unknown) => WritableLike;
+  Duplex: new (options?: unknown) => DuplexLike;
+  Transform: new (options?: unknown) => DuplexLike;
+  PassThrough: new (options?: unknown) => DuplexLike;
+  pipeline: (...args: unknown[]) => unknown;
+  finished: (...args: unknown[]) => unknown;
+  compose: (...args: unknown[]) => unknown;
+  addAbortSignal: (...args: unknown[]) => unknown;
+  duplexPair: (...args: unknown[]) => unknown;
+  promises: Record<string, unknown>;
+  isDisturbed: (stream: unknown) => boolean;
+  isErrored: (stream: unknown) => boolean;
+  isReadable: (stream: unknown) => boolean;
+  _isUint8Array: (value: unknown) => boolean;
+  _uint8ArrayToBuffer: (value: Uint8Array) => Uint8Array;
+}
+
+/** The shape the engine's own parts use a readable through. */
+export interface ReadableLike {
+  push(chunk: unknown, encoding?: string): boolean;
+  read(size?: number): string | Uint8Array | null;
+  pause(): this;
+  resume(): this;
+  destroy(error?: Error): this;
+  setEncoding(encoding: string): this;
+  pipe(destination: unknown, options?: unknown): unknown;
+  on(event: string, listener: (...args: never[]) => void): this;
+  once(event: string, listener: (...args: never[]) => void): this;
+  emit(event: string, ...args: unknown[]): boolean;
+  readable: boolean;
+  readableEnded: boolean;
+  destroyed: boolean;
+  isTTY?: boolean;
+  [key: string]: unknown;
+}
+
+/** The shape the engine's own parts use a writable through. */
+export interface WritableLike {
+  write(chunk: unknown, encoding?: unknown, callback?: unknown): boolean;
+  end(chunk?: unknown, encoding?: unknown, callback?: unknown): this;
+  destroy(error?: Error): this;
+  on(event: string, listener: (...args: never[]) => void): this;
+  once(event: string, listener: (...args: never[]) => void): this;
+  emit(event: string, ...args: unknown[]): boolean;
+  writable: boolean;
+  destroyed: boolean;
+  [key: string]: unknown;
+}
+
+export interface DuplexLike extends ReadableLike, WritableLike {}
+
+/** Node's own `stream.js`, built by the loader on the first property read. */
+export const streamModule = lazyModule<StreamModule>('stream');
+
+/**
+ * The classes, and the names the engine's own code uses as TYPES for them:
+ * a stream a shim holds is "a Readable", whatever Node's own class is.
+ */
+export type Readable = ReadableLike;
+export type Writable = WritableLike;
+export type Duplex = DuplexLike;
+export type Transform = DuplexLike;
+export type PassThrough = DuplexLike;
+
+export const Stream = lazyExport<StreamModule['Stream']>('stream', 'Stream');
+export const Readable = lazyExport<StreamModule['Readable']>('stream', 'Readable');
+export const Writable = lazyExport<StreamModule['Writable']>('stream', 'Writable');
+export const Duplex = lazyExport<StreamModule['Duplex']>('stream', 'Duplex');
+export const Transform = lazyExport<StreamModule['Transform']>('stream', 'Transform');
+export const PassThrough = lazyExport<StreamModule['PassThrough']>('stream', 'PassThrough');
+export const pipeline = lazyExport<StreamModule['pipeline']>('stream', 'pipeline');
+export const finished = lazyExport<StreamModule['finished']>('stream', 'finished');
+export const promises = lazyModule<Record<string, unknown>>('stream/promises');
+
+/** The promise form of `pipeline` and `finished`, as `stream/promises`. */
+export const streamPromisesModule = lazyModule<Record<string, unknown>>('stream/promises');
+
+/** Node's `stream` module object IS the `Stream` class, as `stream.js` exports it. */
+export default streamModule;

package/src/node-lib/stream.js

@@ -0,0 +1,152 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+
+const {
+  ObjectDefineProperty,
+  ObjectKeys,
+  ReflectApply,
+} = primordials;
+
+const {
+  promisify: { custom: customPromisify },
+} = require('internal/util');
+
+const {
+  streamReturningOperators,
+  promiseReturningOperators,
+} = require('internal/streams/operators');
+
+const {
+  codes: {
+    ERR_ILLEGAL_CONSTRUCTOR,
+  },
+} = require('internal/errors');
+const compose = require('internal/streams/compose');
+const { setDefaultHighWaterMark, getDefaultHighWaterMark } = require('internal/streams/state');
+const { pipeline } = require('internal/streams/pipeline');
+const { destroyer } = require('internal/streams/destroy');
+const eos = require('internal/streams/end-of-stream');
+const internalBuffer = require('internal/buffer');
+
+const promises = require('stream/promises');
+const utils = require('internal/streams/utils');
+const { isArrayBufferView, isUint8Array } = require('internal/util/types');
+
+const Stream = module.exports = require('internal/streams/legacy').Stream;
+
+Stream.isDestroyed = utils.isDestroyed;
+Stream.isDisturbed = utils.isDisturbed;
+Stream.isErrored = utils.isErrored;
+Stream.isReadable = utils.isReadable;
+Stream.isWritable = utils.isWritable;
+
+Stream.Readable = require('internal/streams/readable');
+const streamKeys = ObjectKeys(streamReturningOperators);
+for (let i = 0; i < streamKeys.length; i++) {
+  const key = streamKeys[i];
+  const op = streamReturningOperators[key];
+  function fn(...args) {
+    if (new.target) {
+      throw new ERR_ILLEGAL_CONSTRUCTOR();
+    }
+    return Stream.Readable.from(ReflectApply(op, this, args));
+  }
+  ObjectDefineProperty(fn, 'name', { __proto__: null, value: op.name });
+  ObjectDefineProperty(fn, 'length', { __proto__: null, value: op.length });
+  ObjectDefineProperty(Stream.Readable.prototype, key, {
+    __proto__: null,
+    value: fn,
+    enumerable: false,
+    configurable: true,
+    writable: true,
+  });
+}
+const promiseKeys = ObjectKeys(promiseReturningOperators);
+for (let i = 0; i < promiseKeys.length; i++) {
+  const key = promiseKeys[i];
+  const op = promiseReturningOperators[key];
+  function fn(...args) {
+    if (new.target) {
+      throw new ERR_ILLEGAL_CONSTRUCTOR();
+    }
+    return ReflectApply(op, this, args);
+  }
+  ObjectDefineProperty(fn, 'name', { __proto__: null, value: op.name });
+  ObjectDefineProperty(fn, 'length', { __proto__: null, value: op.length });
+  ObjectDefineProperty(Stream.Readable.prototype, key, {
+    __proto__: null,
+    value: fn,
+    enumerable: false,
+    configurable: true,
+    writable: true,
+  });
+}
+Stream.Writable = require('internal/streams/writable');
+Stream.Duplex = require('internal/streams/duplex');
+Stream.Transform = require('internal/streams/transform');
+Stream.PassThrough = require('internal/streams/passthrough');
+Stream.duplexPair = require('internal/streams/duplexpair');
+Stream.pipeline = pipeline;
+const { addAbortSignal } = require('internal/streams/add-abort-signal');
+Stream.addAbortSignal = addAbortSignal;
+Stream.finished = eos;
+Stream.destroy = destroyer;
+Stream.compose = compose;
+Stream.setDefaultHighWaterMark = setDefaultHighWaterMark;
+Stream.getDefaultHighWaterMark = getDefaultHighWaterMark;
+
+ObjectDefineProperty(Stream, 'promises', {
+  __proto__: null,
+  configurable: true,
+  enumerable: true,
+  get() {
+    return promises;
+  },
+});
+
+ObjectDefineProperty(pipeline, customPromisify, {
+  __proto__: null,
+  enumerable: true,
+  get() {
+    return promises.pipeline;
+  },
+});
+
+ObjectDefineProperty(eos, customPromisify, {
+  __proto__: null,
+  enumerable: true,
+  get() {
+    return promises.finished;
+  },
+});
+
+// Backwards-compat with node 0.4.x
+Stream.Stream = Stream;
+
+Stream._isArrayBufferView = isArrayBufferView;
+Stream._isUint8Array = isUint8Array;
+Stream._uint8ArrayToBuffer = function _uint8ArrayToBuffer(chunk) {
+  return new internalBuffer.FastBuffer(chunk.buffer,
+                                       chunk.byteOffset,
+                                       chunk.byteLength);
+};

package/src/node-lib/timers.ts

@@ -0,0 +1,33 @@
+/**
+ * Node's `Timeout`, over whatever the realm's timers answer.
+ *
+ * Node's timers answer an object -- `ref`, `unref`, `hasRef`, `refresh`, and a
+ * primitive conversion to the id -- and Node's own files rely on it:
+ * `lib/_http_server.js` writes `setInterval(...).unref()` the moment a server
+ * listens. A browser realm answers a number, so the object has to be built
+ * here. Two readers need the same one: a guest's global timers, counted
+ * against the run's loop in `src/runtime.ts`, and the `timers` module a
+ * vendored file requires, in `src/node-lib/public-modules.ts`. They must agree
+ * on the shape, because a timer made through one is cleared through the other.
+ *
+ * This file imports nothing, so both can read it.
+ */
+
+/** Node's `Timeout` over a browser's numeric id; anything else is already a handle. */
+export function nodeTimeout(id: unknown): unknown {
+  if (typeof id !== "number") return id;
+  const timeout = {
+    _id: id,
+    ref() { return timeout; },
+    unref() { return timeout; },
+    hasRef() { return true; },
+    refresh() { return timeout; },
+    [Symbol.toPrimitive]() { return id; },
+  };
+  return timeout;
+}
+
+/** The realm's own id inside a {@link nodeTimeout}, for the clear that takes one. */
+export function timerHandleOf(id: unknown): unknown {
+  return id && typeof id === "object" && "_id" in (id as object) ? (id as { _id: unknown })._id : id;
+}