Roadmap.
The route is checkpointed, not treated as a fixed waterfall. Early checkpoints are concrete; later ones are revised when implementation evidence changes the best sequence.
JS0 - Foundation · complete
The C++17 build, CLI identity, sanitizer gate, independent runner, handovers and maintainable website are now executable. The ABI begins at JS1.
JS1 - Embedding lifecycle · complete
Opaque runtime/value handles, runtime-owned errors, explicit teardown, creator-thread affinity, C compilation and sanitizer-backed lifetime pressure are implemented.
JS2 - Frontend · complete
Attributed diagnostics, bounded ECMAScript tokens, executable primitive/declaration syntax, precedence and controlled malformed-input rejection are implemented through js --check.
JS3 - Primitive VM · complete
Inspectable stack bytecode now executes primitive values, initialized bindings, arithmetic, equality/order and completion values through the CLI and js.h.
JS4 - Control flow · complete
Branches, classic loops, break/continue, assignment, short-circuiting, conditional expressions, const enforcement and bounded execution now run through the VM.
JS5 - Functions and closures · complete
Ordinary and arrow functions now execute with calls, parameters, return, recursion, lexical environments, block scope and retained captures.
JS6A - Core objects · complete
Object and array literals, named/computed properties, reads/writes, holes/length and reference aliasing now execute through dedicated bytecode.
JS6B - Object model · complete
Methods, receiver-bound calls, this, live prototype lookup, constructors and new now execute as a bounded descriptor-free slice.
JS7A - Heap foundation · complete
All environments and reference values now enter one engine-owned allocation registry with graph inventory and accounting. Collection activates after the JS7B root/cycle gate.
JS7B - Traced collection · complete
Runtime handles now root traced object, array, function, prototype, closure and environment graphs; unreachable cycles are broken and reclaimed under repeated pressure.
JS7C - Execution safe points · complete
Allocation thresholds now collect during top-level execution while rooting the active operand stack and environment; expired registry entries are compacted deterministically.
JS8A - Explicit throw · complete
Primitive throws now compile to an explicit completion opcode, unwind lexical scopes, propagate through calls and surface as deterministic embedding errors. Handlers follow in JS8B.
JS8B - Completion records · complete
Normal, return, throw, break and continue now have explicit VM identities. Thrown values cross frames intact and are formatted only at the embedding boundary.
JS8C - Handler regions · complete
Protected bytecode regions now validate handler targets, unwind lexical scopes and operand stacks, and receive local or cross-frame thrown values. Surface handlers remain behind the reassessment gate.
JS8D - Try/catch · complete
Source-level try/catch now supports optional lexical bindings, nearest nested handlers, cross-frame throws, rethrows and returns from catch. finally remains a separate completion-model checkpoint.
JS8E - Pending completions · complete
Cleanup regions can suspend and resume throws and returns exactly once, including replacement by a new abrupt completion. This is VM infrastructure; source-level finally follows in JS8F.
JS8F - Finally · complete
try/finally and try/catch/finally now preserve normal, return, throw, break and continue completions, including nesting, cross-frame throws and replacement by a new return or throw.
JS9A - Central conversions · complete
Truthiness, primitive/number/string/property-key conversion, equality and relational comparison now live in one engine layer used by operators and property access. User-defined conversion hooks follow native built-ins.
JS10A - Intrinsic framework · complete
Each runtime owns one GC-rooted intrinsic environment. Native functions use normal call and construct paths with stable name, length and prototype identity; Object proves the first bounded constructor slice.
JS10B - Foundational built-ins · complete
Object and Function prototype methods, Error families and user-defined valueOf/toString conversion now run through native functions and the common VM invoker. The independent corpus is 114/114.
JS10C - Descriptors and reflection · complete
Bounded data descriptors, Object prototype reflection, enumerable own keys and instanceof are covered by an independent 124/124 corpus.
JS10D - Array and String foundations · complete
Array construction and core prototype methods plus primitive String indexing and core methods are covered by an independent 138/138 corpus.
JS10E - Shared descriptors and accessors · complete
Objects, arrays and functions share descriptor metadata, bounded accessors and descriptor reflection. The independent corpus is 148/148.
JS10F - Abrupt conversion and native errors · complete
Conversion hooks, property keys, accessors and callbacks preserve thrown completions; native validation creates catchable TypeError/RangeError objects. The corpus is 158/158.
JS10H - Error factory and stack frames · complete
Error constructors and native validation share one factory; deterministic native and JavaScript function frames are preserved through throw propagation. The corpus is 160/160.
JS10J - Located bytecode and stacks · complete
Bytecode retains statement locations and deterministic error frames include evaluation line and column data. The corpus is 166/166.
EP0-EP5 - Embedded preview contract · qualified
The bounded Linux candidate is qualified by its frozen host demonstration, 171/171 external cases, package consumers, ASan/UBSan, 400 deterministic mutations and a 250-evaluation soak. It is not a general ECMAScript compatibility claim.
EP0 - Contract inventory · complete
A machine-readable manifest now freezes the initial Linux C11/C++17 boundary, exclusions, candidate gates and public-header-only exit demonstration.
EP1 - Host values · complete
The public C API creates primitive, object and array values and exposes bounded own-data property/element access with explicit runtime-owned handle rules. The corpus is 167/167.
EP2 - Calls and callbacks · complete
Host-to-JavaScript calls, synchronous native callbacks, host data, same-thread re-entry, callback failures and retrievable JavaScript exceptions now share the ordinary VM path. The corpus is 168/168.
EP3 - Containment · complete
Public instruction, call-stack and cumulative allocation limits now produce deterministic statuses and allow runtime recovery after contained failure. The corpus is 169/169.
EP4 - Package and ABI · complete
ABI 0.1 now installs a public header, static library, SONAME shared library, CLI and pkg-config/CMake metadata. Versioned symbol visibility and isolated C/C++ consumer tests pin the initial Linux package.
EP5 - Embedded preview candidate · complete
Global injection closes the frozen host path through structured values, callbacks, closures, array callbacks, Error retrieval, containment and recovery. LeakSanitizer remains an external confirmation because the managed runner is ptrace-based.
JRS7-JRS8 - Evidence reconciliation · complete
The runtime/embedding and frontend contracts are now separated, PC0V is complete, the selected Test262 harness/revision is pinned without a fabricated pass rate, and the next runtime decision has been made from current evidence.
JS11A - Bounded class runtime semantics · next
Implement class runtime values, construction/prototype linkage and instance/static methods first, then inheritance and super. Fields, private names and static blocks remain separately bounded follow-ups.
JS11B - Jobs, promises and async
Introduce the host/job-queue contract only after the synchronous class slice is stable.
JS12 - Modules
Add module records, linking, cycles, live bindings and host resolution as a complete vertical system rather than parser-only syntax.
JS7-JS10 - Runtime and host safety
Tracing GC, exceptions, conversions, foundational built-ins, native functions and persistent handles.
JS13+ - Broader ECMAScript systems
Iterators/generators and broader language/built-in families follow the class, job and module contracts as evidence-selected vertical slices.
JS14-JS15 - Conformance and release
Selected Test262, fuzzing, platforms, ABI policy, packages, installers, automation and evidence-backed docs.
Integration checkpoints
After primitive execution becomes useful, tscc gains dual-runtime tests, then optional independent output parsing and a clearly owned emitted-JavaScript corpus. Syntax sharing and production embedding remain later decision gates.
Foundation status: JS0 and the product-boundary checkpoint are complete. JS++ remains independently useful, normal tscc compilation remains runtime-independent, and the first integration is explicitly test-only.
Read JS++ and tscc for the complete boundary.