boa-dev/boa

This system is a Rust-based JavaScript engine that parses, compiles, and executes ECMAScript code. It provides a comprehensive runtime environment by implementing core language features, including modern syntax, asynchronous execution, and a wide array of built-in objects and APIs. The engine also supports advanced capabilities such as internationalization, WebAssembly integration, and extensibility through native Rust bindings.

128 changes.

This period focused on rebuilding the Boa JavaScript engine's core infrastructure, introducing a spec-compliant AST, a register-based bytecode compiler, and a NaN-boxed value system. It also involved implementing a comprehensive suite of ECMAScript built-ins, including modern features like Temporal, BigInt, and async generators, alongside significant performance optimizations in the VM and garbage collector.

43 changes.

This period focused on expanding the engine's Web API coverage by implementing Fetch, Intl, AbortController, and postMessage, alongside Node.js compatibility features like the process global. Significant internal refactoring introduced optimized string handling, native source-map integration for debugging, and embedded module loading with compression. The work was supported by extensive test coverage, including WPT integration, bytecode snapshots, and performance benchmarks.

The engine now supports the \Array.fromAsync\ static method, allowing users to create arrays from async iterables or promises. This change also introduces the underlying \ArrayIterator\ object, which powers array iteration methods like \entries\, \keys\, and \values\, ensuring they correctly handle both standard arrays and typed arrays.

core/engine/src/builtins/array · high confidence

Adds the implementation of the ECMAScript \AsyncGenerator\ object, including its prototype methods (\next\, \return\, \throw\) and internal state management, to the engine's built-in objects.

_core/engine/src/builtins/async\generator · high confidence

The engine now implements the ECMAScript BigInt object, allowing users to work with arbitrarily large integers beyond the safe limits of standard JavaScript numbers. This change introduces the \BigInt\ constructor for converting values, the \BigInt.asIntN\ and \BigInt.asUintN\ static methods for bit-width truncation, and prototype methods like \toString\ with radix support. It also enables standard arithmetic operations (addition, subtraction, multiplication, division, modulo, exponentiation) and bitwise shifts on BigInt values, along with strict error handling for invalid conversions and operations such as division by zero.

core/engine/src/builtins/bigint · high confidence

A new benchmark suite has been added to the core engine to measure performance across parsing, compilation, and execution phases. The suite includes JavaScript scripts covering arithmetic, array, object, string, and regular expression operations, allowing developers to track the impact of local changes on Boa's performance.

core/engine/benches · high confidence

The engine now includes a dedicated \ConcatToString\ opcode operation that efficiently concatenates multiple stack objects into a single string. This new capability allows the VM to handle string joining operations with optimized memory usage by leveraging \ThinVec\ for register operands and delegating the final assembly to \JsString::concat\_array\.

core/engine/src/vm/opcode/concat · high confidence

Introduces the built-in \Generator\ object, conforming to the ECMAScript Iterator and Iterable interfaces. This adds support for generator functions, including the \next\, \return\, and \throw\ methods, as well as the \Symbol.toStringTag\ property. The implementation manages generator state (SuspendedStart, SuspendedYield, Executing, Completed) and handles context switching via a dedicated \GeneratorContext\ that preserves the VM stack and call frame during suspension and resumption.

core/engine/src/builtins/generator · high confidence

Users can now use the WeakRef object to hold a weak reference to another object without preventing it from being garbage collected. This change introduces the WeakRef constructor and its prototype.deref() method, allowing scripts to check if a referenced object is still alive or has been collected.

core/engine/src/builtins/weak · high confidence

The engine now implements the legacy ECMAScript \escape()\ and \unescape()\ global functions. \escape()\ converts a string into an escaped format by replacing non-ASCII characters with \%XX\ or \%uXXXX\ sequences, while \unescape()\ reverses this process. These functions are now available as built-in intrinsics within the JavaScript runtime.

core/engine/src/builtins/escape · high confidence

The engine now implements the ECMAScript \FinalizationRegistry\ object, allowing JavaScript code to register cleanup callbacks that are invoked when specific values are garbage collected, and adds support for the \BigInt\ primitive type with full arithmetic and conversion operations.

core/engine/src · high confidence

The engine now implements the \Intl.ListFormat\ API, allowing JavaScript code to format lists of values according to locale-specific conventions. This change introduces the \Intl.ListFormat\ constructor and its methods (\format\, \formatToParts\, \supportedLocalesOf\, \resolvedOptions\), supporting options for list type (\conjunction\, \disjunction\, \unit\) and style (\long\, \short\, \narrow\) by leveraging the ICU4X library for underlying formatting logic.

_core/engine/src/builtins/intl/list\format · high confidence

Users can now use the \Intl.Segmenter\ API to segment strings into grapheme clusters, words, or sentences. This change introduces the \Segmenter\ constructor, which accepts locale and granularity options, and provides methods like \segment()\ and \supportedLocalesOf()\. The implementation leverages ICU4X's segmenters and supports both Latin1 and UTF-16 string variants, exposing a \Segments\ object with a \containing()\ method and an iterator for traversing segment boundaries.

core/engine/src/builtins/intl/segmenter · high confidence

The engine now implements the ECMAScript Iterator constructor and the Iterator Helpers proposal, exposing new static methods on the Iterator object (Iterator.from, Iterator.concat, Iterator.zip, Iterator.zipKeyed) and prototype methods (Iterator.prototype.drop, filter, flatMap, map, take, zip). These additions enable lazy, composable iteration patterns such as chaining transformations, combining multiple iterators, and controlling iteration length or alignment.

core/engine/src/builtins/iterable · high confidence

The engine now implements the ECMAScript Temporal proposal's \Temporal.Instant\ built-in object, exposing the constructor and methods (such as \from\, \add\, \subtract\, \round\, \toString\, and accessors like \epochMilliseconds\) to JavaScript. This implementation relies on the \temporal\_rs\ crate for the underlying time handling logic.

core/engine/src/builtins/temporal/instant · high confidence

This change introduces the \Temporal.PlainDate\ built-in object to the engine, providing a compliant wrapper around the \temporal\_rs\ library. It exposes standard ECMAScript Temporal properties such as \year\, \month\, \day\, \era\, and \calendarId\, along with methods for date manipulation and conversion. The implementation includes specific validation logic, ensuring that null values passed to options objects in methods like \Temporal.PlainDate.from\ correctly throw \TypeError\ or \RangeError\ as specified.

_core/engine/src/builtins/temporal/plain\date · high confidence

The engine now implements the ECMAScript Temporal \PlainDateTime\ built-in object, exposing accessors for calendar identifiers, era, year, month, day, time components, and week-based fields, along with corresponding unit tests.

_core/engine/src/builtins/temporal/plain\_date\time · high confidence

Introduces the \Temporal.PlainMonthDay\ built-in object, exposing accessors for \day\, \monthCode\, and \calendarId\, along with static and instance methods including \from\, \with\, \equals\, \toString\, \toLocaleString\, \toJSON\, \valueOf\, and \toPlainDate\. This implementation relies on the \temporal\_rs\ crate for the underlying date logic and registers the constructor within the engine's intrinsic system.

_core/engine/src/builtins/temporal/plain\_month\day · high confidence

The runtime now includes the \TextEncoder\ and \TextDecoder\ JavaScript classes, enabling encoding and decoding of text strings to and from byte buffers. \TextDecoder\ supports UTF-8, UTF-16LE, and UTF-16BE encodings, respects \DataView\ and \TypedArray\ offsets and lengths, and handles BOM stripping via the \ignoreBOM\ option. \TextEncoder\ is restricted to UTF-8 encoding, replacing unpaired surrogates with the replacement character during encoding.

core/runtime/src/text · high confidence

A new benchmark target has been added to measure the execution performance of JavaScript scripts using the Criterion framework. This includes a \scripts.rs\ module that loads and runs \.js\ files from the \scripts/\ directory, specifically optimizing sample sizes and measurement times for benchmarks located in the \v8-benches\ subdirectory. The benchmark harness also configures platform-specific global memory allocators (tikv-jemallocator on Linux x86\_64 and mimalloc on macOS) to ensure consistent performance measurement conditions.

benches/benches · high confidence

The engine now implements the ECMAScript WeakSet builtin, providing the constructor and prototype methods add, delete, and has. This allows JavaScript code to create sets of weakly held objects, where non-object values passed to add are rejected with a TypeError, and the set supports chaining on add and standard iteration during construction.

_core/engine/src/builtins/weak\set · high confidence

The \examples\ directory now includes a full suite of Rust binaries demonstrating Boa engine capabilities, including basic execution (\loadstring\, \loadfile\), API usage for core types (\JsArray\, \JsMap\, \JsSet\, \JsDate\, \JsRegExp\, \JsArrayBuffer\, \JsTypedArray\), and advanced features like native classes, closures, AST visitors, and \TryFromJs\ derivation. It also provides examples for modern JavaScript features such as ES modules, Promises, Async Generators, and Host-defined Realm state.

examples · high confidence

The engine now includes a legacy, enum-based implementation of the \JsValue\ inner type (\EnumBasedValue\) as an alternative to the default NaN-boxed representation. This implementation is gated behind the \jsvalue-enum\ feature flag and provides the same public interface as the NaN-boxed version, allowing users to opt into a more traditional memory layout if needed.

core/engine/src/value/inner · high confidence

The runtime now implements the \postMessage\ API, allowing JavaScript code to send messages between contexts. This change introduces a \MessageSender\ trait and a default \OnMessageQueueSender\ that delivers messages to the global \onMessageQueue\ callback. It also adds support for transferring \SharedArrayBuffer\ objects, enabling shared memory communication between isolated contexts, as verified by new multi-threaded tests.

core/runtime/src/message · high confidence

The \core/ast/src/operations\ module has been added to implement ECMAScript syntax-directed operations, specifically the \Contains\ operation. This introduces a \contains\ function and a \ContainsSymbol\ enum (covering symbols like \super\, \yield\, \await\, \new.target\, \this\, \eval\, and \arguments\) to check if AST nodes contain specific semantic markers. The implementation includes visitor logic for various function types, call expressions, and \with\ statements, along with unit tests verifying detection of \this\ and \new.target\ in \with\ statements and call arguments.

core/ast/src/operations · high confidence

Users can now use the standard AbortController and AbortSignal APIs to cancel asynchronous operations. This change introduces the \AbortController\ class and the \AbortSignal\ class in the JavaScript runtime, allowing scripts to create abort signals, check their \aborted\ status, access the abort \reason\, and register event listeners for the 'abort' event. The implementation includes a \throwIfAborted\ method on signals and ensures that listeners are only fired for the 'abort' event type, ignoring unknown event names.

core/runtime/src/abort · high confidence

The runtime now exposes a global \process\ object compatible with Node.js, providing \process.cwd()\ to retrieve the current working directory and \process.env\ to access environment variables. This allows JavaScript code relying on these standard Node.js globals to run correctly within the Boa engine.

core/runtime/src/process · high confidence

The \benches/scripts/v8-benches\ directory now includes a suite of JavaScript benchmark files (crypto, deltablue, earley-boyer, navier-stokes, raytrace, regexp, richards, and splay) copied from the V8 project, along with a README documenting their origin. These scripts provide the benchmark logic and framework used to measure performance against V8 reference scores.

benches/scripts/v8-benches · high confidence

A new Rust binary tool (\regenerate-about\) has been added to the \tools/scripts\ directory. This utility iterates through the workspace's publishable crates and copies the root \ABOUT.md\ file into each crate's directory, ensuring that the about documentation is present for all crates intended for publication.

tools/scripts · high confidence

The engine now provides a complete implementation of the ECMAScript Set object, including standard methods like add, delete, has, clear, forEach, and iteration support (keys, values, entries). Additionally, it implements the new set-theoretic methods from the ECMAScript specification: difference, intersection, union, symmetricDifference, isDisjointFrom, isSubsetOf, and isSupersetOf. The implementation uses an ordered set internally to preserve insertion order and includes a dedicated SetIterator for handling iteration state correctly.

core/engine/src/builtins/set · high confidence

The parser in core/parser/src/parser now supports parsing ECMAScript scripts and modules into the Boa AST while capturing source text and performing scope analysis. This enables more accurate error reporting and better integration with the Boa VM for bytecode compilation.

core/parser/src/parser · high confidence

The engine now supports the ECMAScript \AggregateError\ constructor, allowing users to wrap multiple errors into a single exception with an \errors\ array property. Additionally, error objects now capture native backtrace information, enabling the \Error.prototype.stack\ accessor to provide detailed call-stack traces for debugging purposes.

core/engine/src/builtins/error · high confidence

The engine now exposes the global \AsyncFunction\, \AsyncGeneratorFunction\, and \GeneratorFunction\ constructors, allowing users to dynamically create async functions, async generator functions, and standard generator functions respectively. These built-in objects are initialized with their standard prototypes and \Symbol.toStringTag\ properties, and their constructors delegate to the internal dynamic function creation logic to produce the appropriate function types.

_core/engine/src/builtins/async\_function, core/engine/src/builtins/async\_generator\_function, core/engine/src/builtins/generator\function · high confidence

The Atomics builtin now supports asynchronous waiting via the new \Atomics.waitAsync\ method, allowing JavaScript code to wait on shared memory without blocking the main thread. This is implemented in the engine's atomics module using a futex emulation layer that manages wait queues and utilizes async channels to signal completion, with corresponding tests verifying the behavior across multiple threads.

core/engine/src/builtins/atomics · high confidence

Adds the \Symbol\ built-in object, including the \Symbol()\ constructor, the \Symbol.for()\ and \Symbol.keyFor()\ global registry methods, and the \description\ accessor. The implementation registers all standard well-known symbols (such as \Symbol.iterator\, \Symbol.asyncIterator\, \Symbol.hasInstance\, and \Symbol.dispose\) as static properties on the \Symbol\ object, ensuring they are available for JavaScript code. The global symbol registry is implemented as a thread-safe structure, allowing symbols created via \Symbol.for()\ to be shared across different execution contexts and threads.

core/engine/src/builtins/symbol · high confidence

Added the \Intl.Collator\ built-in object to the JavaScript engine, enabling string comparison and sorting with locale-aware rules. This implementation leverages the ICU4X library to support standard options such as \usage\ (sort vs. search), \sensitivity\ (base, accent, case, variant), \numeric\, \caseFirst\, and \collation\, ensuring compliance with the ECMAScript Internationalization API specification.

core/engine/src/builtins/intl/collator · high confidence

The engine now supports the \Intl.DateTimeFormat\ object, enabling localized formatting of dates and times via methods like \format()\, \formatToParts()\, and \formatRange()\. This implementation includes support for various locale options (such as \dateStyle\, \timeStyle\, and \timeZone\), exposes \supportedLocalesOf()\ and \resolvedOptions()\, and correctly handles time zone conversions and calendar algorithms using ICU4X. Users can now format \Date\ objects according to specific regional conventions and retrieve detailed parts of the formatted string.

_core/engine/src/builtins/intl/date\_time\format · high confidence

Users can now use the \Intl.Locale\ constructor to create locale objects and access properties such as \calendar\, \region\, and \script\. The engine also implements locale resolution logic, allowing internationalization APIs to match requested locales against available ICU data using lookup and best-fit strategies.

core/engine/src/builtins/intl/locale · high confidence

The engine now provides a complete implementation of the \Intl.NumberFormat\ constructor, enabling locale-aware number formatting. This change introduces support for compact number formatting (e.g., '1K' instead of '1000') via \CompactDecimalFormatter\, as well as the \formatToParts\ method for granular access to formatted number components. The implementation integrates with ICU4X for locale resolution and decimal formatting, supporting options such as rounding modes, numbering systems, and grouping strategies.

_core/engine/src/builtins/intl/number\format · high confidence

Added the \Intl.PluralRules\ built-in object, enabling locale-aware plural rule selection for numbers via \select\ and \selectRange\ methods. The implementation supports the \type\ option (cardinal/ordinal) and, notably, the \notation\ option (standard, scientific, engineering, compact), allowing plural rules to be resolved based on how a number is formatted. This change introduces the core engine files for this feature, including the main \PluralRules\ struct and its options handling.

_core/engine/src/builtins/intl/plural\rules · high confidence

Adds the core implementation for the Temporal proposal's Calendar builtin, including abstract operations to extract calendar values from Temporal date/time objects and to parse calendar identifiers from strings or objects, defaulting to ISO 8601 when undefined.

core/engine/src/builtins/temporal/calendar · high confidence

This change introduces the core \Date\ builtin for the JavaScript engine, providing the full set of standard methods including constructors, static methods (\Date.now\, \Date.parse\, \Date.UTC\), and instance methods for getting/setting date components (\getFullYear\, \setHours\, etc.) and string conversions (\toISOString\, \toString\, \toLocaleString\). The implementation includes a dedicated utility module for ECMASpec-compliant time calculations (leap years, day-of-year, timezone offsets) and integrates with the engine's intrinsic and realm systems to ensure proper prototype chains and constructor behavior.

core/engine/src/builtins/date · high confidence

This change introduces the core \Promise\ object implementation to the engine, including the \PromiseState\ enum, internal reaction handling, and the \PromiseCapability\ record. It provides the foundational behavior for creating, resolving, and rejecting promises, along with the job queue integration required for asynchronous execution. The entry also includes initial test coverage for standard Promise behaviors such as \Promise.all\, \Promise.any\, \Promise.race\, and \Promise.allSettled\.

core/engine/src/builtins/promise · high confidence

The FFI layer now includes the \boa\_wasm\ package, providing WebAssembly bindings for the Boa JavaScript engine. This addition allows users to evaluate ECMAScript code directly in browser or Node.js environments via the \evaluate\ function. The package is distributed under MIT or Unlicense terms and includes a README with usage examples and a test suite for the WebAssembly module.

ffi · high confidence

Adds the Fetch API to the runtime, providing the \fetch()\ function along with the \Request\, \Response\, and \Headers\ JavaScript classes. This includes support for request bodies, headers, and abort signals, with a default blocking HTTP backend (via \reqwest\) that can be swapped out via the \Fetcher\ trait.

core/runtime/src/fetch · high confidence

The \core/engine/src/native\_function\ module now includes a new \NativeCoroutine\ type and supporting \continuation\ utilities, enabling native Rust functions to be implemented as async coroutines that can await promises. This change adds the infrastructure for \NativeFunction\ to handle asynchronous execution flows directly, moving beyond simple future wrapping to support more complex async patterns within the engine's native function interface.

_core/engine/src/native\function · high confidence

The engine now supports the \Temporal.PlainYearMonth\ built-in object, exposing a complete API for handling year-month pairs in the JavaScript Temporal proposal. Users can create instances via the constructor or static \from\ method, and access properties such as \year\, \month\, \monthCode\, \era\, and \calendarId\. The implementation includes standard methods for manipulation and comparison, including \with\, \add\, \subtract\, \until\, \since\, \equals\, \toPlainDate\, \toString\, \toLocaleString\, \toJSON\, and \valueOf\.

_core/engine/src/builtins/temporal/plain\_year\month · high confidence

This change adds the \Temporal.ZonedDateTime\ built-in object to the engine, implementing the ECMAScript Temporal proposal specification. The new module exposes a comprehensive set of accessor properties (such as \calendarId\, \timeZoneId\, \era\, \year\, \month\, \day\, \hour\, \minute\, \second\, \millisecond\, \microsecond\, \nanosecond\, \epochMilliseconds\, \epochNanoseconds\, \dayOfWeek\, \dayOfYear\, \weekOfYear\, \daysInWeek\, \yearOfWeek\, \daysInMonth\, \daysInYear\, \monthsInYear\, \inLeapYear\, \offsetNanoseconds\, and \offset\) and registers the constructor within the realm's intrinsics. This provides users with the ability to create and inspect date-time objects that include timezone information.

core/engine/src/builtins/temporal/duration, core/engine/src/builtins/temporal/zoneddatetime · high confidence

A new \boa\_wintertc\ crate has been added to implement the WinterTC (TC55) Minimum Common Web API, providing a standalone set of Web Platform features that depend only on \boa\_engine\. This crate includes initial implementations for \atob\/\btoa\ (with forgiving Base64 decoding), \structuredClone\ (supporting deep cloning and \ArrayBuffer\ transfers), \queueMicrotask\, and the \console\ object (including \console.table\ rendering and a pluggable \Logger\ trait). It also registers stubs for other TC55-required APIs like \AbortController\, \TextEncoder\, and \EventTarget\, allowing users to opt into a portable, baseline-compliant JavaScript environment.

core/wintertc · high confidence

The ECMAScript string engine has been extracted into a new, standalone \boa\_string\ crate. This change introduces a new internal representation for \JsString\ that supports both Latin1 and UTF-16 encodings, allowing for more efficient memory usage for ASCII/Latin1 text. The new implementation includes a \JsStringBuilder\ for efficient string construction, a \CodePoint\ type for handling Unicode scalar values and unpaired surrogates, and optimized iterators for code points and windows. It also adds support for static string interning to avoid heap allocations for common JavaScript identifiers and symbols, and provides new display modes (\escaped\ and \lossy\) for debugging and error reporting.

core/string · high confidence

The module loader subsystem now includes an \EmbeddedModuleLoader\ that allows bundling JavaScript source files directly into the binary at build time. This new capability supports optional LZ4 compression for embedded assets via the \embedded\_lz4\ feature flag, enabling smaller binary sizes for bundled modules while maintaining lazy parsing and caching of the embedded sources.

core/engine/src/module/loader · high confidence

The garbage collector now exposes a new set of pointer types in the \core/gc/src/pointers\ module, including \Gc\<T\>\ for strong references, \GcErased\ for type-erased handles, \WeakGc\ for non-owning weak references, and \Ephemeron\ for key-value pairs where the value is cleared when the key is collected. These primitives power the new \WeakMap\ collection, which allows storing values associated with weak keys that are automatically invalidated upon garbage collection, enabling patterns like caching without preventing memory reclamation.

core/gc/src/pointers · high confidence

The engine's object model now supports typed native data storage via a new \JsObject\<T\>\ structure, allowing Rust types to be stored directly inside JavaScript objects without type erasure. This change introduces the \JsData\ trait and \NativeObject\ trait to enable safe downcasting and type checking of stored data, replacing the previous erased object model. Additionally, a \WeakJsObject\ type is added, providing a weak reference mechanism that allows embedders to hold handles to objects without preventing garbage collection, with an \upgrade\ method to safely retrieve the strong reference if the object is still alive.

core/engine/src/object · high confidence

A new \small\_btree\ crate has been added to the \utils\ directory, providing a \SmallBTreeMap\ collection. This map is optimized for small datasets by initially storing entries in an inline vector, automatically switching to a heap-backed B-tree only when the number of elements exceeds a configurable \ARRAY\_SIZE\. The implementation exposes standard map operations including insertion, retrieval, iteration, and entry-based modifications (such as \or\_insert\ and \and\_modify\), allowing users to benefit from reduced heap allocations for common small-map use cases.

_utils/small\btree · high confidence

The AST module now includes a new \Punctuator\ enum in \core/ast/src/punctuator\ that represents all ECMAScript punctuators (such as \+\, \=\, \&&\, etc.). This enum derives \EnumIter\ for easy iteration and provides \as\_assign\_op\ and \as\_binary\_op\ methods to convert specific punctuators into their corresponding \AssignOp\ or \BinaryOp\ representations, facilitating more structured operator handling in the parser.

core/ast/src/punctuator · high confidence

The engine now includes a dedicated implementation of ECMAScript Property Descriptors in \core/engine/src/property\, supporting data, accessor, and generic descriptor kinds with attributes like enumerable, configurable, writable, value, get, and set. This module also introduces a \NonMaxU32\ type to safely represent unsigned 32-bit integers excluding the maximum value, preventing overflow in property index handling.

core/engine/src/property · high confidence

The parser now represents ECMAScript reserved words (such as \await\, \async\, \class\, \const\, \import\, etc.) as a distinct \Keyword\ AST node type. This change centralizes the definition of all recognized keywords in one location, ensuring that reserved words are handled consistently as a specific token category rather than generic identifiers or strings. This structural improvement supports more accurate parsing and error reporting for reserved word usage in variable names, labels, or function definitions.

core/ast/src/keyword · high confidence

The parser now uses a \BufferedLexer\ that maintains a fixed-size buffer of up to three peeked tokens, allowing the parser to look ahead without consuming input. This implementation deduplicates consecutive line terminators in the buffer and provides \peek\ and \next\ methods to support lookahead logic, with tests verifying correct token ordering and skipping behavior.

_core/parser/src/parser/cursor/buffered\lexer · high confidence

The core parser functionality is now exposed via the new \boa\_parser\ crate, which provides the \Lexer\, \Parser\, \Source\, and \Error\ types for parsing ECMAScript code according to the latest language specification.

core/parser/src · high confidence

The engine now includes the \JSON\ object built-in, providing \JSON.parse\ and \JSON.stringify\ functionality. A key behavioral addition is that \JSON.parse\ preserves the original source text for primitive values, making it available via the \context.source\ property in the reviver function, which allows users to inspect the raw text representation of parsed values.

core/engine/src/builtins/json · high confidence

The engine now includes the ECMAScript \Math\ global object, providing standard mathematical constants (such as \E\, \PI\, and \LN2\) and methods including \abs\, \acos\, \acosh\, \asin\, \asinh\, \atan\, \atan2\, \cbrt\, \ceil\, \clz32\, \cos\, \cosh\, \exp\, \expm1\, \floor\, \fround\, \hypot\, \imul\, \log\, \log1p\, \log10\, \log2\, \max\, \min\, \pow\, \random\, \round\, \sign\, \sin\, \sinh\, \sqrt\, \tan\, \tanh\, and \trunc\. The implementation includes specific fixes for \Math.acosh\ and \Math.asinh\ to handle large finite inputs correctly. Additionally, the \Math.sumPrecise\ method is available when the \xsum\ feature is enabled, and \Math.f16round\ is available when the \float16\ feature is enabled. A comprehensive test suite is included to verify the behavior of these functions.

core/engine/src/builtins/math · high confidence

The engine now includes a native source-map builder and lookup system in the VM layer, allowing it to map bytecode program counters back to specific source file paths and line/column positions. This infrastructure enables the runtime to generate detailed, accurate stack traces for errors (supporting \Error.prototype.stack\) and exposes full call-frame position data, significantly improving the debugging experience by linking execution points directly to the original source code.

_core/engine/src/vm/source\info · high confidence

A new global \$boa\ object is exposed in the CLI to provide introspection into the Boa engine's internal state. This API includes sub-objects for debugging: \function\ (to generate flowgraphs in Mermaid/Graphviz, print bytecode, and trace execution), \gc\ (to force garbage collection), \limits\ (to get/set runtime limits for loops, stack, recursion, and backtraces), \object\ (to inspect memory IDs and indexed storage types like DenseI32 or SparseElement), \shape\ (to inspect object shape pointers and types), \optimizer\ (to toggle constant folding and statistics), \realm\ (to create new ECMAScript realms), and \string\ (to inspect storage and encoding variants like Latin1 vs UTF-16).

cli/src/debug · high confidence

The \boa\_ast\ crate has been introduced to represent the ECMAScript Abstract Syntax Tree, providing structured nodes for declarations (including \let\, \const\, \var\, functions, classes, and explicit resource management \using\/\await using\), expressions, and statements. This new module adds support for import and export declarations with attributes, object and array destructuring patterns, and scope analysis for tracking identifier bindings, replacing the previous ad-hoc representation with a spec-compliant, visitor-based AST structure.

core/ast/src · high confidence

The engine's optimizer now includes three new passes that improve runtime performance by simplifying code at parse time. Constant folding evaluates literal expressions (such as unary operations and binary logical/comma operators) to their resulting values, reducing execution overhead. Dead code elimination removes unreachable branches in if-statements and loops when their conditions are compile-time literals, provided no hoisted declarations are present. Strength reduction replaces expensive operations like division by two or squaring with cheaper equivalents (multiplication by 0.5 or self-multiplication). These changes are implemented in the optimizer pass module and apply to the engine's internal AST representation.

core/engine/src/optimizer, core/engine/src/optimizer/pass · high confidence

The VM now includes dedicated opcodes for handling asynchronous execution: \Await\ suspends the current async function and schedules it to resume upon promise resolution or rejection, while \CreatePromiseCapability\ initializes the promise capability structure required for async functions. These changes provide the underlying bytecode operations necessary for correct async/await semantics and async generator support.

core/engine/src/vm/opcode/await · high confidence

The \ffi/wasm\ crate now exposes a \evaluate\ function that allows host applications to execute ECMAScript code strings and retrieve the result as a string. This feature is implemented using the \boa\_engine\ library and is accessible via \wasm\_bindgen\, enabling JavaScript-like scripting capabilities within WebAssembly environments. Error handling is included, returning a \JsValue\ with the error message if the script execution fails.

ffi/wasm · high confidence

The engine now provides a comprehensive set of traits and types for converting between JavaScript values and Rust types. The new \TryFromJs\ trait allows fallible conversion from \JsValue\ to Rust primitives, collections (\Vec\, \HashMap\, \BTreeMap\), tuples, and \Option\. The \TryIntoJs\ trait enables the reverse, converting Rust types back to \JsValue\, with safe handling for large integers (\i64\, \u64\, etc.) that exceed JavaScript's safe integer range. A new \Convert\<T\>\ wrapper type applies JavaScript's standard type coercion rules (e.g., string-to-number) during conversion. Additionally, a \Nullable\<T\>\ type is introduced to distinguish between JavaScript \null\ and \undefined\, mapping \null\ to \Nullable::Null\ and defined values to \Nullable::NonNull\, while \Option\<T\>\ continues to map \undefined\ to \None\. These changes are implemented in the \core/engine/src/value/conversions\ module.

core/engine/src/value/conversions · high confidence

A new \flowgraph\ module has been added to the VM engine to generate visual representations of bytecode execution paths. This module constructs a graph of nodes (representing opcodes) and edges (representing control flow), supporting both Graphviz and Mermaid output formats. It allows developers to visualize the structure of \CodeBlock\ instructions, including conditional jumps, logical short-circuiting, and scope management, with distinct shapes and colors for different instruction types.

core/engine/src/vm/flowgraph · high confidence

The engine now includes dedicated VM opcodes to define class members, specifically \DefineClassStaticGetterByName\, \DefineClassGetterByName\, \DefineClassStaticGetterByValue\, \DefineClassGetterByValue\, and their counterparts for setters and methods. These new operations handle the creation of property descriptors on class prototypes and static objects, ensuring that function names are correctly set and home objects are linked, which supports more precise and efficient class member definition in JavaScript.

core/engine/src/vm/opcode/define/class · high confidence

Uint8Array now supports static \fromBase64\ and \fromHex\ methods to create instances from encoded strings, as well as instance methods \toBase64\, \toHex\, \setFromBase64\, and \setFromHex\ to convert existing arrays to or from these formats. These methods follow the proposal-arraybuffer-base64 specification, allowing users to easily encode and decode binary data without external libraries.

_core/engine/src/builtins/typed\array · high confidence

The \core/engine/src/interop\ module has been introduced to provide traits and utilities for bridging Rust and JavaScript. It adds \IntoJsFunctionCopied\ and \UnsafeIntoJsFunction\ traits, allowing Rust closures to be converted into \NativeFunction\ instances callable from JavaScript. The module also introduces \TryFromJsArgument\ for parsing JS arguments into Rust types, along with helper types like \JsRest\ (to capture remaining arguments) and \JsAll\ (to capture arguments of a specific type), enabling more flexible and ergonomic integration of Rust logic into the JS engine.

core/engine/src/interop · high confidence

The runtime now exposes a structured extension system that allows users to selectively register Web APIs such as \console\, \setTimeout\/\setInterval\, \structuredClone\, \atob\/\btoa\, \URL\, \TextEncoder\/\TextDecoder\, and \fetch\/\AbortController\ via dedicated extension structs. This replaces the previous monolithic registration approach, giving users finer control over which APIs are available in their JavaScript context and enabling conditional compilation through feature flags (e.g., \fetch\, \url\, \process\).

core/runtime/src · high confidence

The engine now implements the ECMAScript module system with support for import attributes (e.g., \import x from 'y' with { type: 'json' }\), allowing modules to declare metadata about their dependencies. It introduces \SyntheticModule\ for programmatically creating modules (useful for JSON modules or custom loaders) and \ModuleNamespace\ objects that cache resolved bindings for efficient export access. The module lifecycle (parse, load, link, evaluate) is exposed via the \ModuleLoader\ trait, enabling custom loading strategies such as fetching from URLs or using Rust futures.

core/engine/src/module · high confidence

The \boa\_macros\ crate introduces a suite of procedural macros to simplify integrating Rust types with the Boa JavaScript engine. The \\#\[boa\_class\]\ attribute allows Rust structs to be exposed as JavaScript classes, supporting constructors, methods, accessors, and symbol-named methods. The \\#\[boa\_module\]\ attribute automatically registers Rust constants, functions, and classes as exports in a JavaScript module. Additionally, the \embed\_module!\ macro enables embedding external files into the binary at build time with optional LZ4 compression, while \js\_value!\ and \js\_object!\ provide DSLs for creating JavaScript values from Rust code.

core/macros · high confidence

A new utility crate, \utils/tag\_ptr\, has been added to provide a \Tagged\<T\>\ type that associates a pointer with a \usize\ tag. This allows the system to store either a valid heap pointer or a small integer tag within a single memory location by utilizing the least significant bit of the pointer address, which is safe for pointers with at least 2-byte alignment. This component is part of the broader refactoring to split \Tagged\<T\>\ into its own utility crate.

_utils/tag\ptr · high confidence

A new utility at tools/gen-icu4x-data has been added to generate ICU4X data files for the engine's Intl components. This tool exports data for services including datetime, collator, calendar, plural rules, list format, and locale fallback into the core/icu\_provider/data directory, ensuring coverage for modern locales plus specific test requirements like en-US and Manx (gv).

tools/gen-icu4x-data · high confidence

The engine now exposes a comprehensive set of typed Rust wrappers for core JavaScript built-in objects, including \JsArray\, \JsArrayBuffer\, \JsDataView\, \JsDate\, \JsFinalizationRegistry\, \JsFunction\ (with \TypedJsFunction\ support), \JsGenerator\, \JsAsyncGenerator\, \JsGeneratorFunction\, \JsMap\, \JsMapIterator\, and \JsPromise\. These wrappers provide a safe, idiomatic Rust API for creating, inspecting, and manipulating these objects from host code, replacing or supplementing the previous untyped \JsObject\ interactions with specific methods like \JsArray::push\, \JsArrayBuffer::from\_byte\_block\, and \JsPromise::new\.

core/engine/src/object/builtins · high confidence

The parser's input source module has been expanded to handle UTF-16 encoded code, in addition to the existing UTF-8 support. Users can now create a \Source\ from a UTF-16 byte slice using the new \Source::from\_utf16\ method, enabling the parsing of scripts encoded in UTF-16. The implementation includes dedicated \UTF16Input\ and \UTF8Input\ types that abstract over the underlying reader, and the \Source\ struct now tracks an optional file path to support accurate error reporting and source maps for both encoding types.

core/parser/src/source · high confidence

The WeakMap builtin now includes \getOrInsert(key, value)\ and \getOrInsertComputed(key, callback)\ methods, allowing users to retrieve an existing value or insert a new one in a single operation, with the latter supporting lazy evaluation via a callback. These additions complement the existing \set\, \get\, \has\, and \delete\ methods, providing a more convenient API for common lookup-and-insert patterns while maintaining strict type checking for object keys.

_core/engine/src/builtins/weak\map · high confidence

The standalone binary file \src/bin/bin.rs\ has been removed from the project. This file previously contained a simple \main\ function that read and printed the contents of a hardcoded \test.js\ file, serving as an early proof-of-concept or development tool. Its deletion indicates a shift away from this specific hardcoded testing mechanism, likely as the project evolved into a more structured workspace architecture with proper file input handling and runtime logic.

src/bin · high confidence

The src/main.rs file containing the application's main function has been deleted, removing the primary entry point for the program.

src · high confidence

The core engine's bytecode compiler has been restructured from a single large module into a set of specialized submodules (class, declarations, env, function, generator, iterator, jump\_control, module, register, statement, utils). This change improves code organization and maintainability by separating concerns such as class compilation, declaration instantiation, environment management, generator/iterator handling, and register allocation, without altering the external behavior of the JavaScript engine.

core/engine/src/bytecompiler · high confidence

The VM's opcode infrastructure has been restructured to improve type safety and maintainability. Operand encoding and decoding logic has been extracted into a dedicated \args\ module, introducing new typed operand wrappers such as \RegisterOperand\, \IndexOperand\, and \Address\ to replace previous generic or varying representations. Opcode execution logic has been modularized into separate files (e.g., \arguments.rs\, \function.rs\, \object.rs\), where each operation is now a distinct struct implementing the \Operation\ trait. This change standardizes how bytecode instructions are defined, encoded, and executed, laying the groundwork for further performance optimizations and cleaner bytecode management.

core/engine/src/vm/opcode · high confidence

The parser's expression handling has been restructured by extracting specific grammar rules into dedicated modules within the assignment parsing directory. This change introduces separate parsers for arrow functions, async arrow functions, conditional expressions, exponentiation, and yield expressions, replacing the previous monolithic implementation. Users benefit from a more maintainable parser architecture that strictly adheres to ECMAScript specification production rules for these expression types.

core/parser/src/parser/expression/assignment · high confidence

A change to existing behaviour in core/icu\_provider/data — 7 commits (1 fix), 12 files.

_core/icu\provider/data · medium confidence · unverified

The AST nodes for expression operators (including assignment, binary, unary, update, and conditional expressions) now carry source location information via a \Span\ field. This enables the parser and subsequent processing steps to report precise error locations and improve debugging for JavaScript expressions.

core/ast/src/expression/operator · high confidence

A new pre-push hook has been added to the repository to automatically run CI checks before pushing code. The hook ensures that \cargo-make\ is installed and sets compiler flags to treat warnings as errors, then executes \cargo make run-ci\ to validate the changes.

.husky · high confidence

The \core/ast/src/expression\ module has been completely rewritten to define the Abstract Syntax Tree nodes for JavaScript expressions. This change introduces dedicated structs for all expression types—including property access, calls, awaits, yields, and literals—and integrates them into a unified \Expression\ enum. It also adds support for modern ECMAScript features such as dynamic imports (\import.defer()\, \import.source()\), optional chaining, and private property access.

core/ast/src/expression · high confidence

Errors thrown during JavaScript execution, including those caught by internal handlers like async module evaluation, now retain their stack traces when passed through promise rejections. Previously, converting a JsError to a JsValue and back could lose this context; the engine now ensures the backtrace is preserved across these round-trips, providing developers with accurate stack information for debugging.

core/engine/src/error · high confidence

The engine now uses a dedicated \ForInIterator\ object to handle \for...in\ enumeration, replacing the previous internal mechanism. This change introduces a new module in the Object builtins that implements the iterator protocol for object keys, ensuring that the iteration correctly traverses the prototype chain and respects property enumerability as specified by the ECMAScript standard.

core/engine/src/builtins/object · high confidence

The \eval\ builtin now correctly implements the ECMAScript specification for direct and indirect eval calls. It validates the execution context to ensure that \new.target\ and \super\ references are only allowed in permitted scopes (such as within functions or methods), throwing a SyntaxError otherwise. The implementation also integrates with the host hooks to check \HostEnsureCanCompileStrings\ before parsing, ensuring that string compilation is permitted by the host environment.

core/engine/src/builtins/eval · high confidence

The engine now supports the internal method dispatch required by the ECMAScript specification for String exotic objects and Immutable Prototype exotic objects. This change introduces \immutable\_prototype.rs\ to enforce the invariant that an object's prototype cannot be changed after creation, and \string.rs\ to handle property access, definition, and key enumeration specifically for String wrapper objects (e.g., allowing numeric index access to string characters while respecting their non-extensible nature). These implementations are registered in the new \internal\_methods\ module, enabling correct behavior for code relying on these exotic object semantics.

_core/engine/src/object/internal\methods · high confidence

The engine now includes the \New\ and \NewSpread\ VM opcodes to handle object instantiation. \New\ calls the \\_\construct\\_\ method on a function object, while \NewSpread\ handles construction when arguments are passed via a spread array. Both opcodes enforce that the target is a constructor, throwing a type error with the value's type if it is not, and correctly manage the \new.target\ value on the stack during execution.

core/engine/src/vm/opcode/new · high confidence

The engine now supports the legacy \\[\[IsHTMLDDA\]\]\ internal slot (Annex B §B.3.6), which changes how certain objects behave: \typeof\ returns \"undefined"\, \ToBoolean\ returns \false\, and abstract equality with \null\ or \undefined\ returns \true\. Additionally, calling these objects returns \null\ per Annex B §B.3.6.1. This feature is gated behind the \annex-b\ feature flag and is primarily used to support legacy browser behaviors like \document.all\.

core/engine/src/builtins · high confidence

The VM now includes dedicated opcode operations for creating and managing generators, async generators, and tagged templates. Generator and AsyncGenerator opcodes initialize their respective objects and handle suspension, while AsyncGeneratorClose and AsyncGeneratorYield manage the lifecycle and yielding behavior of async generators, including proper realm handling during yields. Additionally, TemplateLookup and TemplateCreate opcodes handle the caching and construction of tagged template objects, ensuring both cooked and raw string arrays are correctly populated and frozen.

core/engine/src/vm/opcode/generator · high confidence

The engine now implements the core JavaScript function objects, including the \Function\ constructor, the \arguments\ object (supporting both mapped and unmapped variants), and the \Function.prototype.bind\ mechanism. This change introduces the \OrdinaryFunction\ struct to manage function internals such as environment stacks, code blocks, and class fields, while \BoundFunction\ handles the exotic object behavior required by \bind\. The \arguments\ object is now an exotic object that synchronizes property access with the function's lexical environment bindings, ensuring that modifying \arguments\[i\]\ updates the corresponding parameter variable and vice versa. Additionally, the \Function\ constructor now correctly validates syntax for \super\ calls and references, throwing early syntax errors when encountered.

core/engine/src/builtins/function · high confidence

The \boa\_interner\ crate has been updated to detect and record whether an interned string is Latin-1 encodable at the time of insertion. This is exposed via a new \is\_latin1\ method on the \Interner\, allowing consumers to quickly determine if a string can be represented in the Latin-1 character set without re-encoding it. The implementation handles both static and dynamic strings, correctly identifying boundary cases (U+00FF vs U+0100) and ensuring that non-Latin-1 characters (such as CJK characters) are accurately flagged.

core/interner · high confidence

The VM now uses specific opcodes (\CallEval\, \CallEvalSpread\, and \Call\) to handle function invocations, separating the logic for calling the \eval\ builtin from standard function calls. This change implements the ECMAScript specification's runtime semantics for function calls, including strict mode handling for \eval\ and support for spread arguments in \eval\ calls, while optimizing the case where \eval\ is called with no arguments.

core/engine/src/vm/opcode/call · high confidence

The \core/gc\ crate now includes a new \GcRefCell\ type that provides garbage-collected interior mutability with dynamically checked borrow rules, allowing safe mutable and immutable access to values inside \Gc\<T\>\ pointers. Additionally, the garbage collector's tracing mechanism has been refactored to use a non-recursive, queue-based approach via the \Tracer\ struct, which improves stability by avoiding stack overflow risks during deep object graphs. These changes are part of the broader \boa\_gc\ implementation, providing the foundational memory management primitives for the engine.

core/gc/src · high confidence

The engine context now supports configurable timekeeping via a new \Clock\ trait and \StdClock\ implementation, replacing the previous default UTC time hook with a monotonic clock for scheduling and a separate system time source for \Date\ objects. It also integrates a lazy, cached ICU4X provider (\IntlProvider\) for internationalization utilities and exposes a \HostHooks\ trait, allowing host applications to customize behaviors such as string compilation checks, job callback execution, and promise rejection tracking.

core/engine/src/context · high confidence

The \boa\_icu\_provider\ crate now implements a \LazyBufferProvider\ that defers the deserialization of ICU4X locale data until it is first requested. By loading the static blob data on-demand rather than at startup, Boa reduces initial memory overhead and improves engine initialization time. This change is part of a broader restructuring that also includes splitting ICU data generation into separate crates and updating the ICU4X dependency version.

_core/icu\provider · high confidence

The lexer implementation in core/parser/src/lexer has been restructured into distinct modules (comment, cursor, identifier, number, operator, regex, string, template, etc.) to improve maintainability and clarity. A key behavioral change is that regular expression literals are now validated using regress::backends::try\_parse without being optimized or compiled, which may alter error reporting for invalid regex patterns. Additionally, the lexer now properly handles hashbang comments using goal symbols, fixes line terminator handling in template strings, and removes boolean and null keywords from the identifier lexer, treating them as literals instead.

core/parser/src/lexer · high confidence

The AST module now includes dedicated \ArrayLiteral\, \ObjectLiteral\, and \TemplateLiteral\ node types, replacing or supplementing previous generic literal handling. These new structures provide specific fields for spans and element collections, and implement conversion methods (such as \to\_pattern\) that allow array and object literals to be directly transformed into their corresponding destructuring patterns, supporting default initializers and spread elements.

core/ast/src/expression/literal · high confidence

The engine now includes a dedicated Boolean global object with \toString\ and \valueOf\ methods, ensuring correct type returns for both call and construct forms. Additionally, \String.prototype.repeat\ now respects the runtime's loop iteration limit, throwing a runtime limit error instead of potentially hanging or consuming excessive resources when repeating strings with large counts.

core/engine/src/builtins/string · high confidence

The engine now uses a new \Map\ implementation backed by an \OrderedMap\ (wrapping \indexmap::IndexMap\) that preserves insertion order for keys and values. This change introduces a dedicated \MapIterator\ object to support ECMAScript iterator protocols, enabling \Map.prototype.keys()\, \Map.prototype.values()\, and \Map.prototype.entries()\ to return proper iterators. The \Map\ constructor now accepts an iterable to initialize entries, and methods like \set\, \get\, \delete\, \clear\, \has\, and \forEach\ are implemented to interact with this ordered structure. Tests confirm that iteration order is maintained and that the map behaves as a standard key-value store with insertion-order preservation.

core/engine/src/builtins/map · high confidence

The engine now uses a new \RegExp\ implementation in \core/engine/src/builtins/regexp\ that adds support for the \v\ (unicode sets) flag, the \RegExp.escape()\ static method, and the \RegExp String Iterator\ protocol. This change also corrects named capture group ordering to follow definition order rather than alphabetical, fixes escaping in \RegExp.prototype.source\, and ensures proper handling of surrogate pairs in non-unicode patterns. Users will see more accurate ECMAScript compliance in regex matching, new utility methods, and improved error handling for invalid patterns.

core/engine/src/builtins/regexp · high confidence

The VM now includes dedicated opcodes to handle setting class prototypes, variable bindings, and object properties. SetClassPrototype establishes the prototype chain for class definitions, while SetName and SetNameByLocator manage variable assignments with strict checks for uninitialized bindings. SetPrivateField, DefinePrivateField, SetPrivateMethod, SetPrivateGetter, and SetPrivateSetter handle private class members. Additionally, SetPropertyByName, SetPropertyByNameWithThis, and SetPropertyByValue manage public property assignments, including optimized fast paths for array indices and support for inline caching.

core/engine/src/vm/opcode/set · high confidence

The VM now includes dedicated opcodes for unary operations, allowing scripts to use increment (++) and decrement (--) operators on integers, floats, and BigInts, as well as logical NOT (!), unary plus (+), unary minus (-), bitwise NOT (\~), typeof, and explicit ToInt32 conversion. These changes refine how the engine handles value coercion and arithmetic, ensuring consistent behavior across numeric types and improving performance for common unary patterns.

_core/engine/src/vm/opcode/unary\ops · high confidence

The VM now includes new opcode implementations for declaring variables (\DefVar\, \DefEvalVar\, \DefInitVar\) and initializing lexical bindings (\PutLexicalValue\), as well as defining object properties (\DefineOwnPropertyByName\, \DefineOwnPropertyByValue\). These changes enable the engine to handle variable scoping, initialization, and property creation more explicitly during execution, supporting features like \var\ declarations, function arguments, and dynamic property assignment.

core/engine/src/vm/opcode/define · high confidence

The engine now compiles JavaScript control-flow statements (blocks, loops, conditionals, switch, try/catch/finally, with, break, continue, and return) using a new register-based bytecode compiler. This replaces the previous implementation, introducing changes to how scopes are managed, how loop iterations are counted, and how return values are preserved across finally blocks, which may alter execution behavior and performance characteristics for these constructs.

core/engine/src/bytecompiler/statement · high confidence

A new \declaration\ module has been added to the bytecompiler, introducing \declaration\_pattern.rs\ to handle the compilation of destructuring patterns (such as object and array destructuring) into bytecode. This implementation manages the logic for extracting values from source objects into registers, handling default initializers, and processing rest properties, effectively replacing or refactoring how declaration patterns are processed within the engine's compilation pipeline.

core/engine/src/bytecompiler/declaration · high confidence

The parser now includes a dedicated module for parsing function definitions, introducing strict validation for formal parameters. This change enforces ECMAScript rules by rejecting duplicate parameter names in strict mode and preventing default initializers on rest parameters, while also supporting rest parameters and ensuring they appear last in the argument list.

core/parser/src/parser/function · high confidence

The parser now uses a new \Cursor\ structure in \core/parser/src/parser/cursor\ to manage token reading, buffering, and state tracking. This change introduces a \BufferedLexer\ to handle tokenization, including specific logic for lexing regex patterns (handling \/=\ vs \/\) and template literals, as well as tracking context such as arrow functions, JSON parsing mode, and strict mode. Users will benefit from more robust token handling and accurate parsing of edge cases like regex starting with \/=\.

core/parser/src/parser/cursor · high confidence

The Number builtin now uses a new \conversions.rs\ module that implements fast paths for converting floating-point numbers to integers (\f64\_to\_int32\/\f64\_to\_uint32\) and includes optimized \parseInt\ and \parseFloat\ logic. On ARMv8.3 hardware with the \jsconv\ feature, integer conversions utilize the \FJCVTZS\ instruction for improved performance, while other platforms use a software fallback. These changes streamline how numeric values are converted to strings and parsed, reducing overhead in common number operations.

core/engine/src/builtins/number · high confidence

The VM's property and binding retrieval operations have been refactored to include inline caching, significantly improving access performance. New opcodes such as \GetNameGlobal\, \GetPropertyByName\, and \GetLengthProperty\ now check a shape-based cache before falling back to slower property lookup methods, and they automatically update the cache when the object's shape remains stable. This change reduces the overhead of repeated property and global binding accesses by avoiding redundant prototype chain traversals and internal method calls.

core/engine/src/vm/opcode/get · high confidence

The parser's error handling has been refactored to attach and expose context strings to parsing errors. This allows error messages to specify the location or scenario in which a syntax error occurred (e.g., 'in context'), providing users with more precise diagnostic information when parsing fails. The \Error\ enum now supports a \context\ field for \Expected\ errors, and the \ErrorContext\ trait enables setting and retrieving this context on parse results.

core/parser/src/error · high confidence

The parser in \core/parser/src/parser/statement\ and its expression submodules has been restructured to explicitly track \allow\_yield\ and \allow\_await\ contexts. This change introduces dedicated parsers for \await\ expressions and refactors identifier, block, break, and continue statement parsing to respect these flags, ensuring that \await\ and \yield\ are correctly rejected or allowed based on whether the code is inside an async or generator function. This enables more accurate parsing of modern JavaScript features like async/await and generators by preventing their use as identifiers or keywords in invalid contexts.

core/parser/src/parser/statement · high confidence

The parser for primary expressions has been restructured to use dedicated modules for each expression type, including array literals, function expressions, async function expressions, generator expressions, async generator expressions, and class expressions. This change improves code organization and maintainability by isolating parsing logic for each specific syntax construct, while preserving existing parsing behavior for JavaScript code.

core/parser/src/parser/expression/primary · high confidence

The engine now formats the arguments passed to \console.log\ and similar debugging outputs with human-readable, pretty-printed structures. Instead of generic object representations, arrays, maps, sets, typed arrays, and function arguments are displayed with their specific type labels (e.g., \\[Arguments\]\, \Map { ... }\, \Uint8Array(3) \[ ... \]\) and their contents expanded. This change improves the readability of debugging information by showing the actual values and structure of complex data types rather than just their type names or compact placeholders.

core/engine/src/value/display · high confidence

The URI handling functions in the engine core now safely handle malformed percent-encoded sequences. Previously, decoding a URI with an incomplete escape sequence (such as \%E7%9A%8\) could cause a runtime panic due to an out-of-bounds access. This change tightens the bounds checking during percent-decoding to prevent such panics, ensuring that malformed input is handled gracefully rather than crashing the engine.

core/engine/src/builtins/uri · high confidence

The Proxy implementation now strictly enforces ECMAScript invariants, throwing TypeErrors when traps return invalid results (such as reporting non-configurable properties as configurable, hiding non-configurable properties, or violating extensible/prototype constraints). This behavioral change is accompanied by a comprehensive suite of unit tests verifying these invariant checks.

core/engine/src/builtins/proxy · high confidence

The CLI has been refactored to provide a more robust and user-friendly experience. The REPL now features syntax highlighting for JavaScript code, real-time syntax validation (showing errors as you type), and support for dot-commands. A new \Executor\ implementation manages JavaScript jobs (promises, async jobs, and finalization registry jobs) more efficiently, preventing spin-looping when idle and ensuring proper cleanup of kept objects to avoid memory growth. Additionally, the CLI now supports reading JavaScript from piped stdin, offers a \--time\ flag to report script execution timing, and includes a \--quiet\ flag to suppress the welcome banner.

cli/src · high confidence

The AST nodes for functions (including regular, async, generator, and arrow variants) and classes have been restructured to include dedicated scope tracking and source location data. Each function and class node now explicitly stores a \FunctionScopes\ object for scope analysis, alongside \Span\ and \LinearSpan\ fields to track source code positions. Additionally, the \FormalParameterList\ has been updated to compute and expose flags indicating parameter characteristics, such as whether the list is simple, contains duplicates, or includes rest parameters and expressions.

core/ast/src/function · high confidence

The AST statement nodes in \core/ast/src/statement\ have been restructured to include explicit scope tracking and direct-evaluation detection. New or updated nodes such as \Block\, \ForInLoop\, \ForOfLoop\, \Switch\, and \ForLoop\ now carry \scope\ and \contains\_direct\_eval\ fields, enabling the engine to correctly analyze variable scopes and identify uses of \eval\ within control flow structures.

core/ast/src/statement · high confidence

The CallFrame implementation has been restructured to manage registers and execution state via a stack-based model rather than a separate register array. This change introduces persistent register indices for critical internal states, including a read-only register for \undefined\, dedicated registers for \PromiseCapability\ (promise, resolve, reject), and the async generator object. It also exposes the full position of a call frame for debugging and error reporting, while removing the local binding's initialized state tracking in favor of a binding stack.

_core/engine/src/vm/call\frame · high confidence

The binary operations module has been restructured to use a new macro-based definition system for standard operators (such as arithmetic, comparison, and bitwise operations) and a dedicated file for logical operators (&&, \|\|, ??). This change introduces fast-path optimizations for numeric operations and standardizes the implementation of binary opcodes. Additionally, the \InPrivate\ opcode now correctly resolves private identifiers through the environment chain, and the \CopyDataProperties\ opcode has been implemented to handle object property copying with exclusion keys.

_core/engine/src/vm/opcode/binary\ops · high confidence

The VM's control-flow implementation has been restructured to use new \RegisterOperand\ and \Address\ types for opcode arguments, replacing previous mechanisms. This change introduces fused comparison-and-jump instructions (such as \JumpIfNotLessThan\) to optimize loop and conditional logic, and refactors return, throw, and exception-handling opcodes (including \CheckReturn\, \Throw\, and \Exception\) to align with the new register-based architecture.

_core/engine/src/vm/opcode/control\flow · high confidence

The VM's iteration-related opcodes have been reorganized into a new \core/engine/src/vm/opcode/iteration\ module, splitting the logic into \for\_in.rs\, \get.rs\, \iterator.rs\, and \loop\_ops.rs\. This change introduces specific operations for managing the iterator lifecycle, including \CreateForInIterator\, \GetIterator\, \GetAsyncIterator\, \IteratorPush\, \IteratorPop\, \IteratorNext\, \IteratorResult\, \IteratorValue\, and \IteratorUpdateResult\, alongside \IncrementLoopIteration\ for enforcing loop limits. This structural shift aligns the bytecode representation with the latest specification and improves the clarity of iterator handling within the engine.

core/engine/src/vm/opcode/iteration · high confidence

The VM's class definition logic has been restructured to use new, specific opcodes for managing class internals. The \StoreClassPrototype\ opcode now explicitly handles superclass prototype resolution and constructor parent assignment, ensuring correct prototype chain setup. Additionally, dedicated opcodes (\PushClassField\, \PushClassFieldPrivate\, \PushClassPrivateMethod\, \PushClassPrivateGetter\, and \PushClassPrivateSetter\) have been introduced to handle the creation and registration of public fields, private fields, and private methods/getters/setters, including proper home object binding and property descriptor configuration.

core/engine/src/vm/opcode/push/class · high confidence

The bytecode compiler for expressions has been restructured to use a new set of RISC-style opcodes and a dedicated register allocator. This change replaces previous instruction patterns with more granular operations (such as separate load, compute, and store steps) and introduces optimized fast paths for common patterns like increment/decrement on local variables and bitwise conversions. Users benefit from improved execution performance and a more consistent internal representation of expression evaluation.

core/engine/src/bytecompiler/expression · high confidence

The environment-related VM opcodes have been restructured to use the new \RegisterOperand\ type for register-typed arguments and to leverage the updated \JsExpect\ pattern for error handling. This change introduces specific opcode operations for retrieving the current function object, managing cached \this\ values, resolving \this\ in object environments (supporting \with\ statements), and executing \super\ calls, ensuring these operations align with the refactored bytecode representation and environment stack architecture.

core/engine/src/vm/opcode/environment · high confidence

The internal implementation of the garbage collector has been restructured to improve type safety and memory management. New internal modules have been introduced: \GcBox\ now serves as the concrete allocation wrapper for garbage-collected values, \GcHeader\ centralizes reference counting, marking, and rooting state, and \EphemeronBox\ implements the ephemeron semantics where values are collected if their keys become unreachable. Additionally, \WeakMapBox\ and \ErasedWeakMapBox\ manage weak reference maps, while \VTable\ provides a type-erased interface for tracing and finalization operations. These changes underpin the non-erased \JsObject\ and type-erased \Gc\<T\>\ capabilities mentioned in the commit history.

core/gc/src/internals · high confidence

The parser for left-hand-side expressions (calls, member access, optional chaining, and tagged templates) has been restructured into dedicated modules (arguments, call, member, optional, template). This change introduces specific parsing logic for \import.defer()\ and \import.source()\ dynamic import syntax, adds support for parsing keywords like \true\, \false\, and \null\ as property identifiers in member and call expressions, and enforces stricter validation for optional chaining (e.g., rejecting tagged templates and private identifiers in certain contexts).

_core/parser/src/parser/expression/left\_hand\side · high confidence

The engine's object shape management has been restructured to use a new \Shape\ abstraction that distinguishes between \UniqueShape\ (for objects with few or no shared properties) and \SharedShape\ (for objects sharing property layouts). This change introduces a \PropertyTable\ for efficient property storage and lookup, and a \ForwardTransition\ mechanism in \SharedShape\ that uses weak references to cache property and prototype transitions, automatically pruning stale entries to manage memory. The system now supports transitions for inserting, removing, and changing property attributes, as well as prototype changes, with logic to convert shared shapes to unique ones after a threshold of transitions to maintain performance.

core/engine/src/object/shape · high confidence

The engine's environment records now use fixed-size lists of binding values instead of hashmaps, with binding positions determined at bytecode compile time to eliminate expensive runtime lookups. The environment stack is implemented as a singly-linked list, allowing O(1) cloning on function calls. This change also introduces a 'poisoned' flag mechanism to handle dynamic binding additions from eval, ensuring correctness while maintaining performance.

core/engine/src/environments · high confidence

The engine's ArrayBuffer implementation has been restructured to introduce a unified \BufferObject\ enum that wraps both \ArrayBuffer\ and \SharedArrayBuffer\. This change adds support for resizable buffers (including \maxByteLength\ and \grow\ capabilities) and introduces a new \SharedArrayBuffer\ type with atomic byte access. The internal data storage now uses aligned vectors (\AVec\/\ABox\) to ensure proper memory alignment for atomic operations, and the module exposes new accessor methods for \growable\ and \maxByteLength\ on shared buffers.

_core/engine/src/builtins/array\buffer · high confidence

The \Intl\ module has been restructured to align with ICU4X's locale preference handling. This change introduces a new \ServicePreferences\ trait and associated macros to manage locale-specific settings for internationalization services (such as Collator, DateTimeFormat, NumberFormat, etc.). It also adds an \IntlOptions\ type to aggregate locale matchers and preferences, and implements abstract operations like \GetNumberOption\ and \DefaultNumberOption\ to handle option parsing and validation according to the ECMAScript Internationalization API specification.

core/engine/src/builtins/intl · high confidence

The core engine's value representation has been refactored to use NaN-boxing for improved performance and memory efficiency, replacing the previous enum-based implementation. This change introduces a new \JsVariant\ type and redefines equality semantics: \JsValue\ now implements Rust's \PartialEq\ and \Eq\ traits using the ECMAScript \SameValueZero\ algorithm, meaning \NaN\ is considered equal to itself in standard equality checks. The engine also provides explicit \strict\_equals\ (for \===\) and \equals\ (for \==\) methods, with the latter correctly handling Annex B \\[\[IsHTMLDDA\]\]\ objects as equal to \null\ and \undefined\. Additionally, a \js\_value!\ macro is now available for creating \JsValue\ instances from a JSON-like DSL.

core/engine/src/value · high confidence

The Temporal built-in implementation has been migrated to use the \temporal\_rs\ crate for its core logic. This change updates how the engine handles Temporal objects, including error mapping from \TemporalError\ to JavaScript native errors and the initialization of the \Temporal\ global namespace and its static methods (such as \Now\, \Duration\, \Instant\, \PlainDate\, etc.) via the intrinsic system. Users interacting with Temporal APIs will see behavior driven by this new underlying Rust library.

core/engine/src/builtins/temporal · high confidence

The \Temporal.PlainTime.prototype.with\ method now correctly throws a \RangeError\ when negative values are passed for time components (such as hour, minute, or second) and the \overflow\ option is set to \'reject'\. This change ensures the implementation aligns with the ECMAScript Temporal specification by validating component ranges before construction, preventing invalid time objects from being created.

_core/engine/src/builtins/temporal/plain\time · high confidence

The engine now uses \web-time\ for time operations and \getrandom\ for random number generation on WebAssembly targets (excluding Emscripten and WASI) when the \js\ feature is enabled. This change ensures consistent behavior across platforms by abstracting system-specific implementations, with a fallback to standard library time functions for other environments.

core/engine/src/sys · high confidence

The VM opcode operations in the \push\ module have been renamed from the \Push\ prefix to \Store\ (e.g., \PushUndefined\ is now \StoreUndefined\) to better reflect their function of storing values into registers. This change introduces new specialized opcodes for handling arrays (\StoreNewArray\, \PushValueToArray\, \PushElisionToArray\, \PushIteratorToArray\), literals (\StoreLiteral\, \StoreRegexp\), and environments (\PushScope\, \PushObjectEnvironment\, \PushPrivateEnvironment\, \PopPrivateEnvironment\), alongside existing stores for primitives, numbers, and objects. These opcodes now use \RegisterOperand\ for target registers and implement specific logic for dense array storage, iterator consumption, and environment stack management.

core/engine/src/vm/opcode/push · high confidence

The virtual machine in core/engine/src/vm has been refactored to significantly improve property access performance and error diagnostics. A new polymorphic inline cache (PIC) system is now used to cache shape-to-slot mappings for object property access, accelerating repeated reads and writes. Additionally, the VM now tracks native backtrace positions via a shadow stack, allowing error objects to preserve detailed call stack information including source locations and function names. The refactoring also restructures the internal representation of functions into \CodeBlock\ objects, separates VM registers from the calling convention stack, and introduces new RISC-style opcodes for iterator and generator operations.

core/engine/src/vm · high confidence

Add internationalization (Intl) benchmarks; Added JSON stringify benchmarks for circular and deep structures; Added JavaScript assertion harness for runtime testing; Added WPT fetcher implementation for Fetch API tests; Added WPT integration tests for boa\_runtime; Added WPT test infrastructure and logging recorder; Added basic JavaScript benchmark scripts; Added benchmarks for closure creation, property access, and prototype chain resolution; Added bytecode snapshot tests using insta; Added comprehensive test coverage for engine core components; Added comprehensive test suite for the garbage collector; Added formatting tests for parser output; Added fuzz testing infrastructure for Boa engine; Added integration tests for macros and interop features; Added parser unit tests for script and module parsing; Added string operation benchmarks; Added test assets for macro integration tests; Added test coverage for control flow statements; Added test coverage for module loading, JSON imports, and derive macros; Added test coverage for the Fetch API implementation; Added test execution module for parallel test runner; Added tests for AST scope analysis; Added tests for derive macro conversions; Added tests for structuredClone support; Added tests for the utf16 macro; Test262 tester restructured with edition-aware classification and CLI; Updated bytecode compilation snapshots for loop, class, and control flow tests.

A dependency / build maintenance change in (dependencies) — 1642 commits (39 fixs), 27 files.

(dependencies) · high confidence · unverified

The repository is initialized with essential project configuration and documentation files, including \.editorconfig\ and \.gitattributes\ for consistent code formatting and line endings, \README.md\ and \CONTRIBUTING.md\ for project overview and developer guidelines, \CHANGELOG.md\ for version history, and \Makefile.toml\ for build automation tasks. This entry reflects the structural setup of the project rather than a specific engine feature or behavioral change.

(repo-wide) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 80 → 80 (-0.1)
• Rubric changed (rubric-2026.09.9 → rubric-2026.09.17) — scores are not directly comparable.

• Code Health 83 → 83 (+0.0)
• Architecture 96 → 96 (-0.2)
• Maturity 75 → 76 (+0.0)
• Readiness 88 → 79 (-8.8)
• Security 78 → 85 (+6.2)
• Performance 100 (new)

• Context::this_from_object_environment_binding (cognitive 23) (core/engine/src/environments/runtime/mod.rs)
• Documentation: written for insiders (docs/debugging.md)
• Duplicated block (6 lines × 2) (core/engine/src/environments/runtime/mod.rs)
• Hotspot: cli/src/main.rs (cli/src/main.rs)
• Hotspot: core/engine/src/builtins/date/mod.rs (core/engine/src/builtins/date/mod.rs)
• Hotspot: core/engine/src/builtins/iterable/iterator_helper/zip.rs (core/engine/src/builtins/iterable/iterator_helper/zip.rs)
• Hotspot: core/engine/src/bytecompiler/mod.rs (core/engine/src/bytecompiler/mod.rs)
• Hotspot: core/engine/src/bytecompiler/statement/loop.rs (core/engine/src/bytecompiler/statement/loop.rs)
• Hotspot: core/wintertc/src/console/mod.rs (core/wintertc/src/console/mod.rs)
• Off-boarding risk: anonymized user #1
• Off-boarding risk: anonymized user #2
• Off-boarding risk: anonymized user #3
• TooManyFields: StandardConstructors (core/engine/src/context/intrinsics.rs)
• TooManyMethods: StandardConstructors (core/engine/src/context/intrinsics.rs)

• Ambiguous naming in ImportCall. The constructor takes specifier and options, but the getters expose specifier() and argument(). It is unclear if argument() corresponds to options or if there is a missing options() getter. Given the constructor signature new(specifier: S, options: Expression, ...), the argument() getter likely returns options, but the name is misleading.
• Dependency hygiene PARTLY measured — Cargo dependencies read, dependency currency not (crates.io unreachable)
• Inconsistent access pattern for the same logical data. VarDeclaration exposes its internal list via a public tuple struct field (.0), while LexicalDeclaration uses a getter method (.variable_list()). This breaks API uniformity for consumers iterating over declaration types.
• JsStr::to_number (cognitive 17) (core/string/src/str.rs)
• JsStr::to_number (cyclomatic 16) (core/string/src/str.rs)
• Low cohesion: AnnexBFunctionDeclarationNamesVisitor (LCOM4 5) (core/ast/src/operations/mod.rs)
• Low cohesion: CallFrame (LCOM4 4) (core/engine/src/vm/call_frame/mod.rs)
• Low cohesion: Context (LCOM4 6) (core/engine/src/context/mod.rs)
• Low cohesion: JsValue (LCOM4 5) (core/engine/src/value/mod.rs)
• Low cohesion: JumpControlInfo (LCOM4 4) (core/engine/src/bytecompiler/jump_control.rs)
• Low cohesion: ModuleItemList (LCOM4 6) (core/ast/src/module_item_list/mod.rs)
• Low cohesion: VarDeclaredNamesVisitor (LCOM4 5) (core/ast/src/operations/mod.rs)
• Low cohesion: VarScopedDeclarationsVisitor (LCOM4 11) (core/ast/src/operations/mod.rs)
• Off the main sequence: boa_icu_provider
• Off the main sequence: boa_string
• Off the main sequence: small_btree
• Off the main sequence: tag_ptr
• Off-boarding risk: anonymized user #2
• Off-boarding risk: anonymized user #3
• Off-boarding risk: anonymized user #1
• …and 2 more

• 9 commits — 6 feature/other, 3 fixes

• (root) — 4 commits
• .github/workflows — 2 commits
• core/engine — 2 commits
• core/string — 1 commit

• fix: fix(engine): correct WithBaseObject and HasBinding semantics for with calls (#5507)
• fix: fix(engine): keep pending return value in a dedicated slot across finally (#5514)
• fix: fix(string): reject signed Infinity and non-decimal literals in StringToNumber (#5509)
• change: chore(deps): bump rstest from 0.26.1 to 0.27.0 (#5521)
• change: chore(deps): bump the ci-dependencies group with 2 updates (#5519)
• change: chore(deps): bump the ci-dependencies group with 3 updates (#5532)
• change: chore(deps): bump the rust-dependencies group with 5 updates (#5533)
• change: chore(deps): bump the rust-dependencies group with 7 updates (#5520)
• change: chore(deps): migrate jemallocator -> tikv-jemallocator (#5525)

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

boa-dev/boa was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.