typenative 0.0.20 → 0.0.21

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

@@ -1,9 +1,14 @@
 # Triggered by tags matching "TypeNative_{version}" (e.g. TypeNative_0.0.18)
 # Runs tests, creates a GitHub release, and publishes to npm.
 #
-# Requires an NPM_TOKEN secret set in your GitHub repository settings.
-# Setup: npmjs.com → Access Tokens → Generate New Token (Automation)
-#        GitHub repo → Settings → Secrets → Actions → New secret: NPM_TOKEN
+# Uses npm Trusted Publishing (OIDC) — no NPM_TOKEN secret needed.
+# One-time setup on npmjs.com:
+#   typenative package page → Settings → Publishing access → Trusted Publisher → Connect GitHub
+#     - Organization or user: danisss9
+#     - Repository:           typenative
+#     - Workflow filename:    npm-publish-github-packages.yml
+#     - Environment name:     (leave blank)
+# Requires npm >= 11.5.1 (ensured below) and the `id-token: write` permission.
 
 name: Release & Publish
 
@@ -61,6 +66,9 @@ jobs:
           node-version: 24
           registry-url: https://registry.npmjs.org/
 
+      # Trusted Publishing (OIDC) requires npm >= 11.5.1 — ensure we have it
+      - run: npm install -g npm@latest
+
       - name: Extract version from tag
         id: version
         run: echo "VERSION=${GITHUB_REF_NAME#TypeNative_}" >> $GITHUB_OUTPUT
@@ -70,6 +78,6 @@ jobs:
 
       - run: npm ci
 
+      # 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
-        env:
-          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

package/CHANGELOG.md

@@ -5,6 +5,38 @@ All notable changes to TypeNative will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.0.21] - 2026-09-06
+
+Self-hosting milestone: the compiler no longer depends on `execa`, `fs-extra`, or `nanoid`, and the
+TypeScript parser is decoupled behind an injectable, normalized JSON AST — produced either by the
+`typescript` npm package (dev CLI) or by the new Go-native `tsparser` tool (self-hosted binary).
+Verified: all 33 test specs transpile identically through both parser paths, and the compiler now
+transpiles its own source all the way to `go build`.
+
+### Added
+
+- **`node:fs` mappings**: `readFileSync`, `writeFileSync`, `appendFileSync`, `existsSync`, `mkdirSync`, `readdirSync`, `copyFileSync`, `rmSync` → Go helpers (`TnReadFile`, `TnWriteFile`, …)
+- **`node:url` mappings**: `fileURLToPath`, `pathToFileURL`
+- **`node:os` mappings**: `platform` (returns `win32`/`darwin`/linux like Node), `homedir`, `tmpdir`
+- **`node:child_process` mappings**: sync `exec`/`execSync`/`spawnSync` shaped like Node's `spawnSync` (`{ stdout, stderr, status }`); `{ stdio: 'inherit' }` runs with the parent's stdio (`TnRunInherit`); `{ input }` pipes stdin (`TnExecInput`)
+- **`node:readline` mapping**: synchronous `question(prompt)` for interactive native prompts (`TnQuestion`, single buffered stdin reader)
+- **`process.env.X`** → `TnGetenv("X")`
+- **Go helper registry**: node-stdlib helpers are emitted once into the main output file with correct per-file import scoping (helpers register their Go packages lazily; import lists are computed after function bodies are visited)
+- **`tsparser/` Go tool**: parses TypeScript via `github.com/buke/typescript-go-internal` (native Go port of the TypeScript parser — no embedded JS runtime) and emits a normalized JSON AST with TypeScript-API kind and field names
+- **`src/parse-node.ts`**: Node adapter producing the identical JSON AST from the `typescript` npm package; verified byte-identical against `tsparser` on all test specs and all compiler sources
+- **`src/parse-native.ts`**: self-hosted parser client (spawns the `tsparser` binary, `TYPENATIVE_TSPARSER` env override)
+- **Injectable parser**: `transpileToNative(code, { parse, readFile })` — the transpiler no longer imports `typescript`
+- **Unbraced `if`/`else if`/`else` statements**: single-statement branches now emit valid Go blocks
+- **`%` and `%=` on numbers** → `math.Mod`
+- **`./x.js` → `x.ts` import resolution** for ES-style relative specifiers
+- **Tests 31–32**: node-stdlib end-to-end spec (fs round-trip, os platform, shell exec) and subprocess/control-flow spec
+
+### Changed
+
+- **CLI entry split**: `bin/cli.js` (npm `bin`) keeps inquirer for interactive Node use; the transpilable core lives in `src/index.ts` (`run`/`createProject`), with `src/main.ts` as the self-hosting entry and `src/prompt.ts` (transpilable sync prompts) replacing inquirer in native builds
+- **Transpiler internals**: the `ts` typechecker is replaced by syntactic `typeNodeToText`; node predicates became plain `isX()` kind-string functions; operator tokens map through a kind-name table
+- Dropped runtime dependencies: `execa`, `fs-extra`, `nanoid` (replaced by a local `goSafeId`)
+
 ## [0.0.20] - 2026-03-16
 
 ### Added

package/TODO.md

@@ -0,0 +1,34 @@
+# Self-Hosting Roadmap
+
+Goal: TypeNative transpiles itself into a native Go binary (1.0 milestone).
+
+## Done
+- [x] node:fs mappings (read/write/append/exists/mkdir/readdir/copy/rm) via Go helpers
+- [x] node:url (fileURLToPath/pathToFileURL), node:os (platform/homedir/tmpdir)
+- [x] node:child_process (spawnSync-shaped sync API, stdio-inherit runs)
+- [x] node:readline sync `question` (stdin prompts in native binaries)
+- [x] Go helper-function registry emitted into the main output file
+- [x] Per-file import scoping (imports registered after function-body visits)
+- [x] Unbraced if/else-if/else statements, `%`/`%=` → math.Mod
+- [x] nanoid/fs-extra/execa removed from src; inquirer isolated in Node-only cli.ts
+- [x] Transpilable core: src/index.ts (run/createProject), src/prompt.ts, src/main.ts (self-host entry)
+
+## Done (phase 3a/3b)
+- [x] tsparser/ Go tool: parses TS via buke/typescript-go-internal (no JS runtime),
+      emits normalized JSON AST (kind + TS-spec field names)
+- [x] src/parse-node.ts: Node adapter (typescript npm pkg → same JSON shape)
+- [x] Verified byte-identical AST signatures across all 32 test specs AND all
+      compiler sources (incl. transpiler.ts, 521k-char signature)
+
+- [x] ts shim converted to plain isX() functions + string kind literals
+      (object-literal shim was itself untranspilable)
+- [x] Phase 3c: transpiler.ts no longer imports `typescript` — consumes the JSON AST
+      via an injected parse function (ts shim keeps predicate call sites); operator
+      tokens, process.env, stdin-exec mappings added; verified identical Go output
+      via npm parser and Go-parser paths on all 33 test specs
+- [ ] Phase 4: dogfood src/transpiler.ts (2.6k lines): regex /g semantics,
+      String.replace with function replacer, JSON.parse result typing, object spread,
+      Array.includes on untyped values, default-import namespace stripping (ts.x → x)
+- [ ] import.meta.url lowering
+- [ ] Phase 5: stage-1/stage-2 bootstrap + run test suite through the native binary
+- [ ] Phase 5: CI self-hosting job; README/CHANGELOG updates

package/bin/cli.js

@@ -0,0 +1,62 @@
+#!/usr/bin/env node
+// Node CLI entry point (npm `bin`). Interactive prompts use inquirer here;
+// the actual compiler logic lives in the transpilable src/index.ts.
+import inquirer from 'inquirer';
+import { run, createProject } from './index.js';
+import { parseAstJson } from './parse-node.js';
+(async function main() {
+    const scriptMode = process.argv.findIndex((a) => a === '--script') > -1;
+    const newCommand = process.argv.findIndex((a) => a === '--new') > -1;
+    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');
+    const output = outputIndex > -1 ? process.argv[outputIndex + 1] : null;
+    const answers = await inquirer.prompt([
+        {
+            type: 'input',
+            name: 'projectName',
+            message: 'Enter Project Name:',
+            when: newCommand,
+            validate: (input) => input.trim() !== ''
+        },
+        {
+            type: 'confirm',
+            name: 'installDependencies',
+            message: 'Do you want to install dependencies?',
+            when: newCommand
+        },
+        {
+            type: 'input',
+            name: 'path',
+            message: 'Enter Path to typescript main file:',
+            when: !newCommand && !scriptMode && !source,
+            validate: (input) => input.trim() !== ''
+        },
+        {
+            type: 'input',
+            name: 'output',
+            message: 'Enter Output Path:',
+            when: !newCommand && !scriptMode && !output,
+            validate: (input) => input.trim() !== ''
+        },
+        {
+            type: 'editor',
+            name: 'tsCode',
+            message: 'Write your typescript code here:',
+            when: !newCommand && scriptMode && !source,
+            default: `console.log('Hello, World!');`
+        }
+    ]);
+    if (newCommand) {
+        createProject(answers.projectName.trim(), answers.installDependencies);
+        return;
+    }
+    const sourcePath = answers.tsCode ? null : (source ?? answers.path ?? null);
+    run({
+        source: sourcePath,
+        output: output ?? answers.output ?? null,
+        scriptMode,
+        tsCode: answers.tsCode ?? null,
+        parse: parseAstJson
+    });
+})();

package/bin/index.js

@@ -1,151 +1,123 @@
-#!/usr/bin/env node
-import inquirer from 'inquirer';
-import fs from 'fs-extra';
+// Core compiler logic — kept free of Node-only dependencies (inquirer, execa,
+// fs-extra) so this module transpiles with TypeNative itself.
+// Node-only interactive prompting lives in src/cli.ts; the self-hosted entry
+// point is src/main.ts.
 import path from 'node:path';
-import { execa } from 'execa';
+import * as fs from 'node:fs';
+import { platform } from 'node:os';
+// TypeNative maps node:child_process to a synchronous Go API whose shape differs
+// from Node's; under Node these functions are never called (the CLI wrapper does
+// not reach them), so they're accessed through `any` casts for type-checking.
+import * as childProcess from 'node:child_process';
 import { transpileToNative } from './transpiler.js';
-import { fileURLToPath } from 'node:url';
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-(async function main() {
-    const scriptMode = process.argv.findIndex((a) => a === '--script') > -1;
-    const newCommand = process.argv.findIndex((a) => a === '--new') > -1;
-    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');
-    const output = outputIndex > -1 ? process.argv[outputIndex + 1] : null;
-    const answers = await inquirer.prompt([
-        {
-            type: 'input',
-            name: 'projectName',
-            message: 'Enter Project Name:',
-            when: newCommand,
-            validate: (input) => input.trim() !== ''
-        },
-        {
-            type: 'confirm',
-            name: 'installDependencies',
-            message: 'Do you want to install dependencies?',
-            when: newCommand
-        },
-        {
-            type: 'input',
-            name: 'path',
-            message: 'Enter Path to typescript main file:',
-            when: !newCommand && !scriptMode && !source,
-            validate: (input) => input.trim() !== ''
-        },
-        {
-            type: 'input',
-            name: 'output',
-            message: 'Enter Output Path:',
-            when: !newCommand && !scriptMode && !output,
-            validate: (input) => input.trim() !== ''
-        },
-        {
-            type: 'editor',
-            name: 'tsCode',
-            message: 'Write your typescript code here:',
-            when: !newCommand && scriptMode && !source,
-            default: `console.log('Hello, World!');`
-        }
-    ]);
-    if (newCommand) {
-        const projectName = answers.projectName.trim();
-        await fs.ensureDir(projectName);
-        await fs.writeFile(path.join(projectName, 'main.ts'), `// Write your TypeScript code here\nconsole.log('Hello, World!');\n`, { encoding: 'utf-8' });
-        await fs.writeFile(path.join(projectName, 'tsconfig.json'), getTsConfig(), {
-            encoding: 'utf-8'
-        });
-        await fs.writeFile(path.join(projectName, 'package.json'), getPackageJson(projectName), {
-            encoding: 'utf-8'
-        });
-        await fs.writeFile(path.join(projectName, '.gitignore'), getGitIgnore(), {
-            encoding: 'utf-8'
-        });
-        await fs.writeFile(path.join(projectName, 'README.md'), getReadMe(projectName), {
-            encoding: 'utf-8'
-        });
-        console.log(`Project "${projectName}" created successfully!`);
-        if (answers.installDependencies) {
-            console.log('Installing dependencies...');
-            await execa('npm', ['install'], { cwd: projectName, stdio: 'inherit' });
-            console.log('Dependencies installed successfully!');
+// Run a command and capture its output. Uses Node's spawnSync under Node and a
+// Go helper (os/exec) once transpiled — both synchronous, same result shape.
+export function runCommand(name, args) {
+    const result = childProcess.spawnSync(name, args, { encoding: 'utf-8' });
+    return { stdout: result.stdout, stderr: result.stderr, status: result.status };
+}
+// Run a command with the parent's stdio, returns the exit code.
+export function runInherit(name, args = []) {
+    const result = childProcess.spawnSync(name, args, { stdio: 'inherit' });
+    return result.status;
+}
+export function createProject(projectName, installDependencies) {
+    fs.mkdirSync(projectName, { recursive: true });
+    fs.writeFileSync(path.join(projectName, 'main.ts'), `// Write your TypeScript code here\nconsole.log('Hello, World!');\n`);
+    fs.writeFileSync(path.join(projectName, 'tsconfig.json'), getTsConfig());
+    fs.writeFileSync(path.join(projectName, 'package.json'), getPackageJson(projectName));
+    fs.writeFileSync(path.join(projectName, '.gitignore'), getGitIgnore());
+    fs.writeFileSync(path.join(projectName, 'README.md'), getReadMe(projectName));
+    console.log(`Project "${projectName}" created successfully!`);
+    if (installDependencies) {
+        console.log('Installing dependencies...');
+        // npm --prefix avoids needing cwd support in the subprocess binding
+        const result = runCommand('npm', ['install', '--prefix', projectName]);
+        if (result.stdout)
+            console.log(result.stdout.trim());
+        if (result.status !== 0) {
+            if (result.stderr)
+                console.error(result.stderr.trim());
+            process.exit(result.status);
         }
-        return;
+        console.log('Dependencies installed successfully!');
     }
-    const sourcePath = answers.tsCode ? null : (source ?? answers.path ?? null);
-    const tsCode = answers.tsCode
-        ? answers.tsCode
-        : await fs.readFile(sourcePath, { encoding: 'utf-8' });
+}
+export function run(opts) {
+    const sourcePath = opts.tsCode ? null : opts.source;
+    const tsCode = opts.tsCode ? opts.tsCode : fs.readFileSync(sourcePath, 'utf-8');
     const sourceDir = sourcePath ? path.dirname(path.resolve(sourcePath)) : null;
-    const transpileResult = transpileToNative(tsCode, sourceDir
-        ? {
-            readFile: (specifier, fromDir) => {
-                const baseDir = fromDir ?? sourceDir;
-                // Relative or absolute path → resolve from baseDir
-                if (specifier.startsWith('.') || specifier.startsWith('/')) {
-                    for (const candidate of [specifier + '.ts', specifier]) {
-                        try {
-                            const fullPath = path.resolve(baseDir, candidate);
-                            return {
-                                content: fs.readFileSync(fullPath, 'utf-8'),
-                                dir: path.dirname(fullPath)
-                            };
-                        }
-                        catch {
-                            /* not found */
-                        }
+    const transpileOptions = { parse: opts.parse };
+    if (sourceDir) {
+        transpileOptions.readFile = (specifier, fromDir) => {
+            const baseDir = fromDir ?? sourceDir;
+            // Relative or absolute path → resolve from baseDir
+            if (specifier.startsWith('.') || specifier.startsWith('/')) {
+                // ES convention: ./x.js may refer to x.ts
+                const tsSpecifier = specifier.endsWith('.js')
+                    ? specifier.replace(/\.js$/, '.ts')
+                    : specifier;
+                for (const candidate of [tsSpecifier + '.ts', tsSpecifier, specifier]) {
+                    try {
+                        const fullPath = path.resolve(baseDir, candidate);
+                        return {
+                            content: fs.readFileSync(fullPath, 'utf-8'),
+                            dir: path.dirname(fullPath)
+                        };
+                    }
+                    catch {
+                        /* not found */
                     }
-                    return null;
-                }
-                // npm package — walk up from baseDir looking for node_modules/<name>
-                const resolved = resolveNpmPackage(baseDir, specifier);
-                if (!resolved)
-                    return null;
-                let { content, dir } = resolved;
-                // Normalize CommonJS to ES module syntax
-                if (!content.includes('export ') && (content.includes('module.exports') || content.includes('exports.'))) {
-                    content = normalizeCjsContent(content);
                 }
-                // Inject types from a local ambient .d.ts if available
-                const typed = tryInjectDtsTypes(content, specifier, sourceDir);
-                if (typed)
-                    content = typed;
-                return { content, dir };
+                return null;
             }
-        }
-        : undefined);
-    const exeName = process.platform === 'win32' ? 'native.exe' : 'native';
+            // npm package — walk up from baseDir looking for node_modules/<name>
+            const resolved = resolveNpmPackage(baseDir, specifier);
+            if (!resolved)
+                return null;
+            let { content, dir } = resolved;
+            // Normalize CommonJS to ES module syntax
+            if (!content.includes('export ') &&
+                (content.includes('module.exports') || content.includes('exports.'))) {
+                content = normalizeCjsContent(content);
+            }
+            // Inject types from a local ambient .d.ts if available
+            const typed = tryInjectDtsTypes(content, specifier, sourceDir);
+            if (typed)
+                content = typed;
+            return { content, dir };
+        };
+    }
+    const transpileResult = transpileToNative(tsCode, transpileOptions);
+    const exeName = platform() === 'win32' ? 'native.exe' : 'native';
     const exePath = `dist/${exeName}`;
-    await fs.ensureDir('dist');
+    fs.mkdirSync('dist', { recursive: true });
     // Clean up stale Go files from previous runs before writing new ones
-    for (const existing of await fs.readdir('dist')) {
+    for (const existing of fs.readdirSync('dist')) {
         if (existing.endsWith('.go'))
-            await fs.remove(`dist/${existing}`);
+            fs.rmSync(`dist/${existing}`);
     }
-    await fs.writeFile('dist/code.go', transpileResult.main, { encoding: 'utf-8' });
+    fs.writeFileSync('dist/code.go', transpileResult.main);
     const goFiles = ['dist/code.go'];
     for (const [filename, content] of transpileResult.files) {
-        await fs.writeFile(`dist/${filename}`, content, { encoding: 'utf-8' });
+        fs.writeFileSync(`dist/${filename}`, content);
         goFiles.push(`dist/${filename}`);
     }
-    await execa('go', ['build', '-o', exePath, ...goFiles], {
-        stdio: 'inherit'
-    });
-    // await fs.remove('dist/code.go');
-    if (scriptMode) {
-        await execa(exePath, {
-            stdio: 'inherit'
-        });
-        //await fs.remove(exePath);
+    const buildResult = runCommand('go', ['build', '-o', exePath, ...goFiles]);
+    if (buildResult.status !== 0) {
+        console.error('go build failed:');
+        if (buildResult.stderr)
+            console.error(buildResult.stderr.trim());
+        process.exit(1);
     }
-    else if (output || answers.output) {
-        await fs.copy(exePath, output ?? answers.output, { overwrite: true });
-        //await fs.remove(exePath);
-        console.log(`Created native executable at: ${output ?? answers.output}`);
+    if (opts.scriptMode) {
+        process.exit(runInherit(exePath));
     }
-})();
+    else if (opts.output) {
+        fs.copyFileSync(exePath, opts.output);
+        console.log(`Created native executable at: ${opts.output}`);
+    }
+}
 function normalizeCjsContent(code) {
     code = code.replace(/['"]use strict['"];?\n?/g, '');
     code = code.replace(/(?:module\.exports|exports)\.(\w+)\s*=\s*function\s*\w*\s*\(/g, 'export function $1(');
@@ -237,7 +209,7 @@ function resolveNpmPackage(fromDir, packageName) {
     return null;
 }
 function getPackageJson(projectName) {
-    const exeName = process.platform === 'win32' ? `${projectName}.exe` : projectName;
+    const exeName = platform() === 'win32' ? `${projectName}.exe` : projectName;
     const pckg = {
         name: projectName,
         version: '1.0.0',
@@ -274,7 +246,7 @@ bin/
 `;
 }
 function getReadMe(projectName) {
-    const exeName = process.platform === 'win32' ? `${projectName}.exe` : projectName;
+    const exeName = platform() === 'win32' ? `${projectName}.exe` : projectName;
     return `# ${projectName}
 
 This project was created using TypeNative, a tool to transpile TypeScript code to native Go code.

package/bin/main.js

@@ -0,0 +1,31 @@
+// Self-hosting entry point: this file is what TypeNative compiles to produce
+// the native compiler binary. Interactive prompts use the transpilable
+// prompt module (sync stdin) instead of inquirer.
+import { run, createProject } from './index.js';
+import { ask, askMultiline, confirm } from './prompt.js';
+import { parseAstJsonNative } 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 sourceIndex = process.argv.findIndex((a) => a === '--source');
+    let source = sourceIndex > -1 ? process.argv[sourceIndex + 1] : null;
+    const outputIndex = process.argv.findIndex((a) => a === '--output');
+    let output = outputIndex > -1 ? process.argv[outputIndex + 1] : null;
+    if (newCommand) {
+        const projectName = ask('Enter Project Name:');
+        const installDependencies = confirm('Do you want to install dependencies?');
+        createProject(projectName, installDependencies);
+        return;
+    }
+    let tsCode = null;
+    if (!newCommand && !scriptMode && !source) {
+        source = ask('Enter Path to typescript main file:');
+    }
+    if (!newCommand && !scriptMode && !output) {
+        output = ask('Enter Output Path:');
+    }
+    if (!newCommand && scriptMode && !source) {
+        tsCode = askMultiline('Write your typescript code here:');
+    }
+    run({ source, output, scriptMode, tsCode, parse: parseAstJsonNative });
+})();

package/bin/parse-native.js

@@ -0,0 +1,37 @@
+// Self-hosted parser: spawns the tsparser Go tool (tsparser/main.go) to parse
+// TypeScript into the normalized JSON AST. Fully transpilable — used by the
+// native compiler binary instead of the typescript npm package.
+import * as path from 'node:path';
+import * as fs from 'node:fs';
+import * as childProcess from 'node:child_process';
+export function parseAstJsonNative(code) {
+    const exe = findTsparser();
+    const result = childProcess.spawnSync(exe, [], { input: code, encoding: 'utf-8' });
+    if (result.status !== 0) {
+        throw new Error('tsparser 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() {
+    const exeName = platformIsWindows() ? 'tsparser.exe' : 'tsparser';
+    const envPath = process.env.TYPENATIVE_TSPARSER;
+    if (envPath && fs.existsSync(envPath))
+        return envPath;
+    const thisDir = path.dirname(path.resolve(process.argv[0]));
+    const candidates = [
+        path.join(thisDir, exeName),
+        path.join(thisDir, 'tsparser', exeName),
+        path.join(thisDir, '..', 'tsparser', exeName),
+        path.join(thisDir, '..', '..', 'tsparser', exeName)
+    ];
+    for (const candidate of candidates) {
+        if (fs.existsSync(candidate))
+            return candidate;
+    }
+    throw new Error('tsparser binary not found; set TYPENATIVE_TSPARSER');
+}
+function platformIsWindows() {
+    return process.platform === 'win32';
+}

package/bin/parse-node.js

@@ -0,0 +1,110 @@
+// Node-side AST adapter: converts a `typescript` npm package AST into the same
+// normalized JSON shape that the `tsparser` Go tool emits
+// (tsparser/main.go). The transpiler consumes this shape, so dev-CLI output and
+// self-hosted (Go parser) output are field-compatible.
+//
+// Node-only module: imports the `typescript` package directly and is injected
+// into the transpiler by the Node CLI wrapper (src/cli.ts). The self-hosted
+// binary uses src/parse-native.ts instead.
+import ts from 'typescript';
+// Internal ts.Node bookkeeping properties that must not leak into the JSON
+const SKIP_PROPS = new Set([
+    'pos',
+    'end',
+    'flags',
+    'modifierFlagsCache',
+    'transformFlags',
+    'parent',
+    'original',
+    'symbol',
+    'id',
+    'jsDoc',
+    'flowNode',
+    'contextFlags',
+    'parserContextFlags',
+    'excludeFlags',
+    'modifierFlags',
+    'flowId',
+    'symbolCount',
+    'identifierCount',
+    'nodeArrayCache',
+    'parsedByParser',
+    'autoGenerateKind',
+    'autoGenerateId',
+    'emitNode',
+    'localSymbol',
+    // 'text'/'escapedText' are only emitted for token-like kinds (TEXT_KINDS);
+    // SourceFile.text would otherwise leak the whole source into the AST
+    'text',
+    'escapedText',
+    'endOfFileToken',
+    'externalModuleIndicator',
+    'commonJsModuleIndicator',
+    'localJsxNamespace',
+    'localJsxFactory',
+    'localJsxFragmentFactory'
+]);
+const TEXT_KINDS = new Set([
+    ts.SyntaxKind.Identifier,
+    ts.SyntaxKind.PrivateIdentifier,
+    ts.SyntaxKind.StringLiteral,
+    ts.SyntaxKind.NumericLiteral,
+    ts.SyntaxKind.BigIntLiteral,
+    ts.SyntaxKind.NoSubstitutionTemplateLiteral,
+    ts.SyntaxKind.RegularExpressionLiteral,
+    ts.SyntaxKind.TemplateHead,
+    ts.SyntaxKind.TemplateMiddle,
+    ts.SyntaxKind.TemplateTail,
+    ts.SyntaxKind.JsxText
+]);
+// Reverse enum map preferring canonical names over aliases
+// (ts.SyntaxKind[8] is "FirstLiteralToken", the alias of NumericLiteral)
+const KIND_NAMES = (() => {
+    const names = {};
+    for (const key of Object.keys(ts.SyntaxKind)) {
+        const val = ts.SyntaxKind[key];
+        if (typeof val === 'number' && names[val] === undefined)
+            names[val] = key;
+    }
+    return names;
+})();
+function isNode(v) {
+    return typeof v === 'object' && v !== null && typeof v.kind === 'number' && typeof v.pos === 'number';
+}
+function convertNode(node) {
+    const obj = { kind: KIND_NAMES[node.kind] ?? String(node.kind) };
+    if (TEXT_KINDS.has(node.kind)) {
+        obj.text = node.text ?? node.escapedText;
+    }
+    for (const key of Object.keys(node)) {
+        if (SKIP_PROPS.has(key))
+            continue;
+        const v = node[key];
+        if (typeof v === 'function')
+            continue;
+        if (v === null || v === undefined)
+            continue;
+        if (isNode(v)) {
+            obj[key] = convertNode(v);
+        }
+        else if (Array.isArray(v)) {
+            const arr = v.filter((e) => isNode(e)).map((e) => convertNode(e));
+            if (arr.length > 0)
+                obj[key] = arr;
+        }
+        else if (typeof v === 'number' && key === 'operator') {
+            // unary operator: emit the kind name (matches the Go producer)
+            obj[key] = KIND_NAMES[v] ?? String(v);
+        }
+        else if (typeof v === 'string' || typeof v === 'number' || typeof v === 'boolean') {
+            if (key !== 'kind')
+                obj[key] = v;
+        }
+    }
+    return obj;
+}
+// Parse TypeScript source into the normalized JSON AST shape.
+export function parseAstJson(code) {
+    const sourceFile = ts.createSourceFile('main.ts', code, ts.ScriptTarget.ES2020, true, ts.ScriptKind.TS);
+    return convertNode(sourceFile);
+}