typenative 0.0.21 → 0.1.0

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

@@ -27,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

package/CHANGELOG.md

@@ -5,6 +5,44 @@ 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

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

@@ -26,9 +26,13 @@ Goal: TypeNative transpiles itself into a native Go binary (1.0 milestone).
       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)
+- [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
-- [ ] Phase 5: stage-1/stage-2 bootstrap + run test suite through the native binary
-- [ ] Phase 5: CI self-hosting job; README/CHANGELOG updates
+- [ ] Gradually type the AST in transpiler.ts (fewer dynamic lookups, faster binary)

package/bin/index.js

@@ -149,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)

package/bin/parse-node.js

@@ -92,8 +92,8 @@ function convertNode(node) {
             if (arr.length > 0)
                 obj[key] = arr;
         }
-        else if (typeof v === 'number' && key === 'operator') {
-            // unary operator: emit the kind name (matches the Go producer)
+        else if (typeof v === 'number' && (key === 'operator' || key === 'token')) {
+            // operator / heritage-clause token: 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') {