Rolldown Bug: JSON Array Methods Become `void 0`

Nov 21, 2025 by Alex Johnson 49 views

Rolldown Bug: JSON Array Methods Incorrectly Transformed to `void 0`

Introduction

In the realm of modern JavaScript development, bundlers play a crucial role in optimizing and packaging code for deployment. Rolldown, a rising star in this domain, aims to provide a fast and efficient bundling solution. However, like any software, it's not immune to bugs. This article delves into a peculiar issue encountered with Rolldown where JSON array methods are incorrectly transformed to void 0, leading to unexpected behavior. Understanding the root cause of this issue is paramount for developers relying on Rolldown for their projects. The transformation of JSON array methods to void 0 can lead to significant problems in applications that rely on these methods for data manipulation. Therefore, a thorough investigation and a clear understanding of the bug are essential for the Rolldown community. This article not only highlights the problem but also provides a detailed analysis, including reproduction steps, expected behavior, actual results, and system information. By presenting a comprehensive view of the issue, it aims to assist both developers and the Rolldown team in identifying and resolving the bug effectively.

The Problem: JSON Array Methods Becoming `void 0`

The core issue lies in how Rolldown handles JSON files that use an array as the top-level structure. When importing such JSON files into TypeScript and attempting to use array methods like flatMap, Rolldown incorrectly transforms these methods to void 0. This leads to runtime errors and unexpected behavior, as the intended array methods are no longer available. This bug specifically affects how Rolldown processes JSON files that serve as data sources for applications. When array methods are transformed to void 0, the application's ability to process and manipulate data is severely hampered. This can result in broken features, incorrect data rendering, and overall application instability. The impact of this bug extends to various use cases, including data fetching, configuration loading, and any scenario where JSON arrays are used as primary data structures. Therefore, understanding the scope and implications of this issue is crucial for developers who rely on Rolldown for their projects.

Reproducing the Bug

To illustrate the issue, consider a simple JSON file (data.json) with an array as its top level:

[
  {
    "name": "Tom"
  }
]

This JSON file is then imported into a TypeScript file (index.ts):

// index.ts
import data from "./data.json";

const processed1 = [...data];
const processed2 = [...data.flatMap((c) => Object.values(c))];

console.log(processed1, processed2);

export { processed1, processed2 };

The expectation is that data.flatMap should function correctly. However, when bundled with Rolldown, it gets transformed to void 0. To reproduce this bug, you can follow these steps:

Create a new project directory.
Initialize a new npm project: npm init -y.
Install Rolldown: npm install rolldown --save-dev.
Create data.json and index.ts files with the content provided above.
Run Rolldown: npx rolldown -c.
Observe the warning and the generated output in the dist/index.js file.

The warning message [IMPORT_IS_UNDEFINED] Warning: Import latMap\] will always be undefined because there is no matching export in 'src/data.json' clearly indicates the issue. The generated JavaScript code will show that data.flatMap has been replaced with void 0, confirming the bug. This reproducible scenario allows developers and the Rolldown team to consistently observe and analyze the bug, making it easier to identify the root cause and develop a solution. By providing a clear and concise set of steps, this guide ensures that anyone can replicate the issue and contribute to its resolution. The ability to reproduce a bug is a crucial step in the debugging process, as it allows for controlled experimentation and validation of potential fixes.

Expected vs. Actual Behavior

The expected behavior is that data.flatMap should remain a valid method call on the imported JSON array. The output JavaScript should look something like this:

// dist/index.js
//#region src/data.json
var data_default = [{ "name": "Tom" }];

//#endregion
//#region src/index.ts
const processed1 = [...data_default];
const processed2 = [...data_default.flatMap((c) => Object.values(c))];
console.log(processed1, processed2);

//#endregion
export { processed1, processed2 };

However, the actual behavior is that Rolldown transforms data.flatMap to void 0, resulting in the following output:

// dist/index.js
//#region src/data.json
var data_default = [{ "name": "Tom" }];

//#endregion
//#region src/index.ts
const processed1 = [...data_default];
const processed2 = [...(void 0)((c) => Object.values(c))];
console.log(processed1, processed2);

//#endregion
export { processed1, processed2 };

This transformation leads to a runtime error because void 0 is not a function, and attempting to call it as such will result in a TypeError. The discrepancy between the expected and actual behavior highlights the severity of the bug. Developers relying on Rolldown to correctly bundle their code will encounter unexpected errors and application failures when this transformation occurs. The incorrect transformation not only breaks the functionality of array methods but also introduces a significant debugging challenge. The void 0 error message can be misleading, making it difficult for developers to trace the issue back to the Rolldown transformation. Therefore, understanding the specific behavior of this bug is crucial for developers to effectively diagnose and work around the problem until a permanent fix is available.

System Information

The bug has been observed on the following system:

System:
    OS: Windows 11 10.0.26100
    CPU: (8) x64 11th Gen Intel(R) Core(TM) i5-1135G7 @ 2.40GHz
    Memory: 1.94 GB / 15.79 GB
Binaries:
    Node: 24.11.1 - C:\Program Files\nodejs\node.EXE
    Yarn: 1.22.21 - C:\Program Files\nodejs\yarn.CMD
    npm: 11.6.2 - C:\Program Files\nodejs\npm.CMD
    pnpm: 10.20.0 - C:\Users\northword\AppData\Roaming\npm\pnpm.CMD
Browsers:
    Chrome: 142.0.7444.176
    Edge: Chromium (140.0.3485.54)
    Firefox: 143.0.1 - C:\Program Files\Mozilla Firefox\firefox.exe
    Internet Explorer: 11.0.26100.1882
npmPackages:
    rolldown: 1.0.0-beta.51 => 1.0.0-beta.51

This information is crucial for the Rolldown team to understand the environment in which the bug occurs. It includes details about the operating system, CPU, memory, Node.js version, package managers, browsers, and the Rolldown version. This comprehensive system information helps narrow down potential causes of the bug and ensures that the fix is compatible with a wide range of environments. The specific versions of Node.js, npm, Yarn, and pnpm are particularly important, as they can influence the behavior of JavaScript bundlers. Similarly, the operating system and CPU architecture can play a role in how the code is processed and optimized. By providing this detailed system information, developers can assist the Rolldown team in identifying any environment-specific issues that may be contributing to the bug. This collaborative approach ensures that the bug is addressed effectively and that the fix is robust and reliable across different systems.

Additional Context

It's worth noting that other bundlers like esbuild handle this situation correctly. Running tsx src/index.ts also outputs the expected value normally, indicating that the syntax itself is valid. This comparison highlights that the issue is specific to Rolldown's handling of JSON array methods in this context. The fact that esbuild and tsx can correctly process the code suggests that the underlying JavaScript and TypeScript syntax is not the issue. Instead, the problem likely lies within Rolldown's transformation or optimization steps. This information is valuable for the Rolldown team, as it helps them focus their attention on the specific areas of the bundler that are responsible for handling JSON imports and array methods. By comparing Rolldown's behavior with other tools, developers can gain a better understanding of the bug and its potential impact. This comparative analysis also underscores the importance of thorough testing and validation in the development of bundlers, ensuring that they correctly handle a wide range of scenarios and code patterns.

Conclusion

The bug where Rolldown incorrectly transforms JSON array methods to void 0 is a significant issue that can impact applications relying on JSON data. Understanding the reproduction steps, expected vs. actual behavior, and system information is crucial for both developers and the Rolldown team. Addressing this bug will enhance Rolldown's reliability and usability. The transformation of JSON array methods to void 0 can lead to unexpected errors and application instability, making it essential to address this bug promptly. By providing a detailed analysis of the issue, this article aims to assist the Rolldown team in identifying the root cause and developing an effective solution. The collaborative effort between developers and the Rolldown team is crucial in ensuring that the bundler remains a reliable and efficient tool for modern JavaScript development. Further investigation and testing are necessary to fully understand the scope of the bug and to prevent similar issues from occurring in the future. The Rolldown community's involvement in reporting and reproducing bugs is invaluable in maintaining the quality and stability of the bundler.

For more information on Rolldown and its capabilities, visit the official Rolldown GitHub repository.