@volter/tabnode 0.5.16 → 0.5.18

package/dist/node-lib/binding/zlib.d.ts

@@ -25,10 +25,23 @@ export declare class Zlib {
     /** Node asks a handle for these two after a `Z_STREAM_END`. */
     get ended(): boolean;
 }
+declare class BrotliDecoderHandle {
+    #private;
+    readonly mode: number;
+    onerror: ((message: string, errno: number, code?: string) => void) | null;
+    constructor(mode: number);
+    init(_params: Uint32Array, writeState: Uint32Array, processCallback: ProcessCallback): boolean;
+    write(flush: number, inBuf: Uint8Array | null, inOff: number, inLen: number, outBuf: Uint8Array, outOff: number, outLen: number): this;
+    writeSync(flush: number, inBuf: Uint8Array | null, inOff: number, inLen: number, outBuf: Uint8Array, outOff: number, outLen: number): this;
+    params(): void;
+    reset(): void;
+    close(): void;
+    getAvailableOutput(): number;
+}
 export declare const zlibBinding: {
     Zlib: typeof Zlib;
     BrotliEncoder: new (...args: unknown[]) => never;
-    BrotliDecoder: new (...args: unknown[]) => never;
+    BrotliDecoder: typeof BrotliDecoderHandle;
     ZstdCompress: new (...args: unknown[]) => never;
     ZstdDecompress: new (...args: unknown[]) => never;
     /** `zlib.crc32`, which is zlib's own table-driven one. */

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/perf_hooks.d.ts

@@ -1,7 +1,3 @@
-/**
- * perf_hooks shim - Performance measurement APIs
- * Wraps browser Performance API
- */
 export declare const performance: Performance;
 export declare class PerformanceObserver {
     private callback;

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/dist/shims/tls.d.ts

@@ -291,6 +291,7 @@ export declare function createTlsModule(require?: (name: string) => any): {
     };
     createSecureContext: (_options?: unknown) => {};
     getCiphers: () => string[];
+    getCACertificates: (type?: string) => string[];
     DEFAULT_ECDH_CURVE: string;
     DEFAULT_MAX_VERSION: string;
     DEFAULT_MIN_VERSION: string;
@@ -583,6 +584,7 @@ declare const tls: {
     };
     createSecureContext: (_options?: unknown) => {};
     getCiphers: () => string[];
+    getCACertificates: (type?: string) => string[];
     DEFAULT_ECDH_CURVE: string;
     DEFAULT_MAX_VERSION: string;
     DEFAULT_MIN_VERSION: string;
@@ -868,7 +870,7 @@ export declare const TLSSocket: {
     write(chunk: unknown, encoding?: unknown, callback?: unknown): boolean;
     end(chunk?: unknown, encoding?: unknown, callback?: unknown): /*elided*/ any;
     writable: boolean;
-}, createSecureContext: (_options?: unknown) => {}, getCiphers: () => string[], DEFAULT_ECDH_CURVE: string, DEFAULT_MAX_VERSION: string, DEFAULT_MIN_VERSION: string, rootCertificates: string[];
+}, createSecureContext: (_options?: unknown) => {}, getCiphers: () => string[], getCACertificates: (type?: string) => string[], DEFAULT_ECDH_CURVE: string, DEFAULT_MAX_VERSION: string, DEFAULT_MIN_VERSION: string, rootCertificates: string[];
 export type TLSSocket = InstanceType<typeof TLSSocket>;
 export type Server = InstanceType<typeof Server>;
 export default tls;

package/dist/shims/worker_threads.d.ts

@@ -44,6 +44,8 @@ export declare function receiveMessageOnPort(port: MessagePort): {
 } | undefined;
 export declare const SHARE_ENV: unique symbol;
 export declare function markAsUntransferable(object: unknown): void;
+export declare function markAsUncloneable(object: unknown): void;
+export declare function isMarkedAsUncloneable(object: unknown): boolean;
 export declare function getEnvironmentData(key: unknown): unknown;
 export declare function setEnvironmentData(key: unknown, value: unknown): void;
 declare const _default: {
@@ -59,6 +61,8 @@ declare const _default: {
     receiveMessageOnPort: typeof receiveMessageOnPort;
     SHARE_ENV: symbol;
     markAsUntransferable: typeof markAsUntransferable;
+    markAsUncloneable: typeof markAsUncloneable;
+    isMarkedAsUncloneable: typeof isMarkedAsUncloneable;
     getEnvironmentData: typeof getEnvironmentData;
     setEnvironmentData: typeof setEnvironmentData;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@volter/tabnode",
-  "version": "0.5.16",
+  "version": "0.5.18",
   "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/code-transforms.ts

@@ -26,6 +26,14 @@ let __nodeLowering = false;
 const __cjsExports = () => __nodeLowering ? "$exports" : "exports";
 const __cjsModule = () => __nodeLowering ? "$module" : "module";
 const __cjsRequire = () => __nodeLowering ? "$require" : "require";
+// The realm's own `Object` and `Symbol`, by names a module cannot declare over.
+// Lowered code calls them before the module's own body has run -- its exports
+// are defined at the top -- and a module that imports a binding called `Object`
+// (typebox does, its object type) had the lowering's `Object.defineProperty`
+// read that import in its dead zone. The dev server's lowering of a browser
+// module keeps the plain names, which exist where that module runs.
+const __cjsObject = () => __nodeLowering ? "__browserRuntimeObject" : "Object";
+const __cjsSymbol = () => __nodeLowering ? "__browserRuntimeSymbol" : "Symbol";
 const __cjsDefault = (expression: string) => __nodeLowering ? "__browserRuntimeInteropDefault(" + expression + ")" : expression;
 // The helper lowered code calls by bare name. It is a name on the realm, so
 // it goes up when a guest first exists, not when this module is loaded.
@@ -33,8 +41,12 @@ forGuestRealm(() => {
   if ((globalThis as Record<string, unknown>).__browserRuntimeInteropDefault) return;
   takeFromHost(globalThis, '__browserRuntimeInteropDefault', (imported: any) => imported && imported.__esModule && "default" in imported ? imported.default : imported);
 });
+forGuestRealm(() => {
+  if (!(globalThis as Record<string, unknown>).__browserRuntimeObject) takeFromHost(globalThis, '__browserRuntimeObject', Object);
+  if (!(globalThis as Record<string, unknown>).__browserRuntimeSymbol) takeFromHost(globalThis, '__browserRuntimeSymbol', Symbol);
+});
 export const setNodeLowering = (value: boolean): void => { __nodeLowering = value; };
-export { __cjsExports };
+export { __cjsExports, __cjsObject };
 
 /**
  * Whether a module is ESM is a fact of its syntax, not of its text. Asking
@@ -175,7 +187,7 @@ function __substrateLiveImportBindings(code: any) {
       // or in what it imports; an importer waits for it, as a module graph
       // evaluates in order. The marker becomes `await` when the loader runs
       // this body as an async function, and reads nothing otherwise.
-      parts.push("/*__substrate_await__*/(" + namespace + " && " + namespace + "[Symbol.for(\"substrate.pending\")]);");
+      parts.push("/*__substrate_await__*/(" + namespace + " && " + namespace + "[" + __cjsSymbol() + ".for(\"substrate.pending\")]);");
     }
     for (const imported of declaration.specifiers) {
       const read = imported.type === "ImportDefaultSpecifier" ? __cjsDefault(namespace)
@@ -210,7 +222,10 @@ function __substrateLiveImportBindings(code: any) {
     if (typeof node.type !== "string") return;
     switch (node.type) {
       case "ImportDeclaration": case "ImportSpecifier": case "ImportDefaultSpecifier":
-      case "ImportNamespaceSpecifier": case "ExportSpecifier": case "MetaProperty":
+      // `export * as X from "…"` holds a name and a source, no reference: an
+      // imported binding also called X was rewritten into the exported name,
+      // and typebox's `export * as Guard` became `__substrateImport1`.
+      case "ImportNamespaceSpecifier": case "ExportSpecifier": case "ExportAllDeclaration": case "MetaProperty":
       case "BreakStatement": case "ContinueStatement": case "PrivateIdentifier":
         return;
       case "Identifier":
@@ -368,7 +383,7 @@ function transformEsmToCjsAst(code: string): string {
         // for any import (the marker becomes `await` in an async body).
         sideEffectImports += 1;
         const namespace = `__substrateImportSide${sideEffectImports}`;
-        replacements.push([node.start, node.end, `const ${namespace} = ${__cjsRequire()}(${JSON.stringify(source)}); /*__substrate_await__*/(${namespace} && ${namespace}[Symbol.for("substrate.pending")]);`]);
+        replacements.push([node.start, node.end, `const ${namespace} = ${__cjsRequire()}(${JSON.stringify(source)}); /*__substrate_await__*/(${namespace} && ${namespace}[${__cjsSymbol()}.for("substrate.pending")]);`]);
       } else {
         const defaultSpec = specs.find((s: any) => s.type === 'ImportDefaultSpecifier');
         const nsSpec = specs.find((s: any) => s.type === 'ImportNamespaceSpecifier');
@@ -404,7 +419,7 @@ function transformEsmToCjsAst(code: string): string {
       // `module.exports = X`, which threw away every named export defined
       // before it (readdirp exports `readdirp` by name and as the default;
       // chokidar imports the name and found the module was the function).
-      const defineDefault = (value: string): string => `Object.defineProperty(${__cjsExports()}, "default", { enumerable: true, configurable: true, get: function () { return ${value}; } });`;
+      const defineDefault = (value: string): string => `${__cjsObject()}.defineProperty(${__cjsExports()}, "default", { enumerable: true, configurable: true, get: function () { return ${value}; } });`;
       if (decl.type === 'FunctionDeclaration') {
         const funcCode = code.slice(decl.start, node.end);
         replacements.push([node.start, node.end, decl.id ? `${funcCode}\n${defineDefault(decl.id.name)}` : `${defineDefault(`(${funcCode})`)}`]);
@@ -423,11 +438,11 @@ function transformEsmToCjsAst(code: string): string {
           const name = decl.id.name;
           const funcCode = code.slice(decl.start, node.end);
           replacements.push([node.start, node.end, funcCode]);
-          hoisted.push(`Object.defineProperty(${__cjsExports()}, "${name}", { enumerable: true, get: function () { return ${name}; } });`);
+          hoisted.push(`${__cjsObject()}.defineProperty(${__cjsExports()}, "${name}", { enumerable: true, get: function () { return ${name}; } });`);
         } else if (decl.type === 'ClassDeclaration') {
           const name = decl.id.name;
           const classCode = code.slice(decl.start, node.end);
-          replacements.push([node.start, node.end, `${classCode}\nObject.defineProperty(${__cjsExports()}, "${name}", { enumerable: true, get: function () { return ${name}; } });`]);
+          replacements.push([node.start, node.end, `${classCode}\n${__cjsObject()}.defineProperty(${__cjsExports()}, "${name}", { enumerable: true, get: function () { return ${name}; } });`]);
         } else if (decl.type === 'VariableDeclaration') {
           // The declaration stays as written, so the module keeps a binding of
           // its own; what follows is an export that reads that binding when
@@ -446,7 +461,7 @@ function transformEsmToCjsAst(code: string): string {
             else if (pattern.type === 'RestElement') collect(pattern.argument);
           };
           for (const declarator of decl.declarations) collect(declarator.id);
-          for (const name of names) parts.push(`Object.defineProperty(${__cjsExports()}, "${name}", { enumerable: true, get: function () { return ${name}; } });`);
+          for (const name of names) parts.push(`${__cjsObject()}.defineProperty(${__cjsExports()}, "${name}", { enumerable: true, get: function () { return ${name}; } });`);
           replacements.push([node.start, node.end, parts.join('\n')]);
         }
       } else if (node.source) {
@@ -462,9 +477,9 @@ function transformEsmToCjsAst(code: string): string {
         const tmpVar = `__reexport_${node.start}`;
         parts.push(`const ${tmpVar} = ${__cjsRequire()}(${JSON.stringify(source)})`);
         // The re-exported module may still be settling; wait for it as for an import.
-        parts.push(`/*__substrate_await__*/(${tmpVar} && ${tmpVar}[Symbol.for("substrate.pending")])`);
+        parts.push(`/*__substrate_await__*/(${tmpVar} && ${tmpVar}[${__cjsSymbol()}.for("substrate.pending")])`);
         for (const spec of node.specifiers) {
-          parts.push(`Object.defineProperty(${__cjsExports()}, "${spec.exported.name}", { enumerable: true, configurable: true, get: function () { return ${tmpVar}.${spec.local.name}; } })`);
+          parts.push(`${__cjsObject()}.defineProperty(${__cjsExports()}, "${spec.exported.name}", { enumerable: true, configurable: true, get: function () { return ${tmpVar}.${spec.local.name}; } })`);
         }
         replacements.push([node.start, node.end, parts.join(';\n')]);
       } else {
@@ -472,7 +487,7 @@ function transformEsmToCjsAst(code: string): string {
         // an explicit export that replaces a star's getter of the same name.
         const parts: string[] = [];
         for (const spec of node.specifiers) {
-          parts.push(`Object.defineProperty(${__cjsExports()}, "${spec.exported.name}", { enumerable: true, configurable: true, get: function () { return ${spec.local.name}; } })`);
+          parts.push(`${__cjsObject()}.defineProperty(${__cjsExports()}, "${spec.exported.name}", { enumerable: true, configurable: true, get: function () { return ${spec.local.name}; } })`);
         }
         replacements.push([node.start, node.end, parts.join(';\n')]);
       }
@@ -485,7 +500,7 @@ function transformEsmToCjsAst(code: string): string {
       const source = node.source.value;
       const name = node.exported.type === 'Identifier' ? node.exported.name : node.exported.value;
       const tmpVar = `__reexport_${node.start}`;
-      replacements.push([node.start, node.end, `const ${tmpVar} = ${__cjsRequire()}(${JSON.stringify(source)}); /*__substrate_await__*/(${tmpVar} && ${tmpVar}[Symbol.for("substrate.pending")]); Object.defineProperty(${__cjsExports()}, ${JSON.stringify(name)}, { enumerable: true, configurable: true, get: function () { return ${tmpVar}; } })`]);
+      replacements.push([node.start, node.end, `const ${tmpVar} = ${__cjsRequire()}(${JSON.stringify(source)}); /*__substrate_await__*/(${tmpVar} && ${tmpVar}[${__cjsSymbol()}.for("substrate.pending")]); ${__cjsObject()}.defineProperty(${__cjsExports()}, ${JSON.stringify(name)}, { enumerable: true, configurable: true, get: function () { return ${tmpVar}; } })`]);
     } else if (node.type === 'ExportAllDeclaration') {
       // export * from './helpers'
       const source = node.source.value;
@@ -498,7 +513,7 @@ function transformEsmToCjsAst(code: string): string {
       // module does not already export; a local export shadows a star's, as the
       // language says.
       const tmpVar = `__reexport_${node.start}`;
-      replacements.push([node.start, node.end, `const ${tmpVar} = ${__cjsRequire()}(${JSON.stringify(source)}); /*__substrate_await__*/(${tmpVar} && ${tmpVar}[Symbol.for("substrate.pending")]); (function (__from, __into) { for (const __key of Object.keys(__from)) { if (__key === "default" || __key === "__esModule" || Object.prototype.hasOwnProperty.call(__into, __key)) continue; Object.defineProperty(__into, __key, { enumerable: true, configurable: true, get: function () { return __from[__key]; } }); } })(${tmpVar}, ${__cjsExports()})`]);
+      replacements.push([node.start, node.end, `const ${tmpVar} = ${__cjsRequire()}(${JSON.stringify(source)}); /*__substrate_await__*/(${tmpVar} && ${tmpVar}[${__cjsSymbol()}.for("substrate.pending")]); (function (__from, __into) { for (const __key of ${__cjsObject()}.keys(__from)) { if (__key === "default" || __key === "__esModule" || ${__cjsObject()}.prototype.hasOwnProperty.call(__into, __key)) continue; ${__cjsObject()}.defineProperty(__into, __key, { enumerable: true, configurable: true, get: function () { return __from[__key]; } }); } })(${tmpVar}, ${__cjsExports()})`]);
     }
   }
 

package/src/node-lib/binding/zlib.ts

@@ -28,6 +28,9 @@
  * which this product does not do. The row in BUILTINS.md says the same.
  */
 import { zstream, inflateModule, deflateModule, zlibConstants } from './zlib-pako';
+// @ts-expect-error `brotli` ships no types; its decoder takes and returns bytes.
+import brotliDecompressUntyped from 'brotli/decompress';
+const brotliDecompress = brotliDecompressUntyped as (input: Uint8Array) => Uint8Array;
 
 /** Node's `zlib` modes, by the numbers `zlib.js` passes. */
 const DEFLATE = 1;
@@ -236,9 +239,83 @@ function absentCodec(name: string, reason: string): new (...args: unknown[]) =>
   } as unknown as new (...args: unknown[]) => never;
 }
 
+/**
+ * `BrotliDecoder`, over the engine's own Brotli decoder (`brotli`'s, pure
+ * JavaScript). That decoder takes a whole stream, so this handle collects
+ * the input it is given and decodes when `zlib.js` sends the finishing
+ * flush, then hands the output back as the caller's buffers take it: a
+ * stream is inflated, it is not inflated incrementally. A server reading a
+ * pre-compressed file through `createBrotliDecompress` is the case it serves.
+ */
+const BROTLI_OPERATION_FINISH = 2;
+class BrotliDecoderHandle {
+  #writeState: Uint32Array | null = null;
+  #callback: ProcessCallback | null = null;
+  #input: Uint8Array[] = [];
+  #output: Uint8Array | null = null;
+  #outputAt = 0;
+  onerror: ((message: string, errno: number, code?: string) => void) | null = null;
+
+  constructor(public readonly mode: number) {}
+
+  init(_params: Uint32Array, writeState: Uint32Array, processCallback: ProcessCallback): boolean {
+    this.#writeState = writeState;
+    this.#callback = processCallback;
+    return true;
+  }
+
+  #run(flush: number, inBuf: Uint8Array | null, inOff: number, inLen: number, outBuf: Uint8Array, outOff: number, outLen: number): void {
+    if (inBuf && inLen > 0) this.#input.push(inBuf.slice(inOff, inOff + inLen));
+    if (flush === BROTLI_OPERATION_FINISH && this.#output === null) {
+      const total = this.#input.reduce((sum, part) => sum + part.byteLength, 0);
+      const whole = new Uint8Array(total);
+      let at = 0;
+      for (const part of this.#input) { whole.set(part, at); at += part.byteLength; }
+      this.#input = [];
+      try {
+        this.#output = brotliDecompress(whole);
+      } catch (error) {
+        this.onerror?.(`Decompression failed: ${error instanceof Error ? error.message : String(error)}`, -1, 'ERR_BROTLI_DECOMPRESSION_FAILED');
+        return;
+      }
+      this.#outputAt = 0;
+    }
+    let written = 0;
+    if (this.#output) {
+      written = Math.min(outLen, this.#output.byteLength - this.#outputAt);
+      outBuf.set(this.#output.subarray(this.#outputAt, this.#outputAt + written), outOff);
+      this.#outputAt += written;
+    }
+    if (this.#writeState) {
+      this.#writeState[0] = outLen - written;
+      this.#writeState[1] = 0;
+    }
+  }
+
+  write(flush: number, inBuf: Uint8Array | null, inOff: number, inLen: number, outBuf: Uint8Array, outOff: number, outLen: number): this {
+    const tick = (globalThis as { process?: { nextTick?: (fn: () => void) => void } }).process?.nextTick
+      ?? ((fn: () => void) => { queueMicrotask(fn); });
+    tick(() => {
+      this.#run(flush, inBuf, inOff, inLen, outBuf, outOff, outLen);
+      this.#callback?.();
+    });
+    return this;
+  }
+
+  writeSync(flush: number, inBuf: Uint8Array | null, inOff: number, inLen: number, outBuf: Uint8Array, outOff: number, outLen: number): this {
+    this.#run(flush, inBuf, inOff, inLen, outBuf, outOff, outLen);
+    return this;
+  }
+
+  params(): void {}
+  reset(): void { this.#input = []; this.#output = null; this.#outputAt = 0; }
+  close(): void { this.reset(); this.#callback = null; }
+  getAvailableOutput(): number { return this.#output ? this.#output.byteLength - this.#outputAt : 0; }
+}
+
 const BROTLI_REASON =
-  'Brotli is a codec of its own, not zlib; the engine has a wasm build of it as a dependency ' +
-  'but no binding for Node\'s Brotli handle yet. `zlib.gzip`, `deflate` and `inflate` are Node\'s own here.';
+  'Brotli is a codec of its own, not zlib; the engine decodes it (`brotli`, pure JavaScript) but has no ' +
+  'encoder for Node\'s Brotli handle yet. `zlib.gzip`, `deflate` and `inflate` are Node\'s own here.';
 const ZSTD_REASON =
   'Zstandard is a codec of its own and this engine has no implementation of it at all. ' +
   '`zlib.gzip`, `deflate` and `inflate` are Node\'s own here.';
@@ -246,7 +323,7 @@ const ZSTD_REASON =
 export const zlibBinding = {
   Zlib,
   BrotliEncoder: absentCodec('Brotli compression', BROTLI_REASON),
-  BrotliDecoder: absentCodec('Brotli decompression', BROTLI_REASON),
+  BrotliDecoder: BrotliDecoderHandle,
   ZstdCompress: absentCodec('Zstandard compression', ZSTD_REASON),
   ZstdDecompress: absentCodec('Zstandard decompression', ZSTD_REASON),
   /** `zlib.crc32`, which is zlib's own table-driven one. */

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,
+};