{% /raw %} #### Fixed: `Script not found "..."` We fixed a bug when running `bun run` in the script of a workspace would not resolve other scripts properly. ```json#package.json { "name": "monorepo", "workspaces": ["foo"] } ``` ```json#foo/package.json { "name": "foo", "scripts": { "prepare": "bun run start", "start": "echo 'Starting...'" } } ``` Previously, `bun add` would fail with: ```sh $ bun add bar bun add ⚙️ bar [1/1] error: Script not found "start" error: prepare script from "start" exited with 1 ``` Now, `bun add` will work as expected: ```sh $ bun add bar bun add ⚙️ bar [1/1] success ``` ### Fixed: Incorrect number of `Removed` packages reported A bug in the lockfile caused Bun to report an incorrect and sometimes inconsistent number of packages removed when running `bun install/add/remove`. ### Fixed: Crash when non-existent `--cwd` is given to `bun install` A bug where `bun install --cwd=i-dont-exist` would crash with an unhelpful error message has been fixed. Big thanks to [@dylan-conway](https://github.com/dylan-conway) for fixing these issues! ### Fixed: Crash with different versions of `bun install` We fixed a crash when it was possible to run `bun install` using a newer version of Bun, then running `bun add` with an older version of Bun. ```sh # Run `bun install` using a newer version of Bun $ bun upgrade --canary $ bun install # Run `bun add` with an older version of Bun $ bun upgrade --stable $ bun add lodash ``` This has now been fixed thanks to [@dylan-conway](https://github.com/dylan-conway). ## Improved IPv4, IPv6, & VPN connectivity A longstanding issue where Bun would fail to connect due to the server only broadcasting on either IPv4 or IPv6 has been fixed. When your computer is connected to a dual-stack network, it is possible for DNS queries to return both IPv4 and IPv6 addresses. This often happened when using a VPN or connecting to `localhost`. Previously, Bun would not handle this case and would fail to connect to the socket. For the following input code: ```ts using server = Bun.serve({ hostname: "127.0.0.1", port: 0, fetch() { return new Response("👀😊👀"); } }); const response = await fetch("http://localhost:" + server.port); console.log(await response.text()); ``` Bun now outputs: ```sh ❯ bun happy-eyeballs.js # New 👀😊👀 ``` Previously, Bun would output: ```sh ❯ bun-1.1.8 happy-eyeballs.js # Old ConnectionRefused: Unable to connect. Is the computer able to access the url? path: "http://localhost:64836/" Bun v1.1.8 (macOS arm64) ``` Now, Bun implements a subset of the IETF standard ["Happy Eyeballs"](https://datatracker.ietf.org/doc/html/rfc6555) algorithm. If Bun receives multiple IP addresses for a single hostname, it will attempt to simultaneously connect to each address, then select the first successful connection. Thanks to [@gvilums](https://github.com/gvilums) for implementing this feature! ### `fetch()` gets faster DNS resolution Bun now supports asynchronous DNS resolution in `fetch()` requests. This means that `fetch()` is faster in scenarios where your operating system does not use a DNS cache, or if you are sending requests to lots of different subdomains. Bun caches these DNS records in-memory, so that they are not re-resolved every time you make a `fetch()` request. {% raw %}In the next version of Bun
— Bun (@bunjavascript) May 21, 2024
Several bugs in workspaces are fixed pic.twitter.com/uxAhJFi0nx
{% /raw %} Thanks to [@gvilums](https://github.com/gvilums) for implementing this feature! ## Asynchronous DNS & Caching Bun now automatically caches up to 255 DNS records in-memory for a maximum of 30 seconds. This reduces latency when making multiple requests to the same domain over a short period of time. This applies to: - `fetch()` requests - `node:http` requests - `node:https` requests - `Bun.connect` requests - `node:net` requests - `node:tls` requests This cache applies to both in-flight DNS requests and completed DNS requests. This means that if you make 50 `fetch()` requests to `example.com` at the same time, it will only resolve the DNS record once. If you wait 31 seconds and make another request, it will ask the operating system for the DNS record again. This is useful for Docker Containers and environments where the operating system may not have an effective DNS cache. ### New: `dns.prefetch()` API You can also use the new `dns.prefetch()` API to prefetch DNS records before they are needed. This is useful if you want to pre-warm the DNS cache on startup. ```js import { dns } from "bun"; // ...on startup dns.prefetch("example.com"); // ...later on await fetch("https://example.com/"); ``` This will prefetch the DNS record for `example.com` and make it available for use in `fetch()` requests. ### New: `dns.getCacheStats()` API To observe the DNS cache, you can use the new `dns.getCacheStats()` API. ```js import { dns } from "bun"; console.log(dns.getCacheStats()); // // { // cacheHitsCompleted: 0, // cacheHitsInflight: 0, // cacheMisses: 0, // size: 0, // errors: 0, // totalCount: 0, // } // await fetch("https://example.com/"); console.log(dns.getCacheStats()); // { // cacheHitsCompleted: 0, // cacheHitsInflight: 0, // cacheMisses: 1, // size: 1, // errors: 0, // totalCount: 1, // } ``` ### `atob()` gets 8x faster Thanks to [@lemire](https://github.com/lemire)'s [simdutf](https://github.com/lemire/simdutf) library, `atob()` is now 8x faster in Bun. {% raw %}yOu cAnT mAkE fEtCh fAsTeR pic.twitter.com/Ie8a6YM8Js
— Bun (@bunjavascript) May 18, 2024
{% /raw %} ### New: Added `bytes()` API to Web streams Bun now supports the `bytes()` property on Web streams, which returns a `Uint8Array` of the stream's data. This is available on `Request`, `Response`, `Blob`, and `Bun.file()` objects. ```js const response = await fetch("https://example.com/"); const bytes = await response.bytes(); console.log(bytes); // Uint8Array(1256) [ 60, 33, ... ] ``` `bytes()` is a recent addition to the `fetch()` standard. Thanks to [@nektro](https://github.com/nektro) for implementing this feature! ### New: `bun --no-clear-screen --watch` You can now use `bun --no-clear-screen` to disable the clearing of the screen when Bun is running in `--watch` or `--hot` mode. This is useful if you want to keep the terminal history after a file reloads. {% raw %}In the next version of Bun
— Bun (@bunjavascript) May 15, 2024
atob() gets 8x faster, thanks to @lemire's simdutf library pic.twitter.com/5iL1zrZS5d
{% /raw %} You can also configure this using the `BUN_CONFIG_NO_CLEAR_TERMINAL_ON_RELOAD` environment variable. ```sh $ BUN_CONFIG_NO_CLEAR_TERMINAL_ON_RELOAD=1 bun --watch src/index.ts ``` ### New: `expect().toHaveReturned()` matchers Bun now supports the `expect().toHaveReturned()` and `expect().toHaveReturnedTimes(n)` matchers, which are implemented by Jest. ```js import { expect } from "bun:test"; test("expect().toHaveReturned()", () => { const fn = jest.fn(() => "foo"); fn(); expect(fn).toHaveReturned(); fn(); expect(fn).toHaveReturnedTimes(2); }); ``` This has now been added thanks to [@nektro](https://github.com/nektro). ## Sourcemap improvements ### Bun now loads sourcemaps after `bun build --target=bun --sourcemap` When you build for production with `bun build --target=bun --sourcemap`, Bun will now load sourcemaps at runtime & use them to map stack traces to the original source code. ```ts ❯ bun out/sourca.js 1 | function mySource(hello: string) { 2 | throw new Error("woopsie!!"); ^ error: woopsie!! at mySource (/Users/jarred/Desktop/sourca.ts:2:9) at /Users/jarred/Desktop/sourca.ts:5:1 Bun v1.1.9 (macOS arm64) ``` Previously: ```ts ❯ bun-1.1.8 out/sourca.js 1 | // @bun 2 | // sourca.ts 3 | var mySource = function(hello) { 4 | throw new Error("woopsie!!"); ^ error: woopsie!! at mySource (/Users/jarred/Desktop/out/sourca.js:4:9) at /Users/jarred/Desktop/out/sourca.js:6:1 Bun v1.1.8 (macOS arm64) ``` Thanks to [@paperclover](https://github.com/paperclover). ### Fixed: Sourcemaps off-by-24-bytes error At runtime, Bun reserves the first 24 bytes of the internal source map buffer for metadata about the sourcemap. This behavior was only meant to occur at runtime, but it was mistakenly enabled in `bun build` too. This caused sourcemaps to be off by 24 bytes when using `bun build --target=bun --sourcemap`. This has now been fixed thanks to [@paperclover](https://github.com/paperclover). ## Bundows improvements ### Fixed: "Unexpected" reading junctions & symlinks in Windows In the module resolver code, Bun thought that junctions and symlinks were regular files instead of directories. This caused issues when using monorepos on Windows or when using the `pnpm` package manager with Bun. The following code now works as expected on Windows: ```ts import { version } from "lodash"; console.log(version); // 4.17.21 ``` Previously: ```ts error: Unexpected reading 'C:\\abcd\\node_modules\\lodash' ``` Thanks to [@paperclover](https://github.com/paperclover). ### Fixed: Loading UNC paths in Windows When a UNC path was used in various parts of Bun such as `require("\\wsl.local\\path")`, it would fail with an assertion failure about storing posix paths in Windows. This assertion failure was an internal error in Bun, and has now been fixed. This bug impacted: - `bun install` - `bun runIn the next version of Bun
— Jarred Sumner (@jarredsumner) May 15, 2024
The "--no-clear-screen" flag disables clearing the terminal on --watch or --hot
left: --hot --no-clear-screen
right: --hot pic.twitter.com/TDsTcGx7hh
{% /raw %} ### Fixed: `http.Agent` not working without `new` We fixed a bug where you could not construct an `http.Agent` without using the `new` keyword. Some older Node.js APIs, such as `http.Agent` existed before JavaScript introduced classes, and so they did not require the `new` keyword. ```js import { Agent } from "node:http"; const agent = Agent(); ``` This has now been fixed thanks to [@nektro](https://github.com/nektro). ### Fixed: `newListener` event is emitted in correct order We fixed an issue where the `newListener` event was being emitted in the wrong order, which could cause issues with some libraries. Previously, the `newListener` event was emitted _after_ the listener was added, but now it is emitted _before_ the listener is added. ```js import { expect, mock } from "bun:test"; import { Stream } from "node:stream"; test("newListener event is emitted in correct order", () => { const stream = new Stream(); const cb = mock((event) => { expect(stream.listenerCount(event)).toBe(0); }); stream.on("newListener", cb); stream.on("foo", () => {}); expect(cb).toHaveBeenCalled(); }); ``` ### Fixed: Improved argument parsing in `net.connect()` We fixed various bugs where the argument parsing in `net.connect()` would not match the behavior of Node.js. For example, when a `port` and `host` are provided, or only an `options` object is provided, the `port` and `host` arguments would be ignored. ```js import { connect } from "node:net"; const socket = connect({ port: 443, host: "localhost", rejectUnauthorized: false, }); socket.on("secureConnect", () => { console.log("Connected!"); socket.end(); }); ``` ### Fixed: Promisified `child_process.execFile()` returned wrong value We fixed a bug where the `execFile()` function was not returning the correct value when using the `util.promisify()` function. ```js import { execFile } from "node:child_process"; import util from "node:util"; const execFileAsync = util.promisify(execFile); const result = await execFileAsync("ls"); console.log(result); // Before: 'src\n' // After: { stdout: 'src\n', stderr: '' } ``` ### Fixed: Crash using `which` with long path We fixed a bug where `Bun.which()` would crash when given a long path. Instead of crashing, it now throws an error: `bin path is too long`. ```js import { which } from "bun"; which("a".repeat(100000)); // Before:The fast JavaScript runtime Bun is going to get 5x faster base64 encoding (`toString("base64url")`).https://t.co/BO4PDSOgkS
— Daniel Lemire (@lemire) May 15, 2024
work by @jarredsumner
Relies on the simdutf library https://t.co/8L5xwdvzKs
Node.js already relies on simdutf for these tasks.