@volter/tabnode 0.5.17 → 0.5.19

package/dist/node-lib/internals/amaro.d.ts

@@ -0,0 +1,31 @@
+/**
+ * `internal/deps/amaro/dist/index`: the type stripper Node carries.
+ *
+ * Node v22.18.0 runs a `.ts`, `.mts` or `.cts` file by erasing its types with
+ * amaro 1.1.0 (swc's stripper, built to WebAssembly), vendored under
+ * `deps/amaro`, and its own `lib/internal/modules/typescript.js` (vendored
+ * here unmodified) is what calls it. amaro is not native: it is JavaScript and
+ * WebAssembly, and this engine takes the same release as a dependency rather
+ * than writing a stripper of its own. esbuild, which the engine also carries,
+ * is not a substitute: it reprints the program (a stack's line and column move)
+ * and it transforms `enum`, `namespace` and parameter properties where Node, in
+ * strip-only mode, refuses them.
+ *
+ * amaro's glue loads its WebAssembly synchronously from bytes inlined in the
+ * package and reads `util` and `buffer`, so it is loaded through the host's own
+ * `require` where the host is Node. A browser realm has no such door: there the
+ * page supplies its stripper as `globalThis.__substrateStripTypes`, which the
+ * module loader asks first, and this answers absent.
+ */
+type AmaroTransform = (source: string, options: Record<string, unknown>) => {
+    code: string;
+    map?: string;
+};
+interface Amaro {
+    transformSync: AmaroTransform;
+}
+/** amaro, loaded once from beside this engine, or null where the realm cannot load it. */
+export declare function hostAmaro(): Amaro | null;
+/** The module Node's `typescript.js` requires; absent, the error Node raises when built without amaro. */
+export declare function internalAmaro(): Amaro;
+export {};

package/dist/node-lib/internals/runtime.d.ts

@@ -107,6 +107,7 @@ export declare const internalEventTarget: {
     kNewListener: symbol;
     kRemoveListener: symbol;
 };
+export declare function withOptionValues<T>(overrides: Record<string, unknown>, fn: () => T): T;
 export declare const internalOptions: {
     getOptionValue: (name: string) => unknown;
     getEmbedderOptions: () => {

package/dist/node-lib/node-versions.d.ts

@@ -23,4 +23,5 @@ export declare function nodeVersions(node?: string): {
     uv: string;
     webcontainer: string;
     openssl: string;
+    amaro: string;
 };

package/dist/node-lib/typescript-module.d.ts

@@ -0,0 +1,11 @@
+type RunProcess = {
+    execArgv?: readonly string[];
+    env?: Record<string, string | undefined>;
+};
+/** Whether this realm can erase types itself: amaro is loadable here. */
+export declare function canStripTypes(): boolean;
+/** Whether a process transforms TypeScript-only syntax rather than refusing it. */
+export declare function transformsTypes(process: RunProcess): boolean;
+/** The module's source with its types erased (or, under `--experimental-transform-types`, transformed), for this process. */
+export declare function stripModuleTypes(source: string, filename: string, process: object): string;
+export {};

package/dist/process-tokens.d.ts

@@ -96,6 +96,8 @@ export declare function runPid(token: ProcessToken | null | undefined): {
 } | undefined;
 /** A run that has ended is no longer a process; its number is nobody's. */
 export declare function forgetRunPid(token: ProcessToken): void;
+/** The named run a pid belongs to in this realm, for a signal sent by number (the shell's `kill`). */
+export declare function tokenOfPid(pid: number): ProcessToken | null;
 /** Whether a live run carries this number, which is what `kill(pid, 0)` asks. */
 export declare function pidIsLive(pid: number): boolean;
 /** `kill(pid, signal)` to another realm's live process; whether one took it. */

package/dist/shims/process.d.ts

@@ -177,6 +177,9 @@ export interface Process {
     send?: (message: unknown, callback?: (error: Error | null) => void) => boolean;
     connected?: boolean;
 }
+/** The signal numbers a guest sees, and the signals a tab must ignore. */
+export declare const __substrateSignals: Record<string, number>;
+export declare const __substrateSignalNames: Record<number, string>;
 /**
  * The guest's children are processes it can see. `process.kill(pid, 0)`
  * answered ESRCH for every pid but the guest's own, so a program that keeps its

package/dist/shims/shell-jobs.d.ts

@@ -0,0 +1,12 @@
+import type { Bash, CommandContext } from 'just-bash';
+import { type ProcessToken } from '../process-tokens';
+import type { RunStreams } from './child_process';
+/** What the engine's process model gives this module. */
+export interface ShellJobsHost {
+    runTokenOf(ctx: CommandContext): ProcessToken | null;
+    runStreamsFor(token: ProcessToken): RunStreams | undefined;
+    registerRunStreams(token: ProcessToken, streams: RunStreams): void;
+    releaseRunStreams(token: ProcessToken): void;
+}
+/** The engine's shell, given background jobs. */
+export declare function installShellJobs(bash: Bash, host: ShellJobsHost): void;

package/dist/shims/streamed-output.d.ts

@@ -0,0 +1,14 @@
+/**
+ * What of a command's collected output was not already streamed.
+ *
+ * The engine's shell collects a command line's output as one text at its end;
+ * a `node` in it (or a background job) also streams its own as it writes. A
+ * caller that forwarded the streamed pieces sends the rest at the end. Cutting
+ * the collected text at the streamed length assumed the streamed pieces came
+ * first: `echo "pid=1"; node -e "console.log('fg out')"; echo end`, spawned by
+ * a guest, reached it as `fg out\ng out\nend\n` -- the builtin's line lost and
+ * the node's half repeated. Each streamed piece is taken out where it stands in
+ * the collected text, in order, and what is left is the rest; a piece the text
+ * does not hold is passed over.
+ */
+export declare function unstreamedOutput(total: string, streamed: readonly string[]): string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@volter/tabnode",
-  "version": "0.5.17",
+  "version": "0.5.19",
   "description": "Node's own library, in a browser tab.",
   "type": "module",
   "license": "MIT",
@@ -53,6 +53,7 @@
   "dependencies": {
     "@noble/hashes": "2.3.0",
     "acorn": "^8.15.0",
+    "amaro": "1.1.0",
     "brotli": "^1.3.3",
     "brotli-wasm": "^3.0.1",
     "buffer": "6.0.3",

package/src/node-lib/internal/modules/typescript.js

@@ -0,0 +1,183 @@
+'use strict';
+
+const {
+  ObjectPrototypeHasOwnProperty,
+} = primordials;
+const {
+  validateBoolean,
+  validateOneOf,
+  validateObject,
+  validateString,
+} = require('internal/validators');
+const { assertTypeScript,
+        emitExperimentalWarning,
+        getLazy,
+        isUnderNodeModules,
+        kEmptyObject } = require('internal/util');
+const {
+  ERR_INVALID_TYPESCRIPT_SYNTAX,
+  ERR_UNSUPPORTED_NODE_MODULES_TYPE_STRIPPING,
+  ERR_UNSUPPORTED_TYPESCRIPT_SYNTAX,
+} = require('internal/errors').codes;
+const { getOptionValue } = require('internal/options');
+const assert = require('internal/assert');
+const { Buffer } = require('buffer');
+
+/**
+ * The TypeScript parsing mode, either 'strip-only' or 'transform'.
+ * @type {function(): TypeScriptMode}
+ */
+const getTypeScriptParsingMode = getLazy(() =>
+  (getOptionValue('--experimental-transform-types') ?
+    (emitExperimentalWarning('Transform Types'), 'transform') : 'strip-only'),
+);
+
+/**
+ * Load the TypeScript parser.
+ * and returns an object with a `code` property.
+ * @returns {Function} The TypeScript parser function.
+ */
+const loadTypeScriptParser = getLazy(() => {
+  assertTypeScript();
+  const amaro = require('internal/deps/amaro/dist/index');
+  return amaro.transformSync;
+});
+
+/**
+ *
+ * @param {string} source the source code
+ * @param {object} options the options to pass to the parser
+ * @returns {TransformOutput} an object with a `code` property.
+ */
+function parseTypeScript(source, options) {
+  const parse = loadTypeScriptParser();
+  try {
+    return parse(source, options);
+  } catch (error) {
+    /**
+     * Amaro v0.3.0 (from SWC v1.10.7) throws an object with `message` and `code` properties.
+     * It allows us to distinguish between invalid syntax and unsupported syntax.
+     */
+    switch (error?.code) {
+      case 'UnsupportedSyntax': {
+        const unsupportedSyntaxError = new ERR_UNSUPPORTED_TYPESCRIPT_SYNTAX(error.message);
+        throw decorateErrorWithSnippet(unsupportedSyntaxError, error); /* node-do-not-add-exception-line */
+      }
+      case 'InvalidSyntax': {
+        const invalidSyntaxError = new ERR_INVALID_TYPESCRIPT_SYNTAX(error.message);
+        throw decorateErrorWithSnippet(invalidSyntaxError, error); /* node-do-not-add-exception-line */
+      }
+      default:
+        // SWC may throw strings when something goes wrong.
+        if (typeof error === 'string') { assert.fail(error); }
+        assert(error != null && ObjectPrototypeHasOwnProperty(error, 'message'));
+        assert.fail(error.message);
+    }
+  }
+}
+
+/**
+ *
+ * @param {Error} error the error to decorate: ERR_INVALID_TYPESCRIPT_SYNTAX, ERR_UNSUPPORTED_TYPESCRIPT_SYNTAX
+ * @param {object} amaroError the error object from amaro
+ * @returns {Error} the decorated error
+ */
+function decorateErrorWithSnippet(error, amaroError) {
+  const errorHints = `${amaroError.filename}:${amaroError.startLine}\n${amaroError.snippet}`;
+  error.stack = `${errorHints}\n${error.stack}`;
+  return error;
+}
+
+/**
+ * Performs type-stripping to TypeScript source code.
+ * @param {string} code TypeScript code to parse.
+ * @param {TransformOptions} options The configuration for type stripping.
+ * @returns {string} The stripped TypeScript code.
+ */
+function stripTypeScriptTypes(code, options = kEmptyObject) {
+  emitExperimentalWarning('stripTypeScriptTypes');
+  validateString(code, 'code');
+  validateObject(options, 'options');
+
+  const {
+    sourceMap = false,
+    sourceUrl = '',
+  } = options;
+  let { mode = 'strip' } = options;
+  validateOneOf(mode, 'options.mode', ['strip', 'transform']);
+  validateBoolean(sourceMap, 'options.sourceMap');
+  validateString(sourceUrl, 'options.sourceUrl');
+  if (mode === 'strip') {
+    validateOneOf(sourceMap, 'options.sourceMap', [false, undefined]);
+    // Rename mode from 'strip' to 'strip-only'.
+    // The reason is to match `process.features.typescript` which returns `strip`,
+    // but the parser expects `strip-only`.
+    mode = 'strip-only';
+  }
+
+  return processTypeScriptCode(code, {
+    mode,
+    sourceMap,
+    filename: sourceUrl,
+  });
+}
+
+/**
+ * Processes TypeScript code by stripping types or transforming.
+ * Handles source maps if needed.
+ * @param {string} code TypeScript code to process.
+ * @param {object} options The configuration object.
+ * @returns {string} The processed code.
+ */
+function processTypeScriptCode(code, options) {
+  const { code: transformedCode, map } = parseTypeScript(code, options);
+
+  if (map) {
+    return addSourceMap(transformedCode, map);
+  }
+
+  if (options.filename) {
+    return `${transformedCode}\n\n//# sourceURL=${options.filename}`;
+  }
+
+  return transformedCode;
+}
+
+/**
+ * Performs type-stripping to TypeScript source code internally.
+ * It is used by internal loaders.
+ * @param {string} source TypeScript code to parse.
+ * @param {string} filename The filename of the source code.
+ * @returns {TransformOutput} The stripped TypeScript code.
+ */
+function stripTypeScriptModuleTypes(source, filename) {
+  assert(typeof source === 'string');
+  if (isUnderNodeModules(filename)) {
+    throw new ERR_UNSUPPORTED_NODE_MODULES_TYPE_STRIPPING(filename);
+  }
+  const options = {
+    mode: getTypeScriptParsingMode(),
+    sourceMap: getOptionValue('--enable-source-maps'),
+    filename,
+  };
+  return processTypeScriptCode(source, options);
+}
+
+/**
+ *
+ * @param {string} code The compiled code.
+ * @param {string} sourceMap The source map.
+ * @returns {string} The code with the source map attached.
+ */
+function addSourceMap(code, sourceMap) {
+  // The base64 encoding should be https://datatracker.ietf.org/doc/html/rfc4648#section-4,
+  // not base64url https://datatracker.ietf.org/doc/html/rfc4648#section-5. See data url
+  // spec https://tools.ietf.org/html/rfc2397#section-2.
+  const base64SourceMap = Buffer.from(sourceMap).toString('base64');
+  return `${code}\n\n//# sourceMappingURL=data:application/json;base64,${base64SourceMap}`;
+}
+
+module.exports = {
+  stripTypeScriptModuleTypes,
+  stripTypeScriptTypes,
+};

package/src/node-lib/internals/amaro.ts

@@ -0,0 +1,51 @@
+/**
+ * `internal/deps/amaro/dist/index`: the type stripper Node carries.
+ *
+ * Node v22.18.0 runs a `.ts`, `.mts` or `.cts` file by erasing its types with
+ * amaro 1.1.0 (swc's stripper, built to WebAssembly), vendored under
+ * `deps/amaro`, and its own `lib/internal/modules/typescript.js` (vendored
+ * here unmodified) is what calls it. amaro is not native: it is JavaScript and
+ * WebAssembly, and this engine takes the same release as a dependency rather
+ * than writing a stripper of its own. esbuild, which the engine also carries,
+ * is not a substitute: it reprints the program (a stack's line and column move)
+ * and it transforms `enum`, `namespace` and parameter properties where Node, in
+ * strip-only mode, refuses them.
+ *
+ * amaro's glue loads its WebAssembly synchronously from bytes inlined in the
+ * package and reads `util` and `buffer`, so it is loaded through the host's own
+ * `require` where the host is Node. A browser realm has no such door: there the
+ * page supplies its stripper as `globalThis.__substrateStripTypes`, which the
+ * module loader asks first, and this answers absent.
+ */
+type AmaroTransform = (source: string, options: Record<string, unknown>) => { code: string; map?: string };
+interface Amaro { transformSync: AmaroTransform }
+
+/** The host's `process`, taken before a guest's takes the global name. */
+const hostProcess = typeof process !== 'undefined' && process !== null
+  ? (process as unknown as { getBuiltinModule?: (name: string) => unknown })
+  : null;
+
+let loaded: Amaro | null | undefined;
+
+/** amaro, loaded once from beside this engine, or null where the realm cannot load it. */
+export function hostAmaro(): Amaro | null {
+  if (loaded !== undefined) return loaded;
+  loaded = null;
+  try {
+    const moduleBuiltin = typeof hostProcess?.getBuiltinModule === 'function'
+      ? hostProcess.getBuiltinModule('module') as { createRequire?: (from: string) => (id: string) => unknown } | undefined
+      : undefined;
+    if (moduleBuiltin && typeof moduleBuiltin.createRequire === 'function') {
+      const amaro = moduleBuiltin.createRequire(import.meta.url)('amaro') as Amaro;
+      if (typeof amaro?.transformSync === 'function') loaded = amaro;
+    }
+  } catch { /* no host require, or amaro not installed beside the engine */ }
+  return loaded;
+}
+
+/** The module Node's `typescript.js` requires; absent, the error Node raises when built without amaro. */
+export function internalAmaro(): Amaro {
+  const amaro = hostAmaro();
+  if (amaro) return amaro;
+  throw Object.assign(new Error('Node.js is not compiled with TypeScript support'), { code: 'ERR_NO_TYPESCRIPT' });
+}

package/src/node-lib/internals/index.ts

@@ -26,6 +26,7 @@ import {
   internalAbortController, internalBlob, internalFile, internalWebStreamsAdapters, createWebStreamsAdapters,
 } from './buffer-and-streams';
 import { internalBootstrapRealm, internalUrl, internalEncoding } from './modules';
+import { internalAmaro } from './amaro';
 
 /** Built on the first ask, for the reason `./binding/index.ts` gives. */
 // eslint-disable-next-line no-var, vars-on-top
@@ -69,6 +70,7 @@ export function nodeLibInternal(name: string, require?: (name: string) => any, p
   'internal/process/warning': () => internalProcessWarning,
   'internal/source_map/source_map_cache': () => internalSourceMapCache,
   'internal/deps/undici/undici': () => internalUndici,
+  'internal/deps/amaro/dist/index': () => internalAmaro(),
   'internal/readline/interface': () => internalReadlineInterface,
   'internal/worker/js_transferable': () => internalJsTransferable,
 };;

package/src/node-lib/internals/runtime.ts

@@ -235,10 +235,25 @@ const optionValues: Record<string, unknown> = {
   '--max-http-header-size': 16 * 1024,
   '--insecure-http-parser': false,
   '--enable-source-maps': false,
+  '--experimental-transform-types': false,
 };
 
+/**
+ * Options one run was started with, answered only while a call made for that
+ * run is on the stack. Node reads an option of its own process; the engine
+ * holds many processes in one realm, so a caller that knows whose call it is
+ * (the module loader stripping a `.ts` file for a run started with
+ * `--experimental-transform-types`) says so for the length of that call.
+ */
+let optionOverrides: Record<string, unknown> | null = null;
+export function withOptionValues<T>(overrides: Record<string, unknown>, fn: () => T): T {
+  const previous = optionOverrides;
+  optionOverrides = { ...(previous ?? {}), ...overrides };
+  try { return fn(); } finally { optionOverrides = previous; }
+}
+
 export const internalOptions = {
-  getOptionValue: (name: string): unknown => optionValues[name],
+  getOptionValue: (name: string): unknown => (optionOverrides !== null && name in optionOverrides ? optionOverrides[name] : optionValues[name]),
   getEmbedderOptions: () => ({ shouldNotRegisterESMLoader: false, noGlobalSearchPaths: false, noBrowserGlobals: false }),
 };
 

package/src/node-lib/node-versions.ts

@@ -25,10 +25,13 @@ export function nodeVersions(node: string = NODE_LTS_VERSION): {
   uv: string;
   webcontainer: string;
   openssl: string;
+  amaro: string;
 } {
   // `https.js` calls `assertCrypto()`, which is `!process.versions.openssl`.
   // The engine has crypto (the noble-hashes binding); Node reports openssl
   // whenever it does. A worker compiles `internal/util` against this table
   // before any guest process exists, so the name has to live here.
-  return { node, v8: "11.3.244.8", uv: "1.44.2", webcontainer: "1", openssl: "3.0.15" };
+  // `amaro` is the type stripper a `.ts` file runs through, the release Node
+  // v22.18.0 carries; `internal/util` reads it for `assertTypeScript()`.
+  return { node, v8: "11.3.244.8", uv: "1.44.2", webcontainer: "1", openssl: "3.0.15", amaro: "1.1.0" };
 }

package/src/node-lib/sources.ts

@@ -43,6 +43,7 @@ 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 INTERNAL_MODULES_TYPESCRIPT from './internal/modules/typescript.js?raw';
 import EVENTS from './events.js?raw';
 import INTERNAL_CONSTANTS from './internal/constants.js?raw';
 import INTERNAL_MIME from './internal/mime.js?raw';
@@ -142,6 +143,7 @@ export const NODE_LIB_SOURCES: Record<string, string> = {
   'internal/events/abort_listener': INTERNAL_ABORT_LISTENER,
   'internal/child_process/serialization': INTERNAL_CHILD_PROCESS_SERIALIZATION,
   'internal/modules/customization_hooks': INTERNAL_MODULES_CUSTOMIZATION_HOOKS,
+  'internal/modules/typescript': INTERNAL_MODULES_TYPESCRIPT,
   'events': EVENTS,
   'internal/constants': INTERNAL_CONSTANTS,
   'internal/mime': INTERNAL_MIME,

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

@@ -0,0 +1,50 @@
+/**
+ * A `.ts`, `.mts` or `.cts` module's types erased the way Node's loader erases
+ * them: `Module.prototype._compile` hands the source to
+ * `stripTypeScriptModuleTypes` of Node's own `internal/modules/typescript.js`
+ * (vendored, unmodified), which runs amaro in strip-only mode -- types become
+ * whitespace, so every line and column stays where the file has it -- refuses
+ * `enum`, `namespace` with values, parameter properties and the rest with
+ * `ERR_UNSUPPORTED_TYPESCRIPT_SYNTAX`, and refuses any file under
+ * `node_modules` with `ERR_UNSUPPORTED_NODE_MODULES_TYPE_STRIPPING`.
+ *
+ * The file is the process's own, from the process's builtin graph: Node reads
+ * `--experimental-transform-types` once per process (`getLazy`) and emits its
+ * experimental warning on that process, which `--no-warnings` silences. The
+ * options a run was started with are answered for the length of the call;
+ * `--experimental-transform-types` implies `--enable-source-maps`, as Node's
+ * option table says.
+ */
+import { loadNodeLibFor } from './load';
+import { withOptionValues } from './internals/runtime';
+import { hostAmaro } from './internals/amaro';
+
+interface TypeScriptModule { stripTypeScriptModuleTypes(source: string, filename: string): string }
+type RunProcess = { execArgv?: readonly string[]; env?: Record<string, string | undefined> };
+
+/** Whether this realm can erase types itself: amaro is loadable here. */
+export function canStripTypes(): boolean {
+  return hostAmaro() !== null;
+}
+
+/** Whether a process was started with an option, on its command line or in `NODE_OPTIONS` (both options here are allowed there). */
+function startedWith(process: RunProcess, option: string): boolean {
+  if (Array.isArray(process.execArgv) && process.execArgv.includes(option)) return true;
+  const nodeOptions = process.env?.NODE_OPTIONS;
+  return typeof nodeOptions === 'string' && nodeOptions.split(/\s+/u).includes(option);
+}
+
+/** Whether a process transforms TypeScript-only syntax rather than refusing it. */
+export function transformsTypes(process: RunProcess): boolean {
+  return startedWith(process, '--experimental-transform-types');
+}
+
+/** The module's source with its types erased (or, under `--experimental-transform-types`, transformed), for this process. */
+export function stripModuleTypes(source: string, filename: string, process: object): string {
+  const typescript = loadNodeLibFor(process, 'internal/modules/typescript') as TypeScriptModule;
+  const transform = transformsTypes(process as RunProcess);
+  return withOptionValues({
+    '--experimental-transform-types': transform,
+    '--enable-source-maps': transform || startedWith(process as RunProcess, '--enable-source-maps'),
+  }, () => typescript.stripTypeScriptModuleTypes(source, filename));
+}

package/src/process-tokens.ts

@@ -237,6 +237,12 @@ export function forgetRunPid(token: ProcessToken): void {
   pidsOfRuns.delete(token);
 }
 
+/** The named run a pid belongs to in this realm, for a signal sent by number (the shell's `kill`). */
+export function tokenOfPid(pid: number): ProcessToken | null {
+  for (const [token, numbers] of pidsOfRuns) if (numbers.pid === pid) return token;
+  return null;
+}
+
 /** Whether a live run carries this number, which is what `kill(pid, 0)` asks. */
 export function pidIsLive(pid: number): boolean {
   return processRegistry.lookup(pid) !== undefined;

package/src/runtime.ts

@@ -68,6 +68,7 @@ import { createWasiModule, type WasiHostFs, type WasiModule } from './shims/wasi
 import { resolve as resolveExports, imports as resolveImports } from 'resolve.exports';
 import { transformEsmToCjsSimple, setNodeLowering, __cjsExports, __cjsObject, __substrateHasEsmSyntax } from './code-transforms';
 import { applySourceEdits } from './source-edits';
+import { canStripTypes, stripModuleTypes, transformsTypes } from './node-lib/typescript-module';
 import * as acorn from 'acorn';
 
 /**
@@ -114,6 +115,31 @@ function __substrateGuestConstructor(Constructor: unknown, process: Process): un
     return __substrateFunctionScope(__substrateGuestGlobal(process), String(compiled));
   } });
 }
+/**
+ * A `.ts`, `.mts` or `.cts` file runs with its types stripped, as Node runs
+ * one since 22.18, before the module's imports are read -- the entry a `node`
+ * command names and every module it loads alike. A page that loaded a
+ * stripper into the realm supplies it; elsewhere the engine erases the types
+ * itself, through Node's own `typescript.js` over amaro
+ * (`node-lib/typescript-module.ts`): strip-only, positions kept, the syntax
+ * Node refuses refused with Node's error. Before this, a realm with no stripper
+ * registered -- the engine under Node -- ran the file as JavaScript and died on
+ * its first type (`Unexpected identifier 'SlackReply'`), and an entry was never
+ * stripped anywhere. A realm that can load neither runs the file as it is.
+ *
+ * `format` is what a load hook named, and it decides instead of the extension
+ * where a hook gave one.
+ */
+function __substrateModuleTypes(code: string, resolvedPath: string, format: string | undefined, process: unknown): string {
+  const typescript = format === undefined
+    ? /[.](?:ts|mts|cts)$/u.test(resolvedPath) && !resolvedPath.endsWith('.d.ts')
+    : format === 'typescript' || format === 'commonjs-typescript' || format === 'module-typescript';
+  if (!typescript) return code;
+  const registered = (globalThis as { __substrateStripTypes?: (code: string, filename: string) => string }).__substrateStripTypes;
+  if (typeof registered === 'function') return registered(code, resolvedPath);
+  if (!canStripTypes()) return code;
+  return stripModuleTypes(code, resolvedPath, process as object);
+}
 /**
  * The name the script of a module's body carries.
  *
@@ -794,9 +820,14 @@ function __substratePackageIdentity(vfs: VirtualFS, file: string): string | unde
 }
 
 function __webStreamsModule(): Record<string, unknown> {
+  // Read when used, not when the engine loads: the engine later wraps the
+  // global ReadableStream (Node's closed-promise tracking), and a copy taken
+  // here was the unwrapped one, so require('stream/web').ReadableStream was
+  // not globalThis.ReadableStream, as it is in Node.
   const module: Record<string, unknown> = {};
   for (const name of ["ReadableStream", "ReadableStreamDefaultReader", "ReadableStreamBYOBReader", "ReadableStreamBYOBRequest", "ReadableByteStreamController", "ReadableStreamDefaultController", "TransformStream", "TransformStreamDefaultController", "WritableStream", "WritableStreamDefaultWriter", "WritableStreamDefaultController", "ByteLengthQueuingStrategy", "CountQueuingStrategy", "TextEncoderStream", "TextDecoderStream", "CompressionStream", "DecompressionStream"]) {
-    if (typeof (globalThis as Record<string, unknown>)[name] !== "undefined") module[name] = (globalThis as Record<string, unknown>)[name];
+    if (typeof (globalThis as Record<string, unknown>)[name] === "undefined") continue;
+    Object.defineProperty(module, name, { enumerable: true, configurable: true, get: () => (globalThis as Record<string, unknown>)[name] });
   }
   return module;
 }
@@ -1775,7 +1806,7 @@ function createRequire(
   const prepareModuleCode = (rawCode: string, resolvedPath: string, format?: string): string => {
     // Check processed code cache (useful for HMR when module cache is cleared but code hasn't changed)
     // Use a simple hash of the content for cache key to handle content changes
-    const codeCacheKey = `${resolvedPath}|${format ?? ''}|${simpleHash(rawCode)}`;
+    const codeCacheKey = `${resolvedPath}|${format ?? ''}|${transformsTypes(process as { execArgv?: string[]; env?: Record<string, string> }) ? 'transform-types|' : ''}${simpleHash(rawCode)}`;
     let code = processedCodeCache?.get(codeCacheKey);
 
     if (!code) {
@@ -1786,16 +1817,7 @@ function createRequire(
         code = code.slice(code.indexOf('\n') + 1);
       }
 
-      // A `.ts`, `.mts` or `.cts` file runs with its types stripped, as Node
-      // runs one since 22.18: the source goes to the type stripper the realm
-      // loaded, amaro, before the module's imports are read. A realm without one
-      // runs the file as it is.
-      const __typescript = format === undefined
-        ? /[.](?:ts|mts|cts)$/u.test(resolvedPath) && !resolvedPath.endsWith('.d.ts')
-        : format === 'typescript' || format === 'commonjs-typescript' || format === 'module-typescript';
-      if (__typescript && typeof (globalThis as any).__substrateStripTypes === 'function') {
-        code = (globalThis as any).__substrateStripTypes(code, resolvedPath) as string;
-      }
+      code = __substrateModuleTypes(code, resolvedPath, format, process);
 
       // Transform ESM to CJS if needed (for .mjs files or ESM that wasn't pre-transformed)
       // transformEsmToCjs uses AST to handle import/export, import.meta, and dynamic imports
@@ -1804,12 +1826,15 @@ function createRequire(
         ? true
         : format === 'module' || format === 'module-typescript'
           ? false
-          : resolvedPath.endsWith('.cjs');
+          : resolvedPath.endsWith('.cjs') || resolvedPath.endsWith('.cts');
       if (!__commonjs) {
         // An ES module is strict wherever it runs; the mark says so to the
         // compile below, which is otherwise sloppy as a CommonJS body is.
+        // The directive shares the body's first line, as Node's one-line
+        // wrapper does, so a frame of an ES module counts the file's own lines;
+        // on a line of its own it put every frame one line below the file's.
         const lowered = transformEsmToCjs(code, resolvedPath);
-        code = lowered === code ? code : `${__substrateModuleMarker}"use strict";\n${lowered}`;
+        code = lowered === code ? code : `${__substrateModuleMarker}"use strict";${lowered}`;
       } else {
         // A `.cjs` module skips the ESM transform, and with it the rewrite of
         // `import(...)` to the engine's dynamic import, so its
@@ -2374,10 +2399,13 @@ export class Runtime {
       code = code.slice(code.indexOf('\n') + 1);
     }
 
+    code = __substrateModuleTypes(code, filename, undefined, this.process);
+
     // Transform ESM to CJS if needed (AST-based, handles import.meta and dynamic imports too)
-    if (!filename.endsWith('.cjs')) {
+    if (!filename.endsWith('.cjs') && !filename.endsWith('.cts')) {
       const lowered = transformEsmToCjs(code, filename);
-      code = lowered === code ? code : `${__substrateModuleMarker}"use strict";\n${lowered}`;
+      // The directive shares the body's first line, as `prepareModuleCode`'s does.
+      code = lowered === code ? code : `${__substrateModuleMarker}"use strict";${lowered}`;
     } else {
       // A `.cjs` module skips the ESM transform, and with it the rewrite of
       // `import(...)` to the engine's dynamic import, so its