parcel-bundler/parcel

This release delivers a major architectural overhaul of Parcel's core, introducing a modular, request-based build pipeline and a new public API for graph and asset management. A significant portion of the bundler's hot path has been rewritten in Rust, including the JavaScript, HTML, and SVG transformers, resolvers, and optimizers, resulting in substantial performance gains. The release also expands language and framework support with new transformers for Vue, Elm, and TypeScript, alongside comprehensive React Server Components (RSC) and Hot Module Replacement (HMR) capabilities. Additionally, the ecosystem is enriched with new reporters for bundle analysis and profiling, and the repository is standardized with modern tooling like Yarn 4 and ESLint configurations.

Introduces the @parcel/create-react-app package, providing a CLI tool that scaffolds a new Parcel project. The utility initializes a git repository, copies a default React template (including CSS, HTML, and JS entry points), and installs dependencies (Parcel, PostCSS, Babel, React) using either Yarn or npm. It also includes improved emoji support detection for better console output across different terminal environments.

packages/utils/create-react-app · high confidence

Introduced two new optimizers: BlobURLOptimizer, which generates Blob URLs for inline content, and DataURLOptimizer, which converts assets into data URLs with proper MIME type detection and base64 encoding for binary files.

packages/optimizers/data-url · high confidence

A new 'Bundle Buddy' reporter has been added to the build system. When a build succeeds, it generates a JSON file named 'bundle-buddy.json' in each target's output directory. This file maps source files to their resolved dependencies, enabling external tools or users to visualize the bundle graph and understand asset relationships within the project.

packages/reporters/bundle-buddy · high confidence

The build system now includes a new CSSNano optimizer that minifies CSS assets. This change introduces the \CSSNanoOptimizer\ which processes CSS bundles by running them through the \cssnano\ library via PostCSS. Users will see their CSS output minified and optimized by default when the \shouldOptimize\ environment flag is set, with support for loading configuration from \.cssnanorc\ or \cssnano.config.\*\ files.

packages/optimizers/cssnano · high confidence

The events utility package now includes a new \Disposable\ class that normalizes and manages the disposal of multiple resources, and a \ValueEmitter\ class that provides a type-safe, single-event emitter with automatic listener cleanup. Both components are exported from the package's main entry point, enabling consumers to manage resource lifecycles and emit typed events more safely.

packages/utils/events/src · high confidence

A new ESBuild-based optimizer has been added to the Parcel build system. This optimizer automatically minifies JavaScript bundles and enables tree-shaking when the environment is set to optimize. It also handles source map generation and reference injection, ensuring that the final output includes proper source map URLs for debugging.

packages/optimizers/esbuild · high confidence

The packages/validators directory now includes new ESLint and TypeScript validators. The ESLint validator integrates with both ESLint versions \<8 and \>=8, reporting errors and warnings with code frames. The TypeScript validator uses the TypeScript Language Service to perform semantic analysis, caching language services per tsconfig to optimize rechecking when files change. These additions enable automatic linting and type-checking during the build process.

packages/validators · high confidence

The ESLint plugin now includes a new rule that forbids importing or requiring modules by their package name when the code is part of that same package. This prevents accidental cross-package imports that work in the monorepo but break in published modules. The rule supports \require\, \require.resolve\, and \import\ declarations, and provides an automatic fix that rewrites the import to a relative path.

packages/dev/eslint-plugin/src · high confidence

The @parcel/elm-transformer package is introduced, enabling Parcel to compile Elm source files (.elm) into optimized JavaScript. The transformer invokes the Elm compiler, resolves dependencies, and handles error reporting via ThrowableDiagnostic. It also supports Hot Module Replacement (HMR) injection and applies minification using Terser while preserving Elm's pure function signatures.

packages/transformers/elm · high confidence

A new GLSL transformer has been added to the Parcel core, enabling the bundling of GLSL shader files. This transformer uses the glslify library to parse GLSL code, resolve its dependencies, and bundle them into a single JavaScript module that exports the compiled shader code.

packages/transformers/glsl · high confidence

A new GraphQL transformer has been added to the packages/transformers/graphql directory. This transformer parses GraphQL documents, resolves and inlines imported files, and outputs the result as a JavaScript module. It supports both development and optimized (minified) output modes, ensuring that changes to imported GraphQL files trigger appropriate cache invalidation.

packages/transformers/graphql · high confidence

A new HTML example has been added to the examples/html package, demonstrating the use of \<script type="module"\> in HTML templates and the import of asynchronous JavaScript modules. The example includes supporting files such as CSS stylesheets, an SVG sprite, and multiple JavaScript modules that import each other dynamically.

packages/examples/html · high confidence

The WebExtension runtime now supports Hot Module Replacement (HMR) for background scripts. When a background script changes, the runtime injects an autoreload script that detects the update and triggers a browser reload, improving the development workflow for web extension authors.

packages/runtimes/webextension · high confidence

Parcel now supports importing JSON files as JavaScript modules. When a JSON file is imported, it is transformed into a JavaScript module that exports the parsed data, using JSON.parse for performance. This allows developers to import .json files directly in their code.

packages/transformers/json · high confidence

A new JSON reporter has been introduced to the build system, enabling structured, machine-readable output for build events such as build start, progress, success, and failure. This allows users or external tools to parse build logs as JSON objects, with support for filtering by log level and capturing metrics like build time and bundle information.

packages/reporters/json · high confidence

A new JSON-LD transformer has been added to the build system, enabling the processing of JSON-LD structured data files. The transformer parses JSON5-formatted JSON-LD, extracts URLs from schema attributes (such as logo, image, and video), and converts the output to standard JSON. This allows the bundler to handle JSON-LD assets by resolving their internal URL dependencies.

packages/transformers/jsonld · high confidence

A new JavaScript-based file watcher using Watchman has been added as a drop-in replacement for the C++ watchman client. This backend implements the standard @parcel/watcher interface (writeSnapshot, getEventsSince, subscribe, unsubscribe) to provide a temporary workaround for bugs and feature gaps in the existing C++ implementation, specifically targeting Node.js environments.

packages/utils/parcel-watcher-watchman-js · high confidence

The PostHTML transformer is now available to process HTML files, supporting configuration via .posthtmlrc, .posthtmlrc.js, .posthtmlrc.cjs, .posthtmlrc.mjs, posthtml.config.js, posthtml.config.cjs, and posthtml.config.mjs files. The transformer loads PostHTML plugins and applies them to the HTML content, with support for both array and object-style plugin configurations. JavaScript config files trigger a warning about reduced caching capabilities.

packages/transformers/posthtml · high confidence

A new PugTransformer is introduced to handle .pug template files, converting them into HTML. The transformer supports configuration via .pugrc or pug.config files (including CJS and ESM variants), forwards Pug options, and registers file dependencies for hot reloading and cache invalidation.

packages/transformers/pug · high confidence

A new resolver, REPLRuntimesResolver, was added to the packages/resolvers/repl-runtimes directory. This resolver maps internal runtime helpers and the @parcel/error-overlay module to their source code, enabling the REPL environment to resolve these dependencies correctly. This change supports the REPL feature by ensuring that error overlays and related helper modules are properly loaded within the REPL runtime context.

packages/resolvers/repl-runtimes · high confidence

The react-static packager now supports React Server Components (RSC) for static site generation. This introduces a new build path that renders pages to static HTML using RSC streams, enabling features like automatic CSS injection into the RSC stream and support for mixing static and dynamic RSCs. The implementation includes a new packager file that handles loading modules, managing component state, and generating static output, effectively adding a new capability for building static sites with React Server Components.

packages/packagers/react-static · high confidence

A new example project at packages/examples/react-refresh demonstrates Hot Module Replacement (HMR) for React. The example includes a React application entry point (index.js) that renders an App component, which in turn renders various child components (ClassDefault, ClassNamed, FunctionDefault, FunctionNamed, and LazyComponent). An ESLint configuration file is also added to extend the browser ESLint config.

packages/examples/react-refresh · high confidence

A new example in the react-static package demonstrates how to build a static site using React Server Components. It includes page components (Index, Other) that render server-side content, a client-side router (client.tsx) that intercepts link clicks and back-button events to fetch and stream new RSC payloads via fetchRSC, and a Counter component that uses the 'use client' directive for interactivity. This provides a concrete reference for mixing static and dynamic RSCs with client-side navigation.

packages/examples/react-static · medium confidence

The react-server-components example now demonstrates a full RSC setup, including server-side rendering of components, client-side hydration, and server actions. The app includes a main page (App) that renders server components, uses dynamic imports for lazy loading, and integrates with a client-side router for navigation. It also features a file browser page (FilePage) that reads files from the filesystem, a counter component, and a button that triggers a server action. The server handles RSC requests and actions, while the client handles hydration and navigation. This example showcases the capabilities of React Server Components in a practical application.

packages/examples/react-server-components · high confidence

The react-static template now includes a complete starter project for building static React applications using React Server Components (RSC). The template provides a client entry point that handles navigation and hydration via the @parcel/rsc client, a static index page, and an MDX page example. It also includes a reusable navigation component and layout for MDX content, along with necessary configuration files like tsconfig.json and a gitignore file.

packages/utils/create-parcel/templates/react-static · medium confidence

The Parcel build system now includes a new SVGO optimizer for processing SVG files. This feature automatically detects the installed version of SVGO (supporting both v2 and v3 configurations) and applies default optimizations, such as disabling ID cleanup to preserve SVG sprites. Users can provide custom SVGO configurations via standard config files (e.g., svgo.config.js, .cjs, .mjs, or .json).

packages/optimizers/svgo · high confidence

A new SimplePackageInstaller implementation has been added to the REPL development tools. This component handles resolving npm package metadata from the official npm registry (registry.npmjs.org) and fetching/parsing package tarballs to install dependencies into a node\_modules directory, enabling package management within the REPL environment.

packages/dev/repl/SimplePackageInstaller · high confidence

The build system now supports compiling .styl files into CSS. This adds a new transformer that processes Stylus stylesheets, resolving imports and dependencies, and supports configuration via .stylusrc, .stylusrc.js, and .stylusrc.cjs files.

packages/transformers/stylus · high confidence

Users can now use .sss (SugarSS) files in their projects, which will be automatically transformed into standard CSS. This adds support for the SugarSS preprocessor syntax, allowing developers to write CSS using a more concise, whitespace-sensitive syntax that is then processed by PostCSS with the sugarss parser.

packages/transformers/sugarss · high confidence

Users can now use TOML files in their projects. The new TOML transformer parses TOML content and converts it into JavaScript modules, allowing TOML files to be imported or required like any other asset type.

packages/transformers/toml · high confidence

The @parcel/cache package now includes TypeScript type definitions (index.d.ts) that export the Cache interface and the FSCache and LMDBCache constructors. This provides static typing for cache usage, resolving previous issues with circular dependencies and missing imports in the public package.

packages/core/cache, packages/core/core · high confidence

Added TypeScript type definitions for the core plugin classes (Transformer, Resolver, Bundler, Namer, Runtime, Validator, Packager, Optimizer, Compressor, and Reporter) in the @parcel/core package. This provides static typing for plugin developers, enabling better IDE support and compile-time checks for plugin implementations.

packages/core/plugin · high confidence

The @parcel/fs package now includes TypeScript type definitions (index.d.ts) that export types such as FileSystem, FileOptions, and ReaddirOptions from @parcel/types-internal, along with constructors for NodeFS, MemoryFS, and OverlayFS. This change provides static typing support for developers using the file system abstraction in TypeScript projects.

packages/core/fs · high confidence

The core workers package now includes TypeScript type definitions (index.d.ts) for the WorkerFarm class and its configuration options, providing better type safety and autocompletion for developers using the worker farm.

packages/core/workers · high confidence

A new \index.d.ts\ file has been added to \packages/core/package-manager\, providing TypeScript type definitions for the package manager. This exposes types such as \PackageManager\, \PackageInstaller\, and the constructors for \Npm\, \Pnpm\, \Yarn\, and \NodePackageManager\ from \@parcel/types\, enabling better type checking and autocompletion for consumers of this module.

packages/core/package-manager · high confidence

A new TypeScript example project (ts-example) has been added to the repository, providing a concrete demonstration of TypeScript usage. The project includes source files (index.ts, other.ts) that showcase module exports, type definitions, and variable declarations. A tsconfig.json is included, indicating support for TypeScript compilation. The commit messages suggest this example supports both ES Module and CommonJS output formats, and includes TypeScript typechecking capabilities.

packages/examples/ts-example · medium confidence

A new TSPackager is introduced to handle TypeScript files, producing JavaScript output with optional source maps. The packager processes bundles containing a single asset, extracts its code and map, and appends a source map URL if a map is present.

packages/packagers/ts · high confidence

The ts-utils package introduces new utility classes to manage TypeScript compilation and configuration. FSHost provides a wrapper around the file system for TypeScript operations, while CompilerHost extends it to handle specific TypeScript compiler interactions, including a workaround for package.json types field redirection. LanguageServiceHost implements the TypeScript Language Service host interface for IDE-like features, and ParseConfigHost manages tsconfig.json parsing and file watching. The loadTSConfig function is also added to load and parse TypeScript configuration files.

packages/utils/ts-utils · high confidence

A new CoffeeScript transformer has been added to handle the conversion of CoffeeScript files to JavaScript. The transformer compiles CoffeeScript code, updates the asset type to 'js', and generates source maps when the 'sourceMap' option is enabled, utilizing the @parcel/source-map library to manage the mapping data.

packages/transformers/coffeescript · high confidence

Introduces a new Vue transformer that parses and compiles Vue single-file components (SFCs). The transformer reads Vue configuration files (.vuerc, vue.config.js, etc.) and uses @vue/compiler-sfc to parse the SFC template, script, and styles. It generates glue code that imports the script, template, styles, and custom blocks, enabling Hot Module Replacement (HMR) for Vue components. This adds the capability to build Vue 3 applications using the Parcel bundler.

packages/transformers/vue · high confidence

A new WasmPackager has been introduced to handle WebAssembly assets. It ensures each bundle contains exactly one asset, then processes the output to inject or update the source map URL reference, supporting both direct URLs and relative path resolution for debugging.

packages/packagers/wasm · high confidence

A new WebExtension packager has been added to handle the packaging of browser extensions. It processes the extension's manifest and runtime assets, automatically resolving and updating the \web\_accessible\_resources\ list to include necessary bundled files, and adjusts the manifest for compatibility (such as removing the \type: 'module'\ from background scripts).

packages/packagers/webextension · high confidence

Introduces a new XML packager that processes XML bundles by parsing the content with DOMParser, replacing inline references and URL references (escaping double quotes to &quot;), and serializing the result. This enables Parcel to properly handle XML files, including RSS and Atom feeds, by ensuring inline assets are correctly embedded and URL references are updated.

packages/packagers/xml · high confidence

A new XML transformer has been introduced to process RSS and Atom feed files. The transformer parses XML content and applies specific handlers for Atom elements (such as link, icon, logo, and content) and RSS elements (including link, url, comments, enclosure, and description). It also handles xml-stylesheet processing instructions, allowing these feed formats to be bundled and transformed within the build pipeline.

packages/transformers/xml · high confidence

A new YAML transformer has been added to the packages/transformers/yaml directory. This transformer allows the build system to process .yaml files by parsing the YAML content and converting it into a JavaScript module that exports the parsed data as a JavaScript object. This enables direct import of YAML configuration files in JavaScript code.

packages/transformers/yaml · high confidence

The runtime now includes new helper modules for loading CSS, HTML, JavaScript, and WebAssembly bundles in both browser and Node.js environments. In the browser, JavaScript and CSS are loaded via dynamic script/link injection, while Node.js loaders read files from disk. A shared cache loader prevents duplicate loads, and a new \get-worker-url\ helper manages worker script URLs. This enables the bundler to dynamically import these asset types at runtime.

packages/runtimes/js/src/helpers · high confidence

The bundle analyzer reporter has been implemented to generate an interactive HTML report of the bundle's internal structure. This new feature allows users to visualize the size and hierarchy of assets within each target, displaying file names, sizes, and a tree of directories and files. The report is written to a 'parcel-bundle-reports' directory in the project root, providing a clear view of what contributes to the final bundle size.

packages/reporters/bundle-analyzer/src · high confidence

A new command-line interface for the bundle-stats tool has been added to the development environment. Users can now run \parcel-bundle-stats\ to generate a stats report for a Parcel build, which writes a \parcel-bundle-reports\ directory containing JSON files with bundle information. This CLI acts as a bridge to the underlying \@parcel/query\ and \@parcel/reporter-bundle-stats\ modules, allowing developers to inspect build metrics directly from the terminal.

packages/dev/bundle-stats-cli · high confidence

The RSC example now supports a client-rendered entry point that fetches and renders a server component, enabling a mix of static and dynamic RSCs. It also introduces a server action (the 'like' function) that updates state via a POST request, demonstrating how client-side interactions can trigger server-side logic and return updated RSC payloads.

packages/examples/rsc-client · medium confidence

A new CLI tool has been added to the create-parcel package, enabling users to generate new Parcel projects from templates. The tool supports multiple package managers (npm, yarn, pnpm), initializes a Git repository, and handles template installation and dependency installation automatically.

packages/utils/create-parcel/src · high confidence

The dev server now serves custom HTML templates for 404 (Page not found) and 500 (Build Error) responses. The 500 error page is particularly notable as it provides a rich, styled interface for displaying build errors, including stack traces, hints, and documentation links, along with a WebSocket connection for Hot Module Replacement (HMR) to trigger a page reload when an error occurs.

packages/reporters/dev-server/src/templates · high confidence

The test-utils package now includes a new \fsFixture\ helper and supporting utilities (\toFixture\, \applyFixture\) that allow tests to declaratively define and manipulate filesystem states. This enables developers to write tests that interact with a virtual or in-memory filesystem, simplifying the setup of complex directory structures and file contents for integration tests. The change also adds configuration files (\.eslintrc.json\, \.gitignore\, \.babelrc\, \.parcelrc-no-reporters\) and a Mocha setup file to support this new testing infrastructure.

packages/core/test-utils · high confidence

A new glob resolver plugin has been added to support wildcard imports in JavaScript and CSS files. The resolver handles relative paths (starting with . or /), tilde-prefixed package-relative paths, and deep entry points for npm packages by combining Node.js resolution with glob matching. It also supports the \~ and / prefixes for path resolution.

packages/resolvers/glob · high confidence

The bundle analyzer reporter now includes a client-side visualization of the bundle structure. This adds a new \index.js\ file and the \CarrotSearchFoamTree\ library (with its license) to the \packages/reporters/bundle-analyzer/client\ directory. The JavaScript code initializes a DOM-based interactive treemap, allowing users to hover over segments to see file sizes and click to zoom into specific parts of the bundle analysis report.

packages/reporters/bundle-analyzer/client · high confidence

The kitchen-sink example now includes a modern simple entry point (index.js) that demonstrates dynamic imports (async.js, async2.js), preloading and prefetching of resources (prefetched.js, preloaded.js), and Web Worker usage (worker.js). This provides a comprehensive test case for the bundler's handling of asynchronous code splitting, resource preloading, and worker instantiation.

packages/examples/kitchen-sink/src · high confidence

A new module in the core package converts Markdown syntax (bold, italic, underline, and strikethrough) into ANSI escape codes for terminal styling. The implementation uses the 'chalk' library to apply formatting, and includes a corresponding test suite to verify the output for each style and escape character handling.

packages/core/markdown-ansi · high confidence

A new \parcel-link\ CLI tool has been added to the development environment, allowing developers to link a local, in-development version of Parcel into a project. The tool supports linking packages into \node\_modules\, handling custom namespaces for forked projects, and managing monorepo structures. A corresponding \parcel-unlink\ command is also provided to restore the project to its default state by removing the symlinks and optionally reinstalling dependencies.

packages/dev/parcel-link · high confidence

A new CLI tool named \parcel-query\ is introduced in \packages/dev/query\ to investigate Parcel build graphs stored in the cache. The tool provides a REPL interface and CLI commands to load and inspect the AssetGraph, BundleGraph, and RequestGraph from the \.parcel-cache\ directory, allowing developers to debug build issues offline. The implementation includes a CLI entry point, a REPL interface with commands like \.findBundleReason\ and \.getAsset\, and logic to deserialize and display graph data from the cache.

packages/dev/query · high confidence

A new transformer for raw files has been added to the build system. This transformer configures assets to be treated as isolated bundles and sets the JavaScript runtime to 'url', allowing raw file assets to be processed without standard bundling or runtime integration.

packages/transformers/raw · high confidence

A new RawPackager is introduced in the packages/packagers/raw module. This packager processes bundles containing a single asset and returns the asset's original content stream directly, enabling workflows where the raw file content is preserved without transformation.

packages/packagers/raw · high confidence

A new benchmark suite has been added to the parcel-resolver crate, providing performance comparisons between the internal Parcel resolver, oxc\_resolver, rspack\_resolver, and node\_resolver. The benchmark tests resolution of various package specifiers (including '@parcel/core', 'axios', and '@babel/parser') to measure uncached resolution performance.

crates/parcel-resolver/benches · high confidence

A new 'simple' example project has been added to the repository, containing basic ES module files (index.js, foo.js, bar.js) that demonstrate standard import/export syntax and console logging.

packages/examples/simple/src · high confidence

A new 'simple' example has been added to the examples directory. It includes a \.parcelrc\ file that extends the default Parcel configuration, providing a basic starting point for users.

packages/examples/simple · high confidence

A new reporter has been added that generates a \sourcemap-info.json\ file containing source content and mapping data for each bundle, enabling users to upload this file to an external visualisation tool for debugging sourcemaps.

packages/reporters/sourcemap-visualiser · high confidence

A new transformer has been added to handle CSS worklets, configuring them as isolated ES modules with a 'url' JS runtime. This enables users to utilize CSS worklet functionality within their projects.

packages/transformers/worklet · high confidence

The Parcel web extension transformer now supports the Manifest V3 format, enabling users to build modern browser extensions. This includes validation for V3-specific fields such as \side\_panel\, \oauth2\, and \declarativeNetRequest\ rules, as well as support for \chrome\_style\ and \content\_scripts\ world properties. The transformer also handles V3's new \web\_accessible\_resources\ structure and ensures compatibility with both MV2 and MV3 manifests.

packages/transformers/webextension/src · high confidence

Users can now use .less files in their projects. The new LessTransformer compiles LESS to CSS, supports configuration via .lessrc files, and handles source maps and URL dependencies for assets referenced in LESS files.

packages/transformers/less · high confidence

A new transformer for web app manifests (webmanifest) has been added to the build system. It parses the JSON5/JSON manifest file, validates its structure against a defined schema, and processes resource dependencies for icons, screenshots, shortcuts, and file handlers, ensuring that all referenced assets are correctly tracked and included in the build output.

packages/transformers/webmanifest · high confidence

A new ESM fuzzer tool has been added to the repository to automatically generate and test ES module examples against the Parcel bundler. This utility compares Parcel's module resolution and bundling behavior against the native Node.js ES module loader, helping to identify discrepancies in how imports, exports, and re-exports are handled. The package includes configuration files, a generator for random module structures, and scripts to run the fuzzing loop.

packages/dev/esm-fuzzer · high confidence

Added Flowtype definitions for the @swc/core npm package, enabling static type checking for the SWC compiler's JavaScript/TypeScript minification and transformation APIs.

flow-typed/npm/@swc · high confidence

Added Flow type definitions (.flow files) for a wide range of dependencies including Babel packages (core, generator, parser, preset-env, template, traverse, types), ansi-html-community, browserslist, chrome-trace-event, cli-spinners, commander, cross-spawn, cssnano, deasync, dotenv-expand, fast-glob, fastest-levenshtein, fb-watchman, filesize, get-port, grapheme-breaker, htmlnano, ink, inspector, isbinaryfile, json5, less, micromatch, ncp, and node-ipc. These additions provide static type checking for the library's internal usage of these packages.

flow-libs · high confidence

Added Flow type definitions (libdefs) for the following npm packages to improve type checking: chalk, clone, express, is-url, mime, mkdirp, mocha, rimraf, semver, sinon, source-map, tempy, and typescript. These new libdef files provide type information for these libraries, enabling better static analysis and autocompletion for developers using the Flow type checker.

flow-typed/npm · high confidence

The worker system now supports a new execution backend using Node.js's native \worker\_threads\ API, implemented in \packages/core/workers/src/threads/\. This adds \ThreadsChild.js\ and \ThreadsWorker.js\ files that handle message passing and process management via \parentPort\ and \Worker\ instances, complementing the existing \process\-based backend. Users benefit from potentially improved performance or stability when running parallel tasks in Node.js environments that support the \worker\_threads\ module.

packages/core/workers/src/process · high confidence

The react-hmr example now includes a basic React application setup that demonstrates Hot Module Replacement (HMR) functionality. The entry point (index.js) implements module.hot.dispose and module.hot.accept handlers to manage hot updates, while index.html provides the standard HTML structure for the example.

packages/examples/react-hmr · high confidence

The dev-server-sw reporter now implements Hot Module Replacement via a service worker. On successful builds, the server broadcasts asset updates and file contents to the service worker, enabling the browser to hot-reload JavaScript and CSS assets without a full page refresh. This change also patches the @nodelib/fs.scandir dependency to ensure compatibility with older Node.js versions.

packages/reporters/dev-server-sw, patches · high confidence

A new TracerReporter has been introduced to enable Chrome Trace Event (CTE) profiling for Parcel builds. This reporter captures build events and writes them to a JSON trace file, allowing users to analyze build performance using Chrome DevTools or similar tools. The implementation handles initialization, event collection, and file output, with a link to the profiling documentation.

packages/reporters/tracer · high confidence

The node-resolver-rs package now includes a new \tsconfig.rs\ module that parses \tsconfig.json\ files to extract \baseUrl\, \paths\, and \moduleSuffixes\ settings. This enables the Rust-based resolver to understand TypeScript path mappings and base URL configurations, allowing it to resolve module specifiers according to TypeScript's path mapping rules.

packages/utils/node-resolver-rs · high confidence

The @parcel/macros package now includes TypeScript type definitions for the MacroContext interface, exposing the loc property which provides the source location of the macro call. This enables better type checking and autocompletion for developers using macros.

packages/utils/macros · high confidence

A new example project was added to demonstrate TypeScript type-checking capabilities. The example includes a Parcel configuration that integrates the @parcel/validator-typescript validator for .ts and .tsx files, a minimal TypeScript source file that intentionally contains a type error (accessing 'world' on a 'Params' object), and a basic tsconfig.json.

packages/examples/ts-typecheck-example · high confidence

A new reporter has been added to the Parcel build process that generates a JSON statistics file for each build target. This reporter collects data about bundles and their constituent assets, including file sizes and names, and writes the results to a 'parcel-bundle-reports' directory in the project root. This allows users to analyze their bundle composition and sizes after a successful build.

packages/reporters/bundle-stats · high confidence

The @parcel/profiler package now includes a new Tracer system that allows internal components to emit trace events for performance analysis. This includes a SamplingProfiler for CPU profiling via the Node.js inspector, a Trace class for generating Chrome Trace Event format data, and a PluginTracer for plugins to record their own timings. A build script (build-ts.js) is also added to post-process TypeScript declaration files. These changes provide the foundation for future user-facing performance insights and debugging capabilities.

packages/core/profiler · high confidence

A new example named 'internalize-example' has been added to showcase how the bundler handles dynamic imports. The example includes an HTML entry point and several JavaScript modules (index.js, index-sync.js, async.js, index-other.js) that demonstrate how dynamic imports are processed, specifically illustrating scenarios where assets are internalized into the same bundle versus different bundles.

packages/examples/internalize-example · high confidence

The Parcel build system now includes a new image optimizer that performs lossless optimization on PNG and JPEG images. This is achieved by integrating a Rust-based optimization function (\optimizeImage\) into the JavaScript optimizer (\ImageOptimizer.js\). The implementation includes error handling that logs a warning and returns the original image if the optimization fails, rather than crashing the build process.

packages/optimizers/image · high confidence

The web extension transformer now includes runtime scripts to enable hot-reloading during development. The new \autoreload.js\ file implements a communication loop between the browser extension and the development server, using \chrome.runtime\ or \browser.runtime\ APIs to trigger page reloads when source files change. A default background script (\default-bg.js\) is also provided to facilitate this runtime integration.

packages/transformers/webextension/src/runtime · medium confidence

The vanilla template for creating new Parcel applications now includes a gitignore file (excluding .parcel-cache, dist, and node\_modules), a basic index.html entry point, and a default style.css. These files provide the initial structure for vanilla JavaScript/HTML/CSS projects created via the CLI.

packages/utils/create-parcel/templates/vanilla · high confidence

The CSS packager has been rewritten to use the lightningcss library, replacing the previous PostCSS-based implementation. This change introduces support for CSS modules, including variable scoping and tree-shaking of unused classes, while also enabling proper source map generation for CSS assets.

packages/packagers/css · high confidence

A new helper module (rsc-helpers.jsx) was added to the RSC runtime to automatically inject CSS resources into the React Server Components stream. The module provides a createResourcesProxy function that wraps components to detect React components and inject specified resources (such as CSS stylesheets) into the rendered output. Additionally, a waitForCSS utility was introduced to ensure stylesheets are fully loaded before rendering, improving the reliability of CSS injection in server-side rendered components.

packages/runtimes/rsc · high confidence

The inline-requires optimizer has been added as an experimental feature that transforms synchronous require calls into deferred, lazy-loaded module inclusions. This reduces initial runtime startup time by delaying the execution of module factories until the modules are actually used. The optimizer respects side-effect markers to ensure modules with side effects are still executed immediately. It also includes a test suite for the inlining visitor logic.

packages/optimizers/inline-requires · high confidence

The \@parcel/transformers-typescript-types\ package is introduced, providing the core logic for generating TypeScript declaration files (.d.ts). This includes new modules for tracking module graphs, collecting imports and exports, and shaking unused code, enabling the bundler to produce accurate type definitions for JavaScript libraries.

packages/transformers/typescript-types · high confidence

The \packages/dev/repl\ directory has been initialized with essential configuration files to support the new REPL feature. This includes an ESLint configuration for React/JSX development, a \.gitignore\ file to exclude build artifacts and commit hashes, and a \patchDeps.sh\ script to apply necessary workarounds for dependencies like Sass and htmlnano. Additionally, \serve.json\ and \vercel.json\ are added to configure Cross-Origin-Embedder-Policy headers for the deployment environment, while \write-commit.js\ tracks the current commit hash. These changes establish the foundational tooling and environment setup for the REPL.

packages/dev/repl · high confidence

The repository now includes a new Rust-based architecture for Parcel v3, introducing a \Cargo.lock\ file and new \Cargo.toml\ configurations for core modules like \parcel-core\, \parcel-resolver\, and \parcel-node-bindings\. This change establishes the foundation for native performance improvements and cross-platform binary distribution, while also updating the JavaScript tooling dependencies to support the new Rust integration.

(dependencies) · high confidence

The internal type definitions for caching (Cache), file system operations (FileSystem, Stats, Dirent), and package management (PackageManager, PackageInstaller) have been explicitly defined. This introduces structured interfaces for cache operations, file system interactions, and package resolution, providing a clearer contract for these core functionalities.

packages/core/types-internal · high confidence

Added the @parcel/register package, which allows Node.js to synchronously load and transform files (such as JavaScript) using Parcel's build pipeline. The implementation registers hooks for file extensions and patches Module.\_resolveFilename to intercept require calls, utilizing a syncPromise helper to block the event loop while the asynchronous Parcel transform completes.

packages/core/register/src · high confidence

The @parcel/babel-register package now includes a new Babel registration setup and a custom Babel plugin (babel-plugin-module-translate) that intercepts and resolves @parcel/ scoped imports. This allows child processes and workers to correctly resolve internal Parcel package imports during compilation, ensuring that relative paths and package exports are properly translated for the build system.

packages/dev/babel-register · high confidence

The default bundler is now implemented as a plugin in \packages/bundlers/default/src/DefaultBundler.js\. This new plugin handles the core bundling logic, including configuration loading, entry point processing, and the creation of an ideal graph for bundle splitting and deduplication.

packages/bundlers/default · high confidence

Added the HMR (Hot Module Replacement) runtime implementation for the loaders package, including the core \hmr-runtime.js\ file which manages hot reloading logic, WebSocket/SSE connections, and error overlays. Additionally, an \.eslintrc.json\ file was added to configure ESLint for the loaders directory, extending the browser-specific ESLint configuration.

packages/runtimes/hmr/src/loaders · high confidence

Added a new HMR runtime implementation in packages/runtimes/hmr/src/HMRRuntime.js. This runtime injects Hot Module Replacement logic into JavaScript bundles, configuring connection details (host, port, HTTPS status, and bundle ID) based on Parcel options. It explicitly excludes library targets, server-side bundles, and scripts, ensuring HMR is only applied to client-side JavaScript assets.

packages/runtimes/hmr/src · high confidence

Added a new HTMLNano optimizer that processes HTML and SVG files. The optimizer loads configuration from .htmlnanorc, package.json, or dedicated config files, and supports both CommonJS and ESM config formats. It handles SVG minification by detecting the installed SVGO version and mapping lowercase SVG tag/attribute names to their correct case-sensitive equivalents to ensure compatibility with SVGO.

packages/optimizers/htmlnano · high confidence

A new JSRuntime implementation is added to handle the generation of JavaScript runtime code, including support for ES Modules and CommonJS output formats, dynamic imports, and preloading/prefetching of bundles. This change introduces a declarative API for runtimes, allowing the bundler to correctly load async and shared bundles in workers and browsers, while also supporting import maps and relative URL resolution for external bundles.

packages/runtimes/js/src · high confidence

The dev server now supports running Node.js bundles in development. A new \NodeRunner\ component manages Node.js worker threads, allowing the dev server to serve and hot-reload Node.js applications alongside browser assets. This enables a unified development experience for full-stack applications, where changes to Node.js code trigger appropriate hot module replacement updates or restarts.

packages/reporters/dev-server/src · high confidence

Added a new \@parcel/rsc\ utility package that provides a simplified API for rendering React Server Components (RSC) on both the server and client sides. The library exports functions to hydrate RSC payloads in the browser, render RSC streams and HTML on the server, and handle server actions. It also includes TypeScript definitions for the underlying \react-server-dom-parcel\ and \rsc-html-stream\ modules, enabling developers to easily integrate RSC into their applications.

packages/utils/rsc · high confidence

A new \ReactRefreshWrapTransformer\ is added to wrap source files with React Fast Refresh helpers. The transformer injects code to initialize and restore React's hot-reload state, supporting \react\, \@emotion/react\, and their respective JSX runtimes. It excludes library targets, workers, worklets, and non-browser environments, ensuring that only appropriate source files are transformed for hot module replacement.

packages/transformers/react-refresh-wrap/src · high confidence

Added a new RSC runtime implementation that enables React Server Components. This includes logic to handle 'use client' and 'use server' directives, automatically inject CSS resources into the RSC stream, and use import maps for bundle manifests to support mixing static and dynamic RSCs.

packages/runtimes/rsc/src · high confidence

Added new @parcel/optimizer-html and @parcel/optimizer-svg packages that use a Rust-based implementation for HTML and SVG optimization respectively. The HTML optimizer reads configuration from .htmlnanorc files and htmlnano.config.js, while the SVG optimizer reads from svgo.config.js files. Both provide optimized output when the environment's shouldOptimize flag is true.

packages/optimizers/html, packages/optimizers/svg · high confidence

The HTML and SVG processing pipeline has been rewritten in Rust, introducing a new \crates/html\ crate that handles parsing, dependency collection, JSX conversion, and optimization. This change replaces the previous JavaScript-based implementation with a high-performance Rust-based transformer and packager, enabling features like preserving \\<meta charset="utf-8"\>\, fixing SVG to JSX conversion, and optimizing HTML/SVG output.

crates/html · high confidence

A new Rust-based packager has been added for processing HTML and SVG files. This change introduces a dedicated SVGPackager that handles SVG assets by delegating to a Rust implementation, supporting inline styles, inline scripts, and CSS processing within SVGs. Users will see improved handling of SVG assets with support for inline content and CSS processing.

packages/packagers/svg · medium confidence

The \parcel-resolver\ crate has been introduced to handle module resolution in Rust, replacing the previous JavaScript-based implementation. This adds a new \Cache\ for file system metadata, an \Invalidations\ system to track file changes, and a \FileSystem\ trait with a default \OsFileSystem\ implementation. The resolver now supports Node.js CommonJS and ESM resolution, TypeScript \tsconfig\ paths, \alias\ and \browser\ fields, and various resolution flags. It also includes a list of Node.js built-in modules and handles schemes like \npm:\, \jsr:\, and \cloudflare:\.

crates/parcel-resolver/src · high confidence

The \packages/core/rust\ directory now contains the JavaScript/TypeScript bindings for the new Rust-backed resolver and transformer. This adds a \Resolver\ class and functions for transforming, packaging, and optimizing HTML and SVG assets via NAPI-RS. The implementation includes platform-specific loading logic for Windows, macOS, Linux, and Android, supporting x64, arm64, and other architectures. This change enables the bundler to use Rust for these specific asset types, potentially improving performance and stability.

packages/core/rust · high confidence

A new @parcel/transformer-svg-jsx package has been added, providing a Rust-based transformer that converts SVG files into JSX components. The transformer supports SVGR configuration files (.svgrrc, svgr.config.\) and SVGO configuration (svgo.config.\), while explicitly rejecting unsupported SVGR options like 'jsx' and 'template'. By default, it prefixes SVG IDs with a hash to prevent conflicts, and the output is marked as JSX with automatic runtime.

packages/transformers/inline-string, packages/transformers/svg-jsx · high confidence

Users can now have SVG files processed by a new dedicated transformer. This change adds an SVG transformer that calls into a Rust-based implementation to transform SVG content, handle dependencies, and manage asset bundling behavior. The transformer ensures SVGs are treated as isolated bundles and processes CSS within SVGs, allowing for more granular control over SVG asset handling in the build pipeline.

packages/transformers/svg · high confidence

Added a new optimizer implementation using the SWC library to handle JavaScript minification and optimization. This new component reads user configuration files (such as .terserrc) and applies minification settings like mangling and compression, while also generating source maps and handling error reporting for the build process.

packages/optimizers/swc · high confidence

The Parcel for VS Code extension is now available, providing inline error and warning diagnostics in the editor. It connects to the Parcel LSP server to fetch importers and document diagnostics, and includes an 'Importers' view in the sidebar to explore file dependencies. The extension also supports multiple workspaces and cleans up its LSP server state on shutdown.

packages/utils/parcelforvscode · high confidence

A new feature flag system has been added to the core package, allowing runtime configuration of internal capabilities. The implementation includes a \FeatureFlags\ type definition with specific flags such as \exampleFeature\ and \useWatchmanWatcher\, along with functions to set and retrieve flag values. This enables toggling experimental or optional behaviors, such as using a Node.js-based watchman backend for file watching, without requiring code changes.

packages/core/feature-flags · high confidence

Added a new image transformer that processes images using the 'sharp' library (version ^0.33.5). The transformer supports JPEG, PNG, WebP, GIF, TIFF, AVIF, and HEIC formats, allowing users to specify width, height, quality, and format via URL query parameters or a 'sharp.config.json' configuration file. It also preserves EXIF metadata and supports animated images.

packages/transformers/image · high confidence

The \@parcel/fs\ module now includes a \MemoryFS\ class, an in-memory implementation of the \FileSystem\ interface that stores files in Maps, enabling faster, non-persistent file operations ideal for testing and temporary builds. Additionally, an \OverlayFS\ class is introduced, which layers a writable filesystem over a readable one, allowing changes to be tracked without modifying the underlying read-only source. These changes support a more modular and performant filesystem abstraction within Parcel's core.

packages/core/fs/src · high confidence

A new LibraryBundler plugin has been added to the bundlers library package. This bundler is designed specifically for library builds, outputting a separate bundle for each input asset. This approach ensures that the library can be effectively tree-shaken and code-split by an application bundler. The implementation traverses the bundle graph to collect dependencies and assets, creating individual bundles for each asset while establishing references between parent and child bundles to maintain dependency graphs.

packages/bundlers/library · high confidence

The Parcel core package now includes a dedicated CLI entry point (bin.js) that bootstraps the command-line interface by loading Babel register and invoking the new cli.js module. The cli.js file defines the full set of command-line options for Parcel, including flags for caching, source maps, logging, reporters, feature flags, HMR settings, and more. An .eslintrc.json file is also added to configure ESLint rules for the new CLI code, specifically turning off the no-console rule.

packages/core/parcel/src · high confidence

Added a new CSS transformer (CSSTransformer.js) that leverages the lightningcss library to handle CSS processing, including support for CSS modules, source maps, and error recovery. Additionally, a new React static transformer (ReactStaticTransformer.js) was introduced to handle React static assets, disabling scope hoisting and setting the bundle behavior to 'isolated' for these assets.

packages/transformers/css · high confidence

The JS packager has been rewritten to support scope hoisting and multiple output formats (ESM, CommonJS, and global/script). The new packager generates optimized, scope-hoisted bundles by default, while also providing a legacy dev packager for development. This change introduces new output format classes (ESMOutputFormat, CJSOutputFormat, GlobalOutputFormat) that control how the bundled code is structured, including handling of external dependencies, exports, and preambles. The packager also supports an unstable async bundle runtime feature, configurable via the \unstable\_asyncBundleRuntime\ config option, which enables dynamic loading of JavaScript bundles. The implementation includes a new \ScopeHoistingPackager\ class that handles the core bundling logic, along with helper functions and utilities for dependency resolution and code generation.

packages/packagers/js · high confidence

The cache module now includes three distinct cache storage implementations: FSCache for file-system based caching, LMDBCache for high-performance local storage using LMDB, and IDBCache for browser-based caching using IndexedDB. These implementations provide different storage backends that can be selected based on the environment (Node.js vs. Browser) and performance requirements.

packages/core/cache/src · high confidence

A new codeframe module has been added to the core package, providing functionality to generate visual code frames for error diagnostics. This includes support for syntax highlighting, colorized output, and handling of long lines and small terminals, with comprehensive test coverage for various highlighting scenarios.

packages/core/codeframe · medium confidence

Adds a new interactive development environment (REPL) that runs in the browser, allowing users to edit, build, and preview code without a local Node.js environment. The feature includes a file browser for managing assets, a CodeMirror-based editor with syntax highlighting and linting, and a live preview pane. It also provides a settings panel to configure build options such as source maps, output format, and target environment.

packages/dev/repl/src · high confidence

The \crates/node-bindings\ directory introduces a new Rust-based Node.js addon that exposes core Parcel capabilities to JavaScript. This includes a file-system-aware dependency resolver with caching, a lossless image optimizer (PNG via oxipng, JPEG via libjpeg), and transformers for HTML, SVG, and JavaScript (via SWC). The resolver exposes a \FileSystem\ interface to the JS layer, allowing the Node bindings to read files and resolve modules. The transformer module exposes synchronous and asynchronous (rayon-based) transformation functions, enabling JS macro support and faster processing. Additionally, utility functions for hashing and file searching are exposed to the Node environment.

crates/node-bindings · high confidence

A new Babel preset, @parcel/babel-preset-env, has been introduced. This preset detects when it is being used by the Parcel bundler (specifically versions 2.0.0-beta.1 and above) and, in that case, configures @babel/preset-env with browser targets passed from the caller. It also enables shippedProposals and uses corejs 3. For non-Parcel callers, it still enables shippedProposals but does not apply the custom target configuration.

packages/utils/babel-preset-env · high confidence

The \@parcel/transformer-babel\ package has been introduced to handle JavaScript and TypeScript compilation. It leverages \@babel/core\ to resolve and apply Babel configurations, supporting \.js\, \.jsx\, \.ts\, and \.tsx\ files. The transformer automatically detects JSX syntax and Flow types, applying the appropriate Babel plugins (\@babel/preset-env\, \@babel/plugin-transform-typescript\, \@babel/plugin-transform-flow-strip-types\, and \@babel/plugin-transform-react-jsx\). It also improves source map accuracy by remapping AST locations and handles Babel environment variables (\BABEL\_ENV\, \NODE\_ENV\) for conditional configuration.

packages/transformers/babel · high confidence

The ESLint plugin now includes a new rule, 'no-self-package-imports', which detects and prevents importing from the same package, helping developers avoid circular dependencies or redundant internal imports.

packages/dev/eslint-plugin · high confidence

A new LSP reporter and server have been added to enable diagnostics and code intelligence in the VS Code extension. The \@parcel/reporter-lsp\ package now communicates with the \@parcel/parcel-lsp\ server using \vscode-jsonrpc\ for IPC, allowing the editor to receive build diagnostics and support features like importers and workspace management.

packages/reporters/lsp-reporter, packages/utils/parcel-lsp · high confidence

Added new project templates for React applications, including a client-side entry point and a server-side entry point that supports React Server Components (RSC) and server actions. The server template includes an Express-based server setup that renders pages and handles server actions, while the client template provides a basic React app structure with CSS and TypeScript configuration.

packages/utils/create-parcel/templates/react-server · high confidence

A new TSCTransformer has been added to the codebase, enabling Parcel to compile TypeScript files using the TypeScript compiler (tsc) directly. This transformer loads tsconfig.json settings, transpiles the code to JavaScript, and properly handles source maps by extending any existing maps from the original file.

packages/transformers/typescript-tsc · high confidence

A new ESLint configuration package has been introduced for browser-based codebases. It extends the shared '@parcel/eslint-config' and configures the '@babel/eslint-parser' with ECMAScript 5 support. The configuration enables browser environment globals and adjusts linting rules: 'no-console' is disabled, 'no-global-assign' is set to warn, and 'no-unused-vars' is disabled.

packages/dev/eslint-config-browser · high confidence

Added a suite of new scripts in the \scripts/\ directory to manage native package builds and releases. \build-native.js\ handles building native packages (NAPI/WASM) with support for release, canary, and target-specific builds, including macOS cross-compilation setup. \tag-release.mjs\ updates npm dist-tags for releases. \link-all.js\ and \unlink-all.js\ manage local package linking. \update-config-dependencies.js\ and \update-engines-peerdeps.js\ synchronize version numbers across configuration files. \swc-update-all.sh\ updates SWC crate versions. These changes support the new native package build process.

scripts · high confidence

A new \BuildMetricsReporter\ has been added to \packages/reporters/build-metrics\. It tracks the duration of each build phase and generates a \parcel-metrics.json\ file containing phase timings, total build time, and per-bundle statistics (file path, size, time, and top 10 largest assets).

packages/reporters/build-metrics · high confidence

A new inline transformer has been added to the codebase. This transformer sets the bundle behavior to 'inline' for assets it processes, effectively inlining those assets into the bundle rather than emitting them as separate files.

packages/transformers/inline · high confidence

The package manager module has been rewritten to provide a unified interface for installing dependencies using npm, pnpm, or Yarn. The new implementation includes dedicated classes for each package manager (Npm, Pnpm, Yarn) that handle the specific command-line arguments and output parsing for each tool. A central \installPackage\ module automatically detects which package manager to use based on lockfiles (package-lock.json, pnpm-lock.yaml, yarn.lock) or the current environment, ensuring consistent dependency resolution and installation behavior across different project setups.

packages/core/package-manager/src · high confidence

The public API for Parcel's core graph and asset objects has been refactored. New wrapper classes are now exposed in \packages/core/core/src/public\, including \Asset\, \Bundle\, \BundleGraph\, \MutableBundleGraph\, \BundleGroup\, \Config\, \Dependency\, \Environment\, \PluginOptions\, \Target\, and \Symbols\. These classes provide a stable, public-facing interface for interacting with the internal graph structures, allowing plugins and tools to access and modify assets, bundles, and dependencies in a consistent way.

packages/core/core/src/public · high confidence

The PostCSS transformer has been implemented to handle \.pcss\ and CSS files, introducing a new \PostCSSTransformer\ that parses and transforms CSS using PostCSS 8. The system now loads PostCSS configuration from \.postcssrc\, \postcss.config.js\, and \package.json\, supporting both CommonJS and ES Module config files. It automatically detects and warns about redundant plugins like \autoprefixer\ and \postcss-preset-env\, and handles CSS modules via \postcss-modules\. The transformer also supports \dir-dependency\ messages and considers dependencies from PostCSS messages for proper caching and hot reloading.

packages/transformers/postcss · high confidence

The build process has been restructured into distinct request types—AssetGraphRequest, AssetRequest, BundleGraphRequest, ConfigRequest, DevDepRequest, EntryRequest, PackageRequest, ParcelBuildRequest, ParcelConfigRequest, PathRequest, and TargetRequest. This change replaces the previous monolithic build logic with a modular, request-based architecture where each stage of the build (resolving entries, resolving targets, building the asset graph, bundling, and packaging) is handled by its own dedicated request handler, improving maintainability and incremental build performance.

packages/core/core/src/requests · high confidence

The repository now includes a comprehensive set of configuration files to standardize development and build processes. This includes \.editorconfig\ for consistent file formatting, \.eslintrc.json\ extending the \@parcel/eslint-config\, and \.flowconfig\ for type checking with Flow 0.184.0. Additionally, \.prettierrc\ and \.prettierignore\ enforce code style, while \.mocharc.json\ configures the test runner. The \gulpfile.js\ automates the build process, and \verdaccio.yml\ sets up a local npm registry for testing. The root \test.js\ file has been removed.

(repo-wide) · high confidence

The JavaScript transformer core in \packages/transformers/js/core\ has been rewritten in Rust, replacing the previous JavaScript implementation. This new Rust-based transformer introduces dedicated modules for collecting imports and exports (\collect.rs\), resolving dependencies (\dependency\_collector.rs\), replacing environment variables (\env\_replacer.rs\), handling Node.js globals (\global\_replacer.rs\), and performing scope hoisting (\hoist.rs\). This change provides a high-performance, memory-safe foundation for all JavaScript, TypeScript, and MDX transformation, enabling features like constant module inlining, file inlining, and improved error diagnostics.

packages/transformers/js/core · high confidence

A new ServiceWorkerRuntime was added to automatically generate a service worker entry point. This runtime scans the bundle graph to collect all inline bundles, constructs a manifest of their public URLs, and injects code that registers the service worker with the current bundle's hash reference for versioning.

packages/runtimes/service-worker · high confidence

The @parcel/optimizer-terser package is introduced as a new optimizer that handles JavaScript minification and scope hoisting. It supports configuration via .terserrc files and .cjs/.mjs config files, enabling per-target minification settings. The optimizer generates source maps, appends source map references to optimized bundles, and provides detailed code frame diagnostics for parse errors, ensuring users receive clear feedback when Terser encounters unsupported syntax.

packages/optimizers/terser · high confidence

The file packages/core/parcel-bundler/src/visitors/dependencies.js has been deleted. This file previously handled the extraction of import, export, and require statements for bundling. Its removal indicates that the logic for visiting these dependency types has been migrated or restructured elsewhere in the codebase.

packages/core/parcel-bundler/src/visitors · high confidence

Deleted the legacy Parcel v1 bundler implementation, including Bundle, Module, Parser, Resolver, and related parser and builtin files from the core parcel-bundler package.

packages/core/parcel-bundler/src · high confidence

The macro evaluation implementation has been moved from the previous location into a new, separate \crates/macros\ crate. This refactoring isolates the macro processing logic, including the \Macros\ struct, the \Evaluator\, and the \MacroCallback\ interface, into its own module. This change improves code organization and separation of concerns within the build system.

crates/macros · high confidence

The example now includes an ESLint configuration that enforces the 'no-console' rule as an error. Additionally, the Parcel build configuration has been updated to use the @parcel/validator-eslint validator for JavaScript and TypeScript files, enabling linting during the build process.

packages/examples/eslint-example · high confidence

A new example project was added to packages/core/register/example, demonstrating how to use @parcel/register. The example includes entry points (index.js, count.js, number.js) and a local dependency (node\_modules/something) to showcase module resolution and registration behavior.

packages/core/register/example · medium confidence

The repository now automatically runs the linting and formatting scripts before each commit, ensuring consistent code style without manual intervention.

.husky · high confidence

The repository now uses a shared ESLint configuration located at packages/dev/eslint-config. This configuration extends recommended rules for ESLint, Flowtype, React, and Prettier, and enforces import ordering, newline after imports, and no console statements. It also includes custom rules such as @parcel/no-self-package-imports and mocha/no-exclusive-tests, with specific overrides for test files to disable certain import checks and enable Mocha environment. This change standardizes linting across the codebase.

packages/dev/eslint-config · high confidence

The CSS optimizer now uses the lightningcss library for minification instead of the previous default. This change introduces a new optimization pipeline that supports tree-shaking of unused CSS symbols and handles inline style attributes differently. Users with existing cssnano configurations will see a warning message suggesting they either remove the configuration or explicitly use the @parcel/optimizer-cssnano plugin if they need the old behavior.

packages/optimizers/css · high confidence

The default namer now determines bundle filenames based on the bundle group's entry asset, supporting both ES Module and CommonJS extensions (.js, .mjs, .cjs). It enforces that target output paths match the compiled bundle type, throwing a diagnostic if they do not. For split bundles, it uses the first bundle in the group to derive the name, and groups server/client React bundles into separate folders to prevent exposing server code on public servers.

packages/namers · high confidence

The default resolver now detects and throws a user-friendly error when it encounters webpack-specific loader syntax (e.g., \imports-loader?$=jquery!./example.js\). This prevents confusing resolution failures by explicitly informing users that this import style is not supported by Parcel.

packages/resolvers/default · high confidence

The graph implementation has been refactored into a dedicated \@parcel/graph\ package, introducing new internal data structures like \AdjacencyList\ and \BitSet\ to improve performance. The \Graph\ and \ContentGraph\ classes now utilize these optimized structures, which support multiple edge types and store edges in a \SharedArrayBuffer\ for better memory management. This change also includes an iterative DFS implementation and optimizations for symbol propagation and edge counting.

packages/core/graph/src · high confidence

The HTML packager has been rewritten to leverage a new Rust-based template engine for generating HTML output, which now supports inline bundles and import maps for JavaScript modules. This change introduces support for ES modules with import maps, allowing for more efficient loading of shared scripts. Additionally, the packager now handles inline bundle contents by escaping closing script and style tags to prevent parsing issues, and ensures that sibling bundles are inserted correctly into the HTML structure.

packages/packagers/html · medium confidence

The HTML transformer has been rewritten to use a Rust-based implementation (via @parcel/rust) for parsing and transforming HTML files. This change introduces support for .htm and .xhtml file types, sets the bundle behavior to 'isolated', and handles HMR script injection and dependency resolution through the new Rust backend.

packages/transformers/html · high confidence

The React Refresh integration in the Parcel transformer was updated to fix several HMR issues affecting usage at scale. The helper now implements a leading-edge debounce on the update queue to prevent rapid-fire hot reloads, and the error overlay is modernized to better handle runtime errors and editor integration. Additionally, the logic for detecting React refresh boundaries and invalidating them on signature changes was refined to prevent page reload loops and handle getters on the namespace correctly.

packages/transformers/react-refresh-wrap/src/helpers · medium confidence

The Babel plugin for transforming runtime helpers now includes a wrapper that detects when it is being called by the Parcel bundler. When the caller is identified as 'parcel' with a compatible version, the plugin configures the transform to use ES modules if the output format is 'esmodule', otherwise it falls back to the standard Babel plugin behavior. This ensures that Parcel can control the module format for runtime helpers, while external callers receive the default transformation.

packages/utils/babel-plugin-transform-runtime · high confidence

The CLI reporter has been refactored into a new native implementation located in packages/reporters/cli/src. This update provides a more accurate bundle report, displaying build times and file sizes for each bundle and its assets. It also logs build phase times (e.g., transforming, bundling, packaging & optimizing) when the PARCEL\_SHOW\_PHASE\_TIMES environment variable is set. The reporter now respects log levels, supports detailed reporting, and handles terminal resizing and non-TTY environments more robustly.

packages/reporters/cli/src · medium confidence

The diagnostic package now provides a structured way to emit errors, warnings, and info messages. This includes support for code frames that highlight specific locations in source files, allowing for better visualization of issues. Additionally, all diagnostic messages are now escaped for markdown rendering to prevent potential security issues with user input. The system also supports converting various error types into a unified diagnostic format.

packages/core/diagnostic/src · high confidence

The kitchen-sink example now includes a new .parcelrc configuration file that extends the default Parcel config, explicitly registers the @parcel/transformer-babel transformer for .js files, and adds the @parcel/reporter-sourcemap-visualiser reporter. Additionally, the example now provides two separate entry points—legacy.html and modern.html—each linking to their respective dist/legacy and dist/modern build outputs, allowing users to compare or choose between legacy and modern build workflows.

packages/examples/kitchen-sink · medium confidence

The logger has been rewritten to use an internal ValueEmitter for emitting log events, replacing the previous implementation. This change introduces a structured event-based logging system where log messages are emitted as events, allowing for more flexible and decoupled log handling. The Logger class now exposes methods like verbose, info, log, warn, and error that emit corresponding LogEvent objects. Additionally, the code includes functions to patch and unpatch the console object to forward console messages to the logger, with a guard to prevent multiple patching.

packages/core/logger/src · high confidence

The error overlay has been modernized to use Preact instead of React, resulting in a lighter bundle and avoiding duplicate React dependencies. The overlay now features a new UI with collapsible stack traces, a navigation bar to switch between multiple errors, and improved code display with syntax highlighting. The overlay is now rendered inside a shadow DOM element to ensure styles do not leak into the application.

packages/utils/error-overlay · high confidence

The Node.js module resolution logic has been refactored into a new \node-resolver-core\ package, introducing a Rust-based resolver backend (\@parcel/rust\) for improved performance. The implementation now supports configurable \mainFields\ and \extensions\ options, handles Yarn PnP resolution, and provides specific polyfills for Node.js built-in modules in browser environments. This change replaces the previous JavaScript-only resolution logic with a more robust, async-capable system that also integrates with the existing plugin and diagnostic infrastructure.

packages/utils/node-resolver-core/src · medium confidence

Node native modules are now treated as isolated bundles, meaning they will be bundled separately rather than being merged with the main application bundle. This ensures that Node-specific dependencies are handled independently, preventing potential conflicts or issues arising from shared bundling.

packages/transformers/node · high confidence

The node-resolver-core package now includes build configuration for a Rust-based implementation, indicated by the addition of a build.rs script that sets up the napi build environment for non-WASM targets. This change introduces support for native modules (.node files) and WebAssembly (.wasm files) in the resolver core, alongside a .gitignore to manage these build artifacts.

packages/utils/node-resolver-core · medium confidence

Brotli and Gzip compressors now skip execution during development, reducing unnecessary processing when running the dev server. Additionally, Gzip compression is configured to use the maximum compression level (level 9) for better file size reduction in production.

packages/compressors · medium confidence

The @parcel/utils package has been refactored to improve performance, type safety, and functionality. This includes adding new utility classes like DefaultMap and Deferred, and a PromiseQueue for managing concurrent operations. The config loading logic has been updated to support TOML and JSON5 formats, with improved caching and error reporting. Path and URL handling functions have been standardized, and new utilities for generating SSL certificates, computing hashes, and formatting diagnostics have been added. Additionally, the codebase has been fully typed with Flow, and several performance optimizations have been applied, such as using xxhash3 for hashing and optimizing the levenshtein algorithm.

packages/core/utils/src · high confidence

The core bundler architecture has been refactored to use new internal graph structures. AssetGraph now extends ContentGraph with specific node types for assets, dependencies, and entries, while BundleGraph manages the relationships between bundles and their contents. A new CommittedAsset class handles asset content and source map retrieval, and Dependency creation has been updated to include symbol and package condition handling. These changes underpin the new bundler's improved performance, caching, and symbol propagation capabilities.

packages/core/core/src · high confidence

The bundler's internal utility modules for filesystem operations, promise conversion, and task queuing have been removed. This cleanup eliminates the custom \promisify\ helper, the \fs\ wrapper, and the \Queue\ class, likely replacing them with native Node.js APIs or other internal abstractions.

packages/core/parcel-bundler/src/utils · high confidence

The worker management system has been refactored to support shared references between the main process and workers, allowing complex objects to be passed without full serialization. The new implementation introduces a pluggable backend system that automatically detects and uses either Node.js worker threads, child processes, or browser Web Workers, with the specific backend selectable via the \PARCEL\_WORKER\_BACKEND\ environment variable. This change also introduces a \Handle\ class for reverse function calls from workers to the main process and improves CPU core detection across Linux, macOS, and Windows.

packages/core/workers/src · high confidence

The JavaScript transformer has been rewritten in Rust to deliver performance improvements and new capabilities. Users benefit from first-class MDX support via new component handling, automatic JSX runtime configuration via tsconfig.json, and enhanced source map generation. The change also introduces JS macros with a dedicated context for asset invalidation, fixes default interop for CommonJS modules, and ensures esmodule-helpers are IE11-compatible.

packages/transformers/js/src · medium confidence

The SVG-to-React transformer has been rewritten to use the @svgr library, enabling conversion of SVGs to React components. A key new capability is the ability to generate TypeScript (.tsx) output when the 'typescript' option is enabled. The transformer also integrates with the project's installed version of SVGO, automatically detecting whether it is version 2 or 3, and issues a warning if deprecated SVGO v2 options are detected in configuration files.

packages/transformers/svg-react · high confidence

The Sass transformer now detects whether to use the legacy or modern Sass API based on the configuration options provided. This allows users to continue using older Sass features and configurations while also enabling support for the newer Sass API, ensuring compatibility with both legacy and modern Sass projects.

packages/transformers/sass · high confidence

The service worker utility now exposes \manifest\ and \version\ properties that can be injected at runtime via the \\_register\ function. This allows the service worker to dynamically receive and store the application's manifest data and version string, enabling the worker to stay in sync with the current application state.

packages/utils/service-worker · medium confidence

The build configuration for the Three.js example has been updated to use ESBuild as the JavaScript optimizer, replacing the previous setup. This change is supported by the addition of a \.parcelrc\ file that configures the \@parcel/optimizer-esbuild\ plugin, alongside a new \.gitignore\ file and a \Makefile\ that manages the Three.js source code. This shift in the build tooling may affect how the example is compiled and optimized.

packages/examples/three · medium confidence

The Babel preset has been updated to target Node.js 16 and enable the React automatic runtime for JSX. For production builds, the preset now inlines the PARCEL\_BUILD\_ENV, SKIP\_PLUGIN\_COMPATIBILITY\_CHECK, and PARCEL\_SELF\_BUILD environment variables, allowing dead code elimination to remove unused code paths. During development or self-builds, the preset simplifies configuration by inlining PARCEL\_BUILD\_ENV and applying dead code elimination, while also enabling lazy loading of CommonJS modules for faster startup.

packages/dev/babel-preset · high confidence

The project has been upgraded to use Yarn 4, as indicated by the addition of the \yarn-4.9.1.cjs\ release file in the \.yarn/releases\ directory. This update changes the underlying package manager and its associated tooling used for dependency resolution and installation.

.yarn · high confidence

The @parcel/types package now exports types from @parcel/types-internal and re-exports them, resolving a circular dependency issue that previously affected this module.

packages/core/types · medium confidence

Add tests for eslint-plugin utility functions; Added comprehensive unit tests for the Node resolver core; Added integration tests for Babel config resolution in a monorepo; Added integration tests for Babel configuration and environment handling; Added integration tests for Parcel v2 core functionality; Added integration tests for WorkerFarm; Added integration tests for glob resolver with absolute and tilde paths; Added integration tests for shared bundle resolution; Added integration tests for symlinked monorepos; Added test fixture for malformed Parcel configuration; Added test fixtures for Parcel config resolution; Added test fixtures for config and source map handling; Added test fixtures for custom source per target; Added test fixtures for local plugin configuration; Added test fixtures for module resolution; Added test fixtures for peer dependency scenarios; Added test fixtures for pkg-a and pkg-b; Added test fixtures for self-referencing package resolution; Added test fixtures for self-source package resolution; Added test fixtures for source exports resolution; Added tests for OverlayFS delete tracking and symlink/unlink support; Added tests for WorkerFarm and CPU count detection; Added tests for default config dependencies; Added tests for diagnostic markdown escaping and JSON code highlights; Added tests for package manager resolution and utility functions; Added tests for the CLI reporter; Added tests for the Logger module; Added unit tests for ConfigRequest and DevDepRequest; Added unit tests for Disposable and ValueEmitter utilities; Added unit tests for core Parcel components; Added unit tests for core utility functions; Added unit tests for the graph package; Tests added for the no-self-package-imports ESLint rule.

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

• CAI 31 → 53 (+22.6)
• Rubric changed (rubric-2026.08.15 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 45 → 49 (+3.4)
• Architecture 63 (new)
• Maturity 57 → 59 (+2.4)
• Readiness 20 → 53 (+32.8)
• Security 34 → 63 (+28.9)
• Accessibility 64 (new)

• (anonymous) (cognitive 16) (packages/dev/repl/src/sw.js)
• (anonymous) (cognitive 16) (packages/optimizers/css/src/CSSOptimizer.js)
• (anonymous) (cognitive 16) (packages/transformers/typescript-types/src/wrappers.js)
• (anonymous) (cognitive 17) (packages/packagers/css/src/CSSPackager.js)
• (anonymous) (cognitive 172) (packages/runtimes/rsc/src/RSCRuntime.js)
• (anonymous) (cognitive 19) (packages/dev/esm-fuzzer/generateExample.js)
• (anonymous) (cognitive 19) (packages/transformers/stylus/src/StylusTransformer.js)
• (anonymous) (cognitive 20) (packages/core/utils/src/schema.js)
• (anonymous) (cognitive 33) (packages/utils/error-overlay/src/listenToRuntimeErrors.js)
• (anonymous) (cognitive 39) (packages/packagers/js/src/ScopeHoistingPackager.js)
• (anonymous) (cognitive 50) (packages/transformers/typescript-types/src/collect.js)
• (anonymous) (cognitive 74) (packages/packagers/js/src/DevPackager.js)
• (anonymous) (cognitive 77) (packages/transformers/typescript-types/src/shake.js)
• (anonymous) (cyclomatic 16) (packages/packagers/js/src/ScopeHoistingPackager.js)
• (anonymous) (cyclomatic 16) (packages/packagers/js/src/dev-prelude.js)
• (anonymous) (cyclomatic 16) (packages/transformers/typescript-types/src/wrappers.js)
• (anonymous) (cyclomatic 17) (packages/transformers/vue/src/VueTransformer.js)
• (anonymous) (cyclomatic 31) (packages/transformers/typescript-types/src/collect.js)
• (anonymous) (cyclomatic 32) (packages/packagers/js/src/DevPackager.js)
• (anonymous) (cyclomatic 47) (packages/transformers/typescript-types/src/shake.js)
• …and 159 more

• (anonymous) (cognitive 23) (packages/dev/repl/src/sw.js)
• (anonymous) (cyclomatic 16) (packages/dev/repl/src/sw.js)
• (anonymous) (cyclomatic 36) (packages/packagers/js/src/dev-prelude.js)
• (anonymous)::newRequire (cognitive 18) (packages/packagers/js/src/dev-prelude.js)
• Assertions commented out: should lossless optimise progressive JPEGs (packages/core/integration-tests/test/image.js)
• AssetGraphBuilder.build (cognitive 23) (packages/core/core/src/requests/AssetGraphRequest.js)
• AssetGraphBuilder.shouldVisitChild (cognitive 28) (packages/core/core/src/requests/AssetGraphRequest.js)
• AssetGraphBuilder.shouldVisitChild (cyclomatic 16) (packages/core/core/src/requests/AssetGraphRequest.js)
• Browsers::fmt (cognitive 27) (crates/core/src/environment.rs)
• Browsers::fmt (cyclomatic 19) (crates/core/src/environment.rs)
• CI installs an unverified third-party binary (.github/workflows/ci.yml)
• CLIReporter.writeDiagnostic (cognitive 26) (packages/reporters/cli/src/CLIReporter.js)
• CLIReporter.writeDiagnostic (cyclomatic 20) (packages/reporters/cli/src/CLIReporter.js)
• Change coupling: Parcel.js ↔ worker.js (packages/core/core/src/Parcel.js)
• Change coupling: PluginOptions.js ↔ resolveOptions.js (packages/core/core/src/public/PluginOptions.js)
• Change coupling: Transformation.js ↔ Validation.js (packages/core/core/src/Transformation.js)
• ClassTooLong: Collect (packages/transformers/js/core/src/collect.rs)
• ClassTooLong: DependencyCollector (packages/transformers/js/core/src/dependency_collector.rs)
• ClassTooLong: Hoist (packages/transformers/js/core/src/hoist.rs)
• ClassTooLong: NodeResolver (packages/utils/node-resolver-core/src/Wrapper.js)
• …and 1015 more

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

parcel-bundler/parcel 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.