oxc-project/oxc

This system is a high-performance, Rust-based toolchain for JavaScript and TypeScript that provides parsing, linting, formatting, and minification capabilities. It exposes these core engine functions through Node.js bindings, enabling integration into build pipelines and IDEs via a unified API. The toolchain supports a wide range of file types including CSS, JSON, YAML, and GraphQL, and includes specialized transformers for React and Relay.

133 changes.

This period focused on restructuring the Oxc codebase into a modular architecture with dedicated crates for AST, diagnostics, and memory management, while establishing a unified compiler interface. Significant effort was directed toward building a robust JavaScript plugin system for oxlint, featuring raw memory transfer, ESLint compatibility, and extensive conformance testing. The work also expanded the toolchain's capabilities with new formatters, minification APIs, and isolated declaration generation, all supported by comprehensive documentation and CI infrastructure.

104 changes.

This period focused on replacing Prettier dependencies with native Rust formatters for CSS, JSON, YAML, and Markdown, while introducing a Prettier compatibility layer for embedded languages. It also established a robust JavaScript/TypeScript configuration system for oxlint and oxfmt, complete with extensive conformance testing and LSP integration.

Oxfmt now includes CLI commands to automatically migrate configuration files from Biome and Prettier into the native \.oxfmtrc.json\ format. The \--init\ command scaffolds a default configuration, while \--migrate biome\ and \--migrate prettier\ read existing settings (including plugin-specific options like \prettier-plugin-tailwindcss\ and \prettier-plugin-packagejson\) and convert them to Oxfmt equivalents. The migration logic handles common formatting options, ignore patterns, and warns about unsupported features such as Biome overrides or Prettier plugins without Oxfmt equivalents.

apps/oxfmt/src-js/cli/migration · high confidence

Introduces a new Rust-based transform for Relay's \graphql\ tagged template expressions, ported from \babel-plugin-relay\ and \swc\_relay\. The \oxc\_relay\ crate rewrites \graphql\ tags into imports or requires pointing to artifacts generated by \relay-compiler\, supporting options for artifact directory, language (JavaScript, TypeScript, Flow), and eager ES module emission. This core logic is exposed via the \oxc-transform-relay\ Node.js package (\napi/transform-relay\), providing both synchronous and asynchronous APIs for use in build toolchains.

_crates/oxc\relay, napi/transform-relay · high confidence

A new \tasks/minsize\ crate has been added, providing a \cargo minsize\ command that benchmarks the Oxc minifier against a suite of popular JavaScript libraries (such as React, Vue, and Lodash). The task outputs a table comparing Oxc's minified and gzipped sizes against ESBuild benchmarks, saves the resulting minified files to \./target/minifier\, and records the number of compression iterations. It also supports a \--compress-only\ flag to disable mangling for isolated compression testing.

tasks/minsize · high confidence

A new example file, \crates/oxc/examples/compiler.rs\, has been added to demonstrate the complete Oxc compilation pipeline. This example shows how to use the \Compiler\ struct to parse, perform semantic analysis, transform, and generate code for a JavaScript or TypeScript file, handling both successful output and error rendering.

crates/oxc/examples · high confidence

A new utility in the \tasks/transform\_checker\ crate validates that the transformer maintains correct semantic data (\ScopeTree\ and \SymbolTable\) after processing the AST. It works by cloning the post-transform AST, running a fresh semantic analysis on it, and comparing the resulting scope, symbol, and reference IDs against the transformer's output. This ensures that semantic state remains consistent with the modified AST structure.

_tasks/transform\checker · high confidence

A new \website\_formatter\ task has been added to automatically generate documentation for the Oxfmt CLI and its configuration schema. This tool produces Markdown help pages for the command-line interface (including options like \--init\, \--migrate\, and \--config\) and renders the full \Oxfmtrc\ configuration schema into Markdown, covering options such as \arrowParens\, \jsdoc\, and \experimentalOperatorPosition\. This ensures that the website's formatter documentation stays synchronized with the actual tool capabilities and configuration options.

_tasks/website\formatter · high confidence

The \@oxc-project/runtime\ package now includes a comprehensive set of helper functions required to transpile modern JavaScript features, specifically focusing on the Decorators proposal and class private fields. This update adds runtime support for various stages of the decorator specification (via helpers like \applyDecs2203\, \applyDecs2301\, \applyDecs2305\, and \applyDecs2311\), as well as utilities for private field access (\classPrivateFieldGet\, \classPrivateFieldSet\), metadata handling (\decorateMetadata\), and async iteration. Users relying on these transpiled features will now have the necessary runtime dependencies available in this package.

npm/runtime · high confidence

The oxfmt package now includes build scripts that automate the compilation process and the generation of TypeScript configuration types. The new build script handles the compilation via tsdown and ensures native \.node\ files are copied to the distribution directory, while a separate script generates TypeScript definitions from the JSON configuration schema, ensuring type safety for configuration files without manual maintenance.

apps/oxfmt/scripts · high confidence

A new \compat\_data\ task has been added to automatically generate the \ESFeature\ enum and the \features()\ lookup map in \crates/oxc\_compat/src/es\_features.rs\. This tool reads compatibility data from \tasks/compat\_data/data.json\ and produces the Rust source code, removing the need for manual maintenance of this mapping between ECMAScript features and engine targets.

_tasks/compat\data · high confidence

The \tasks/website\_linter\ task now automatically generates the linter's website documentation, including CLI help pages, JSON configuration schemas, and individual rule documentation pages. This ensures that the website's reference materials for configuration options, CLI flags, and rule behaviors stay in sync with the linter's current codebase without manual updates.

_tasks/website\linter · high confidence

The repository now includes foundational configuration files to standardize development workflows and tooling. A \.clippy.toml\ file enforces performance best practices by disallowing \std::collections::HashMap\/\HashSet\ in favor of faster \FxHashMap\/\FxHashSet\ and preventing memory-allocating string methods. Editor settings are standardized via \.editorconfig\, and Rust formatting is defined in \.rustfmt.toml\. To support AI-assisted development, \AGENTS.md\ provides comprehensive guidelines, repository structure, and command references for contributors. Additionally, \.gitattributes\ ensures consistent line endings for test fixtures, and \.git-blame-ignore-revs\ filters out large formatting commits from blame history.

(repo-wide) · high confidence

The \crates/oxc\_ast/src/generated\ directory now contains auto-generated Rust source files that define the core AST structure and builder infrastructure. This includes \ast\_kind.rs\, which enumerates all AST node types (such as \Program\, \Expression\, and various TypeScript nodes) for pattern matching; \ast\_builder.rs\, which provides arena-allocated constructor methods for creating AST nodes; \derive\_clone\_in.rs\ and \derive\_content\_eq.rs\, which implement cloning and content-equality logic for semantic analysis and transformation; and \assert\_layouts.rs\, which enforces struct memory layout and padding constraints. These files are produced by \ast\_tools\ and form the foundational code generation layer for the AST.

_crates/oxc\ast/src/generated · high confidence

Developers can now use a pre-configured VS Code dev container to work on the project. The environment is based on the official Rust container and includes essential build tools (just, cmake) and the uv package manager. It provides a curated set of VS Code extensions for Rust, TOML, Git, and syntax highlighting, along with features like SSH, Node.js, GitHub CLI, and Claude Code. A post-creation script automatically installs ast-grep, the Graphite CLI, and initializes the project using 'just'.

.devcontainer · high confidence

This entry introduces the \oxc\_napi\ crate, which provides Node.js native bindings for oxc's parsing, linting, and transformation capabilities. It exposes structured error objects (\OxcError\) with codeframes and labels, handles UTF-8 to UTF-16 span conversion for JavaScript compatibility, and allows JavaScript consumers to specify source types (including \commonjs\ and \dts\) and interact with regular expressions via a \JsRegExp\ wrapper.

_crates/oxc\napi · high confidence

The \crates/oxc\_ast\ crate is introduced, providing the core Abstract Syntax Tree definitions for JavaScript, TypeScript, and JSX. This includes the \AstKind\ and \AstType\ enums for node identification, expression precedence logic in \precedence.rs\, and utilities for handling source code trivia (comments and whitespace) in \trivia.rs\. The crate also exposes AST builder methods and generated traits for span and address management, forming the foundational data structures for the Oxc parser and codegen tools.

_crates/oxc\ast/src · high confidence

The \oxc\_diagnostics\ crate now includes a \JSONReportHandler\ that renders diagnostics as machine-readable JSON, including message, code, severity, help, note, filename, and label spans with line/column details. This enables programmatic consumption of diagnostic output by external tools and IDEs. The crate also exposes a \DiagnosticReporter\ trait and \DiagnosticService\ for flexible, multi-threaded diagnostic collection and reporting, along with a \Diagnostics\ collection type that tracks error and warning counts.

_crates/oxc\diagnostics · high confidence

This change adds the core JavaScript infrastructure for the new JS plugin system, including the \eslintCompatPlugin\ function that converts Oxlint's native \createOnce\ plugin API into ESLint-compatible \create\ methods, enabling existing plugins to run within ESLint. It also introduces the \defineConfig\ helper for type-safe configuration files, the \definePlugin\ and \defineRule\ helpers for plugin definition, and the \RuleTester\ class for testing rules with ESLint compatibility mode, language options, and fix recursion support.

apps/oxlint/src-js/package · high confidence

The \oxc\_str\ crate now includes \JSStr\, \JSChar\, and \JSStrBuilder\ to handle JavaScript strings that may contain lone surrogates, which standard Rust \str\ cannot represent. These types store data in canonical WTF-8 format, allowing safe round-tripping of UTF-16 code units while preserving surrogate information. \JSStr\ provides methods to check for lone surrogates, encode to UTF-16, and safely convert to \&str\ when no surrogates are present, enabling accurate parsing and manipulation of JavaScript string literals.

_crates/oxc\str · high confidence

Added a new N-API module (\napi/transform-react\) that exposes synchronous and asynchronous functions to compile React modules using the React Compiler. This binding allows users to transform JavaScript/TypeScript with JSX support, generate source maps, and configure the compiler via options such as compilation mode, target version (17/18/19), and ESLint suppression rules. It also supports reporting recoverable diagnostics when enabled, providing detailed feedback on compilation bail-outs or lint findings without halting the transform.

napi/transform-react · high confidence

This change adds the \napi/minify\ module, exposing synchronous (\minifySync\) and asynchronous (\minify\) JavaScript functions to minify source code directly from Node.js. The API accepts \MinifyOptions\ which allow users to configure compression (e.g., \drop\_console\, \drop\_debugger\, \unused\, \join\_vars\, \sequences\, \drop\_labels\, \max\_iterations\), tree-shaking (e.g., \annotations\, \manual\_pure\_functions\, \property\_read\_side\_effects\, \property\_write\_side\_effects\, \unknown\_global\_side\_effects\, \invalid\_import\_side\_effects\), and code generation (e.g., \target\, \sourcemap\, \legalComments\). The result includes the minified code, an optional source map, parse/minification errors, extracted legal comments, and a property-name mangling cache.

napi/minify · high confidence

A new Prettier plugin (\prettier-plugin-oxfmt\) has been added to allow the Oxc formatter to handle JavaScript and TypeScript code embedded within Vue Single File Components (SFCs) and Svelte files. This plugin overrides Prettier's default JS/TS parsers to route embedded code through the Rust-based \oxc\_formatter\, enabling features like import sorting for code inside \\<script\>\ blocks. It supports various contexts including standard JS/TS, TSX, and specific Vue constructs like v-for bindings and generic type parameters, while also handling internal optimizations like shared reference resolution and dedent restoration.

apps/oxfmt/src-js/libs/prettier-plugin-oxfmt · high confidence

A new \Vec2\ module has been added to the allocator crate, providing a contiguous growable array type (\Vec\<'a, T\>\) backed by an arena allocator. This implementation is derived from the standard library's \std::vec\ and Bumpalo's \Vec\, offering O(1) indexing, amortized O(1) push/pop, and integration with the project's custom \Alloc\ trait. The module includes a low-level \RawVec\ component for managing memory layout and capacity, supporting fallible reservation and specialized growth methods.

_crates/oxc\allocator/src/vec2 · high confidence

The \oxc\_allocator\ crate now exposes a \GetAllocator\ trait to abstract how code retrieves the underlying arena allocator, replacing previous direct access patterns. Additionally, a new \Address\ type and associated \GetAddress\/\UnstableAddress\ traits are introduced, allowing users to obtain stable or unstable memory addresses for AST nodes allocated in the arena. This enables reliable node identification and comparison, particularly for nodes stored in \Box\es which are guaranteed not to move in memory.

_crates/oxc\allocator/src · high confidence

The \oxc\_codegen\ crate now supports an \ascii\_only\ option that forces all generated output to use only ASCII characters, which is useful for environments that do not support UTF-8 or for ensuring compatibility with legacy systems.

_crates/oxc\codegen · high confidence

The \tasks/ast\_tools\ crate now provides a structured code generation engine for the AST, replacing the previous ad-hoc codegen. It introduces a \Codegen\ runner that manages \Derive\ and \Generator\ implementations, allowing attributes like \\#\[clone\_in\]\ and \\#\[content\_eq\]\ to drive the generation of traits such as \CloneIn\ and \ContentEq\. This change centralizes the logic for generating AST-related code, including handling of semantic IDs and layout calculations, into a reusable and extensible framework.

_tasks/ast\tools · high confidence

The \napi/minify\ directory now contains the complete \oxc-minify\ NAPI package, exposing synchronous and asynchronous minification APIs (including property mangling, compression, and codegen options) to Node.js and browsers. The package includes a robust binding loader (\index.js\) that attempts to load native addons for supported platforms and falls back to a WASI-based WebAssembly build (\minify.wasi-browser.js\) for browser environments. A new \disable-reused-workers.mjs\ utility is provided to patch the WASI bindings, disabling the \reuseWorker\ option to prevent cross-origin worker URL errors when loading the binding from a CDN. Additionally, a \.gitignore\ file is added to exclude generated build artifacts and temporary test files.

napi · high confidence

The \oxc\_estree\ crate is now available to provide ESTree compatibility for the oxc AST, enabling serialization to and from JSON in the ESTree format. This allows oxc AST nodes to be serialized for interoperability with other JavaScript tools (such as Babel or ESLint) and for debugging. The crate includes a custom serializer (replacing \serde\), supports both compact and pretty-printed JSON output, and allows runtime configuration to include or exclude TypeScript-specific fields and range information.

_crates/oxc\estree · high confidence

The \oxc\_syntax\ crate has been added to centralize shared JavaScript and TypeScript syntax definitions, constants, and utilities used across the oxc toolchain. This new location provides fundamental types and enums representing language constructs, including identifier validation, operator precedence tables, module record structures for import/export tracking, and semantic ID types. It also includes generated code for AST serialization, cloning, and layout assertions, serving as a foundation for the parser, semantic analysis, linter, and transformer components.

_crates/oxc\syntax · high confidence

The \oxc\_mangler\ crate now exposes a \MangleOptions\ API allowing users to control mangling behavior via \top\_level\ (defaulting to enabled for modules and CommonJS), \keep\_names\ (to preserve function/class \name\ properties), \reserved\ (to prevent mangling specific names like \exports\), and \debug\ (for readable slot names). Internally, the base54 name generator has been optimized to use a frequency-ordered character set for better gzip compression and utilizes \InlineString\ to avoid heap allocations. The crate also includes logic to collect and preserve symbols used in \name\ property assignments and integrates with the minifier pipeline to return private class member mappings.

_crates/oxc\mangler · high confidence

The new \oxc\_formatter\_css\ crate provides a Prettier-compatible formatter for CSS, SCSS, and Less files, replacing the previous Prettier fallback. It uses the \oxc-css-parser\ (a \raffia\ fork) to parse stylesheets and \oxc\_formatter\_core\ to generate the output, supporting standard CSS as well as SCSS and Less dialects. The crate exposes entry points for standalone formatting (\format\) and embedded usage via the dispatcher (\format\_to\_ir\), which enables css-in-js support by handling \${}\ interpolation markers. It also includes configuration options for dialect variants, Tailwind \@apply\ class sorting, and specific layout rules for comments and line endings.

_crates/oxc\_formatter\css · high confidence

A new \oxc\_formatter\_json\ crate provides a standalone, high-performance formatter for JSON, JSONC, JSON5, and JSON.stringify outputs, built on \oxc\_formatter\_core\. It supports four formatting variants (Json, Jsonc, Json5, JsonStringify) that control features like trailing commas, quote styles, and comment handling, while parsing all inputs leniently via the JavaScript parser to match Prettier's behavior. The formatter includes a CLI example for ad-hoc compatibility checks, automatic variant inference from file extensions, and optimized performance that is 1.4–2.3x faster than routing JSON through the general-purpose \oxc\_formatter\.

_crates/oxc\_formatter\json · high confidence

The oxfmt language server is now a standalone component within the oxfmt application, replacing the previous shared formatter integration. This change introduces a dedicated \ServerFormatter\ that handles document formatting via the LSP protocol, including support for dynamic worker management, per-directory configuration resolution, and specific file-type handling (such as mapping language IDs to file extensions). Users benefit from a more isolated and robust formatting experience in their editors, with improved configuration discovery and error handling specific to the formatter's needs.

apps/oxfmt/src/lsp · high confidence

The \oxc\_estree\_tokens\ crate now provides the core logic for converting parser tokens into ESTree-compatible formats. It supports two distinct output modes: serializing tokens to compact or pretty JSON, and updating token kinds in-place for efficient raw transfer to JavaScript. The implementation handles both JavaScript (Espree) and TypeScript (TS-ESLint) token styles, correctly managing differences such as JSX identifier emission, escaped identifier decoding, and \this\ keyword handling. It also includes performance optimizations like pre-allocating JSON buffers, using custom serializers instead of \serde\, and sharing a single JS token update entry point.

_crates/oxc\_estree\tokens · high confidence

The \oxc\_regular\_expression\ crate is introduced to provide a standalone parser and AST for ECMAScript regular expressions, implementing the ES2024 specification and Stage 4 proposals such as duplicate named capturing groups, regexp modifiers, and buffer boundary assertions. This change adds a complete AST structure (including nodes for patterns, disjunctions, character classes, and lookaround assertions), a \LiteralParser\ for parsing regex literals, and a visitor pattern for AST traversal. It also includes comprehensive diagnostics for invalid syntax, support for Unicode property escapes, and examples demonstrating parsing and AST inspection.

_crates/oxc\_regular\expression · high confidence

The \oxc\_isolated\_declarations\ crate is added, implementing TypeScript's isolated declarations feature to generate \.d.ts\ files from source code without requiring full type checking. This enables faster builds and better incremental compilation by extracting type information locally. The implementation includes AST transformation logic for classes, functions, variables, and enums, along with a diagnostic system that enforces explicit type annotations for exported members (e.g., TS9007–TS9039 errors) and provides an example demonstrating usage via the \IsolatedDeclarations\ API.

_crates/oxc\_isolated\declarations · high confidence

The \crates/oxc\_lexer\ crate now provides a new standalone lexer implementation that uses SIMD (AVX2) on x86\_64 platforms to significantly improve tokenization performance. This new engine is designed to be spec-compliant, handling JS, JSX, and TS, and includes robust support for edge cases like regex vs. division disambiguation and HTML-like comments in JSX. It also features a scalar fallback for other architectures and includes detailed comment metadata tracking for tooling integration.

_crates/oxc\lexer · high confidence

The diagnostic reporting system has been restructured to support a wider variety of output formats, including new formatters for Agent, Checkstyle, GitLab, JUnit, SARIF, and Stylish styles, alongside updates to the existing Default, GitHub, JSON, and Unix reporters. This change introduces a unified \InternalFormatter\ trait and \DiagnosticReporter\ interface, allowing each format to handle its own rendering logic (such as path normalization for GitLab or XML escaping for Checkstyle/JUnit) while centralizing format selection in the \OutputFormat\ enum. Users can now select these formats via the \--format\ flag to integrate oxlint results into CI/CD pipelines, IDEs, or other tooling that expects specific report structures.

_apps/oxlint/src/output\formatter · high confidence

A new \oxc-codegen\ package has been added to provide a pure JavaScript/TypeScript code generator that produces byte-identical output to the Rust \oxc\_codegen\ crate. This package supports JavaScript, JSX, TypeScript, and TSX, and introduces full Source Map v3 generation via the \sourcemap\ option. The \printSync\ API has been updated to return an object containing both the generated \code\ and the optional \map\, replacing the previous string-only return. The package is optimized for performance by using specialized builds for different feature combinations (with/without source maps, with/without TypeScript) to maintain monomorphic code paths.

packages/codegen · high confidence

The new \oxc\_compat\ crate provides the core compatibility data and logic used by the Oxc toolchain to determine which ECMAScript features are supported by target engines. It exposes an \EngineTargets\ API that parses browser and Node.js version queries (via Browserslist), maps them to specific engine versions, and checks feature support against a generated compatibility table (\es\_features.rs\). This enables the transformer and minifier to make consistent decisions about which code transformations are necessary based on the user's target environment.

_crates/oxc\compat · high confidence

A new \oxc\_transformer\_plugins\ crate has been added to provide specialized, composable transformation plugins. It includes a \ReplaceGlobalDefines\ plugin that replaces compile-time constants (such as \process.env.NODE\ENV\ or \import.meta\ properties) with configured values, and an \InjectGlobalVariables\ plugin that automatically injects import statements for global variables (e.g., replacing \Buffer\ with an import from a polyfill). Additionally, a \ModuleRunnerTransform\ plugin is provided to transform standard ES module imports and exports into Vite-style SSR runtime calls (\\\_vite\_ssr\import\\_\), enabling compatibility with Vite's Node.js SSR environment.

_crates/oxc\_transformer\plugins · high confidence

The new \oxc\_traverse\ crate provides an advanced AST traversal system that allows visitors to access parent nodes and scope context during tree walks, addressing a limitation of traditional downward-only visitors. It includes a \TraverseCtx\ for managing parent stacks and scope information, \BoundIdentifier\ and \MaybeBoundIdentifier\ helpers for generating and managing variable bindings, and a \GatherNodeParts\ utility for extracting identifier names from AST nodes. The crate enforces memory safety by preventing aliasing violations through strict lifetime constraints on ancestor references, ensuring that parent nodes cannot outlive the traversal context.

_crates/oxc\traverse · high confidence

The \apps/oxfmt/src\ directory now contains the core Rust library (\lib.rs\) and entry points for the \oxfmt\ formatter. This includes a pure Rust CLI entry point (\main.rs\) for basic formatting and a NAPI-based entry point (\main\_napi.rs\) that exposes \run\_cli\ and \format\ functions to Node.js. The NAPI bindings allow JavaScript/TypeScript consumers to invoke the formatter programmatically, supporting features like JS/TS config loading, embedded code formatting (e.g., JS in Vue), and Tailwind CSS class sorting via callbacks. This change establishes the foundational Rust library structure and Node.js integration layer for \oxfmt\.

apps/oxfmt/src · high confidence

The \oxlint\ application now supports JavaScript plugins via a new NAPI-based architecture that uses raw memory transfer. This change introduces a fixed-size allocator model (defined in \raw\_transfer\_constants.rs\) where source text and AST data are passed directly between the Rust core and the JS plugin runtime via shared \Uint8Array\ buffers. This enables high-performance, zero-copy parsing and linting for JS plugins, replacing previous serialization overheads.

_apps/oxlint/src/js\plugins · high confidence

The NAPI parser now supports a raw transfer mode that writes the AST, comments, module record, and errors directly into a pre-allocated JavaScript Uint8Array buffer, eliminating JSON serialization overhead. This feature is available on 64-bit little-endian platforms via the \parse\_raw\ (async) and \parse\_raw\_sync\ functions, along with \get\_buffer\_offset\ to align the buffer. The implementation includes generated layout assertions to ensure memory layout stability, custom ESTree serialization for the raw types, and a metadata struct to track offsets for the program, tokens, and other data within the shared buffer. Users can opt into this high-performance path by providing a sufficiently large buffer and source text offsets, enabling direct deserialization on the JavaScript side.

napi/parser · high confidence

The new \oxc\_span\ crate provides the foundation for precise source location tracking throughout the oxc toolchain. It introduces a \Span\ system using UTF-8 byte offsets to enable accurate error highlighting and source map generation across the parser, semantic analysis, linter, and codegen. The crate also includes a \Source Type\ system for automatic language and module detection (JavaScript vs TypeScript, ESM vs Script, JSX support) and a \Labeled Span\ structure to support detailed diagnostic messages with primary and secondary highlights.

_crates/oxc\span · high confidence

The \oxc\_cfg\ crate is now a separate, standalone library providing data structures and algorithms for building and analyzing Control Flow Graphs from AST nodes. This new component supports block-based CFG construction, graph analysis (including dead code elimination, data flow analysis, and loop detection), and DOT export for Graphviz visualization. It introduces specific instruction types such as implicit returns and labeled break/continue statements, and includes an iterative depth-first search implementation to prevent stack overflows on large graphs.

_crates/oxc\cfg · high confidence

The \napi/transform\ package now exposes a new \isolated\_declaration\ API (both sync and async variants) that generates standalone \.d.ts\ declaration files from TypeScript source code. This feature allows users to emit type declarations without full JavaScript transformation, supporting options to strip \@internal\ JSDoc annotations and generate source maps for the resulting declarations.

napi/transform · high confidence

This change introduces the \napi/playground\ module, exposing a unified \Oxc\ API that allows users to parse, lint, format, transform, minify, and analyze JavaScript/TypeScript code from Node.js or browser environments. The API supports a wide range of options including parser settings, linter configuration, formatter preferences (such as quote styles and import sorting), transformer targets, and minification controls (including property mangling and dead code elimination). It also provides access to generated outputs like AST, control flow graphs, symbol tables, and isolated declarations, enabling developers to integrate Oxc's toolchain capabilities directly into their build pipelines or interactive tools.

napi/playground · high confidence

The \oxc\ crate now exposes a \Compiler\ struct and a \CompilerInterface\ trait that orchestrate the full JavaScript/TypeScript pipeline—parsing, semantic analysis, transformation, minification, and code generation—in a single, extensible entry point. Users can implement \CompilerInterface\ to customize each stage (e.g., enabling source maps, isolated declarations, or specific transform/minify options) and receive the final printed code or accumulated diagnostics, simplifying integration compared to manually chaining individual tool components.

crates/oxc/src · high confidence

The \tasks/coverage\ crate has been restructured into a modular test harness that centralizes the execution of parser, lexer, semantic, codegen, formatter, transformer, transpiler, minifier, runtime, and ESTree conformance tests. A new \Driver\ struct implements the \CompilerInterface\ to orchestrate the full compilation pipeline (parse, transform, minify, codegen) for individual test cases, while dedicated modules handle loading and running fixtures from Test262, Babel, TypeScript, and Acorn JSX. The runner now supports parallel execution via Rayon, includes a runtime test suite that executes transformed code in Node.js to catch semantic bugs, and provides a CLI interface to run specific test subsets or all suites at once.

tasks/coverage · high confidence

JavaScript plugins can now implement rules that require Code Path Analysis (CFG) via the new \walkProgramWithCfg\ function and \CfgVisitFn\ visitor type, enabling complex control-flow-based linting. The \SourceCode\ API is significantly expanded with new methods for retrieving comments (\getCommentsBefore\, \getCommentsAfter\, \getCommentsInside\, \getAllComments\) and tokens, as well as handling disable directives (\getDisableDirectives\). Additionally, the plugin system now supports rule fixes and suggestions through the \Fixer\ API, allowing rules to report diagnostics with automatic code corrections.

apps/oxlint/src-js/plugins · high confidence

The \apps/oxlint/src-js/workspace\ module now provides the JavaScript-side logic for managing isolated linting workspaces. It exposes functions to create and (stubbed) destroy workspaces, maintaining a registry of active workspaces and tracking the current one. This implementation supports reloading workspaces by clearing stale state and ensures that plugin data is correctly associated with specific workspace URIs, laying the groundwork for workspace-aware linting in the JS layer.

apps/oxlint/src-js/workspace · high confidence

The \oxc\_ast\_visit\ crate now exposes generated \Visit\ and \VisitMut\ traits for full AST traversal, alongside new \VisitJs\ and \VisitJsMut\ traits that skip TypeScript type-space nodes while still descending into JavaScript code nested within TypeScript constructs (such as decorators, enum initializers, and type casts). This allows tools to process the JavaScript runtime portion of a TypeScript AST without needing to manually filter out type-only grammar.

_crates/oxc\_ast\visit/src/generated · high confidence

The \apps/oxlint/src/command\ directory now contains the core CLI argument definitions for the linter, including \ignore.rs\ for file exclusion options, \lint.rs\ for the main linting command structure, and \mod.rs\ for miscellaneous options like thread count and silent mode. This change introduces the \bpaf\-based argument parsing infrastructure that defines how users interact with oxlint's command-line interface, such as specifying ignore paths, patterns, and thread usage.

apps/oxlint/src/command · high confidence

Added a new conformance test runner in \apps/oxlint/conformance/src\ that validates Oxlint's JS plugin compatibility against ESLint's \RuleTester\. The system patches the CommonJS loader to substitute ESLint's \RuleTester\ with Oxlint's, hooks \describe\ and \it\ to capture test results, and generates markdown reports summarizing passing, failing, and skipped tests for various rule groups (including ESLint built-ins and external plugins like \eslint-plugin-react-hooks\).

apps/oxlint/conformance/src · high confidence

A new Markdown formatter is now available in the \oxc\_formatter\_markdown\ crate, providing Prettier-compatible formatting for \.md\ files. It parses Markdown using \oxc-markdown-parser\ (targeting micromark/Prettier semantics) and prints output that aligns with Prettier's behavior, including specific handling for front matter (kept verbatim), CJK line-breaking, emphasis marker normalization, and various edge cases documented in \DIVERGENCES.md\. The formatter supports standard options like \proseWrap\ and \singleQuote\, and includes a CLI example for ad-hoc compatibility checks against Prettier.

_crates/oxc\_formatter\markdown · high confidence

The \apps/oxfmt/src/api\ module now exposes a new direct-document formatting API (\format\_api.rs\) and a text-to-document conversion API (\text\_to\_doc\_api.rs\) for Node.js via NAPI. The formatting API allows callers to format source code strings directly without file discovery or config file resolution, supporting embedded contexts like Vue and Svelte scripts through callback-based external services. The text-to-doc API enables converting formatted source into Prettier-compatible document JSON, handling specific fragment kinds such as Vue \v-for\ bindings, slot bindings, and generic script types. This change introduces the underlying Rust infrastructure for these NAPI bindings, including session management, external service dispatch, and error handling for unsupported file types and missing plugins.

apps/oxfmt/src/api · high confidence

The \oxc\_macros\ crate now provides the \declare\_oxc\_lint!\ procedural macro, which allows developers to declare lint rules with structured metadata including name, plugin, category, and auto-fix capabilities. The macro supports optional configuration via a \config\ path, integration markers like \(tsgolint)\, and conditional fix types (e.g., \fix\, \suggestion\, \dangerous\_fix\). It also enables automatic documentation generation for the website by parsing doc comments and supporting shared documentation constants, ensuring rule descriptions stay in sync with implementation.

_crates/oxc\macros · high confidence

The \tasks/lint\_rules\ directory has been refactored into a modern ESM-based Node.js application (replacing the previous CommonJS structure) to automate the tracking of lint rule implementation status. This new task loads rules from external ESLint plugins (such as \eslint-plugin-react\, \@typescript-eslint/eslint-plugin\, and \eslint-plugin-vue\), cross-references them against the implemented rules in \crates/oxc\_linter\, and applies a comprehensive list of unsupported rules from \unsupported-rules.json\. It generates detailed Markdown reports—categorized by recommended, not recommended, and deprecated status—and can automatically update the corresponding GitHub tracking issues via the \result-reporter.mjs\ module, providing a live dashboard of implementation progress.

_tasks/lint\rules · high confidence

A new \tasks/track\_memory\_allocations\ tool has been added to the OXC repository, allowing users to measure and report memory usage across various stages of the JavaScript/TypeScript processing pipeline (parsing, semantic analysis, transformation, minification, and formatting). The tool tracks heap allocation metrics including the number of allocations, deallocations, reallocations, total bytes allocated, live memory size, and peak memory growth. It specifically excludes arena chunk operations from these metrics to provide more accurate per-operation memory profiles, and uses a custom tracked allocator wrapper around \mimalloc\ to ensure consistent tracking across platforms. The output is presented in a vertical per-file block format for easy comparison.

_tasks/track\_memory\allocations · high confidence

The \oxc\_ecmascript\ crate has been introduced to centralize ECMAScript specification operations, including constant evaluation, side-effect analysis, and type coercion. This new library provides the core logic for evaluating expressions to constant values (such as string methods, math functions, and URL encoding), determining if code has side effects, and handling value conversions (ToNumber, ToString, etc.). It serves as the foundational engine for the minifier's optimization passes, enabling more aggressive dead-code elimination and expression folding by accurately modeling JavaScript runtime behavior.

_crates/oxc\ecmascript · high confidence

The \oxc\_formatter\_tests\ crate has been extracted to provide shared test infrastructure for all formatter crates (JS, TS, CSS, JSON, YAML, etc.). It introduces a build-script codegen that automatically generates \\#\[test\]\ functions for fixture files, a language-agnostic fixture harness that drives format passes, validates idempotency, and asserts input/output fingerprint equality, and a Prettier conformance suite that automatically provisions the Prettier test suite and compares formatter output against Prettier's snapshots. This centralizes test maintenance, ensures consistent snapshotting across languages, and enforces lossless formatting contracts without requiring each formatter crate to reimplement test logic.

_crates/oxc\_formatter\tests · high confidence

The \oxc\_jsdoc\ crate has been extracted from \oxc\_semantic\ to provide dedicated JSDoc comment parsing for the oxc toolchain. It introduces lazy parsing via \OnceCell\ for structured extraction of tags, types, and descriptions, and includes a \JSDocBuilder\ that attaches comments to specific AST nodes (such as functions, classes, and variables) during semantic analysis. The parser correctly handles complex syntax including interval notation in descriptions, backtick-quoted code blocks, and indented code blocks, while optimizing performance by skipping attachment checks when no JSDoc comments remain.

_crates/oxc\jsdoc · high confidence

A new \tasks/common\ crate has been introduced to centralize utilities used across the project's benchmarking, formatting, and testing tasks. It provides a colored terminal diff printer (\print\_diff\_in\_terminal\) with context lines and invisible character rendering to improve the readability of test mismatches. The library also includes a \Snapshot\ helper that pins benchmark fixtures to specific Git commit SHAs to ensure reproducible results and detect outdated submodules. Additionally, it offers a robust HTTP client (\agent\) that automatically detects proxy settings from environment variables and respects \SSL\_CERT\_FILE\ for custom TLS certificates, with platform-specific TLS provider selection (NativeTls on macOS, Rustls elsewhere). Finally, it defines structured \TestFiles\ collections (minifier, formatter, minimal, complicated) that fetch and cache real-world JavaScript/TypeScript/JSX/TSX sources from CDN URLs for use in benchmarks and tests.

tasks/common · high confidence

A new test runner has been added to the \tasks/transform\_conformance\ crate to validate the JavaScript/TypeScript/React transformer against the Babel test suite. The runner walks the Babel repository fixtures, executes transformations using the \Driver\ (which integrates the \CompilerInterface\ for parsing, transforming, and code generation), and compares the output against Babel's expected results. It supports filtering tests, running executable tests via Vitest, and overriding snapshots for debugging. The suite includes a comprehensive list of supported Babel plugins (such as \babel-preset-env\, \babel-preset-typescript\, and \babel-preset-react\) and explicitly skips tests for unsupported features or known mismatches.

_tasks/transform\conformance · high confidence

The \apps/oxlint/src-js/utils\ directory now includes four new utility files: \asserts.ts\ provides debug-only assertion functions (\debugAssertIsNonNull\, \debugAssertIsNotUndefined\, \debugAssertIsFunction\, \debugAssert\) that throw errors in debug builds but are removed in release builds, alongside a compile-time-only \typeAssertIs\; \typed\_arrays.ts\ exports pre-allocated empty \Uint8Array\ and \Int32Array\ instances to avoid redundant object creation; \types.ts\ adds a \SetNullable\ utility type for making specific properties nullable; and \utils.ts\ introduces a robust \getErrorMessage\ function that safely extracts error details from various input types without throwing.

apps/oxlint/src-js/utils · high confidence

Added a new \tasks/website\_common\ crate that provides shared utilities for generating website documentation. This includes \generate\_schema\_json\ for creating JSON schemas with VS Code-friendly extensions (like \markdownDescription\ and comment support), \generate\_cli\_docs\ for formatting CLI help text for the website, and a \Renderer\ for converting JSON schemas into structured Markdown documentation.

_tasks/website\common · high confidence

This change introduces the \oxc\_react\_compiler\ crate, which integrates the Rust port of the React Compiler into the Oxc ecosystem. It provides the conversion layer between the oxc AST and the compiler's internal AST, enabling the compiler to analyze and memoize React components and hooks. The release includes the core compiler logic, a comprehensive suite of test fixtures covering aliasing, scope alignment, and ref handling, and an example demonstrating the compilation pipeline. This marks the initial availability of the React Compiler integration in Oxc.

_crates/oxc\_react\compiler · high confidence

The \npm/oxc-types\, \npm/oxfmt\, and \npm/oxlint\ packages now ship with \CHANGELOG.md\ and \README.md\ files, providing users with a clear history of changes and usage instructions. Additionally, \oxfmt\ now includes a \configuration\_schema.json\ file, enabling better IDE support and validation for \.oxfmtrc.json\ configuration files. The \oxc-types\ package also provides auto-generated TypeScript definitions for Oxc AST nodes, with recent updates including support for CommonJS source types and various AST compatibility fixes.

npm · high confidence

The \rulegen\ task has been completely rewritten to generate linter rules for a broader set of plugins (including Jest, TypeScript, Unicorn, Import, React, JSX-A11y, Next.js, JSDoc, Node, Promise, Vitest, and Vue) and to handle modern ESLint test structures. The new tool parses test files to extract pass/fail/fix cases, automatically generates Rust rule implementations with proper configuration structs, and outputs the code to the correct plugin directories. It also includes utilities for converting JavaScript object literals to JSON, dedenting code snippets, and formatting the generated Rust files.

tasks/rulegen · high confidence

The \apps/shared\ area now provides reusable JavaScript/TypeScript configuration loading utilities. It introduces \importJsConfig\ to dynamically import JS/TS config files with cache-busting and improved error messages for unsupported Node.js versions, and \loadViteConfigField\ to extract specific fields (like \lint\ or \fmt\) from Vite+ configs. These utilities are exported from \apps/shared/src-js/index.ts\ and include supporting logic for Node version checks and object validation, along with corresponding tests.

apps/shared · high confidence

oxfmt now supports loading configuration from standard JavaScript and TypeScript files (e.g., \oxfmt.config.js\), as well as extracting formatting settings from the \.fmt\ field in Vite configuration files (\vite.config.ts\). Additionally, the external formatting worker pool is now initialized lazily on first use rather than at startup, which improves performance for runs that do not require external formatting services by avoiding unnecessary child process spawning.

apps/oxfmt/src-js/cli · high confidence

The \oxfmt\ tool now formats YAML files, providing Prettier-compatible output for \.yaml\ and \.yml\ files. This includes support for standard formatting options like line width and prose wrapping, as well as specific YAML features such as block scalars, anchors, and tags. The formatter is also integrated into the dispatcher, allowing YAML content within CSS frontmatter to be formatted.

_crates/oxc\_formatter\yaml · high confidence

This release adds \likely\ and \unlikely\ functions to help the compiler optimize branch prediction, introduces the \assert\_unchecked!\ macro for safe unchecked assertions in const contexts, and provides \boxed\_slice!\ and \boxed\_array!\ macros for creating boxed collections. It also includes the \fieldless\_enum!\ macro for generating enums with a \VARIANTS\ constant, and the \implements!\ macro for checking trait implementations at compile time.

_crates/oxc\_data\structures · high confidence

This release introduces support for \vite-plus/resolveConfig\ in \vite.config.ts\ files, allowing the formatter to correctly discover configuration in Vite+ environments. It also includes significant updates to embedded language formatting, such as formatting \parser:graphql\ files via \oxc\_formatter\_graphql\, formatting \parser:yaml\ files via \oxc\_formatter\_yaml\, and formatting \parser:css,less,scss\ files plus \css-in-js\ via \oxc\_formatter\_css\. The release notes highlight breaking changes where these languages are now handled by native Rust formatters instead of falling back to Prettier, improving performance and consistency. Additionally, the release includes bug fixes for JSDoc fence handling, literal line support in Vue scripts, and improved Tailwind CSS class sorting.

apps/oxfmt · high confidence

oxfmt v0.70.0 introduces a new Node.js API and CLI entry point in \apps/oxfmt/src-js\. The \index.ts\ file exposes a \format()\ function and a \jsTextToDoc()\ function for Prettier plugins, with native bindings loaded lazily to avoid hangs. The \cli.ts\ file provides a JS-based CLI entry point that handles argument parsing, config loading, and migration modes (\init\, \migrate:prettier\, \migrate:biome\), while also setting blocking I/O for non-TTY environments and redirecting stdout to stderr in LSP mode. The \bindings.d.ts\ and \bindings.js\ files define the NAPI-RS interface for these functions, including callbacks for formatting files, embedded code, and sorting Tailwind classes. The \config.generated.ts\ file provides TypeScript types for the configuration schema, and \cli-worker.ts\ re-exports core formatting functions for use in worker threads.

apps/oxfmt/src-js · high confidence

The \apps/oxlint\ directory is initialized with the core configuration files required to build and test the application. This includes a \tsdown.config.ts\ that defines the build pipeline for the main CLI, the \@oxlint/plugins\ package, and the \oxlint-plugin-eslint\ package, along with a \vitest.config.ts\ for test execution. Supporting files such as \tsconfig.json\, \build.rs\ (for NAPI bindings), \.gitignore\, and \.npmignore\ are also added to establish the project structure.

apps/oxlint · high confidence

The \apps/oxlint/src\ directory has been reorganized into a modular Rust application structure, introducing dedicated modules for configuration loading (\config\_loader.rs\), JavaScript/TypeScript config integration (\js\_config.rs\), and command modes like initialization (\init.rs\) and rule listing (\rules.rs\). A new \agent\_detection.rs\ module automatically detects AI coding agents (such as Claude, Cursor, and Copilot) via environment variables to enable agent-aware linting behavior. The application now exposes NAPI bindings (\run.rs\) for use within Node.js environments, allowing the Rust linter to be invoked programmatically from JavaScript/TypeScript tooling.

apps/oxlint/src · high confidence

The AST node definitions previously located in the root \ast.rs\ file have been reorganized into dedicated modules: \comment.rs\ for comment types, \js.rs\ for core JavaScript syntax, \jsx.rs\ for JSX elements, and \literal.rs\ for primitive literals. This structural change improves code maintainability by grouping related node definitions without altering the public API or runtime behavior.

_crates/oxc\ast/src/ast · high confidence

The \oxc\_allocator\ arena implementation has been reorganized from a single monolithic module into distinct, focused source files (such as \alloc.rs\, \alloc\_impl.rs\, \chunks.rs\, \create.rs\, and \drop.rs\). This structural change improves code maintainability and readability by separating public allocation methods, internal layout logic, chunk management, arena construction, and memory deallocation into their own modules, without altering the external API or allocation behavior.

_crates/oxc\allocator/src/arena · high confidence

Implementation methods for AST nodes (such as \Expression\, \JSXElementName\, \NumericLiteral\, and \TSType\) are now organized into specific files (\js.rs\, \jsx.rs\, \literal.rs\, \ts.rs\) within the \ast\_impl\ crate. This change groups related logic by domain, making it easier to locate and maintain helper methods like \is\_typescript\_syntax\, \get\_identifier\, and \parse\_pattern\ without cluttering the main AST definition files.

_crates/oxc\_ast/src/ast\impl · high confidence

The \oxc\_formatter\_core\ crate has been split from the main formatter to serve as a shared, language-agnostic engine for the IR and printing pipeline. This change introduces a generic \FormatContext\ trait and \FormatOptions\ trait, allowing language-specific formatters (JS, CSS, JSON, etc.) to inject their own options and source text while keeping the core engine free of language-specific rules. It also adds a \FormatSession\ for managing embedded language dispatch (e.g., CSS-in-JS) and defines a strict \FORMATTER\_POLICY\ that governs Prettier compatibility, comment placement invariants, and known divergences. The core now owns the IR construction, the printer, and shared utilities like front-matter handling, while language-specific logic is pushed to consumer crates.

_crates/oxc\_formatter\core · high confidence

The \apps/oxfmt/src/core\ directory has been restructured into distinct modules (\config\, \format\, \options\, \oxfmtrc\, \support\, \utils\, and \external\_services\) to separate file classification, configuration resolution, and formatting strategy execution. This change introduces a \FormatStrategy\ enum that explicitly routes files to their specific formatters (e.g., \OxcFormatter\ for JS/TS, \OxcFormatterJson\ for JSON, \OxcFormatterCss\ for CSS, etc.) and centralizes the \Oxfmtrc\ configuration schema. It also adds \ExternalServices\ to manage JavaScript-side callbacks for embedded formatting and Tailwind sorting, while \support.rs\ handles file kind classification and \utils.rs\ provides path normalization and tracing initialization.

apps/oxfmt/src/core · high confidence

The AST builder API has been refactored so that node creation methods are now defined directly on the AST types (e.g., \Expression::new\_number\_0\) rather than on a central \AstBuilder\ struct. This change introduces the \AstBuild\ and \GetAstBuilder\ traits, allowing builder methods to accept any type implementing \GetAstBuilder\ (such as parser contexts) instead of requiring a direct reference to \AstBuilder\. The old \AstBuilder\ methods have been removed, and the \AstBuilder\ struct itself is no longer re-exported from the crate root, requiring imports from the new \builder\ module. Convenience methods for common patterns (like \new\_use\_strict\ or \new\_plain\) are provided in \custom.rs\ to simplify AST construction.

_crates/oxc\ast/src/builder · high confidence

The \\#\[ast\]\ macro in \oxc\_ast\_macros\ has been restructured to rely on pre-generated metadata (from \oxc\_ast\_tools\) rather than calculating layout details at compile time. This change enables the macro to automatically apply \\#\[repr(C, u8)\]\ or \\#\[repr(u8)\]\ to enums based on whether they are fieldless, insert inherited variants from other enums via \INHERIT\ markers, and reorder struct fields to minimize memory padding. It also adds \\#\[non\_exhaustive\]\ to AST node structs to enforce construction via \AstBuilder\ and generates static assertions for traits specified via \\#\[generate\_derive\]\.

_crates/oxc\_ast\macros/src · high confidence

The build and code-generation scripts in \apps/oxlint/scripts\ have been rewritten in TypeScript. This includes a new \build.ts\ entry point that orchestrates the build process using \tsdown\, and introduces \generate-plugin-eslint.ts\ to automatically create the \@oxlint/plugins\ and \oxlint-plugin-eslint\ packages by wrapping ESLint core rules. The \generate-config-types.ts\ script now uses \json-schema-to-typescript\ to produce TypeScript definitions from the configuration schema. These changes streamline the release workflow and ensure type safety for generated plugin code.

apps/oxlint/scripts · high confidence

The \oxc\config\ crate now provides shared utilities for configuration discovery and file walking. Config discovery supports \.oxlintrc\/\.oxfmtrc\ (JSON/JSONC) and TypeScript config files (\oxlint.config.ts\, \oxfmt.config.ts\, and their \.mts\ variants), with a dedicated Vite+ mode that discovers \vite.config.\\ files and suppresses nested config discovery. Glob patterns in configuration are validated at deserialization time, rejecting invalid syntax (such as unclosed braces or character classes) and normalizing \./\ prefixes. The \ignorePatterns\ field now rejects patterns containing \..\ segments, as they cannot match files outside the config directory. File walking respects repository-local \.gitignore\ files and stops at VCS boundaries, ensuring that explicitly named file targets are processed even if they match \.gitignore\ rules, while directory targets within ignored paths are excluded.

_crates/oxc\config · high confidence

The \oxfmt\ configuration pipeline has been restructured to centralize validation and decouple option resolution from downstream consumers. A new validation gate (\validate\) now runs once during config resolution to produce \ValidatedOptions\ (including \CoreFormatOptions\ and \SortImportsOptions\), ensuring that all subsequent formatter-specific mappers (for JS/TS, JSON, CSS, GraphQL, YAML, TOML, and Prettier-compatible outputs) remain infallible. This change introduces a single source of truth for core layout options (indentation, line width, line ending) and enforces strict validation for \tabWidth\ and \printWidth\ ranges, while also separating \sortImports\ validation from its type enum to improve clarity and maintainability.

apps/oxfmt/src/core/options · high confidence

The fixed-size arena allocator now uses platform-specific implementations to handle high-alignment memory requests safely. On Linux (including MUSL) and macOS, it over-allocates with lower alignment to work around system allocator limitations and avoid segmentation faults during deallocation. On Windows, it switches to direct \VirtualAlloc\ calls to reserve and commit memory, bypassing the standard library's workaround for high-alignment requests. This ensures stable memory management for raw transfer operations across all supported platforms.

_crates/oxc\_allocator/src/arena/fixed\size · high confidence

The allocator now includes auto-generated source files that enforce memory layout invariants and define size constants for the fixed-size allocator and raw transfer mechanism. \assert\_layouts.rs\ adds compile-time checks for the \FixedSizeAllocatorMetadata\ structure on 32-bit and 64-bit platforms, ensuring fields like \id\ and \is\_double\_owned\ are at the expected offsets. \fixed\_size\_constants.rs\ defines precise byte sizes and alignments for the allocator block, transfer buffer, and metadata structures, which are required for correct memory management and raw data transfer between Rust and JavaScript.

_crates/oxc\allocator/src/generated · high confidence

The GraphQL formatter now supports draft syntax features, including executable descriptions and directive extensions (always-on) and fragment arguments (behind the experimental\_fragment\_arguments flag). This is achieved by using a forked parser, oxc-graphql-parser, which aligns with graphql-js v17.x, and removing the previous Prettier fallback.

_crates/oxc\_formatter\graphql · high confidence

The graphical diagnostic handler in \crates/oxc\_diagnostics\ has been refactored to improve rendering performance and code clarity. The implementation now uses fixed ANSI styles and optimizes number and grapheme rendering to reduce allocations. The gutter logic, line splitting, and label drawing have been restructured into dedicated modules (\gutter\, \line\, \label\, \snippet\, \report\, \span\) to better manage multi-line spans, visual offsets, and terminal width wrapping.

_crates/oxc\diagnostics/src/handlers/graphical · high confidence

The oxfmt JavaScript library now supports formatting embedded code in JavaScript files for Markdown, Angular, HTML, GraphQL, and Svelte, along with better Tailwind CSS integration. To prevent V8 crashes during Rust interop, error handling was refactored so that formatting failures are returned as data rather than rejecting promises, ensuring stable operation when formatting non-JavaScript snippets within JS files.

apps/oxfmt/src-js/libs · high confidence

Added a new \prettier\_compat\ module that enables seamless integration between the Rust-based \oxc\_formatter\ and the JavaScript Prettier engine. This change introduces \from\_prettier\_doc.rs\ to convert Prettier's Doc JSON representation into the internal \FormatElement\ IR, and \to\_prettier\_doc.rs\ to convert the formatted IR back into Prettier Doc JSON. This bidirectional conversion is essential for handling embedded languages (such as CSS-in-JS, HTML-in-JS, and Vue/JSX contexts) where the Rust formatter processes the content but Prettier must handle the final line-wrapping and layout in the parent document context. The implementation includes logic to preserve shared sub-trees via reference IDs and handles specific printer state optimizations like space deduplication and line-break collapsing to ensure output parity.

_apps/oxfmt/src/prettier\compat · high confidence

The oxlint LSP now exposes two distinct code action kinds for applying fixes: \source.fixAll.oxc\ for safe fixes only, and \source.fixAllDangerous.oxc\ for both safe and dangerous fixes. The server respects the new \rulesCustomization\ LSP option, allowing users to override rule severity and explicitly disable autofixes for specific rules, which will filter out those rules from the fix-all actions. Additionally, the LSP now includes diagnostic notes in its messages and provides a dedicated command \oxc.fixAll\ to trigger the safe fix-all operation.

apps/oxlint/src/lsp · high confidence

The language server now uses the \tower-lsp-server\ crate instead of the previous \tower-lsp\ implementation, and relies on \futures-util\ rather than the \futures\ crate. This change updates the underlying LSP transport and async primitives used by the server, which may affect how the server initializes and handles LSP requests and notifications.

_crates/oxc\_language\server · high confidence

The linter codegen tool in \tasks/linter\_codegen\ has been refactored to automatically detect the AST node types required by lint rules by analyzing their \run\ method bodies. It now supports extracting node types from \match node.kind()\, \if let AstKind::... = node.kind()\, \let AstKind::... = node.kind() else { return }\, and early-diverging match blocks. This allows the generated \RuleRunner\ implementations to specify precise \NODE\_TYPES\ bitsets, enabling the linter to skip rules that do not apply to the current node type and improving performance.

_tasks/linter\codegen · high confidence

The build process now includes three new TSDown plugins in the \tsdown\_plugins\ directory to optimize the final output. The \replace\_globals\ plugin replaces global property accesses (like \Object.keys\) with top-level variable declarations, improving performance and minification while making the code resilient to global reassignment. The \inline\_search\ plugin inlines the \firstTokenAtOrAfter\ binary search function directly into its call sites to eliminate function call overhead. The \replace\_asserts\ plugin removes debug and type assertion imports and their call sites entirely, ensuring the minifier can fully eliminate dead code and side-effect expressions that it might otherwise leave behind.

_apps/oxlint/tsdown\plugins · high confidence

The parser in \crates/oxc\_parser\ has been updated to detect and report syntax errors when a definite assignment assertion (e.g., \!\) is used on a property that also has an initializer. This change improves diagnostic accuracy by flagging the conflicting usage of \!\ and \=\ in class fields, ensuring users receive immediate feedback on invalid TypeScript syntax.

_crates/oxc\parser · high confidence

The AST serialization logic has been reorganized from a single monolithic file into distinct modules (\basic\, \js\, \jsx\, \literal\, \ts\) to improve maintainability and reduce binary bloat. This change introduces specialized serializers for specific node types, such as handling \ImportMeta\ and \NewTarget\ meta-properties in \js.rs\, converting JSX identifiers in \jsx.rs\, and managing literal values (including lone surrogates and BigInt/RegExp fixes) in \literal.rs\. It also adds support for TypeScript-specific fields like \TSTypeAnnotation \| null\ in \basic.rs\ and complex module/namespace declarations in \ts.rs\, ensuring the serialized ESTree output matches the expected structure for both JS and TS consumers.

_crates/oxc\ast/src/serialize · high confidence

The UTF-8 to UTF-16 offset conversion logic has been restructured into a dedicated module (\utf8\_to\_utf16\) with separate files for the converter, translation table building, and AST visitors. This change introduces a high-performance \Utf8ToUtf16Converter\ that uses a translation table and SIMD-optimized chunk processing to handle non-ASCII characters efficiently, while maintaining ascending-order conversion for fast paths. New public methods on \Utf8ToUtf16\ allow converting spans in programs, comments, and module records, as well as converting offsets back from UTF-16 to UTF-8. The visitor logic has been refined to handle specific AST nodes like export declarations with decorators and formal parameters with rest elements, ensuring correct span conversion in complex scenarios.

_crates/oxc\_ast\_visit/src/utf8\_to\utf16 · high confidence

The allocator pooling logic has been restructured to separate standard and fixed-size allocator pools into distinct implementations. The \FixedSizeAllocatorPool\ now handles its own platform-specific memory management: on Linux/macOS it pre-allocates a fixed number of 4 GiB allocators, while on Windows it dynamically creates as many as possible up to the thread count without exhausting system memory, blocking threads if the pool is exhausted. The \AllocatorPool\ wrapper now exposes a \new\_fixed\_size\ constructor for raw transfer scenarios, and the \AllocatorGuard\ ensures allocators are reset and returned to the correct pool type upon drop. This change improves memory safety on Windows and reduces mutex contention by using a \Stack\ for allocator storage.

_crates/oxc\allocator/src/pool · high confidence

The configuration resolution logic in \oxfmt\ has been restructured into distinct, reusable modules (\editorconfig\, \js\_config\, \nested\, \overrides\) to improve performance and maintainability. EditorConfig parsing is now cached and applied only when file-specific properties differ from the root, reducing redundant work. JavaScript/TypeScript config loading is decoupled into a thread-safe callback system that handles both Tokio and non-Tokio contexts. A new \NestedConfigCtx\ centralizes on-demand nested config discovery with walk-wide caching, ensuring each directory is probed at most once. Additionally, override matching is optimized to collect only relevant options per file path.

apps/oxfmt/src/core/config · high confidence

The generated JavaScript files in \apps/oxlint/src-js/generated\ have been updated to reflect recent AST and parser changes. This includes new AST node types such as \ImportMeta\, \NewTarget\, \ArrowFunctionBody\, and \ExportDeclaration\, alongside structural updates like splitting \MetaProperty\ and moving scope to \TSEnumBody\. The raw transfer deserialization logic has been optimized for performance, utilizing \Int32Array\ buffers, lazy deserialization for comments and tokens, and efficient UTF-8 string decoding. Additionally, the generated code now includes environment definitions (\envs.ts\) and updated visitor keys and type IDs to support the new AST structure and selector classes.

apps/oxlint/src-js/generated · high confidence

The benchmarking task now uses a custom global allocator (\NeverGrowInPlaceAllocator\) that wraps the system allocator but disables in-place memory growth. This change eliminates non-deterministic variance in benchmark results caused by the operating system's unpredictable memory management behavior, ensuring more consistent and reliable performance measurements.

tasks/benchmark · high confidence

The \rulegen\ task template now validates its configuration and will error if an invalid config is provided, helping developers catch configuration mistakes early when generating new lint rules.

tasks · high confidence

Embedded code blocks (such as CSS, YAML, JSON, GraphQL, and JSDoc fences) are now formatted using native Rust formatters instead of relying exclusively on Prettier. A new routing table directs supported languages to optimized Rust branches, while Prettier is retained only for languages without native ports (HTML, Angular, Markdown) via a Doc-to-IR fallback. This change ensures consistent formatting behavior across all builds, improves performance by avoiding unnecessary Prettier invocations, and centralizes configuration resolution for embedded content.

apps/oxfmt/src/core/embed · high confidence

The generated AST macro files have been updated to reflect recent changes in the AST schema. The \derived\_traits.rs\ file now maps the \GetNodeId\ trait to \oxc\_syntax::GetNodeId\ and includes the \ReplaceWith\ and \UnstableAddress\ traits from \oxc\_allocator\, while \enums.rs\ and \structs.rs\ contain refreshed metadata for enum inheritance hierarchies and struct field ordering. These changes ensure the generated code aligns with the new node ID capabilities and allocator traits introduced in the AST layer.

_crates/oxc\_ast\macros/src/generated · medium confidence

The oxfmt CLI has been restructured to support distinct operational modes: standard file formatting, stdin processing, LSP server, configuration initialization, and migration from Prettier or Biome. The command-line interface now exposes explicit output modes (\--write\, \--check\, \--list-different\) and configuration options like \--disable-nested-config\. It also introduces new runtime controls such as \--threads\ for parallelism and \--ignore-path\ for custom ignore files, alongside support for glob patterns and \!\ prefixed exclusions in path arguments.

apps/oxfmt/src/cli · high confidence

The oxlint CLI and LSP JavaScript layer has been converted to a NAPI application, replacing the previous implementation with auto-generated Rust bindings (bindings.js/bindings.d.ts) and a new CLI entry point (cli.ts). This change introduces lazy-loading for JavaScript plugins and workspace management to reduce startup overhead, adds support for loading JavaScript/TypeScript configuration files (including Vite \.lint\ fields), and enforces blocking stdio for non-TTY environments to prevent LSP communication errors.

apps/oxlint/src-js · high confidence

Added a new \.oxlintrc.json\ configuration file to the \apps/api\ fixture that extends the root linter configuration, ensuring consistent linting rules are applied. Included a sample TypeScript file (\firebase.ts\) to support the LSP testing scenario for issue \#22758.

_apps/oxlint/fixtures/lsp/issue\22758/apps/api · high confidence

The linter now correctly resolves \ignorePatterns\ relative to the directory containing the configuration file, ensuring that ignore rules apply as intended in nested or ancestor config scenarios. This change is validated by a new fixture that tests this specific resolution behavior.

_apps/oxlint/fixtures/cli/ignore\_patterns\_ancestor\config/packages/foo · high confidence

The \jsx-a11y/iframe-has-title\ rule has been updated to correctly detect and validate \title\ attributes when they are accessed via member expressions (e.g., \props.title\), preventing false negatives in cases where the title is not provided as a direct literal or simple identifier.

_crates/oxc\linter · high confidence

API integration tests for oxfmt; Add CLI integration tests for oxfmt configuration and editorconfig handling; Add test fixture for validating token and comment API behavior; Added CSS-in-JS conformance fixtures for edge cases; Added GraphQL-in-JS edge-case conformance fixtures; Added LSP initialization tests; Added LSP linting tests for configuration and nested configs; Added LSP multi-workspace linting tests; Added LSP test utilities for JavaScript-side testing; Added comprehensive test suite for the Arena allocator; Added conformance fixtures for JavaScript-in-Vue edge cases; Added conformance fixtures for edge-case template comment handling; Added test coverage for .mts config file support; Added test coverage for JS plugin and Vue rule interaction in multi-script Vue files; Added test coverage for JS plugins in config overrides; Added test coverage for Vue partial source handling with custom JS plugins; Added test coverage for boolean fixable values in custom plugins; Added test coverage for circular JS config extends references; Added test coverage for custom plugin message interpolation; Added test coverage for legacy plugin report signature; Added test coverage for the denyWarnings configuration option; Added test coverage for the maxWarnings configuration option; Added test coverage for unambiguous await token handling; Added test coverage for unused disable directives with JS plugins in Vue; Added test fixture for CLI config file argument; Added test fixture for ESTree-compatible AST validation; Added test fixture for JS config dynamic type checking; Added test fixture for JS plugin configuration loading; Added test fixture for JS plugin context properties; Added test fixture for JS plugin hook error handling; Added test fixture for JS plugin suppression; Added test fixture for JavaScript plugin globals and env access; Added test fixture for SourceCode\#getNodeByRangeIndex plugin API; Added test fixture for UTF-16 offset handling in custom plugins; Added test fixture for Vite config file priority; Added test fixture for Vite+ nested config ignoring; Added test fixture for built-in linting errors; Added test fixture for custom JS plugins with no errors; Added test fixture for custom plugin context wrapping; Added test fixture for custom plugin integration; Added test fixture for custom plugin parser services access; Added test fixture for custom plugin rules; Added test fixture for custom plugin rules in lint overrides; Added test fixture for late AST access in custom plugins; Added test fixture for long GitHub annotation messages; Added test fixture for nested config with custom JS plugin; Added test fixture for override rule counting; Added test fixture for scope manager API methods; Added test fixture for spread rule options in JS config; Added test fixture for the new \parents\ lint rule; Added test fixture for type-aware linting configuration; Added test fixture for unicode comment handling in custom plugins; Added test fixture for validating missing plugin error reporting; Added test fixtures for BOM handling in custom plugins; Added test fixtures for Code Path Analysis (CFG) plugin events; Added test fixtures for ESLint compatibility plugin hooks; Added test fixtures for JS plugin diagnostic location handling; Added test fixtures for JS plugin error handling; Added test fixtures for JavaScript plugin settings access; Added test fixtures for LSP code actions and plugin suggestions; Added test fixtures for Vite Plus configuration handling; Added test fixtures for Vite config integration and priority handling; Added test fixtures for Vite config validation edge cases; Added test fixtures for comment-related plugin APIs; Added test fixtures for custom plugin configuration errors; Added test fixtures for custom plugin file formats; Added test fixtures for custom plugin fix edge cases; Added test fixtures for custom plugin name resolution; Added test fixtures for custom plugin rule enforcement; Added test fixtures for custom plugin rule interactions; Added test fixtures for custom plugin rule options and validation; Added test fixtures for custom plugin selector matching; Added test fixtures for languageOptions plugin context; Added test fixtures for linter plugin suggestions; Added test fixtures for oxlint bulk suppression behavior; Added test fixtures for oxlint.config.ts extends support; Added test fixtures for the \defineConfig\ helper; Added test fixtures for the \isSpaceBetween\ plugin API; Added test fixtures for the defineRule API; Added test fixtures for the eslint-js plugin; Added test for JS plugin error handling during AST visitation; Added test for JS plugin visitor compilation error handling; Added test for conflicting JS configuration files; Added test for duplicate JS plugin name rejection; Added test for error reporting on unknown builtin rules; Added test for invalid CLI configuration argument; Added test for invalid JS plugin name alias error; Added test for invalid oxlint configuration property; Added test for loading linter plugins from outside the current working directory; Added test for missing plugin name error; Added test for nested config file conflict detection; Added test for oxlint.config.ts error handling; Added test for print-config with extended base configuration; Added test snapshots for embedded language formatting; Added tests for Arena allocation failure handling; Added tests for ESLint compat \after\ hook error handling; Added tests for JS config overrides in oxlint; Added tests for JS plugin messageId validation; Added tests for LSP config change handling; Added tests for LSP single-file linting mode; Added tests for banning relative JS plugin specifiers in extended configs; Added tests for custom plugin message ID interpolation; Added tests for linter plugin token and comment lazy deserialization; Added tests for reserved plugin name validation; Added tests for the SourceCode.getDisableDirectives plugin API; Added tests for the \sourceCode.markVariableAsUsed\ API; Added tests for token-related SourceCode plugin APIs; Automated conformance fixture downloads and structured test runner; Expanded CLI fixture coverage for configuration and ignore behavior; Expanded ESLint plugin conformance testing coverage; Expanded LSP test coverage for formatting, configuration, and workspace behaviors; Expanded LSP test fixtures for configuration and framework support; Expanded test coverage for oxlint plugin system and core utilities; Introduce Rust-based codegen conformance reference for source map validation; New conformance test suite for ESLint plugins in Oxlint; Snapshot tests for CLI linter behavior and configuration; Snapshot tests for LSP code actions; Updated LSP test snapshots for diagnostics and code actions; Updated conformance fixtures for HTML-in-JS formatting edge cases.

This update performs routine maintenance on the project's dependency manifests, updating Rust crates and npm packages to their latest compatible versions. The changes include lock file maintenance for both ecosystems, ensuring that the build environment remains consistent and up-to-date without introducing new features or behavioral changes.

(dependencies) · high confidence

The \oxc\_transformer\ crate has been released as version 0.38.0. This update includes various internal refactors and fixes to the transformation logic, such as hoisting lowered async declarations, preserving orphaned file coverage comments, and shortening code in arrow function transforms. Users should expect standard version compatibility updates when upgrading to this release.

_crates/oxc\transformer · high confidence

Added coding agent guide for oxc\_semantic; Formatter documentation and changelog added; Minifier changelog for v0.151.0.

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

• CAI 37 → 58 (+20.5)
• Rubric changed (rubric-2026.08.15 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 57 → 60 (+3.2)
• Architecture 76 (new)
• Maturity 69 → 67 (-2.2)
• Readiness 20 → 49 (+28.9)
• Security 48 → 75 (+27.1)

• Boundary-crossing change coupling: bindings.js ↔ bindings.js (apps/oxfmt/src-js/bindings.js)
• Change coupling: bindings.d.ts ↔ cli.ts (apps/oxlint/src-js/bindings.d.ts)
• Change coupling: bindings.d.ts ↔ index.ts (apps/oxfmt/src-js/bindings.d.ts)
• Change coupling: bindings.d.ts ↔ worker-proxy.ts (apps/oxfmt/src-js/bindings.d.ts)
• Change coupling: bindings.js ↔ index.js (napi/parser/src-js/bindings.js)
• Change coupling: build.ts ↔ tsdown.config.ts (apps/oxlint/scripts/build.ts)
• Change coupling: download-fixtures.js ↔ run.ts (apps/oxfmt/conformance/download-fixtures.js)
• Change coupling: index.js ↔ bindings.js (napi/minify/index.js)
• Change coupling: index.js ↔ index.js (napi/minify/index.js)
• Change coupling: worker-proxy.ts ↔ index.ts (apps/oxfmt/src-js/cli/worker-proxy.ts)
• Consequences/trade-offs are absent from the visible text — the decision is framed as a one-line command with output logs and an error list but no trade-offs (e.g. loss of Prettier defaults when migrating) or migration failure handling (apps/oxfmt/test/cli/migrate_prettier/13.snap.md)
• Consequences/trade-offs of migrating ignore patterns (loss of custom ignore rules) are not present in the visible text (apps/oxfmt/test/cli/migrate_biome/10.snap.md)
• Consequences/trade-offs of the migrate command (e.g. loss of Prettier overrides not migrated) are not stated (apps/oxfmt/test/cli/migrate_prettier/12.snap.md)
• Context/problem ('overrides cannot be migrated automatically yet') plus consequences/trade-offs are not present and the decision is not stated (apps/oxfmt/test/cli/migrate_biome/11.snap.md)
• Coverage not measured — test suite did not build
• Critical CVE: [GHSA redacted] (pnpm-lock.yaml)
• Dimension evaluation failed
• FileTooLong: minify/index.js (napi/minify/index.js)
• FileTooLong: playground/index.js (napi/playground/index.js)
• FileTooLong: src-js/bindings.js (napi/parser/src-js/bindings.js)
• …and 118 more

• AccessorPairs::check_class_body (cognitive 19) (crates/oxc_linter/src/rules/eslint/accessor_pairs.rs)
• AnchorHasContent::run (cognitive 27) (crates/oxc_linter/src/rules/jsx_a11y/anchor_has_content.rs)
• AnchorIsValid::run (cognitive 36) (crates/oxc_linter/src/rules/jsx_a11y/anchor_is_valid.rs)
• AnchorIsValid::run (cyclomatic 19) (crates/oxc_linter/src/rules/jsx_a11y/anchor_is_valid.rs)
• AnyJsxTagWithChildren::fmt (cognitive 16) (crates/oxc_formatter/src/print/jsx/element.rs)
• AriaRole::run (cognitive 18) (crates/oxc_linter/src/rules/jsx_a11y/aria_role.rs)
• ArrayCallbackReturn::run (cognitive 41) (crates/oxc_linter/src/rules/eslint/array_callback_return/mod.rs)
• ArrayCallbackReturn::run (cyclomatic 26) (crates/oxc_linter/src/rules/eslint/array_callback_return/mod.rs)
• ArrowBodyStyle::run_for_arrow_block (cognitive 16) (crates/oxc_linter/src/rules/eslint/arrow_body_style.rs)
• ArrowChain::fmt (cognitive 40) (crates/oxc_formatter/src/print/arrow_function_expression.rs)
• ArrowChain::fmt (cyclomatic 24) (crates/oxc_formatter/src/print/arrow_function_expression.rs)
• ArrowFunctionConverter::get_scope_id_from_this_affected_block (cognitive 18) (crates/oxc_transformer/src/common/arrow_function_converter.rs)
• AssignmentLike::chain_formatting_layout (cognitive 17) (crates/oxc_formatter/src/utils/assignment_like.rs)
• AssignmentLike::fmt (cognitive 18) (crates/oxc_formatter/src/utils/assignment_like.rs)
• AssignmentLike::fmt (cyclomatic 19) (crates/oxc_formatter/src/utils/assignment_like.rs)
• AssignmentLike::write_left (cognitive 43) (crates/oxc_formatter/src/utils/assignment_like.rs)
• AssignmentLike::write_left (cyclomatic 31) (crates/oxc_formatter/src/utils/assignment_like.rs)
• AssignmentTargetPropertyProperty::r#gen (cognitive 21) (crates/oxc_codegen/src/gen.rs)
• AstNode::fmt (cognitive 17) (crates/oxc_formatter/src/print/call_like_expression/arguments.rs)
• AstNode::needs_parentheses (cognitive 17) (crates/oxc_formatter/src/parentheses/expression.rs)
• …and 3317 more

• 300 commits — 235 feature/other, 65 fixes

• crates/oxc_lexer — 116 commits
• crates/oxc_linter — 34 commits
• (root) — 22 commits
• crates/oxc_ast — 15 commits
• crates/oxc_minifier — 15 commits
• crates/oxc_formatter — 13 commits
• apps/oxlint — 10 commits
• tasks/coverage — 10 commits
• crates/oxc_formatter_markdown — 9 commits
• crates/oxc_react_compiler — 8 commits
• apps/oxfmt — 7 commits
• .github/workflows — 6 commits
• crates/oxc_str — 6 commits
• crates/oxc_language_server — 4 commits
• napi/parser — 4 commits
• napi/minify — 3 commits
• crates/oxc_formatter_core — 2 commits
• tasks/benchmark — 2 commits
• .agents/skills — 1 commit
• .github/renovate.json — 1 commit

• fix: chore(deps): fix cargo deny check failure (#26673)
• fix: fix(ci): run conformance-lexer in update_submodules job (#26791)
• fix: fix(codegen): remove redundant dollar escapes in minified templates (#26924)
• fix: fix(formatter): fix block comment with RHS assignment and typecast-ed arrow body (#26672)
• fix: fix(formatter): keep after-operator comments in place (#26725)
• fix: fix(formatter): keep comments around = on their side and line (#27041)
• fix: fix(formatter): keep comments deferred before an assignment operator (#26997)
• fix: fix(formatter): keep trailing double spaces on JSDoc lines (#26861)
• fix: fix(formatter): keep trailing spaces on normal block comments (#27037)
• fix: fix(formatter): let union place leading comments at as|satisfies (#26674)
• fix: fix(formatter): nestle adjacent block comments (#27036)
• fix: fix(formatter): preserve redundant parens for TSTypeAliasDeclaration with suppress comment (#26671)
• fix: fix(formatter): treat /* comments as JSDoc (#27035)
• fix: fix(formatter/jsdoc): more alignment with original plugin (#27039)
• fix: fix(formatter_markdown): fix more mismatches found in ecosystem-ci repos (#27003)
• fix: fix(formatter_markdown): fix real-world missmatches (#26785)
• fix: fix(formatter_markdown): keep a line break before an inline liquid tag under preserve (#26998)
• fix: fix(formatter_markdown): keep a math span after a kept line break from opening a block (#27001)
• fix: fix(formatter_markdown): keep a shape line after a multi-line inline node or link title (#27000)
• fix: fix(lexer): context walk mistakes on valid code (#27085)
• …and 280 more

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

oxc-project/oxc 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.