- Share symbol-keyed global caches across statically compiled modules.
- Preserve assignment results and evaluation order for native fields, accessors, and nullish defaults.
- Read omitted options correctly in specialized JavaScript package calls.
- Share program creation, checker queries, virtual files, and snapshot lifetimes between Node and native compiler clients.
- Preserve typed async-context results and opaque compiler objects through checked native boundaries.
- Support native realpath and Unicode Windows filesystem operations needed by the compiler host.
- Compile Unicode code-point construction, scalar iterable inputs, and primitive Buffer predicates without a JavaScript engine.
- Preserve object identity and property additions or deletions in inferred JavaScript locals.
- Recover nullable class fields initialized through static factories in bundled packages.
- Preserve nullable class fields and module callbacks in native storage with correct initialization behavior.
- Support typed-array construction, bulk copying, and in-place compaction through checked native values.
- Preserve receiver identity and evaluation order in nested field updates.
- Launch and manage TypeScript server processes through a portable native FFI boundary.
- Share the production session API between Node and statically compiled clients.
- Preserve Unicode command-line arguments and release server resources on every exit path.
- Compile the memoizing TypeScript checker with project-owned caches and explicit disposal.
- Support nested Map and Set values with native identity and cycle tracing.
- Preserve synthetic AST fragments and isolate semantic answers across snapshots.
- Keep null-initialized fields and inferred returns in mutable native storage, including inherited resets and saved callbacks.
- Convert checked native values with Number using JavaScript coercion and catchable errors.
- Compile fs.appendFileSync with Buffer and Uint8Array data.
- Preserve binary contents and append-or-create behavior while keeping filesystem errors catchable.
- Compile Buffer.isBuffer checks on untyped values using the native Buffer flag.
- Distinguish stream Buffers from plain byte arrays and document existing brand loss at typed boundaries.
- Support varying JavaScript event payloads for untyped and zero-argument listeners.
- Preserve listener identity, argument counts, ordering, and default values in native dispatch.
- Compile zero-argument callback fields and derived arrow replacements using their declared nullable type.
- Preserve callback captures, identity, and null resets in native class storage.
- Preserve class identity and member storage through interface and intersection refinements.
- Replace TypeScript runtime enum imports with pinned native constants and name lookups.
- Use concrete type predicates in the native semantic client.
- Allow JavaScript classes with unused incompatible return overrides to compile natively.
- Preserve inherited dispatch signatures and throw a named refusal if an incompatible override is called.
- Carry declaration-backed string, number, and boolean method results into static JavaScript compilation.
- Match named class re-exports to their implementations while preserving self types and rejecting ambiguous aliases.
- Replace SDK snapshots, projects, and programs with the owned native client.
- Preserve source identity across snapshots with native paths, caches, metadata, and diagnostics.
- Collect request timing and close snapshot state reliably without SDK helpers.
- Preserve lexical captures, callback identity, receiver effects, and default arguments in native bound arrows.
- Keep bound function name and length available through JavaScript aliases and checked storage.
- Keep empty inferred objects mutable across class fields, accessor parameters, and function values.
- Preserve object identity through named, private, symbol-keyed, and static JavaScript fields.
- Replace SDK semantic objects with native type, symbol, and signature registries.
- Route production checker queries through the owned client while preserving identity and snapshot lifetimes.
- Support scalar BigInt conversion and class union checks needed by native semantic decoding.
- Preserve native virtual dispatch when an override omits trailing checked-value parameters.
- Keep argument side effects and subclass defaults correct across direct, inherited, and super calls.
- Keep empty inferred options objects in native checked storage across calls and function values.
- Preserve supplied properties, per-call defaults, and null errors through JavaScript exports.
- Keep fields, accessor parameters, and return values inferred as undefined in native checked storage.
- Preserve virtual dispatch for overridden methods in JavaScript packages.
- Route assignments through class accessors without creating shadow fields.
- Store checked values in native collections while preserving supported object identities and JavaScript key equality.
- Support collection iteration and reject reference conversions that would copy or adapt stored objects.
- Replace SDK AST materialization with checked native node, list, and text decoding.
- Preserve checker handle identity and snapshot reuse across the frontend.
- Compile generic visitors and guarded node-list iteration without dynamic execution.
Lower static and non-overridden instance generator methods through spawn wrappers. Bind sync and async generator loop values through declarations or assignment patterns, and preserve compound assignment expression values.
- Move frontend message framing and filesystem callbacks into native-capable TypeScript
- Route production requests through the owned client while preserving AST and checker identity
- Preserve synchronous error recovery and cross-platform process cleanup
- Compile JavaScript instance fields with native undefined initialization and ordered resets.
- Support prefix and postfix updates to numeric static fields through exact class bindings.
- Compile initialized Symbol() and Symbol.for() fields, including inherited OpenTUI brands.
- Share registry-key storage across modules and keep symbol slots out of string-keyed enumeration.
- Refuse unstable keys and unsupported symbol-field copies.
- Run the production LLVM backend natively and reproduce its output across compiler generations.
- Replace unchecked emitter contexts with explicit shared state and callback hosts.
- Preserve NaN in serialized IR and respect optional record storage during spreads.
- Statically resolve stable let/var createRequire bindings while rejecting mutation, escape, and early use.
- Compile node:console output methods to native process streams and retain explicit custom Console refusals.
- Extend native FFI with additional scalar widths and writable byte spans.
- Compile stored text codecs and supported bundled module patterns without a JavaScript engine.
- Document supported limits.
- Compile the production C emitter and reproduce its output across native generations.
- Support the union operations, recursive spreads, and compression options needed by the emitter.
- Fix temporary ownership and verify the bootstrap and shared call operands with both backends and sanitizers.
* feat(compiler): advance self-hosting with identity collections
- Support reference identity in Maps and Sets, including unions and cycle cleanup.
- Run production integer-range analysis natively with typed IR traversal.
- Add differential coverage for native analyses and collection behavior.
* chore: ignore generated output directories
- Exclude generated output directories from version control.
* Support synchronous arrays in for-await loops
Drive array values through async-from-sync timing, including promise values and early iterator close. Handle defaulted union destructuring into checked-dynamic bindings and refuse void callback parameters before native code generation. Add differential coverage and pinned async Test262 regressions with original-source completion checks.
* Fix Error subclass C calls and diagnostics snapshot
- Compile production LLVM layouts, ownership helpers, debug metadata, and JSON emitters on both native backends
- Support nullable collections and mixed insertion spreads needed by compiler code
- Verify native emission parity and generated executables with focused sanitizer coverage
- Compile scalar-record optimization and backend analyses on both native backends
- Use exhaustive typed IR traversal and shared cycle analysis
- Verify optimized IR and executable parity with focused sanitizer coverage
- Compile production IR serialization and runtime dependency scans on both native backends
- Support native JSON callbacks and checked records with unknown payloads
- Verify native IR round trips and executable generation with focused sanitizer coverage
- Compile the production validator and exercise native IR construction and validation on C and LLVM.
- Preserve Error causes, wider callbacks, and discriminated JSON layouts in static programs.
- Version the IR and runtime ABI and cover the new compiler paths with differential and sanitizer tests.
Chris Tate