typenative 0.0.20 → 0.1.0

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
 
@@ -22,7 +27,7 @@ jobs:
           node-version: 24
       - uses: actions/setup-go@v5
         with:
-          go-version: '1.21'
+          go-version: '1.23'
       - run: npm ci
       - run: npm ci
         working-directory: test
@@ -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,76 @@ 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.1.0] - 2026-10-09
+
+TypeNative compiles itself: `src/main.ts` builds into a native `typenative` binary that passes the
+whole test suite and regenerates its own Go source identically (stage-1/stage-2 bootstrap).
+
+### Added
+
+- **Native compiler**: `npm run build:native` builds `native/typenative` and `native/tsparser`
+- **`any` / `unknown` at runtime**: property and index access, truthiness, equality (objects by
+  identity), method calls, spreads and conversions to typed values via a small Go runtime
+  (`TnGet`, `TnSet`, `TnAs`, …) — no guessed types
+- **Language**: object spread, `??=`, `in`, `typeof`, `continue`, optional and destructured
+  parameters, constructor parameter properties, `return` inside `try`/`catch`, object type
+  aliases and inline object types → Go structs, `Record<K, V>` and dictionaries → Go maps
+- **Typing**: contextual types for object/array/function literals, narrowing of `T | undefined`,
+  JS truthiness, `??` chains, nullable ternaries, optional chains across calls
+- **Library**: `toFixed`, `Math.max(...arr)`, `sort` with comparators, `flat`, typed
+  `Object.keys`/`values`, regex `replace` (`/g`, `$1`/`$&`, function replacers), `match`/`split`
+  with regexes, `Array.isArray`, `console.warn`, `fs.unlinkSync`, `process.env['X']`
+- Tests 33–50
+
+### Changed
+
+- **Go 1.23 or newer is required** (generated code uses `slices`/`maps` iterator helpers)
+- `process.platform` reports Node's names (`win32`, `darwin`, `linux`)
+- `JSON.stringify` no longer escapes `<`, `>`, `&` (like JS)
+- Out-of-range array/string reads give zero values instead of panicking (JS `undefined`)
+- Imports and helpers are emitted in sorted order
+- Map, Set and Record keep insertion order (like JS); objects are references (Go pointers)
+
+### Fixed
+
+- The test suite never ran (scripts called `bin/index.js`, which has no entry point); it now runs
+  through `bin/cli.js`
+- Phase 3c regressions (19 tests): AST kind names, missing parent links, `extends` detection
+- Main-file top-level variables were invisible to functions
+- `spawnSync` with `stdio: 'inherit'` dropped its arguments
+
+## [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/README.md

@@ -5,7 +5,7 @@ Build native applications using Typescript.
 ## PreRequisites
 
 - [Nodejs v24](https://nodejs.org/en) or newer.
-- [Go 1.21](https://go.dev/doc/install) or newer.
+- [Go 1.23](https://go.dev/doc/install) or newer.
 
 ## Get Started
 
@@ -24,7 +24,7 @@ TypeNative currently supports a focused subset of TypeScript syntax elements tha
 | boolean        |    ✅     | Transpiled to `bool`                                          |
 | string         |    ✅     |                                                               |
 | null           |    ✅     |                                                               |
-| any            |    ✅     | Used for type inference                                       |
+| any / unknown  |    ✅     | Dynamic values handled at runtime (JSON-like objects, arrays, primitives) |
 | Nullable types |    ✅     | `T \| null` / `T \| undefined` transpiled to Go pointer types |
 
 **Variables & Objects**
@@ -36,6 +36,9 @@ TypeNative currently supports a focused subset of TypeScript syntax elements tha
 | Object shorthand       |    ✅     | `{ name }` → `{ name: name }`                  |
 | Array destructuring    |    ✅     | `const [a, b] = arr`                            |
 | Object destructuring   |    ✅     | `const { x, y } = obj`                          |
+| Object spread          |    ✅     | `{ ...base, x: 1 }`                             |
+| Records / dictionaries |    ✅     | `Record<K, V>` and objects indexed by key → Go maps |
+| Object type aliases    |    ✅     | `type P = { x: number }` → Go struct            |
 
 **Operators**
 
@@ -50,6 +53,9 @@ TypeNative currently supports a focused subset of TypeScript syntax elements tha
 | Ternary expressions      |    ✅     | `condition ? a : b`            |
 | Nullish coalescing       |    ✅     | `??` operator                  |
 | Optional chaining        |    ✅     | `obj?.prop`, `arr?.[i]`        |
+| Nullish assignment       |    ✅     | `x ??= value`                  |
+| `in` / `typeof`          |    ✅     | `"key" in obj`, `typeof x === "string"` |
+| JS truthiness            |    ✅     | `if (str)`, `!count`, `a \|\| fallback` on any type |
 
 **Control Flow**
 
@@ -58,11 +64,13 @@ TypeNative currently supports a focused subset of TypeScript syntax elements tha
 | If/Else statements |    ✅     | Fully supported                                        |
 | Switch statements  |    ✅     | Case and default statements                            |
 | For loops          |    ✅     | Standard `for` loops                                   |
+| Continue           |    ✅     | `continue` in all loop kinds                           |
 | For...of loops     |    ✅     | Arrays, Maps, Sets; `Object.entries()` unwrapping      |
 | For...in loops     |    ✅     | Iterates keys via Go `range`                           |
 | While loops        |    ✅     | Transpiled to Go's `for` loops                         |
 | Do...while loops   |    ✅     | Implemented with conditional break                     |
 | Try/Catch/Finally  |    ✅     | `throw` → `panic`; catch/finally via `defer`/`recover` |
+| Narrowing          |    ✅     | `T \| undefined` narrowed after `if (x)`, `x !== undefined`, early returns |
 
 **Data Structures & Array Methods**
 
@@ -74,6 +82,8 @@ TypeNative currently supports a focused subset of TypeScript syntax elements tha
 | Method chaining            |    ✅     | e.g. `.map(...).filter(...).join(...)`                                                        |
 | Map                        |    ✅     | `Map<K, V>` → Go `map[K]V`; `.set()`, `.get()`, `.has()`, `.delete()`, `.clear()`, `.size`  |
 | Set                        |    ✅     | `Set<T>` → Go `map[T]struct{}`; `.add()`, `.has()`, `.delete()`, `.clear()`, `.size`         |
+| Object.keys / values       |    ✅     | Typed results for maps and records                                                            |
+| Array sort / flat          |    ✅     | `sort((a, b) => a - b)` in place, `flat()` one level                                          |
 
 **Functions**
 
@@ -87,12 +97,15 @@ TypeNative currently supports a focused subset of TypeScript syntax elements tha
 | Generics (functions/classes) |    ✅     | Type parameters via Go generics                             |
 | Default parameter values     |    ✅     | `function(x = defaultValue)`                                |
 | Rest parameters              |    ✅     | `function(...args: T[])` → Go variadic                      |
+| Optional parameters          |    ✅     | `function f(x?: string)`                                    |
+| Destructured parameters      |    ✅     | `function f({ a, b }: T)`, `([x, y]: number[])`             |
 
 **Classes & Interfaces**
 
 | Feature             | Supported | Notes                                                          |
 | ------------------- | :-------: | -------------------------------------------------------------- |
 | Classes             |    ✅     | Transpiled to Go structs with constructor and receiver methods |
+| Parameter properties |    ✅     | `constructor(private x: number)`                              |
 | Class inheritance   |    ✅     | `extends` via embedded structs, `super()` supported            |
 | Static members      |    ✅     | `static method()` / `static prop` → package-level declarations |
 | Getters / Setters   |    ✅     | `get prop()` → `Get_prop()`, `set prop(v)` → `Set_prop(v)`    |
@@ -131,7 +144,8 @@ TypeNative currently supports a focused subset of TypeScript syntax elements tha
 | Math.random               |    ✅     | Mapped to `rand.Float64()`                        |
 | Math.floor / ceil / round |    ✅     | Mapped to `math.Floor`, `math.Ceil`, `math.Round` |
 | Math.abs / sqrt / pow     |    ✅     | Mapped to corresponding `math` functions          |
-| Math.min / max            |    ✅     | Mapped to `math.Min`, `math.Max`                  |
+| Math.min / max            |    ✅     | Go builtins `min` / `max`                         |
+| Math.max(...arr)          |    ✅     | Spread and any number of arguments via `slices.Max` / `max` |
 | Math.log / log2 / log10   |    ✅     | Mapped to `math.Log`, `math.Log2`, `math.Log10`   |
 | Math.sin / cos / tan      |    ✅     | Mapped to `math.Sin`, `math.Cos`, `math.Tan`      |
 | Math.trunc / sign         |    ✅     | Mapped to `math.Trunc` and inline sign check      |
@@ -146,6 +160,7 @@ TypeNative currently supports a focused subset of TypeScript syntax elements tha
 | split / includes / indexOf |    ✅     | Via `strings` package                         |
 | startsWith / endsWith      |    ✅     | Via `strings` package                         |
 | replace / replaceAll       |    ✅     | Via `strings` package                         |
+| replace with RegExp        |    ✅     | `/g` vs first match, `$1`/`$&` patterns, function replacers |
 | charAt / substring / slice |    ✅     | Direct Go string indexing/slicing             |
 | concat / repeat            |    ✅     | String concatenation and `strings.Repeat`     |
 | padStart / padEnd          |    ✅     | Via `strings.Repeat`                          |
@@ -157,6 +172,7 @@ TypeNative currently supports a focused subset of TypeScript syntax elements tha
 | Feature  | Supported | Notes                                                 |
 | -------- | :-------: | ----------------------------------------------------- |
 | toString |    ✅     | Universal `toString()` via `fmt.Sprintf` for any type |
+| toFixed  |    ✅     | `n.toFixed(2)` via `strconv.FormatFloat`               |
 
 **RegExp**
 
@@ -180,4 +196,25 @@ TypeNative currently supports a focused subset of TypeScript syntax elements tha
 | npm package imports      |    ✅     | `import { x } from 'pkg'` mapped to Go module imports              |
 | Named exports            |    ✅     | `export function` / `export const` declarations                    |
 
-TypeNative is currently in early development and new features are being added regularly. The goal for `1.0` release is for TypeNative to transpile itself.
+## Native (self-hosted) compiler
+
+TypeNative compiles itself: `src/main.ts` transpiles to Go and builds into a native `typenative`
+binary that needs no Node.js at runtime and produces the same Go output as the npm package.
+
+```sh
+npm run build              # compile the TypeScript sources
+npm run build:native       # build native/typenative and native/tsparser
+native/typenative --source app.ts --script
+```
+
+Building the native compiler requires Go 1.26 (for the TypeScript parser, `tsparser/`). The
+`typenative` binary finds `tsparser` next to itself, or via the `TYPENATIVE_TSPARSER`
+environment variable.
+
+### Known limitations
+
+- Stateful `/g` regex loops (`while ((m = re.exec(s)))`) are not supported — use `matchAll`
+- `import.meta.url` is not lowered
+- Object types compile to Go structs, which are copied by value (JS objects are references)
+
+TypeNative is in early development and new features are being added regularly.

package/TODO.md

@@ -0,0 +1,38 @@
+# 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
+- [x] Phase 4: src/main.ts (incl. transpiler.ts) compiles to a native binary;
+      `any` values use a small Go runtime (TnGet/TnSet/TnAs/...) instead of guessed types
+- [x] Phase 5: stage-1/stage-2 bootstrap — the native compiler passes all test specs
+      and reproduces its own Go source identically (fixpoint)
+
+## Next
+- [ ] CI self-hosting job (stage 1 → stage 2 → compare); README/CHANGELOG updates
+- [ ] Stateful RegExp /g (`lastIndex`, `while ((m = re.exec(s)))` loops)
+- [ ] import.meta.url lowering
+- [ ] Gradually type the AST in transpiler.ts (fewer dynamic lookups, faster binary)

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(');
@@ -177,8 +149,7 @@ function tryInjectDtsTypes(jsContent, packageName, searchDir) {
     // Extract typed function signatures from the .d.ts module body
     const signatures = new Map();
     const sigRegex = /export function (\w+)\(([^)]*)\)\s*:\s*([^\n;]+)/g;
-    let m;
-    while ((m = sigRegex.exec(dtsBody)) !== null) {
+    for (const m of dtsBody.matchAll(sigRegex)) {
         signatures.set(m[1], { params: m[2].trim(), returnType: m[3].trim() });
     }
     if (signatures.size === 0)
@@ -237,7 +208,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 +245,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.