typenative 0.2.0 → 0.3.1

package/.github/workflows/ci.yml

@@ -5,7 +5,39 @@ on:
   pull_request:
 
 jobs:
+  # Every probe through the Node CLI, on each OS a generated binary can target
   conformance:
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, windows-latest, macos-latest]
+    runs-on: ${{ matrix.os }}
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 24
+          cache: npm
+
+      - uses: actions/setup-go@v5
+        with:
+          go-version: '1.26'
+          cache-dependency-path: tsparser/go.sum
+
+      - run: npm ci
+
+      - run: npm run build
+
+      - run: npm ci
+        working-directory: conformance
+
+      - run: npm run check:go-types
+
+      - run: npm run conformance:parallel
+
+  # The self-hosted compiler: same probes, and it must reproduce its own Go
+  native:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
@@ -18,6 +50,7 @@ jobs:
       - uses: actions/setup-go@v5
         with:
           go-version: '1.26'
+          cache-dependency-path: tsparser/go.sum
 
       - run: npm ci
 
@@ -26,4 +59,8 @@ jobs:
       - run: npm ci
         working-directory: conformance
 
-      - run: npm run conformance
+      - run: npm run build:native
+
+      - run: npm run bootstrap:check
+
+      - run: node scripts/conformance-parallel.mjs --native

package/.github/workflows/npm-publish-github-packages.yml

@@ -29,9 +29,11 @@ jobs:
         with:
           go-version: '1.26'
       - run: npm ci
+      # Test what gets published: bin/ rebuilt from src/, not the committed copy
+      - run: npm run build
       - run: npm ci
         working-directory: conformance
-      - run: npm run conformance
+      - run: npm run conformance:parallel
 
   release:
     needs: test
@@ -78,6 +80,9 @@ jobs:
 
       - run: npm ci
 
+      # Publish bin/ built from this commit (prebuild also stamps the tag's version)
+      - run: npm run build
+
       # Authenticates via OIDC (id-token: write) — no NODE_AUTH_TOKEN needed.
       # Provenance is included automatically; the flag is kept for explicitness.
       - run: npm publish --provenance --access public

package/CHANGELOG.md

@@ -7,6 +7,66 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.3.1] - 2026-10-18
+
+### Fixed
+
+- `node:tls` on macOS: an untrusted certificate chain reports Node's codes
+  (`DEPTH_ZERO_SELF_SIGNED_CERT`, `SELF_SIGNED_CERT_IN_CHAIN`,
+  `UNABLE_TO_GET_ISSUER_CERT_LOCALLY`) like on other platforms; the platform verifier returns
+  a plain error, not `UnknownAuthorityError`
+- `go build` runs with `-trimpath`, so vendored packages (the ~5 MB sqlite driver) are cached
+  once instead of recompiled for every project directory, and builds are reproducible
+- `conformance-parallel.mjs` builds one sqlite probe first so a cold cache doesn't time out
+  every sqlite probe at once on small runners; the `node:sqlite` `location()` probe compares
+  canonical paths (symlinks, Windows 8.3 short names)
+
+## [0.3.0] - 2026-10-18
+
+Errors now point at your TypeScript. Programs are type-checked before they're transpiled, code
+TypeNative can't compile stops the build with its position, and Go build errors and panics
+report `.ts` lines. CI runs the suite on Linux, Windows and macOS, and all 398 probes pass on
+Windows (four failed there before), through both the Node CLI and the self-hosted compiler.
+
+### Added
+
+- **Type-checking**: the CLI type-checks the entry file and its imports before transpiling,
+  using the nearest `tsconfig.json` (or `lib: []` plus the bundled `typenative` declarations),
+  and stops on errors (`main.ts:4:7: error TS2322: …`); `--no-typecheck` skips it. The
+  self-hosted compiler runs the same check on typescript-go (`tsparser --check`)
+- **Line directives**: generated Go carries `/*line file.ts:line:col*/` directives, so
+  `go build` errors and panic stack traces report TypeScript files and lines; runtime helpers
+  keep their own `dist/code.go` positions. Both parsers emit `line` / `column` on AST nodes
+- `TranspileResult.diagnostics`, and `fileName` / `goFile` / `goos` transpile options
+- `npm run bootstrap:check`: the self-hosted compiler must emit byte-identical Go for
+  `src/main.ts` to the Node CLI's; `conformance-parallel.mjs --native`
+- CI on Ubuntu, Windows and macOS, `check:go-types` in CI, and a self-hosted compiler job
+  (bootstrap fixpoint + the suite through it)
+
+### Changed
+
+- Unsupported syntax and unsupported `node:` modules are errors with a position
+  (`main.ts:2:1: error: Unsupported syntax: WithStatement`) instead of warnings followed by
+  broken Go; `;` and `debugger` statements compile to nothing
+- Generated Go is deterministic: temp and renamed identifiers come from a generator seeded per
+  transpilation instead of `Math.random`, so the same source always gives the same Go
+- Code typed into `--script`'s prompt is saved as `dist/script.ts` (type-checked, and named in
+  errors)
+- Scaffolded `tsconfig.json` sets `skipLibCheck`
+- `node:sqlite` `function()` / `aggregate()` callbacks are typed `(...args: any[])`: arguments
+  convert to the types the callback declares
+- The release workflow builds `bin/` before testing and publishing; `conformance-parallel.mjs`
+  sizes its worker pool to the machine
+- Probes that depend on the OS (`lib-node-dns-resolver`, `lib-node-util-parse-args`) hold on
+  Windows, and the conformance probes type-check (`conformance/tsconfig.json` sets
+  `skipLibCheck`)
+
+### Fixed
+
+- Windows: `os.totalmem()` / `os.freemem()` / `os.uptime()` read the OS (they returned the
+  process's own memory, `0` and `0`); `performance.now()` keeps increasing between calls, so
+  marks taken in a row keep their order (Go's Windows clock repeats readings)
+
 ## [0.2.0] - 2026-10-18
 
 The Go standard-library bridge (`go:*` imports) goes from 73 to 154 probed packages, with 16

package/CONTRIBUTION.md

@@ -44,7 +44,7 @@ Probe conventions:
 
 - Self-contained — no imports except the module under test, no external files.
 - Exercise the feature with `console.log` **and** verify with `assert(condition, 'message')`.
-- A passing probe transpiles, compiles with `go build`, runs, and exits `0`. Anything else is a failure.
+- A passing probe type-checks (against `conformance/tsconfig.json`), transpiles, compiles with `go build`, runs, and exits `0`. Anything else is a failure.
 
 ```ts
 // conformance/lib-map.ts
@@ -73,7 +73,8 @@ No signature → user code won't type-check → the feature doesn't exist.
 ### 3. Implement in `src/transpiler.ts`
 
 - Match on `node.kind === 'Xxx'` strings (never the `typescript` enum) so the same code consumes Node- and Go-produced ASTs.
-- Emit a warning, not a crash, for anything still unsupported: `console.warn('[TypeNative] Unsupported syntax: …')`.
+- Report anything still unsupported with `reportError(node, 'Unsupported …')`, not a crash or a guess: it becomes a `file.ts:line:col: error:` diagnostic and the CLI stops before `go build`.
+- New statement-like output goes through `withLineMarker(node, code)` (statement lists already do), so Go errors and stack traces point at the `.ts` line.
 - Keep the transpiler free of Node-only dependencies (see below).
 
 ### 4. Document in `conformance.md`
@@ -85,7 +86,7 @@ Add or flip the matrix row and link your probe. Keep ✅/❌ honest — known ga
 This is the one rule that breaks the build if ignored: **`src/index.ts`, `src/transpiler.ts`, `src/main.ts`, `src/prompt.ts`, and `src/parse-native.ts` must transpile with TypeNative itself.** That means:
 
 - ❌ No `inquirer`, no async Node-only APIs, no unmapped modules in those files.
-- ✅ Node-only code lives in `src/cli.ts` (prompts) and `src/parse-node.ts` (`typescript` package) and is injected at the boundary — e.g. `run({ ..., parse: parseAstJson })`.
+- ✅ Node-only code lives in `src/cli.ts` (prompts), `src/parse-node.ts` and `src/typecheck-node.ts` (`typescript` package) and is injected at the boundary — e.g. `run({ ..., parse: parseAstJson, typeCheck })`. The self-hosted binary injects `tsparser`-backed versions (`src/parse-native.ts`).
 - ✅ Prompts in transpilable code go through `src/prompt.ts` (`node:readline` → Go helper).
 
 If you need a new capability in transpilable code, add the mapping (transpiler + `types/` shim) first, then use it.
@@ -109,10 +110,11 @@ If you touched anything transpilable, also verify self-hosting:
 
 ```sh
 npm run build:native            # builds native/tsparser + native/typenative
-node scripts/conformance.mjs --native  # full suite through your new binary
+npm run bootstrap:check         # native/typenative must emit the same Go for src/main.ts
+node scripts/conformance-parallel.mjs --native  # full suite through your new binary
 ```
 
-CI ([`.github/workflows/ci.yml`](.github/workflows/ci.yml)) runs `npm ci` → `npm run build` → `npm run conformance` on Ubuntu (Node 24 + Go). Match it locally before pushing.
+CI ([`.github/workflows/ci.yml`](.github/workflows/ci.yml)) runs `npm run build`, `npm run check:go-types` and `npm run conformance:parallel` on Ubuntu, Windows and macOS (Node 24 + Go 1.26), plus a Linux job that builds the native compiler, runs `npm run bootstrap:check` and the suite through it. Probes that depend on the OS should hold on all three (branch on `process.platform` where Node itself differs).
 
 ## Pull requests
 

package/README.md

@@ -122,8 +122,11 @@ Scaffolded `tsconfig.json` targets the TypeNative type surface:
 | `--output <path>` | build          | Where to copy the compiled binary. If omitted with `--script`, the temp binary in `dist/` is executed and kept there.                                |
 | `--script`        | run            | Build to `dist/native(.exe)` and execute immediately with inherited stdio. Combine with `--source`, or omit `--source` to type code into the prompt. |
 | `--new`           | scaffold       | Create a new project directory (`main.ts`, `package.json`, `tsconfig.json`, `README.md`, `.gitignore`).                                              |
+| `--no-typecheck`  | build / script | Skip the type-check that runs before transpiling.                                                                                                    |
 
-Exit codes from `--script` are the exit code of your program. A non-zero `go build` prints `go build failed:` plus the compiler output and exits `1`.
+Exit codes from `--script` are the exit code of your program. Before anything is built, the entry file and its imports are type-checked with the nearest `tsconfig.json` (or TypeNative's defaults: `lib: []` plus the `typenative` declarations); type errors print as `main.ts:4:7: error TS2322: …` and exit `1`. TypeScript TypeNative can't compile yet is an error too (`main.ts:2:1: error: Unsupported syntax: WithStatement`), not a guess. A non-zero `go build` prints `go build failed:` plus the compiler output and exits `1`.
+
+Errors point at your TypeScript, not the generated Go: `dist/code.go` carries Go line directives, so `go build` errors and panic stack traces report `.ts` files and lines (`main.ts:12`).
 
 ## Writing TypeNative-compatible TypeScript
 
@@ -235,18 +238,19 @@ console.log(`count=${c.count} seen=${seen.get('a')}`);
 ## How it works
 
 ```text
-main.ts --(parse)--> normalized JSON AST --(transpileToNative)--> dist/code.go --(go build)--> dist/native(.exe) --run/copy--> your binary
+main.ts --(type-check)--(parse)--> normalized JSON AST --(transpileToNative)--> dist/code.go --(go build)--> dist/native(.exe) --run/copy--> your binary
 ```
 
-- **Parse:** Node CLI uses the `typescript` npm package (`src/parse-node.ts`); the self-hosted binary spawns the Go `tsparser` tool (`src/parse-native.ts`). Both emit the same `{ kind: "Xxx", ... }` JSON shape so one transpiler consumes either.
-- **Transpile:** `transpileToNative(code, { parse, readFile })` in `src/transpiler.ts` lowers the AST to Go, resolving relative and npm imports into additional Go files (`TranspileResult { main, files }`).
+- **Type-check:** Node CLI builds a program with the `typescript` package (`src/typecheck-node.ts`); the self-hosted binary runs `tsparser --check`, the same check on typescript-go (`tsparser/check.go`).
+- **Parse:** Node CLI uses the `typescript` npm package (`src/parse-node.ts`); the self-hosted binary spawns the Go `tsparser` tool (`src/parse-native.ts`). Both emit the same `{ kind: "Xxx", line, column, ... }` JSON shape so one transpiler consumes either.
+- **Transpile:** `transpileToNative(code, { parse, readFile })` in `src/transpiler.ts` lowers the AST to Go, resolving relative and npm imports into additional Go files (`TranspileResult { main, files, diagnostics }`). Generated statements carry `/*line file.ts:line:col*/` directives; `diagnostics` lists source the transpiler can't compile.
 - **Build:** `run()` in `src/index.ts` writes `dist/code.go` (+ one Go file per module), cleans stale `dist/*.go`, shells out to `go build -o dist/native(.exe)`, then either executes it (`--script`, stdio inherited) or copies it to `--output`. Third-party Go modules a program needs (`node:sqlite`'s driver, shipped in `govendor/`; `golang.org/x/text`, copied from GOROOT) are copied under `dist/tnvendor` and wired in with `replace` directives in `dist/go.mod`, so builds stay offline.
 
 ## Testing and conformance
 
-`npm test` is `npm run conformance`: every `conformance/*.ts` probe is transpiled, built with `go`, executed, and must exit `0`. Results print per category (`syntax` / `semantics` / `lib`) plus a total pass rate; any failure exits non-zero and lists the first diagnostic line (`*.go:line`, `panic:`, `Unsupported syntax`, `Error`).
+`npm test` is `npm run conformance`: every `conformance/*.ts` probe is type-checked, transpiled, built with `go`, executed, and must exit `0` (`npm run conformance:parallel` runs them concurrently). Results print per category (`syntax` / `semantics` / `lib`) plus a total pass rate; any failure exits non-zero and lists the first diagnostic line (`*.go:line`, `panic:`, `Unsupported syntax`, `Error`).
 
-CI (`.github/workflows/ci.yml`) runs `npm ci`, `npm run build`, and `npm run conformance` on Ubuntu with Node 24 and Go. Releases are cut from `TypeNative_*` tags via trusted publishing.
+CI (`.github/workflows/ci.yml`) runs `npm run build`, `npm run check:go-types` and the conformance suite on Ubuntu, Windows and macOS with Node 24 and Go 1.26, and a Linux job that builds the self-hosted compiler, checks the bootstrap fixpoint (`npm run bootstrap:check`) and runs the suite through it. Releases are cut from `TypeNative_*` tags via trusted publishing, from a fresh `npm run build`.
 
 When adding a feature: add a probe, link it from [conformance.md](conformance.md), and keep the ✅/❌ matrix honest — gaps are documented, not hidden.
 
@@ -260,7 +264,7 @@ npm run build:native   # builds native/tsparser + native/typenative side by side
 native/typenative --source app.ts --script
 ```
 
-`TYPENATIVE_TSPARSER` overrides parser discovery if you move the binaries apart. Verify parity with `node scripts/conformance.mjs --native`.
+`TYPENATIVE_TSPARSER` overrides parser discovery if you move the binaries apart. Verify parity with `node scripts/conformance.mjs --native`, and that the binary reproduces its own Go with `npm run bootstrap:check`.
 
 ## License
 

package/bin/cli.js

@@ -5,9 +5,11 @@ import inquirer from 'inquirer';
 import { fileURLToPath } from 'node:url';
 import { run, createProject } from './index.js';
 import { parseAstJson } from './parse-node.js';
+import { typeCheckNode } from './typecheck-node.js';
 (async function main() {
     const scriptMode = process.argv.findIndex((a) => a === '--script') > -1;
     const newCommand = process.argv.findIndex((a) => a === '--new') > -1;
+    const noTypeCheck = process.argv.includes('--no-typecheck');
     const sourceIndex = process.argv.findIndex((a) => a === '--source');
     const source = sourceIndex > -1 ? process.argv[sourceIndex + 1] : null;
     const outputIndex = process.argv.findIndex((a) => a === '--output');
@@ -53,12 +55,14 @@ import { parseAstJson } from './parse-node.js';
         return;
     }
     const sourcePath = answers.tsCode ? null : (source ?? answers.path ?? null);
+    const typesDir = fileURLToPath(new URL('../types', import.meta.url));
     run({
         source: sourcePath,
         output: output ?? answers.output ?? null,
         scriptMode,
         tsCode: answers.tsCode ?? null,
         parse: parseAstJson,
+        typeCheck: noTypeCheck ? null : (fileName) => typeCheckNode(fileName, typesDir),
         vendorDir: fileURLToPath(new URL('../govendor', import.meta.url))
     });
 })();

package/bin/index.js

@@ -11,6 +11,22 @@ import { platform } from 'node:os';
 import * as childProcess from 'node:child_process';
 import { transpileToNative } from './transpiler.js';
 import { VERSION } from './version.js';
+// A source path as diagnostics and Go line directives show it: relative to
+// the working directory when inside it, else absolute; forward slashes
+function displayPath(file) {
+    const absolute = path.resolve(file);
+    const relative = path.relative(process.cwd(), absolute);
+    const inside = relative !== '' && !relative.startsWith('..') && !path.isAbsolute(relative);
+    return (inside ? relative : absolute).split('\\').join('/');
+}
+// file:line:column: <label>: message (the position Go's own errors use)
+function printDiagnostic(file, line, column, label, message) {
+    const position = line > 0 ? `${displayPath(file)}:${line}:${column}` : displayPath(file);
+    console.error(`${file ? position + ': ' : ''}${label}: ${message.split('\n').join('\n    ')}`);
+}
+function plural(count, noun) {
+    return `${count} ${noun}${count === 1 ? '' : 's'}`;
+}
 // golang.org/x/text's transform and unicode/norm packages (String.normalize),
 // copied from GOROOT/src/vendor
 function vendorXText() {
@@ -104,10 +120,30 @@ export function createProject(projectName, installDependencies) {
 export function run(opts) {
     const sourcePath = opts.tsCode ? null : opts.source;
     const tsCode = opts.tsCode ? opts.tsCode : fs.readFileSync(sourcePath, 'utf-8');
+    fs.mkdirSync('dist', { recursive: true });
+    // Code typed into the prompt is saved as dist/script.ts, so it is
+    // type-checked and errors point at a real file
+    const entryPath = sourcePath ?? 'dist/script.ts';
+    if (!sourcePath)
+        fs.writeFileSync(entryPath, tsCode);
+    if (opts.typeCheck) {
+        const typeErrors = opts.typeCheck(entryPath);
+        if (typeErrors.length > 0) {
+            for (const d of typeErrors)
+                printDiagnostic(d.file, d.line, d.column, `error TS${d.code}`, d.message);
+            console.error(`\n${plural(typeErrors.length, 'type error')} (--no-typecheck skips the check)`);
+            process.exit(1);
+        }
+    }
     const sourceDir = sourcePath ? path.dirname(path.resolve(sourcePath)) : null;
+    // Node's platform names are GOOS names, except win32
+    const goos = platform() === 'win32' ? 'windows' : platform();
     const transpileOptions = {
         parse: opts.parse,
-        tsx: !!sourcePath && sourcePath.endsWith('.tsx')
+        tsx: !!sourcePath && sourcePath.endsWith('.tsx'),
+        fileName: displayPath(entryPath),
+        goFile: 'dist/code.go',
+        goos: goos
     };
     if (sourceDir) {
         transpileOptions.readFile = (specifier, fromDir) => {
@@ -127,7 +163,8 @@ export function run(opts) {
                         return {
                             content: fs.readFileSync(fullPath, 'utf-8'),
                             dir: path.dirname(fullPath),
-                            tsx: fullPath.endsWith('.tsx')
+                            tsx: fullPath.endsWith('.tsx'),
+                            path: displayPath(fullPath)
                         };
                     }
                     catch {
@@ -150,13 +187,18 @@ export function run(opts) {
             const typed = tryInjectDtsTypes(content, specifier, sourceDir);
             if (typed)
                 content = typed;
-            return { content, dir };
+            return { content, dir, path: displayPath(resolved.path) };
         };
     }
     const transpileResult = transpileToNative(tsCode, transpileOptions);
+    if (transpileResult.diagnostics.length > 0) {
+        for (const d of transpileResult.diagnostics)
+            printDiagnostic(d.file, d.line, d.column, 'error', d.message);
+        console.error(`\n${plural(transpileResult.diagnostics.length, 'error')}: TypeNative can't compile this yet`);
+        process.exit(1);
+    }
     const exeName = platform() === 'win32' ? 'native.exe' : 'native';
     const exePath = `dist/${exeName}`;
-    fs.mkdirSync('dist', { recursive: true });
     // Clean up stale Go files from previous runs before writing new ones
     for (const existing of fs.readdirSync('dist')) {
         if (existing.endsWith('.go') || existing === 'go.mod' || existing === 'go.sum')
@@ -191,12 +233,16 @@ export function run(opts) {
             'build',
             '-C',
             'dist',
+            // Path-independent cache keys: the vendored packages (sqlite is ~5 MB
+            // of Go) compile once, not again for every project directory
+            '-trimpath',
             '-o',
             exeName,
             ...goFiles.map((f) => f.slice('dist/'.length))
         ])
         : runCommand('go', ['build', '-o', exePath, ...goFiles]);
     if (buildResult.status !== 0) {
+        // Positions in .ts files come from line directives in the generated Go
         console.error('go build failed:');
         if (buildResult.stderr)
             console.error(buildResult.stderr.trim());
@@ -282,7 +328,7 @@ function resolveNpmPackage(fromDir, packageName) {
             for (const candidate of candidates) {
                 const fullPath = path.resolve(pkgDir, candidate);
                 try {
-                    return { content: fs.readFileSync(fullPath, 'utf-8'), dir: path.dirname(fullPath) };
+                    return { content: fs.readFileSync(fullPath, 'utf-8'), dir: path.dirname(fullPath), path: fullPath };
                 }
                 catch {
                     /* try next candidate */
@@ -324,7 +370,8 @@ function getTsConfig() {
             rootDir: '.',
             strict: true,
             noImplicitAny: true,
-            allowSyntheticDefaultImports: true
+            allowSyntheticDefaultImports: true,
+            skipLibCheck: true
         }
     };
     return JSON.stringify(tsConfig, null, 2);

package/bin/main.js

@@ -4,10 +4,11 @@
 import path from 'node:path';
 import { run, createProject } from './index.js';
 import { ask, askMultiline, confirm } from './prompt.js';
-import { parseAstJsonNative } from './parse-native.js';
+import { parseAstJsonNative, typeCheckNative } from './parse-native.js';
 (function main() {
     const scriptMode = process.argv.findIndex((a) => a === '--script') > -1;
     const newCommand = process.argv.findIndex((a) => a === '--new') > -1;
+    const noTypeCheck = process.argv.includes('--no-typecheck');
     const sourceIndex = process.argv.findIndex((a) => a === '--source');
     let source = sourceIndex > -1 ? process.argv[sourceIndex + 1] : null;
     const outputIndex = process.argv.findIndex((a) => a === '--output');
@@ -28,7 +29,10 @@ import { parseAstJsonNative } from './parse-native.js';
     if (!newCommand && scriptMode && !source) {
         tsCode = askMultiline('Write your typescript code here:');
     }
-    // The native compiler lives in native/, next to the package's govendor/
-    const vendorDir = path.join(path.dirname(path.resolve(process.argv[0])), '..', 'govendor');
-    run({ source, output, scriptMode, tsCode, parse: parseAstJsonNative, vendorDir });
+    // The native compiler lives in native/, next to the package's govendor/ and types/
+    const packageDir = path.join(path.dirname(path.resolve(process.argv[0])), '..');
+    const vendorDir = path.join(packageDir, 'govendor');
+    const typesDir = path.join(packageDir, 'types');
+    const typeCheck = noTypeCheck ? null : (fileName) => typeCheckNative(fileName, typesDir);
+    run({ source, output, scriptMode, tsCode, parse: parseAstJsonNative, typeCheck, vendorDir });
 })();

package/bin/node/system_extra.js

@@ -163,6 +163,9 @@ func tnSysctl(name string) string {
 }
 
 func TnOsTotalmem() float64 {
+	if total, _, ok := tnPlatformMemory(); ok {
+		return total
+	}
 	if n := tnMemInfo("MemTotal"); n >= 0 {
 		return n
 	}
@@ -180,6 +183,9 @@ func TnOsTotalmem() float64 {
 }
 
 func TnOsFreemem() float64 {
+	if _, free, ok := tnPlatformMemory(); ok {
+		return free
+	}
 	if n := tnMemInfo("MemAvailable"); n >= 0 {
 		return n
 	}
@@ -193,6 +199,9 @@ func TnOsFreemem() float64 {
 
 // Seconds since boot
 func TnOsUptime() float64 {
+	if n, ok := tnPlatformUptime(); ok {
+		return n
+	}
 	if data, err := os.ReadFile("/proc/uptime"); err == nil {
 		if f := strings.Fields(string(data)); len(f) > 0 {
 			n, _ := strconv.ParseFloat(f[0], 64)
@@ -572,9 +581,53 @@ func TnEventLoopUtilization(previous ...*TnLoopUtilization) *TnLoopUtilization {
 	}
 	return u
 }`;
+// Memory and uptime from the OS API where there's no /proc or sysctl
+// (Windows); the helper is picked per target OS (nodeSystemOS@os)
+const windowsSystemHelper = `// GlobalMemoryStatusEx's MEMORYSTATUSEX
+type tnMemoryStatusEx struct {
+	length               uint32
+	memoryLoad           uint32
+	totalPhys            uint64
+	availPhys            uint64
+	totalPageFile        uint64
+	availPageFile        uint64
+	totalVirtual         uint64
+	availVirtual         uint64
+	availExtendedVirtual uint64
+}
+
+var tnKernel32 = syscall.NewLazyDLL("kernel32.dll")
+var tnGlobalMemoryStatusEx = tnKernel32.NewProc("GlobalMemoryStatusEx")
+var tnGetTickCount64 = tnKernel32.NewProc("GetTickCount64")
+
+// Total and available physical memory in bytes
+func tnPlatformMemory() (float64, float64, bool) {
+	status := tnMemoryStatusEx{}
+	status.length = uint32(unsafe.Sizeof(status))
+	if ok, _, _ := tnGlobalMemoryStatusEx.Call(uintptr(unsafe.Pointer(&status))); ok == 0 {
+		return 0, 0, false
+	}
+	return float64(status.totalPhys), float64(status.availPhys), true
+}
+
+// Seconds since boot
+func tnPlatformUptime() (float64, bool) {
+	ms, _, _ := tnGetTickCount64.Call()
+	return float64(ms) / 1000, true
+}`;
+const otherSystemHelper = `// /proc or sysctl answer instead (TnOsTotalmem / TnOsFreemem / TnOsUptime)
+func tnPlatformMemory() (float64, float64, bool) {
+	return 0, 0, false
+}
+
+func tnPlatformUptime() (float64, bool) {
+	return 0, false
+}`;
 export function registerSystemExtra(r) {
     defineHelper(r, 'nodeUncaught', [], ['nodeEvents', 'nodeProcess', 'eventLoop', 'promise'], uncaughtHelper);
-    defineHelper(r, 'nodeSystem', ['math', 'os', 'os/exec', 'runtime', 'runtime/metrics', 'strconv', 'strings', 'time'], [], systemHelper);
+    defineHelper(r, 'nodeSystemOS@windows', ['syscall', 'unsafe'], [], windowsSystemHelper);
+    defineHelper(r, 'nodeSystemOS@other', [], [], otherSystemHelper);
+    defineHelper(r, 'nodeSystem', ['math', 'os', 'os/exec', 'runtime', 'runtime/metrics', 'strconv', 'strings', 'time'], ['nodeSystemOS@os'], systemHelper);
     defineHelper(r, 'nodePerfExtra', ['math', 'math/big', 'reflect', 'sort', 'time'], ['nodePerf', 'nodeSystem', 'eventLoop', 'nodeInvoke', 'dynamic', 'orderedMap'], perfExtraHelper);
     // process events handled by the loop
     for (const name of ['process.on', 'process.once', 'process.addListener']) {

package/bin/node/timers.js

@@ -18,8 +18,21 @@ var tnPerfMu sync.Mutex
 // Set by PerformanceObserver: new entries reach the observers
 var tnPerfHook func(e *TnPerformanceEntry)
 
+// Go's monotonic clock on Windows advances only at the timer interrupt, so
+// back-to-back readings repeat; each reading is kept later than the last
+// (by 1ns) so marks taken in a row stay in call order, as with Node's clock
+var tnPerfLast float64
+var tnPerfClockMu sync.Mutex
+
 func TnPerfNow() float64 {
-	return float64(time.Since(tnPerfStart).Nanoseconds()) / 1e6
+	now := float64(time.Since(tnPerfStart).Nanoseconds()) / 1e6
+	tnPerfClockMu.Lock()
+	defer tnPerfClockMu.Unlock()
+	if now <= tnPerfLast {
+		now = tnPerfLast + 1e-6
+	}
+	tnPerfLast = now
+	return now
 }
 
 func TnPerfTimeOrigin() float64 {

package/bin/node/tls.js

@@ -167,7 +167,9 @@ func tnVerifyPeer(certs []*x509.Certificate, roots *x509.CertPool, host string)
 				return TnNodeError("Error", "CERT_NOT_YET_VALID", "certificate is not yet valid")
 			}
 			return TnNodeError("Error", "CERT_HAS_EXPIRED", "certificate has expired")
-		case errors.As(err, &unknown):
+		// macOS's platform verifier (nil roots) reports an untrusted chain as a
+		// plain error, not UnknownAuthorityError
+		case errors.As(err, &unknown) || roots == nil:
 			if len(certs) == 1 && bytes.Equal(leaf.RawIssuer, leaf.RawSubject) {
 				return TnNodeError("Error", "DEPTH_ZERO_SELF_SIGNED_CERT", "self-signed certificate")
 			}

package/bin/parse-native.js

@@ -13,6 +13,16 @@ export function parseAstJsonNative(code, tsx) {
     }
     return JSON.parse(result.stdout);
 }
+// Type-checks the program rooted at fileName with typescript-go
+// (tsparser --check); typesDir holds the bundled declarations
+export function typeCheckNative(fileName, typesDir) {
+    const exe = findTsparser();
+    const result = childProcess.spawnSync(exe, ['--check', fileName, typesDir], { encoding: 'utf-8' });
+    if (result.status !== 0) {
+        throw new Error('tsparser --check failed: ' + result.stderr);
+    }
+    return JSON.parse(result.stdout);
+}
 // Locates the tsparser binary: TYPENATIVE_TSPARSER env var, next to this
 // executable, or in a sibling tsparser/ directory (dev checkout layout).
 function findTsparser() {

package/bin/parse-node.js

@@ -83,8 +83,17 @@ function declarationKind(flags) {
 function isNode(v) {
     return typeof v === 'object' && v !== null && typeof v.kind === 'number' && typeof v.pos === 'number';
 }
+// The file being converted, for node positions
+let currentSourceFile;
 function convertNode(node) {
     const obj = { kind: KIND_NAMES[node.kind] ?? String(node.kind) };
+    // 1-based line and column of the node's first token (columns count UTF-16
+    // units, as in the Go producer); the transpiler maps Go positions back to them
+    if (node.kind !== ts.SyntaxKind.SourceFile && node.pos >= 0) {
+        const start = currentSourceFile.getLineAndCharacterOfPosition(node.getStart(currentSourceFile));
+        obj.line = start.line + 1;
+        obj.column = start.character + 1;
+    }
     if (TEXT_KINDS.has(node.kind)) {
         obj.text = node.text ?? node.escapedText;
     }
@@ -122,5 +131,6 @@ export function parseAstJson(code, tsx) {
     const sourceFile = tsx
         ? ts.createSourceFile('main.tsx', code, ts.ScriptTarget.ES2020, true, ts.ScriptKind.TSX)
         : ts.createSourceFile('main.ts', code, ts.ScriptTarget.ES2020, true, ts.ScriptKind.TS);
+    currentSourceFile = sourceFile;
     return convertNode(sourceFile);
 }