es-meta/esmeta

ESMeta is a tool for modeling, analyzing, and testing the ECMAScript specification. It extracts formal definitions from the ECMA-262 standard to build an executable engine that interprets algorithms and executes JavaScript programs. The system provides static type checking, fuzzing for program synthesis, and automated generation of conformance tests against the Test262 suite.

61 changes.

This period established the foundational architecture of ESMeta, introducing the core metalanguage, Intermediate Representation (IR), and Control Flow Graph (CFG) modules alongside their respective serialization and traversal utilities. It implemented the essential pipeline components, including the ECMA-262 specification extractor, the metalanguage-to-IR compiler, and the interpreter with garbage collection, while adding static type checking and fuzzing support. Comprehensive test suites were developed to validate the parser, compiler, interpreter, and analyzer against the ECMAScript specification and test262.

9 changes.

This period focused on restructuring the static analyzer to support pluggable abstract domains and introducing a symbolic type system with provenance tracking. Concurrently, significant infrastructure was added, including a web-based debugger and visualizer, automated release scripts, and enhanced fuzzing capabilities for JavaScript program synthesis.

The analyzer now includes utilities to visualize Control Flow Graphs (CFG) as DOT/PDF diagrams and stringify analysis states. A new DotPrinter generates visual representations of the CFG, highlighting reachable nodes, the current execution point, and the worklist, with output saved to the analysis log directory. A new Stringifier provides detailed textual representations of analyzer elements like control points and views, supporting configurable detail levels for debugging and logging.

src/main/scala/esmeta/analyzer/util · high confidence

A new grammar file for JSON (based on the ECMA-404 standard) has been added to the manuals/grammars directory. This enables the system to recognize and parse JSON structures according to the specified syntax rules, including objects, arrays, strings, numbers, and literals.

src/main/resources/manuals/grammars · high confidence

This change introduces a new set of utility classes and objects in the \es.util\ package to support ECMAScript program handling. It adds a \Parser\ for reading ECMAScript-specific syntax (including templates, models, and intrinsic definitions), a \Stringifier\ for converting ASTs and scripts into readable text, and \Walker\/\UnitWalker\ traits for traversing AST structures. Additionally, it provides \ValidityChecker\ and \AstValidityChecker\ to verify program correctness by running code against external engines, and a \JsonProtocol\ to enable JSON serialization of coverage and view data. These utilities also include helper functions for merging and flattening statement lists and a strict-mode directive constant.

src/main/scala/esmeta/es/util · high confidence

A new index.html file has been added to the site root to serve as a landing page for GitHub Pages. This page automatically redirects visitors to the latest API documentation located at 'latest/api', while also providing a manual link for users whose browsers do not support JavaScript redirection.

src/site · high confidence

Added \JsonProtocol\, \Parser\, and \Stringifier\ utilities in \esmeta.spec.util\ to enable reading, writing, and displaying ECMAScript specification data (including grammar, algorithms, and intrinsics) in JSON format. This allows users to extract spec details into a structured JSON representation for further processing or debugging.

src/main/scala/esmeta/spec/util · high confidence

A new JavaScript file, assertions.js, has been added to the resources to support the synthesis of JavaScript programs during fuzzing. This file provides a suite of assertion functions (such as sameValue, notThrows, compareArray, and compareIterator) and helper utilities for error logging and type checking, enabling the fuzzing engine to validate synthesized code behavior.

src/main/resources · high confidence

The interpreter module now includes a garbage collector (GC) that identifies and removes unreachable heap objects based on provided root values, ensuring memory is reclaimed for non-named addresses. Additionally, the package introduces extension methods for Double, BigInt, and BigDecimal that implement a symmetric modulo operation (%%), ensuring the result has the same sign as the divisor rather than the dividend.

src/main/scala/esmeta/interpreter · high confidence

Introduced a new \Extractor\ module in \src/main/scala/esmeta/extractor\ that parses ECMA-262 specification HTML documents to generate structured internal representations. This component extracts grammar productions, abstract algorithms, constants, tables, type models, and intrinsics, supporting both standard extraction and evaluation modes for testing.

src/main/scala/esmeta/extractor · high confidence

The state module now includes utilities for serializing and inspecting internal state. A new \JsonProtocol\ class enables encoding and decoding of state elements (such as call paths, features, and contexts) to and from JSON using the circe library. Additionally, a \Stringifier\ class provides human-readable string representations of state elements for debugging, and a \UnitWalker\ trait allows traversal of state element trees.

src/main/scala/esmeta/state/util · high confidence

The \esmeta.ty.util\ package now includes comprehensive support for type system components, introducing a JSON protocol for serializing and deserializing type models, declarations, and values using the circe library. A new parser allows these types to be constructed from string representations, while a stringifier handles the reverse conversion for debugging and logging. Additionally, walker traits (both unit and value-returning) are provided to traverse and transform type hierarchies, and a TypeErrorCollector utility enables the aggregation and dumping of type errors to files.

src/main/scala/esmeta/ty/util · high confidence

A new shell script at scripts/release has been added to automate the release process. It validates semantic versioning inputs, updates version strings in build.sbt, package.scala, and README.md, runs sbt release and tests, manages git branching (dev/main), and prompts for remote publishing, streamlining the creation and deployment of new ESMeta versions.

scripts · high confidence

The \src/main/resources/manuals/funcs\ directory now includes a comprehensive set of new manual algorithm implementations to support advanced language features. This adds explicit IR definitions for BigInt operations (\BigInt::exponentiate\, \BigInt::leftShift\, \BigInt::toString\, \StringToBigInt\, \ToBigInt\) and Number/String conversions (\Number::toString\, \StringToNumber\, \StringToCodePoints\). It also introduces detailed implementations for several ECMAScript intrinsics, including \Function.prototype.toString\ (with source text and native code handling), \Math.random\, and \print\, alongside stubs for various \toLocaleString\ methods. Furthermore, the update adds manual models for critical Abstract Operations (\RequireObjectCoercible\, \ToBoolean\, \ToObject\, \IsInTailPosition\, \PrepareForTailCall\) and a suite of auxiliary functions (\\_\_NEW\OBJ\\\, \\\_NEW\_ERROR\OBJ\\\, \\\_IS\_ARRAY\INDEX\\\, \\\CLAMP\\_\, etc.) to support internal logic. Finally, it implements host hooks for module loading and promise handling (\HostEnqueuePromiseJob\, \HostGetImportMetaProperties\, \HostPromiseRejectionTracker\, etc.).

src/main/resources/manuals/funcs · high confidence

Added the foundational resource files for the \manuals\ subsystem, which provides a formal, executable model of the ECMAScript specification. This includes \rule.json\ defining the logical conditions and instruction mappings for abstract operations, \intrinsics\ and \types\ files specifying the structure of built-in objects and ECMAScript language types, \tycheck-ignore.json\ for type-checking exclusions, and \algos/RunJobs.algo\ implementing the host job queue processing loop. These resources enable the engine to interpret and execute ECMAScript algorithms according to the standard's manual rules.

src/main/resources/manuals · high confidence

The repository is initialized with essential configuration files, including \.jvmopts\ for JVM memory settings, \.scalafmt.conf\ for code formatting, and \.gitmodules\ to manage submodules for the ECMA-262 specification, Test262 tests, and the debugger client. A new \.completion\ file is added to provide command-line auto-completion for the \esmeta\ tool, listing commands such as \extract\, \compile\, \tycheck\, \test262-test\, and \fuzz\. The project structure is further defined by a \.gitignore\ file and a renamed \LICENSE.md\.

(repo-wide) · high confidence

An interactive Read-Eval-Print Loop (REPL) has been added to the static analyzer, allowing users to inspect and control the analysis process in real-time. The tool provides commands to set breakpoints on functions or control-flow graph nodes, step through execution, print variable states, view the worklist, and jump to specific iterations or entry points. This enables developers to debug type-checking issues and understand the analyzer's internal state without restarting the analysis.

src/main/scala/esmeta/analyzer/repl · high confidence

The engine now supports template-based intrinsic modeling, allowing users to define and replace intrinsic objects using named templates. A new \TemplateReplacer\ component enables the substitution of template instances into models, while the \package.scala\ file establishes a comprehensive set of predefined constants, addresses, and helper functions for intrinsics, typed arrays, symbols, and property descriptors. This change provides the foundational infrastructure for modeling complex ECMAScript intrinsic behaviors and object structures more flexibly.

src/main/scala/esmeta/es/builtin · high confidence

The type system in the \esmeta.ty\ package has been expanded with new structural types to support more precise static analysis. \AstTy\ now models AST value types, including simple sets of nonterminal names and detailed types with right-hand side indices. \ListTy\ and \MapTy\ provide lattice-based type definitions for list and map structures, enabling containment checks and union/intersection operations on their element types. \RecordTy\ has been significantly enhanced to support named record types with refined fields, allowing for complex subtyping, union, and intersection logic based on field maps. These additions are complemented by a comprehensive set of predefined value types in \package.scala\, such as \RecordT\, \ListT\, and \AstT\, which integrate these new structures into the broader type hierarchy.

src/main/scala/esmeta/ty · high confidence

A new CFGBuilder module has been added to the codebase, providing the core logic to translate IR functions into Control Flow Graphs (CFGs). This component processes program functions by iterating through their bodies, handling normal instructions, sequences, calls, and branch instructions (including if/else and while loops) to construct the corresponding graph nodes and edges. It also integrates with an allocation site setter to track memory allocation contexts during the build process.

src/main/scala/esmeta/cfgbuilder · high confidence

The CFG module now includes a new SdoInfo enum to represent Static Data Object information, distinguishing between default function contexts and base object contexts with specific indices. Additionally, the CFGElem trait has been introduced to standardize how CFG elements are serialized, providing methods for detailed stringification, flow string generation, and SHA-512 fingerprinting to support CFG validity testing.

src/main/scala/esmeta/cfg · high confidence

ESMeta now includes a new \tycheck\ command that performs static type analysis on ECMAScript specifications and programs. This change introduces a dedicated analyzer framework, including abstract domains for values (\AbsValue\), states (\AbsState\), and effects (\Effect\), along with a REPL for interactive debugging of the type-checking process. Users can now run \esmeta tycheck\ to verify type consistency in the extracted specification model, helping to catch type errors before execution.

repository · high confidence

A new \esmeta.compiler\ package has been added, introducing core components to translate the metalanguage specification into Intermediate Representation (IR). This includes the \Compiler\ class for processing algorithms, \BackEdgeWalker\ to link IR elements back to language definitions, \ReturnModifier\ to handle completion records, and \TyCompiler\ for type normalization. The module also provides utility helpers in \package.scala\ for reference and intrinsic conversions, enabling the system to compile ECMAScript specification algorithms into executable IR.

src/main/scala/esmeta/compiler · high confidence

The new \esmeta.state\ package introduces foundational IR state elements, including predefined enums (such as \ENUM\_UNINITIALIZED\, \ENUM\_NORMAL\, and promise states like \ENUM\_FULFILLED\), global identifiers, and infinity constants. It also implements a \toStringHelper\ function for converting numbers to strings that utilizes \MathContext.UNLIMITED\ for precise mathematical value representation, ensuring accurate decimal formatting without precision loss.

src/main/scala/esmeta/state · high confidence

This change introduces a suite of new utility classes and objects in the IR package to support parsing, JSON serialization, stringification, and tree traversal of the Intermediate Representation. Specifically, it adds a Parser for converting string representations into IR structures, a JsonProtocol for encoding and decoding IR elements to/from JSON, a Stringifier for generating human-readable IR text, and Walker/UnitWalker traits for traversing IR trees. Additionally, it includes an AllocSiteSetter for automatically assigning allocation sites and a YetCollector for gathering 'yet' expressions from the IR.

src/main/scala/esmeta/ir/util · high confidence

The fuzzer now supports the synthesis and mutation of JavaScript programs. This change introduces a new \TargetSelector\ to choose mutation targets based on branch coverage, and a suite of new mutators (\NearestMutator\, \RandomMutator\, \Remover\, \SpecStringMutator\, \StatementInserter\) that modify the ECMAScript AST. It also adds synthesizers (\BuiltinSynthesizer\, \RandomSynthesizer\, \SimpleSynthesizer\) to generate initial scripts and mutate specific AST nodes, enabling the fuzzer to create and evolve JavaScript code for testing.

src/main/scala/esmeta/fuzzer · high confidence

A new \esmeta.injector\ module has been added to automatically generate ECMAScript conformance test scripts from execution traces. This includes an \Injector\ class that analyzes the final state of an interpreter run to produce assertions about global and lexical variables, object properties (such as extensibility and callability), and prototype chains. The module also defines \ExitTag\ to categorize execution outcomes (normal, timeout, spec error, or thrown value) and a \Stringifier\ to output these results as runnable JavaScript test files using standard assertion libraries.

src/main/scala/esmeta/injector · high confidence

Added four new utility classes in the \esmeta.cfg.util\ package to support exporting and inspecting Control Flow Graphs: \DotPrinter\ generates Graphviz DOT format output for visualizing CFGs with colored entry/exit nodes and edges; \FlowStringifier\ provides a compact textual representation of CFG structure; \JsonProtocol\ enables JSON serialization and deserialization of CFG elements (functions, blocks, calls, branches) using circe; and \Stringifier\ offers a detailed textual dump of CFGs with configurable detail and location options. These utilities allow users to export CFGs for external visualization tools, debug CFG structures via text logs, and integrate CFG data into JSON-based workflows.

src/main/scala/esmeta/cfg/util · high confidence

Added new utility classes in the metalanguage package to support JSON serialization and AST traversal. The \JsonProtocol\ object provides JSON encoding and decoding for all metalanguage elements (steps, expressions, conditions, references, etc.) using the circe library, enabling interchange with other tools. The \CaseCollector\ class walks the metalanguage AST to collect and categorize steps, expressions, conditions, and references by type, which is useful for analysis and debugging. The \StepCollector\ class specifically extracts all steps from a metalanguage element. The \UnitWalker\ and \Walker\ traits provide base classes for traversing and transforming metalanguage AST nodes, with \UnitWalker\ for side-effecting traversal and \Walker\ for structural transformation.

src/main/scala/esmeta/lang/util · high confidence

This change introduces a new phase execution model via the \Phase\ trait and \ArgParser\, allowing commands to be structured into configurable stages with JSON-based option injection. It adds a comprehensive set of utility modules including \Appender\ for structured text formatting, \BasicParsers\ and \BasicJsonProtocol\ for serialization, \BasicWalker\ and \BasicUnitWalker\ for tree traversal, and \SystemUtils\ for file and JSON I/O. Additionally, it provides shell autocompletion generation via \GenCompl\ and GitHub Actions workflow integration via \GitHubAction\.

src/main/scala/esmeta/util · high confidence

This change introduces a new HTTP-based debugger service and associated visualizer dump utilities. It adds a WebServer using http4s that exposes endpoints for execution control (step, continue, rewind), breakpoint management, and specification metadata. The dump module gains new components to generate visualizer logs, including mappings from node IDs to program IDs and Test262 identifiers, step-to-node mappings, and section-to-function information, along with utilities for JSON serialization and step counting to support the new debugging interface.

src/main/scala/esmeta/dump · high confidence

The test262 module now includes a new stringifier that formats test results with enhanced detail. Users will see output that explicitly lists negative assertions, flags, included files, features, and ES5 compatibility status for each test, providing a more comprehensive summary of test execution results.

src/main/scala/esmeta/test262 · high confidence

The specification documentation has been updated to allow built-in function objects as valid constructors in InitializeInstanceElements, added an early return for negative search lengths in StringLastIndexOf to prevent invalid indexing, and enforced error handling in TypedArray construction by wrapping conversion operations with a throw completion. These changes refine the defined behavior for instance initialization, string searching, and typed array element conversion.

src/main/resources/manuals/bugfix · high confidence

The IR package has been restructured to define core operator types (unary, binary, variadic, mathematical, and conversion) as Scala enums in Op.scala, and to integrate the IR Stringifier directly with the IRElem toString method via package.scala. This change also introduces a LangEdge trait for backward edges to the metalanguage and defines a set of predefined global identifiers, local variables, and auxiliary function bindings used throughout the IR.

src/main/scala/esmeta/ir · high confidence

The application now requires the ESMETA\_HOME environment variable to be set, which defines the base project directory root. This change replaces the previous implicit or default directory resolution, ensuring that all internal paths (such as logs, tests, and resources) are anchored to this explicit location. If the variable is not provided, the application will throw a NoEnvVarError upon startup.

src/main/scala/esmeta · high confidence

The error handling module now includes a new ESMetaError class that automatically tags error messages with the current ESMeta version. A specific NoEnvVarError has been added to provide a clear, user-facing message when the ESMETA\_HOME environment variable is missing, including a link to the documentation for setting it up.

src/main/scala/esmeta/error · high confidence

The \esmeta.lang\ module now provides foundational abstractions for the metalanguage, introducing the \Syntax\ trait as the base for syntax elements and the \LangElem\ trait with a unified stringification mechanism for all language components. This change establishes the structural basis for the language representation, replacing previous ad-hoc implementations with a consistent hierarchy that supports detailed and location-aware string output.

src/main/scala/esmeta/lang · high confidence

The type checker now employs a new symbolic type system (SymTy) to represent abstract values, enabling more precise analysis through symbolic references and refinement. Additionally, the system tracks the provenance of type refinements, recording which variables were refined and by what conditions, which supports better debugging and visualization of the analysis results.

src/main/scala/esmeta/analyzer/tychecker · high confidence

The parser module has been restructured to support ECMAScript 2025 and Unicode 17.0.0. A new \AstFrom\ trait standardizes how abstract syntax trees are generated from strings or files, while the \Unicode\ object now loads character properties (such as ID\_Start and ID\_Continue) from JSON data for the latest Unicode version. Additionally, \UnicodeParsers\ provides updated parsers for special code points, whitespace, and line terminators required by the new specification.

src/main/scala/esmeta/parser · high confidence

The static analyzer in \src/main/scala/esmeta/analyzer\ has been restructured to support pluggable abstract domains. This change introduces new trait-based abstractions (\AbsTransferLike\, \DomainLike\, \ViewLike\) and a refactored \Analyzer\ base class that manages the fixpoint computation, control flow graph traversal, and abstract state management. For users, this represents a significant internal architectural shift that enables more flexible and modular type analysis implementations, although the external analysis results remain consistent.

src/main/scala/esmeta/analyzer · medium confidence

The result files in src/main/resources/result have been regenerated to reflect the ES2026 specification update. The spec-summary now reports 400 grammar productions, 2,909 algorithms, and 8,381 types, with a complete coverage of 87.38% for algorithms and 96.83% for algorithm steps. A new cfg-fingerprint file has been added to track control-flow graph integrity, and the complete-funcs file has been expanded to include detailed analysis data for the updated specification.

src/main/resources/result · high confidence

Added ECMAScript specification tests; Added ECMAScript test infrastructure and small test suites; Added IR expression and instruction test suite; Added IR parser and interpreter test suites; Added IR test suite for core language features; Added compiler validity tests; Added extractor module with specification element utilities; Added test coverage for ESMeta language components; Added test coverage for IR stringify functionality; Added test coverage for JSON serialization of Tiny AST components; Added test coverage for compiler and CFG builder validity; Added test coverage for completion functionality; Added test coverage for extractor validity; Added test coverage for interpreter evaluation and analyzer type checking; Added test coverage for state module components; Added test coverage for ty package components; Added test for visualizer section-to-function mapping; Added test infrastructure and completion verification; Added test results for CFG stringify and validity checks; Added test results for EvalSmallTest and ParseSmallTest; Added test results for StringifyTinyTest and TypeSmallTest; Added test262 evaluation and parsing test suites; Added tests for CFG builder validity; Added tests for CFG stringify and validity; Added tests for IR state stringify functionality; Added tests for JSON serialization and stringification of spec grammar and algorithm components; Added tests for injector assertion stringify functionality; Added tests for the type checker analyzer; Added unit tests for the type system module; Updated test262 submodule to ES2023-compatible version.

The build configuration has been upgraded to Scala 3.3.6, requiring users to ensure their environment supports this version. Several core libraries have been updated to newer versions: Circe (0.14.7), Circe YAML (0.16.0), Zio HTTP (3.3.2), Http4s (0.23.30), ScalaTest (3.2.19), and Commons Text (1.13.0). The build also enables semanticdb support for Metals and configures sbt-ghpages for scaladoc generation.

(dependencies) · high confidence

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

• First survey — no prior run to compare against. CAI 58.

• Code Health 45
• Architecture 97
• Maturity 59
• Readiness 68
• Security 78
• Domain Modelling 100

• 300 commits — 247 feature/other, 53 fixes

• src/main — 219 commits
• (root) — 58 commits
• .github/workflows — 8 commits
• tests/result — 6 commits
• tests/ir — 2 commits
• tests/test262 — 2 commits
• project/build.properties — 1 commit
• project/ghpages.sbt — 1 commit
• scripts/release — 1 commit
• src/test — 1 commit
• tests/es — 1 commit

• fix: Add bugfix related to normal completion return value of continuations
• fix: Fix BackEdgeWalker (#281)
• fix: Fix Metalanguage Stringifier (#278)
• fix: Fix Random Termination of WebServer (#280)
• fix: Fix Tests (#295)
• fix: Fix WebServer (#290)
• fix: Fix dump-visualizer (#282)
• fix: Fix getVersion to handle tag properly (#158)
• fix: Fix lookupStr not to lookup when str is Bottom (#154)
• fix: Fix a bug in __IS_ARRAY_INDEX__ modeling in IR (#318)
• fix: Fix a bug in evaluating variadic operators in Interpreter (#325)
• fix: Fix broken links for PLDI tutorial slides
• fix: Fix bug in DumpDebugger
• fix: Fix bugs in handling FunctionT and ConstructorT (#300)
• fix: Fix bugs in type modeling
• fix: Fix error in bugfix process
• fix: Fix error in type analysis for short circuit expressions
• fix: Fix error in type propagation
• fix: Fix error in typing rules for EKeys (#207)
• fix: Fix errors in post-submit workflow
• …and 280 more

• 0 containers · 1 bounded contexts · 0 dependency edges (baseline)

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

es-meta/esmeta 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.