typenative 0.1.3 → 0.2.0

package/conformance.md

@@ -28,7 +28,7 @@ self-hosted binary). Each ❌ row is a known gap with no passing probe yet.
 | --------------------------------------- | :----: | -------------------------------------------------------------------------------- | ---------------------------------------------------                      |
 | Variable declarations (`let` / `const`) |   ✅    | [syntax-variables.ts](conformance/syntax-variables.ts)                           |                                                                          |
 | Array destructuring                     |   ✅    | [syntax-destructuring.ts](conformance/syntax-destructuring.ts)                   | Parenthesized initializers; elision and element/property reads           |
-| Object destructuring                    |   ✅    | [syntax-destructuring.ts](conformance/syntax-destructuring.ts)                   | Parenthesized initializers; elision and element/property reads           |
+| Object destructuring                    |   ✅    | [syntax-destructuring.ts](conformance/syntax-destructuring.ts)                   | Parenthesized initializers; elision and element/property reads; the initializer is evaluated once ([lib-node-worker-threads.ts](conformance/lib-node-worker-threads.ts)) |
 | Destructuring with defaults             |   ✅    | [syntax-destructuring-defaults.ts](conformance/syntax-destructuring-defaults.ts) | Missing elements/properties take defaults (nil- and bounds-checked)      |
 | Destructured parameters                 |   ✅    | [syntax-destructuring-params.ts](conformance/syntax-destructuring-params.ts)     | `function f({ a, b }: T)`, `([x, y]: number[])`                          |
 | Object shorthand                        |   ✅    | [syntax-destructuring.ts](conformance/syntax-destructuring.ts)                   | Parenthesized initializers; elision and element/property reads           |
@@ -36,7 +36,7 @@ self-hosted binary). Each ❌ row is a known gap with no passing probe yet.
 | Array spread                            |   ✅    | [syntax-array-spread.ts](conformance/syntax-array-spread.ts)                     | `[...arr]`, `fn(...args)`                                                |
 | `delete` operator                       |   ✅    | [syntax-delete.ts](conformance/syntax-delete.ts)                                 | `delete o.key` on records                                                |
 | Computed keys                           |   ✅    | [syntax-computed-keys.ts](conformance/syntax-computed-keys.ts)                   | Computed keys become map entries; `o.name` reads lower to `.Get("name")` |
-| Records / dictionaries                  |   ✅    | [syntax-in-operator.ts](conformance/syntax-in-operator.ts)                       | `Record<K, V>` and objects indexed by key → Go maps                      |
+| Records / dictionaries                  |   ✅    | [syntax-in-operator.ts](conformance/syntax-in-operator.ts)                       | `Record<K, V>` and objects indexed by key → Go maps; so are literals with keys that aren't identifiers (`{ 'Content-Type': … }`, [lib-node-http-server.ts](conformance/lib-node-http-server.ts)) |
 | Tuples                                  |   ✅    | [syntax-tuples.ts](conformance/syntax-tuples.ts)                                 | `[string, number]` fixed-length arrays                                   |
 | Top-level / module-scope variables      |   ✅    | [syntax-top-level-scope.ts](conformance/syntax-top-level-scope.ts)               | Functions see main-file top-level variables                              |
 | Numeric separators                      |   ✅    | [syntax-numeric-separators.ts](conformance/syntax-numeric-separators.ts)         | `1_000_000`                                                              |
@@ -90,6 +90,7 @@ self-hosted binary). Each ❌ row is a known gap with no passing probe yet.
 | Optional catch binding (`catch {}`) |   ✅    | [syntax-try-catch-finally.ts](conformance/syntax-try-catch-finally.ts)                                         |                                                                            |
 | Custom error classes                |   ✅    | [syntax-custom-errors.ts](conformance/syntax-custom-errors.ts)                                                 | `extends Error` → embedded `TnError`; constructors take the message        |
 | `Error.message`                     |   ✅    | [syntax-error-message.ts](conformance/syntax-error-message.ts)                                                 | `throw new Error` panics with a `*TnError`; `.message` on caught values    |
+| `Error` `cause` (`new Error(message, { cause })`, `err.cause`) |   ✅    | [lib-node-fetch-bad-port.ts](conformance/lib-node-fetch-bad-port.ts) | Built-in error classes too |
 | Narrowing                           |   ✅    | [syntax-typeof.ts](conformance/syntax-typeof.ts)                                                               | `T \| undefined` narrowed after `if (x)`, `x !== undefined`, early returns |
 
 ## Functions
@@ -202,7 +203,7 @@ self-hosted binary). Each ❌ row is a known gap with no passing probe yet.
 | Namespace imports                                  |   ✅    | [syntax-import-go.ts](conformance/syntax-import-go.ts)           | `import * as x from 'pkg'`                                                                                             |
 | Local file imports                                 |   ✅    | [syntax-import-local.ts](conformance/syntax-import-local.ts)     | Relative paths transpiled to a separate Go file (helper: [import-local-helper.ts](conformance/import-local-helper.ts)) |
 | Default export                                     |   ✅    | [syntax-default-export.ts](conformance/syntax-default-export.ts) | `export default function`                                                                                              |
-| Node.js built-in imports                           |   ✅    | [lib-node-path.ts](conformance/lib-node-path.ts)                 | `import { join } from 'node:path'` mapped to Go stdlib (see [Standard library](#standard-library))                     |
+| Node.js built-in imports                           |   ✅    | [lib-node-path.ts](conformance/lib-node-path.ts)                 | `node:x` or bare (`'fs'`), named / default / namespace imports, subpaths (`fs/promises`) (see [Node builtins](#node-builtins-node)) |
 | Go package imports                                 |   ✅    | [syntax-import-go.ts](conformance/syntax-import-go.ts)           | `import { x } from 'go:pkg'`                                                                                           |
 | npm package imports                                |   ✅    | [syntax-import-npm.ts](conformance/syntax-import-npm.ts)         | `import { x } from 'pkg'` mapped to Go module imports                                                                  |
 | Re-exports (`export { x } from`, `export *`)       |   ✅    | [syntax-re-exports.ts](conformance/syntax-re-exports.ts)         | Re-exported files are included (one Go package)                                                                        |
@@ -214,16 +215,17 @@ self-hosted binary). Each ❌ row is a known gap with no passing probe yet.
 
 | Feature                                              | Status | Probe                                                        | Notes                                                                                          |
 | ---------------------------------------------------- | :----: | ------------------------------------------------------------ | --------------------------------------                                                         |
-| `async` / `await`                                    |   ✅    | [syntax-async-await.ts](conformance/syntax-async-await.ts)   | Async functions send returns over a channel; `await` receives; pending work drains before exit |
-| `Promise` constructor / `.then`                      |   ✅    | [syntax-promise-then.ts](conformance/syntax-promise-then.ts) | `new Promise` executor runs in a goroutine; `.then` consumes the channel on a wait group       |
+| `async` / `await`                                    |   ✅    | [syntax-async-await.ts](conformance/syntax-async-await.ts)   | The body runs synchronously until its first `await`; `await` runs pending event-loop tasks while it waits; the loop drains before exit |
+| Async arrow callbacks (`emitter.on('x', async () => { await … })`, `test('t', async () => …)`) | ✅ | [lib-node-test.ts](conformance/lib-node-test.ts) | Run to completion when called (their awaits keep the event loop running), so the caller sees them finish before it continues |
+| `Promise` constructor / `.then`                      |   ✅    | [syntax-promise-then.ts](conformance/syntax-promise-then.ts) | The executor runs synchronously; promises are buffered channels; `.then` callbacks run on the event loop |
 | `Promise.all`                                        |   ✅    | [syntax-promise-all.ts](conformance/syntax-promise-all.ts)   | `TnPromiseAll` drains every promise channel into a slice                                       |
 | `Promise.resolve`                                    |   ✅    | [lib-promise-resolve.ts](conformance/lib-promise-resolve.ts) | Buffered channel holding the value                                                             |
 | `Promise.reject` / `.catch` / `.finally`             |   ✅    | [lib-promise-catch.ts](conformance/lib-promise-catch.ts)     | Rejected promises are closed channels with a reason; `await` rethrows                          |
 | `Promise.race` / `allSettled` / `any`                |   ✅    | [lib-promise-combinators.ts](conformance/lib-promise-combinators.ts) | Goroutine per promise; first settled / all settled / first fulfilled                           |
 | `clearTimeout`                                       |   ✅    | [lib-timers.ts](conformance/lib-timers.ts)                   | `TnClearTimeout` stops the timer                                                               |
-| `setInterval` / `clearInterval`                      |   ✅    | [lib-set-interval.ts](conformance/lib-set-interval.ts)       | `time.Ticker`; the process lives until cleared                                                 |
-| `queueMicrotask`                                     |   ✅    | [lib-queue-microtask.ts](conformance/lib-queue-microtask.ts) | Runs after the current synchronous code (end of main or a timer callback)                      |
-| `setTimeout`                                         |   ✅    | [lib-set-timeout.ts](conformance/lib-set-timeout.ts)         | `time.AfterFunc` registered on a wait group the process waits on                               |
+| `setInterval` / `clearInterval`                      |   ✅    | [lib-set-interval.ts](conformance/lib-set-interval.ts)       | `time.Ticker` posting to the event loop; the process lives until cleared                       |
+| `queueMicrotask`                                     |   ✅    | [lib-queue-microtask.ts](conformance/lib-queue-microtask.ts) | Runs after the current synchronous code (end of main or of an event-loop task)                 |
+| `setTimeout`                                         |   ✅    | [lib-set-timeout.ts](conformance/lib-set-timeout.ts)         | `time.AfterFunc` posting the callback to the event loop, which keeps the process alive          |
 
 ## Semantics (JS behaviour preserved)
 
@@ -254,10 +256,12 @@ Every standard-library API TypeNative ports, split by module. Per
 
 | API                                | Status | Probe                                                  | Notes                                                  |
 | ---------------------------------- | :----: | ------------------------------------------------------ | ------------------------------------------------------ |
-| `console.log`                      |   ✅    | [lib-console-log.ts](conformance/lib-console-log.ts)   | Mapped to `fmt.Println`                                |
+| `console.log`                      |   ✅    | [lib-console-log.ts](conformance/lib-console-log.ts)   | `fmt.Println`; non-string arguments print like Node (`util.inspect`), format strings like `util.format` |
 | `console.error`                    |   ✅    | [lib-console-error.ts](conformance/lib-console-error.ts) | `fmt.Fprintln(os.Stderr, ...)`                         |
 | `console.warn`                     |   ✅    | [lib-console-error.ts](conformance/lib-console-error.ts) | Mapped to stderr like `console.error`                  |
-| `console.time` / `console.timeEnd` |   ✅    | [lib-console-time.ts](conformance/lib-console-time.ts) | Via `time.Now` / `time.Since`                          |
+| `console.time` / `console.timeEnd` / `console.timeLog` |   ✅    | [lib-console-time.ts](conformance/lib-console-time.ts) | Node's format: `label: 1.234ms`                         |
+| `console.info` / `debug` / `dir` / `count` / `countReset` / `group` / `groupEnd` / `assert` / `trace` | ✅ | [lib-console-more.ts](conformance/lib-console-more.ts) | `group` indents every later console line; `assert` prints `Assertion failed` |
+| `console.table` (arrays, objects, `Map`, `Set`, a `properties` filter) | ✅ | [lib-node-console-table.ts](conformance/lib-node-console-table.ts) | Node's box-drawn layout (left-aligned cells); other values are logged as is |
 
 ### `Math`
 
@@ -278,7 +282,7 @@ Every standard-library API TypeNative ports, split by module. Per
 
 | API              | Status | Probe                                                      | Notes                                                   |
 | ---------------- | :----: | ---------------------------------------------------------- | -------------------------------------                   |
-| `JSON.parse`     |   ✅    | [lib-json-parse.ts](conformance/lib-json-parse.ts)         | Mapped to `encoding/json` `Unmarshal`                   |
+| `JSON.parse`     |   ✅    | [lib-json-parse.ts](conformance/lib-json-parse.ts)         | Mapped to `encoding/json` `Unmarshal`; assigned to an interface type, the result converts into its struct |
 | `JSON.stringify` |   ✅    | [lib-json-stringify.ts](conformance/lib-json-stringify.ts) | Reflection serializer includes unexported struct fields |
 
 ### `Object`
@@ -300,7 +304,7 @@ Every standard-library API TypeNative ports, split by module. Per
 | `toUpperCase` / `toLowerCase`                             |   ✅    | [lib-string-basics.ts](conformance/lib-string-basics.ts)               | Via `strings` package                                                  |
 | `trim` / `trimStart` / `trimEnd`                          |   ✅    | [lib-string-basics.ts](conformance/lib-string-basics.ts)               | Via `strings` package                                                  |
 | `split` / `join`                                          |   ✅    | [lib-string-split-join.ts](conformance/lib-string-split-join.ts)       | Via `strings` package                                                  |
-| `includes` / `startsWith` / `endsWith` / `indexOf`        |   ✅    | [lib-string-search.ts](conformance/lib-string-search.ts)               | Via `strings` package                                                  |
+| `includes` / `startsWith` / `endsWith` / `indexOf` (with `fromIndex`)        |   ✅    | [lib-string-search.ts](conformance/lib-string-search.ts)               | Via `strings` package                                                  |
 | `replace` / `replaceAll` (string pattern)                 |   ✅    | [lib-string-replace.ts](conformance/lib-string-replace.ts)             | Via `strings` package                                                  |
 | `replace` / `replaceAll` (RegExp, `$1`/`$&`, fn replacer) |   ✅    | [syntax-top-level-scope.ts](conformance/syntax-top-level-scope.ts)     | `/g` vs first match, `$1`/`$&` patterns, function replacers            |
 | `charAt` / `substring` / `slice`                          |   ✅    | [lib-string-slice.ts](conformance/lib-string-slice.ts)                 | Direct Go string indexing/slicing                                      |
@@ -396,6 +400,7 @@ Every standard-library API TypeNative ports, split by module. Per
 | API                                                  | Status | Probe                                                        | Notes                                                               |
 | ---------------------------------------------------- | :----: | ------------------------------------------------------------ | ------------------------------------------------------------------- |
 | `Promise` constructor / `.then`                      |   ✅    | [syntax-promise-then.ts](conformance/syntax-promise-then.ts) | Channel lowering works (see [Async & timing](#async--timing))       |
+| `resolve` / `reject` passed as values                |   ✅    | [lib-node-async-hooks.ts](conformance/lib-node-async-hooks.ts) | `new Promise((resolve) => setTimeout(resolve, ms))`                 |
 | `Promise.all`                                        |   ✅    | [syntax-promise-all.ts](conformance/syntax-promise-all.ts)   | Channel lowering works (see [Async & timing](#async--timing))       |
 | `Promise.resolve`                                    |   ✅    | [lib-promise-resolve.ts](conformance/lib-promise-resolve.ts) | Buffered channel holding the value                                  |
 | `Promise.reject` / `.catch` / `.finally`             |   ✅    | [lib-promise-catch.ts](conformance/lib-promise-catch.ts)     | Rejected promises are closed channels with a reason; `await` rethrows |
@@ -410,248 +415,709 @@ Every standard-library API TypeNative ports, split by module. Per
 | API                                         | Status | Probe                                                              | Notes                                    |
 | ------------------------------------------- | :----: | ------------------------------------------------------------------ | ---------------------------------------- |
 | `assert`                                    |   ✅    | [lib-console-log.ts](conformance/lib-console-log.ts)               | Transpiled to `panic` on failure         |
-| `process.argv` / `process.platform`         |   ✅    | [lib-process.ts](conformance/lib-process.ts)                       | Mapped to `os.Args` / `runtime.GOOS`     |
+| `process.argv` / `process.platform`         |   ✅    | [lib-process.ts](conformance/lib-process.ts)                       | Node's shapes (`[execPath, script, ...args]`, `win32`); the rest of `process` is in [node:process](#nodeprocess) |
 | `process.env`                               |   ✅    | [syntax-top-level-scope.ts](conformance/syntax-top-level-scope.ts) | Environment variable access              |
-| `process.exit`                              |   ✅    | [lib-process-exit.ts](conformance/lib-process-exit.ts)             | `os.Exit`                                |
+| `process.exit`                              |   ✅    | [lib-process-exit.ts](conformance/lib-process-exit.ts)             | `os.Exit`, after `process.on('exit')` listeners |
 | `process.cwd()`                             |   ✅    | [lib-process-cwd.ts](conformance/lib-process-cwd.ts)               | `os.Getwd()`                             |
+| `Buffer` / `Uint8Array` / `TextEncoder` / `TextDecoder` / `atob` / `btoa` | ✅ | [lib-node-buffer-encodings.ts](conformance/lib-node-buffer-encodings.ts) | See [node:buffer](#nodebuffer)           |
+| `URL` / `URLSearchParams`                   |   ✅    | [lib-node-url-class.ts](conformance/lib-node-url-class.ts)         | See [node:url](#nodeurl)                 |
+| `EventTarget` / `Event` / `AbortController` / `AbortSignal` | ✅ | [lib-node-abort.ts](conformance/lib-node-abort.ts) | See [node:events](#nodeevents)           |
+| `performance` / `setImmediate` / `crypto`   |   ✅    | [lib-node-perf-hooks.ts](conformance/lib-node-perf-hooks.ts)       | See [perf_hooks](#nodeperf_hooks), [timers](#nodetimers), [crypto](#nodecrypto) |
+| `TypeError` / `RangeError` / `SyntaxError` & co. | ✅ | [lib-node-assert.ts](conformance/lib-node-assert.ts)             | `TnError`s carrying their `name`; `instanceof` checks the name |
 | `Infinity`                                  |   ✅    | [lib-globals.ts](conformance/lib-globals.ts)                       | `math.Inf(1)`                            |
 | Global `isNaN` / `isFinite`                 |   ✅    | [lib-globals.ts](conformance/lib-globals.ts)                       | `math.IsNaN` / `math.IsInf`              |
 | `encodeURIComponent` / `decodeURIComponent` |   ✅    | [lib-uri.ts](conformance/lib-uri.ts)                               | `TnEncodeURIComponent` / `url.PathUnescape` |
 | `structuredClone`                           |   ✅    | [lib-structured-clone.ts](conformance/lib-structured-clone.ts)     | Reflection deep copy                     |
+| `fetch` / `Headers` / `Request` / `Response` |   ✅    | [lib-node-fetch.ts](conformance/lib-node-fetch.ts)                 | See [fetch](#fetch)                      |
+| `ReadableStream` / `WritableStream` / `TransformStream` & co., `TextEncoderStream` / `TextDecoderStream`, `CompressionStream` / `DecompressionStream` | ✅ | [lib-node-stream-web.ts](conformance/lib-node-stream-web.ts) | See [stream/web](#nodestreamweb) |
+| `Blob` / `File` / `FormData`                 |   ✅    | [lib-node-blob.ts](conformance/lib-node-blob.ts)                   | See [buffer](#nodebuffer) and [fetch](#fetch) |
+| `MessageChannel` / `MessagePort` / `BroadcastChannel` | ✅ | [lib-node-worker-threads.ts](conformance/lib-node-worker-threads.ts) | See [worker_threads](#nodeworker_threads) |
+| `__filename` / `__dirname`                  |   ✅    | —                                                                  | The running executable (a native binary has no script file) |
 | `globalThis`                                |   ✅    | [lib-global-this.ts](conformance/lib-global-this.ts)               | `globalThis.x` is the global `x`; `(globalThis as any)` is a dynamic object |
 
 ### Node builtins (`node:*`)
 
-| Module                                                                               | Status | Probe                                            | Notes                                                 |
-| ------------------------------------------------------------------------------------ | :----: | ------------------------------------------------ | ----------------------------------------------------- |
-| `node:path` (`join`, `dirname`, `basename`, `extname`, `resolve`)                    |   ✅    | [lib-node-path.ts](conformance/lib-node-path.ts) | Mapped to Go `path`/`filepath`                        |
-| `node:fs` (`read/write/append/exists/mkdir/readdir/copy/rm/unlink`)                  |   ✅    | [lib-node-fs.ts](conformance/lib-node-fs.ts)     | Via Go helpers                                        |
-| `node:url` (`fileURLToPath`, `pathToFileURL`)                                        |   ✅    | [lib-node-url.ts](conformance/lib-node-url.ts)   | `TnFileURLToPath` / `TnPathToFileURL`                 |
-| `node:os` (`platform`, `homedir`, `tmpdir`)                                          |   ✅    | [lib-node-fs.ts](conformance/lib-node-fs.ts)     | `platform()` covered; `homedir`/`tmpdir` unprobed     |
-| `node:child_process` (`exec`, `execSync`, `spawnSync`, `spawnInherit`)               |   ✅    | [lib-node-fs.ts](conformance/lib-node-fs.ts)     | Sync API shape, stdio-inherit runs                    |
-| `node:readline` (`question`)                                                         |   ❌    | —                                                | Declared (TypeNative sync extension) but no probe yet |
-| `node:assert` / `node:assert/strict`                                                 |   ❌    | —                                                | Undeclared; global `assert` is mapped to `panic`      |
-| `node:async_hooks`                                                                   |   ❌    | —                                                | Undeclared; unsupported                               |
-| `node:buffer`                                                                        |   ❌    | —                                                | Undeclared; unsupported                               |
-| `node:cluster`                                                                       |   ❌    | —                                                | Undeclared; unsupported                               |
-| `node:console`                                                                       |   ❌    | —                                                | Undeclared; global `console` methods are mapped       |
-| `node:constants`                                                                     |   ❌    | —                                                | Undeclared; unsupported                               |
-| `node:crypto`                                                                        |   ❌    | —                                                | Undeclared; unsupported                               |
-| `node:dgram`                                                                         |   ❌    | —                                                | Undeclared; unsupported                               |
-| `node:diagnostics_channel`                                                           |   ❌    | —                                                | Undeclared; unsupported                               |
-| `node:dns` / `node:dns/promises`                                                     |   ❌    | —                                                | Undeclared; unsupported                               |
-| `node:domain`                                                                        |   ❌    | —                                                | Deprecated upstream; undeclared                       |
-| `node:events`                                                                        |   ❌    | —                                                | Undeclared; unsupported                               |
-| `node:fs/promises`                                                                   |   ❌    | —                                                | Undeclared; sync `node:fs` subset only                |
-| `node:http`                                                                          |   ❌    | —                                                | Undeclared; unsupported                               |
-| `node:http2`                                                                         |   ❌    | —                                                | Undeclared; unsupported                               |
-| `node:https`                                                                         |   ❌    | —                                                | Undeclared; unsupported                               |
-| `node:inspector` / `node:inspector/promises`                                         |   ❌    | —                                                | Undeclared; unsupported                               |
-| `node:module`                                                                        |   ❌    | —                                                | Undeclared; unsupported                               |
-| `node:net`                                                                           |   ❌    | —                                                | Undeclared; unsupported                               |
-| `node:path/posix` / `node:path/win32`                                                |   ❌    | —                                                | Undeclared; unsupported                               |
-| `node:perf_hooks`                                                                    |   ❌    | —                                                | Undeclared; unsupported                               |
-| `node:process`                                                                       |   ❌    | —                                                | Undeclared; global `process` partially mapped         |
-| `node:punycode`                                                                      |   ❌    | —                                                | Deprecated upstream; undeclared                       |
-| `node:querystring`                                                                   |   ❌    | —                                                | Undeclared; unsupported                               |
-| `node:readline/promises`                                                             |   ❌    | —                                                | Undeclared; unsupported                               |
-| `node:repl`                                                                          |   ❌    | —                                                | Undeclared; unsupported                               |
-| `node:sea`                                                                           |   ❌    | —                                                | Undeclared; unsupported (`node:`-only module)         |
-| `node:sqlite`                                                                        |   ❌    | —                                                | Undeclared; unsupported (`node:`-only module)         |
-| `node:stream` / `node:stream/consumers` / `node:stream/promises` / `node:stream/web` |   ❌    | —                                                | Undeclared; unsupported                               |
-| `node:string_decoder`                                                                |   ❌    | —                                                | Undeclared; unsupported                               |
-| `node:sys`                                                                           |   ❌    | —                                                | Deprecated alias of `node:util`; undeclared           |
-| `node:test` / `node:test/reporters`                                                  |   ❌    | —                                                | Undeclared; unsupported (`node:`-only module)         |
-| `node:timers` / `node:timers/promises`                                               |   ❌    | —                                                | Undeclared; unsupported                               |
-| `node:tls`                                                                           |   ❌    | —                                                | Undeclared; unsupported                               |
-| `node:trace_events`                                                                  |   ❌    | —                                                | Undeclared; unsupported                               |
-| `node:tty`                                                                           |   ❌    | —                                                | Undeclared; unsupported                               |
-| `node:util` / `node:util/types`                                                      |   ❌    | —                                                | Undeclared; unsupported                               |
-| `node:v8`                                                                            |   ❌    | —                                                | Undeclared; unsupported                               |
-| `node:vm`                                                                            |   ❌    | —                                                | Undeclared; unsupported                               |
-| `node:wasi`                                                                          |   ❌    | —                                                | Undeclared; unsupported                               |
-| `node:worker_threads`                                                                |   ❌    | —                                                | Undeclared; unsupported                               |
-| `node:zlib`                                                                          |   ❌    | —                                                | Undeclared; unsupported                               |
+Every module can be imported as `node:x` or by its bare name (`fs`), with
+named, default or namespace imports; subpaths (`fs/promises`, `path/posix`,
+`stream/promises`, …) work too. Signatures follow `@types/node`
+([types/typenative-npm.d.ts](types/typenative-npm.d.ts)). Callbacks, timers, I/O
+completions and events run on one event loop, one at a time, as in Node; an
+async function runs synchronously until its first `await`.
+
+| Module                                      | Status | Section                                                    |
+| ------------------------------------------- | :----: | ---------------------------------------------------------- |
+| `node:assert` / `node:assert/strict`        |   ✅    | [assert](#nodeassert)                                       |
+| `node:async_hooks`                          |   ✅    | [async_hooks](#nodeasync_hooks)                             |
+| `node:buffer` (+ globals `Buffer`, `Uint8Array`, `atob`, `btoa`, `Blob`, `File`) | ✅ | [buffer](#nodebuffer)                 |
+| `node:child_process`                        |   ✅    | [child_process](#nodechild_process)                         |
+| `node:cluster`                              |   ✅    | [cluster](#nodecluster)                                     |
+| `node:console`                              |   ✅    | [console](#nodeconsole)                                     |
+| `node:constants`                            |   ✅    | [constants](#nodeconstants--nodesys)                        |
+| `node:crypto` (+ global `crypto`)           |   ✅    | [crypto](#nodecrypto)                                       |
+| `node:dgram`                                |   ✅    | [dgram](#nodedgram)                                         |
+| `node:diagnostics_channel`                  |   ✅    | [diagnostics_channel](#nodediagnostics_channel)             |
+| `node:dns` / `node:dns/promises`            |   ✅    | [dns](#nodedns)                                             |
+| `node:domain`                               |   ❌    | [domain](#nodedomain)                                       |
+| `node:events` (+ `EventTarget`, `AbortController`) | ✅ | [events](#nodeevents)                                      |
+| `node:fs` / `node:fs/promises`              |   ✅    | [fs](#nodefs)                                               |
+| `node:http` / `node:https`                  |   ✅    | [http / https](#nodehttp--nodehttps)                        |
+| `node:http2`                                |   ✅    | [http2](#nodehttp2)                                         |
+| `node:inspector`                            |   ❌    | [inspector](#nodeinspector)                                 |
+| `node:module`                               |   ❌    | [module](#nodemodule)                                       |
+| `node:net`                                  |   ✅    | [net](#nodenet)                                             |
+| `node:os`                                   |   ✅    | [os](#nodeos)                                               |
+| `node:path` / `path/posix` / `path/win32`   |   ✅    | [path](#nodepath)                                           |
+| `node:perf_hooks` (+ global `performance`)  |   ✅    | [perf_hooks](#nodeperf_hooks)                               |
+| `node:process` (+ global `process`)         |   ✅    | [process](#nodeprocess)                                     |
+| `node:punycode`                             |   ✅    | [punycode](#nodepunycode)                                   |
+| `node:querystring`                          |   ✅    | [querystring](#nodequerystring)                             |
+| `node:readline` / `node:readline/promises`  |   ✅    | [readline](#nodereadline)                                   |
+| `node:repl`                                 |   ❌    | [repl](#noderepl)                                           |
+| `node:sea`                                  |   ❌    | [sea](#nodesea)                                             |
+| `node:sqlite`                               |   ✅    | [sqlite](#nodesqlite)                                       |
+| `node:stream` / `stream/promises` / `stream/consumers` | ✅ | [stream](#nodestream)                                     |
+| `node:stream/web` (+ globals `ReadableStream`, `WritableStream`, `TransformStream`, …) | ✅ | [stream/web](#nodestreamweb)                 |
+| `node:string_decoder`                       |   ✅    | [string_decoder](#nodestring_decoder)                       |
+| `node:sys`                                  |   ✅    | [constants / sys](#nodeconstants--nodesys)                  |
+| `node:test`                                 |   ✅    | [test](#nodetest)                                           |
+| `node:test/reporters`                       |   ❌    | [test/reporters](#nodetestreporters)                        |
+| `node:timers` / `node:timers/promises`      |   ✅    | [timers](#nodetimers)                                       |
+| `node:tls`                                  |   ✅    | [tls](#nodetls)                                             |
+| `node:trace_events`                         |   ❌    | [trace_events](#nodetrace_events)                           |
+| `node:tty`                                  |   ✅    | [tty](#nodetty)                                             |
+| `node:url` (+ globals `URL`, `URLSearchParams`) | ✅  | [url](#nodeurl)                                             |
+| `node:util` / `node:util/types`             |   ✅    | [util](#nodeutil)                                           |
+| `node:v8`                                   |   ❌    | [v8](#nodev8)                                               |
+| `node:vm`                                   |   ❌    | [vm](#nodevm)                                               |
+| `node:wasi`                                 |   ❌    | [wasi](#nodewasi)                                           |
+| `node:worker_threads` (+ globals `MessageChannel`, `MessagePort`, `BroadcastChannel`) | ✅ | [worker_threads](#nodeworker_threads) |
+| `node:zlib`                                 |   ✅    | [zlib](#nodezlib)                                           |
+| Global `fetch` (+ `Headers`, `Request`, `Response`, `FormData`) | ✅ | [fetch](#fetch)                                |
+
+#### `node:path`
+
+| API                                                                 | Status | Probe                                                                    | Notes                                                                 |
+| ------------------------------------------------------------------- | :----: | ------------------------------------------------------------------------ | --------------------------------------------------------------------- |
+| `join` / `dirname` / `basename` / `extname` / `resolve`             |   ✅    | [lib-node-path.ts](conformance/lib-node-path.ts)                         | Ports of Node's algorithms (not Go's `filepath`): same results as Node |
+| `normalize` / `relative` / `isAbsolute` / `parse` / `format` / `sep` / `delimiter` | ✅ | [lib-node-path-more.ts](conformance/lib-node-path-more.ts) | Trailing separators, `.bashrc`-style extensions, `''` for same paths   |
+| `path.posix` / `path.win32` / `node:path/posix` / `toNamespacedPath` |   ✅    | [lib-node-path-posix-win32.ts](conformance/lib-node-path-posix-win32.ts) | Both flavours on every OS (drive letters, UNC roots); `path` is the platform's |
+| `matchesGlob` (`*`, `**`, `?`, `[...]`, `{a,b}`; no leading-dot matches) |   ✅    | [lib-node-path-glob.ts](conformance/lib-node-path-glob.ts) | minimatch-style patterns compiled to regular expressions |
+
+#### `node:buffer`
+
+| API                                                                                     | Status | Probe                                                                          | Notes                                                                                  |
+| --------------------------------------------------------------------------------------- | :----: | ------------------------------------------------------------------------------ | -------------------------------------------------------------------------------------- |
+| `Buffer.from` / `alloc` / `concat` / `byteLength` / `isBuffer` / `compare`; `buf[i]`, `length` | ✅ | [lib-node-buffer.ts](conformance/lib-node-buffer.ts)                          | Buffers are Go `[]byte`; `subarray` / `slice` share memory; writes wrap modulo 256      |
+| `toString` / `equals` / `indexOf` / `includes` / `fill` / `write` / `copy`              |   ✅    | [lib-node-buffer.ts](conformance/lib-node-buffer.ts)                           | `` `${buf}` `` decodes UTF-8; `console.log(buf)` prints `<Buffer 68 69>`                |
+| Encodings (utf8, hex, base64, base64url, latin1, ascii, utf16le); `atob` / `btoa`        |   ✅    | [lib-node-buffer-encodings.ts](conformance/lib-node-buffer-encodings.ts)       | Invalid UTF-8 bytes decode to U+FFFD, as in Node                                        |
+| `TextEncoder` / `TextDecoder` (`decode(bytes, { stream: true })`), minimal `Uint8Array` |   ✅    | [lib-node-buffer-encodings.ts](conformance/lib-node-buffer-encodings.ts)       | `Uint8Array` is `[]byte` too: `length`, indexing, `subarray`, `slice`, `set`            |
+| `read*` / `write*` (U)Int8/16/32 LE/BE, Float, Double                                    |   ✅    | [lib-node-buffer-binary.ts](conformance/lib-node-buffer-binary.ts)             | Out-of-range offsets throw `ERR_OUT_OF_RANGE`                                           |
+| `Blob` / `File` (`size`, `type`, `name`, `lastModified`, `text()` / `bytes()` / `arrayBuffer()`, `slice`, `stream()`); parts of strings, Buffers and Blobs | ✅ | [lib-node-blob.ts](conformance/lib-node-blob.ts) | Also globals; bytes held in memory |
+| `read/writeBigInt64LE/BE`, `read/writeBigUInt64LE/BE`, `swap16/32/64`; `isUtf8` / `isAscii` / `transcode` / `kMaxLength` | ✅ | [lib-node-buffer-bigint.ts](conformance/lib-node-buffer-bigint.ts) | bigints are `*big.Int` |
+| Typed arrays other than `Uint8Array` (`Int32Array`, `Float64Array`, `DataView`, …) | ❌ | — | Buffers and `Uint8Array`s are `[]byte`; other views are not implemented |
+
+#### `node:fs`
+
+| API                                                                                     | Status | Probe                                                                  | Notes                                                                                     |
+| --------------------------------------------------------------------------------------- | :----: | ---------------------------------------------------------------------- | ----------------------------------------------------------------------------------------- |
+| `readFileSync` / `writeFileSync` / `appendFileSync` / `existsSync` / `rmSync`           |   ✅    | [lib-node-fs.ts](conformance/lib-node-fs.ts)                           | `readFileSync` returns a Buffer without an encoding, a string with one; `flag` option     |
+| `statSync` / `lstatSync` (`Stats`) / `renameSync` / `copyFileSync` / `truncateSync` / `realpathSync` / `accessSync` / `unlinkSync` | ✅ | [lib-node-fs-stat.ts](conformance/lib-node-fs-stat.ts) | `throwIfNoEntry: false`; Go exposes only the modification time portably, so `atime` / `ctime` / `birthtime` report it too |
+| `mkdirSync` / `mkdtempSync` / `readdirSync` (`withFileTypes`, `recursive`) / `rmdirSync` / `cpSync` |   ✅    | [lib-node-fs-dirs.ts](conformance/lib-node-fs-dirs.ts)                 | `Dirent` with `isFile()` / `isDirectory()` / `parentPath`                                  |
+| Node system errors (`err.code` / `syscall` / `path` / `errno`)                          |   ✅    | [lib-node-fs-errors.ts](conformance/lib-node-fs-errors.ts)             | `ENOENT: no such file or directory, open 'x'`; `EEXIST`, `ENOTEMPTY`, `ERR_FS_EISDIR`, `COPYFILE_EXCL` |
+| File descriptors: `openSync` / `readSync` / `writeSync` / `fstatSync` / `closeSync`     |   ✅    | [lib-node-fs-fd.ts](conformance/lib-node-fs-fd.ts)                     | Flags `r`, `w`, `a`, `+`, `x`; positional reads and writes                                 |
+| Callback API (`readFile(path, enc, (err, data) => …)` & co.)                            |   ✅    | [lib-node-fs-callbacks.ts](conformance/lib-node-fs-callbacks.ts)       | Work runs on a goroutine; callbacks run on the event loop                                 |
+| `fs/promises` / `fs.promises` (incl. `FileHandle` from `open`)                          |   ✅    | [lib-node-fs-promises.ts](conformance/lib-node-fs-promises.ts)         | Rejections carry the error code                                                            |
+| `createReadStream` / `createWriteStream`                                                |   ✅    | [lib-node-fs-streams.ts](conformance/lib-node-fs-streams.ts)           | `encoding`, `start` / `end`, `highWaterMark`, `flags`                                      |
+| `chmodSync` / `utimesSync` / `symlinkSync` / `readlinkSync` / `linkSync`                |   ✅    | —                                                                      | Implemented, not probed (symlinks need privileges on Windows)                             |
+| `watch` / `watchFile`                                                                   |   ❌    | —                                                                      | Go's standard library has no file-system notifications                                    |
+
+#### `node:os`
+
+| API                                                                                          | Status | Probe                                        | Notes                                                                   |
+| -------------------------------------------------------------------------------------------- | :----: | -------------------------------------------- | ----------------------------------------------------------------------- |
+| `platform` / `arch` / `type` / `machine` / `EOL` / `devNull` / `endianness`                  |   ✅    | [lib-node-os.ts](conformance/lib-node-os.ts) | Node's names (`win32`, `x64`, `Windows_NT`, `x86_64`)                    |
+| `hostname` / `homedir` / `tmpdir` / `userInfo` / `cpus` / `availableParallelism` / `networkInterfaces` / `constants.signals` | ✅ | [lib-node-os.ts](conformance/lib-node-os.ts) | `cpus()` has one entry per logical CPU (model / speed / times are zero) |
+| `totalmem` / `freemem` / `uptime` / `loadavg` / `release` / `version` | ✅ | [lib-node-os-mem.ts](conformance/lib-node-os-mem.ts) | `/proc` on Linux, `sysctl` on macOS / BSD; zeros where neither exists |
+
+#### `node:process`
+
+| API                                                                                                  | Status | Probe                                                          | Notes                                                                       |
+| ---------------------------------------------------------------------------------------------------- | :----: | -------------------------------------------------------------- | --------------------------------------------------------------------------- |
+| `argv` / `argv0` / `execPath` / `execArgv` / `pid` / `ppid` / `arch` / `version` / `versions`         |   ✅    | [lib-node-process.ts](conformance/lib-node-process.ts)         | `argv` has Node's shape: `[execPath, script, ...args]`; `version` is `v24.0.0`; `versions.go` is Go's |
+| `hrtime` / `hrtime.bigint` / `uptime` / `memoryUsage` / `chdir` / `cwd` / `stdout.write` / `nextTick` / `exitCode` | ✅ | [lib-node-process.ts](conformance/lib-node-process.ts) | `exitCode` is applied when the event loop drains                            |
+| `process.env` reads, writes, `delete`, `in`, `Object.keys(process.env)`; `import { env } from 'node:process'` | ✅ | [lib-node-process-env.ts](conformance/lib-node-process-env.ts) | `os.Setenv` / `os.Unsetenv`; missing variables read as `""`                  |
+| `process.on('exit' \| 'SIGINT' \| 'SIGTERM' \| 'SIGHUP')` / `once` / `off` / `emit`                   |   ✅    | [lib-node-process-events.ts](conformance/lib-node-process-events.ts) | `'exit'` runs after the event loop with the exit code; signals arrive on the loop |
+| `process.stdin` / `stdout` / `stderr` as streams                                                     |   ✅    | [lib-node-child-process-async.ts](conformance/lib-node-child-process-async.ts) | `stdin` keeps the process alive only while flowing                           |
+| `kill` / `emitWarning` / `getuid` / `getgid`                                                         |   ✅    | —                                                              | Implemented, not probed                                                     |
+| `on('uncaughtException')` / `'uncaughtExceptionMonitor'` / `'unhandledRejection'` / `'beforeExit'` (per drain, can schedule more work); `cpuUsage` / `resourceUsage` / `availableMemory` / `loadEnvFile` | ✅ | [lib-node-process-uncaught.ts](conformance/lib-node-process-uncaught.ts), [lib-node-os-mem.ts](conformance/lib-node-os-mem.ts) | Throws in the top-level code, loop callbacks and detached async calls reach the handlers; CPU times from `/proc` (Linux) or Go's runtime metrics |
+| `umask` / `stdout.columns` / `setRawMode` | ❌ | — | Need OS-specific syscalls a single portable binary can't contain |
+
+#### `node:console`
+
+| API                                                         | Status | Probe                                                      | Notes                                                   |
+| ----------------------------------------------------------- | :----: | ---------------------------------------------------------- | ------------------------------------------------------- |
+| Module re-export (`import { log } from 'node:console'`)     |   ✅    | [lib-node-console-class.ts](conformance/lib-node-console-class.ts) | Same as the global `console`                            |
+| `new Console(stdout, stderr)` / `new Console({ stdout, stderr })` |   ✅    | [lib-node-console-class.ts](conformance/lib-node-console-class.ts) | `log` / `info` / `debug` / `error` / `warn` / `dir` |
+
+#### `node:util`
+
+| API                                                                                   | Status | Probe                                                            | Notes                                                                                     |
+| ------------------------------------------------------------------------------------- | :----: | ---------------------------------------------------------------- | ----------------------------------------------------------------------------------------- |
+| `format` / `formatWithOptions` (`%s %d %i %f %j %o %O %c %%`)                          |   ✅    | [lib-node-util-format.ts](conformance/lib-node-util-format.ts)   | Extra arguments appended; also used by `console.log`                                       |
+| `inspect` (`depth`, `breakLength`, `compact`)                                          |   ✅    | [lib-node-util-inspect.ts](conformance/lib-node-util-inspect.ts) | Node's layout rules: single line up to 80 columns, number arrays grouped in columns, `Map(1) {…}`, `ClassName {…}`, `[Circular *1]` |
+| `isDeepStrictEqual` / `types.*` (`node:util/types`) / `deprecate` / `stripVTControlCharacters` / `styleText` | ✅ | [lib-node-util-misc.ts](conformance/lib-node-util-misc.ts) | `styleText` colours only TTYs unless `validateStream: false`                               |
+| `promisify` / `callbackify`                                                           |   ✅    | [lib-node-util-promisify.ts](conformance/lib-node-util-promisify.ts) | Node functions map to their promise versions at compile time (`fs.readFile`, `setTimeout`, `exec`); other functions are wrapped |
+| `parseArgs` (short / long / grouped flags, `multiple`, `default`, `strict`, `allowPositionals`, `allowNegative`, `tokens`, Node's errors), `getSystemErrorName` / `getSystemErrorMessage` / `getSystemErrorMap`, `MIMEType` / `MIMEParams`, `parseEnv` (+ `process.loadEnvFile`), `aborted`, `debuglog` (`NODE_DEBUG`), `toUSVString` | ✅ | [lib-node-util-parse-args.ts](conformance/lib-node-util-parse-args.ts) | |
+| `inherits` (legacy), `inspect.custom` (symbols), `getCallSites` (V8 stack frames) | ❌ | — | Legacy or engine-specific |
+
+#### `node:assert`
+
+| API                                                                                       | Status | Probe                                                          | Notes                                                                       |
+| ----------------------------------------------------------------------------------------- | :----: | -------------------------------------------------------------- | --------------------------------------------------------------------------- |
+| `assert` / `ok` / `equal` / `strictEqual` (+ `not*`) / `match` / `throws` / `doesNotThrow` / `fail` / `ifError`; `node:assert/strict` | ✅ | [lib-node-assert.ts](conformance/lib-node-assert.ts) | Failures throw an `AssertionError` (`code: 'ERR_ASSERTION'`, `actual`, `expected`, `operator`); `throws` validates with a RegExp, class or object |
+| `deepEqual` / `deepStrictEqual` (+ `not*`) / `rejects` / `doesNotReject`                   |   ✅    | [lib-node-assert-deep.ts](conformance/lib-node-assert-deep.ts) | Key order is ignored for objects, Maps and Sets; failure messages are simplified (no diff) |
+
+#### `node:url`
+
+| API                                                                                          | Status | Probe                                                                  | Notes                                                                                      |
+| -------------------------------------------------------------------------------------------- | :----: | ---------------------------------------------------------------------- | ------------------------------------------------------------------------------------------ |
+| `fileURLToPath` / `pathToFileURL`                                                            |   ✅    | [lib-node-url.ts](conformance/lib-node-url.ts)                         | `pathToFileURL` returns a `URL`; Windows drive letters                                      |
+| `URL` (WHATWG): parsing, relative resolution, getters / setters, `canParse`, `parse`; `domainToASCII` / `domainToUnicode`; `format` | ✅ | [lib-node-url-class.ts](conformance/lib-node-url-class.ts) | Special schemes, dot segments, default ports, percent-encode sets, IDN hosts (punycode); invalid input throws `ERR_INVALID_URL` |
+| `URLSearchParams` (and `url.searchParams`, kept in sync)                                     |   ✅    | [lib-node-url-search-params.ts](conformance/lib-node-url-search-params.ts) | `for...of`, `forEach`, `sort`, construction from strings / objects / pairs                  |
+| Legacy `url.parse` / `url.resolve`                                                           |   ❌    | —                                                                      | Deprecated upstream; not implemented                                                       |
+
+#### `node:querystring`
+
+| API                                                                   | Status | Probe                                                        | Notes                                      |
+| --------------------------------------------------------------------- | :----: | ------------------------------------------------------------ | ------------------------------------------ |
+| `parse` / `stringify` / `escape` / `unescape` / `decode` / `encode`   |   ✅    | [lib-node-querystring.ts](conformance/lib-node-querystring.ts) | Repeated keys become arrays; custom separators |
+
+#### `node:punycode`
+
+| API                                           | Status | Probe                                                    | Notes                           |
+| --------------------------------------------- | :----: | -------------------------------------------------------- | ------------------------------- |
+| `encode` / `decode` / `toASCII` / `toUnicode` |   ✅    | [lib-node-punycode.ts](conformance/lib-node-punycode.ts) | RFC 3492 (deprecated upstream)  |
+
+#### `node:string_decoder`
+
+| API                                     | Status | Probe                                                              | Notes                                                       |
+| --------------------------------------- | :----: | ------------------------------------------------------------------ | ----------------------------------------------------------- |
+| `StringDecoder` (`write` / `end`)       |   ✅    | [lib-node-string-decoder.ts](conformance/lib-node-string-decoder.ts) | Holds back split UTF-8 / UTF-16LE characters and base64 groups |
+
+#### `node:crypto`
+
+| API                                                                       | Status | Probe                                                            | Notes                                                                     |
+| ------------------------------------------------------------------------- | :----: | ---------------------------------------------------------------- | ------------------------------------------------------------------------- |
+| `createHash` / `createHmac` / `hash` / `getHashes` (`update` / `digest` / `copy`) | ✅ | [lib-node-crypto-hash.ts](conformance/lib-node-crypto-hash.ts) | md5, sha1, sha224/256/384/512, sha512-224/256, sha3-224/256/384/512        |
+| `randomBytes` / `randomUUID` / `randomInt` / `getRandomValues` / `timingSafeEqual`; global `crypto` | ✅ | [lib-node-crypto-random.ts](conformance/lib-node-crypto-random.ts) | `crypto/rand`                                                              |
+| `pbkdf2Sync` / `hkdfSync`                                                 |   ✅    | [lib-node-crypto-kdf.ts](conformance/lib-node-crypto-kdf.ts)     | `crypto/pbkdf2` / `crypto/hkdf` (Go 1.24+)                                 |
+| `createCipheriv` / `createDecipheriv` (aes-128/192/256-cbc/ctr/gcm)       |   ✅    | [lib-node-crypto-cipher.ts](conformance/lib-node-crypto-cipher.ts) | GCM output arrives from `final()` (authenticated as a whole)               |
+| `scryptSync` / `scrypt` (`N` / `r` / `p` / `maxmem` and their aliases); callback forms of `pbkdf2`, `hkdf`, `randomBytes`, `randomFill`; `randomFillSync` | ✅ | [lib-node-crypto-scrypt.ts](conformance/lib-node-crypto-scrypt.ts) | scrypt written out over `crypto/pbkdf2` (Salsa20/8, BlockMix, ROMix); callbacks run on the event loop |
+| `KeyObject` (`type`, `asymmetricKeyType`, `asymmetricKeyDetails`, `symmetricKeySize`, `export` as PEM / DER / JWK, `equals`, `KeyObject.from`), `createPrivateKey` / `createPublicKey` / `createSecretKey` (PEM, DER, JWK; pkcs1 / pkcs8 / sec1 / spki; certificates) | ✅ | [lib-node-crypto-keys.ts](conformance/lib-node-crypto-keys.ts) | RSA, EC (P-256 / P-384 / P-521), Ed25519, X25519 |
+| `generateKeyPair(Sync)` (`rsa`, `ec`, `ed25519`, `x25519`; KeyObjects or `publicKeyEncoding` / `privateKeyEncoding`), `generateKey(Sync)` (`hmac`, `aes`) | ✅ | [lib-node-crypto-keys.ts](conformance/lib-node-crypto-keys.ts) | RSA keys use the public exponent 65537 |
+| `sign` / `verify`, `createSign` / `createVerify` (RSA PKCS#1 v1.5 and PSS with `saltLength`, ECDSA in DER or `ieee-p1363`, Ed25519); `publicEncrypt` / `privateDecrypt` (OAEP with `oaepHash` / `oaepLabel`, PKCS#1, none), `privateEncrypt` / `publicDecrypt`; `crypto.constants` | ✅ | [lib-node-crypto-sign.ts](conformance/lib-node-crypto-sign.ts) | |
+| `createECDH` (compressed / uncompressed keys), `getCurves`, `diffieHellman` (ec / x25519 KeyObjects), `createDiffieHellman` / `getDiffieHellman` (modp1 – modp18) | ✅ | [lib-node-crypto-sign.ts](conformance/lib-node-crypto-sign.ts) | `createDiffieHellman(bits)` generates a random (not safe) prime |
+| `generatePrime(Sync)` (`bigint`, `safe`, `add` / `rem`), `checkPrime(Sync)` | ✅ | [lib-node-crypto-sign.ts](conformance/lib-node-crypto-sign.ts) | `math/big`'s Miller-Rabin |
+| `X509Certificate` (`subject`, `issuer`, `subjectAltName`, `validFrom` / `validTo` (+ `Date`s), fingerprints, `serialNumber`, `ca`, `publicKey`, `raw`, `keyUsage`, `checkHost` / `checkIP` / `checkEmail`, `checkIssued`, `verify`, `toString`, `toLegacyObject`) | ✅ | [lib-node-crypto-keys.ts](conformance/lib-node-crypto-keys.ts) | `crypto/x509` |
+| `crypto.subtle` / `webcrypto.subtle`: `digest`, `generateKey`, `importKey` / `exportKey` (`raw`, `spki`, `pkcs8`, `jwk`), `sign` / `verify` (HMAC, RSASSA-PKCS1-v1_5, RSA-PSS, ECDSA, Ed25519), `encrypt` / `decrypt` (AES-GCM / CBC / CTR, RSA-OAEP), `deriveBits` / `deriveKey` (PBKDF2, HKDF, ECDH, X25519), `wrapKey` / `unwrapKey` | ✅ | [lib-node-crypto-subtle.ts](conformance/lib-node-crypto-subtle.ts) | Key usages are recorded but not enforced |
+| Encrypted private keys (`passphrase` / `cipher`), `rsa-pss` / `dsa` / `dh` / `ed448` / `x448` key types, `secp256k1`, AES-KW, `Certificate` (SPKAC), `hash` streams (`createHash` as a stream) | ❌ | — | No Go standard-library support (encrypted PKCS#8, these algorithms) |
+
+#### `node:zlib`
+
+| API                                                                                                  | Status | Probe                                                      | Notes                                                    |
+| ---------------------------------------------------------------------------------------------------- | :----: | ---------------------------------------------------------- | -------------------------------------------------------- |
+| `gzipSync` / `gunzipSync` / `deflateSync` / `inflateSync` / `deflateRawSync` / `inflateRawSync` / `unzipSync` / `crc32` / `constants` | ✅ | [lib-node-zlib.ts](conformance/lib-node-zlib.ts) | `{ level }`; invalid input throws `Z_DATA_ERROR` |
+| `createGzip` / `createGunzip` / `createDeflate` / `createInflate` / `createDeflateRaw` / `createInflateRaw` / `createUnzip` | ✅ | [lib-node-zlib-streams.ts](conformance/lib-node-zlib-streams.ts) | Transforms that (de)compress when the input ends |
+| Callback forms `gzip` / `gunzip` / `deflate` / `inflate` / `deflateRaw` / `inflateRaw` / `unzip` (`buf, [options], cb`) and `util.promisify` of them | ✅ | [lib-node-zlib-async.ts](conformance/lib-node-zlib-async.ts) | The codec runs on a goroutine; the callback runs on the event loop |
+| Brotli (`brotliCompressSync` & co.)                                                                   |   ❌    | —                                                          | Go's standard library has no Brotli codec                 |
+
+#### `node:timers`
+
+| API                                                                              | Status | Probe                                                              | Notes                                                                      |
+| -------------------------------------------------------------------------------- | :----: | ------------------------------------------------------------------ | -------------------------------------------------------------------------- |
+| `setTimeout` / `setInterval` / `setImmediate` (+ extra arguments) / `clear*`; global `setImmediate` | ✅ | [lib-node-timers.ts](conformance/lib-node-timers.ts) | Callbacks run on the event loop                                             |
+| `node:timers/promises` (`setTimeout`, `setImmediate`, `setInterval`, `scheduler`) |   ✅    | [lib-node-timers-promises.ts](conformance/lib-node-timers-promises.ts) | `{ signal }` aborts; `setInterval` is an async iterator                      |
+| `Timeout` / `Immediate` handles: `ref` / `unref` / `hasRef` / `refresh` / `close` (also on intervals) | ✅ | [lib-node-timers-ref.ts](conformance/lib-node-timers-ref.ts) | Unref'ed timers don't keep the process alive |
+
+#### `node:perf_hooks`
+
+| API                                                                                    | Status | Probe                                                      | Notes                                       |
+| -------------------------------------------------------------------------------------- | :----: | ---------------------------------------------------------- | ------------------------------------------- |
+| `performance.now` / `timeOrigin` / `mark` / `measure` / `getEntries*` / `clearMarks`; global `performance` | ✅ | [lib-node-perf-hooks.ts](conformance/lib-node-perf-hooks.ts) | Monotonic milliseconds since process start |
+| `PerformanceObserver` (`entryTypes` / `type` + `buffered`, batched, sorted by `startTime`), `timerify`, `createHistogram`, `monitorEventLoopDelay`, `eventLoopUtilization` | ✅ | [lib-node-perf-observer.ts](conformance/lib-node-perf-observer.ts) | `eventLoopUtilization` is estimated from CPU time |
+
+#### `node:tty`
+
+| API          | Status | Probe                                                      | Notes                                    |
+| ------------ | :----: | ---------------------------------------------------------- | ---------------------------------------- |
+| `isatty(fd)` |   ✅    | [lib-node-perf-hooks.ts](conformance/lib-node-perf-hooks.ts) | Character-device check on fds 0–2        |
+| `ReadStream` / `WriteStream` (`columns`, `setRawMode`) | ❌ | — | Terminal sizes need non-portable syscalls |
+
+#### `node:constants` / `node:sys`
+
+| API                                       | Status | Probe                                                      | Notes                                                |
+| ----------------------------------------- | :----: | ---------------------------------------------------------- | ---------------------------------------------------- |
+| `node:constants` (`F_OK`, `SIGINT`, …)    |   ✅    | [lib-node-perf-hooks.ts](conformance/lib-node-perf-hooks.ts) | Deprecated upstream: `fs.constants` + `os.constants.signals` |
+| `node:sys`                                |   ✅    | —                                                          | Deprecated alias of `node:util`                      |
+
+#### `node:events`
+
+| API                                                                                                  | Status | Probe                                                          | Notes                                                                      |
+| ---------------------------------------------------------------------------------------------------- | :----: | -------------------------------------------------------------- | -------------------------------------------------------------------------- |
+| `EventEmitter`: `on` / `once` / `off` / `prepend*` / `emit` / `removeAllListeners` / `listenerCount` / `eventNames` / max listeners / `newListener`; unhandled `'error'` throws | ✅ | [lib-node-events.ts](conformance/lib-node-events.ts) | Listeners are called with any signature; removal by identity                |
+| `class X extends EventEmitter`                                                                       |   ✅    | [lib-node-events-extends.ts](conformance/lib-node-events-extends.ts) | The emitter is embedded; `this.emit` and inherited methods work           |
+| `events.once` (→ promise) / `events.on` (async iterator)                                             |   ✅    | [lib-node-events-once.ts](conformance/lib-node-events-once.ts) | `'error'` rejects `once`                                                   |
+| `EventTarget` / `Event` / `AbortController` / `AbortSignal` (`abort`, `timeout`, `any`, `throwIfAborted`) | ✅ | [lib-node-abort.ts](conformance/lib-node-abort.ts)            | Globals (also exported by `node:events`)                                   |
+| `errorMonitor`, `captureRejections` (option and global), `getMaxListeners` / `setMaxListeners` (static), `addAbortListener` | ✅ | [lib-node-events-extra.ts](conformance/lib-node-events-extra.ts) | Captures rejections of listeners that return a promise; async arrow listeners run inline (their `await`s don't yield to `emit`) |
+| Symbol event names other than `errorMonitor`, `EventEmitterAsyncResource`, `Symbol.for('nodejs.rejection')` | ❌ | — | Event names are strings |
+
+#### `node:stream`
+
+| API                                                                                                   | Status | Probe                                                                | Notes                                                                                        |
+| ----------------------------------------------------------------------------------------------------- | :----: | -------------------------------------------------------------------- | -------------------------------------------------------------------------------------------- |
+| `Readable` (`push`, `read`, `pause` / `resume`, `setEncoding`, `destroy`), `Readable.from`, `for await` | ✅    | [lib-node-stream-readable.ts](conformance/lib-node-stream-readable.ts) | Arrays, strings, Buffers and async generators as sources                                      |
+| `Writable` (`write` / `end` / callbacks, `final`, `'finish'`, write after end)                         |   ✅    | [lib-node-stream-writable.ts](conformance/lib-node-stream-writable.ts) | Strings become Buffers unless `decodeStrings: false` or `objectMode`                          |
+| `Transform` / `PassThrough` / `Duplex`, `pipe` chains, subclasses overriding `_transform` & co.        |   ✅    | [lib-node-stream-transform.ts](conformance/lib-node-stream-transform.ts) | Option methods (`transform`, `flush`, `write`, `final`, `read`) and `_`-overrides both work; `this` inside option methods is not the stream (use the callback) |
+| `pipeline` / `finished` / `stream/promises` / `stream/consumers` (`text`, `json`, `buffer`)           |   ✅    | [lib-node-stream-pipeline.ts](conformance/lib-node-stream-pipeline.ts) | Errors destroy the pipeline and reach the callback / rejection                               |
+| `Readable.toWeb` / `fromWeb`, `Writable.toWeb` / `fromWeb`, `Duplex.toWeb` / `fromWeb`, `compose` (Node and web streams) | ✅ | [lib-node-stream-web-bridge.ts](conformance/lib-node-stream-web-bridge.ts) | `toWeb` pauses the Node stream while the web queue is full |
+| Backpressure (`highWaterMark` beyond `write()`'s return value), `compose` with generator functions | ❌  | —                                                                    | Not implemented                                                                              |
+
+#### `node:stream/web`
+
+| API                                                                                                   | Status | Probe                                                                | Notes                                                                 |
+| ----------------------------------------------------------------------------------------------------- | :----: | -------------------------------------------------------------------- | --------------------------------------------------------------------- |
+| `ReadableStream` (underlying source `start` / `pull` / `cancel`, sync or async), `getReader()` → `read` / `releaseLock` / `cancel` / `closed`, `locked`, `cancel`, `tee`, `for await` / `values()`, `ReadableStream.from` | ✅ | [lib-node-stream-web.ts](conformance/lib-node-stream-web.ts) | Promise reactions run as microtasks on the event loop; an error ends `for await` with a throw |
+| `WritableStream` (sink `start` / `write` / `close` / `abort`), `getWriter()` → `write` / `close` / `abort` / `ready` / `closed` / `desiredSize` / `releaseLock`; controller `error` / `signal` | ✅ | [lib-node-stream-web.ts](conformance/lib-node-stream-web.ts) | Writes run one at a time; `ready` follows the queue's backpressure |
+| `TransformStream` (`transform` / `flush` / `start`, controller `enqueue` / `error` / `terminate`), `pipeThrough` / `pipeTo` (`preventClose` / `preventAbort` / `preventCancel` / `signal`) | ✅ | [lib-node-stream-web.ts](conformance/lib-node-stream-web.ts) | A transform waits until its readable side wants more |
+| `CountQueuingStrategy` / `ByteLengthQueuingStrategy`, `{ highWaterMark, size }` strategies             |   ✅    | [lib-node-stream-web.ts](conformance/lib-node-stream-web.ts)         |                                                                       |
+| `TextEncoderStream` / `TextDecoderStream` (characters split across chunks), `CompressionStream` / `DecompressionStream` (`gzip`, `deflate`, `deflate-raw`) | ✅ | [lib-node-stream-web-bridge.ts](conformance/lib-node-stream-web-bridge.ts) | Decompression decodes once the input ends |
+| BYOB readers (`getReader({ mode: 'byob' })` reads into a view), byte-stream controllers' `byobRequest`, transferring streams | ❌ | — | `getReader({ mode: 'byob' })` returns a default reader |
+
+#### `node:readline`
+
+| API                                                                                     | Status | Probe                                                                    | Notes                                                                   |
+| --------------------------------------------------------------------------------------- | :----: | ------------------------------------------------------------------------ | ----------------------------------------------------------------------- |
+| `createInterface` (`'line'` / `'close'`, `question(q, cb)`, `prompt`, `close`, `for await`) |   ✅    | [lib-node-readline.ts](conformance/lib-node-readline.ts)                 | Any readable stream as input (`process.stdin` included)                  |
+| `node:readline/promises` (`await rl.question(q)`)                                        |   ✅    | [lib-node-readline-promises.ts](conformance/lib-node-readline-promises.ts) |                                                                         |
+| `question(prompt)` (synchronous)                                                        |   ✅    | [lib-node-readline-question.ts](conformance/lib-node-readline-question.ts) | TypeNative extension (not in Node): used by the self-hosted compiler     |
+| `cursorTo` / `moveCursor` / `clearLine` / `clearScreenDown`                              |   ✅    | [lib-node-readline-cursor.ts](conformance/lib-node-readline-cursor.ts)   | ANSI escape sequences written to the stream; optional callback           |
+| `emitKeypressEvents`, `history`, `completer`                                            |   ❌    | —                                                                        | Need raw terminal mode (OS-specific syscalls)                            |
+
+#### `node:child_process`
+
+| API                                                                                              | Status | Probe                                                                      | Notes                                                                                     |
+| ------------------------------------------------------------------------------------------------ | :----: | -------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------- |
+| `execSync` / `execFileSync` / `spawnSync` (`encoding`, `input`, `cwd`, `env`, `shell`, `stdio: 'inherit'`) | ✅ | [lib-node-child-process-sync.ts](conformance/lib-node-child-process-sync.ts) | Buffers unless an encoding is given (as in Node); a non-zero exit throws with `status` / `stdout` / `stderr` |
+| `exec` / `execFile` (callbacks), `spawn` → `ChildProcess` (stdio streams, `'exit'` / `'close'`, `kill`); `promisify(exec)` | ✅ | [lib-node-child-process-async.ts](conformance/lib-node-child-process-async.ts) | `'close'` follows the end of the stdio streams being read; exit codes on `err.code`     |
+| `fork(modulePath, args, { env, cwd, silent })` → `send` / `'message'` / `disconnect` / `'disconnect'` / `connected`; in the child `process.send` / `process.on('message')` / `process.connected` / `process.disconnect` | ✅ | [lib-node-child-process-fork.ts](conformance/lib-node-child-process-fork.ts) | The child is this program run again (branch on `process.argv` / `process.send`), linked over loopback TCP; messages are structured clones (a superset of Node's default JSON) |
+| `detached`, `stdio` arrays beyond stdout, `serialization: 'advanced'` handle passing (`send(msg, socket)`), forking another file | ❌ | — | `detached` needs OS-specific process attributes; one binary holds one program |
+
+#### `node:cluster`
+
+| API                                                                                                   | Status | Probe                                                                | Notes                                                                 |
+| ----------------------------------------------------------------------------------------------------- | :----: | -------------------------------------------------------------------- | --------------------------------------------------------------------- |
+| `isPrimary` / `isWorker` / `isMaster`, `fork(env)`, `workers`, `worker`, `setupPrimary` / `settings`, `disconnect(cb)`, `SCHED_RR` / `schedulingPolicy`; events `'fork'` / `'online'` / `'listening'` / `'message'` / `'disconnect'` / `'exit'` | ✅ | [lib-node-cluster.ts](conformance/lib-node-cluster.ts) | Workers are this program run again with `NODE_UNIQUE_ID` set |
+| `Worker` (`id`, `process`, `send`, `'message'`, `disconnect`, `kill`, `isConnected`, `isDead`, `exitedAfterDisconnect`); `process.send` from workers | ✅ | [lib-node-cluster.ts](conformance/lib-node-cluster.ts) | |
+| Shared ports: `net` / `http` / `https` / `tls` servers in workers listen on one port (also `listen(0)`), connections round-robin | ✅ | [lib-node-cluster.ts](conformance/lib-node-cluster.ts) | The primary owns the listener and relays each connection to a worker's private loopback listener with the client's address (no handle passing) |
+| `SCHED_NONE` (OS-level balancing), `exclusive: true` listeners, dgram sockets in workers | ❌ | — | Everything goes through the primary |
+
+#### `node:diagnostics_channel`
+
+| API                                                                                  | Status | Probe                                                                        | Notes                         |
+| ------------------------------------------------------------------------------------ | :----: | ---------------------------------------------------------------------------- | ----------------------------- |
+| `channel` / `publish` / `subscribe` / `unsubscribe` / `hasSubscribers`               |   ✅    | [lib-node-diagnostics-channel.ts](conformance/lib-node-diagnostics-channel.ts) | Synchronous; shared by name   |
+| `tracingChannel` (`start` / `end` / `asyncStart` / `asyncEnd` / `error` channels, `subscribe` / `unsubscribe`, `traceSync` / `tracePromise` / `traceCallback`); `channel.bindStore` / `unbindStore` / `runStores` | ✅ | [lib-node-diagnostics-tracing.ts](conformance/lib-node-diagnostics-tracing.ts) | The context gets `result` / `error`; a struct context without those fields is copied into a record |
+
+#### `node:net`
+
+| API                                                                                                   | Status | Probe                                        | Notes                                                                                     |
+| ----------------------------------------------------------------------------------------------------- | :----: | -------------------------------------------- | ----------------------------------------------------------------------------------------- |
+| `createServer` / `Server` (`listen` forms incl. `{ port, host }` and Unix paths, `address()`, `close(cb)`, `getConnections`, `maxConnections`, `ref` / `unref`; `'listening'` / `'connection'` / `'close'` / `'error'`) | ✅ | [lib-node-net.ts](conformance/lib-node-net.ts) | A listening server keeps the process alive; `close()` emits `'close'` once its connections end |
+| `connect` / `createConnection` / `Socket` (a duplex stream: `write` / `end` / `'data'` / `'end'`, `setEncoding`, `remoteAddress` / `remotePort` / `localPort`, `setTimeout` + `'timeout'`, `setNoDelay`, `setKeepAlive`, `destroy`, `'close'(hadError)`) | ✅ | [lib-node-net.ts](conformance/lib-node-net.ts) | One goroutine reads the `net.Conn`; `allowHalfOpen: false` ends the socket after `'end'`, as in Node |
+| Node's errors (`connect ECONNREFUSED 127.0.0.1:80`, `EADDRINUSE`, `ECONNRESET`; `code` / `errno` / `syscall` / `address` / `port`) | ✅ | [lib-node-net.ts](conformance/lib-node-net.ts) |                                                                                           |
+| `isIP` / `isIPv4` / `isIPv6`                                                                           |   ✅    | [lib-node-net.ts](conformance/lib-node-net.ts) |                                                                                         |
+| `BlockList` (`addAddress` / `addRange` / `addSubnet` / `check` / `rules` / `isBlockList`) / `SocketAddress` (`parse`, `toJSON`) | ✅ | [lib-node-net-blocklist.ts](conformance/lib-node-net-blocklist.ts) | `net/netip`; IPv4-mapped IPv6 addresses match IPv4 rules, as in Node |
+| `net.Stream`, `get/setDefaultAutoSelectFamily(AttemptTimeout)`                                          |   ✅    | [lib-node-net-blocklist.ts](conformance/lib-node-net-blocklist.ts) | Go's dialer always races IPv4 / IPv6, so the settings are reported but not used |
+| IPC handle passing (`send(msg, socket)`)                                                               |   ❌    | —                                            | Needs file-descriptor passing over the IPC channel                                        |
+
+#### `node:dns`
+
+| API                                                                                    | Status | Probe                                        | Notes                                                                 |
+| -------------------------------------------------------------------------------------- | :----: | -------------------------------------------- | --------------------------------------------------------------------- |
+| `lookup` (`family`, `all`) and `dns/promises` / `dns.promises` `lookup`                 |   ✅    | [lib-node-dns.ts](conformance/lib-node-dns.ts) | Go's resolver; `getaddrinfo ENOTFOUND host` errors with `hostname`   |
+| `resolve` (rrtype) / `resolve4` / `resolve6` / `resolveCname` / `resolveMx` / `resolveTxt` / `resolveNs` / `resolveSrv` / `reverse` (callback and promise forms), `getServers` | ✅ | — | Implemented, not probed (needs a network); `getServers` reads `/etc/resolv.conf` |
+| `Resolver` class (callback and `dns/promises` forms: `setServers` / `getServers` / `setLocalAddress` / `cancel`, `timeout` option), module `setServers`, `lookupService` | ✅ | [lib-node-dns-resolver.ts](conformance/lib-node-dns-resolver.ts) | Go's pure resolver dialing the configured servers in turn; `ETIMEOUT` / `ECANCELLED`; services from `/etc/services` |
+| `resolveAny` / `resolveCaa` / `resolveNaptr` / `resolvePtr` / `resolveSoa`, the `ttl` option, `tries` |   ❌    | —                                            | Go's resolver does not expose these records or TTLs                   |
+
+#### `node:http` / `node:https`
+
+| API                                                                                                   | Status | Probe                                                          | Notes                                                                                        |
+| ----------------------------------------------------------------------------------------------------- | :----: | -------------------------------------------------------------- | -------------------------------------------------------------------------------------------- |
+| `createServer((req, res) => …)` / `'request'`; `IncomingMessage` (a Readable: `method`, `url`, `headers`, `headersDistinct`, `rawHeaders`, `httpVersion`, `socket.remoteAddress`) | ✅ | [lib-node-http-server.ts](conformance/lib-node-http-server.ts) | Go's `net/http` serves the connections; bodies stream into the request                       |
+| `ServerResponse` (a Writable: `statusCode`, `setHeader` / `getHeader` / `getHeaders` / `hasHeader` / `removeHeader` / `appendHeader`, `writeHead`, `write`, `end`, `headersSent`, `'finish'`) | ✅ | [lib-node-http-server.ts](conformance/lib-node-http-server.ts) | `end(data)` without earlier writes sends a `Content-Length`; `write()` streams a chunked body |
+| `request` / `get` (URL strings, `URL` objects, options: `hostname` / `port` / `path` / `method` / `headers` / `auth` / `timeout` / `signal` / `socketPath`); `ClientRequest` (`setHeader`, `write`, `end`, `destroy`, `'response'`, `'error'`, `'timeout'`) | ✅ | [lib-node-http-client.ts](conformance/lib-node-http-client.ts) | No redirects are followed and bodies are not decompressed, as in Node; `destroy()` before a response fails with `socket hang up` |
+| `STATUS_CODES` / `METHODS` / `maxHeaderSize` / `Agent` / `globalAgent`                                |   ✅    | [lib-node-http-server.ts](conformance/lib-node-http-server.ts) | `Agent` options are accepted; Go's transport pools connections                               |
+| `https.createServer({ key, cert })` / `https.request` / `https.get` (`ca`, `rejectUnauthorized`, `servername`, client `key` / `cert`) | ✅ | [lib-node-https.ts](conformance/lib-node-https.ts) | Certificate checks as in [node:tls](#nodetls)                                               |
+| `headers` values                                                                                      |   ✅    | [lib-node-http-client.ts](conformance/lib-node-http-client.ts) | Repeated headers are joined with `, ` (`; ` for `cookie`) — including `set-cookie`, which Node keeps as an array: use `headersDistinct['set-cookie']` |
+| Server `'upgrade'` / `'connect'` (`req, socket, head`) and client `'upgrade'` / `'connect'` events | ✅ | [lib-node-http-upgrade.ts](conformance/lib-node-http-upgrade.ts) | The server hijacks the connection; an upgrade nobody listens for is an ordinary request, an unhandled CONNECT closes the connection, as in Node |
+| `statusMessage` on responses we send, `'checkContinue'`, `Agent` socket pooling control, trailers we send |   ❌    | —                              | Go's `ResponseWriter` sends its standard reason phrases                                      |
+
+#### `node:http2`
+
+| API                                                                                                   | Status | Probe                                                                | Notes                                                                 |
+| ----------------------------------------------------------------------------------------------------- | :----: | -------------------------------------------------------------------- | --------------------------------------------------------------------- |
+| `createServer` (cleartext h2c) / `createSecureServer({ key, cert, allowHTTP1 })`; `'stream'` → `ServerHttp2Stream` (`respond`, `write` / `end`, `respondWithFile`, `close`, a Duplex over the request body) with `:method` / `:path` / `:scheme` / `:authority` headers | ✅ | [lib-node-http2.ts](conformance/lib-node-http2.ts), [lib-node-http2-secure.ts](conformance/lib-node-http2-secure.ts) | On `net/http`'s HTTP/2 (`http.Protocols`) |
+| Compatibility API: `(req, res)` handlers get `Http2ServerRequest` / `Http2ServerResponse` (`httpVersion` `'2.0'`, pseudo-headers in `req.headers`) | ✅ | [lib-node-http2.ts](conformance/lib-node-http2.ts) | The node:http objects |
+| `connect(authority, { ca, rejectUnauthorized, servername })` → `ClientHttp2Session` (`request`, `close`, `destroy`, `'connect'` / `'error'` / `'close'`, `alpnProtocol`, `encrypted`); `ClientHttp2Stream` (`'response'` with `:status`, body as a Readable, request bodies) | ✅ | [lib-node-http2.ts](conformance/lib-node-http2.ts), [lib-node-http2-secure.ts](conformance/lib-node-http2-secure.ts) | Connection failures error the session and cancel its streams (`ERR_HTTP2_STREAM_CANCEL`); request bodies are sent once the writable side ends |
+| `constants`, `getDefaultSettings` | ✅ | [lib-node-http2.ts](conformance/lib-node-http2.ts) | |
+| Server push, `ping`, `settings` / `goaway` / `altsvc`, `'session'` events, `getPackedSettings`, upgrades from HTTP/1 | ❌ | — | Go's standard library does not expose HTTP/2 frames |
+
+#### `node:tls`
+
+| API                                                                                                   | Status | Probe                                        | Notes                                                                                       |
+| ----------------------------------------------------------------------------------------------------- | :----: | -------------------------------------------- | ------------------------------------------------------------------------------------------- |
+| `createServer({ key, cert, ca, requestCert, ALPNProtocols, minVersion, maxVersion }, cb)` / `'secureConnection'` | ✅ | [lib-node-tls.ts](conformance/lib-node-tls.ts) | Handshakes run on the accept goroutine                                                    |
+| `connect` (`host`, `port`, `ca`, `servername`, `rejectUnauthorized`, client `key` / `cert`) / `'secureConnect'`; `TLSSocket` (`authorized`, `authorizationError`, `encrypted`, `alpnProtocol`, `getPeerCertificate`, `getProtocol`, `getCipher`) | ✅ | [lib-node-tls.ts](conformance/lib-node-tls.ts) | Node's verification codes: `DEPTH_ZERO_SELF_SIGNED_CERT`, `SELF_SIGNED_CERT_IN_CHAIN`, `UNABLE_TO_GET_ISSUER_CERT_LOCALLY`, `CERT_HAS_EXPIRED`, `ERR_TLS_CERT_ALTNAME_INVALID` |
+| `createSecureContext` / `getCiphers` / `DEFAULT_MIN_VERSION` / `DEFAULT_MAX_VERSION`                   |   ✅    | —                                            | Implemented, not probed; cipher names are Go's                                              |
+| `checkServerIdentity` (function and `connect` option)                                                  |   ✅    | [lib-node-tls-identity.ts](conformance/lib-node-tls-identity.ts) | Node's rules: one leftmost wildcard label, IP altnames, CN only without DNS altnames |
+| PFX / passphrase-protected keys, session resumption, `renegotiate`, `rootCertificates`                 |   ❌    | —                                     | Not implemented                                                                             |
+
+#### `node:dgram`
+
+| API                                                                                       | Status | Probe                                          | Notes                                         |
+| ----------------------------------------------------------------------------------------- | :----: | ---------------------------------------------- | --------------------------------------------- |
+| `createSocket('udp4' \| 'udp6' \| { type })`, `bind`, `send` (offset / length forms, callback), `'message'(msg, rinfo)`, `address`, `close`, `connect` / `disconnect` / `remoteAddress`, `ref` / `unref` | ✅ | [lib-node-dgram.ts](conformance/lib-node-dgram.ts) | `send` binds an unbound socket first, as in Node |
+| Multicast membership, `setBroadcast` / `setTTL` effects                                   |   ❌    | —                                              | Accepted without effect                       |
+
+#### `fetch`
+
+| API                                                                                                   | Status | Probe                                            | Notes                                                                                      |
+| ----------------------------------------------------------------------------------------------------- | :----: | ------------------------------------------------ | ------------------------------------------------------------------------------------------ |
+| `fetch(url \| Request, { method, headers, body, redirect, signal })`; `Response` (`status`, `ok`, `statusText`, `headers`, `url`, `redirected`, `text()` / `json()` / `bytes()` / `arrayBuffer()`, `clone()`, `Response.json` / `error` / `redirect`) | ✅ | [lib-node-fetch.ts](conformance/lib-node-fetch.ts) | Follows redirects (`manual` / `error` too); gzip bodies are decompressed; failures reject with `TypeError('fetch failed')` whose `cause` is the system error; aborts reject with `AbortError` |
+| `Headers` (`get` / `set` / `append` / `has` / `delete` / `forEach` / `entries` / `getSetCookie`, `for...of`) / `Request` |   ✅    | [lib-node-fetch.ts](conformance/lib-node-fetch.ts) | Names are lower-cased and iterated in sorted order                                         |
+| Streaming bodies: `response.body` / `request.body` as `ReadableStream`s, `ReadableStream` request bodies (`duplex: 'half'`), `clone()` tees the body | ✅ | [lib-node-fetch-stream.ts](conformance/lib-node-fetch-stream.ts) | Network bodies are read a chunk per pull |
+| `Blob` / `FormData` bodies (multipart encoding), `blob()` / `formData()` (multipart and urlencoded) |   ✅    | [lib-node-blob.ts](conformance/lib-node-blob.ts), [lib-node-fetch-stream.ts](conformance/lib-node-fetch-stream.ts) | |
+| The Fetch standard's bad-port list (also on redirects)                                                |   ✅    | [lib-node-fetch-bad-port.ts](conformance/lib-node-fetch-bad-port.ts) | `TypeError: fetch failed` with cause `bad port`                                            |
+
+#### `node:async_hooks`
+
+| API                                                                                                  | Status | Probe                                                      | Notes                                                                                                   |
+| ---------------------------------------------------------------------------------------------------- | :----: | ---------------------------------------------------------- | ------------------------------------------------------------------------------------------------------- |
+| `AsyncLocalStorage` (`run`, `getStore`, `enterWith`, `exit`, `disable`, static `bind` / `snapshot`)    |   ✅    | [lib-node-async-hooks.ts](conformance/lib-node-async-hooks.ts) | The store follows timers, `setImmediate`, `nextTick`, microtasks, promise callbacks, `await`, async function bodies, fs / dns callbacks; streams, sockets and servers emit in the context they were created / listened in |
+| `AsyncResource` (`runInAsyncScope`, `bind`, `asyncId`, static `bind`)                                 |   ✅    | [lib-node-async-hooks.ts](conformance/lib-node-async-hooks.ts) | Captures the context it is created in                                                                   |
+| `createHook` callbacks (`init` / `before` / `after` / `destroy`), real `executionAsyncId` / `triggerAsyncId` |   ❌    | —                                                  | `createHook` is accepted but never calls back; ids are always `1` / `0`                                 |
+
+#### `node:test`
+
+| API                                                                                                  | Status | Probe                                                   | Notes                                                                                                   |
+| ---------------------------------------------------------------------------------------------------- | :----: | ------------------------------------------------------- | ------------------------------------------------------------------------------------------------------- |
+| `test` / `it` / `describe` / `suite` (+ `.skip` / `.todo` / `.only`; `skip` / `todo` / `timeout` options); sync, async and `done`-callback tests | ✅ | [lib-node-test.ts](conformance/lib-node-test.ts) | Tests run one after another once the main module has finished, as in Node |
+| `before` / `after` / `beforeEach` / `afterEach` (file and suite level, `t.before` & co.)              |   ✅    | [lib-node-test.ts](conformance/lib-node-test.ts)        | Node's order: outer `beforeEach` first, inner `afterEach` first                                          |
+| `TestContext`: `t.test` subtests, `t.skip`, `t.todo`, `t.diagnostic`, `t.plan`, `t.name`, `t.fullName`, `t.signal`, `t.mock` |   ✅    | [lib-node-test.ts](conformance/lib-node-test.ts) |                                                                                       |
+| Reporting: TAP (Node's default when stdout is not a terminal) / spec (on a terminal); `tests` / `suites` / `pass` / `fail` / `cancelled` / `skipped` / `todo` counters; exit code 1 on failure | ✅ | [lib-node-test-fail.ts](conformance/lib-node-test-fail.ts) | Same layout as Node, without `location` / `stack` (a native binary has no source positions); timeouts count as cancelled |
+| `mock.fn(original?, implementation?)`; `fn.mock.calls` / `callCount()` / `mockImplementation(Once)` / `resetCalls()` / `restore()` |   ✅    | [lib-node-test.ts](conformance/lib-node-test.ts) | The mock has the original's Go function type                                                          |
+| `t.assert` (`node:assert`'s functions, counted by `t.plan`) and `mock.timers` (`enable({ apis, now })`, `tick`, `runAll`, `setTime`, `reset`; `setTimeout` / `setInterval` / `setImmediate` / `Date`) | ✅ | [lib-node-test-mock-timers.ts](conformance/lib-node-test-mock-timers.ts) | Mocked timers do not keep the process alive; `t.mock` timers reset after each test |
+| `mock.method` / `mock.getter` / `mock.setter`                                                         |   ❌    | —                                   | Go methods cannot be replaced at runtime                                                                 |
+| Snapshots, coverage, `--test` / `--test-reporter` / `--test-only` flags, `run()`                      |   ❌    | —                                   | Not implemented (`only` runs everything, like Node without `--test-only`)                               |
+
+#### `node:worker_threads`
+
+| API                                                                                                  | Status | Probe                                                              | Notes                                                                                                   |
+| ---------------------------------------------------------------------------------------------------- | :----: | ------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------- |
+| `Worker` (`workerData`, `argv`, `env` / `SHARE_ENV`; `postMessage`, `'online'` / `'message'` / `'error'` / `'exit'`, `terminate()`, `threadId`, `ref` / `unref`); `isMainThread`, `parentPort`, `workerData`, `threadId` | ✅ | [lib-node-worker-threads.ts](conformance/lib-node-worker-threads.ts) | A worker re-runs the current program as a child process (an isolate of its own, as in Node) linked over loopback TCP; branch on `isMainThread` |
+| Messages: structured clone of JSON-like values, Buffers (arriving as `Uint8Array`s), `Map`, `Set`, `Date`, `bigint`, errors |   ✅    | [lib-node-worker-threads.ts](conformance/lib-node-worker-threads.ts) | Functions throw `DataCloneError`                                                                    |
+| Uncaught exceptions in a worker / `terminate()`                                                        |   ✅    | [lib-node-worker-errors.ts](conformance/lib-node-worker-errors.ts) | `'error'` with the message, then exit code `1`                                                          |
+| `MessageChannel` / `MessagePort` (`postMessage`, `on('message')`, `onmessage`, `start`, `close`, `ref` / `unref`), `receiveMessageOnPort`, `BroadcastChannel`, `get/setEnvironmentData` | ✅ | [lib-node-worker-threads.ts](conformance/lib-node-worker-threads.ts) | Channels and broadcast channels work within one process (ports can't be transferred to workers)     |
+| Workers for another file / `eval: true`, transferring ports, `SharedArrayBuffer` / `Atomics`, `resourceLimits`, worker `stdout: true` streams |   ❌    | —                                     | One binary holds one program; memory is not shared between processes                                  |
+
+#### `node:sqlite`
+
+SQLite comes from [ncruces/go-sqlite3](https://github.com/ncruces/go-sqlite3): SQLite compiled
+to Wasm and translated to Go, so programs need no cgo and still cross-compile. The npm package
+ships the driver in [govendor/](govendor/) (`npm run vendor:go` updates it), so builds need no
+network; it adds about 10 MB to a binary. Rows are records: `row.name`, `row as Row` and
+`rows as Row[]` all work.
+
+| API | Status | Probe | Notes |
+| --- | :----: | ----- | ----- |
+| `new DatabaseSync(path, options)` (`:memory:`, files, `file:` URIs), `open` / `close` / `isOpen` / `isTransaction` / `location()`, `exec` | ✅ | [lib-node-sqlite.ts](conformance/lib-node-sqlite.ts) | `open: false` defers to `open()` |
+| `prepare(sql, options)`; `StatementSync#run` (`{ changes, lastInsertRowid }`) / `get` / `all` / `iterate` (`for…of`, `next()`) | ✅ | [lib-node-sqlite.ts](conformance/lib-node-sqlite.ts) | Rows are objects keyed by column name; `get()` without a row is `undefined` |
+| Parameters: anonymous `?`, named `:x` / `$x` / `@x`, bare names (`{ x }`); values `null`, number (REAL), bigint (INTEGER), string, boolean (1 / 0), `Uint8Array` / Buffer | ✅ | [lib-node-sqlite.ts](conformance/lib-node-sqlite.ts) | Results: INTEGER → number (bigint with `readBigInts`), REAL → number, TEXT → string, BLOB → `Uint8Array`, NULL → `null` |
+| Options `readOnly`, `enableForeignKeyConstraints` (on by default), `enableDoubleQuotedStringLiterals`, `timeout`, `readBigInts`, `returnArrays`, `allowBareNamedParameters`, `allowUnknownNamedParameters`, `defensive`, `limits` | ✅ | [lib-node-sqlite-options.ts](conformance/lib-node-sqlite-options.ts) | `db.limits.x = n` sets a limit; `Infinity` restores the maximum |
+| `columns()`, `sourceSQL`, `expandedSQL`, `setReadBigInts` / `setReturnArrays` / `setAllowBareNamedParameters` / `setAllowUnknownNamedParameters`, `enableDefensive` | ✅ | [lib-node-sqlite-options.ts](conformance/lib-node-sqlite-options.ts) | |
+| `createTagStore()` (`` sql.get`… ${x}` `` / `all` / `run` / `iterate`, `size`, `capacity`, `clear`) | ✅ | [lib-node-sqlite-options.ts](conformance/lib-node-sqlite-options.ts) | One cached statement per template, least recently used out first |
+| `function(name, options, fn)` (`deterministic`, `directOnly`, `varargs`, `useBigIntArguments`), `aggregate(name, { start, step, result, inverse })` (window functions) | ✅ | [lib-node-sqlite-functions.ts](conformance/lib-node-sqlite-functions.ts) | A throw inside the callback is rethrown by the statement |
+| `setAuthorizer(callback)`, `constants` (`SQLITE_OK` / `DENY` / `IGNORE`, action codes, `SQLITE_CHANGESET_*`) | ✅ | [lib-node-sqlite-functions.ts](conformance/lib-node-sqlite-functions.ts) | |
+| Errors: SQLite's message with `code: 'ERR_SQLITE_ERROR'`, `errcode` (extended result code), `errstr`; `ERR_INVALID_STATE` / `ERR_OUT_OF_RANGE` / `ERR_INVALID_ARG_VALUE` | ✅ | [lib-node-sqlite-errors.ts](conformance/lib-node-sqlite-errors.ts) | Same messages as Node 24 |
+| `backup(db, path, { source, rate, progress })` | ✅ | [lib-node-sqlite-errors.ts](conformance/lib-node-sqlite-errors.ts) | Copies `rate` pages per event-loop turn; resolves with the page count |
+| `loadExtension` / `enableLoadExtension` | ❌ | — | SQLite runs as Wasm inside the program; native extensions can't load |
+| `createSession` / `applyChangeset` | ❌ | — | The bundled SQLite build has no session extension |
+| `serialize` / `deserialize` | ❌ | — | The driver has no `sqlite3_serialize` binding |
+| `undefined` as a parameter value, `[Object: null prototype]` rows | ❌ | — | `undefined` and `null` are both `nil` (binds NULL instead of throwing); rows print as plain objects |
+| Finalizing a statement when it is garbage-collected | ❌ | — | Statements live until `db.close()` (Go has no hook that is safe here): re-preparing in a loop holds every copy until then; reuse statements or `createTagStore()` |
+
+#### `node:inspector`
+
+| API | Status | Probe | Notes |
+| --- | :----: | ----- | ----- |
+| Debugger / profiler sessions (`Session`, `open`, `url`) | ❌ | — | Speaks the inspector protocol of a JavaScript engine; a native binary has none |
+
+#### `node:repl`
+
+| API | Status | Probe | Notes |
+| --- | :----: | ----- | ----- |
+| `start` / `REPLServer` | ❌ | — | Evaluates JavaScript at runtime; needs a JavaScript engine |
+
+#### `node:vm`
+
+| API | Status | Probe | Notes |
+| --- | :----: | ----- | ----- |
+| `Script` / `runInContext` / `createContext` / `compileFunction` & co. | ❌ | — | Compiles and runs JavaScript code at runtime; needs a JavaScript engine |
+
+#### `node:v8`
+
+| API | Status | Probe | Notes |
+| --- | :----: | ----- | ----- |
+| Heap statistics / snapshots, `serialize` / `deserialize`, flags | ❌ | — | V8 internals; there is no V8 in a native binary |
+
+#### `node:wasi`
+
+| API | Status | Probe | Notes |
+| --- | :----: | ----- | ----- |
+| `WASI` | ❌ | — | Runs WebAssembly modules; the generated program has no Wasm runtime |
+
+#### `node:sea`
+
+| API | Status | Probe | Notes |
+| --- | :----: | ----- | ----- |
+| `isSea` / `getAsset` / `getRawAsset` | ❌ | — | Single-executable-application assets; TypeNative already produces a native binary |
+
+#### `node:trace_events`
+
+| API | Status | Probe | Notes |
+| --- | :----: | ----- | ----- |
+| `createTracing` / `getEnabledCategories` | ❌ | — | V8 / Node trace categories; no native equivalent |
+
+#### `node:module`
+
+| API | Status | Probe | Notes |
+| --- | :----: | ----- | ----- |
+| `createRequire` / `register` / `builtinModules` / `findPackageJSON` & co. | ❌ | — | Loader hooks for a JavaScript runtime; imports are resolved at compile time |
+
+#### `node:test/reporters`
+
+| API | Status | Probe | Notes |
+| --- | :----: | ----- | ----- |
+| `tap` / `spec` / `dot` / `junit` / `lcov` | ❌ | — | Reporters consume `run()`'s event stream, and `run()` runs test files as separate processes; one binary holds one program (see [test](#nodetest)) |
+
+#### `node:domain`
+
+| API | Status | Probe | Notes |
+| --- | :----: | ----- | ----- |
+| `create` / `Domain` | ❌ | — | Deprecated upstream |
 
 ### Go bridges (`go:*`)
 
-| Module                              | Status | Probe                                                  | Notes                                                                         |
-| ----------------------------------- | :----: | ------------------------------------------------------ | ----------------------------------------------------------------------------- |
-| `go:fmt` (`Println`, `Sprintf`)     |   ✅    | [syntax-import-go.ts](conformance/syntax-import-go.ts) | Direct Go package access                                                      |
-| `go:strings` (`ToUpper`, `ToLower`) |   ✅    | [syntax-import-go.ts](conformance/syntax-import-go.ts) | Direct Go package access                                                      |
-| `go:strconv` (`FormatBool`)         |   ✅    | [syntax-import-go.ts](conformance/syntax-import-go.ts) | Direct Go package access                                                      |
-| `go:archive/tar`                    |   ❌    | —                                                      | tar archive read/write; not declared in types, no probe yet                   |
-| `go:archive/zip`                    |   ❌    | —                                                      | ZIP archive read/write; not declared in types, no probe yet                   |
-| `go:bufio`                          |   ❌    | —                                                      | Buffered I/O; not declared in types, no probe yet                             |
-| `go:bytes`                          |   ❌    | —                                                      | Byte-slice utilities; not declared in types, no probe yet                     |
-| `go:cmp`                            |   ❌    | —                                                      | Ordered comparison primitives; not declared in types, no probe yet            |
-| `go:compress/bzip2`                 |   ❌    | —                                                      | bzip2 decompression (read-only); not declared in types, no probe yet          |
-| `go:compress/flate`                 |   ❌    | —                                                      | DEFLATE compression; not declared in types, no probe yet                      |
-| `go:compress/gzip`                  |   ❌    | —                                                      | gzip read/write; not declared in types, no probe yet                          |
-| `go:compress/lzw`                   |   ❌    | —                                                      | LZW compression (GIF/PDF/TIFF); not declared in types, no probe yet           |
-| `go:compress/zlib`                  |   ❌    | —                                                      | zlib read/write; not declared in types, no probe yet                          |
-| `go:container/heap`                 |   ❌    | —                                                      | Heap / priority queue; not declared in types, no probe yet                    |
-| `go:container/list`                 |   ❌    | —                                                      | Doubly linked list; not declared in types, no probe yet                       |
-| `go:container/ring`                 |   ❌    | —                                                      | Circular list; not declared in types, no probe yet                            |
-| `go:context`                        |   ❌    | —                                                      | Cancellation and deadlines; not declared in types, no probe yet               |
-| `go:crypto`                         |   ❌    | —                                                      | Crypto constants and algorithm selection; not declared in types, no probe yet |
-| `go:crypto/aes`                     |   ❌    | —                                                      | AES encryption; not declared in types, no probe yet                           |
-| `go:crypto/cipher`                  |   ❌    | —                                                      | Block cipher modes (GCM, CBC, CTR); not declared in types, no probe yet       |
-| `go:crypto/des`                     |   ❌    | —                                                      | DES / triple DES (deprecated); not declared in types, no probe yet            |
-| `go:crypto/dsa`                     |   ❌    | —                                                      | DSA signatures (deprecated); not declared in types, no probe yet              |
-| `go:crypto/ecdh`                    |   ❌    | —                                                      | ECDH key exchange; not declared in types, no probe yet                        |
-| `go:crypto/ecdsa`                   |   ❌    | —                                                      | ECDSA signatures; not declared in types, no probe yet                         |
-| `go:crypto/ed25519`                 |   ❌    | —                                                      | Ed25519 signatures; not declared in types, no probe yet                       |
-| `go:crypto/elliptic`                |   ❌    | —                                                      | Elliptic curves (legacy; use ecdh/ecdsa); not declared in types, no probe yet |
-| `go:crypto/fips140`                 |   ❌    | —                                                      | FIPS 140-3 mode controls; not declared in types, no probe yet                 |
-| `go:crypto/hkdf`                    |   ❌    | —                                                      | HKDF key derivation; not declared in types, no probe yet                      |
-| `go:crypto/hmac`                    |   ❌    | —                                                      | HMAC keyed hashing; not declared in types, no probe yet                       |
-| `go:crypto/hpke`                    |   ❌    | —                                                      | HPKE encryption (RFC 9180); not declared in types, no probe yet               |
-| `go:crypto/md5`                     |   ❌    | —                                                      | MD5 hash; not declared in types, no probe yet                                 |
-| `go:crypto/mlkem`                   |   ❌    | —                                                      | ML-KEM post-quantum key encapsulation; not declared in types, no probe yet    |
-| `go:crypto/mlkem/mlkemtest`         |   ❌    | —                                                      | ML-KEM test vectors helper; not declared in types, no probe yet               |
-| `go:crypto/pbkdf2`                  |   ❌    | —                                                      | PBKDF2 key derivation; not declared in types, no probe yet                    |
-| `go:crypto/rand`                    |   ❌    | —                                                      | Cryptographically secure random bytes; not declared in types, no probe yet    |
-| `go:crypto/rc4`                     |   ❌    | —                                                      | RC4 stream cipher (deprecated); not declared in types, no probe yet           |
-| `go:crypto/rsa`                     |   ❌    | —                                                      | RSA signatures / encryption; not declared in types, no probe yet              |
-| `go:crypto/sha1`                    |   ❌    | —                                                      | SHA-1 hash; not declared in types, no probe yet                               |
-| `go:crypto/sha256`                  |   ❌    | —                                                      | SHA-224 / SHA-256 hashes; not declared in types, no probe yet                 |
-| `go:crypto/sha3`                    |   ❌    | —                                                      | SHA-3 / SHAKE hashes; not declared in types, no probe yet                     |
-| `go:crypto/sha512`                  |   ❌    | —                                                      | SHA-384 / SHA-512 family hashes; not declared in types, no probe yet          |
-| `go:crypto/subtle`                  |   ❌    | —                                                      | Constant-time comparison primitives; not declared in types, no probe yet      |
-| `go:crypto/tls`                     |   ❌    | —                                                      | TLS client / server; not declared in types, no probe yet                      |
-| `go:crypto/x509`                    |   ❌    | —                                                      | X.509 certificates and revocation; not declared in types, no probe yet        |
-| `go:crypto/x509/pkix`               |   ❌    | —                                                      | X.509 ASN.1/PKIX structures; not declared in types, no probe yet              |
-| `go:database/sql`                   |   ❌    | —                                                      | SQL database access; not declared in types, no probe yet                      |
-| `go:database/sql/driver`            |   ❌    | —                                                      | SQL driver interfaces; not declared in types, no probe yet                    |
-| `go:debug/buildinfo`                |   ❌    | —                                                      | Build info from executables; not declared in types, no probe yet              |
-| `go:debug/dwarf`                    |   ❌    | —                                                      | DWARF debug info parsing; not declared in types, no probe yet                 |
-| `go:debug/elf`                      |   ❌    | —                                                      | ELF object files; not declared in types, no probe yet                         |
-| `go:debug/gosym`                    |   ❌    | —                                                      | Go symbol tables; not declared in types, no probe yet                         |
-| `go:debug/macho`                    |   ❌    | —                                                      | Mach-O object files; not declared in types, no probe yet                      |
-| `go:debug/pe`                       |   ❌    | —                                                      | PE (Windows) object files; not declared in types, no probe yet                |
-| `go:debug/plan9obj`                 |   ❌    | —                                                      | Plan 9 object files; not declared in types, no probe yet                      |
-| `go:embed`                          |   ❌    | —                                                      | Files embedded via //go:embed; not declared in types, no probe yet            |
-| `go:encoding`                       |   ❌    | —                                                      | Shared encoding interfaces; not declared in types, no probe yet               |
-| `go:encoding/ascii85`               |   ❌    | —                                                      | ascii85 encoding; not declared in types, no probe yet                         |
-| `go:encoding/asn1`                  |   ❌    | —                                                      | ASN.1 DER encoding; not declared in types, no probe yet                       |
-| `go:encoding/base32`                |   ❌    | —                                                      | base32 encoding; not declared in types, no probe yet                          |
-| `go:encoding/base64`                |   ❌    | —                                                      | base64 encoding; not declared in types, no probe yet                          |
-| `go:encoding/binary`                |   ❌    | —                                                      | Binary packing / varints; not declared in types, no probe yet                 |
-| `go:encoding/csv`                   |   ❌    | —                                                      | CSV read/write; not declared in types, no probe yet                           |
-| `go:encoding/gob`                   |   ❌    | —                                                      | Go binary serialization; not declared in types, no probe yet                  |
-| `go:encoding/hex`                   |   ❌    | —                                                      | hex encoding; not declared in types, no probe yet                             |
-| `go:encoding/json`                  |   ❌    | —                                                      | JSON encode/decode; not declared in types, no probe yet                       |
-| `go:encoding/pem`                   |   ❌    | —                                                      | PEM encoding; not declared in types, no probe yet                             |
-| `go:encoding/xml`                   |   ❌    | —                                                      | XML read/write; not declared in types, no probe yet                           |
-| `go:errors`                         |   ❌    | —                                                      | Error creation / wrapping / inspection; not declared in types, no probe yet   |
-| `go:expvar`                         |   ❌    | —                                                      | Public process variables; not declared in types, no probe yet                 |
-| `go:flag`                           |   ❌    | —                                                      | Command-line flag parsing; not declared in types, no probe yet                |
-| `go:go/ast`                         |   ❌    | —                                                      | Go syntax tree; not declared in types, no probe yet                           |
-| `go:go/build`                       |   ❌    | —                                                      | Go package build metadata; not declared in types, no probe yet                |
-| `go:go/build/constraint`            |   ❌    | —                                                      | Build-tag constraint parsing; not declared in types, no probe yet             |
-| `go:go/constant`                    |   ❌    | —                                                      | Untyped constant values; not declared in types, no probe yet                  |
-| `go:go/doc`                         |   ❌    | —                                                      | Go doc extraction; not declared in types, no probe yet                        |
-| `go:go/doc/comment`                 |   ❌    | —                                                      | Doc comment parse/print; not declared in types, no probe yet                  |
-| `go:go/format`                      |   ❌    | —                                                      | Go source formatting; not declared in types, no probe yet                     |
-| `go:go/importer`                    |   ❌    | —                                                      | Export-data type importer; not declared in types, no probe yet                |
-| `go:go/parser`                      |   ❌    | —                                                      | Go source parser; not declared in types, no probe yet                         |
-| `go:go/printer`                     |   ❌    | —                                                      | Go AST printer; not declared in types, no probe yet                           |
-| `go:go/scanner`                     |   ❌    | —                                                      | Go tokenizer; not declared in types, no probe yet                             |
-| `go:go/token`                       |   ❌    | —                                                      | Go tokens / positions; not declared in types, no probe yet                    |
-| `go:go/types`                       |   ❌    | —                                                      | Go type checker; not declared in types, no probe yet                          |
-| `go:go/version`                     |   ❌    | —                                                      | Go version comparison; not declared in types, no probe yet                    |
-| `go:hash`                           |   ❌    | —                                                      | Hash function interface; not declared in types, no probe yet                  |
-| `go:hash/adler32`                   |   ❌    | —                                                      | Adler-32 checksum; not declared in types, no probe yet                        |
-| `go:hash/crc32`                     |   ❌    | —                                                      | CRC-32 checksum; not declared in types, no probe yet                          |
-| `go:hash/crc64`                     |   ❌    | —                                                      | CRC-64 checksum; not declared in types, no probe yet                          |
-| `go:hash/fnv`                       |   ❌    | —                                                      | FNV-1 / FNV-1a hash; not declared in types, no probe yet                      |
-| `go:hash/maphash`                   |   ❌    | —                                                      | Seeded string hashing; not declared in types, no probe yet                    |
-| `go:html`                           |   ❌    | —                                                      | HTML escaping; not declared in types, no probe yet                            |
-| `go:html/template`                  |   ❌    | —                                                      | HTML templating (auto-escaped); not declared in types, no probe yet           |
-| `go:image`                          |   ❌    | —                                                      | 2D image interface; not declared in types, no probe yet                       |
-| `go:image/color`                    |   ❌    | —                                                      | Color types; not declared in types, no probe yet                              |
-| `go:image/color/palette`            |   ❌    | —                                                      | Standard color palettes; not declared in types, no probe yet                  |
-| `go:image/draw`                     |   ❌    | —                                                      | Image compositing; not declared in types, no probe yet                        |
-| `go:image/gif`                      |   ❌    | —                                                      | GIF decode/encode; not declared in types, no probe yet                        |
-| `go:image/jpeg`                     |   ❌    | —                                                      | JPEG decode/encode; not declared in types, no probe yet                       |
-| `go:image/png`                      |   ❌    | —                                                      | PNG decode/encode; not declared in types, no probe yet                        |
-| `go:index/suffixarray`              |   ❌    | —                                                      | Suffix-array substring search; not declared in types, no probe yet            |
-| `go:io`                             |   ❌    | —                                                      | Core I/O interfaces (Reader/Writer); not declared in types, no probe yet      |
-| `go:io/fs`                          |   ❌    | —                                                      | Filesystem abstraction; not declared in types, no probe yet                   |
-| `go:io/ioutil`                      |   ❌    | —                                                      | Deprecated I/O helpers (Go 1.16); not declared in types, no probe yet         |
-| `go:iter`                           |   ❌    | —                                                      | Range-over-func iterator types; not declared in types, no probe yet           |
-| `go:log`                            |   ❌    | —                                                      | Leveled logging to stderr; not declared in types, no probe yet                |
-| `go:log/slog`                       |   ❌    | —                                                      | Structured logging; not declared in types, no probe yet                       |
-| `go:log/syslog`                     |   ❌    | —                                                      | syslog client (Unix only); not declared in types, no probe yet                |
-| `go:maps`                           |   ❌    | —                                                      | Generic map utilities; not declared in types, no probe yet                    |
-| `go:math`                           |   ❌    | —                                                      | Float math functions; not declared in types, no probe yet                     |
-| `go:math/big`                       |   ❌    | —                                                      | Arbitrary-precision arithmetic; not declared in types, no probe yet           |
-| `go:math/bits`                      |   ❌    | —                                                      | Bit counting / manipulation; not declared in types, no probe yet              |
-| `go:math/cmplx`                     |   ❌    | —                                                      | Complex-number math; not declared in types, no probe yet                      |
-| `go:math/rand`                      |   ❌    | —                                                      | Pseudo-random generator (legacy); not declared in types, no probe yet         |
-| `go:math/rand/v2`                   |   ❌    | —                                                      | Pseudo-random generator (v2); not declared in types, no probe yet             |
-| `go:mime`                           |   ❌    | —                                                      | MIME type lookup; not declared in types, no probe yet                         |
-| `go:mime/multipart`                 |   ❌    | —                                                      | multipart/form-data parsing; not declared in types, no probe yet              |
-| `go:mime/quotedprintable`           |   ❌    | —                                                      | quoted-printable encoding; not declared in types, no probe yet                |
-| `go:net`                            |   ❌    | —                                                      | Network I/O (TCP/UDP/Unix sockets); not declared in types, no probe yet       |
-| `go:net/http`                       |   ❌    | —                                                      | HTTP client / server; not declared in types, no probe yet                     |
-| `go:net/http/cgi`                   |   ❌    | —                                                      | CGI handler support; not declared in types, no probe yet                      |
-| `go:net/http/cookiejar`             |   ❌    | —                                                      | HTTP cookie storage; not declared in types, no probe yet                      |
-| `go:net/http/fcgi`                  |   ❌    | —                                                      | FastCGI server; not declared in types, no probe yet                           |
-| `go:net/http/httptest`              |   ❌    | —                                                      | HTTP test helpers; not declared in types, no probe yet                        |
-| `go:net/http/httptrace`             |   ❌    | —                                                      | HTTP request tracing; not declared in types, no probe yet                     |
-| `go:net/http/httputil`              |   ❌    | —                                                      | HTTP utilities (reverse proxy); not declared in types, no probe yet           |
-| `go:net/http/pprof`                 |   ❌    | —                                                      | Profiling endpoints over HTTP; not declared in types, no probe yet            |
-| `go:net/mail`                       |   ❌    | —                                                      | RFC 5322 address parsing; not declared in types, no probe yet                 |
-| `go:net/netip`                      |   ❌    | —                                                      | IP address / prefix types; not declared in types, no probe yet                |
-| `go:net/rpc`                        |   ❌    | —                                                      | Go RPC; not declared in types, no probe yet                                   |
-| `go:net/rpc/jsonrpc`                |   ❌    | —                                                      | JSON-RPC codec for net/rpc; not declared in types, no probe yet               |
-| `go:net/smtp`                       |   ❌    | —                                                      | SMTP client; not declared in types, no probe yet                              |
-| `go:net/textproto`                  |   ❌    | —                                                      | Text-based protocol helpers; not declared in types, no probe yet              |
-| `go:net/url`                        |   ❌    | —                                                      | URL parsing / building; not declared in types, no probe yet                   |
-| `go:os`                             |   ❌    | —                                                      | OS functions (files, env, process); not declared in types, no probe yet       |
-| `go:os/exec`                        |   ❌    | —                                                      | External command execution; not declared in types, no probe yet               |
-| `go:os/signal`                      |   ❌    | —                                                      | OS signal handling; not declared in types, no probe yet                       |
-| `go:os/user`                        |   ❌    | —                                                      | User / group lookup; not declared in types, no probe yet                      |
-| `go:path`                           |   ❌    | —                                                      | Slash-separated path utilities; not declared in types, no probe yet           |
-| `go:path/filepath`                  |   ❌    | —                                                      | OS-specific file paths; not declared in types, no probe yet                   |
-| `go:plugin`                         |   ❌    | —                                                      | Go plugin loading (cgo; Linux/macOS/BSD); not declared in types, no probe yet |
-| `go:reflect`                        |   ❌    | —                                                      | Runtime reflection; not declared in types, no probe yet                       |
-| `go:regexp`                         |   ❌    | —                                                      | Regular expressions (RE2); not declared in types, no probe yet                |
-| `go:regexp/syntax`                  |   ❌    | —                                                      | Regex syntax parsing; not declared in types, no probe yet                     |
-| `go:runtime`                        |   ❌    | —                                                      | Runtime introspection (GC, goroutines); not declared in types, no probe yet   |
-| `go:runtime/coverage`               |   ❌    | —                                                      | Coverage counter writing; not declared in types, no probe yet                 |
-| `go:runtime/debug`                  |   ❌    | —                                                      | Debug controls (stack dump, GC tuning); not declared in types, no probe yet   |
-| `go:runtime/metrics`                |   ❌    | —                                                      | Runtime metrics; not declared in types, no probe yet                          |
-| `go:runtime/pprof`                  |   ❌    | —                                                      | CPU / memory profiling; not declared in types, no probe yet                   |
-| `go:runtime/race`                   |   ❌    | —                                                      | Race detector interaction; not declared in types, no probe yet                |
-| `go:runtime/trace`                  |   ❌    | —                                                      | Execution tracing; not declared in types, no probe yet                        |
-| `go:slices`                         |   ❌    | —                                                      | Generic slice utilities; not declared in types, no probe yet                  |
-| `go:sort`                           |   ❌    | —                                                      | Sorting; not declared in types, no probe yet                                  |
-| `go:structs`                        |   ❌    | —                                                      | Struct layout annotations; not declared in types, no probe yet                |
-| `go:sync`                           |   ❌    | —                                                      | Sync primitives (Mutex, WaitGroup); not declared in types, no probe yet       |
-| `go:sync/atomic`                    |   ❌    | —                                                      | Atomic memory operations; not declared in types, no probe yet                 |
-| `go:syscall`                        |   ❌    | —                                                      | Raw system call interface; not declared in types, no probe yet                |
-| `go:testing`                        |   ❌    | —                                                      | Test / benchmark harness; not declared in types, no probe yet                 |
-| `go:testing/cryptotest`             |   ❌    | —                                                      | FIPS crypto test helpers; not declared in types, no probe yet                 |
-| `go:testing/fstest`                 |   ❌    | —                                                      | In-memory filesystem maps; not declared in types, no probe yet                |
-| `go:testing/iotest`                 |   ❌    | —                                                      | Reader / writer test shims; not declared in types, no probe yet               |
-| `go:testing/quick`                  |   ❌    | —                                                      | Property-based testing; not declared in types, no probe yet                   |
-| `go:testing/slogtest`               |   ❌    | —                                                      | slog handler testing; not declared in types, no probe yet                     |
-| `go:testing/synctest`               |   ❌    | —                                                      | Deterministic async testing; not declared in types, no probe yet              |
-| `go:text/scanner`                   |   ❌    | —                                                      | Generic token scanning; not declared in types, no probe yet                   |
-| `go:text/tabwriter`                 |   ❌    | —                                                      | Column-aligned text output; not declared in types, no probe yet               |
-| `go:text/template`                  |   ❌    | —                                                      | Data-driven text templating; not declared in types, no probe yet              |
-| `go:text/template/parse`            |   ❌    | —                                                      | Template parse tree; not declared in types, no probe yet                      |
-| `go:time`                           |   ❌    | —                                                      | Dates, durations, timers; not declared in types, no probe yet                 |
-| `go:time/tzdata`                    |   ❌    | —                                                      | Embedded timezone database; not declared in types, no probe yet               |
-| `go:unicode`                        |   ❌    | —                                                      | Unicode properties / tables; not declared in types, no probe yet              |
-| `go:unicode/utf16`                  |   ❌    | —                                                      | UTF-16 encoding; not declared in types, no probe yet                          |
-| `go:unicode/utf8`                   |   ❌    | —                                                      | UTF-8 encoding; not declared in types, no probe yet                           |
-| `go:unique`                         |   ❌    | —                                                      | Interned canonical values; not declared in types, no probe yet                |
-| `go:unsafe`                         |   ❌    | —                                                      | Unsafe pointers / memory layout; not declared in types, no probe yet          |
-| `go:weak`                           |   ❌    | —                                                      | Weak pointers; not declared in types, no probe yet                            |
+Status: ✅ probed, ⚠️ typed (declared and bridged), no probe yet, ❌ excluded.
+
+<!-- go-bridges:start -->
+| Module | Status | Probe | Notes |
+| ------ | :----: | ----- | ----- |
+| `go:archive/tar` | ✅ | [lib-go-compress-extra.ts](conformance/lib-go-compress-extra.ts) | tar archive read/write |
+| `go:archive/zip` | ✅ | [lib-go-archive.ts](conformance/lib-go-archive.ts) | ZIP archive read/write |
+| `go:bufio` | ✅ | [lib-go-bufio.ts](conformance/lib-go-bufio.ts) | Buffered I/O |
+| `go:bytes` | ✅ | [lib-go-bytes.ts](conformance/lib-go-bytes.ts) | Byte-slice utilities |
+| `go:cmp` | ✅ | [lib-go-slices.ts](conformance/lib-go-slices.ts) | Ordered comparison primitives |
+| `go:compress/bzip2` | ✅ | [lib-go-compress-extra.ts](conformance/lib-go-compress-extra.ts) | bzip2 decompression (read-only) |
+| `go:compress/flate` | ✅ | [lib-go-compress-extra.ts](conformance/lib-go-compress-extra.ts) | DEFLATE compression |
+| `go:compress/gzip` | ✅ | [lib-go-compress-gzip.ts](conformance/lib-go-compress-gzip.ts) | gzip read/write |
+| `go:compress/lzw` | ✅ | [lib-go-compress-extra.ts](conformance/lib-go-compress-extra.ts) | LZW compression (GIF/PDF/TIFF) |
+| `go:compress/zlib` | ✅ | [lib-go-compress-extra.ts](conformance/lib-go-compress-extra.ts) | zlib read/write |
+| `go:container/heap` | ⚠️ | — | Needs a TS class satisfying `heap.Interface`; TS classes cannot implement Go interfaces yet |
+| `go:container/list` | ✅ | [lib-go-containers.ts](conformance/lib-go-containers.ts) | Doubly linked list |
+| `go:container/ring` | ✅ | [lib-go-containers.ts](conformance/lib-go-containers.ts) | Circular list |
+| `go:context` | ✅ | [lib-go-sync.ts](conformance/lib-go-sync.ts) | Cancellation and deadlines |
+| `go:crypto` | ✅ | [lib-go-crypto-extra.ts](conformance/lib-go-crypto-extra.ts) | Crypto constants and algorithm selection |
+| `go:crypto/aes` | ✅ | [lib-go-crypto-aes.ts](conformance/lib-go-crypto-aes.ts) | AES encryption |
+| `go:crypto/cipher` | ✅ | [lib-go-crypto-aes.ts](conformance/lib-go-crypto-aes.ts) | Block cipher modes (GCM, CBC, CTR) |
+| `go:crypto/des` | ✅ | [lib-go-crypto-extra.ts](conformance/lib-go-crypto-extra.ts) | DES / triple DES (deprecated) |
+| `go:crypto/dsa` | ✅ | [lib-go-crypto-more.ts](conformance/lib-go-crypto-more.ts) | DSA signatures (deprecated) |
+| `go:crypto/ecdh` | ✅ | [lib-go-crypto-keys.ts](conformance/lib-go-crypto-keys.ts) | ECDH key exchange |
+| `go:crypto/ecdsa` | ✅ | [lib-go-crypto-keys.ts](conformance/lib-go-crypto-keys.ts) | ECDSA signatures |
+| `go:crypto/ed25519` | ✅ | [lib-go-ed25519.ts](conformance/lib-go-ed25519.ts) | Ed25519 signatures |
+| `go:crypto/elliptic` | ✅ | [lib-go-crypto-keys.ts](conformance/lib-go-crypto-keys.ts) | Elliptic curves (legacy; use ecdh/ecdsa) |
+| `go:crypto/fips140` | ✅ | [lib-go-crypto-extra.ts](conformance/lib-go-crypto-extra.ts) | FIPS 140-3 mode controls |
+| `go:crypto/hkdf` | ✅ | [lib-go-crypto-extra.ts](conformance/lib-go-crypto-extra.ts) | HKDF key derivation |
+| `go:crypto/hmac` | ✅ | [lib-go-crypto-hash.ts](conformance/lib-go-crypto-hash.ts) | HMAC keyed hashing |
+| `go:crypto/hpke` | ✅ | [lib-go-crypto-more.ts](conformance/lib-go-crypto-more.ts) | HPKE encryption (RFC 9180) |
+| `go:crypto/md5` | ✅ | [lib-go-crypto-hash.ts](conformance/lib-go-crypto-hash.ts) | MD5 hash |
+| `go:crypto/mlkem` | ✅ | [lib-go-crypto-keys.ts](conformance/lib-go-crypto-keys.ts) | ML-KEM post-quantum key encapsulation |
+| `go:crypto/mlkem/mlkemtest` | ✅ | [lib-go-crypto-more.ts](conformance/lib-go-crypto-more.ts) | Deterministic ML-KEM encapsulation |
+| `go:crypto/pbkdf2` | ✅ | [lib-go-crypto-extra.ts](conformance/lib-go-crypto-extra.ts) | PBKDF2 key derivation |
+| `go:crypto/rand` | ✅ | [lib-go-crypto-aes.ts](conformance/lib-go-crypto-aes.ts) | Cryptographically secure random bytes |
+| `go:crypto/rc4` | ✅ | [lib-go-crypto-extra.ts](conformance/lib-go-crypto-extra.ts) | RC4 stream cipher (deprecated) |
+| `go:crypto/rsa` | ✅ | [lib-go-rsa.ts](conformance/lib-go-rsa.ts) | RSA signatures / encryption |
+| `go:crypto/sha1` | ✅ | [lib-go-crypto-hash.ts](conformance/lib-go-crypto-hash.ts) | SHA-1 hash |
+| `go:crypto/sha256` | ✅ | [lib-go-hash.ts](conformance/lib-go-hash.ts) | SHA-224 / SHA-256 hashes |
+| `go:crypto/sha3` | ✅ | [lib-go-crypto-extra.ts](conformance/lib-go-crypto-extra.ts) | SHA-3 / SHAKE hashes |
+| `go:crypto/sha512` | ✅ | [lib-go-crypto-hash.ts](conformance/lib-go-crypto-hash.ts) | SHA-384 / SHA-512 family hashes |
+| `go:crypto/subtle` | ✅ | [lib-go-crypto-aes.ts](conformance/lib-go-crypto-aes.ts) | Constant-time comparison primitives |
+| `go:crypto/tls` | ✅ | [lib-go-crypto-keys.ts](conformance/lib-go-crypto-keys.ts) | TLS client/server; loopback probe is a later phase |
+| `go:crypto/x509` | ✅ | [lib-go-crypto-keys.ts](conformance/lib-go-crypto-keys.ts) | X.509 certificates and revocation |
+| `go:crypto/x509/pkix` | ✅ | [lib-go-crypto-keys.ts](conformance/lib-go-crypto-keys.ts) | X.509 ASN.1/PKIX structures |
+| `go:database/sql` | ✅ | [lib-go-sql.ts](conformance/lib-go-sql.ts) | No std driver: registry and errors probed |
+| `go:database/sql/driver` | ✅ | [lib-go-sql.ts](conformance/lib-go-sql.ts) | Driver interfaces and value converters |
+| `go:debug/buildinfo` | ✅ | [lib-go-runtime-extra.ts](conformance/lib-go-runtime-extra.ts) | Build info from executables |
+| `go:debug/dwarf` | ⚠️ | — | DWARF debug info parsing |
+| `go:debug/elf` | ⚠️ | — | ELF object files |
+| `go:debug/gosym` | ⚠️ | — | Go symbol tables |
+| `go:debug/macho` | ⚠️ | — | Mach-O object files |
+| `go:debug/pe` | ⚠️ | — | PE (Windows) object files |
+| `go:debug/plan9obj` | ⚠️ | — | Plan 9 object files |
+| `go:encoding` | ✅ | [lib-go-encoding.ts](conformance/lib-go-encoding.ts) | Shared encoding interfaces |
+| `go:encoding/ascii85` | ✅ | [lib-go-encoding-more.ts](conformance/lib-go-encoding-more.ts) | ascii85 encoding |
+| `go:encoding/asn1` | ✅ | [lib-go-encoding-more.ts](conformance/lib-go-encoding-more.ts) | ASN.1 DER encoding |
+| `go:encoding/base32` | ✅ | [lib-go-encoding-more.ts](conformance/lib-go-encoding-more.ts) | base32 encoding |
+| `go:encoding/base64` | ✅ | [lib-go-encoding.ts](conformance/lib-go-encoding.ts) | base64 encoding |
+| `go:encoding/binary` | ✅ | [lib-go-encoding-extra.ts](conformance/lib-go-encoding-extra.ts) | Binary packing / varints |
+| `go:encoding/csv` | ✅ | [lib-go-csv.ts](conformance/lib-go-csv.ts) | CSV read/write |
+| `go:encoding/gob` | ✅ | [lib-go-gob.ts](conformance/lib-go-gob.ts) | Go binary serialization |
+| `go:encoding/hex` | ✅ | [lib-go-encoding.ts](conformance/lib-go-encoding.ts) | hex encoding |
+| `go:encoding/json` | ✅ | [lib-go-encoding-more.ts](conformance/lib-go-encoding-more.ts) | JSON encode/decode |
+| `go:encoding/pem` | ✅ | [lib-go-encoding-extra.ts](conformance/lib-go-encoding-extra.ts) | PEM encoding |
+| `go:encoding/xml` | ✅ | [lib-go-encoding-extra.ts](conformance/lib-go-encoding-extra.ts) | XML read/write |
+| `go:errors` | ✅ | [lib-go-errors.ts](conformance/lib-go-errors.ts) | Error creation / wrapping / inspection |
+| `go:expvar` | ✅ | [lib-go-runtime.ts](conformance/lib-go-runtime.ts) | Public process variables |
+| `go:flag` | ✅ | [lib-go-exec.ts](conformance/lib-go-exec.ts) | Command-line flag parsing |
+| `go:fmt` | ✅ | [lib-go-fmt.ts](conformance/lib-go-fmt.ts) | Formatted I/O; integer verbs take TS numbers |
+| `go:go/ast` | ✅ | [lib-go-gotools-extra.ts](conformance/lib-go-gotools-extra.ts) | Go syntax tree |
+| `go:go/build` | ✅ | [lib-go-gotypes.ts](conformance/lib-go-gotypes.ts) | Go package build metadata |
+| `go:go/build/constraint` | ✅ | [lib-go-gotools-extra.ts](conformance/lib-go-gotools-extra.ts) | Build-tag constraint parsing |
+| `go:go/constant` | ✅ | [lib-go-gotools-extra.ts](conformance/lib-go-gotools-extra.ts) | Untyped constant values |
+| `go:go/doc` | ✅ | [lib-go-gotypes.ts](conformance/lib-go-gotypes.ts) | Go doc extraction |
+| `go:go/doc/comment` | ✅ | [lib-go-gotools-extra.ts](conformance/lib-go-gotools-extra.ts) | Doc comment parse/print |
+| `go:go/format` | ✅ | [lib-go-gotools.ts](conformance/lib-go-gotools.ts) | Go source formatting |
+| `go:go/importer` | ✅ | [lib-go-gotypes.ts](conformance/lib-go-gotypes.ts) | Export-data type importer |
+| `go:go/parser` | ✅ | [lib-go-gotools-extra.ts](conformance/lib-go-gotools-extra.ts) | Go source parser |
+| `go:go/printer` | ✅ | [lib-go-gotools-extra.ts](conformance/lib-go-gotools-extra.ts) | Go AST printer |
+| `go:go/scanner` | ✅ | [lib-go-gotools-extra.ts](conformance/lib-go-gotools-extra.ts) | Go tokenizer |
+| `go:go/token` | ✅ | [lib-go-gotools.ts](conformance/lib-go-gotools.ts) | Go tokens / positions |
+| `go:go/types` | ✅ | [lib-go-gotypes.ts](conformance/lib-go-gotypes.ts) | Go type checker |
+| `go:go/version` | ✅ | [lib-go-gotools.ts](conformance/lib-go-gotools.ts) | Go version comparison |
+| `go:hash` | ✅ | [lib-go-hash.ts](conformance/lib-go-hash.ts) | Hash function interface |
+| `go:hash/adler32` | ✅ | [lib-go-hash-extra.ts](conformance/lib-go-hash-extra.ts) | Adler-32 checksum |
+| `go:hash/crc32` | ✅ | [lib-go-hash.ts](conformance/lib-go-hash.ts) | CRC-32 checksum |
+| `go:hash/crc64` | ✅ | [lib-go-hash-extra.ts](conformance/lib-go-hash-extra.ts) | CRC-64 checksum |
+| `go:hash/fnv` | ✅ | [lib-go-hash.ts](conformance/lib-go-hash.ts) | FNV-1 / FNV-1a hash |
+| `go:hash/maphash` | ✅ | [lib-go-hash-extra.ts](conformance/lib-go-hash-extra.ts) | Seeded string hashing |
+| `go:html` | ✅ | [lib-go-url.ts](conformance/lib-go-url.ts) | HTML escaping |
+| `go:html/template` | ✅ | [lib-go-text-extra.ts](conformance/lib-go-text-extra.ts) | HTML templating (auto-escaped) |
+| `go:image` | ✅ | [lib-go-image.ts](conformance/lib-go-image.ts) | 2D image interface |
+| `go:image/color` | ✅ | [lib-go-image-extra.ts](conformance/lib-go-image-extra.ts) | Color types |
+| `go:image/color/palette` | ✅ | [lib-go-image-extra.ts](conformance/lib-go-image-extra.ts) | Standard color palettes |
+| `go:image/draw` | ✅ | [lib-go-image-extra.ts](conformance/lib-go-image-extra.ts) | Image compositing |
+| `go:image/gif` | ✅ | [lib-go-image-extra.ts](conformance/lib-go-image-extra.ts) | GIF decode/encode |
+| `go:image/jpeg` | ✅ | [lib-go-image-extra.ts](conformance/lib-go-image-extra.ts) | JPEG decode/encode |
+| `go:image/png` | ✅ | [lib-go-image.ts](conformance/lib-go-image.ts) | PNG decode/encode |
+| `go:index/suffixarray` | ✅ | [lib-go-text.ts](conformance/lib-go-text.ts) | Suffix-array substring search |
+| `go:io` | ✅ | [lib-go-compress-gzip.ts](conformance/lib-go-compress-gzip.ts) | Core I/O interfaces (Reader/Writer) |
+| `go:io/fs` | ✅ | [lib-go-path-fs.ts](conformance/lib-go-path-fs.ts) | Filesystem abstraction |
+| `go:io/ioutil` | ✅ | [lib-go-path-fs.ts](conformance/lib-go-path-fs.ts) | Deprecated I/O helpers (Go 1.16) |
+| `go:iter` | ✅ | [lib-go-collections.ts](conformance/lib-go-collections.ts) | Range-over-func iterators via `for…of`; `Pull` not bridged |
+| `go:log` | ✅ | [lib-go-log.ts](conformance/lib-go-log.ts) | Logging to stderr |
+| `go:log/slog` | ✅ | [lib-go-log.ts](conformance/lib-go-log.ts) | Structured logging |
+| `go:log/syslog` | ⚠️ | — | Unix syslog; no portable probe |
+| `go:maps` | ✅ | [lib-go-collections.ts](conformance/lib-go-collections.ts) | Generic map helpers |
+| `go:math` | ✅ | [lib-go-math.ts](conformance/lib-go-math.ts) | Math functions |
+| `go:math/big` | ✅ | [lib-go-big.ts](conformance/lib-go-big.ts) | Arbitrary-precision arithmetic |
+| `go:math/bits` | ✅ | [lib-go-math-extra.ts](conformance/lib-go-math-extra.ts) | Bit operations |
+| `go:math/cmplx` | ⚠️ | — | `complex128` has no TS mapping |
+| `go:math/rand` | ✅ | [lib-go-math-extra.ts](conformance/lib-go-math-extra.ts) | Pseudo-random numbers |
+| `go:math/rand/v2` | ✅ | [lib-go-math-extra.ts](conformance/lib-go-math-extra.ts) | Pseudo-random numbers (v2 API) |
+| `go:mime` | ✅ | [lib-go-encoding-extra.ts](conformance/lib-go-encoding-extra.ts) | MIME media types |
+| `go:mime/multipart` | ✅ | [lib-go-misc.ts](conformance/lib-go-misc.ts) | Multipart forms |
+| `go:mime/quotedprintable` | ✅ | [lib-go-encoding-more.ts](conformance/lib-go-encoding-more.ts) | Quoted-printable encoding |
+| `go:net` | ✅ | [lib-go-net.ts](conformance/lib-go-net.ts) | Sockets (loopback TCP), addresses |
+| `go:net/http` | ✅ | [lib-go-http.ts](conformance/lib-go-http.ts) | HTTP client/server (loopback) |
+| `go:net/http/cgi` | ✅ | [lib-go-http-extra.ts](conformance/lib-go-http-extra.ts) | CGI request parsing |
+| `go:net/http/cookiejar` | ✅ | [lib-go-net.ts](conformance/lib-go-net.ts) | Cookie jars (loopback) |
+| `go:net/http/fcgi` | ⚠️ | — | FastCGI handler; needs a FastCGI web server |
+| `go:net/http/httptest` | ✅ | [lib-go-http.ts](conformance/lib-go-http.ts) | HTTP test servers (loopback) |
+| `go:net/http/httptrace` | ✅ | [lib-go-net.ts](conformance/lib-go-net.ts) | HTTP tracing hooks |
+| `go:net/http/httputil` | ✅ | [lib-go-net.ts](conformance/lib-go-net.ts) | HTTP utilities (loopback) |
+| `go:net/http/pprof` | ✅ | [lib-go-http-extra.ts](conformance/lib-go-http-extra.ts) | pprof HTTP handlers |
+| `go:net/mail` | ✅ | [lib-go-encoding-extra.ts](conformance/lib-go-encoding-extra.ts) | Mail address parsing |
+| `go:net/netip` | ✅ | [lib-go-encoding-extra.ts](conformance/lib-go-encoding-extra.ts) | IP address types |
+| `go:net/rpc` | ⚠️ | — | Needs Go method sets on registered receivers |
+| `go:net/rpc/jsonrpc` | ⚠️ | — | Needs Go method sets on registered receivers |
+| `go:net/smtp` | ⚠️ | — | SMTP client; needs a server |
+| `go:net/textproto` | ✅ | [lib-go-net.ts](conformance/lib-go-net.ts) | Text protocol I/O |
+| `go:net/url` | ✅ | [lib-go-url.ts](conformance/lib-go-url.ts) | URL parsing |
+| `go:os` | ✅ | [lib-go-os.ts](conformance/lib-go-os.ts) | OS files and processes |
+| `go:os/exec` | ✅ | [lib-go-exec.ts](conformance/lib-go-exec.ts) | External commands |
+| `go:os/signal` | ✅ | [lib-go-misc.ts](conformance/lib-go-misc.ts) | Signal notification (`Notify` + `Stop`) |
+| `go:os/user` | ✅ | [lib-go-runtime-extra.ts](conformance/lib-go-runtime-extra.ts) | User lookup |
+| `go:path` | ✅ | [lib-go-path-fs.ts](conformance/lib-go-path-fs.ts) | Slash-separated paths |
+| `go:path/filepath` | ✅ | [lib-go-os.ts](conformance/lib-go-os.ts) | File paths |
+| `go:reflect` | ✅ | [lib-go-text-extra.ts](conformance/lib-go-text-extra.ts) | Runtime reflection |
+| `go:regexp` | ✅ | [lib-go-regexp.ts](conformance/lib-go-regexp.ts) | Regular expressions |
+| `go:regexp/syntax` | ✅ | [lib-go-text-extra.ts](conformance/lib-go-text-extra.ts) | Regexp parse trees |
+| `go:runtime` | ✅ | [lib-go-runtime.ts](conformance/lib-go-runtime.ts) | Runtime introspection |
+| `go:runtime/debug` | ✅ | [lib-go-runtime.ts](conformance/lib-go-runtime.ts) | Stack traces and GC stats |
+| `go:runtime/metrics` | ✅ | [lib-go-runtime-extra.ts](conformance/lib-go-runtime-extra.ts) | Runtime metrics sampling |
+| `go:runtime/pprof` | ✅ | [lib-go-runtime-extra.ts](conformance/lib-go-runtime-extra.ts) | Profiling data |
+| `go:runtime/trace` | ✅ | [lib-go-runtime-extra.ts](conformance/lib-go-runtime-extra.ts) | Execution tracing |
+| `go:slices` | ✅ | [lib-go-slices.ts](conformance/lib-go-slices.ts) | Generic slice helpers |
+| `go:sort` | ✅ | [lib-go-sort.ts](conformance/lib-go-sort.ts) | Sorting |
+| `go:strconv` | ✅ | [lib-go-strconv.ts](conformance/lib-go-strconv.ts) | String conversions |
+| `go:strings` | ✅ | [lib-go-strings.ts](conformance/lib-go-strings.ts) | String utilities |
+| `go:structs` | ✅ | [lib-go-lowlevel.ts](conformance/lib-go-lowlevel.ts) | `HostLayout` marker |
+| `go:sync` | ✅ | [lib-go-sync.ts](conformance/lib-go-sync.ts) | Mutexes and wait groups |
+| `go:sync/atomic` | ✅ | [lib-go-sync.ts](conformance/lib-go-sync.ts) | Atomic operations |
+| `go:syscall` | ✅ | [lib-go-lowlevel.ts](conformance/lib-go-lowlevel.ts) | Portable subset probed; per-arch constants dropped |
+| `go:testing` | ✅ | [lib-go-testing.ts](conformance/lib-go-testing.ts) | Helpers usable outside `go test` |
+| `go:testing/cryptotest` | ⚠️ | — | Needs a `*testing.T` (no `go test` harness) |
+| `go:testing/fstest` | ✅ | [lib-go-testing.ts](conformance/lib-go-testing.ts) | `TestFS` over any `fs.FS` |
+| `go:testing/iotest` | ✅ | [lib-go-testing.ts](conformance/lib-go-testing.ts) | Reader/writer test wrappers |
+| `go:testing/quick` | ✅ | [lib-go-testing.ts](conformance/lib-go-testing.ts) | Property checks with TS callbacks |
+| `go:testing/slogtest` | ⚠️ | — | Needs a `*testing.T` (no `go test` harness) |
+| `go:testing/synctest` | ⚠️ | — | Needs a `*testing.T` (no `go test` harness) |
+| `go:text/scanner` | ✅ | [lib-go-text.ts](conformance/lib-go-text.ts) | Text scanner |
+| `go:text/tabwriter` | ✅ | [lib-go-text.ts](conformance/lib-go-text.ts) | Aligned text columns |
+| `go:text/template` | ✅ | [lib-go-template.ts](conformance/lib-go-template.ts) | Text templating |
+| `go:text/template/parse` | ✅ | [lib-go-text-extra.ts](conformance/lib-go-text-extra.ts) | Template parse trees |
+| `go:time` | ✅ | [lib-go-time.ts](conformance/lib-go-time.ts) | Time and durations |
+| `go:time/tzdata` | ✅ | [lib-go-runtime-extra.ts](conformance/lib-go-runtime-extra.ts) | Embedded timezone database (side-effect import) |
+| `go:unicode` | ✅ | [lib-go-unicode.ts](conformance/lib-go-unicode.ts) | Unicode tables |
+| `go:unicode/utf16` | ✅ | [lib-go-encoding-more.ts](conformance/lib-go-encoding-more.ts) | UTF-16 encoding |
+| `go:unicode/utf8` | ✅ | [lib-go-unicode.ts](conformance/lib-go-unicode.ts) | UTF-8 encoding |
+| `go:unique` | ✅ | [lib-go-collections.ts](conformance/lib-go-collections.ts) | Canonical values |
+| `go:weak` | ✅ | [lib-go-lowlevel.ts](conformance/lib-go-lowlevel.ts) | Weak pointers |
+| `go:plugin` | ❌ | — | cgo, `-buildmode=plugin` |
+| `go:unsafe` | ❌ | — | raw pointers |
+| `go:runtime/race` | ❌ | — | needs `-race` |
+| `go:runtime/coverage` | ❌ | — | needs `-cover` |
+| `go:runtime/cgo` | ❌ | — | needs cgo |
+| `go:embed` | ❌ | — | needs a `//go:embed` directive; a later phase |
+<!-- go-bridges:end -->
+
+#### Go bridge semantics
+
+| Rule | Meaning |
+| ---- | ------- |
+| Number conversion | All Go ints/floats map to TS `number`; args convert via `T(x)`, results read back via `float64(x)`. `int64`/`uint64` beyond 2^53 lose precision. |
+| Throw on error | `(T, error)` results throw a `GoError` on failure; `error`-only calls throw as statements and yield the error value in value position. |
+| Tuples | Multi-value results pack into a slice (TS tuple); `const [a, b] = f()` types each element (ints read as numbers). |
+| Structs | `new pkg.T({...})` builds a composite literal (pointer when any method needs it); fields read/write directly, converting numbers both ways (`h.Size += 1`). Embedded structs promote their fields. |
+| Named numerics | Typed constants (`time.Second`, `reflect.String`) stay typed in Go; arithmetic and `===` coerce the `number` side (`time.Second * 2`). Results read as numbers: `token.Token(n)` restores the methods. |
+| Callbacks | Func-typed params and struct fields become Go closures with the exact Go signature (int params read as numbers, returns convert to the result type); sync callbacks (sort, slices, strings, ...) run inline. |
+| Generics | Type args are inferred from the arguments, including through constraints (`maps.Keys(m)` with `Map ~map[K]V`); unresolved ones become `any`. |
+| printf verbs | With a literal format, numbers passed to `%d %x %o %b %c %U` convert to `int64`; scan into number refs with `%v`. |
+| nil | `null` passes as `nil`; `x === null` on nil-able Go values (slices, maps, interfaces, pointers) is a real nil check. |
+| Channels | `chan<T>(size?)` / `GoChan<T>` with `send`, `recv`, `close`; `for…of` ranges channels, `iter.Seq` and `iter.Seq2` (`for (const [k, v] of seq2)`). |
+| Out-params | `ref<T>(init?)` makes a pointer cell; `.value` dereferences it. |
+| Byte slices | `[]byte` is `Uint8Array` (zero-copy); `number[]` converts per call (mutations of the copy are lost). |
+| Side-effect imports | `import 'go:time/tzdata'` emits a blank `import _`. |
 
 ### npm packages