Fix tinycc

Co-authored-by: Jarred-Sumner <Jarred-Sumner@users.noreply.github.com>

.buildkite/bootstrap.yml

@@ -0,0 +1,30 @@
+# Uploads the latest CI workflow to Buildkite.
+# https://buildkite.com/docs/pipelines/defining-steps
+#
+# Changes to this file must be manually edited here:
+# https://buildkite.com/bun/bun/settings/steps
+steps:
+  - if: "build.pull_request.repository.fork"
+    block: ":eyes:"
+    prompt: "Did you review the PR?"
+    blocked_state: "running"
+
+  - label: ":pipeline:"
+    command: "buildkite-agent pipeline upload .buildkite/ci.yml"
+    agents:
+      queue: "build-linux"
+
+  - if: "build.branch == 'main' && !build.pull_request.repository.fork"
+    label: ":github:"
+    agents:
+      queue: "test-darwin"
+    depends_on:
+      - "darwin-aarch64-build-bun"
+      - "darwin-x64-build-bun"
+      - "linux-aarch64-build-bun"
+      - "linux-x64-build-bun"
+      - "linux-x64-baseline-build-bun"
+      - "windows-x64-build-bun"
+      - "windows-x64-baseline-build-bun"
+    command:
+      - ".buildkite/scripts/upload-release.sh"

.buildkite/ci.md

@@ -0,0 +1,63 @@
+## CI
+
+How does CI work?
+
+### Building
+
+Bun is built on macOS, Linux, and Windows. The process is split into the following steps, the first 3 of which are able to run in parallel:
+
+#### 1. `build-deps`
+
+Builds the static libaries in `src/deps` and outputs a directory: `build/bun-deps`.
+
+- on Windows, this runs the script: [`scripts/all-dependencies.ps1`](scripts/all-dependencies.ps1)
+- on macOS and Linux, this runs the script: [`scripts/all-dependencies.sh`](scripts/all-dependencies.sh)
+
+#### 2. `build-zig`
+
+Builds the Zig object file: `build/bun-zig.o`. Since `zig build` supports cross-compiling, this step is run on macOS aarch64 since we have observed it to be the fastest.
+
+- on macOS and Linux, this runs the script: [`scripts/build-bun-zig.sh`](scripts/build-bun-zig.sh)
+
+#### 3. `build-cpp`
+
+Builds the C++ object file: `build/bun-cpp-objects.a`.
+
+- on Windows, this runs the script: [`scripts/build-bun-cpp.ps1`](scripts/build-bun-cpp.ps1)
+- on macOS and Linux, this runs the script: [`scripts/build-bun-cpp.sh`](scripts/build-bun-cpp.sh)
+
+#### 4. `link` / `build-bun`
+
+After the `build-deps`, `build-zig`, and `build-cpp` steps have completed, this step links the Zig object file and C++ object file into a single binary: `bun-<os>-<arch>.zip`.
+
+- on Windows, this runs the script: [`scripts/buildkite-link-bun.ps1`](scripts/buildkite-link-bun.ps1)
+- on macOS and Linux, this runs the script: [`scripts/buildkite-link-bun.sh`](scripts/buildkite-link-bun.sh)
+
+To speed up the build, thare are two options:
+
+- `--fast`: This disables the LTO (link-time optimization) step.
+- without `--fast`: This runs the LTO step, which is the default. The binaries that are release to Github are always built with LTO.
+
+### Testing
+
+### FAQ
+
+> How do I add a new CI agent?
+
+> How do I add/modify system dependencies?
+
+> How do I SSH into a CI agent?
+
+### Known issues
+
+These are things that we know about, but haven't fixed or optimized yet.
+
+- There is no `scripts/build-bun-zig.ps1` for Windows.
+
+- The `build-deps` step does not cache in CI, so it re-builds each time (though it does use ccache). It attempts to check the `BUN_DEPS_CACHE_DIR` environment variable, but for some reason it doesn't work.
+
+- Windows and Linux machines sometimes take up to 1-2 minutes to start tests. This is because robobun is listening for when the job is scheduled to provision the VM. Instead, it can start provisioning during the link step, or keep a pool of idle VMs around (but it's unclear how more expensive this is).
+
+- There are a limited number of macOS VMs. This is because they are expensive and manually provisioned, mostly through MacStadium. If wait times are too long we can just provision more, or buy some.
+
+- To prevent idle machines, robobun periodically checks for idle machines and terminates them. Before doing this, it checks to see if the machine is connected as an agent to Buildkite. However, sometimes the machine picks up a job in-between this time, and the job is terminated.

.buildkite/scripts/upload-release.sh

@@ -0,0 +1,94 @@
+#!/bin/bash
+
+set -eo pipefail
+
+function assert_main() {
+  if [[ "$BUILDKITE_PULL_REQUEST_REPO" && "$BUILDKITE_REPO" != "$BUILDKITE_PULL_REQUEST_REPO" ]]; then
+    echo "error: Cannot upload release from a fork"
+    exit 1
+  fi
+  if [ "$BUILDKITE_PULL_REQUEST" != "false" ]; then
+    echo "error: Cannot upload release from a pull request"
+    exit 1
+  fi
+  if [ "$BUILDKITE_BRANCH" != "main" ]; then
+    echo "error: Cannot upload release from a branch other than main"
+    exit 1
+  fi
+}
+
+function assert_buildkite_agent() {
+  if ! command -v buildkite-agent &> /dev/null; then
+    echo "error: Cannot find buildkite-agent, please install it:"
+    echo "https://buildkite.com/docs/agent/v3/install"
+    exit 1
+  fi
+}
+
+function assert_gh() {
+  if ! command -v gh &> /dev/null; then
+    echo "warning: gh is not installed, installing..."
+    if command -v brew &> /dev/null; then
+      brew install gh
+    else
+      echo "error: Cannot install gh, please install it:"
+      echo "https://github.com/cli/cli#installation"
+      exit 1
+    fi
+  fi
+}
+
+function assert_gh_token() {
+  local token=$(buildkite-agent secret get GITHUB_TOKEN)
+  if [ -z "$token" ]; then
+    echo "error: Cannot find GITHUB_TOKEN secret"
+    echo ""
+    echo "hint: Create a secret named GITHUB_TOKEN with a GitHub access token:"
+    echo "https://buildkite.com/docs/pipelines/buildkite-secrets"
+    exit 1
+  fi
+  export GH_TOKEN="$token"
+}
+
+function download_artifact() {
+  local name=$1
+  buildkite-agent artifact download "$name" .
+  if [ ! -f "$name" ]; then
+    echo "error: Cannot find Buildkite artifact: $name"
+    exit 1
+  fi
+}
+
+function upload_assets() {
+  local tag=$1
+  local files=${@:2}
+  gh release upload "$tag" $files --clobber --repo "$BUILDKITE_REPO"
+}
+
+assert_main
+assert_buildkite_agent
+assert_gh
+assert_gh_token
+
+declare artifacts=(
+  bun-darwin-aarch64.zip
+  bun-darwin-aarch64-profile.zip
+  bun-darwin-x64.zip
+  bun-darwin-x64-profile.zip
+  bun-linux-aarch64.zip
+  bun-linux-aarch64-profile.zip
+  bun-linux-x64.zip
+  bun-linux-x64-profile.zip
+  bun-linux-x64-baseline.zip
+  bun-linux-x64-baseline-profile.zip
+  bun-windows-x64.zip
+  bun-windows-x64-profile.zip
+  bun-windows-x64-baseline.zip
+  bun-windows-x64-baseline-profile.zip
+)
+
+for artifact in "${artifacts[@]}"; do
+  download_artifact $artifact
+done
+
+upload_assets "canary" "${artifacts[@]}"

.github/ISSUE_TEMPLATE/2-bug-report.yml

@@ -1,6 +1,8 @@
 name: 🐛 Bug Report
 description: Report an issue that should be fixed
-labels: [bug]
+labels:
+  - bug
+  - needs triage
 body:
   - type: markdown
     attributes:

.github/ISSUE_TEMPLATE/6-crash-report.yml

@@ -1,17 +1,17 @@
 name: Prefilled crash report
 description: Report a crash in Bun
 labels:
-  - bug
   - crash
 body:
   - type: markdown
     attributes:
       value: |
-        Thank you for submitting a crash report. It helps make Bun better.
+        **Thank you so much** for submitting a crash report. You're helping us make Bun more reliable for everyone!
   - type: textarea
+    id: code
     attributes:
       label: How can we reproduce the crash?
-      description: Please provide instructions on how to reproduce the crash.
+      description: Please provide a [minimal reproduction](https://stackoverflow.com/help/minimal-reproducible-example) using a GitHub repository, [Replit](https://replit.com/@replit/Bun) or [CodeSandbox](https://codesandbox.io/templates/bun)
   - type: textarea
     id: logs
     attributes:

.github/ISSUE_TEMPLATE/7-install-crash-report.yml

@@ -0,0 +1,27 @@
+name: bun install crash report
+description: Report a crash in bun install
+labels:
+  - npm
+body:
+  - type: markdown
+    attributes:
+      value: |
+        **Thank you so much** for submitting a crash report. You're helping us make Bun more reliable for everyone!
+  - type: textarea
+    id: repro
+    attributes:
+      label: How can we reproduce the crash?
+      description: Please provide a [minimal reproduction](https://stackoverflow.com/help/minimal-reproducible-example) using a GitHub repository, [Replit](https://replit.com/@replit/Bun) or [CodeSandbox](https://codesandbox.io/templates/bun)
+  - type: textarea
+    id: logs
+    attributes:
+      label: Relevant log output
+      description: Please copy and paste any relevant log output. This will be
+        automatically formatted into code, so no need for backticks.
+      render: shell
+  - type: textarea
+    id: remapped_trace
+    attributes:
+      label: Stack Trace (bun.report)
+    validations:
+      required: true

.github/actions/bump/action.yml

@@ -0,0 +1,43 @@
+name: Bump version
+description: Bump the version of Bun
+
+inputs:
+  version:
+    description: The most recent version of Bun.
+    required: true
+    type: string
+  token:
+    description: The GitHub token to use for creating a pull request.
+    required: true
+    type: string
+    default: ${{ github.token }}
+
+runs:
+  using: composite
+  steps:
+    - name: Run Bump
+      shell: bash
+      id: bump
+      run: |
+        set -euo pipefail
+        MESSAGE=$(bun ./scripts/bump.ts patch --last-version=${{ inputs.version }})
+        LATEST=$(cat LATEST)
+        echo "version=$LATEST" >> $GITHUB_OUTPUT
+        echo "message=$MESSAGE" >> $GITHUB_OUTPUT
+    - name: Create Pull Request
+      uses: peter-evans/create-pull-request@v4
+      with:
+        add-paths: |
+          CMakeLists.txt
+          LATEST
+        token: ${{ inputs.token }}
+        commit-message: Bump version to ${{ steps.bump.outputs.version }}
+        title: Bump to ${{ steps.bump.outputs.version }}
+        delete-branch: true
+        branch: github-actions/bump-version-${{ steps.bump.outputs.version }}--${{ github.run_id }}
+        body: |
+          ## What does this PR do?
+
+          ${{ steps.bump.outputs.message }}
+
+          Auto-bumped by [this workflow](https://github.com/oven-sh/bun/actions/workflows/release.yml)

.github/workflows/build-darwin.yml

@@ -9,7 +9,7 @@ on:
     inputs:
       runs-on:
         type: string
-        default: macos-12-large
+        default: macos-13-large
       tag:
         type: string
         required: true
@@ -27,8 +27,12 @@ on:
         type: boolean
 
 env:
-  LLVM_VERSION: 16
-  BUN_VERSION: 1.1.2
+  LLVM_VERSION: 18
+  BUN_VERSION: 1.1.8
+  LC_CTYPE: "en_US.UTF-8"
+  LC_ALL: "en_US.UTF-8"
+  # LTO is disabled because we cannot use lld on macOS currently
+  BUN_ENABLE_LTO: "0"
 
 jobs:
   build-submodules:
@@ -51,16 +55,7 @@ jobs:
             cat $(echo scripts/build*.sh scripts/all-dependencies.sh | tr " " "\n" | sort)
           }
           echo "hash=$(print_versions | shasum)" >> $GITHUB_OUTPUT
-      - if: ${{ !inputs.no-cache }}
-        name: Restore Cache
-        id: cache
-        uses: actions/cache/restore@v4
-        with:
-          path: ${{ runner.temp }}/bun-deps
-          key: bun-${{ inputs.tag }}-deps-${{ steps.hash.outputs.hash }}
-      # TODO: Figure out how to cache homebrew dependencies
-      - if: ${{ inputs.no-cache || !steps.cache.outputs.cache-hit }}
-        name: Install Dependencies
+      - name: Install Dependencies
         env:
           HOMEBREW_NO_INSTALLED_DEPENDENTS_CHECK: 1
           HOMEBREW_NO_AUTO_UPDATE: 1
@@ -78,29 +73,22 @@ jobs:
             automake \
             openssl@1.1 \
             ninja \
-            gnu-sed --force
+            golang \
+            gnu-sed --force --overwrite
           echo "$(brew --prefix ccache)/bin" >> $GITHUB_PATH
           echo "$(brew --prefix coreutils)/libexec/gnubin" >> $GITHUB_PATH
           echo "$(brew --prefix llvm@$LLVM_VERSION)/bin" >> $GITHUB_PATH
           brew link --overwrite llvm@$LLVM_VERSION
-      - if: ${{ inputs.no-cache || !steps.cache.outputs.cache-hit }}
-        name: Clone Submodules
+      - name: Clone Submodules
         run: |
           ./scripts/update-submodules.sh
       - name: Build Submodules
-        if: ${{ inputs.no-cache || !steps.cache.outputs.cache-hit }}
         env:
           CPU_TARGET: ${{ inputs.cpu }}
           BUN_DEPS_OUT_DIR: ${{ runner.temp }}/bun-deps
         run: |
           mkdir -p $BUN_DEPS_OUT_DIR
           ./scripts/all-dependencies.sh
-      - name: Save Cache
-        if: ${{ inputs.no-cache || !steps.cache.outputs.cache-hit }}
-        uses: actions/cache/save@v4
-        with:
-          path: ${{ runner.temp }}/bun-deps
-          key: ${{ steps.cache.outputs.cache-primary-key }}
       - name: Upload bun-${{ inputs.tag }}-deps
         uses: actions/upload-artifact@v4
         with:
@@ -134,7 +122,8 @@ jobs:
             automake \
             openssl@1.1 \
             ninja \
-            gnu-sed --force
+            golang \
+            gnu-sed --force --overwrite
           echo "$(brew --prefix ccache)/bin" >> $GITHUB_PATH
           echo "$(brew --prefix coreutils)/libexec/gnubin" >> $GITHUB_PATH
           echo "$(brew --prefix llvm@$LLVM_VERSION)/bin" >> $GITHUB_PATH
@@ -143,14 +132,6 @@ jobs:
         uses: ./.github/actions/setup-bun
         with:
           bun-version: ${{ env.BUN_VERSION }}
-      - if: ${{ !inputs.no-cache }}
-        name: Restore Cache
-        uses: actions/cache@v4
-        with:
-          path: ${{ runner.temp }}/ccache
-          key: bun-${{ inputs.tag }}-cpp-${{ hashFiles('Dockerfile', 'Makefile', 'CMakeLists.txt', 'build.zig', 'scripts/**', 'src/**', 'packages/bun-usockets/src/**', 'packages/bun-uws/src/**') }}
-          restore-keys: |
-            bun-${{ inputs.tag }}-cpp-
       - name: Compile
         env:
           CPU_TARGET: ${{ inputs.cpu }}
@@ -215,7 +196,8 @@ jobs:
             automake \
             openssl@1.1 \
             ninja \
-            gnu-sed --force
+            golang \
+            gnu-sed --force --overwrite
           echo "$(brew --prefix ccache)/bin" >> $GITHUB_PATH
           echo "$(brew --prefix coreutils)/libexec/gnubin" >> $GITHUB_PATH
           echo "$(brew --prefix llvm@$LLVM_VERSION)/bin" >> $GITHUB_PATH
@@ -239,18 +221,9 @@ jobs:
         with:
           name: bun-${{ inputs.tag }}-zig
           path: ${{ runner.temp }}/release
-      - if: ${{ !inputs.no-cache }}
-        name: Restore Cache
-        uses: actions/cache@v4
-        with:
-          path: ${{ runner.temp }}/ccache
-          key: bun-${{ inputs.tag }}-cpp-${{ hashFiles('Dockerfile', 'Makefile', 'CMakeLists.txt', 'build.zig', 'scripts/**', 'src/**', 'packages/bun-usockets/src/**', 'packages/bun-uws/src/**') }}
-          restore-keys: |
-            bun-${{ inputs.tag }}-cpp-
       - name: Link
         env:
           CPU_TARGET: ${{ inputs.cpu }}
-          CCACHE_DIR: ${{ runner.temp }}/ccache
         run: |
           SRC_DIR=$PWD
           mkdir ${{ runner.temp }}/link-build
@@ -260,7 +233,7 @@ jobs:
             -DCMAKE_BUILD_TYPE=Release \
             -DUSE_LTO=ON \
             -DBUN_LINK_ONLY=1 \
-            -DBUN_ZIG_OBJ="${{ runner.temp }}/release/bun-zig.o" \
+            -DBUN_ZIG_OBJ_DIR="${{ runner.temp }}/release" \
             -DBUN_CPP_ARCHIVE="${{ runner.temp }}/bun-cpp-obj/bun-cpp-objects.a" \
             -DBUN_DEPS_OUT_DIR="${{ runner.temp }}/bun-deps" \
             -DNO_CONFIGURE_DEPENDS=1
@@ -271,6 +244,12 @@ jobs:
           chmod +x bun-profile bun
           mkdir -p bun-${{ inputs.tag }}-profile/ bun-${{ inputs.tag }}/
           mv bun-profile bun-${{ inputs.tag }}-profile/bun-profile
+          if [ -f bun-profile.dSYM || -d bun-profile.dSYM ]; then
+            mv bun-profile.dSYM bun-${{ inputs.tag }}-profile/bun-profile.dSYM
+          fi
+          if [ -f bun.dSYM || -d bun.dSYM ]; then
+            mv bun.dSYM bun-${{ inputs.tag }}-profile/bun-profile.dSYM
+          fi
           mv bun bun-${{ inputs.tag }}/bun
           zip -r bun-${{ inputs.tag }}-profile.zip bun-${{ inputs.tag }}-profile
           zip -r bun-${{ inputs.tag }}.zip bun-${{ inputs.tag }}
@@ -304,4 +283,4 @@ jobs:
 
             @${{ github.actor }}, the build for bun-${{ inputs.tag }} failed.
 
-            **[View logs](${{ github.event.workflow_run.html_url }})**
+            **[View logs](https://github.com/${{ github.repository }}/actions/runs/${{ github.run_id }})**

.github/workflows/build-linux.yml

@@ -61,4 +61,4 @@ jobs:
 
             @${{ github.actor }}, the build for bun-${{ inputs.tag }} failed.
 
-            **[View logs](${{ github.event.workflow_run.html_url }})**
+            **[View logs](https://github.com/${{ github.repository }}/actions/runs/${{ github.run_id }})**

.github/workflows/build-windows.yml

@@ -9,7 +9,7 @@ on:
     inputs:
       runs-on:
         type: string
-        default: windows-latest
+        default: windows
       tag:
         type: string
         required: true
@@ -25,17 +25,29 @@ on:
         type: boolean
       no-cache:
         type: boolean
+      bun-version:
+        type: string
+        default: 1.1.7
 
 env:
   # Must specify exact version of LLVM for Windows
-  LLVM_VERSION: 16.0.6
-  BUN_VERSION: 1.1.2
+  LLVM_VERSION: 18.1.8
+  BUN_VERSION: ${{ inputs.bun-version }}
+  BUN_GARBAGE_COLLECTOR_LEVEL: 1
+  BUN_FEATURE_FLAG_INTERNAL_FOR_TESTING: 1
+  CI: true
+  USE_LTO: 1
 
 jobs:
   build-submodules:
     name: Build Submodules
     runs-on: ${{ inputs.runs-on }}
     steps:
+      - name: Install Scoop
+        run: |
+          Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser
+          Invoke-RestMethod -Uri https://get.scoop.sh | Invoke-Expression
+          Join-Path (Resolve-Path ~).Path "scoop\shims" >> $Env:GITHUB_PATH
       - name: Setup Git
         run: |
           git config --global core.autocrlf false
@@ -66,14 +78,11 @@ jobs:
           path: bun-deps
           key: bun-${{ inputs.tag }}-deps-${{ steps.hash.outputs.hash }}
       - if: ${{ inputs.no-cache || !steps.cache.outputs.cache-hit }}
-        name: Install LLVM
-        uses: KyleMayes/install-llvm-action@1a3da29f56261a1e1f937ec88f0856a9b8321d7e
-        with:
-          version: ${{ env.LLVM_VERSION }}
-      - if: ${{ inputs.no-cache || !steps.cache.outputs.cache-hit }}
-        name: Install Ninja
+        name: Install LLVM and Ninja
         run: |
-          choco install -y ninja
+          scoop install ninja
+          scoop install llvm@${{ env.LLVM_VERSION }}
+          scoop install nasm@2.16.01
       - if: ${{ inputs.no-cache || !steps.cache.outputs.cache-hit }}
         name: Clone Submodules
         run: |
@@ -83,12 +92,9 @@ jobs:
         env:
           CPU_TARGET: ${{ inputs.cpu }}
           CCACHE_DIR: ccache
+          USE_LTO: 1
         run: |
           .\scripts\env.ps1 ${{ contains(inputs.tag, '-baseline') && '-Baseline' || '' }}
-          Invoke-WebRequest -Uri "https://www.nasm.us/pub/nasm/releasebuilds/2.16.01/win64/nasm-2.16.01-win64.zip" -OutFile nasm.zip
-          Expand-Archive nasm.zip (mkdir -Force "nasm")
-          $Nasm = (Get-ChildItem "nasm")
-          $env:Path += ";${Nasm}"
           $env:BUN_DEPS_OUT_DIR = (mkdir -Force "./bun-deps")
           .\scripts\all-dependencies.ps1
       - name: Save Cache
@@ -116,7 +122,7 @@ jobs:
       - name: Setup Bun
         uses: ./.github/actions/setup-bun
         with:
-          bun-version: ${{ env.BUN_VERSION }}
+          bun-version: ${{ inputs.bun-version }}
       - name: Codegen
         run: |
           ./scripts/cross-compile-codegen.sh win32 x64
@@ -136,6 +142,11 @@ jobs:
     needs: codegen
     runs-on: ${{ inputs.runs-on }}
     steps:
+      - name: Install Scoop
+        run: |
+          Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser
+          Invoke-RestMethod -Uri https://get.scoop.sh | Invoke-Expression
+          Join-Path (Resolve-Path ~).Path "scoop\shims" >> $Env:GITHUB_PATH
       - name: Setup Git
         run: |
           git config --global core.autocrlf false
@@ -144,17 +155,14 @@ jobs:
         uses: actions/checkout@v4
         with:
           submodules: recursive
-      - name: Install LLVM
-        uses: KyleMayes/install-llvm-action@1a3da29f56261a1e1f937ec88f0856a9b8321d7e
-        with:
-          version: ${{ env.LLVM_VERSION }}
-      - name: Install Ninja
+      - name: Install LLVM and Ninja
         run: |
-          choco install -y ninja
+          scoop install ninja
+          scoop install llvm@${{ env.LLVM_VERSION }}
       - name: Setup Bun
         uses: ./.github/actions/setup-bun
         with:
-          bun-version: ${{ env.BUN_VERSION }}
+          bun-version: ${{ inputs.bun-version }}
       - if: ${{ !inputs.no-cache }}
         name: Restore Cache
         uses: actions/cache@v4
@@ -172,6 +180,7 @@ jobs:
         env:
           CPU_TARGET: ${{ inputs.cpu }}
           CCACHE_DIR: ccache
+          USE_LTO: 1
         run: |
           # $CANARY_REVISION = if (Test-Path build/.canary_revision) { Get-Content build/.canary_revision } else { "0" }
           $CANARY_REVISION = 0
@@ -181,6 +190,7 @@ jobs:
           cd build
           cmake .. -G Ninja -DCMAKE_BUILD_TYPE=Release `
             -DNO_CODEGEN=1 `
+            -DUSE_LTO=1 `
             -DNO_CONFIGURE_DEPENDS=1 `
             "-DCANARY=${CANARY_REVISION}" `
             -DBUN_CPP_ONLY=1 ${{ contains(inputs.tag, '-baseline') && '-DUSE_BASELINE_BUILD=1' || '' }}
@@ -215,6 +225,11 @@ jobs:
       - build-zig
       - codegen
     steps:
+      - name: Install Scoop
+        run: |
+          Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser
+          Invoke-RestMethod -Uri https://get.scoop.sh | Invoke-Expression
+          Join-Path (Resolve-Path ~).Path "scoop\shims" >> $Env:GITHUB_PATH
       - name: Setup Git
         run: |
           git config --global core.autocrlf false
@@ -223,17 +238,14 @@ jobs:
         uses: actions/checkout@v4
         with:
           submodules: recursive
-      - name: Install LLVM
-        uses: KyleMayes/install-llvm-action@1a3da29f56261a1e1f937ec88f0856a9b8321d7e
-        with:
-          version: ${{ env.LLVM_VERSION }}
       - name: Install Ninja
         run: |
-          choco install -y ninja
+          scoop install ninja
+          scoop install llvm@${{ env.LLVM_VERSION }}
       - name: Setup Bun
         uses: ./.github/actions/setup-bun
         with:
-          bun-version: ${{ env.BUN_VERSION }}
+          bun-version: ${{ inputs.bun-version }}
       - name: Download bun-${{ inputs.tag }}-deps
         uses: actions/download-artifact@v4
         with:
@@ -277,9 +289,10 @@ jobs:
             -DNO_CONFIGURE_DEPENDS=1 `
             "-DCANARY=${CANARY_REVISION}" `
             -DBUN_LINK_ONLY=1 `
+            -DUSE_LTO=1 `
             "-DBUN_DEPS_OUT_DIR=$(Resolve-Path ../bun-deps)" `
             "-DBUN_CPP_ARCHIVE=$(Resolve-Path ../bun-cpp/bun-cpp-objects.a)" `
-            "-DBUN_ZIG_OBJ=$(Resolve-Path ../bun-zig/bun-zig.o)" `
+            "-DBUN_ZIG_OBJ_DIR=$(Resolve-Path ../bun-zig)" `
             ${{ contains(inputs.tag, '-baseline') && '-DUSE_BASELINE_BUILD=1' || '' }}
           if ($LASTEXITCODE -ne 0) { throw "CMake configuration failed" }
           ninja -v
@@ -294,6 +307,7 @@ jobs:
           cp -r build\bun.exe "$Dist\bun.exe"
           cp -r build\bun.pdb "$Dist\bun.pdb"
           Compress-Archive -Force "$Dist" "$Dist.zip"
+          .\build\bun.exe --print "JSON.stringify(require('bun:internal-for-testing').crash_handler.getFeatureData())" > .\features.json
       - name: Upload bun-${{ inputs.tag }}
         uses: actions/upload-artifact@v4
         with:
@@ -306,6 +320,13 @@ jobs:
           name: bun-${{ inputs.tag }}-profile
           path: bun-${{ inputs.tag }}-profile.zip
           if-no-files-found: error
+      - name: Upload bun-feature-data
+        uses: actions/upload-artifact@v4
+        with:
+          name: bun-feature-data
+          path: features.json
+          if-no-files-found: error
+          overwrite: true
   on-failure:
     if: ${{ github.repository_owner == 'oven-sh' && failure() }}
     name: On Failure
@@ -324,4 +345,4 @@ jobs:
 
             @${{ github.actor }}, the build for bun-${{ inputs.tag }} failed.
 
-            **[View logs](${{ github.event.workflow_run.html_url }})**
+            **[View logs](https://github.com/${{ github.repository }}/actions/runs/${{ github.run_id }})**

.github/workflows/build-zig.yml

@@ -9,7 +9,7 @@ on:
     inputs:
       runs-on:
         type: string
-        default: ${{ github.repository_owner != 'oven-sh' && 'ubuntu-latest' || inputs.arch == 'x64' && 'namespace-profile-bun-ci-linux-x64' || 'namespace-profile-bun-ci-linux-aarch64' }}
+        default: ${{ github.repository_owner != 'oven-sh' && 'ubuntu-latest' || inputs.only-zig && 'namespace-profile-bun-ci-linux-x64' || inputs.arch == 'x64' && 'namespace-profile-bun-ci-linux-x64' || 'namespace-profile-bun-ci-linux-aarch64' }}
       tag:
         type: string
         required: true

.github/workflows/ci.yml

@@ -5,7 +5,7 @@ permissions:
   actions: write
 
 concurrency:
-  group: ${{ github.workflow }}-${{ github.ref == 'refs/heads/main' && github.run_id || github.ref }}
+  group: ${{ github.workflow }}-${{ github.event_name == 'workflow_dispatch' && inputs.run-id  || github.ref }}
   cancel-in-progress: true
 
 on:
@@ -15,27 +15,35 @@ on:
         type: string
         description: The workflow ID to download artifacts (skips the build step)
   pull_request:
+    paths-ignore:
+      - .vscode/**/*
+      - docs/**/*
+      - examples/**/*
   push:
     branches:
       - main
+    paths-ignore:
+      - .vscode/**/*
+      - docs/**/*
+      - examples/**/*
 
 jobs:
   format:
-    if: ${{ !github.event.inputs.run-id }}
+    if: ${{ !inputs.run-id }}
     name: Format
     uses: ./.github/workflows/run-format.yml
     secrets: inherit
     with:
-      zig-version: 0.12.0-dev.1828+225fe6ddb
+      zig-version: 0.13.0
     permissions:
       contents: write
   lint:
-    if: ${{ !github.event.inputs.run-id }}
+    if: ${{ !inputs.run-id }}
     name: Lint
     uses: ./.github/workflows/run-lint.yml
     secrets: inherit
   linux-x64:
-    if: ${{ !github.event.inputs.run-id }}
+    if: ${{ !inputs.run-id }}
     name: Build linux-x64
     uses: ./.github/workflows/build-linux.yml
     secrets: inherit
@@ -44,8 +52,10 @@ jobs:
       tag: linux-x64
       arch: x64
       cpu: haswell
+      canary: true
+      no-cache: true
   linux-x64-baseline:
-    if: ${{ !github.event.inputs.run-id }}
+    if: ${{ !inputs.run-id }}
     name: Build linux-x64-baseline
     uses: ./.github/workflows/build-linux.yml
     secrets: inherit
@@ -54,8 +64,10 @@ jobs:
       tag: linux-x64-baseline
       arch: x64
       cpu: nehalem
+      canary: true
+      no-cache: true
   linux-aarch64:
-    if: ${{ !github.event.inputs.run-id && github.repository_owner == 'oven-sh' }}
+    if: ${{ !inputs.run-id && github.repository_owner == 'oven-sh' }}
     name: Build linux-aarch64
     uses: ./.github/workflows/build-linux.yml
     secrets: inherit
@@ -64,38 +76,43 @@ jobs:
       tag: linux-aarch64
       arch: aarch64
       cpu: native
+      canary: true
+      no-cache: true
   darwin-x64:
-    if: ${{ !github.event.inputs.run-id }}
+    if: ${{ !inputs.run-id }}
     name: Build darwin-x64
     uses: ./.github/workflows/build-darwin.yml
     secrets: inherit
     with:
-      runs-on: ${{ github.repository_owner == 'oven-sh' && 'macos-12-large' || 'macos-12' }}
+      runs-on: ${{ github.repository_owner == 'oven-sh' && 'macos-13-large' || 'macos-13' }}
       tag: darwin-x64
       arch: x64
       cpu: haswell
+      canary: true
   darwin-x64-baseline:
-    if: ${{ !github.event.inputs.run-id }}
+    if: ${{ !inputs.run-id }}
     name: Build darwin-x64-baseline
     uses: ./.github/workflows/build-darwin.yml
     secrets: inherit
     with:
-      runs-on: ${{ github.repository_owner == 'oven-sh' && 'macos-12-large' || 'macos-12' }}
+      runs-on: ${{ github.repository_owner == 'oven-sh' && 'macos-13-large' || 'macos-13' }}
       tag: darwin-x64-baseline
       arch: x64
       cpu: nehalem
+      canary: true
   darwin-aarch64:
-    if: ${{ !github.event.inputs.run-id }}
+    if: ${{ !inputs.run-id }}
     name: Build darwin-aarch64
     uses: ./.github/workflows/build-darwin.yml
     secrets: inherit
     with:
-      runs-on: ${{ github.repository_owner == 'oven-sh' && 'namespace-profile-bun-ci-darwin-aarch64' || 'macos-14' }}
+      runs-on: ${{ github.repository_owner == 'oven-sh' && 'namespace-profile-bun-ci-darwin-aarch64' || 'macos-13' }}
       tag: darwin-aarch64
       arch: aarch64
       cpu: native
+      canary: true
   windows-x64:
-    if: ${{ !github.event.inputs.run-id }}
+    if: ${{ !inputs.run-id }}
     name: Build windows-x64
     uses: ./.github/workflows/build-windows.yml
     secrets: inherit
@@ -104,8 +121,9 @@ jobs:
       tag: windows-x64
       arch: x64
       cpu: haswell
+      canary: true
   windows-x64-baseline:
-    if: ${{ !github.event.inputs.run-id }}
+    if: ${{ !inputs.run-id }}
     name: Build windows-x64-baseline
     uses: ./.github/workflows/build-windows.yml
     secrets: inherit
@@ -114,8 +132,9 @@ jobs:
       tag: windows-x64-baseline
       arch: x64
       cpu: nehalem
+      canary: true
   linux-x64-test:
-    if: ${{ github.event.inputs.run-id && always() || github.event_name == 'pull_request' }}
+    if: ${{ inputs.run-id || github.event_name == 'pull_request' }}
     name: Test linux-x64
     needs: linux-x64
     uses: ./.github/workflows/run-test.yml
@@ -126,7 +145,7 @@ jobs:
       runs-on: ${{ github.repository_owner == 'oven-sh' && 'namespace-profile-bun-ci-linux-x64' || 'ubuntu-latest' }}
       tag: linux-x64
   linux-x64-baseline-test:
-    if: ${{ github.event.inputs.run-id && always() || github.event_name == 'pull_request' }}
+    if: ${{ inputs.run-id || github.event_name == 'pull_request' }}
     name: Test linux-x64-baseline
     needs: linux-x64-baseline
     uses: ./.github/workflows/run-test.yml
@@ -137,7 +156,7 @@ jobs:
       runs-on: ${{ github.repository_owner == 'oven-sh' && 'namespace-profile-bun-ci-linux-x64' || 'ubuntu-latest' }}
       tag: linux-x64-baseline
   linux-aarch64-test:
-    if: ${{ github.event.inputs.run-id && always() || github.event_name == 'pull_request' && github.repository_owner == 'oven-sh'}}
+    if: ${{ inputs.run-id || github.event_name == 'pull_request' && github.repository_owner == 'oven-sh'}}
     name: Test linux-aarch64
     needs: linux-aarch64
     uses: ./.github/workflows/run-test.yml
@@ -148,7 +167,7 @@ jobs:
       runs-on: namespace-profile-bun-ci-linux-aarch64
       tag: linux-aarch64
   darwin-x64-test:
-    if: ${{ github.event.inputs.run-id && always() || github.event_name == 'pull_request' }}
+    if: ${{ inputs.run-id || github.event_name == 'pull_request' }}
     name: Test darwin-x64
     needs: darwin-x64
     uses: ./.github/workflows/run-test.yml
@@ -156,10 +175,10 @@ jobs:
     with:
       run-id: ${{ inputs.run-id }}
       pr-number: ${{ github.event.number }}
-      runs-on: ${{ github.repository_owner == 'oven-sh' && 'macos-12-large' || 'macos-12' }}
+      runs-on: ${{ github.repository_owner == 'oven-sh' && 'macos-13-large' || 'macos-13' }}
       tag: darwin-x64
   darwin-x64-baseline-test:
-    if: ${{ github.event.inputs.run-id && always() || github.event_name == 'pull_request' }}
+    if: ${{ inputs.run-id || github.event_name == 'pull_request' }}
     name: Test darwin-x64-baseline
     needs: darwin-x64-baseline
     uses: ./.github/workflows/run-test.yml
@@ -167,10 +186,10 @@ jobs:
     with:
       run-id: ${{ inputs.run-id }}
       pr-number: ${{ github.event.number }}
-      runs-on: ${{ github.repository_owner == 'oven-sh' && 'macos-12-large' || 'macos-12' }}
+      runs-on: ${{ github.repository_owner == 'oven-sh' && 'macos-13-large' || 'macos-13' }}
       tag: darwin-x64-baseline
   darwin-aarch64-test:
-    if: ${{ github.event.inputs.run-id && always() || github.event_name == 'pull_request' }}
+    if: ${{ inputs.run-id || github.event_name == 'pull_request' }}
     name: Test darwin-aarch64
     needs: darwin-aarch64
     uses: ./.github/workflows/run-test.yml
@@ -178,10 +197,10 @@ jobs:
     with:
       run-id: ${{ inputs.run-id }}
       pr-number: ${{ github.event.number }}
-      runs-on: ${{ github.repository_owner == 'oven-sh' && 'namespace-profile-bun-ci-darwin-aarch64' || 'macos-14' }}
+      runs-on: ${{ github.repository_owner == 'oven-sh' && 'namespace-profile-bun-ci-darwin-aarch64' || 'macos-13' }}
       tag: darwin-aarch64
   windows-x64-test:
-    if: ${{ github.event.inputs.run-id && always() || github.event_name == 'pull_request' }}
+    if: ${{ inputs.run-id || github.event_name == 'pull_request' }}
     name: Test windows-x64
     needs: windows-x64
     uses: ./.github/workflows/run-test.yml
@@ -192,7 +211,7 @@ jobs:
       runs-on: windows
       tag: windows-x64
   windows-x64-baseline-test:
-    if: ${{ github.event.inputs.run-id && always() || github.event_name == 'pull_request' }}
+    if: ${{ inputs.run-id || github.event_name == 'pull_request' }}
     name: Test windows-x64-baseline
     needs: windows-x64-baseline
     uses: ./.github/workflows/run-test.yml

.github/workflows/comment-lint.yml

@@ -0,0 +1,85 @@
+name: C++ Linter comment
+
+permissions:
+  actions: read
+  pull-requests: write
+
+on:
+  workflow_run:
+    workflows:
+      - lint-cpp
+    types:
+      - completed
+
+jobs:
+  comment-lint:
+    if: ${{ github.repository_owner == 'oven-sh' }}
+    name: Comment
+    runs-on: ubuntu-latest
+    steps:
+      - name: Download Comment
+        uses: actions/download-artifact@v4
+        with:
+          name: format.log
+          github-token: ${{ github.token }}
+          run-id: ${{ github.event.workflow_run.id }}
+      - name: PR Number
+        uses: actions/download-artifact@v4
+        with:
+          name: pr-number.txt
+          github-token: ${{ github.token }}
+          run-id: ${{ github.event.workflow_run.id }}
+      - name: Did Fail
+        uses: actions/download-artifact@v4
+        with:
+          name: did_fail.txt
+          github-token: ${{ github.token }}
+          run-id: ${{ github.event.workflow_run.id }}
+      - name: Setup Environment
+        id: env
+        shell: bash
+        run: |
+          # Copy to outputs
+          echo "pr-number=$(cat pr-number.txt)" >> $GITHUB_OUTPUT
+          {
+            echo 'text_output<<EOF'
+            cat format.log
+            echo EOF
+          } >> "$GITHUB_OUTPUT"
+          echo "did_fail=$(cat did_fail.txt)" >> $GITHUB_OUTPUT
+
+      - name: Find Comment
+        id: comment
+        uses: peter-evans/find-comment@v3
+        with:
+          issue-number: ${{ steps.env.outputs.pr-number }}
+          comment-author: github-actions[bot]
+          body-includes: <!-- generated-comment lint-cpp-workflow=${{ github.workflow }} -->
+      - name: Update Comment
+        uses: peter-evans/create-or-update-comment@v4
+        if: steps.env.outputs.did_fail != '0'
+        with:
+          comment-id: ${{ steps.comment.outputs.comment-id }}
+          issue-number: ${{ steps.env.outputs.pr-number }}
+          body: |
+            @${{ github.actor }}, `clang-tidy` had something to share with you about your code:
+
+            ```cpp
+            ${{ steps.env.outputs.text_output }}
+            ```
+
+            Commit: ${{ github.event.workflow_run.head_sha || github.sha }}
+
+            <!-- generated-comment lint-cpp-workflow=${{ github.workflow }} -->
+          edit-mode: replace
+      - name: Update Previous Comment
+        uses: peter-evans/create-or-update-comment@v4
+        if: steps.env.outputs.did_fail == '0' && steps.comment.outputs.comment-id != ''
+        with:
+          comment-id: ${{ steps.comment.outputs.comment-id }}
+          issue-number: ${{ steps.env.outputs.pr-number }}
+          body: |
+            clang-tidy nits are fixed! Thank you.
+
+            <!-- generated-comment lint-cpp-workflow=${{ github.workflow }} -->
+          edit-mode: replace

.github/workflows/comment.yml

@@ -37,7 +37,7 @@ jobs:
           else
             echo -e "✅ @${{ github.actor }}, all tests passed!" > comment.md
           fi
-          echo -e "\n**[View logs](${{ github.event.workflow_run.html_url }})**" >> comment.md
+          echo -e "\n**[View logs](https://github.com/${{ github.repository }}/actions/runs/${{ github.event.workflow_run.id }})**" >> comment.md
           echo -e "<!-- generated-comment workflow=${{ github.workflow }} -->" >> comment.md
       - name: Find Comment
         id: comment

.github/workflows/create-release-build.yml

@@ -0,0 +1,183 @@
+name: Create Release Build
+run-name: Compile Bun v${{ inputs.version }} by ${{ github.actor }}
+
+concurrency:
+  group: release
+  cancel-in-progress: true
+
+permissions:
+  contents: write
+  actions: write
+
+on:
+  workflow_dispatch:
+    inputs:
+      version:
+        type: string
+        required: true
+        description: "Release version. Example: 1.1.4. Exclude the 'v' prefix."
+      tag:
+        type: string
+        required: true
+        description: "GitHub tag to use"
+      clobber:
+        type: boolean
+        required: false
+        default: false
+        description: "Overwrite existing release artifacts?"
+  release:
+    types:
+      - created
+
+jobs:
+  notify-start:
+    if: ${{ github.repository_owner == 'oven-sh' }}
+    name: Notify Start
+    runs-on: ubuntu-latest
+    steps:
+      - name: Send Message
+        uses: sarisia/actions-status-discord@v1
+        with:
+          webhook: ${{ secrets.DISCORD_WEBHOOK_PUBLIC }}
+          nodetail: true
+          color: "#1F6FEB"
+          title: "Bun v${{ inputs.version }} is compiling"
+          description: |
+            ### @${{ github.actor }} started compiling Bun v${{inputs.version}}
+      - name: Send Message
+        uses: sarisia/actions-status-discord@v1
+        with:
+          webhook: ${{ secrets.BUN_DISCORD_GITHUB_CHANNEL_WEBHOOK }}
+          nodetail: true
+          color: "#1F6FEB"
+          title: "Bun v${{ inputs.version }} is compiling"
+          description: |
+            ### @${{ github.actor }} started compiling Bun v${{inputs.version}}
+
+            **[View logs](https://github.com/${{ github.repository }}/actions/runs/${{ github.run_id }})**
+  linux-x64:
+    name: Build linux-x64
+    uses: ./.github/workflows/build-linux.yml
+    secrets: inherit
+    with:
+      runs-on: ${{ github.repository_owner == 'oven-sh' && 'namespace-profile-bun-ci-linux-x64' || 'ubuntu-latest' }}
+      tag: linux-x64
+      arch: x64
+      cpu: haswell
+      canary: false
+  linux-x64-baseline:
+    name: Build linux-x64-baseline
+    uses: ./.github/workflows/build-linux.yml
+    secrets: inherit
+    with:
+      runs-on: ${{ github.repository_owner == 'oven-sh' && 'namespace-profile-bun-ci-linux-x64' || 'ubuntu-latest' }}
+      tag: linux-x64-baseline
+      arch: x64
+      cpu: nehalem
+      canary: false
+  linux-aarch64:
+    name: Build linux-aarch64
+    uses: ./.github/workflows/build-linux.yml
+    secrets: inherit
+    with:
+      runs-on: namespace-profile-bun-ci-linux-aarch64
+      tag: linux-aarch64
+      arch: aarch64
+      cpu: native
+      canary: false
+  darwin-x64:
+    name: Build darwin-x64
+    uses: ./.github/workflows/build-darwin.yml
+    secrets: inherit
+    with:
+      runs-on: ${{ github.repository_owner == 'oven-sh' && 'macos-13-large' || 'macos-13' }}
+      tag: darwin-x64
+      arch: x64
+      cpu: haswell
+      canary: false
+  darwin-x64-baseline:
+    name: Build darwin-x64-baseline
+    uses: ./.github/workflows/build-darwin.yml
+    secrets: inherit
+    with:
+      runs-on: ${{ github.repository_owner == 'oven-sh' && 'macos-13-large' || 'macos-13' }}
+      tag: darwin-x64-baseline
+      arch: x64
+      cpu: nehalem
+      canary: false
+  darwin-aarch64:
+    name: Build darwin-aarch64
+    uses: ./.github/workflows/build-darwin.yml
+    secrets: inherit
+    with:
+      runs-on: ${{ github.repository_owner == 'oven-sh' && 'namespace-profile-bun-ci-darwin-aarch64' || 'macos-13' }}
+      tag: darwin-aarch64
+      arch: aarch64
+      cpu: native
+      canary: false
+  windows-x64:
+    name: Build windows-x64
+    uses: ./.github/workflows/build-windows.yml
+    secrets: inherit
+    with:
+      runs-on: windows
+      tag: windows-x64
+      arch: x64
+      cpu: haswell
+      canary: false
+  windows-x64-baseline:
+    name: Build windows-x64-baseline
+    uses: ./.github/workflows/build-windows.yml
+    secrets: inherit
+    with:
+      runs-on: windows
+      tag: windows-x64-baseline
+      arch: x64
+      cpu: nehalem
+      canary: false
+
+  upload-artifacts:
+    needs:
+      - linux-x64
+      - linux-x64-baseline
+      - linux-aarch64
+      - darwin-x64
+      - darwin-x64-baseline
+      - darwin-aarch64
+      - windows-x64
+      - windows-x64-baseline
+    runs-on: ubuntu-latest
+    steps:
+      - name: Download Artifacts
+        uses: actions/download-artifact@v4
+        with:
+          path: bun-releases
+          pattern: bun-*
+          merge-multiple: true
+          github-token: ${{ github.token }}
+      - name: Check for Artifacts
+        run: |
+          if [ ! -d "bun-releases" ] || [ -z "$(ls -A bun-releases)" ]; then
+            echo "Error: No artifacts were downloaded or 'bun-releases' directory does not exist."
+            exit 1  # Fail the job if the condition is met
+          else
+            echo "Artifacts downloaded successfully."
+          fi
+      - name: Send Message
+        uses: sarisia/actions-status-discord@v1
+        with:
+          webhook: ${{ secrets.DISCORD_WEBHOOK }}
+          nodetail: true
+          color: "#FF0000"
+          title: "Bun v${{ inputs.version }} release artifacts uploaded"
+      - name: "Upload Artifacts"
+        env:
+          GH_TOKEN: ${{ github.token }}
+        run: |
+          # Unzip one level deep each artifact
+          cd bun-releases
+          for f in *.zip; do
+            unzip -o $f
+          done
+          cd ..
+          gh release upload --repo=${{ github.repository }} ${{ github.event_name == 'workflow_dispatch' && github.event.inputs.tag || github.event.release.id }} ${{ inputs.clobber && '--clobber' || '' }} bun-releases/*.zip

.github/workflows/docs.yml

@@ -4,6 +4,7 @@ on:
   push:
     paths:
       - "docs/**"
+      - "CONTRIBUTING.md"
     branches:
       - main
 

.github/workflows/labeled.yml

@@ -0,0 +1,81 @@
+name: Issue Labeled
+env:
+  BUN_VERSION: 1.1.13
+
+on:
+  issues:
+    types: [labeled]
+
+jobs:
+  on-labeled:
+    runs-on: ubuntu-latest
+    if: github.event.label.name == 'crash' || github.event.label.name == 'needs repro'
+    permissions:
+      issues: write
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          sparse-checkout: |
+            scripts
+            .github
+            CMakeLists.txt
+      - name: Setup Bun
+        uses: ./.github/actions/setup-bun
+        with:
+          bun-version: "1.1.13"
+      - name: "add platform and command label"
+        id: add-labels
+        if: github.event.label.name == 'crash'
+        env:
+          GITHUB_ISSUE_BODY: ${{ github.event.issue.body }}
+          GITHUB_ISSUE_TITLE: ${{ github.event.issue.title }}
+        shell: bash
+        run: |
+          LABELS=$(bun scripts/read-issue.ts)
+          echo "labels=$LABELS" >> $GITHUB_OUTPUT
+          bun scripts/is-outdated.ts
+
+          if [[ -f "is-outdated.txt" ]]; then 
+            echo "is-outdated=true" >> $GITHUB_OUTPUT
+          fi
+
+          if [[ -f "outdated.txt" ]]; then
+            echo "oudated=$(cat outdated.txt)" >> $GITHUB_OUTPUT
+          fi
+
+          echo "latest=$(cat LATEST)" >> $GITHUB_OUTPUT
+
+          rm -rf is-outdated.txt outdated.txt latest.txt
+      - name: Add labels
+        uses: actions-cool/issues-helper@v3
+        if: github.event.label.name == 'crash'
+        with:
+          actions: "add-labels"
+          token: ${{ secrets.GITHUB_TOKEN }}
+          issue-number: ${{ github.event.issue.number }}
+          labels: ${{ steps.add-labels.outputs.labels }}
+      - name: Comment outdated
+        if: steps.add-labels.outputs.is-outdated == 'true' && github.event.label.name == 'crash'
+        uses: actions-cool/issues-helper@v3
+        with:
+          actions: "create-comment"
+          token: ${{ secrets.GITHUB_TOKEN }}
+          issue-number: ${{ github.event.issue.number }}
+          body: |
+            @${{ github.event.issue.user.login }}, the latest version of Bun is v${{ steps.add-labels.outputs.latest }}, but this crash was reported on Bun v${{ steps.add-labels.outputs.oudated }}.
+
+            Are you able to reproduce this crash on the latest version of Bun?
+
+            ```sh
+            bun upgrade
+            ```
+      - name: Comment needs repro
+        if: github.event.label.name == 'needs repro'
+        uses: actions-cool/issues-helper@v3
+        with:
+          actions: "create-comment"
+          token: ${{ secrets.GITHUB_TOKEN }}
+          issue-number: ${{ github.event.issue.number }}
+          body: |
+            Hello @${{ github.event.issue.user.login }}. Please provide a [minimal reproduction](https://stackoverflow.com/help/minimal-reproducible-example) using a GitHub repository, [Replit](https://replit.com/@replit/Bun), or [CodeSandbox](https://codesandbox.io/templates/bun). Issues marked with `needs repro` will be closed if they have no activity within 3 days.

.github/workflows/lint-cpp.yml

@@ -0,0 +1,30 @@
+name: lint-cpp
+
+permissions:
+  contents: read
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.event_name == 'workflow_dispatch' && inputs.run-id  || github.ref }}
+  cancel-in-progress: true
+
+on:
+  workflow_dispatch:
+    inputs:
+      run-id:
+        type: string
+        description: The workflow ID to download artifacts (skips the build step)
+  pull_request:
+    paths:
+      - ".github/workflows/lint-cpp.yml"
+      - "**/*.cpp"
+      - "src/deps/**/*"
+      - "CMakeLists.txt"
+
+jobs:
+  lint-cpp:
+    if: ${{ !inputs.run-id }}
+    name: Lint C++
+    uses: ./.github/workflows/run-lint-cpp.yml
+    secrets: inherit
+    with:
+      pr-number: ${{ github.event.number }}

.github/workflows/on-submodule-update.yml

@@ -0,0 +1,89 @@
+name: Comment on updated submodule
+
+on:
+  pull_request_target:
+    paths:
+      - "src/generated_versions_list.zig"
+      - ".github/workflows/on-submodule-update.yml"
+
+jobs:
+  comment:
+    name: Comment
+    runs-on: ubuntu-latest
+    if: ${{ github.repository_owner == 'oven-sh' }}
+    permissions:
+      contents: read
+      pull-requests: write
+      issues: write
+    steps:
+      - name: Checkout current
+        uses: actions/checkout@v4
+        with:
+          sparse-checkout: |
+            src
+      - name: Hash generated versions list
+        id: hash
+        run: |
+          echo "hash=$(sha256sum src/generated_versions_list.zig |  cut -d ' ' -f 1)" >> $GITHUB_OUTPUT
+      - name: Checkout base
+        uses: actions/checkout@v4
+        with:
+          ref: ${{ github.base_ref }}
+          sparse-checkout: |
+            src
+      - name: Hash base
+        id: base
+        run: |
+          echo "base=$(sha256sum src/generated_versions_list.zig |  cut -d ' ' -f 1)" >> $GITHUB_OUTPUT
+      - name: Compare
+        id: compare
+        run: |
+          if [ "${{ steps.hash.outputs.hash }}" != "${{ steps.base.outputs.base }}" ]; then
+            echo "changed=true" >> $GITHUB_OUTPUT
+          else
+            echo "changed=false" >> $GITHUB_OUTPUT
+          fi
+      - name: Find Comment
+        id: comment
+        uses: peter-evans/find-comment@v3
+        with:
+          issue-number: ${{ github.event.pull_request.number }}
+          comment-author: github-actions[bot]
+          body-includes: <!-- generated-comment submodule-updated -->
+      - name: Write Warning Comment
+        uses: peter-evans/create-or-update-comment@v4
+        if: steps.compare.outputs.changed == 'true'
+        with:
+          comment-id: ${{ steps.comment.outputs.comment-id }}
+          issue-number: ${{ github.event.pull_request.number }}
+          edit-mode: replace
+          body: |
+            ⚠️ **Warning:** @${{ github.actor }}, this PR has changes to submodule versions. 
+
+            If this change was intentional, please ignore this message. If not, please undo changes to submodules and rebase your branch.
+
+            <!-- generated-comment submodule-updated -->
+      - name: Add labels
+        uses: actions-cool/issues-helper@v3
+        if: steps.compare.outputs.changed == 'true'
+        with:
+          actions: "add-labels"
+          token: ${{ secrets.GITHUB_TOKEN }}
+          issue-number: ${{ github.event.pull_request.number }}
+          labels: "changed-submodules"
+      - name: Remove labels
+        uses: actions-cool/issues-helper@v3
+        if: steps.compare.outputs.changed == 'false'
+        with:
+          actions: "remove-labels"
+          token: ${{ secrets.GITHUB_TOKEN }}
+          issue-number: ${{ github.event.pull_request.number }}
+          labels: "changed-submodules"
+      - name: Delete outdated comment
+        uses: actions-cool/issues-helper@v3
+        if: steps.compare.outputs.changed == 'false' && steps.comment.outputs.comment-id != ''
+        with:
+          actions: "delete-comment"
+          token: ${{ secrets.GITHUB_TOKEN }}
+          issue-number: ${{ github.event.pull_request.number }}
+          comment-id: ${{ steps.comment.outputs.comment-id }}

.github/workflows/release.yml

@@ -63,7 +63,7 @@ jobs:
       - name: Setup Bun
         uses: ./.github/actions/setup-bun
         with:
-          bun-version: "1.0.21"
+          bun-version: "1.1.20"
       - name: Install Dependencies
         run: bun install
       - name: Sign Release
@@ -88,7 +88,7 @@ jobs:
       - name: Setup Bun
         uses: ./.github/actions/setup-bun
         with:
-          bun-version: "1.0.21"
+          bun-version: "1.1.20"
       - name: Install Dependencies
         run: bun install
       - name: Release
@@ -117,7 +117,7 @@ jobs:
         if: ${{ env.BUN_VERSION != 'canary' }}
         uses: ./.github/actions/setup-bun
         with:
-          bun-version: "1.0.21"
+          bun-version: "1.1.20"
       - name: Setup Bun
         if: ${{ env.BUN_VERSION == 'canary' }}
         uses: ./.github/actions/setup-bun
@@ -259,7 +259,7 @@ jobs:
       - name: Setup Bun
         uses: ./.github/actions/setup-bun
         with:
-          bun-version: "1.0.21"
+          bun-version: "1.1.20"
       - name: Install Dependencies
         run: bun install
       - name: Release
@@ -270,3 +270,43 @@ jobs:
           AWS_SECRET_ACCESS_KEY: ${{ secrets.AWS_SECRET_ACCESS_KEY}}
           AWS_ENDPOINT: ${{ secrets.AWS_ENDPOINT }}
           AWS_BUCKET: bun
+
+  notify-sentry:
+    name: Notify Sentry
+    runs-on: ubuntu-latest
+    needs: s3
+    steps:
+      - name: Notify Sentry
+        uses: getsentry/action-release@v1.7.0
+        env:
+          SENTRY_AUTH_TOKEN: ${{ secrets.SENTRY_AUTH_TOKEN }}
+          SENTRY_ORG: ${{ secrets.SENTRY_ORG }}
+          SENTRY_PROJECT: ${{ secrets.SENTRY_PROJECT }}
+        with:
+          ignore_missing: true
+          ignore_empty: true
+          version: ${{ env.BUN_VERSION }}
+          environment: production
+
+  bump:
+    name: "Bump version"
+    runs-on: ubuntu-latest
+    if: ${{ github.event_name != 'schedule' }}
+    permissions:
+      pull-requests: write
+      contents: write
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        if: ${{ env.BUN_LATEST == 'true' }}
+      - name: Setup Bun
+        uses: ./.github/actions/setup-bun
+        if: ${{ env.BUN_LATEST == 'true' }}
+        with:
+          bun-version: "1.1.12"
+      - name: Bump version
+        uses: ./.github/actions/bump
+        if: ${{ env.BUN_LATEST == 'true' }}
+        with:
+          version: ${{ env.BUN_VERSION }}
+          token: ${{ github.token }}

.github/workflows/run-format.yml

@@ -14,6 +14,7 @@ jobs:
   format:
     name: Format
     runs-on: ubuntu-latest
+    if: ${{ github.ref != 'refs/heads/main' }}
     steps:
       - name: Checkout
         uses: actions/checkout@v4
@@ -21,13 +22,14 @@ jobs:
           sparse-checkout: |
             .github
             src
+            scripts
             packages
             test
             bench
       - name: Setup Bun
         uses: ./.github/actions/setup-bun
         with:
-          bun-version: "1.0.21"
+          bun-version: "1.1.20"
       - name: Setup Zig
         uses: goto-bus-stop/setup-zig@c7b6cdd3adba8f8b96984640ff172c37c93f73ee
         with:
@@ -41,6 +43,9 @@ jobs:
       - name: Format Zig
         run: |
           bun fmt:zig
+      - name: Generate submodule versions
+        run: |
+          bash ./scripts/write-versions.sh
       - name: Commit
         uses: stefanzweifel/git-auto-commit-action@v5
         with:

.github/workflows/run-lint-cpp.yml

@@ -0,0 +1,84 @@
+name: lint-cpp
+
+permissions:
+  contents: read
+env:
+  LLVM_VERSION: 16
+  LC_CTYPE: "en_US.UTF-8"
+  LC_ALL: "en_US.UTF-8"
+
+on:
+  workflow_call:
+    inputs:
+      pr-number:
+        required: true
+        type: number
+
+jobs:
+  lint-cpp:
+    name: Lint C++
+    runs-on: ${{ github.repository_owner == 'oven-sh' && 'macos-13-xlarge' || 'macos-13' }}
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          submodules: recursive
+      - name: Setup Bun
+        uses: ./.github/actions/setup-bun
+        with:
+          bun-version: latest
+      - name: Install Dependencies
+        env:
+          HOMEBREW_NO_INSTALLED_DEPENDENTS_CHECK: 1
+          HOMEBREW_NO_AUTO_UPDATE: 1
+          HOMEBREW_NO_INSTALL_CLEANUP: 1
+        run: |
+          brew install \
+            llvm@${{ env.LLVM_VERSION }} \
+            ninja \
+            coreutils \
+            openssl@1.1 \
+            libiconv \
+            gnu-sed --force --overwrite
+          echo "$(brew --prefix coreutils)/libexec/gnubin" >> $GITHUB_PATH
+          echo "$(brew --prefix llvm@$LLVM_VERSION)/bin" >> $GITHUB_PATH
+          brew link --overwrite llvm@$LLVM_VERSION
+      - name: Bun install
+        run: |
+          bun install
+      - name: clang-tidy
+        id: format
+        env:
+          CPU_TARGET: native
+          BUN_SILENT: 1
+        run: |
+          rm -f did_fail format.log
+          echo "${{ inputs.pr-number }}" > pr-number.txt
+          echo "pr_number=$(cat pr-number.txt)" >> $GITHUB_OUTPUT
+          bun run --silent build:tidy &> >(tee -p format.log) && echo 0 > did_succeed.txt
+          # Upload format.log as github artifact for the workflow
+          if [ -f did_succeed.txt ]; then
+            echo "0" > did_fail.txt
+          else
+            echo "1" > did_fail.txt
+          fi
+          echo "did_fail=$(cat did_fail.txt)" >> $GITHUB_OUTPUT
+
+      - name: Upload format.log
+        uses: actions/upload-artifact@v2
+        with:
+          name: format.log
+          path: format.log
+      - name: Upload PR
+        uses: actions/upload-artifact@v2
+        with:
+          name: pr-number.txt
+          path: pr-number.txt
+      - name: Upload PR
+        uses: actions/upload-artifact@v2
+        with:
+          name: did_fail.txt
+          path: did_fail.txt
+      - name: Fail if formatting failed
+        if: ${{ steps.format.outputs.did_fail == '1' }}
+        run: exit 1

.github/workflows/run-lint.yml

@@ -2,6 +2,8 @@ name: Lint
 
 permissions:
   contents: read
+env:
+  LLVM_VERSION: 16
 
 on:
   workflow_call:

.github/workflows/run-test.yml

@@ -22,10 +22,10 @@ on:
 
 jobs:
   test:
-    name: Run Tests
+    name: Tests
     runs-on: ${{ inputs.runs-on }}
     steps:
-      - if: ${{ runner.os == "Windows" }}
+      - if: ${{ runner.os == 'Windows' }}
         name: Setup Git
         run: |
           git config --global core.autocrlf false
@@ -38,6 +38,7 @@ jobs:
             bun.lockb
             test
             packages/bun-internal-test
+            packages/bun-types
       - name: Setup Environment
         shell: bash
         run: |
@@ -49,34 +50,48 @@ jobs:
           path: bun
           github-token: ${{ github.token }}
           run-id: ${{ inputs.run-id || github.run_id }}
-      - if: ${{ runner.os == 'Windows' }}
-        name: Setup Cygwin
-        uses: secondlife/setup-cygwin@v3
+      - name: Download pnpm
+        uses: pnpm/action-setup@v4
         with:
-          packages: bash
-      - name: Setup Bun
+          version: 8
+      - if: ${{ runner.os != 'Windows' }}
+        name: Setup Bun
         shell: bash
         run: |
           unzip bun/bun-*.zip
           cd bun-*
           pwd >> $GITHUB_PATH
+      - if: ${{ runner.os == 'Windows' }}
+        name: Setup Cygwin
+        uses: secondlife/setup-cygwin@v3
+        with:
+          packages: bash
+      - if: ${{ runner.os == 'Windows' }}
+        name: Setup Bun (Windows)
+        run: |
+          unzip bun/bun-*.zip
+          cd bun-*
+          pwd >> $env:GITHUB_PATH
       - name: Setup Node.js
         uses: actions/setup-node@v4
         with:
           node-version: 20
       - name: Install Dependencies
         timeout-minutes: 5
-        shell: bash
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         run: |
           bun install
       - name: Install Dependencies (test)
         timeout-minutes: 5
-        shell: bash
         run: |
           bun install --cwd test
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
       - name: Install Dependencies (runner)
         timeout-minutes: 5
-        shell: bash
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         run: |
           bun install --cwd packages/bun-internal-test
       - name: Run Tests
@@ -84,12 +99,17 @@ jobs:
         timeout-minutes: 90
         shell: bash
         env:
+          IS_BUN_CI: 1
           TMPDIR: ${{ runner.temp }}
           BUN_TAG: ${{ inputs.tag }}
           BUN_FEATURE_FLAG_INTERNAL_FOR_TESTING: "true"
           SMTP_SENDGRID_SENDER: ${{ secrets.SMTP_SENDGRID_SENDER }}
           TLS_MONGODB_DATABASE_URL: ${{ secrets.TLS_MONGODB_DATABASE_URL }}
           TLS_POSTGRES_DATABASE_URL: ${{ secrets.TLS_POSTGRES_DATABASE_URL }}
+          TEST_INFO_STRIPE: ${{ secrets.TEST_INFO_STRIPE }}
+          TEST_INFO_AZURE_SERVICE_BUS: ${{ secrets.TEST_INFO_AZURE_SERVICE_BUS }}
+          SHELLOPTS: igncr
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         run: |
           node packages/bun-internal-test/src/runner.node.mjs $(which bun)
       - if: ${{ always() }}
@@ -118,9 +138,87 @@ jobs:
 
             ${{ steps.test.outputs.failing_tests }}
 
-            **[View logs](${{ github.event.workflow_run.html_url }})**
+            **[View logs](https://github.com/${{ github.repository }}/actions/runs/${{ github.run_id }})**
       - name: Fail
         if: ${{ failure() || always() && steps.test.outputs.failing_tests != '' }}
         run: |
           echo "There are ${{ steps.test.outputs.failing_tests_count || 'some' }} failing tests on bun-${{ inputs.tag }}."
           exit 1
+  test-node:
+    name: Node.js Tests
+    # TODO: enable when we start paying attention to the results. In the meantime, this causes CI to queue jobs wasting developer time.
+    if: 0
+    runs-on: ${{ inputs.runs-on }}
+    steps:
+      - if: ${{ runner.os == 'Windows' }}
+        name: Setup Git
+        run: |
+          git config --global core.autocrlf false
+          git config --global core.eol lf
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          sparse-checkout: |
+            test/node.js
+      - name: Setup Environment
+        shell: bash
+        run: |
+          echo "${{ inputs.pr-number }}" > pr-number.txt
+      - name: Download Bun
+        uses: actions/download-artifact@v4
+        with:
+          name: bun-${{ inputs.tag }}
+          path: bun
+          github-token: ${{ github.token }}
+          run-id: ${{ inputs.run-id || github.run_id }}
+      - if: ${{ runner.os != 'Windows' }}
+        name: Setup Bun
+        shell: bash
+        run: |
+          unzip bun/bun-*.zip
+          cd bun-*
+          pwd >> $GITHUB_PATH
+      - if: ${{ runner.os == 'Windows' }}
+        name: Setup Cygwin
+        uses: secondlife/setup-cygwin@v3
+        with:
+          packages: bash
+      - if: ${{ runner.os == 'Windows' }}
+        name: Setup Bun (Windows)
+        run: |
+          unzip bun/bun-*.zip
+          cd bun-*
+          pwd >> $env:GITHUB_PATH
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: 20
+      - name: Checkout Tests
+        shell: bash
+        working-directory: test/node.js
+        run: |
+          node runner.mjs --pull
+      - name: Install Dependencies
+        timeout-minutes: 5
+        shell: bash
+        working-directory: test/node.js
+        run: |
+          bun install
+      - name: Run Tests
+        timeout-minutes: 10 # Increase when more tests are added
+        shell: bash
+        working-directory: test/node.js
+        env:
+          TMPDIR: ${{ runner.temp }}
+          BUN_GARBAGE_COLLECTOR_LEVEL: "0"
+          BUN_FEATURE_FLAG_INTERNAL_FOR_TESTING: "true"
+        run: |
+          node runner.mjs
+      - name: Upload Results
+        uses: actions/upload-artifact@v4
+        with:
+          name: bun-${{ inputs.tag }}-node-tests
+          path: |
+            test/node.js/summary/*.json
+          if-no-files-found: error
+          overwrite: true

.github/workflows/test-bump.yml

@@ -0,0 +1,29 @@
+name: Test Bump version
+
+on:
+  workflow_dispatch:
+    inputs:
+      version:
+        type: string
+        description: What is the release tag? (e.g. "1.0.2", "canary")
+        required: true
+
+jobs:
+  bump:
+    name: "Bump version"
+    runs-on: ubuntu-latest
+    permissions:
+      pull-requests: write
+      contents: write
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+      - name: Setup Bun
+        uses: ./.github/actions/setup-bun
+        with:
+          bun-version: "1.1.12"
+      - name: Bump version
+        uses: ./.github/actions/bump
+        with:
+          version: ${{ inputs.version }}
+          token: ${{ github.token }}

.github/workflows/upload.yml

@@ -1,4 +1,5 @@
 name: Upload Artifacts
+run-name: Canary release ${{github.sha}} upload
 
 permissions:
   contents: write
@@ -26,6 +27,14 @@ jobs:
           merge-multiple: true
           github-token: ${{ github.token }}
           run-id: ${{ github.event.workflow_run.id }}
+      - name: Check for Artifacts
+        run: |
+          if [ ! -d "bun" ] || [ -z "$(ls -A bun)" ]; then
+            echo "Error: No artifacts were downloaded or 'bun' directory does not exist."
+            exit 1  # Fail the job if the condition is met
+          else
+            echo "Artifacts downloaded successfully."
+          fi
       - name: Upload to GitHub Releases
         uses: ncipollo/release-action@v1
         with:
@@ -47,7 +56,7 @@ jobs:
           aws_secret_access_key: ${{ secrets.AWS_SECRET_ACCESS_KEY}}
           aws_bucket: ${{ secrets.AWS_BUCKET }}
           source_dir: bun
-          destination_dir: releases/${{ github.event.workflow_run.head_sha || github.sha }}
+          destination_dir: releases/${{ github.event.workflow_run.head_sha || github.sha }}-canary
       - name: Upload to S3 (using tag)
         uses: shallwefootball/s3-upload-action@4350529f410221787ccf424e50133cbc1b52704e
         with:
@@ -57,3 +66,29 @@ jobs:
           aws_bucket: ${{ secrets.AWS_BUCKET }}
           source_dir: bun
           destination_dir: releases/canary
+      - name: Announce on Discord
+        uses: sarisia/actions-status-discord@v1
+        with:
+          webhook: ${{ secrets.BUN_DISCORD_GITHUB_CHANNEL_WEBHOOK }}
+          nodetail: true
+          color: "#1F6FEB"
+          title: "New Bun Canary available"
+          url: https://github.com/oven-sh/bun/commit/${{ github.sha }}
+          description: |
+            A new canary build of Bun has been automatically uploaded. To upgrade, run:
+            ```sh
+            bun upgrade --canary
+            # bun upgrade --stable <- to downgrade
+            ```
+      # If notifying sentry fails, don't fail the rest of the build.
+      - name: Notify Sentry
+        uses: getsentry/action-release@v1.7.0
+        env:
+          SENTRY_AUTH_TOKEN: ${{ secrets.SENTRY_AUTH_TOKEN }}
+          SENTRY_ORG: ${{ secrets.SENTRY_ORG }}
+          SENTRY_PROJECT: ${{ secrets.SENTRY_PROJECT }}
+        with:
+          ignore_missing: true
+          ignore_empty: true
+          version: ${{ github.event.workflow_run.head_sha || github.sha }}-canary
+          environment: canary

.gitignore

@@ -15,6 +15,7 @@
 .vs
 .vscode/clang*
 .vscode/cpp*
+.zig-cache
 *.a
 *.bc
 *.big
@@ -54,6 +55,7 @@
 /test.js
 /test.ts
 /testdir
+/test.zig
 build
 build.ninja
 bun-binary
@@ -140,4 +142,7 @@ txt.js
 x64
 yarn.lock
 zig-cache
-zig-out
+zig-out
+test/node.js/upstream
+.zig-cache
+scripts/env.local

.gitmodules

@@ -69,13 +69,6 @@ ignore = dirty
 depth = 1
 shallow = true
 fetchRecurseSubmodules = false
-[submodule "src/deps/base64"]
-path = src/deps/base64
-url = https://github.com/aklomp/base64.git
-ignore = dirty
-depth = 1
-shallow = true
-fetchRecurseSubmodules = false
 [submodule "src/deps/ls-hpack"]
 path = src/deps/ls-hpack
 url = https://github.com/litespeedtech/ls-hpack.git
@@ -83,10 +76,17 @@ ignore = dirty
 depth = 1
 shallow = true
 fetchRecurseSubmodules = false
+[submodule "src/deps/libuv"]
+path = src/deps/libuv
+url = https://github.com/libuv/libuv.git
+ignore = dirty
+depth = 1
+shallow = true
+fetchRecurseSubmodules = false
+branch = v1.48.0
 [submodule "zig"]
-	path = src/deps/zig
-	url = https://github.com/oven-sh/zig
-	branch = bun
-	depth = 1
-	shallow = true
-	fetchRecurseSubmodules = false
+path = src/deps/zig
+url = https://github.com/oven-sh/zig
+depth = 1
+shallow = true
+fetchRecurseSubmodules = false

.prettierignore

@@ -2,5 +2,6 @@ src/bun.js/WebKit
 src/deps
 test/snapshots
 test/js/deno
+test/node.js
 src/react-refresh.js
 *.min.js

.vscode/launch.json

@@ -17,8 +17,7 @@
       "cwd": "${workspaceFolder}/test",
       "env": {
         "FORCE_COLOR": "1",
-        "BUN_DEBUG_QUIET_LOGS": "1",
-        "BUN_GARBAGE_COLLECTOR_LEVEL": "2",
+        "BUN_GARBAGE_COLLECTOR_LEVEL": "1",
       },
       "console": "internalConsole",
     },
@@ -34,9 +33,16 @@
         "BUN_DEBUG_QUIET_LOGS": "1",
         "BUN_GARBAGE_COLLECTOR_LEVEL": "1",
         "BUN_DEBUG_FileReader": "1",
+        "BUN_DEBUG_jest": "1",
       },
       "console": "internalConsole",
     },
+    {
+      "type": "lldb",
+      "name": "Attach",
+      "request": "attach",
+      "pid": "${command:pickMyProcess}",
+    },
     {
       "type": "lldb",
       "request": "launch",
@@ -139,12 +145,14 @@
       "request": "launch",
       "name": "bun run [file]",
       "program": "${workspaceFolder}/build/bun-debug",
-      "args": ["run", "${fileBasename}"],
+      "args": ["run", "${file}"],
       "cwd": "${fileDirname}",
       "env": {
         "FORCE_COLOR": "0",
         "BUN_DEBUG_QUIET_LOGS": "1",
+        "BUN_DEBUG_EventLoop": "1",
         "BUN_GARBAGE_COLLECTOR_LEVEL": "2",
+        "BUN_DEBUG_ALL": "1",
       },
       "console": "internalConsole",
     },
@@ -438,13 +446,16 @@
       "request": "launch",
       "name": "bun test [*] (ci)",
       "program": "node",
-      "args": ["src/runner.node.mjs"],
-      "cwd": "${workspaceFolder}/packages/bun-internal-test",
+      "args": ["test/runner.node.mjs"],
+      "cwd": "${workspaceFolder}",
       "console": "internalConsole",
     },
     // Windows: bun test [file]
     {
       "type": "cppvsdbg",
+      "sourceFileMap": {
+        "D:\\a\\WebKit\\WebKit\\Source": "${workspaceFolder}\\src\\bun.js\\WebKit\\Source",
+      },
       "request": "launch",
       "name": "Windows: bun test [file]",
       "program": "${workspaceFolder}/build/bun-debug.exe",
@@ -472,6 +483,9 @@
     },
     {
       "type": "cppvsdbg",
+      "sourceFileMap": {
+        "D:\\a\\WebKit\\WebKit\\Source": "${workspaceFolder}\\src\\bun.js\\WebKit\\Source",
+      },
       "request": "launch",
       "name": "Windows: bun test --only [file]",
       "program": "${workspaceFolder}/build/bun-debug.exe",
@@ -510,6 +524,9 @@
     },
     {
       "type": "cppvsdbg",
+      "sourceFileMap": {
+        "D:\\a\\WebKit\\WebKit\\Source": "${workspaceFolder}\\src\\bun.js\\WebKit\\Source",
+      },
       "request": "launch",
       "name": "Windows: bun test [file] (fast)",
       "program": "${workspaceFolder}/build/bun-debug.exe",
@@ -532,6 +549,9 @@
     },
     {
       "type": "cppvsdbg",
+      "sourceFileMap": {
+        "D:\\a\\WebKit\\WebKit\\Source": "${workspaceFolder}\\src\\bun.js\\WebKit\\Source",
+      },
       "request": "launch",
       "name": "Windows: bun test [file] (verbose)",
       "program": "${workspaceFolder}/build/bun-debug.exe",
@@ -554,6 +574,9 @@
     },
     {
       "type": "cppvsdbg",
+      "sourceFileMap": {
+        "D:\\a\\WebKit\\WebKit\\Source": "${workspaceFolder}\\src\\bun.js\\WebKit\\Source",
+      },
       "request": "launch",
       "name": "Windows: bun test [file] --inspect",
       "program": "${workspaceFolder}/build/bun-debug.exe",
@@ -585,6 +608,9 @@
     },
     {
       "type": "cppvsdbg",
+      "sourceFileMap": {
+        "D:\\a\\WebKit\\WebKit\\Source": "${workspaceFolder}\\src\\bun.js\\WebKit\\Source",
+      },
       "request": "launch",
       "name": "Windows: bun test [file] --inspect-brk",
       "program": "${workspaceFolder}/build/bun-debug.exe",
@@ -617,6 +643,9 @@
     // Windows: bun run [file]
     {
       "type": "cppvsdbg",
+      "sourceFileMap": {
+        "D:\\a\\WebKit\\WebKit\\Source": "${workspaceFolder}\\src\\bun.js\\WebKit\\Source",
+      },
       "request": "launch",
       "name": "Windows: bun run [file]",
       "program": "${workspaceFolder}/build/bun-debug.exe",
@@ -639,6 +668,9 @@
     },
     {
       "type": "cppvsdbg",
+      "sourceFileMap": {
+        "D:\\a\\WebKit\\WebKit\\Source": "${workspaceFolder}\\src\\bun.js\\WebKit\\Source",
+      },
       "request": "launch",
       "name": "Windows: bun install",
       "program": "${workspaceFolder}/build/bun-debug.exe",
@@ -658,6 +690,9 @@
     },
     {
       "type": "cppvsdbg",
+      "sourceFileMap": {
+        "D:\\a\\WebKit\\WebKit\\Source": "${workspaceFolder}\\src\\bun.js\\WebKit\\Source",
+      },
       "request": "launch",
       "name": "Windows: bun run [file] (verbose)",
       "program": "${workspaceFolder}/build/bun-debug.exe",
@@ -680,6 +715,9 @@
     },
     {
       "type": "cppvsdbg",
+      "sourceFileMap": {
+        "D:\\a\\WebKit\\WebKit\\Source": "${workspaceFolder}\\src\\bun.js\\WebKit\\Source",
+      },
       "request": "launch",
       "name": "Windows: bun run [file] --inspect",
       "program": "${workspaceFolder}/build/bun-debug.exe",
@@ -711,6 +749,9 @@
     },
     {
       "type": "cppvsdbg",
+      "sourceFileMap": {
+        "D:\\a\\WebKit\\WebKit\\Source": "${workspaceFolder}\\src\\bun.js\\WebKit\\Source",
+      },
       "request": "launch",
       "name": "Windows: bun run [file] --inspect-brk",
       "program": "${workspaceFolder}/build/bun-debug.exe",
@@ -743,6 +784,9 @@
     // Windows: bun test [...]
     {
       "type": "cppvsdbg",
+      "sourceFileMap": {
+        "D:\\a\\WebKit\\WebKit\\Source": "${workspaceFolder}\\src\\bun.js\\WebKit\\Source",
+      },
       "request": "launch",
       "name": "Windows: bun test [...]",
       "program": "${workspaceFolder}/build/bun-debug.exe",
@@ -765,6 +809,9 @@
     },
     {
       "type": "cppvsdbg",
+      "sourceFileMap": {
+        "D:\\a\\WebKit\\WebKit\\Source": "${workspaceFolder}\\src\\bun.js\\WebKit\\Source",
+      },
       "request": "launch",
       "name": "Windows: bun test [...] (fast)",
       "program": "${workspaceFolder}/build/bun-debug.exe",
@@ -787,6 +834,9 @@
     },
     {
       "type": "cppvsdbg",
+      "sourceFileMap": {
+        "D:\\a\\WebKit\\WebKit\\Source": "${workspaceFolder}\\src\\bun.js\\WebKit\\Source",
+      },
       "request": "launch",
       "name": "Windows: bun test [...] (verbose)",
       "program": "${workspaceFolder}/build/bun-debug.exe",
@@ -809,6 +859,9 @@
     },
     {
       "type": "cppvsdbg",
+      "sourceFileMap": {
+        "D:\\a\\WebKit\\WebKit\\Source": "${workspaceFolder}\\src\\bun.js\\WebKit\\Source",
+      },
       "request": "launch",
       "name": "Windows: bun test [...] --watch",
       "program": "${workspaceFolder}/build/bun-debug.exe",
@@ -831,6 +884,9 @@
     },
     {
       "type": "cppvsdbg",
+      "sourceFileMap": {
+        "D:\\a\\WebKit\\WebKit\\Source": "${workspaceFolder}\\src\\bun.js\\WebKit\\Source",
+      },
       "request": "launch",
       "name": "Windows: bun test [...] --hot",
       "program": "${workspaceFolder}/build/bun-debug.exe",
@@ -853,6 +909,9 @@
     },
     {
       "type": "cppvsdbg",
+      "sourceFileMap": {
+        "D:\\a\\WebKit\\WebKit\\Source": "${workspaceFolder}\\src\\bun.js\\WebKit\\Source",
+      },
       "request": "launch",
       "name": "Windows: bun test [...] --inspect",
       "program": "${workspaceFolder}/build/bun-debug.exe",
@@ -884,6 +943,9 @@
     },
     {
       "type": "cppvsdbg",
+      "sourceFileMap": {
+        "D:\\a\\WebKit\\WebKit\\Source": "${workspaceFolder}\\src\\bun.js\\WebKit\\Source",
+      },
       "request": "launch",
       "name": "Windows: bun test [...] --inspect-brk",
       "program": "${workspaceFolder}/build/bun-debug.exe",
@@ -916,6 +978,9 @@
     // Windows: bun exec [...]
     {
       "type": "cppvsdbg",
+      "sourceFileMap": {
+        "D:\\a\\WebKit\\WebKit\\Source": "${workspaceFolder}\\src\\bun.js\\WebKit\\Source",
+      },
       "request": "launch",
       "name": "Windows: bun exec [...]",
       "program": "${workspaceFolder}/build/bun-debug.exe",
@@ -939,6 +1004,9 @@
     // Windows: bun test [*]
     {
       "type": "cppvsdbg",
+      "sourceFileMap": {
+        "D:\\a\\WebKit\\WebKit\\Source": "${workspaceFolder}\\src\\bun.js\\WebKit\\Source",
+      },
       "request": "launch",
       "name": "Windows: bun test [*]",
       "program": "${workspaceFolder}/build/bun-debug.exe",
@@ -961,6 +1029,9 @@
     },
     {
       "type": "cppvsdbg",
+      "sourceFileMap": {
+        "D:\\a\\WebKit\\WebKit\\Source": "${workspaceFolder}\\src\\bun.js\\WebKit\\Source",
+      },
       "request": "launch",
       "name": "Windows: bun test [*] (fast)",
       "program": "${workspaceFolder}/build/bun-debug.exe",
@@ -983,6 +1054,9 @@
     },
     {
       "type": "cppvsdbg",
+      "sourceFileMap": {
+        "D:\\a\\WebKit\\WebKit\\Source": "${workspaceFolder}\\src\\bun.js\\WebKit\\Source",
+      },
       "request": "launch",
       "name": "Windows: bun test [*] --inspect",
       "program": "${workspaceFolder}/build/bun-debug.exe",
@@ -1014,11 +1088,14 @@
     },
     {
       "type": "cppvsdbg",
+      "sourceFileMap": {
+        "D:\\a\\WebKit\\WebKit\\Source": "${workspaceFolder}\\src\\bun.js\\WebKit\\Source",
+      },
       "request": "launch",
       "name": "Windows: bun test [*] (ci)",
       "program": "node",
-      "args": ["src/runner.node.mjs"],
-      "cwd": "${workspaceFolder}/packages/bun-internal-test",
+      "args": ["test/runner.node.mjs"],
+      "cwd": "${workspaceFolder}",
       "console": "internalConsole",
     },
   ],

.vscode/settings.json

@@ -14,6 +14,7 @@
     ".git": true,
     "src/bun.js/WebKit": true,
     "src/deps/*/**": true,
+    "test/node.js/upstream": true,
   },
   "search.followSymlinks": false,
   "search.useIgnoreFiles": true,
@@ -25,8 +26,12 @@
 
   // Zig
   "zig.initialSetupDone": true,
-  "zig.buildOnSave": false,
   "zig.buildOption": "build",
+  "zig.zls.zigLibPath": "${workspaceFolder}/src/deps/zig/lib",
+  "zig.buildArgs": ["-Dgenerated-code=./build/codegen"],
+  "zig.zls.buildOnSaveStep": "check",
+  // "zig.zls.enableBuildOnSave": true,
+  // "zig.buildOnSave": true,
   "zig.buildFilePath": "${workspaceFolder}/build.zig",
   "zig.path": "${workspaceFolder}/.cache/zig/zig.exe",
   "zig.formattingProvider": "zls",
@@ -61,6 +66,7 @@
   "[javascriptreact]": {
     "editor.defaultFormatter": "esbenp.prettier-vscode",
   },
+  "prettier.prettierPath": "./node_modules/prettier",
 
   // TypeScript
   "typescript.tsdk": "${workspaceFolder}/node_modules/typescript/lib",
@@ -120,6 +126,9 @@
     "**/*.xcscheme": true,
     "**/*.xcodeproj": true,
     "**/*.i": true,
+
+    // uws WebSocket.cpp conflicts with webcore WebSocket.cpp
+    "packages/bun-uws/fuzzing": true,
   },
   "files.associations": {
     "*.idl": "cpp",
@@ -142,4 +151,5 @@
     "WebKit/WebKitBuild": true,
     "WebKit/WebInspectorUI": true,
   },
+  "git.detectSubmodules": false,
 }

CMakeLists.txt

@@ -2,12 +2,29 @@ cmake_minimum_required(VERSION 3.22)
 cmake_policy(SET CMP0091 NEW)
 cmake_policy(SET CMP0067 NEW)
 
-set(Bun_VERSION "1.1.4")
-set(WEBKIT_TAG e3a2d89a0b1644cc8d5c245bd2ffee4d4bd6c1d5)
+set(CMAKE_POLICY_DEFAULT_CMP0069 NEW)
+set(Bun_VERSION "1.1.21")
+set(WEBKIT_TAG 49907bff8781719bc2ded068b0c934f6d0074d1e)
 
 set(BUN_WORKDIR "${CMAKE_CURRENT_BINARY_DIR}")
 message(STATUS "Configuring Bun ${Bun_VERSION} in ${BUN_WORKDIR}")
 
+set(CMAKE_COLOR_DIAGNOSTICS ON)
+set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_C_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_C_STANDARD_REQUIRED ON)
+
+# Used in process.version, process.versions.node, napi, and elsewhere
+set(REPORTED_NODEJS_VERSION "22.3.0")
+
+# WebKit uses -std=gnu++20 on non-macOS non-Windows
+# If we do not set this, it will crash at startup on the first memory allocation.
+if(NOT WIN32 AND NOT APPLE)
+    set(CMAKE_CXX_EXTENSIONS ON)
+    set(CMAKE_POSITION_INDEPENDENT_CODE FALSE)
+endif()
+
 # --- Build Type ---
 if(NOT CMAKE_BUILD_TYPE)
     message(WARNING "No CMAKE_BUILD_TYPE value specified, defaulting to Debug.\nSet a build type with -DCMAKE_BUILD_TYPE=<Debug|Release>")
@@ -22,6 +39,13 @@ else()
     message(STATUS "The CMake build type is: ${CMAKE_BUILD_TYPE}")
 endif()
 
+if(WIN32 AND NOT CMAKE_CL_SHOWINCLUDES_PREFIX)
+    # workaround until cmake fix is shipped https://github.com/ninja-build/ninja/issues/2280
+    # './build/.ninja_deps' may need to be deleted, the bug is "Note: including file: ..." is saved
+    # as part of some file paths
+    set(CMAKE_CL_SHOWINCLUDES_PREFIX "Note: including file:")
+endif()
+
 if(CMAKE_BUILD_TYPE STREQUAL "Debug")
     set(DEBUG ON)
     set(DEFAULT_ZIG_OPTIMIZE "Debug")
@@ -34,11 +58,8 @@ elseif(CMAKE_BUILD_TYPE STREQUAL "Release")
     set(DEFAULT_ZIG_OPTIMIZE "ReleaseFast")
 
     if(WIN32)
-        # lld-link will strip it for you, so we can build directly to bun.exe
+        # Debug symbols are in a separate file: bun.pdb
         set(bun "bun")
-
-        # TODO(@paperdave): Remove this
-        # it is enabled for the time being to make sure to catch more bugs in the experimental windows builds
         set(DEFAULT_ZIG_OPTIMIZE "ReleaseSafe")
     else()
         if(ZIG_OPTIMIZE STREQUAL "Debug")
@@ -51,11 +72,7 @@ endif()
 
 # --- MacOS SDK ---
 if(APPLE AND DEFINED ENV{CI})
-    if(ARCH STREQUAL "x86_64")
-        set(CMAKE_OSX_DEPLOYMENT_TARGET "10.14")
-    else()
-        set(CMAKE_OSX_DEPLOYMENT_TARGET "11.0")
-    endif()
+    set(CMAKE_OSX_DEPLOYMENT_TARGET "13.0")
 endif()
 
 if(APPLE AND NOT CMAKE_OSX_DEPLOYMENT_TARGET)
@@ -93,13 +110,17 @@ endif()
 # any case possible. Sorry for the complexity...
 #
 # Bun and WebKit must be compiled with the same compiler, so we do as much as we can to ensure that
-# the compiler used for the prebuilt WebKit, LLVM 16, is the one that we detect in this process.
+# the compiler used for the prebuilt WebKit is the same as we install as a dependency.
 #
 # It has to be done before project() is called, so that CMake doesnt pick a compiler for us, but even then
 # we do some extra work afterwards to double-check, and we will rerun BUN_FIND_LLVM if the compiler did not match.
 #
 # If the user passes -DLLVM_PREFIX, most of this logic is skipped, but we still warn if invalid.
-set(LLVM_VERSION 16)
+if(WIN32 OR APPLE)
+    set(LLVM_VERSION 18)
+else()
+    set(LLVM_VERSION 16)
+endif()
 
 macro(BUN_FIND_LLVM)
     find_program(
@@ -133,11 +154,12 @@ macro(BUN_FIND_LLVM)
         PATHS ENV PATH ${PLATFORM_LLVM_SEARCH_PATHS}
         DOC "Path to LLVM ${LLVM_VERSION}'s llvm-strip binary"
     )
+
     find_program(
         STRIP
         NAMES strip
         PATHS ENV PATH ${PLATFORM_LLVM_SEARCH_PATHS}
-        DOC "Path to LLVM ${LLVM_VERSION}'s llvm-strip binary"
+        DOC "Path to strip binary"
     )
     find_program(
         DSYMUTIL
@@ -214,12 +236,6 @@ else()
     )
 endif()
 
-set(CMAKE_COLOR_DIAGNOSTICS ON)
-set(CMAKE_CXX_STANDARD 20)
-set(CMAKE_C_STANDARD 17)
-set(CMAKE_CXX_STANDARD_REQUIRED ON)
-set(CMAKE_C_STANDARD_REQUIRED ON)
-
 project(Bun VERSION "${Bun_VERSION}")
 
 # if(MSVC)
@@ -299,12 +315,12 @@ option(USE_CUSTOM_LIBARCHIVE "Use Bun's recommended version of libarchive" ON)
 option(USE_CUSTOM_MIMALLOC "Use Bun's recommended version of Mimalloc" ON)
 option(USE_CUSTOM_ZSTD "Use Bun's recommended version of zstd" ON)
 option(USE_CUSTOM_CARES "Use Bun's recommended version of c-ares" ON)
-option(USE_CUSTOM_BASE64 "Use Bun's recommended version of libbase64" ON)
 option(USE_CUSTOM_LOLHTML "Use Bun's recommended version of lolhtml" ON)
 option(USE_CUSTOM_TINYCC "Use Bun's recommended version of tinycc" ON)
 option(USE_CUSTOM_LIBUV "Use Bun's recommended version of libuv (Windows only)" ON)
 option(USE_CUSTOM_LSHPACK "Use Bun's recommended version of ls-hpack" ON)
 option(USE_BASELINE_BUILD "Build Bun for baseline (older) CPUs" OFF)
+option(USE_SYSTEM_ICU "Use the system-provided libicu. May fix startup crashes when building WebKit yourself." OFF)
 
 option(USE_VALGRIND "Build Bun with Valgrind support (Linux only)" OFF)
 
@@ -315,6 +331,19 @@ option(USE_STATIC_LIBATOMIC "Statically link libatomic, requires the presence of
 
 option(USE_LTO "Enable Link-Time Optimization" ${DEFAULT_LTO})
 
+if(APPLE AND USE_LTO)
+    set(USE_LTO OFF)
+    message(WARNING "Link-Time Optimization is not supported on macOS because it requires -fuse-ld=lld and lld causes many segfaults on macOS (likely related to stack size)")
+endif()
+
+if(WIN32 AND USE_LTO)
+    set(CMAKE_LINKER_TYPE LLD)
+    set(CMAKE_INTERPROCEDURAL_OPTIMIZATION OFF)
+endif()
+
+option(BUN_TIDY_ONLY "Only run clang-tidy" OFF)
+option(BUN_TIDY_ONLY_EXTRA " Only run clang-tidy, with extra checks for local development" OFF)
+
 if(NOT ZIG_LIB_DIR)
     cmake_path(SET ZIG_LIB_DIR NORMALIZE "${CMAKE_CURRENT_SOURCE_DIR}/src/deps/zig/lib")
 endif()
@@ -334,6 +363,10 @@ if(NOT CANARY)
     set(CANARY 0)
 endif()
 
+if(NOT ENABLE_LOGS)
+    set(ENABLE_LOGS false)
+endif()
+
 if(NOT ZIG_OPTIMIZE)
     set(ZIG_OPTIMIZE ${DEFAULT_ZIG_OPTIMIZE})
 endif()
@@ -411,7 +444,7 @@ if(ZIG_COMPILER)
     find_program(ZIG_COMPILER_ zig ${REQUIRED_IF_NOT_ONLY_CPP_OR_LINK} DOC "Path to the Zig compiler" VALIDATOR validate_zig)
     set(ZIG_COMPILER "${ZIG_COMPILER_}")
     message(STATUS "Found Zig Compiler: ${ZIG_COMPILER}")
-elseif(NOT BUN_CPP_ONLY AND NOT BUN_LINK_ONLY)
+elseif(NOT BUN_CPP_ONLY AND NOT BUN_LINK_ONLY AND NOT BUN_TIDY_ONLY AND NOT BUN_TIDY_ONLY_EXTRA)
     execute_process(
         COMMAND "${SHELL}"
         "${CMAKE_CURRENT_SOURCE_DIR}/scripts/download-zig.${SCRIPT_EXTENSION}"
@@ -601,7 +634,7 @@ set(BUN_DEPS_DIR "${BUN_SRC}/deps")
 set(BUN_CODEGEN_SRC "${BUN_SRC}/codegen")
 
 if(NOT BUN_DEPS_OUT_DIR)
-    set(BUN_DEPS_OUT_DIR "${BUN_DEPS_DIR}")
+    set(BUN_DEPS_OUT_DIR "${CMAKE_CURRENT_SOURCE_DIR}/build/bun-deps")
 endif()
 
 set(BUN_RAW_SOURCES, "")
@@ -619,16 +652,6 @@ file(GLOB BUN_CPP ${CONFIGURE_DEPENDS}
 )
 list(APPEND BUN_RAW_SOURCES ${BUN_CPP})
 
-# -- Brotli --
-set(BROTLI_SRC "${CMAKE_CURRENT_SOURCE_DIR}/src/deps/brotli")
-file(GLOB BROTLI_FILES ${CONFIGURE_DEPENDS}
-    "${BROTLI_SRC}/common/*.c"
-    "${BROTLI_SRC}/enc/*.c"
-    "${BROTLI_SRC}/dec/*.c"
-)
-list(APPEND BUN_RAW_SOURCES ${BROTLI_FILES})
-include_directories("${BUN_DEPS_DIR}/brotli/include")
-
 # -- uSockets --
 set(USOCKETS_SRC "${CMAKE_CURRENT_SOURCE_DIR}/packages/bun-usockets/src")
 file(GLOB USOCKETS_FILES ${CONFIGURE_DEPENDS}
@@ -759,6 +782,8 @@ if(NOT NO_CODEGEN)
         "${BUN_SRC}/js/thirdparty/*.ts"
         "${BUN_SRC}/js/internal/*.js"
         "${BUN_SRC}/js/internal/*.ts"
+        "${BUN_SRC}/js/internal/util/*.js"
+        "${BUN_SRC}/js/internal/fs/*.ts"
         "${BUN_SRC}/js/node/*.js"
         "${BUN_SRC}/js/node/*.ts"
         "${BUN_SRC}/js/thirdparty/*.js"
@@ -842,11 +867,24 @@ file(GLOB ZIG_FILES
     "${BUN_SRC}/*/*/*/*/*.zig"
 )
 
-if(NOT BUN_ZIG_OBJ)
-    set(BUN_ZIG_OBJ "${BUN_WORKDIR}/CMakeFiles/bun-zig.o")
+if(NOT BUN_ZIG_OBJ_FORMAT)
+    # To use LLVM bitcode from Zig, more work needs to be done. Currently, an install of
+    # LLVM 18.1.7 does not compatible with what bitcode Zig 0.13 outputs (has LLVM 18.1.7)
+    # Change to "bc" to experiment, "Invalid record" means it is not valid output.
+    set(BUN_ZIG_OBJ_FORMAT "obj")
 endif()
 
-get_filename_component(BUN_ZIG_OBJ "${BUN_ZIG_OBJ}" REALPATH BASE_DIR "${CMAKE_BINARY_DIR}")
+if(NOT BUN_ZIG_OBJ_DIR)
+    set(BUN_ZIG_OBJ_DIR "${BUN_WORKDIR}/CMakeFiles")
+endif()
+
+get_filename_component(BUN_ZIG_OBJ_DIR "${BUN_ZIG_OBJ_DIR}" REALPATH BASE_DIR "${CMAKE_BINARY_DIR}")
+
+if(WIN32)
+    set(BUN_ZIG_OBJ "${BUN_ZIG_OBJ_DIR}/bun-zig.o")
+else()
+    set(BUN_ZIG_OBJ "${BUN_ZIG_OBJ_DIR}/bun-zig.o")
+endif()
 
 set(USES_TERMINAL_NOT_IN_CI "")
 
@@ -860,7 +898,8 @@ if(NOT BUN_LINK_ONLY AND NOT BUN_CPP_ONLY)
         COMMAND
         "${ZIG_COMPILER}" "build" "obj"
         "--zig-lib-dir" "${ZIG_LIB_DIR}"
-        "-Doutput-file=${BUN_ZIG_OBJ}"
+        "--prefix" "${BUN_ZIG_OBJ_DIR}"
+        "--verbose"
         "-Dgenerated-code=${BUN_WORKDIR}/codegen"
         "-freference-trace=10"
         "-Dversion=${Bun_VERSION}"
@@ -868,6 +907,9 @@ if(NOT BUN_LINK_ONLY AND NOT BUN_CPP_ONLY)
         "-Doptimize=${ZIG_OPTIMIZE}"
         "-Dcpu=${CPU_TARGET}"
         "-Dtarget=${ZIG_TARGET}"
+        "-Denable_logs=${ENABLE_LOGS}"
+        "-Dreported_nodejs_version=${REPORTED_NODEJS_VERSION}"
+        "-Dobj_format=${BUN_ZIG_OBJ_FORMAT}"
         DEPENDS
         "${CMAKE_CURRENT_SOURCE_DIR}/build.zig"
         "${ZIG_FILES}"
@@ -913,7 +955,9 @@ if(WIN32)
 endif()
 
 # -- The Buntime™️ ---
-if(NOT BUN_CPP_ONLY)
+if(BUN_TIDY_ONLY OR BUN_TIDY_ONLY_EXTRA)
+    add_library(${bun} OBJECT "${BUN_SOURCES}")
+elseif(NOT BUN_CPP_ONLY)
     add_executable(${bun} "${BUN_SOURCES}" "${BUN_ZIG_OBJ}")
 else()
     add_executable(${bun} "${BUN_SOURCES}")
@@ -929,12 +973,15 @@ set_target_properties(${bun} PROPERTIES
     VISIBILITY_INLINES_HIDDEN YES
 )
 
+if(APPLE)
+    add_compile_definitions("__DARWIN_NON_CANCELABLE=1")
+endif()
+
 add_compile_definitions(
 
     # TODO: are all of these variables strictly necessary?
     "_HAS_EXCEPTIONS=0"
     "LIBUS_USE_OPENSSL=1"
-    "UWS_HTTPRESPONSE_NO_WRITEMARK=1"
     "LIBUS_USE_BORINGSSL=1"
     "WITH_BORINGSSL=1"
     "STATICALLY_LINKED_WITH_JavaScriptCore=1"
@@ -948,6 +995,7 @@ add_compile_definitions(
     "IS_BUILD"
     "BUILDING_JSCONLY__"
     "BUN_DYNAMIC_JS_LOAD_PATH=\"${BUN_WORKDIR}/js\""
+    "REPORTED_NODEJS_VERSION=\"${REPORTED_NODEJS_VERSION}\""
 )
 
 if(NOT ASSERT_ENABLED)
@@ -1038,7 +1086,7 @@ elseif(CMAKE_BUILD_TYPE STREQUAL "Release")
 
     if(NOT WIN32)
         if(USE_LTO)
-            list(APPEND LTO_FLAG "-flto=full" "-emit-llvm")
+            list(APPEND LTO_FLAG "-flto=full" "-emit-llvm" "-fwhole-program-vtables" "-fforce-emit-vtables")
         endif()
 
         # Leave -Werror=unused off in release builds so we avoid errors from being used in ASSERT
@@ -1057,13 +1105,38 @@ elseif(CMAKE_BUILD_TYPE STREQUAL "Release")
         set(LTO_LINK_FLAG "")
 
         if(USE_LTO)
-            # -emit-llvm seems to not be supported or under a different name on Windows.
+            target_compile_options(${bun} PUBLIC -Xclang -emit-llvm-bc)
+
             list(APPEND LTO_FLAG "-flto=full")
+            list(APPEND LTO_LINK_FLAG "-flto=full")
             list(APPEND LTO_LINK_FLAG "/LTCG")
+            list(APPEND LTO_LINK_FLAG "/OPT:REF")
+            list(APPEND LTO_LINK_FLAG "/OPT:NOICF")
         endif()
 
-        target_compile_options(${bun} PUBLIC /O2 ${LTO_FLAG} /DEBUG:FULL)
-        target_link_options(${bun} PUBLIC ${LTO_LINK_FLAG} /DEBUG:FULL)
+        target_compile_options(${bun} PUBLIC
+            /O2
+            ${LTO_FLAG}
+            /Gy
+            /Gw
+            /GF
+            /GA
+        )
+        target_link_options(${bun} PUBLIC
+            ${LTO_LINK_FLAG}
+            /DEBUG:FULL
+
+            /delayload:ole32.dll
+            /delayload:WINMM.dll
+            /delayload:dbghelp.dll
+            /delayload:VCRUNTIME140_1.dll
+
+            # libuv loads these two immediately, but for some reason it seems to still be slightly faster to delayload them
+            /delayload:WS2_32.dll
+            /delayload:WSOCK32.dll
+            /delayload:ADVAPI32.dll
+            /delayload:IPHLPAPI.dll
+        )
     endif()
 endif()
 
@@ -1081,6 +1154,11 @@ else()
         # On arm macOS, we can set it to a minimum of the M1 cpu set. this might be the default already.
         target_compile_options(${bun} PUBLIC "-mcpu=apple-m1")
     endif()
+
+    if(NOT WIN32 AND NOT APPLE AND ARCH STREQUAL "aarch64")
+        # on arm64 linux, we set a minimum of armv8
+        target_compile_options(${bun} PUBLIC -march=armv8-a+crc -mtune=ampere1)
+    endif()
 endif()
 
 target_compile_options(${bun} PUBLIC -ferror-limit=${ERROR_LIMIT})
@@ -1094,24 +1172,30 @@ if(WIN32)
         "BORINGSSL_NO_CXX=1" # lol
     )
 
-    # set_property(TARGET ${bun} PROPERTY MSVC_RUNTIME_LIBRARY "MultiThreaded")
-    set_property(TARGET ${bun} PROPERTY MSVC_RUNTIME_LIBRARY "MultiThreadedDLL")
+    # set_property(TARGET ${bun} PROPERTY MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>")
+    set_property(TARGET ${bun} PROPERTY MSVC_RUNTIME_LIBRARY "MultiThreaded")
 
-    target_compile_options(${bun} PUBLIC "/EHsc" "/GR-")
-    target_link_options(${bun} PUBLIC "/STACK:0x1200000,0x100000")
+    target_compile_options(${bun} PUBLIC "/EHsc" "/GR-" -Xclang -fno-c++-static-destructors)
+
+    target_link_options(${bun} PUBLIC "/STACK:0x1200000,0x100000" "/DEF:${BUN_SRC}/symbols.def" "/errorlimit:0")
 else()
     target_compile_options(${bun} PUBLIC
-        -fPIC
         -mtune=${CPU_TARGET}
-        -fconstexpr-steps=1271242
-        -fconstexpr-depth=27
+        -fconstexpr-steps=2542484
+        -fconstexpr-depth=54
         -fno-exceptions
+        -fno-asynchronous-unwind-tables
+        -fno-unwind-tables
+        -fno-c++-static-destructors
         -fvisibility=hidden
         -fvisibility-inlines-hidden
         -fno-rtti
         -fno-omit-frame-pointer
+        -mno-omit-leaf-frame-pointer
+        -fno-pic
+        -fno-pie
+        -faddrsig
     )
-    string(APPEND CMAKE_CXX_FLAGS " -std=c++2a")
 endif()
 
 if(APPLE)
@@ -1120,18 +1204,18 @@ if(APPLE)
     target_link_options(${bun} PUBLIC "-Wl,-stack_size,0x1200000")
     target_link_options(${bun} PUBLIC "-exported_symbols_list" "${BUN_SRC}/symbols.txt")
     set_target_properties(${bun} PROPERTIES LINK_DEPENDS "${BUN_SRC}/symbols.txt")
-
     target_link_options(${bun} PUBLIC "-fno-keep-static-consts")
     target_link_libraries(${bun} PRIVATE "resolv")
 endif()
 
 if(UNIX AND NOT APPLE)
     target_link_options(${bun} PUBLIC
-        "-fuse-ld=lld"
-        "-static-libstdc++"
-        "-static-libgcc"
-        "-fuse-ld=lld"
-        "-Wl,-z,now"
+        -fuse-ld=lld
+        -fno-pic
+        -static-libstdc++
+        -static-libgcc
+        "-Wl,-no-pie"
+        "-Wl,-icf=safe"
         "-Wl,--as-needed"
         "-Wl,--gc-sections"
         "-Wl,-z,stack-size=12800000"
@@ -1140,24 +1224,28 @@ if(UNIX AND NOT APPLE)
         "-Wl,--wrap=stat64"
         "-Wl,--wrap=pow"
         "-Wl,--wrap=exp"
+        "-Wl,--wrap=expf"
         "-Wl,--wrap=log"
         "-Wl,--wrap=log2"
         "-Wl,--wrap=lstat"
+        "-Wl,--wrap=stat64"
         "-Wl,--wrap=stat"
         "-Wl,--wrap=fstat"
         "-Wl,--wrap=fstatat"
         "-Wl,--wrap=lstat64"
-        "-Wl,--wrap=stat64"
         "-Wl,--wrap=fstat64"
         "-Wl,--wrap=fstatat64"
         "-Wl,--wrap=mknod"
         "-Wl,--wrap=mknodat"
         "-Wl,--wrap=statx"
+        "-Wl,--wrap=fmod"
         "-Wl,--compress-debug-sections=zlib"
         "-Bsymbolics-functions"
         "-rdynamic"
         "-Wl,--dynamic-list=${BUN_SRC}/symbols.dyn"
         "-Wl,--version-script=${BUN_SRC}/linker.lds"
+        -Wl,-z,lazy
+        -Wl,-z,norelro
     )
 
     target_link_libraries(${bun} PRIVATE "c")
@@ -1170,9 +1258,15 @@ if(UNIX AND NOT APPLE)
         target_link_libraries(${bun} PRIVATE "libatomic.a")
     endif()
 
-    target_link_libraries(${bun} PRIVATE "${WEBKIT_LIB_DIR}/libicudata.a")
-    target_link_libraries(${bun} PRIVATE "${WEBKIT_LIB_DIR}/libicui18n.a")
-    target_link_libraries(${bun} PRIVATE "${WEBKIT_LIB_DIR}/libicuuc.a")
+    if(USE_SYSTEM_ICU)
+        target_link_libraries(${bun} PRIVATE "libicudata.a")
+        target_link_libraries(${bun} PRIVATE "libicui18n.a")
+        target_link_libraries(${bun} PRIVATE "libicuuc.a")
+    else()
+        target_link_libraries(${bun} PRIVATE "${WEBKIT_LIB_DIR}/libicudata.a")
+        target_link_libraries(${bun} PRIVATE "${WEBKIT_LIB_DIR}/libicui18n.a")
+        target_link_libraries(${bun} PRIVATE "${WEBKIT_LIB_DIR}/libicuuc.a")
+    endif()
 
     set_target_properties(${bun} PROPERTIES LINK_DEPENDS "${BUN_SRC}/linker.lds")
     set_target_properties(${bun} PROPERTIES LINK_DEPENDS "${BUN_SRC}/symbols.dyn")
@@ -1185,12 +1279,16 @@ endif()
 
 # --- Stripped Binary "bun"
 if(CMAKE_BUILD_TYPE STREQUAL "Release" AND NOT WIN32 AND NOT ASSERT_ENABLED)
-    # add_custom_command(
-    # TARGET ${bun}
-    # POST_BUILD
-    # COMMAND ${DSYMUTIL} -o ${BUN_WORKDIR}/bun.dSYM ${BUN_WORKDIR}/${bun}
-    # COMMENT "Stripping Symbols"
-    # )
+    # if(CI AND APPLE)
+    if(APPLE)
+        add_custom_command(
+            TARGET ${bun}
+            POST_BUILD
+            COMMAND ${DSYMUTIL} -o ${BUN_WORKDIR}/${bun}.dSYM ${BUN_WORKDIR}/${bun}
+            COMMENT "Generating .dSYM"
+        )
+    endif()
+
     add_custom_command(
         TARGET ${bun}
         POST_BUILD
@@ -1268,11 +1366,11 @@ if(USE_CUSTOM_MIMALLOC)
     elseif(APPLE)
         if(USE_DEBUG_JSC OR CMAKE_BUILD_TYPE STREQUAL "Debug")
             message(STATUS "Using debug mimalloc")
-            target_link_libraries(${bun} PRIVATE "${BUN_DEPS_OUT_DIR}/libmimalloc-debug.a")
+            target_link_libraries(${bun} PRIVATE "${BUN_DEPS_OUT_DIR}/libmimalloc-debug.o")
         else()
-            # https://github.com/microsoft/mimalloc/issues/512
-            # Linking mimalloc via object file on macOS x64 can cause heap corruption
-            target_link_libraries(${bun} PRIVATE "${BUN_DEPS_OUT_DIR}/libmimalloc.a")
+            # Note: https://github.com/microsoft/mimalloc/issues/512
+            # It may have been a bug in our code at the time.
+            target_link_libraries(${bun} PRIVATE "${BUN_DEPS_OUT_DIR}/libmimalloc.o")
         endif()
     else()
         if(USE_DEBUG_JSC OR CMAKE_BUILD_TYPE STREQUAL "Debug")
@@ -1313,19 +1411,6 @@ else()
     target_link_libraries(${bun} PRIVATE c-ares::cares)
 endif()
 
-if(USE_CUSTOM_BASE64)
-    include_directories(${BUN_DEPS_DIR}/base64/include)
-
-    if(WIN32)
-        target_link_libraries(${bun} PRIVATE "${BUN_DEPS_OUT_DIR}/base64.lib")
-    else()
-        target_link_libraries(${bun} PRIVATE "${BUN_DEPS_OUT_DIR}/libbase64.a")
-    endif()
-else()
-    find_package(base64 REQUIRED)
-    target_link_libraries(${bun} PRIVATE base64::base64)
-endif()
-
 if(USE_CUSTOM_TINYCC)
     if(WIN32)
         target_link_libraries(${bun} PRIVATE "${BUN_DEPS_OUT_DIR}/tcc.lib")
@@ -1371,6 +1456,11 @@ if(USE_STATIC_SQLITE)
         "SQLITE_ENABLE_JSON1=1"
         "SQLITE_ENABLE_MATH_FUNCTIONS=1"
     )
+
+    if(WIN32)
+        target_compile_options(sqlite3 PRIVATE /MT /U_DLL)
+    endif()
+
     target_link_libraries(${bun} PRIVATE sqlite3)
     message(STATUS "Using static sqlite3")
     target_compile_definitions(${bun} PRIVATE "LAZY_LOAD_SQLITE=0")
@@ -1379,6 +1469,24 @@ else()
     target_compile_definitions(${bun} PRIVATE "LAZY_LOAD_SQLITE=1")
 endif()
 
+# -- Brotli --
+set(BROTLI_SRC "${CMAKE_CURRENT_SOURCE_DIR}/src/deps/brotli")
+file(GLOB BROTLI_FILES ${CONFIGURE_DEPENDS}
+    "${BROTLI_SRC}/common/*.c"
+    "${BROTLI_SRC}/enc/*.c"
+    "${BROTLI_SRC}/dec/*.c"
+)
+add_library(brotli STATIC ${BROTLI_FILES})
+target_include_directories(brotli PRIVATE "${BROTLI_SRC}/include")
+target_compile_definitions(brotli PRIVATE "BROTLI_STATIC")
+
+if(WIN32)
+    target_compile_options(brotli PRIVATE /MT /U_DLL)
+endif()
+
+target_link_libraries(${bun} PRIVATE brotli)
+include_directories("${BUN_DEPS_DIR}/brotli/include")
+
 if(USE_CUSTOM_LSHPACK)
     include_directories(${BUN_DEPS_DIR}/ls-hpack)
 
@@ -1398,7 +1506,6 @@ if(NOT WIN32)
     target_link_libraries(${bun} PRIVATE "${WEBKIT_LIB_DIR}/libJavaScriptCore.a")
     target_link_libraries(${bun} PRIVATE "${WEBKIT_LIB_DIR}/libbmalloc.a")
 else()
-    target_link_options(${bun} PRIVATE "-static")
     target_link_libraries(${bun} PRIVATE
         "${WEBKIT_LIB_DIR}/WTF.lib"
         "${WEBKIT_LIB_DIR}/JavaScriptCore.lib"
@@ -1408,17 +1515,13 @@ else()
         winmm
         bcrypt
         ntdll
-        ucrt
         userenv
         dbghelp
         wsock32 # ws2_32 required by TransmitFile aka sendfile on windows
+        delayimp.lib
     )
 endif()
 
-if(WIN32)
-    # delayimp -delayload:shell32.dll -delayload:ole32.dll
-endif()
-
 if(BUN_LINK_ONLY)
     message(STATUS "NOTE: BUN_LINK_ONLY is ON, this build config will only link the Bun executable")
 endif()
@@ -1430,3 +1533,15 @@ endif()
 if(NO_CODEGEN)
     message(STATUS "NOTE: NO_CODEGEN is ON, this build expects ./codegen to exist")
 endif()
+
+if(BUN_TIDY_ONLY)
+    find_program(CLANG_TIDY_EXE NAMES "clang-tidy")
+    set(CLANG_TIDY_COMMAND "${CLANG_TIDY_EXE}" "-checks=-*,clang-analyzer-*,-clang-analyzer-webkit.UncountedLambdaCapturesChecker" "--fix" "--fix-errors" "--format-style=webkit" "--warnings-as-errors=*")
+    set_target_properties(${bun} PROPERTIES CXX_CLANG_TIDY "${CLANG_TIDY_COMMAND}")
+endif()
+
+if(BUN_TIDY_ONLY_EXTRA)
+    find_program(CLANG_TIDY_EXE NAMES "clang-tidy")
+    set(CLANG_TIDY_COMMAND "${CLANG_TIDY_EXE}" "-checks=-*,clang-analyzer-*,performance-*,-clang-analyzer-webkit.UncountedLambdaCapturesChecker" "--fix" "--fix-errors" "--format-style=webkit" "--warnings-as-errors=*")
+    set_target_properties(${bun} PROPERTIES CXX_CLANG_TIDY "${CLANG_TIDY_COMMAND}")
+endif()

CONTRIBUTING.md

@@ -1,76 +1,327 @@
-# Contributing to Bun
+Configuring a development environment for Bun can take 10-30 minutes depending on your internet connection and computer speed. You will need ~10GB of free disk space for the repository and build artifacts.
 
-> **Important:** All contributions need test coverage. If you are adding a new feature, please add a test. If you are fixing a bug, please add a test that fails before your fix and passes after your fix.
+If you are using Windows, please refer to [this guide](/docs/project/building-windows)
 
-## Bun's codebase
+{% details summary="For Ubuntu users" %}
+TL;DR: Ubuntu 22.04 is suggested.
+Bun currently requires `glibc >=2.32` in development which means if you're on Ubuntu 20.04 (glibc == 2.31), you may likely meet `error: undefined symbol: __libc_single_threaded `. You need to take extra configurations. Also, according to this [issue](https://github.com/llvm/llvm-project/issues/97314), LLVM 16 is no longer maintained on Ubuntu 24.04 (noble). And instead, you might want `brew` to install LLVM 16 for your Ubuntu 24.04.
+{% /details %}
 
-Bun is written mostly in Zig, but WebKit & JavaScriptCore (the JavaScript engine) is written in C++.
+## Install Dependencies
 
-Today (February 2023), Bun's codebase has five distinct parts:
+Using your system's package manager, install Bun's dependencies:
 
-- JavaScript, JSX, & TypeScript transpiler, module resolver, and related code
-- JavaScript runtime ([`src/bun.js/`](src/bun.js/))
-- JavaScript runtime bindings ([`src/bun.js/bindings/**/*.cpp`](src/bun.js/bindings/))
-- Package manager ([`src/install/`](src/install/))
-- Shared utilities ([`src/string_immutable.zig`](src/string_immutable.zig))
+{% codetabs %}
 
-The JavaScript transpiler & module resolver is mostly independent from the runtime. It predates the runtime and is entirely in Zig. The JavaScript parser is mostly in [`src/js_parser.zig`](src/js_parser.zig). The JavaScript AST data structures are mostly in [`src/js_ast.zig`](src/js_ast.zig). The JavaScript lexer is in [`src/js_lexer.zig`](src/js_lexer.zig). A lot of this code started as a port of esbuild's equivalent code from Go to Zig, but has had many small changes since then.
+```bash#macOS (Homebrew)
+$ brew install automake ccache cmake coreutils gnu-sed go icu4c libiconv libtool ninja pkg-config rust ruby
+```
 
-## Getting started
+```bash#Ubuntu/Debian
+$ sudo apt install curl wget lsb-release software-properties-common cargo ccache cmake git golang libtool ninja-build pkg-config rustc ruby-full xz-utils
+```
 
-Please refer to [Bun's Development Guide](https://bun.sh/docs/project/contributing) to get your dev environment setup!
+```bash#Arch
+$ sudo pacman -S base-devel ccache cmake git go libiconv libtool make ninja pkg-config python rust sed unzip ruby
+```
 
-## Memory management in Bun
+```bash#Fedora
+$ sudo dnf install cargo ccache cmake git golang libtool ninja-build pkg-config rustc ruby libatomic-static libstdc++-static sed unzip which libicu-devel 'perl(Math::BigInt)'
+```
 
-For the Zig code, please:
+```bash#openSUSE Tumbleweed
+$ sudo zypper install go cmake ninja automake git rustup && rustup toolchain install stable
+```
 
-1. Do your best to avoid dynamically allocating memory.
-2. If we need to allocate memory, carefully consider the owner of that memory. If it's a JavaScript object, it will need a finalizer. If it's in Zig, it will need to be freed either via an arena or manually.
-3. Prefer arenas over manual memory management. Manually freeing memory is leak & crash prone.
-4. If the memory needs to be accessed across threads, use `bun.default_allocator`. Mimalloc threadlocal heaps are not safe to free across threads.
+{% /codetabs %}
 
-The JavaScript transpiler has special-handling for memory management. The parser allocates into a single arena and the memory is recycled after each parse.
+> **Note**: The Zig compiler is automatically installed and updated by the build scripts. Manual installation is not required.
 
-## JavaScript runtime
+Before starting, you will need to already have a release build of Bun installed, as we use our bundler to transpile and minify our code, as well as for code generation scripts.
 
-Most of Bun's JavaScript runtime code lives in [`src/bun.js`](src/bun.js).
+{% codetabs %}
 
-### Calling C++ from Zig & Zig from C++
+```bash#Native
+$ curl -fsSL https://bun.sh/install | bash
+```
 
-TODO: document this (see [`bindings.zig`](src/bun.js/bindings/bindings.zig) and [`bindings.cpp`](src/bun.js/bindings/bindings.cpp) for now)
+```bash#npm
+$ npm install -g bun
+```
 
-### Adding a new JavaScript class
+```bash#Homebrew
+$ brew tap oven-sh/bun
+$ brew install bun
+```
 
-1. Add a new file in [`src/bun.js/*.classes.ts`](src/bun.js) to define the instance and static methods for the class.
-2. Add a new file in [`src/bun.js/**/*.zig`](src/bun.js) and expose the struct in [`src/bun.js/generated_classes_list.zig`](src/bun.js/generated_classes_list.zig)
-3. Run `make codegen`
+{% /codetabs %}
 
-Copy from examples like `Subprocess` or `Response`.
+## Install LLVM
 
-### ESM Modules and Builtins JS
+Bun requires LLVM 16 (`clang` is part of LLVM). This version requirement is to match WebKit (precompiled), as mismatching versions will cause memory allocation failures at runtime. In most cases, you can install LLVM through your system package manager:
 
-Bun implements ESM modules in a mix of native code and JavaScript.
+{% codetabs %}
 
-Several Node.js modules are implemented in JavaScript and loosely based on browserify polyfills.
+```bash#macOS (Homebrew)
+$ brew install llvm@16
+```
 
-Builtin modules in Bun are located in [`src/js`](src/js/). These files are transpiled and support a JavaScriptCore-only syntax for internal slots, which is explained further in [`src/js/README.md`](src/js/README.md).
+```bash#Ubuntu/Debian
+$ # LLVM has an automatic installation script that is compatible with all versions of Ubuntu
+$ wget https://apt.llvm.org/llvm.sh -O - | sudo bash -s -- 16 all
+```
 
-Native C++ modules are in `src/bun.js/modules/`.
+```bash#Arch
+$ sudo pacman -S llvm clang lld
+```
 
-The module loader is in [`src/bun.js/module_loader.zig`](src/bun.js/module_loader.zig).
+```bash#Fedora
+$ sudo dnf install 'dnf-command(copr)'
+$ sudo dnf copr enable -y @fedora-llvm-team/llvm-snapshots
+$ sudo dnf install llvm clang lld
+```
 
-### Memory management in Bun's JavaScript runtime
+```bash#openSUSE Tumbleweed
+$ sudo zypper install clang16 lld16 llvm16
+```
 
-TODO: fill this out (for now, use `JSC.Strong` in most cases)
+{% /codetabs %}
 
-### Strings
+If none of the above solutions apply, you will have to install it [manually](https://github.com/llvm/llvm-project/releases/tag/llvmorg-16.0.6).
 
-TODO: fill this out (for now, use `JSValue.toSlice()` in most cases)
+Make sure Clang/LLVM 16 is in your path:
 
-#### JavaScriptCore C API
+```bash
+$ which clang-16
+```
 
-Do not copy from examples leveraging the JavaScriptCore C API. Please do not use this in new code. We will not accept PRs that add new code that uses the JavaScriptCore C API.
+If not, run this to manually add it:
 
-## Testing
+{% codetabs %}
 
-See [`test/README.md`](test/README.md) for information on how to run tests.
+```bash#macOS (Homebrew)
+# use fish_add_path if you're using fish
+# use path+="$(brew --prefix llvm@16)/bin" if you are using zsh
+$ export PATH="$(brew --prefix llvm@16)/bin:$PATH"
+```
+
+```bash#Arch
+# use fish_add_path if you're using fish
+$ export PATH="$PATH:/usr/lib/llvm16/bin"
+```
+
+{% /codetabs %}
+
+> ⚠️ Ubuntu distributions (<= 20.04) may require installation of the C++ standard library independently. See the [troubleshooting section](#span-file-not-found-on-ubuntu) for more information.
+
+## Building Bun
+
+After cloning the repository, run the following command to run the first build. This may take a while as it will clone submodules and build dependencies.
+
+```bash
+$ bun setup
+```
+
+The binary will be located at `./build/bun-debug`. It is recommended to add this to your `$PATH`. To verify the build worked, let's print the version number on the development build of Bun.
+
+```bash
+$ build/bun-debug --version
+x.y.z_debug
+```
+
+To rebuild, you can invoke `bun run build`
+
+```bash
+$ bun run build
+```
+
+These two scripts, `setup` and `build`, are aliases to do roughly the following:
+
+```bash
+$ ./scripts/setup.sh
+$ cmake -S . -B build -G Ninja -DCMAKE_BUILD_TYPE=Debug
+$ ninja -C build # 'bun run build' runs just this
+```
+
+Advanced users can pass CMake flags to customize the build.
+
+## VSCode
+
+VSCode is the recommended IDE for working on Bun, as it has been configured. Once opening, you can run `Extensions: Show Recommended Extensions` to install the recommended extensions for Zig and C++. ZLS is automatically configured.
+
+If you use a different editor, make sure that you tell ZLS to use the automatically installed Zig compiler, which is located at `./.cache/zig/zig.exe`. The filename is `zig.exe` so that it works as expected on Windows, but it still works on macOS/Linux (it just has a surprising file extension).
+
+We recommend adding `./build` to your `$PATH` so that you can run `bun-debug` in your terminal:
+
+```sh
+$ bun-debug
+```
+
+## Code generation scripts
+
+Several code generation scripts are used during Bun's build process. These are run automatically when changes are made to certain files.
+
+In particular, these are:
+
+- `./src/codegen/generate-jssink.ts` -- Generates `build/codegen/JSSink.cpp`, `build/codegen/JSSink.h` which implement various classes for interfacing with `ReadableStream`. This is internally how `FileSink`, `ArrayBufferSink`, `"type": "direct"` streams and other code related to streams works.
+- `./src/codegen/generate-classes.ts` -- Generates `build/codegen/ZigGeneratedClasses*`, which generates Zig & C++ bindings for JavaScriptCore classes implemented in Zig. In `**/*.classes.ts` files, we define the interfaces for various classes, methods, prototypes, getters/setters etc which the code generator reads to generate boilerplate code implementing the JavaScript objects in C++ and wiring them up to Zig
+- `./src/codegen/bundle-modules.ts` -- Bundles built-in modules like `node:fs`, `bun:ffi` into files we can include in the final binary. In development, these can be reloaded without rebuilding Zig (you still need to run `bun run build`, but it re-reads the transpiled files from disk afterwards). In release builds, these are embedded into the binary.
+- `./src/codegen/bundle-functions.ts` -- Bundles globally-accessible functions implemented in JavaScript/TypeScript like `ReadableStream`, `WritableStream`, and a handful more. These are used similarly to the builtin modules, but the output more closely aligns with what WebKit/Safari does for Safari's built-in functions so that we can copy-paste the implementations from WebKit as a starting point.
+
+## Modifying ESM modules
+
+Certain modules like `node:fs`, `node:stream`, `bun:sqlite`, and `ws` are implemented in JavaScript. These live in `src/js/{node,bun,thirdparty}` files and are pre-bundled using Bun.
+
+## Release build
+
+To compile a release build of Bun, run:
+
+```bash
+$ bun run build:release
+```
+
+The binary will be located at `./build-release/bun` and `./build-release/bun-profile`.
+
+### Download release build from pull requests
+
+To save you time spent building a release build locally, we provide a way to run release builds from pull requests. This is useful for manully testing changes in a release build before they are merged.
+
+To run a release build from a pull request, you can use the `bun-pr` npm package:
+
+```sh
+bunx bun-pr pr-number
+bunx bun-pr branch/branch-name
+bunx bun-pr "https://github.com/oven-sh/bun/pull/1234566"
+```
+
+This will download the release build from the pull request and add it to `$PATH` as `bun-${pr-number}`. You can then run the build with `bun-${pr-number}`.
+
+```sh
+bun-1234566 --version
+```
+
+This works by downloading the release build from the GitHub Actions artifacts on the linked pull request. You may need the `gh` CLI installed to authenticate with GitHub.
+
+## Valgrind
+
+On Linux, valgrind can help find memory issues.
+
+Keep in mind:
+
+- JavaScriptCore doesn't support valgrind. It will report spurious errors.
+- Valgrind is slow
+- Mimalloc will sometimes cause spurious errors when debug build is enabled
+
+You'll need a very recent version of Valgrind due to DWARF 5 debug symbols. You may need to manually compile Valgrind instead of using it from your Linux package manager.
+
+`--fair-sched=try` is necessary if running multithreaded code in Bun (such as the bundler). Otherwise it will hang.
+
+```bash
+$ valgrind --fair-sched=try --track-origins=yes bun-debug <args>
+```
+
+## Building WebKit locally + Debug mode of JSC
+
+{% callout %}
+
+**TODO**: This is out of date. TLDR is pass `-DUSE_DEBUG_JSC=1` or `-DWEBKIT_DIR=...` to CMake. it will probably need more fiddling. ask @paperdave if you need this.
+
+{% /callout %}
+
+WebKit is not cloned by default (to save time and disk space). To clone and build WebKit locally, run:
+
+```bash
+# once you run this, `make submodule` can be used to automatically
+# update WebKit and the other submodules
+$ git submodule update --init --depth 1 --checkout src/bun.js/WebKit
+# to make a jsc release build
+$ make jsc
+# JSC debug build does not work perfectly with Bun yet, this is actively being
+# worked on and will eventually become the default.
+$ make jsc-build-linux-compile-debug cpp
+$ make jsc-build-mac-compile-debug cpp
+```
+
+Note that the WebKit folder, including build artifacts, is 8GB+ in size.
+
+If you are using a JSC debug build and using VScode, make sure to run the `C/C++: Select a Configuration` command to configure intellisense to find the debug headers.
+
+## Troubleshooting
+
+### 'span' file not found on Ubuntu
+
+> ⚠️ Please note that the instructions below are specific to issues occurring on Ubuntu. It is unlikely that the same issues will occur on other Linux distributions.
+
+The Clang compiler typically uses the `libstdc++` C++ standard library by default. `libstdc++` is the default C++ Standard Library implementation provided by the GNU Compiler Collection (GCC). While Clang may link against the `libc++` library, this requires explicitly providing the `-stdlib` flag when running Clang.
+
+Bun relies on C++20 features like `std::span`, which are not available in GCC versions lower than 11. GCC 10 doesn't have all of the C++20 features implemented. As a result, running `make setup` may fail with the following error:
+
+```
+fatal error: 'span' file not found
+#include <span>
+         ^~~~~~
+```
+
+The issue may manifest when initially running `bun setup` as Clang being unable to compile a simple program:
+
+```
+The C++ compiler
+
+  "/usr/bin/clang++-16"
+
+is not able to compile a simple test program.
+```
+
+To fix the error, we need to update the GCC version to 11. To do this, we'll need to check if the latest version is available in the distribution's official repositories or use a third-party repository that provides GCC 11 packages. Here are general steps:
+
+```bash
+$ sudo apt update
+$ sudo apt install gcc-11 g++-11
+# If the above command fails with `Unable to locate package gcc-11` we need
+# to add the APT repository
+$ sudo add-apt-repository -y ppa:ubuntu-toolchain-r/test
+# Now run `apt install` again
+$ sudo apt install gcc-11 g++-11
+```
+
+Now, we need to set GCC 11 as the default compiler:
+
+```bash
+$ sudo update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-11 100
+$ sudo update-alternatives --install /usr/bin/g++ g++ /usr/bin/g++-11 100
+```
+
+### libarchive
+
+If you see an error on macOS when compiling `libarchive`, run:
+
+```bash
+$ brew install pkg-config
+```
+
+### macOS `library not found for -lSystem`
+
+If you see this error when compiling, run:
+
+```bash
+$ xcode-select --install
+```
+
+## Cannot find `libatomic.a`
+
+Bun defaults to linking `libatomic` statically, as not all systems have it. If you are building on a distro that does not have a static libatomic available, you can run the following command to enable dynamic linking:
+
+```bash
+$ bun setup -DUSE_STATIC_LIBATOMIC=OFF
+```
+
+The built version of Bun may not work on other systems if compiled this way.
+
+## ccache conflicts with building TinyCC on macOS
+
+If you run into issues with `ccache` when building TinyCC, try reinstalling ccache
+
+```bash
+brew uninstall ccache
+brew install ccache
+```

Dockerfile

@@ -16,7 +16,7 @@ ARG BUILD_MACHINE_ARCH=x86_64
 ARG BUILDARCH=amd64
 ARG TRIPLET=${ARCH}-linux-gnu
 ARG GIT_SHA=""
-ARG BUN_VERSION="bun-v1.0.30"
+ARG BUN_VERSION="bun-v1.1.4"
 ARG BUN_DOWNLOAD_URL_BASE="https://pub-5e11e972747a44bf9aaf9394f185a982.r2.dev/releases/${BUN_VERSION}"
 ARG CANARY=0
 ARG ASSERTIONS=OFF
@@ -25,7 +25,9 @@ ARG CMAKE_BUILD_TYPE=Release
 
 ARG NODE_VERSION="20"
 ARG LLVM_VERSION="16"
-ARG ZIG_VERSION="0.12.0-dev.1828+225fe6ddb"
+
+ARG ZIG_VERSION="0.13.0"
+ARG ZIG_VERSION_SHORT="0.13.0"
 
 ARG SCCACHE_BUCKET
 ARG SCCACHE_REGION
@@ -50,11 +52,10 @@ ENV CI 1
 ENV CPU_TARGET=${CPU_TARGET}
 ENV BUILDARCH=${BUILDARCH}
 ENV BUN_DEPS_OUT_DIR=${BUN_DEPS_OUT_DIR}
+ENV BUN_ENABLE_LTO 1
 
-ENV CXX=clang++-16
-ENV CC=clang-16
-ENV AR=/usr/bin/llvm-ar-16
-ENV LD=lld-16
+ENV LC_CTYPE=en_US.UTF-8
+ENV LC_ALL=en_US.UTF-8
 
 ENV SCCACHE_BUCKET=${SCCACHE_BUCKET}
 ENV SCCACHE_REGION=${SCCACHE_REGION}
@@ -63,8 +64,7 @@ ENV SCCACHE_ENDPOINT=${SCCACHE_ENDPOINT}
 ENV AWS_ACCESS_KEY_ID=${AWS_ACCESS_KEY_ID}
 ENV AWS_SECRET_ACCESS_KEY=${AWS_SECRET_ACCESS_KEY}
 
-RUN apt-get update -y \
-  && install_packages \
+RUN install_packages \
   ca-certificates \
   curl \
   gnupg \
@@ -88,6 +88,10 @@ RUN apt-get update -y \
   lld-${LLVM_VERSION} \
   lldb-${LLVM_VERSION} \
   clangd-${LLVM_VERSION} \
+  libc++-${LLVM_VERSION}-dev \
+  libc++abi-${LLVM_VERSION}-dev \
+  llvm-${LLVM_VERSION}-runtime \
+  llvm-${LLVM_VERSION}-dev \
   make \
   cmake \
   ninja-build \
@@ -104,14 +108,25 @@ RUN apt-get update -y \
   perl \
   python3 \
   ruby \
+  ruby-dev \
   golang \
-  nodejs \
-  && ln -s /usr/bin/clang-${LLVM_VERSION} /usr/bin/clang \
-  && ln -s /usr/bin/clang++-${LLVM_VERSION} /usr/bin/clang++ \
-  && ln -s /usr/bin/lld-${LLVM_VERSION} /usr/bin/lld \
-  && ln -s /usr/bin/lldb-${LLVM_VERSION} /usr/bin/lldb \
-  && ln -s /usr/bin/clangd-${LLVM_VERSION} /usr/bin/clangd \
-  && ln -s /usr/bin/llvm-ar-${LLVM_VERSION} /usr/bin/llvm-ar \
+  nodejs && \
+  for f in /usr/lib/llvm-${LLVM_VERSION}/bin/*; do ln -sf "$f" /usr/bin; done \
+  && ln -sf /usr/bin/clang-${LLVM_VERSION} /usr/bin/clang \
+  && ln -sf /usr/bin/clang++-${LLVM_VERSION} /usr/bin/clang++ \
+  && ln -sf /usr/bin/lld-${LLVM_VERSION} /usr/bin/lld \
+  && ln -sf /usr/bin/lldb-${LLVM_VERSION} /usr/bin/lldb \
+  && ln -sf /usr/bin/clangd-${LLVM_VERSION} /usr/bin/clangd \
+  && ln -sf /usr/bin/llvm-ar-${LLVM_VERSION} /usr/bin/llvm-ar \
+  && ln -sf /usr/bin/ld.lld /usr/bin/ld \
+  && ln -sf /usr/bin/llvm-ranlib-${LLVM_VERSION} /usr/bin/ranlib \
+  && ln -sf /usr/bin/clang /usr/bin/cc \
+  && ln -sf /usr/bin/clang /usr/bin/c89 \
+  && ln -sf /usr/bin/clang /usr/bin/c99 \
+  && ln -sf /usr/bin/clang++ /usr/bin/c++ \
+  && ln -sf /usr/bin/clang++ /usr/bin/g++ \
+  && ln -sf /usr/bin/llvm-ar /usr/bin/ar \
+  && ln -sf /usr/bin/clang /usr/bin/gcc \
   && arch="$(dpkg --print-architecture)" \
   && case "${arch##*-}" in \
   amd64) variant="x64";; \
@@ -124,6 +139,7 @@ RUN apt-get update -y \
   && ln -s /usr/bin/bun /usr/bin/bunx \
   && rm -rf bun-linux-${variant} bun-linux-${variant}.zip \
   && mkdir -p ${BUN_DIR} ${BUN_DEPS_OUT_DIR}
+
 # && if [ -n "${SCCACHE_BUCKET}" ]; then \
 #   echo "Setting up sccache" \
 #   && wget https://github.com/mozilla/sccache/releases/download/v0.5.4/sccache-v0.5.4-${BUILD_MACHINE_ARCH}-unknown-linux-musl.tar.gz \
@@ -134,6 +150,7 @@ RUN apt-get update -y \
 FROM bun-base as bun-base-with-zig
 
 ARG ZIG_VERSION
+ARG ZIG_VERSION_SHORT
 ARG BUILD_MACHINE_ARCH
 ARG ZIG_FOLDERNAME=zig-linux-${BUILD_MACHINE_ARCH}-${ZIG_VERSION}
 ARG ZIG_FILENAME=${ZIG_FOLDERNAME}.tar.xz
@@ -159,13 +176,14 @@ ENV CCACHE_DIR=${CCACHE_DIR}
 
 COPY Makefile ${BUN_DIR}/Makefile
 COPY src/deps/c-ares ${BUN_DIR}/src/deps/c-ares
+COPY scripts ${BUN_DIR}/scripts
 
 WORKDIR $BUN_DIR
 
 RUN --mount=type=cache,target=${CCACHE_DIR} \
   cd $BUN_DIR \
-  && make c-ares \
-  && rm -rf ${BUN_DIR}/src/deps/c-ares ${BUN_DIR}/Makefile
+  && bash ./scripts/build-cares.sh \
+  && rm -rf ${BUN_DIR}/src/deps/c-ares ${BUN_DIR}/Makefile ${BUN_DIR}/scripts
 
 FROM bun-base as lolhtml
 
@@ -196,13 +214,14 @@ ENV CPU_TARGET=${CPU_TARGET}
 
 COPY Makefile ${BUN_DIR}/Makefile
 COPY src/deps/mimalloc ${BUN_DIR}/src/deps/mimalloc
+COPY scripts ${BUN_DIR}/scripts
 
 ARG CCACHE_DIR=/ccache
 ENV CCACHE_DIR=${CCACHE_DIR}
 
 RUN --mount=type=cache,target=${CCACHE_DIR} \
   cd ${BUN_DIR} \
-  && make mimalloc \
+  && bash ./scripts/build-mimalloc.sh \
   && rm -rf src/deps/mimalloc Makefile
 
 FROM bun-base as mimalloc-debug
@@ -232,14 +251,17 @@ ARG CCACHE_DIR=/ccache
 ENV CCACHE_DIR=${CCACHE_DIR}
 
 COPY Makefile ${BUN_DIR}/Makefile
+COPY CMakeLists.txt ${BUN_DIR}/CMakeLists.txt
+COPY scripts ${BUN_DIR}/scripts
 COPY src/deps/zlib ${BUN_DIR}/src/deps/zlib
+COPY package.json bun.lockb Makefile .gitmodules ${BUN_DIR}/
 
 WORKDIR $BUN_DIR
 
 RUN --mount=type=cache,target=${CCACHE_DIR} \
   cd $BUN_DIR \
-  && make zlib \
-  && rm -rf src/deps/zlib Makefile
+  && bash ./scripts/build-zlib.sh && rm -rf src/deps/zlib scripts
+
 
 FROM bun-base as libarchive
 
@@ -251,15 +273,14 @@ ENV CCACHE_DIR=${CCACHE_DIR}
 
 RUN install_packages autoconf automake libtool pkg-config 
 
-COPY Makefile ${BUN_DIR}/Makefile
+COPY scripts ${BUN_DIR}/scripts
 COPY src/deps/libarchive ${BUN_DIR}/src/deps/libarchive
 
 WORKDIR $BUN_DIR
 
 RUN --mount=type=cache,target=${CCACHE_DIR} \
   cd $BUN_DIR \
-  && make libarchive \
-  && rm -rf src/deps/libarchive Makefile
+  && bash ./scripts/build-libarchive.sh && rm -rf src/deps/libarchive .scripts
 
 FROM bun-base as tinycc
 
@@ -279,6 +300,7 @@ ARG CPU_TARGET
 ENV CPU_TARGET=${CPU_TARGET}
 
 COPY Makefile ${BUN_DIR}/Makefile
+COPY scripts ${BUN_DIR}/scripts
 COPY src/deps/boringssl ${BUN_DIR}/src/deps/boringssl
 
 WORKDIR $BUN_DIR
@@ -288,22 +310,9 @@ ENV CCACHE_DIR=${CCACHE_DIR}
 
 RUN --mount=type=cache,target=${CCACHE_DIR} \
   cd ${BUN_DIR} \
-  && make boringssl \
+  && bash ./scripts/build-boringssl.sh \
   && rm -rf src/deps/boringssl Makefile
 
-FROM bun-base as base64
-
-ARG BUN_DIR
-ARG CPU_TARGET
-ENV CPU_TARGET=${CPU_TARGET}
-
-COPY Makefile ${BUN_DIR}/Makefile
-COPY src/deps/base64 ${BUN_DIR}/src/deps/base64
-
-WORKDIR $BUN_DIR
-
-RUN cd $BUN_DIR && \
-  make base64 && rm -rf src/deps/base64 Makefile
 
 FROM bun-base as zstd
 
@@ -317,12 +326,14 @@ ENV CCACHE_DIR=${CCACHE_DIR}
 
 COPY Makefile ${BUN_DIR}/Makefile
 COPY src/deps/zstd ${BUN_DIR}/src/deps/zstd
+COPY scripts ${BUN_DIR}/scripts
 
 WORKDIR $BUN_DIR
 
 RUN --mount=type=cache,target=${CCACHE_DIR} \
   cd $BUN_DIR \
-  && make zstd
+  && bash ./scripts/build-zstd.sh \
+  && rm -rf src/deps/zstd scripts
 
 FROM bun-base as ls-hpack
 
@@ -336,12 +347,14 @@ ENV CCACHE_DIR=${CCACHE_DIR}
 
 COPY Makefile ${BUN_DIR}/Makefile
 COPY src/deps/ls-hpack ${BUN_DIR}/src/deps/ls-hpack
+COPY scripts ${BUN_DIR}/scripts
 
 WORKDIR $BUN_DIR
 
 RUN --mount=type=cache,target=${CCACHE_DIR} \
   cd $BUN_DIR \
-  && make lshpack
+  && bash ./scripts/build-lshpack.sh \
+  && rm -rf src/deps/ls-hpack scripts
 
 FROM bun-base-with-zig as bun-identifier-cache
 
@@ -414,6 +427,7 @@ COPY package.json bun.lockb Makefile .gitmodules ${BUN_DIR}/
 COPY src/runtime ${BUN_DIR}/src/runtime
 COPY src/runtime.js src/runtime.bun.js ${BUN_DIR}/src/
 COPY packages/bun-error ${BUN_DIR}/packages/bun-error
+COPY packages/bun-types ${BUN_DIR}/packages/bun-types
 COPY src/fallback.ts ${BUN_DIR}/src/fallback.ts
 COPY src/api ${BUN_DIR}/src/api
 
@@ -451,7 +465,7 @@ COPY --from=bun-codegen-for-zig ${BUN_DIR}/packages/bun-error/dist ${BUN_DIR}/pa
 WORKDIR $BUN_DIR
 
 RUN --mount=type=cache,target=${CCACHE_DIR} \
-    --mount=type=cache,target=${ZIG_LOCAL_CACHE_DIR} \
+  --mount=type=cache,target=${ZIG_LOCAL_CACHE_DIR} \
   mkdir -p build \
   && bun run $BUN_DIR/src/codegen/bundle-modules.ts --debug=OFF $BUN_DIR/build \
   && cd build \
@@ -465,7 +479,7 @@ RUN --mount=type=cache,target=${CCACHE_DIR} \
   -DWEBKIT_DIR="omit" \
   -DNO_CONFIGURE_DEPENDS=1 \
   -DNO_CODEGEN=1 \
-  -DBUN_ZIG_OBJ="/tmp/bun-zig.o" \
+  -DBUN_ZIG_OBJ_DIR="/tmp" \
   -DCANARY="${CANARY}" \
   -DZIG_COMPILER=system \
   -DZIG_LIB_DIR=$BUN_DIR/src/deps/zig/lib \
@@ -496,12 +510,12 @@ RUN mkdir -p build bun-webkit
 
 # lol
 COPY src/bun.js/bindings/sqlite/sqlite3.c ${BUN_DIR}/src/bun.js/bindings/sqlite/sqlite3.c
+COPY src/deps/brotli ${BUN_DIR}/src/deps/brotli
 
 COPY src/symbols.dyn src/linker.lds ${BUN_DIR}/src/
 
 COPY CMakeLists.txt ${BUN_DIR}/CMakeLists.txt
 COPY --from=zlib ${BUN_DEPS_OUT_DIR}/* ${BUN_DEPS_OUT_DIR}/
-COPY --from=base64 ${BUN_DEPS_OUT_DIR}/* ${BUN_DEPS_OUT_DIR}/
 COPY --from=libarchive ${BUN_DEPS_OUT_DIR}/* ${BUN_DEPS_OUT_DIR}/
 COPY --from=boringssl ${BUN_DEPS_OUT_DIR}/* ${BUN_DEPS_OUT_DIR}/
 COPY --from=lolhtml ${BUN_DEPS_OUT_DIR}/* ${BUN_DEPS_OUT_DIR}/
@@ -511,18 +525,19 @@ COPY --from=tinycc ${BUN_DEPS_OUT_DIR}/* ${BUN_DEPS_OUT_DIR}/
 COPY --from=c-ares ${BUN_DEPS_OUT_DIR}/* ${BUN_DEPS_OUT_DIR}/
 COPY --from=ls-hpack ${BUN_DEPS_OUT_DIR}/* ${BUN_DEPS_OUT_DIR}/
 COPY --from=bun-compile-zig-obj /tmp/bun-zig.o ${BUN_DIR}/build/bun-zig.o
-COPY --from=bun-cpp-objects ${BUN_DIR}/build/bun-cpp-objects.a ${BUN_DIR}/build/bun-cpp-objects.a
+COPY --from=bun-cpp-objects ${BUN_DIR}/build/*.a ${BUN_DIR}/build/
+COPY --from=bun-cpp-objects ${BUN_DIR}/build/*.o ${BUN_DIR}/build/ 
 COPY --from=bun-cpp-objects ${BUN_DIR}/bun-webkit/lib ${BUN_DIR}/bun-webkit/lib
 
 WORKDIR $BUN_DIR/build
 
 RUN --mount=type=cache,target=${CCACHE_DIR} \
-    --mount=type=cache,target=${ZIG_LOCAL_CACHE_DIR} \
+  --mount=type=cache,target=${ZIG_LOCAL_CACHE_DIR} \
   cmake .. \
   -G Ninja \
   -DCMAKE_BUILD_TYPE=Release \
   -DBUN_LINK_ONLY=1 \
-  -DBUN_ZIG_OBJ="${BUN_DIR}/build/bun-zig.o" \
+  -DBUN_ZIG_OBJ_DIR="${BUN_DIR}/build" \
   -DUSE_LTO=ON \
   -DUSE_DEBUG_JSC=${ASSERTIONS} \
   -DBUN_CPP_ARCHIVE="${BUN_DIR}/build/bun-cpp-objects.a" \
@@ -565,7 +580,6 @@ COPY src/symbols.dyn src/linker.lds ${BUN_DIR}/src/
 
 COPY CMakeLists.txt ${BUN_DIR}/CMakeLists.txt
 COPY --from=zlib ${BUN_DEPS_OUT_DIR}/* ${BUN_DEPS_OUT_DIR}/
-COPY --from=base64 ${BUN_DEPS_OUT_DIR}/* ${BUN_DEPS_OUT_DIR}/
 COPY --from=libarchive ${BUN_DEPS_OUT_DIR}/* ${BUN_DEPS_OUT_DIR}/
 COPY --from=boringssl ${BUN_DEPS_OUT_DIR}/* ${BUN_DEPS_OUT_DIR}/
 COPY --from=lolhtml ${BUN_DEPS_OUT_DIR}/* ${BUN_DEPS_OUT_DIR}/
@@ -580,12 +594,12 @@ COPY --from=bun-cpp-objects ${BUN_DIR}/bun-webkit/lib ${BUN_DIR}/bun-webkit/lib
 WORKDIR $BUN_DIR/build
 
 RUN --mount=type=cache,target=${CCACHE_DIR} \
-    --mount=type=cache,target=${ZIG_LOCAL_CACHE_DIR} \
+  --mount=type=cache,target=${ZIG_LOCAL_CACHE_DIR} \
   cmake .. \
   -G Ninja \
   -DCMAKE_BUILD_TYPE=Release \
   -DBUN_LINK_ONLY=1 \
-  -DBUN_ZIG_OBJ="${BUN_DIR}/build/bun-zig.o" \
+  -DBUN_ZIG_OBJ_DIR="${BUN_DIR}/build" \
   -DUSE_DEBUG_JSC=ON \
   -DBUN_CPP_ARCHIVE="${BUN_DIR}/build/bun-cpp-objects.a" \
   -DWEBKIT_DIR="${BUN_DIR}/bun-webkit" \

LATEST

@@ -0,0 +1 @@
+1.1.20

LICENSE.md

@@ -0,0 +1,71 @@
+Bun itself is MIT-licensed.
+
+## JavaScriptCore
+
+Bun statically links JavaScriptCore (and WebKit) which is LGPL-2 licensed. WebCore files from WebKit are also licensed under LGPL2. Per LGPL2:
+
+> (1) If you statically link against an LGPL’d library, you must also provide your application in an object (not necessarily source) format, so that a user has the opportunity to modify the library and relink the application.
+
+You can find the patched version of WebKit used by Bun here: <https://github.com/oven-sh/webkit>. If you would like to relink Bun with changes:
+
+- `git submodule update --init --recursive`
+- `make jsc`
+- `zig build`
+
+This compiles JavaScriptCore, compiles Bun’s `.cpp` bindings for JavaScriptCore (which are the object files using JavaScriptCore) and outputs a new `bun` binary with your changes.
+
+## Linked libraries
+
+Bun statically links these libraries:
+
+| Library | License |
+|---------|---------|
+| [`boringssl`](https://boringssl.googlesource.com/boringssl/) | [several licenses](https://boringssl.googlesource.com/boringssl/+/refs/heads/master/LICENSE) |
+| [`brotli`](https://github.com/google/brotli) | MIT |
+| [`libarchive`](https://github.com/libarchive/libarchive) | [several licenses](https://github.com/libarchive/libarchive/blob/master/COPYING) |
+| [`lol-html`](https://github.com/cloudflare/lol-html/tree/master/c-api) | BSD 3-Clause |
+| [`mimalloc`](https://github.com/microsoft/mimalloc) | MIT |
+| [`picohttp`](https://github.com/h2o/picohttpparser) | dual-licensed under the Perl License or the MIT License |
+| [`zstd`](https://github.com/facebook/zstd) | dual-licensed under the BSD License or GPLv2 license |
+| [`simdutf`](https://github.com/simdutf/simdutf) | Apache 2.0 |
+| [`tinycc`](https://github.com/tinycc/tinycc) | LGPL v2.1 |
+| [`uSockets`](https://github.com/uNetworking/uSockets) | Apache 2.0 |
+| [`zlib-cloudflare`](https://github.com/cloudflare/zlib) | zlib |
+| [`c-ares`](https://github.com/c-ares/c-ares) | MIT licensed |
+| [`libicu`](https://github.com/unicode-org/icu) 72 | [license here](https://github.com/unicode-org/icu/blob/main/icu4c/LICENSE) |
+| [`libbase64`](https://github.com/aklomp/base64/blob/master/LICENSE) | BSD 2-Clause |
+| A fork of [`uWebsockets`](https://github.com/jarred-sumner/uwebsockets) | Apache 2.0 licensed |
+| Parts of [Tigerbeetle's IO code](https://github.com/tigerbeetle/tigerbeetle/blob/532c8b70b9142c17e07737ab6d3da68d7500cbca/src/io/windows.zig#L1) | Apache 2.0 licensed |
+
+## Polyfills
+
+For compatibility reasons, the following packages are embedded into Bun's binary and injected if imported.
+
+| Package | License |
+|---------|---------|
+| [`assert`](https://npmjs.com/package/assert) | MIT |
+| [`browserify-zlib`](https://npmjs.com/package/browserify-zlib) | MIT |
+| [`buffer`](https://npmjs.com/package/buffer) | MIT |
+| [`constants-browserify`](https://npmjs.com/package/constants-browserify) | MIT |
+| [`crypto-browserify`](https://npmjs.com/package/crypto-browserify) | MIT |
+| [`domain-browser`](https://npmjs.com/package/domain-browser) | MIT |
+| [`events`](https://npmjs.com/package/events) | MIT |
+| [`https-browserify`](https://npmjs.com/package/https-browserify) | MIT |
+| [`os-browserify`](https://npmjs.com/package/os-browserify) | MIT |
+| [`path-browserify`](https://npmjs.com/package/path-browserify) | MIT |
+| [`process`](https://npmjs.com/package/process) | MIT |
+| [`punycode`](https://npmjs.com/package/punycode) | MIT |
+| [`querystring-es3`](https://npmjs.com/package/querystring-es3) | MIT |
+| [`stream-browserify`](https://npmjs.com/package/stream-browserify) | MIT |
+| [`stream-http`](https://npmjs.com/package/stream-http) | MIT |
+| [`string_decoder`](https://npmjs.com/package/string_decoder) | MIT |
+| [`timers-browserify`](https://npmjs.com/package/timers-browserify) | MIT |
+| [`tty-browserify`](https://npmjs.com/package/tty-browserify) | MIT |
+| [`url`](https://npmjs.com/package/url) | MIT |
+| [`util`](https://npmjs.com/package/util) | MIT |
+| [`vm-browserify`](https://npmjs.com/package/vm-browserify) | MIT |
+
+## Additional credits
+
+- Bun's JS transpiler, CSS lexer, and Node.js module resolver source code is a Zig port of [@evanw](https://github.com/evanw)’s [esbuild](https://github.com/evanw/esbuild) project.
+- Credit to [@kipply](https://github.com/kipply) for the name "Bun"!

Makefile

@@ -26,8 +26,11 @@ ifeq ($(ARCH_NAME_RAW),arm64)
 ARCH_NAME = aarch64
 DOCKER_BUILDARCH = arm64
 BREW_PREFIX_PATH = /opt/homebrew
-DEFAULT_MIN_MACOS_VERSION = 11.0
+DEFAULT_MIN_MACOS_VERSION = 13.0
 MARCH_NATIVE = -mtune=$(CPU_TARGET)
+ifeq ($(OS_NAME),linux)
+MARCH_NATIVE = -march=armv8-a+crc -mtune=ampere1
+endif
 else
 ARCH_NAME = x64
 DOCKER_BUILDARCH = amd64
@@ -129,7 +132,7 @@ SED = $(shell which gsed 2>/dev/null || which sed 2>/dev/null)
 
 BUN_DIR ?= $(shell dirname $(realpath $(firstword $(MAKEFILE_LIST))))
 BUN_DEPS_DIR ?= $(shell pwd)/src/deps
-BUN_DEPS_OUT_DIR ?= $(BUN_DEPS_DIR)
+BUN_DEPS_OUT_DIR ?= $(shell pwd)/build/bun-deps
 CPU_COUNT = 2
 ifeq ($(OS_NAME),darwin)
 CPU_COUNT = $(shell sysctl -n hw.logicalcpu)
@@ -154,7 +157,12 @@ CMAKE_FLAGS_WITHOUT_RELEASE = -DCMAKE_C_COMPILER=$(CC) \
 	-DCMAKE_OSX_DEPLOYMENT_TARGET=$(MIN_MACOS_VERSION) \
 	$(CMAKE_CXX_COMPILER_LAUNCHER_FLAG) \
 	-DCMAKE_AR=$(AR) \
-    -DCMAKE_RANLIB=$(which llvm-16-ranlib 2>/dev/null || which llvm-ranlib 2>/dev/null)
+	-DCMAKE_RANLIB=$(which llvm-16-ranlib 2>/dev/null || which llvm-ranlib 2>/dev/null) \
+	-DCMAKE_CXX_STANDARD=20 \
+	-DCMAKE_C_STANDARD=17 \
+	-DCMAKE_CXX_STANDARD_REQUIRED=ON \
+	-DCMAKE_C_STANDARD_REQUIRED=ON \
+	-DCMAKE_CXX_EXTENSIONS=ON 
 
 
 
@@ -181,8 +189,8 @@ endif
 
 OPTIMIZATION_LEVEL=-O3 $(MARCH_NATIVE)
 DEBUG_OPTIMIZATION_LEVEL= -O1 $(MARCH_NATIVE) -gdwarf-4
-CFLAGS_WITHOUT_MARCH = $(MACOS_MIN_FLAG) $(OPTIMIZATION_LEVEL) -fno-exceptions -fvisibility=hidden -fvisibility-inlines-hidden
-BUN_CFLAGS = $(MACOS_MIN_FLAG) $(MARCH_NATIVE)  $(OPTIMIZATION_LEVEL) -fno-exceptions -fvisibility=hidden -fvisibility-inlines-hidden
+CFLAGS_WITHOUT_MARCH = $(MACOS_MIN_FLAG) $(OPTIMIZATION_LEVEL) -fno-exceptions -fvisibility=hidden -fvisibility-inlines-hidden -mno-omit-leaf-frame-pointer -fno-omit-frame-pointer -fno-asynchronous-unwind-tables -fno-unwind-tables -fno-pie -fno-pic
+BUN_CFLAGS = $(MACOS_MIN_FLAG) $(MARCH_NATIVE)  $(OPTIMIZATION_LEVEL) -fno-exceptions -fvisibility=hidden -fvisibility-inlines-hidden  -mno-omit-leaf-frame-pointer -fno-omit-frame-pointer -fno-asynchronous-unwind-tables -fno-unwind-tables -fno-pie -fno-pic
 BUN_TMP_DIR := /tmp/make-bun
 CFLAGS=$(CFLAGS_WITHOUT_MARCH) $(MARCH_NATIVE)
 
@@ -231,14 +239,17 @@ _MIMALLOC_LINK = $(BUN_DEPS_OUT_DIR)/$(MIMALLOC_FILE)
 DEFAULT_LINKER_FLAGS =
 
 JSC_BUILD_STEPS :=
+JSC_BUILD_STEPS_DEBUG :=
 ifeq ($(OS_NAME),linux)
 	JSC_BUILD_STEPS += jsc-build-linux
+	JSC_BUILD_STEPS_DEBUG += jsc-build-linux-debug
 	_MIMALLOC_LINK = $(BUN_DEPS_OUT_DIR)/$(MIMALLOC_FILE)
 DEFAULT_LINKER_FLAGS= -pthread -ldl
 endif
 ifeq ($(OS_NAME),darwin)
     _MIMALLOC_OBJECT_FILE = 0
 	JSC_BUILD_STEPS += jsc-build-mac jsc-copy-headers
+	JSC_BUILD_STEPS_DEBUG += jsc-build-mac-debug
 	_MIMALLOC_FILE = libmimalloc.a
 	_MIMALLOC_INPUT_PATH = libmimalloc.a
 	_MIMALLOC_LINK = -lmimalloc
@@ -446,8 +457,7 @@ MINIMUM_ARCHIVE_FILES = -L$(BUN_DEPS_OUT_DIR) \
 	-ldecrepit \
 	-lssl \
 	-lcrypto \
-	-llolhtml \
-	-lbase64
+	-llolhtml
 
 ARCHIVE_FILES_WITHOUT_LIBCRYPTO = $(MINIMUM_ARCHIVE_FILES) \
 		-larchive \
@@ -917,8 +927,12 @@ bun-codesign-release-local-debug:
 
 .PHONY: jsc
 jsc: jsc-build jsc-copy-headers jsc-bindings
+.PHONY: jsc-debug
+jsc-debug: jsc-build-debug jsc-copy-headers-debug
 .PHONY: jsc-build
 jsc-build: $(JSC_BUILD_STEPS)
+.PHONY: jsc-build-debug
+jsc-build-debug: $(JSC_BUILD_STEPS_DEBUG)
 .PHONY: jsc-bindings
 jsc-bindings: headers bindings
 
@@ -1175,6 +1189,57 @@ jsc-copy-headers:
 	cp $(WEBKIT_DIR)/Source/JavaScriptCore/API/JSWeakValue.h  $(WEBKIT_RELEASE_DIR)/JavaScriptCore/PrivateHeaders/JavaScriptCore/JSWeakValue.h
 	find $(WEBKIT_RELEASE_DIR)/JavaScriptCore/Headers/JavaScriptCore/ -name "*.h" -exec cp {} $(WEBKIT_RELEASE_DIR)/JavaScriptCore/PrivateHeaders/JavaScriptCore/ \;
 
+jsc-copy-headers-debug:
+	cp $(WEBKIT_DIR)/Source/JavaScriptCore/heap/WeakHandleOwner.h $(WEBKIT_DEBUG_DIR)/JavaScriptCore/PrivateHeaders/JavaScriptCore/WeakHandleOwner.h
+	cp $(WEBKIT_DIR)/Source/JavaScriptCore/runtime/LazyClassStructureInlines.h $(WEBKIT_DEBUG_DIR)/JavaScriptCore/PrivateHeaders/JavaScriptCore/LazyClassStructureInlines.h
+	cp $(WEBKIT_DIR)/Source/JavaScriptCore/runtime/LazyPropertyInlines.h $(WEBKIT_DEBUG_DIR)/JavaScriptCore/PrivateHeaders/JavaScriptCore/LazyPropertyInlines.h
+	cp $(WEBKIT_DIR)/Source/JavaScriptCore/runtime/JSTypedArrayViewPrototype.h $(WEBKIT_DEBUG_DIR)/JavaScriptCore/PrivateHeaders/JavaScriptCore/JSTypedArrayViewPrototype.h
+	cp $(WEBKIT_DIR)/Source/JavaScriptCore/runtime/JSTypedArrayPrototypes.h $(WEBKIT_DEBUG_DIR)/JavaScriptCore/PrivateHeaders/JavaScriptCore/JSTypedArrayPrototypes.h
+	cp $(WEBKIT_DIR)/Source/JavaScriptCore/runtime/JSModuleNamespaceObject.h $(WEBKIT_DEBUG_DIR)/JavaScriptCore/PrivateHeaders/JavaScriptCore/JSModuleNamespaceObject.h
+	cp $(WEBKIT_DIR)/Source/JavaScriptCore/jit/JIT.h $(WEBKIT_DEBUG_DIR)/JavaScriptCore/PrivateHeaders/JavaScriptCore/JIT.h
+	cp $(WEBKIT_DIR)/Source/JavaScriptCore/bytecode/StructureStubInfo.h $(WEBKIT_DEBUG_DIR)/JavaScriptCore/PrivateHeaders/JavaScriptCore/StructureStubInfo.h
+	cp $(WEBKIT_DIR)/Source/JavaScriptCore/bytecode/AccessCase.h $(WEBKIT_DEBUG_DIR)/JavaScriptCore/PrivateHeaders/JavaScriptCore/AccessCase.h
+	cp $(WEBKIT_DIR)/Source/JavaScriptCore/bytecode/ObjectPropertyConditionSet.h $(WEBKIT_DEBUG_DIR)/JavaScriptCore/PrivateHeaders/JavaScriptCore/ObjectPropertyConditionSet.h
+	cp $(WEBKIT_DIR)/Source/JavaScriptCore/bytecode/PolyProtoAccessChain.h $(WEBKIT_DEBUG_DIR)/JavaScriptCore/PrivateHeaders/JavaScriptCore/PolyProtoAccessChain.h
+	cp $(WEBKIT_DIR)/Source/JavaScriptCore/bytecode/InlineCacheCompiler.h $(WEBKIT_DEBUG_DIR)/JavaScriptCore/PrivateHeaders/JavaScriptCore/InlineCacheCompiler.h
+	cp $(WEBKIT_DIR)/Source/JavaScriptCore/bytecode/StructureStubClearingWatchpoint.h $(WEBKIT_DEBUG_DIR)/JavaScriptCore/PrivateHeaders/JavaScriptCore/StructureStubClearingWatchpoint.h
+	cp $(WEBKIT_DIR)/Source/JavaScriptCore/bytecode/AdaptiveInferredPropertyValueWatchpointBase.h $(WEBKIT_DEBUG_DIR)/JavaScriptCore/PrivateHeaders/JavaScriptCore/AdaptiveInferredPropertyValueWatchpointBase.h
+	cp $(WEBKIT_DIR)/Source/JavaScriptCore/bytecode/StubInfoSummary.h $(WEBKIT_DEBUG_DIR)/JavaScriptCore/PrivateHeaders/JavaScriptCore/StubInfoSummary.h
+	cp $(WEBKIT_DIR)/Source/JavaScriptCore/runtime/CommonSlowPaths.h $(WEBKIT_DEBUG_DIR)/JavaScriptCore/PrivateHeaders/JavaScriptCore/CommonSlowPaths.h
+	cp $(WEBKIT_DIR)/Source/JavaScriptCore/runtime/DirectArguments.h $(WEBKIT_DEBUG_DIR)/JavaScriptCore/PrivateHeaders/JavaScriptCore/DirectArguments.h
+	cp $(WEBKIT_DIR)/Source/JavaScriptCore/runtime/GenericArguments.h $(WEBKIT_DEBUG_DIR)/JavaScriptCore/PrivateHeaders/JavaScriptCore/GenericArguments.h
+	cp $(WEBKIT_DIR)/Source/JavaScriptCore/runtime/SamplingProfiler.h $(WEBKIT_DEBUG_DIR)/JavaScriptCore/PrivateHeaders/JavaScriptCore/SamplingProfiler.h
+	cp $(WEBKIT_DIR)/Source/JavaScriptCore/runtime/ScopedArguments.h $(WEBKIT_DEBUG_DIR)/JavaScriptCore/PrivateHeaders/JavaScriptCore/ScopedArguments.h
+	cp $(WEBKIT_DIR)/Source/JavaScriptCore/runtime/JSLexicalEnvironment.h $(WEBKIT_DEBUG_DIR)/JavaScriptCore/PrivateHeaders/JavaScriptCore/JSLexicalEnvironment.h
+	cp $(WEBKIT_DIR)/Source/JavaScriptCore/jit/JITDisassembler.h $(WEBKIT_DEBUG_DIR)/JavaScriptCore/PrivateHeaders/JavaScriptCore/JITDisassembler.h
+	cp $(WEBKIT_DIR)/Source/JavaScriptCore/jit/JITInlineCacheGenerator.h $(WEBKIT_DEBUG_DIR)/JavaScriptCore/PrivateHeaders/JavaScriptCore/JITInlineCacheGenerator.h
+	cp $(WEBKIT_DIR)/Source/JavaScriptCore/jit/JITMathIC.h $(WEBKIT_DEBUG_DIR)/JavaScriptCore/PrivateHeaders/JavaScriptCore/JITMathIC.h
+	cp $(WEBKIT_DIR)/Source/JavaScriptCore/jit/JITAddGenerator.h $(WEBKIT_DEBUG_DIR)/JavaScriptCore/PrivateHeaders/JavaScriptCore/JITAddGenerator.h
+	cp $(WEBKIT_DIR)/Source/JavaScriptCore/jit/JITMathICInlineResult.h $(WEBKIT_DEBUG_DIR)/JavaScriptCore/PrivateHeaders/JavaScriptCore/JITMathICInlineResult.h
+	cp $(WEBKIT_DIR)/Source/JavaScriptCore/jit/SnippetOperand.h $(WEBKIT_DEBUG_DIR)/JavaScriptCore/PrivateHeaders/JavaScriptCore/SnippetOperand.h
+	cp $(WEBKIT_DIR)/Source/JavaScriptCore/jit/JITMulGenerator.h $(WEBKIT_DEBUG_DIR)/JavaScriptCore/PrivateHeaders/JavaScriptCore/JITMulGenerator.h
+	cp $(WEBKIT_DIR)/Source/JavaScriptCore/jit/JITNegGenerator.h $(WEBKIT_DEBUG_DIR)/JavaScriptCore/PrivateHeaders/JavaScriptCore/JITNegGenerator.h
+	cp $(WEBKIT_DIR)/Source/JavaScriptCore/jit/JITSubGenerator.h $(WEBKIT_DEBUG_DIR)/JavaScriptCore/PrivateHeaders/JavaScriptCore/JITSubGenerator.h
+	cp $(WEBKIT_DIR)/Source/JavaScriptCore/bytecode/Repatch.h $(WEBKIT_DEBUG_DIR)/JavaScriptCore/PrivateHeaders/JavaScriptCore/Repatch.h
+	cp $(WEBKIT_DIR)/Source/JavaScriptCore/jit/JITRightShiftGenerator.h $(WEBKIT_DEBUG_DIR)/JavaScriptCore/PrivateHeaders/JavaScriptCore/JITRightShiftGenerator.h
+	cp $(WEBKIT_DIR)/Source/JavaScriptCore/jit/JITBitBinaryOpGenerator.h $(WEBKIT_DEBUG_DIR)/JavaScriptCore/PrivateHeaders/JavaScriptCore/JITBitBinaryOpGenerator.h
+	cp $(WEBKIT_DIR)/Source/JavaScriptCore/jit/JSInterfaceJIT.h $(WEBKIT_DEBUG_DIR)/JavaScriptCore/PrivateHeaders/JavaScriptCore/JSInterfaceJIT.h
+	cp $(WEBKIT_DIR)/Source/JavaScriptCore/llint/LLIntData.h $(WEBKIT_DEBUG_DIR)/JavaScriptCore/PrivateHeaders/JavaScriptCore/LLIntData.h
+	cp $(WEBKIT_DIR)/Source/JavaScriptCore/bytecode/FunctionCodeBlock.h $(WEBKIT_DEBUG_DIR)/JavaScriptCore/PrivateHeaders/JavaScriptCore/FunctionCodeBlock.h
+	cp $(WEBKIT_DIR)/Source/JavaScriptCore/dfg/DFGAbstractHeap.h $(WEBKIT_DEBUG_DIR)/JavaScriptCore/PrivateHeaders/JavaScriptCore/DFGAbstractHeap.h
+	cp $(WEBKIT_DIR)/Source/JavaScriptCore/bytecode/OperandsInlines.h $(WEBKIT_DEBUG_DIR)/JavaScriptCore/PrivateHeaders/JavaScriptCore/OperandsInlines.h
+	cp $(WEBKIT_DIR)/Source/JavaScriptCore/bytecode/Operands.h $(WEBKIT_DEBUG_DIR)/JavaScriptCore/PrivateHeaders/JavaScriptCore/Operands.h
+	cp $(WEBKIT_DIR)/Source/JavaScriptCore/domjit/DOMJITHeapRange.h $(WEBKIT_DEBUG_DIR)/JavaScriptCore/PrivateHeaders/JavaScriptCore/DOMJITHeapRange.h
+	cp $(WEBKIT_DIR)/Source/JavaScriptCore/runtime/GeneratorPrototype.h $(WEBKIT_DEBUG_DIR)/JavaScriptCore/PrivateHeaders/JavaScriptCore/GeneratorPrototype.h
+	cp $(WEBKIT_DIR)/Source/JavaScriptCore/runtime/GeneratorFunctionPrototype.h $(WEBKIT_DEBUG_DIR)/JavaScriptCore/PrivateHeaders/JavaScriptCore/GeneratorFunctionPrototype.h
+	cp $(WEBKIT_DIR)/Source/JavaScriptCore/runtime/AsyncFunctionPrototype.h $(WEBKIT_DEBUG_DIR)/JavaScriptCore/PrivateHeaders/JavaScriptCore/AsyncFunctionPrototype.h
+	cp $(WEBKIT_DIR)/Source/JavaScriptCore/runtime/SymbolObject.h $(WEBKIT_DEBUG_DIR)/JavaScriptCore/PrivateHeaders/JavaScriptCore/SymbolObject.h
+	cp $(WEBKIT_DIR)/Source/JavaScriptCore/runtime/JSGenerator.h $(WEBKIT_DEBUG_DIR)/JavaScriptCore/PrivateHeaders/JavaScriptCore/JSGenerator.h
+	cp $(WEBKIT_DIR)/Source/JavaScriptCore/bytecode/UnlinkedFunctionCodeBlock.h $(WEBKIT_DEBUG_DIR)/JavaScriptCore/PrivateHeaders/JavaScriptCore/UnlinkedFunctionCodeBlock.h
+	cp $(WEBKIT_DIR)/Source/JavaScriptCore/runtime/AggregateError.h $(WEBKIT_DEBUG_DIR)/JavaScriptCore/PrivateHeaders/JavaScriptCore/AggregateError.h
+	cp $(WEBKIT_DIR)/Source/JavaScriptCore/API/JSWeakValue.h  $(WEBKIT_DEBUG_DIR)/JavaScriptCore/PrivateHeaders/JavaScriptCore/JSWeakValue.h
+	find $(WEBKIT_DEBUG_DIR)/JavaScriptCore/Headers/JavaScriptCore/ -name "*.h" -exec cp {} $(WEBKIT_DEBUG_DIR)/JavaScriptCore/PrivateHeaders/JavaScriptCore/ \;
+
 # This is a workaround for a JSC bug that impacts aarch64
 # on macOS, it never requests JIT permissions
 .PHONY: jsc-force-fastjit
@@ -1266,7 +1331,8 @@ jsc-build-linux-compile-config:
 		cmake \
 			-DPORT="JSCOnly" \
 			-DENABLE_STATIC_JSC=ON \
-			-DCMAKE_BUILD_TYPE=Release \
+			-DCMAKE_BUILD_TYPE=Debug \
+			-DENABLE_BUN_SKIP_FAILING_ASSERTIONS=ON \
 			-DUSE_THIN_ARCHIVES=OFF \
 			-DUSE_BUN_JSC_ADDITIONS=ON \
 			-DENABLE_FTL_JIT=ON \
@@ -1281,6 +1347,29 @@ jsc-build-linux-compile-config:
 			$(WEBKIT_DIR) \
 			$(WEBKIT_RELEASE_DIR)
 
+.PHONY: jsc-build-linux-compile-config-debug
+jsc-build-linux-compile-config-debug:
+	mkdir -p $(WEBKIT_DEBUG_DIR)
+	cd $(WEBKIT_DEBUG_DIR) && \
+		cmake \
+			-DPORT="JSCOnly" \
+			-DENABLE_STATIC_JSC=ON \
+			-DCMAKE_BUILD_TYPE=Debug \
+			-DENABLE_BUN_SKIP_FAILING_ASSERTIONS=ON \
+			-DUSE_THIN_ARCHIVES=OFF \
+			-DUSE_BUN_JSC_ADDITIONS=ON \
+			-DENABLE_FTL_JIT=ON \
+			-DENABLE_REMOTE_INSPECTOR=ON \
+			-DJSEXPORT_PRIVATE=WTF_EXPORT_DECLARATION \
+			-DALLOW_LINE_AND_COLUMN_NUMBER_IN_BUILTINS=ON \
+			-USE_VISIBILITY_ATTRIBUTE=1 \
+			-DCMAKE_EXPORT_COMPILE_COMMANDS=ON \
+			-G Ninja \
+			-DCMAKE_CXX_COMPILER=$(CXX) \
+			-DCMAKE_C_COMPILER=$(CC) \
+			$(WEBKIT_DIR) \
+			$(WEBKIT_DEBUG_DIR)
+
 # If you get "Error: could not load cache"
 # run  rm -rf src/bun.js/WebKit/CMakeCache.txt
 .PHONY: jsc-build-linux-compile-build
@@ -1290,17 +1379,32 @@ jsc-build-linux-compile-build:
 	CFLAGS="$(CFLAGS) -Wl,--whole-archive -ffat-lto-objects" CXXFLAGS="$(CXXFLAGS) -Wl,--whole-archive -ffat-lto-objects -DUSE_BUN_JSC_ADDITIONS=ON" \
 		cmake --build $(WEBKIT_RELEASE_DIR) --config relwithdebuginfo --target jsc
 
+.PHONY: jsc-build-linux-compile-build-debug
+jsc-build-linux-compile-build-debug:
+		mkdir -p $(WEBKIT_DEBUG_DIR)  && \
+		cd $(WEBKIT_DEBUG_DIR)  && \
+	CFLAGS="$(CFLAGS) -Wl,--whole-archive -ffat-lto-objects" CXXFLAGS="$(CXXFLAGS) -Wl,--whole-archive -ffat-lto-objects -DUSE_BUN_JSC_ADDITIONS=ON" \
+		cmake --build $(WEBKIT_DEBUG_DIR) --config Debug --target jsc
 
-jsc-build-mac: jsc-force-fastjit jsc-build-mac-compile jsc-build-mac-copy
 
-jsc-build-linux: jsc-build-linux-compile-config jsc-build-linux-compile-build jsc-build-mac-copy
+jsc-build-mac: jsc-force-fastjit jsc-build-mac-compile jsc-build-copy
+jsc-build-mac-debug: jsc-force-fastjit jsc-build-mac-compile-debug jsc-build-copy-debug
 
-jsc-build-mac-copy:
+jsc-build-linux: jsc-build-linux-compile-config jsc-build-linux-compile-build jsc-build-copy
+jsc-build-linux-debug: jsc-build-linux-compile-config-debug jsc-build-linux-compile-build-debug jsc-build-copy-debug
+
+jsc-build-copy:
 	cp $(WEBKIT_RELEASE_DIR)/lib/libJavaScriptCore.a $(BUN_DEPS_OUT_DIR)/libJavaScriptCore.a
 	#cp $(WEBKIT_RELEASE_DIR)/lib/libLowLevelInterpreterLib.a $(BUN_DEPS_OUT_DIR)/libLowLevelInterpreterLib.a
 	cp $(WEBKIT_RELEASE_DIR)/lib/libWTF.a $(BUN_DEPS_OUT_DIR)/libWTF.a
 	cp $(WEBKIT_RELEASE_DIR)/lib/libbmalloc.a $(BUN_DEPS_OUT_DIR)/libbmalloc.a
 
+jsc-build-copy-debug:
+	cp $(WEBKIT_DEBUG_DIR)/lib/libJavaScriptCore.a $(BUN_DEPS_OUT_DIR)/libJavaScriptCore.a
+	#cp $(WEBKIT_DEBUG_DIR)/lib/libLowLevelInterpreterLib.a $(BUN_DEPS_OUT_DIR)/libLowLevelInterpreterLib.a
+	cp $(WEBKIT_DEBUG_DIR)/lib/libWTF.a $(BUN_DEPS_OUT_DIR)/libWTF.a
+	cp $(WEBKIT_DEBUG_DIR)/lib/libbmalloc.a $(BUN_DEPS_OUT_DIR)/libbmalloc.a
+
 clean-jsc:
 	cd src/bun.js/WebKit && rm -rf **/CMakeCache.txt **/CMakeFiles && rm -rf src/bun.js/WebKit/WebKitBuild
 clean-bindings:
@@ -1874,11 +1978,6 @@ copy-to-bun-release-dir-bin:
 
 PACKAGE_MAP = --pkg-begin async_io $(BUN_DIR)/src/io/io_darwin.zig --pkg-begin bun $(BUN_DIR)/src/bun_redirect.zig --pkg-end --pkg-end --pkg-begin javascript_core $(BUN_DIR)/src/jsc.zig --pkg-begin bun $(BUN_DIR)/src/bun_redirect.zig --pkg-end --pkg-end --pkg-begin bun $(BUN_DIR)/src/bun_redirect.zig --pkg-end
 
-.PHONY: base64
-base64:
-	cd $(BUN_DEPS_DIR)/base64 && make clean && rm -rf CMakeCache.txt CMakeFiles && cmake $(CMAKE_FLAGS) . && make
-	cp $(BUN_DEPS_DIR)/base64/libbase64.a $(BUN_DEPS_OUT_DIR)/libbase64.a
-
 .PHONY: cold-jsc-start
 cold-jsc-start:
 	$(CXX_WITH_CCACHE) $(CLANG_FLAGS) \
@@ -1896,7 +1995,7 @@ cold-jsc-start:
 		misctools/cold-jsc-start.cpp -o cold-jsc-start
 
 .PHONY: vendor-without-npm
-vendor-without-npm: node-fallbacks runtime_js fallback_decoder bun_error mimalloc picohttp zlib boringssl libarchive lolhtml sqlite usockets uws lshpack tinycc c-ares zstd base64
+vendor-without-npm: node-fallbacks runtime_js fallback_decoder bun_error mimalloc picohttp zlib boringssl libarchive lolhtml sqlite usockets uws lshpack tinycc c-ares zstd
 
 
 .PHONY: vendor-without-check

README.md

@@ -90,42 +90,288 @@ bun upgrade --canary
   - [What is Bun?](https://bun.sh/docs/index)
   - [Installation](https://bun.sh/docs/installation)
   - [Quickstart](https://bun.sh/docs/quickstart)
-- CLI
-  - [`bun run`](https://bun.sh/docs/cli/run)
-  - [`bun install`](https://bun.sh/docs/cli/install)
-  - [`bun test`](https://bun.sh/docs/cli/test)
+  - [TypeScript](https://bun.sh/docs/typescript)
+
+- Templating
   - [`bun init`](https://bun.sh/docs/cli/init)
   - [`bun create`](https://bun.sh/docs/cli/bun-create)
-  - [`bunx`](https://bun.sh/docs/cli/bunx)
+
 - Runtime
-  - [Runtime](https://bun.sh/docs/runtime/index)
+  - [`bun run`](https://bun.sh/docs/cli/run)
+  - [File types](https://bun.sh/docs/runtime/loaders)
+  - [TypeScript](https://bun.sh/docs/runtime/typescript)
+  - [JSX](https://bun.sh/docs/runtime/jsx)
+  - [Environment variables](https://bun.sh/docs/runtime/env)
+  - [Bun APIs](https://bun.sh/docs/runtime/bun-apis)
+  - [Web APIs](https://bun.sh/docs/runtime/web-apis)
+  - [Node.js compatibility](https://bun.sh/docs/runtime/nodejs-apis)
+  - [Single-file executable](https://bun.sh/docs/bundler/executables)
+  - [Plugins](https://bun.sh/docs/runtime/plugins)
+  - [Watch mode](https://bun.sh/docs/runtime/hot)
   - [Module resolution](https://bun.sh/docs/runtime/modules)
-  - [Hot & live reloading](https://bun.sh/docs/runtime/hot)
+  - [Auto-install](https://bun.sh/docs/runtime/autoimport)
+  - [bunfig.toml](https://bun.sh/docs/runtime/bunfig)
+  - [Debugger](https://bun.sh/docs/runtime/debugger)
+  - [Framework API](https://bun.sh/docs/runtime/framework)
+
+- Package manager
+  - [`bun install`](https://bun.sh/docs/cli/install)
+  - [`bun add`](https://bun.sh/docs/cli/add)
+  - [`bun remove`](https://bun.sh/docs/cli/remove)
+  - [`bun update`](https://bun.sh/docs/cli/update)
+  - [`bun link`](https://bun.sh/docs/cli/link)
+  - [`bun pm`](https://bun.sh/docs/cli/pm)
+  - [Global cache](https://bun.sh/docs/install/cache)
+  - [Workspaces](https://bun.sh/docs/install/workspaces)
+  - [Lifecycle scripts](https://bun.sh/docs/install/lifecycle)
+  - [Filter](https://bun.sh/docs/cli/filter)
+  - [Lockfile](https://bun.sh/docs/install/lockfile)
+  - [Scopes and registries](https://bun.sh/docs/install/registries)
+  - [Overrides and resolutions](https://bun.sh/docs/install/overrides)
+
+- Bundler
+  - [`Bun.build`](https://bun.sh/docs/bundler)
+  - [Loaders](https://bun.sh/docs/bundler/loaders)
   - [Plugins](https://bun.sh/docs/bundler/plugins)
-- Ecosystem
-  - [Node.js](https://bun.sh/docs/ecosystem/nodejs)
-  - [TypeScript](https://bun.sh/docs/ecosystem/typescript)
-  - [React](https://bun.sh/docs/ecosystem/react)
-  - [Elysia](https://bun.sh/docs/ecosystem/elysia)
-  - [Hono](https://bun.sh/docs/ecosystem/hono)
-  - [Express](https://bun.sh/docs/ecosystem/express)
-  - [awesome-bun](https://github.com/apvarun/awesome-bun)
+  - [Macros](https://bun.sh/docs/bundler/macros)
+  - [vs esbuild](https://bun.sh/docs/bundler/vs-esbuild)
+
+- Test runner
+  - [`bun test`](https://bun.sh/docs/cli/test)
+  - [Writing tests](https://bun.sh/docs/test/writing)
+  - [Watch mode](https://bun.sh/docs/test/hot)
+  - [Lifecycle hooks](https://bun.sh/docs/test/lifecycle)
+  - [Mocks](https://bun.sh/docs/test/mocks)
+  - [Snapshots](https://bun.sh/docs/test/snapshots)
+  - [Dates and times](https://bun.sh/docs/test/time)
+  - [DOM testing](https://bun.sh/docs/test/dom)
+  - [Code coverage](https://bun.sh/docs/test/coverage)
+
+- Package runner
+  - [`bunx`](https://bun.sh/docs/cli/bunx)
+
 - API
-  - [HTTP](https://bun.sh/docs/api/http)
+  - [HTTP server](https://bun.sh/docs/api/http)
   - [WebSockets](https://bun.sh/docs/api/websockets)
-  - [TCP Sockets](https://bun.sh/docs/api/tcp)
+  - [Workers](https://bun.sh/docs/api/workers)
+  - [Binary data](https://bun.sh/docs/api/binary-data)
+  - [Streams](https://bun.sh/docs/api/streams)
   - [File I/O](https://bun.sh/docs/api/file-io)
+  - [import.meta](https://bun.sh/docs/api/import-meta)
   - [SQLite](https://bun.sh/docs/api/sqlite)
   - [FileSystemRouter](https://bun.sh/docs/api/file-system-router)
+  - [TCP sockets](https://bun.sh/docs/api/tcp)
+  - [UDP sockets](https://bun.sh/docs/api/udp)
   - [Globals](https://bun.sh/docs/api/globals)
-  - [Spawn](https://bun.sh/docs/api/spawn)
+  - [$ Shell](https://bun.sh/docs/runtime/shell)
+  - [Child processes](https://bun.sh/docs/api/spawn)
   - [Transpiler](https://bun.sh/docs/api/transpiler)
+  - [Hashing](https://bun.sh/docs/api/hashing)
   - [Console](https://bun.sh/docs/api/console)
   - [FFI](https://bun.sh/docs/api/ffi)
   - [HTMLRewriter](https://bun.sh/docs/api/html-rewriter)
   - [Testing](https://bun.sh/docs/api/test)
   - [Utils](https://bun.sh/docs/api/utils)
   - [Node-API](https://bun.sh/docs/api/node-api)
+  - [Glob](https://bun.sh/docs/api/glob)
+  - [Semver](https://bun.sh/docs/api/semver)
+
+- Project
+  - [Roadmap](https://bun.sh/docs/project/roadmap)
+  - [Benchmarking](https://bun.sh/docs/project/benchmarking)
+  - [Contributing](https://bun.sh/docs/project/contributing)
+  - [Building Windows](https://bun.sh/docs/project/building-windows)
+  - [License](https://bun.sh/docs/project/licensing)
+
+## Guides 
+
+- Binary 
+  - [Convert a Blob to a DataView](https://bun.sh/guides/binary/blob-to-dataview)
+  - [Convert a Blob to a ReadableStream](https://bun.sh/guides/binary/blob-to-stream)
+  - [Convert a Blob to a string](https://bun.sh/guides/binary/blob-to-string)
+  - [Convert a Blob to a Uint8Array](https://bun.sh/guides/binary/blob-to-typedarray)
+  - [Convert a Blob to an ArrayBuffer](https://bun.sh/guides/binary/blob-to-arraybuffer)
+  - [Convert a Buffer to a blob](https://bun.sh/guides/binary/buffer-to-blob)
+  - [Convert a Buffer to a ReadableStream](https://bun.sh/guides/binary/buffer-to-readablestream)
+  - [Convert a Buffer to a string](https://bun.sh/guides/binary/buffer-to-string)
+  - [Convert a Buffer to a Uint8Array](https://bun.sh/guides/binary/buffer-to-typedarray)
+  - [Convert a Buffer to an ArrayBuffer](https://bun.sh/guides/binary/buffer-to-arraybuffer)
+  - [Convert a DataView to a string](https://bun.sh/guides/binary/dataview-to-string)
+  - [Convert a Uint8Array to a Blob](https://bun.sh/guides/binary/typedarray-to-blob)
+  - [Convert a Uint8Array to a Buffer](https://bun.sh/guides/binary/typedarray-to-buffer)
+  - [Convert a Uint8Array to a DataView](https://bun.sh/guides/binary/typedarray-to-dataview)
+  - [Convert a Uint8Array to a ReadableStream](https://bun.sh/guides/binary/typedarray-to-readablestream)
+  - [Convert a Uint8Array to a string](https://bun.sh/guides/binary/typedarray-to-string)
+  - [Convert a Uint8Array to an ArrayBuffer](https://bun.sh/guides/binary/typedarray-to-arraybuffer)
+  - [Convert an ArrayBuffer to a Blob](https://bun.sh/guides/binary/arraybuffer-to-blob)
+  - [Convert an ArrayBuffer to a Buffer](https://bun.sh/guides/binary/arraybuffer-to-buffer)
+  - [Convert an ArrayBuffer to a string](https://bun.sh/guides/binary/arraybuffer-to-string)
+  - [Convert an ArrayBuffer to a Uint8Array](https://bun.sh/guides/binary/arraybuffer-to-typedarray)
+  - [Convert an ArrayBuffer to an array of numbers](https://bun.sh/guides/binary/arraybuffer-to-array)
+
+- Ecosystem 
+  - [Build a frontend using Vite and Bun](https://bun.sh/guides/ecosystem/vite)
+  - [Build an app with Astro and Bun](https://bun.sh/guides/ecosystem/astro)
+  - [Build an app with Next.js and Bun](https://bun.sh/guides/ecosystem/nextjs)
+  - [Build an app with Nuxt and Bun](https://bun.sh/guides/ecosystem/nuxt)
+  - [Build an app with Qwik and Bun](https://bun.sh/guides/ecosystem/qwik)
+  - [Build an app with Remix and Bun](https://bun.sh/guides/ecosystem/remix)
+  - [Build an app with SolidStart and Bun](https://bun.sh/guides/ecosystem/solidstart)
+  - [Build an app with SvelteKit and Bun](https://bun.sh/guides/ecosystem/sveltekit)
+  - [Build an HTTP server using Elysia and Bun](https://bun.sh/guides/ecosystem/elysia)
+  - [Build an HTTP server using Express and Bun](https://bun.sh/guides/ecosystem/express)
+  - [Build an HTTP server using Hono and Bun](https://bun.sh/guides/ecosystem/hono)
+  - [Build an HTTP server using StricJS and Bun](https://bun.sh/guides/ecosystem/stric)
+  - [Containerize a Bun application with Docker](https://bun.sh/guides/ecosystem/docker)
+  - [Create a Discord bot](https://bun.sh/guides/ecosystem/discordjs)
+  - [Deploy a Bun application on Render](https://bun.sh/guides/ecosystem/render)
+  - [Read and write data to MongoDB using Mongoose and Bun](https://bun.sh/guides/ecosystem/mongoose)
+  - [Run Bun as a daemon with PM2](https://bun.sh/guides/ecosystem/pm2)
+  - [Run Bun as a daemon with systemd](https://bun.sh/guides/ecosystem/systemd)
+  - [Server-side render (SSR) a React component](https://bun.sh/guides/ecosystem/ssr-react)
+  - [Use Drizzle ORM with Bun](https://bun.sh/guides/ecosystem/drizzle)
+  - [Use EdgeDB with Bun](https://bun.sh/guides/ecosystem/edgedb)
+  - [Use Neon's Serverless Postgres with Bun](https://bun.sh/guides/ecosystem/neon-serverless-postgres)
+  - [Use Prisma with Bun](https://bun.sh/guides/ecosystem/prisma)
+  - [Use React and JSX](https://bun.sh/guides/ecosystem/react)
+  - [Add Sentry to a Bun app](https://bun.sh/guides/ecosystem/sentry)
+
+- HTTP 
+  - [Common HTTP server usage](https://bun.sh/guides/http/server)
+  - [Configure TLS on an HTTP server](https://bun.sh/guides/http/tls)
+  - [fetch with unix domain sockets in Bun](https://bun.sh/guides/http/fetch-unix)
+  - [Hot reload an HTTP server](https://bun.sh/guides/http/hot)
+  - [Proxy HTTP requests using fetch()](https://bun.sh/guides/http/proxy)
+  - [Send an HTTP request using fetch](https://bun.sh/guides/http/fetch)
+  - [Start a cluster of HTTP servers](https://bun.sh/guides/http/cluster)
+  - [Stream a file as an HTTP Response](https://bun.sh/guides/http/stream-file)
+  - [Streaming HTTP Server with Async Iterators](https://bun.sh/guides/http/stream-iterator)
+  - [Streaming HTTP Server with Node.js Streams](https://bun.sh/guides/http/stream-node-streams-in-bun)
+  - [Upload files via HTTP using FormData](https://bun.sh/guides/http/file-uploads)
+  - [Write a simple HTTP server](https://bun.sh/guides/http/simple)
+
+- Install 
+  - [Add a dependency](https://bun.sh/guides/install/add)
+  - [Add a development dependency](https://bun.sh/guides/install/add-dev)
+  - [Add a Git dependency](https://bun.sh/guides/install/add-git)
+  - [Add a peer dependency](https://bun.sh/guides/install/add-peer)
+  - [Add a tarball dependency](https://bun.sh/guides/install/add-tarball)
+  - [Add a trusted dependency](https://bun.sh/guides/install/trusted)
+  - [Add an optional dependency](https://bun.sh/guides/install/add-optional)
+  - [Configure a private registry for an organization scope with bun install](https://bun.sh/guides/install/registry-scope)
+  - [Configure git to diff Bun's lockb lockfile](https://bun.sh/guides/install/git-diff-bun-lockfile)
+  - [Configuring a monorepo using workspaces](https://bun.sh/guides/install/workspaces)
+  - [Generate a human-readable lockfile](https://bun.sh/guides/install/yarnlock)
+  - [Install a package under a different name](https://bun.sh/guides/install/npm-alias)
+  - [Install dependencies with Bun in GitHub Actions](https://bun.sh/guides/install/cicd)
+  - [Override the default npm registry for bun install](https://bun.sh/guides/install/custom-registry)
+  - [Using bun install with an Azure Artifacts npm registry](https://bun.sh/guides/install/azure-artifacts)
+  - [Using bun install with Artifactory](https://bun.sh/guides/install/jfrog-artifactory)
+
+- Process 
+  - [Get the process uptime in nanoseconds](https://bun.sh/guides/process/nanoseconds)
+  - [Listen for CTRL+C](https://bun.sh/guides/process/ctrl-c)
+  - [Listen to OS signals](https://bun.sh/guides/process/os-signals)
+  - [Parse command-line arguments](https://bun.sh/guides/process/argv)
+  - [Read from stdin](https://bun.sh/guides/process/stdin)
+  - [Read stderr from a child process](https://bun.sh/guides/process/spawn-stderr)
+  - [Read stdout from a child process](https://bun.sh/guides/process/spawn-stdout)
+  - [Spawn a child process](https://bun.sh/guides/process/spawn)
+  - [Spawn a child process and communicate using IPC](https://bun.sh/guides/process/ipc)
+
+- Read file 
+  - [Check if a file exists](https://bun.sh/guides/read-file/exists)
+  - [Get the MIME type of a file](https://bun.sh/guides/read-file/mime)
+  - [Read a file as a ReadableStream](https://bun.sh/guides/read-file/stream)
+  - [Read a file as a string](https://bun.sh/guides/read-file/string)
+  - [Read a file to a Buffer](https://bun.sh/guides/read-file/buffer)
+  - [Read a file to a Uint8Array](https://bun.sh/guides/read-file/uint8array)
+  - [Read a file to an ArrayBuffer](https://bun.sh/guides/read-file/arraybuffer)
+  - [Read a JSON file](https://bun.sh/guides/read-file/json)
+  - [Watch a directory for changes](https://bun.sh/guides/read-file/watch)
+
+- Runtime 
+  - [Debugging Bun with the VS Code extension](https://bun.sh/guides/runtime/vscode-debugger)
+  - [Debugging Bun with the web debugger](https://bun.sh/guides/runtime/web-debugger)
+  - [Define and replace static globals & constants](https://bun.sh/guides/runtime/define-constant)
+  - [Import a JSON file](https://bun.sh/guides/runtime/import-json)
+  - [Import a TOML file](https://bun.sh/guides/runtime/import-toml)
+  - [Import HTML file as text](https://bun.sh/guides/runtime/import-html)
+  - [Install and run Bun in GitHub Actions](https://bun.sh/guides/runtime/cicd)
+  - [Install TypeScript declarations for Bun](https://bun.sh/guides/runtime/typescript)
+  - [Re-map import paths](https://bun.sh/guides/runtime/tsconfig-paths)
+  - [Read environment variables](https://bun.sh/guides/runtime/read-env)
+  - [Run a Shell Command](https://bun.sh/guides/runtime/shell)
+  - [Set a time zone in Bun](https://bun.sh/guides/runtime/timezone)
+  - [Set environment variables](https://bun.sh/guides/runtime/set-env)
+
+- Streams 
+  - [Convert a Node.js Readable to a Blob](https://bun.sh/guides/streams/node-readable-to-blob)
+  - [Convert a Node.js Readable to a string](https://bun.sh/guides/streams/node-readable-to-string)
+  - [Convert a Node.js Readable to an ArrayBuffer](https://bun.sh/guides/streams/node-readable-to-arraybuffer)
+  - [Convert a Node.js Readable to JSON](https://bun.sh/guides/streams/node-readable-to-json)
+  - [Convert a ReadableStream to a Blob](https://bun.sh/guides/streams/to-blob)
+  - [Convert a ReadableStream to a Buffer](https://bun.sh/guides/streams/to-buffer)
+  - [Convert a ReadableStream to a string](https://bun.sh/guides/streams/to-string)
+  - [Convert a ReadableStream to a Uint8Array](https://bun.sh/guides/streams/to-typedarray)
+  - [Convert a ReadableStream to an array of chunks](https://bun.sh/guides/streams/to-array)
+  - [Convert a ReadableStream to an ArrayBuffer](https://bun.sh/guides/streams/to-arraybuffer)
+  - [Convert a ReadableStream to JSON](https://bun.sh/guides/streams/to-json)
+
+- Test 
+  - [Bail early with the Bun test runner](https://bun.sh/guides/test/bail)
+  - [Generate code coverage reports with the Bun test runner](https://bun.sh/guides/test/coverage)
+  - [Mark a test as a "todo" with the Bun test runner](https://bun.sh/guides/test/todo-tests)
+  - [Migrate from Jest to Bun's test runner](https://bun.sh/guides/test/migrate-from-jest)
+  - [Mock functions in `bun test`](https://bun.sh/guides/test/mock-functions)
+  - [Re-run tests multiple times with the Bun test runner](https://bun.sh/guides/test/rerun-each)
+  - [Run tests in watch mode with Bun](https://bun.sh/guides/test/watch-mode)
+  - [Run your tests with the Bun test runner](https://bun.sh/guides/test/run-tests)
+  - [Set a code coverage threshold with the Bun test runner](https://bun.sh/guides/test/coverage-threshold)
+  - [Set a per-test timeout with the Bun test runner](https://bun.sh/guides/test/timeout)
+  - [Set the system time in Bun's test runner](https://bun.sh/guides/test/mock-clock)
+  - [Skip tests with the Bun test runner](https://bun.sh/guides/test/skip-tests)
+  - [Spy on methods in `bun test`](https://bun.sh/guides/test/spy-on)
+  - [Update snapshots in `bun test`](https://bun.sh/guides/test/update-snapshots)
+  - [Use snapshot testing in `bun test`](https://bun.sh/guides/test/snapshot)
+  - [Write browser DOM tests with Bun and happy-dom](https://bun.sh/guides/test/happy-dom)
+
+- Util 
+  - [Check if the current file is the entrypoint](https://bun.sh/guides/util/entrypoint)
+  - [Check if two objects are deeply equal](https://bun.sh/guides/util/deep-equals)
+  - [Compress and decompress data with DEFLATE](https://bun.sh/guides/util/deflate)
+  - [Compress and decompress data with gzip](https://bun.sh/guides/util/gzip)
+  - [Convert a file URL to an absolute path](https://bun.sh/guides/util/file-url-to-path)
+  - [Convert an absolute path to a file URL](https://bun.sh/guides/util/path-to-file-url)
+  - [Detect when code is executed with Bun](https://bun.sh/guides/util/detect-bun)
+  - [Encode and decode base64 strings](https://bun.sh/guides/util/base64)
+  - [Escape an HTML string](https://bun.sh/guides/util/escape-html)
+  - [Get the absolute path of the current file](https://bun.sh/guides/util/import-meta-path)
+  - [Get the absolute path to the current entrypoint](https://bun.sh/guides/util/main)
+  - [Get the current Bun version](https://bun.sh/guides/util/version)
+  - [Get the directory of the current file](https://bun.sh/guides/util/import-meta-dir)
+  - [Get the file name of the current file](https://bun.sh/guides/util/import-meta-file)
+  - [Get the path to an executable bin file](https://bun.sh/guides/util/which-path-to-executable-bin)
+  - [Hash a password](https://bun.sh/guides/util/hash-a-password)
+  - [Sleep for a fixed number of milliseconds](https://bun.sh/guides/util/sleep)
+
+- WebSocket 
+  - [Build a publish-subscribe WebSocket server](https://bun.sh/guides/websocket/pubsub)
+  - [Build a simple WebSocket server](https://bun.sh/guides/websocket/simple)
+  - [Enable compression for WebSocket messages](https://bun.sh/guides/websocket/compression)
+  - [Set per-socket contextual data on a WebSocket](https://bun.sh/guides/websocket/context)
+
+- Write file 
+  - [Append content to a file](https://bun.sh/guides/write-file/append)
+  - [Copy a file to another location](https://bun.sh/guides/write-file/file-cp)
+  - [Delete a file](https://bun.sh/guides/write-file/unlink)
+  - [Write a Blob to a file](https://bun.sh/guides/write-file/blob)
+  - [Write a file incrementally](https://bun.sh/guides/write-file/filesink)
+  - [Write a file to stdout](https://bun.sh/guides/write-file/cat)
+  - [Write a ReadableStream to a file](https://bun.sh/guides/write-file/stream)
+  - [Write a Response to a file](https://bun.sh/guides/write-file/response)
+  - [Write a string to a file](https://bun.sh/guides/write-file/basic)
+  - [Write to stdout](https://bun.sh/guides/write-file/stdout)
 
 ## Contributing
 

bench/package.json

@@ -3,6 +3,7 @@
   "dependencies": {
     "@babel/core": "^7.16.10",
     "@babel/preset-react": "^7.16.7",
+    "@babel/standalone": "^7.24.7",
     "@swc/core": "^1.2.133",
     "benchmark": "^2.1.4",
     "braces": "^3.0.2",

bench/react-hello-world/react-hello-world.node.jsx

@@ -6,6 +6,7 @@ const App = () => (
   <html>
     <body>
       <h1>Hello World</h1>
+      <p>This is an example.</p>
     </body>
   </html>
 );

bench/snippets/array-sort.mjs

@@ -0,0 +1,24 @@
+import { bench, run } from "./runner.mjs";
+var comparator = (a, b) => a - b;
+
+const numbers = [
+  0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16,
+  32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 63, 62, 61, 60, 59, 58, 57, 56, 55, 54, 53, 52, 51,
+  50, 49, 48.9,
+];
+
+const presorted = numbers.slice().sort(comparator);
+
+bench(`Array.sort (${numbers.length} num, unsorted)`, () => {
+  [
+    0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17,
+    16, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 63, 62, 61, 60, 59, 58, 57, 56, 55, 54, 53, 52,
+    51, 50, 49, 48.9,
+  ].sort(comparator);
+});
+
+bench(`Array.sort (${numbers.length} num, pre-sorted)`, () => {
+  presorted.sort(comparator);
+});
+
+run();

bench/snippets/atob.mjs

@@ -0,0 +1,13 @@
+import { bench, run } from "./runner.mjs";
+
+function makeBenchmark(size) {
+  const latin1 = btoa("A".repeat(size));
+
+  bench(`atob(${size} chars)`, () => {
+    atob(latin1);
+  });
+}
+
+[32, 512, 64 * 1024, 512 * 1024, 1024 * 1024 * 8].forEach(makeBenchmark);
+
+await run();

bench/snippets/buffer-base64.mjs

@@ -0,0 +1,21 @@
+import { bench, run } from "./runner.mjs";
+
+function makeBenchmark(size, isToString) {
+  const base64Input = Buffer.alloc(size, "latin1").toString("base64");
+  const base64From = Buffer.from(base64Input, "base64");
+
+  if (!isToString)
+    bench(`Buffer.from(${size} bytes, 'base64')`, () => {
+      Buffer.from(base64Input, "base64");
+    });
+
+  if (isToString)
+    bench(`Buffer(${size}).toString('base64')`, () => {
+      base64From.toString("base64");
+    });
+}
+
+[32, 512, 64 * 1024, 512 * 1024, 1024 * 1024 * 8].forEach(s => makeBenchmark(s, true));
+[32, 512, 64 * 1024, 512 * 1024, 1024 * 1024 * 8].forEach(s => makeBenchmark(s, false));
+
+await run();

bench/snippets/buffer-to-string.mjs

@@ -14,6 +14,14 @@ bench(`Buffer(${uuid.byteLength}).toString('base64')`, () => {
   return uuid.toString("base64");
 });
 
+bench(`Buffer(${bigBuffer.byteLength}).toString('base64url')`, () => {
+  return bigBuffer.toString("base64url");
+});
+
+bench(`Buffer(${uuid.byteLength}).toString('base64url')`, () => {
+  return uuid.toString("base64url");
+});
+
 bench(`Buffer(${bigBuffer.byteLength}).toString('hex')`, () => {
   return bigBuffer.toString("hex");
 });

bench/snippets/dns-prefetch.mjs

@@ -0,0 +1,38 @@
+// For maximum effect, make sure to clear your DNS cache before running this
+//
+// To clear your DNS cache on macOS:
+//   sudo dscacheutil -flushcache && sudo killall -HUP mDNSResponder
+//
+// To clear your DNS cache on Linux:
+//   sudo systemd-resolve --flush-caches && sudo killall -HUP systemd-resolved
+//
+// To clear your DNS cache on Windows:
+//   ipconfig /flushdns
+//
+const url = new URL(process.argv.length > 2 ? process.argv.at(-1) : "https://bun.sh");
+const hostname = url.hostname;
+const port = url.port ? parseInt(url.port, 10) : url.protocol === "https:" ? 443 : 80;
+
+if (typeof globalThis.Bun?.dns?.prefetch === "function") {
+  Bun.dns.prefetch(hostname, port);
+}
+
+// Delay one second to make sure the DNS prefetch has time to run
+await new Promise(resolve => setTimeout(resolve, 1000));
+
+const start = performance.now();
+const promises = [];
+
+// Now let's fetch 20 times to see if the DNS prefetch has worked
+for (let i = 0; i < 20; i++) {
+  promises.push(fetch(url, { redirect: "manual", method: "HEAD" }));
+}
+
+await Promise.all(promises);
+
+const end = performance.now();
+console.log("fetch() took", (end - start) | 0, "ms");
+
+if (typeof globalThis.Bun?.dns?.getCacheStats === "function") {
+  console.log("DNS cache stats", Bun.dns.getCacheStats());
+}

bench/snippets/json-parse-stringify.mjs

@@ -54,4 +54,14 @@ bench("JSON.stringify(obj)", () => {
   globalThis.bar = JSON.stringify(obj);
 });
 
+var long_ascii = `"${"a".repeat(9999)}"`;
+bench("JSON.parse(`\"${'a'.repeat(9999)}\"`)", () => {
+  globalThis.bar = JSON.parse(long_ascii);
+});
+
+const long_emoji = `"${"🥟".repeat(9999)}"`;
+bench("JSON.parse(`\"${'🥟'.repeat(9999)}\"`)", () => {
+  globalThis.bar = JSON.parse(long_emoji);
+});
+
 await run();

bench/snippets/pbkdf2.mjs

@@ -0,0 +1,29 @@
+import { pbkdf2, pbkdf2Sync } from "node:crypto";
+
+import { bench, run } from "./runner.mjs";
+
+const password = "password";
+const salt = "salt";
+const iterations = 1000;
+const keylen = 32;
+const hash = "sha256";
+
+bench("pbkdf2(iterations = 1000, 'sha256') -> 32", async () => {
+  return new Promise((resolve, reject) => {
+    pbkdf2(password, salt, iterations, keylen, hash, (err, key) => {
+      if (err) return reject(err);
+      resolve(key);
+    });
+  });
+});
+
+bench("pbkdf2(iterations = 500_000, 'sha256') -> 32", async () => {
+  return new Promise((resolve, reject) => {
+    pbkdf2(password, salt, 500_000, keylen, hash, (err, key) => {
+      if (err) return reject(err);
+      resolve(key);
+    });
+  });
+});
+
+await run();

bench/snippets/react-dom-render.bun.js

@@ -26,6 +26,11 @@ group("new Response(stream).arrayBuffer()", () => {
   bench("react-dom/server.bun", async () => await new Response(await renderToReadableStreamBun(<App />)).arrayBuffer());
 });
 
+group("new Response(stream).bytes()", () => {
+  bench("react-dom/server.browser", async () => await new Response(await renderToReadableStream(<App />)).bytes());
+  bench("react-dom/server.bun", async () => await new Response(await renderToReadableStreamBun(<App />)).bytes());
+});
+
 group("new Response(stream).blob()", () => {
   bench("react-dom/server.browser", async () => await new Response(await renderToReadableStream(<App />)).blob());
   bench("react-dom/server.bun", async () => await new Response(await renderToReadableStreamBun(<App />)).blob());

bench/snippets/set-timeout.mjs

@@ -1,16 +1,42 @@
 import { bench, run } from "../node_modules/mitata/src/cli.mjs";
 
-bench("setTimeout(, 4) 100 times", async () => {
-  var i = 100;
-  while (--i >= 0) {
-    await new Promise((resolve, reject) => {
-      setTimeout(() => {
-        resolve();
-      }, 4);
-    });
-  }
-});
+let count = 20_000_000;
+const batchSize = 1_000_000;
+console.time("Run");
 
-setTimeout(() => {
-  run({}).then(() => {});
-}, 1);
+let { promise, resolve, reject } = Promise.withResolvers();
+let remaining = count;
+
+if (batchSize === 0) {
+  for (let i = 0; i < count; i++) {
+    setTimeout(() => {
+      remaining--;
+      if (remaining === 0) {
+        resolve();
+      }
+    }, 0);
+  }
+  await promise;
+} else {
+  for (let i = 0; i < count; i += batchSize) {
+    let batch = Math.min(batchSize, count - i);
+    console.time("Batch " + i + " - " + (i + batch));
+    let { promise: batchPromise, resolve: batchResolve } = Promise.withResolvers();
+    let remaining = batch;
+    for (let j = 0; j < batch; j++) {
+      setTimeout(() => {
+        remaining--;
+        if (remaining === 0) {
+          batchResolve();
+        }
+      }, 0);
+    }
+    await batchPromise;
+    console.timeEnd("Batch " + i + " - " + (i + batch));
+  }
+}
+
+const fmt = new Intl.NumberFormat();
+console.log("Executed", fmt.format(count), "timers");
+console.timeEnd("Run");
+process.exit(0);

bench/snippets/transpiler-2.mjs

@@ -0,0 +1,14 @@
+import { bench, run } from "mitata";
+import { join } from "path";
+
+const code = require("fs").readFileSync(
+  process.argv[2] || join(import.meta.dir, "../node_modules/@babel/standalone/babel.min.js"),
+);
+
+const transpiler = new Bun.Transpiler({ minify: true });
+
+bench("transformSync", () => {
+  transpiler.transformSync(code);
+});
+
+await run();

completions/bun.bash

@@ -39,7 +39,7 @@ _read_scripts_in_package_json() {
         [[ "${COMP_WORDS[${line}]}" == "--cwd" ]] && working_dir="${COMP_WORDS[$((line + 1))]}";
     done
 
-    [[ -f "${working_dir}/package.json" ]] && package_json=$(<${working_dir}/package.json);
+    [[ -f "${working_dir}/package.json" ]] && package_json=$(<"${working_dir}/package.json");
 
     [[ "${package_json}" =~ "\"scripts\""[[:space:]]*":"[[:space:]]*\{(.*)\} ]] && {
         local package_json_compreply;
@@ -82,7 +82,7 @@ _bun_completions() {
     declare -A PACKAGE_OPTIONS;
     declare -A PM_OPTIONS;
 
-    local SUBCOMMANDS="dev bun create run install add remove upgrade completions discord help init pm x";
+    local SUBCOMMANDS="dev bun create run install add remove upgrade completions discord help init pm x test repl update link unlink build";
 
     GLOBAL_OPTIONS[LONG_OPTIONS]="--use --cwd --bunfile --server-bunfile --config --disable-react-fast-refresh --disable-hmr --env-file --extension-order --jsx-factory --jsx-fragment --extension-order --jsx-factory --jsx-fragment --jsx-import-source --jsx-production --jsx-runtime --main-fields --no-summary --version --platform --public-dir --tsconfig-override --define --external --help --inject --loader --origin --port --dump-environment-variables --dump-limits --disable-bun-js";
     GLOBAL_OPTIONS[SHORT_OPTIONS]="-c -v -d -e -h -i -l -u -p";

completions/bun.fish

@@ -32,132 +32,153 @@ function __fish__get_bun_bun_js_files
 	string split ' ' (bun getcompletes j)
 end
 
-function bun_fish_is_nth_token --description 'Test if current token is on Nth place' --argument-names n
-	set -l tokens (commandline -poc)
-	set -l tokens (string replace -r --filter '^([^-].*)' '$1' -- $tokens)
-	test (count $tokens) -eq "$n"
-end
-
-function __bun_command_count --argument-names n
-	set -l cmds (commandline -poc)
-
-	test (count cmds) -eq "$n"
-end
-
-function __bun_last_cmd --argument-names n
-	set -l cmds (commandline -poc)
-
-	test "(cmds[-1])" = "$n"
-end
-
 set -l bun_install_boolean_flags yarn production optional development no-save dry-run force no-cache silent verbose global
 set -l bun_install_boolean_flags_descriptions "Write a yarn.lock file (yarn v1)" "Don't install devDependencies" "Add dependency to optionalDependencies" "Add dependency to devDependencies" "Don't install devDependencies" "Don't install anything" "Always request the latest versions from the registry & reinstall all dependencies" "Ignore manifest cache entirely" "Don't output anything" "Excessively verbose logging" "Use global folder"
 
-set -l bun_builtin_cmds dev create help bun upgrade discord run install remove add init link unlink pm x
 set -l bun_builtin_cmds_without_run dev create help bun upgrade discord install remove add init pm x
-set -l bun_builtin_cmds_without_bun dev create help upgrade run discord install remove add init pm x
-set -l bun_builtin_cmds_without_create dev help bun upgrade discord run install remove add init pm x
-set -l bun_builtin_cmds_without_install create dev help bun upgrade discord run remove add init pm x
-set -l bun_builtin_cmds_without_remove create dev help bun upgrade discord run install add init pm x
-set -l bun_builtin_cmds_without_add create dev help bun upgrade discord run remove install init pm x
-set -l bun_builtin_cmds_without_pm create dev help bun upgrade discord run init pm x
+set -l bun_builtin_cmds_accepting_flags create help bun upgrade discord run init link unlink pm x
 
-# clear
+function __bun_complete_bins_scripts --inherit-variable bun_builtin_cmds_without_run -d "Emit bun completions for bins and scripts"
+    # Do nothing if we already have a builtin subcommand,
+    # or any subcommand other than "run".
+    if __fish_seen_subcommand_from $bun_builtin_cmds_without_run
+    or not __fish_use_subcommand && not __fish_seen_subcommand_from run
+        return
+    end
+    # Do we already have a bin or script subcommand?
+    set -l bins (__fish__get_bun_bins)
+    if __fish_seen_subcommand_from $bins
+        return
+    end
+    # Scripts have descriptions appended with a tab separator.
+    # Strip off descriptions for the purposes of subcommand testing.
+    set -l scripts (__fish__get_bun_scripts)
+    if __fish_seen_subcommand_from (string split \t -f 1 -- $scripts)
+        return
+    end
+    # Emit scripts.
+    for script in $scripts
+        echo $script
+    end
+    # Emit binaries and JS files (but only if we're doing `bun run`).
+    if __fish_seen_subcommand_from run
+        for bin in $bins
+            echo "$bin"\t"package bin"
+        end
+        for file in (__fish__get_bun_bun_js_files)
+            echo "$file"\t"Bun.js"
+        end
+    end
+end
+
+
+# Clear existing completions
 complete -e -c bun
 
+# Dynamically emit scripts and binaries
+complete -c bun -f -a "(__bun_complete_bins_scripts)"
+
+# Complete flags if we have no subcommand or a flag-friendly one.
+set -l flag_applies "__fish_use_subcommand; or __fish_seen_subcommand_from $bun_builtin_cmds_accepting_flags"
 complete -c bun \
-	-n "not __fish_seen_subcommand_from $bun_builtin_cmds_without_run; and not __fish_seen_subcommand_from (__fish__get_bun_bins) (__fish__get_bun_scripts); and __fish_use_subcommand" -a '(__fish__get_bun_scripts)' -d 'script'
+	-n $flag_applies --no-files -s 'u' -l 'origin' -r -d 'Server URL. Rewrites import paths'
 complete -c bun \
-	-n "not __fish_seen_subcommand_from $bun_builtin_cmds_without_run; and not __fish_seen_subcommand_from (__fish__get_bun_bins) (__fish__get_bun_scripts); and __fish_seen_subcommand_from run" -a '(__fish__get_bun_bins)' -d 'package bin'
+	-n $flag_applies --no-files  -s 'p' -l 'port' -r -d 'Port number to start server from'
 complete -c bun \
-	-n "not __fish_seen_subcommand_from $bun_builtin_cmds_without_run; and not __fish_seen_subcommand_from (__fish__get_bun_bins) (__fish__get_bun_scripts); and __fish_seen_subcommand_from run" -a '(__fish__get_bun_scripts)' -d 'script'
+	-n $flag_applies --no-files  -s 'd' -l 'define' -r -d 'Substitute K:V while parsing, e.g. --define process.env.NODE_ENV:\"development\"'
 complete -c bun \
-	-n "not __fish_seen_subcommand_from $bun_builtin_cmds_without_run; and not __fish_seen_subcommand_from (__fish__get_bun_bins) (__fish__get_bun_scripts); and __fish_seen_subcommand_from run" -a '(__fish__get_bun_bun_js_files)' -d 'Bun.js'
+	-n $flag_applies --no-files  -s 'e' -l 'external' -r -d 'Exclude module from transpilation (can use * wildcards). ex: -e react'
 complete -c bun \
-	-n "bun_fish_is_nth_token 1; and not __fish_seen_subcommand_from $bun_builtin_cmds; and not __fish_seen_subcommand_from (__fish__get_bun_bins) (__fish__get_bun_scripts) and __fish_use_subcommand" -a 'run' -f -d 'Run a script or bin' 
+	-n $flag_applies --no-files -l 'use' -r -d 'Use a framework (ex: next)'
 complete -c bun \
-	-n "not __fish_seen_subcommand_from (__fish__get_bun_bins) (__fish__get_bun_scripts) install remove add;" --no-files -s 'u' -l 'origin' -r -d 'Server URL. Rewrites import paths'
+	-n $flag_applies --no-files -l 'hot' -r -d 'Enable hot reloading in Bun\'s JavaScript runtime'
+
+# Complete dev and create as first subcommand.
 complete -c bun \
-	-n "not __fish_seen_subcommand_from (__fish__get_bun_bins) (__fish__get_bun_scripts) install remove add;" --no-files  -s 'p' -l 'port' -r -d 'Port number to start server from' 
+	-n "__fish_use_subcommand" -a 'dev' -d 'Start dev server'
 complete -c bun \
-	-n "not __fish_seen_subcommand_from (__fish__get_bun_bins) (__fish__get_bun_scripts) install remove add;" --no-files  -s 'd' -l 'define' -r -d 'Substitute K:V while parsing, e.g. --define process.env.NODE_ENV:\"development\"' 
+	-n "__fish_use_subcommand" -a 'create' -f -d 'Create a new project from a template'
+
+# Complete "next" and "react" if we've seen "create".
 complete -c bun \
-	-n "not __fish_seen_subcommand_from (__fish__get_bun_bins) (__fish__get_bun_scripts) install remove add;" --no-files  -s 'e' -l 'external' -r -d 'Exclude module from transpilation (can use * wildcards). ex: -e react' 
-complete -c bun \
-	-n "not __fish_seen_subcommand_from (__fish__get_bun_bins) (__fish__get_bun_scripts) install remove add;" --no-files -l 'use' -r -d 'Use a framework (ex: next)' 
-complete -c bun \
-	-n "not __fish_seen_subcommand_from (__fish__get_bun_bins) (__fish__get_bun_scripts) install remove add;" --no-files -l 'hot' -r -d 'Enable hot reloading in Bun\'s JavaScript runtime' 
-	
-complete -c bun \
-	-n "bun_fish_is_nth_token 1; and not __fish_seen_subcommand_from $bun_builtin_cmds; and not __fish_seen_subcommand_from (__fish__get_bun_bins) (__fish__get_bun_scripts) and __fish_use_subcommand" -a 'dev' -d 'Start dev server'
-complete -c bun \
-	-n "bun_fish_is_nth_token 1; and not __fish_seen_subcommand_from $bun_builtin_cmds; and not __fish_seen_subcommand_from (__fish__get_bun_bins) (__fish__get_bun_scripts) and __bun_command_count 1 and __fish_use_subcommand" -a 'create' -f -d 'Create a new project from a template' 
+	-n "__fish_seen_subcommand_from create" -a 'next' -d 'new Next.js project'
 
 complete -c bun \
-	-n "not __fish_seen_subcommand_from $bun_builtin_cmds_without_create next react; and not __fish_seen_subcommand_from (__fish__get_bun_bins) (__fish__get_bun_scripts); and __fish_seen_subcommand_from create;" -a 'next' -d 'new Next.js project'
+	-n "__fish_seen_subcommand_from create" -a 'react' -d 'new React project'
 
+# Complete "upgrade" as first subcommand.
 complete -c bun \
-	-n "not __fish_seen_subcommand_from $bun_builtin_cmds_without_create next react; and not __fish_seen_subcommand_from (__fish__get_bun_bins) (__fish__get_bun_scripts); and __fish_seen_subcommand_from create;" -a 'react' -d 'new React project'
+	-n "__fish_use_subcommand" -a 'upgrade' -d 'Upgrade bun to the latest version' -x
+# Complete "-h/--help" unconditionally.
+complete -c bun \
+	-s "h" -l "help" -d 'See all commands and flags' -x
 
+# Complete "-v/--version" if we have no subcommand.
 complete -c bun \
-	-n "not __fish_seen_subcommand_from $bun_builtin_cmds; and not __fish_seen_subcommand_from (__fish__get_bun_bins) (__fish__get_bun_scripts); and __fish_use_subcommand" -a 'upgrade' -d 'Upgrade bun to the latest version' -x 
-complete -c bun \
-	-n "not __fish_seen_subcommand_from $bun_builtin_cmds; and not __fish_seen_subcommand_from (__fish__get_bun_bins) (__fish__get_bun_scripts); and __fish_use_subcommand"  -a '--help' -d 'See all commands and flags' -x
+	-n "not __fish_use_subcommand" -l "version" -s "v" -d 'Bun\'s version' -x
 
+# Complete additional subcommands.
 complete -c bun \
-	-n "not __fish_seen_subcommand_from $bun_builtin_cmds; and not __fish_seen_subcommand_from (__fish__get_bun_bins) (__fish__get_bun_scripts); and __fish_use_subcommand" -l "version" -s "v"  -a '--version' -d 'Bun\'s version' -x
-complete -c bun \
-	-n "not __fish_seen_subcommand_from $bun_builtin_cmds; and not __fish_seen_subcommand_from (__fish__get_bun_bins) (__fish__get_bun_scripts); and __fish_use_subcommand" -a 'discord' -d 'Open bun\'s Discord server' -x 
+	-n "__fish_use_subcommand" -a 'discord' -d 'Open bun\'s Discord server' -x
 
 
 complete -c bun \
-	-n "not __fish_seen_subcommand_from $bun_builtin_cmds_without_bun; and not __fish_seen_subcommand_from (__fish__get_bun_bins) (__fish__get_bun_scripts); __fish_use_subcommand" -a 'bun' -d 'Generate a new bundle'
+	-n "__fish_use_subcommand" -a 'bun' -d 'Generate a new bundle'
 
 
 complete -c bun \
-	-n "not __fish_seen_subcommand_from $bun_builtin_cmds_without_bun; and not __fish_seen_subcommand_from (__fish__get_bun_bins) (__fish__get_bun_scripts); and __fish_seen_subcommand_from bun" -F -d 'Bundle this'
+	-n "__fish_seen_subcommand_from bun" -F -d 'Bundle this'
 
 complete -c bun \
-	-n "not __fish_seen_subcommand_from $bun_builtin_cmds_without_create; and not __fish_seen_subcommand_from (__fish__get_bun_bins); and not __fish_seen_subcommand_from (__fish__get_bun_scripts); and __fish_seen_subcommand_from react; or __fish_seen_subcommand_from next" -F -d "Create in directory"
+	-n "__fish_seen_subcommand_from create; and __fish_seen_subcommand_from react next" -F -d "Create in directory"
 
 
 complete -c bun \
-	-n "bun_fish_is_nth_token 1; and not __fish_seen_subcommand_from $bun_builtin_cmds; and not __fish_seen_subcommand_from (__fish__get_bun_bins) (__fish__get_bun_scripts) and __bun_command_count 1 and __fish_use_subcommand" -a 'init' -F -d 'Start an empty Bun project' 
+	-n "__fish_use_subcommand" -a 'init' -F -d 'Start an empty Bun project'
 
 complete -c bun \
-	-n "bun_fish_is_nth_token 1; and not __fish_seen_subcommand_from $bun_builtin_cmds; and not __fish_seen_subcommand_from (__fish__get_bun_bins) (__fish__get_bun_scripts) and __bun_command_count 1 and __fish_use_subcommand" -a 'install' -f -d 'Install packages from package.json' 
+	-n "__fish_use_subcommand" -a 'install' -f -d 'Install packages from package.json'
 
 complete -c bun \
-	-n "bun_fish_is_nth_token 1; and not __fish_seen_subcommand_from $bun_builtin_cmds; and not __fish_seen_subcommand_from (__fish__get_bun_bins) (__fish__get_bun_scripts) and __bun_command_count 1 and __fish_use_subcommand" -a 'add' -F -d 'Add a package to package.json' 
-	
-complete -c bun \
-	-n "bun_fish_is_nth_token 1; and not __fish_seen_subcommand_from $bun_builtin_cmds; and not __fish_seen_subcommand_from (__fish__get_bun_bins) (__fish__get_bun_scripts) and __bun_command_count 1 and __fish_use_subcommand" -a 'remove' -F -d 'Remove a package from package.json' 
+	-n "__fish_use_subcommand" -a 'add' -F -d 'Add a package to package.json'
 
 complete -c bun \
-	-n "bun_fish_is_nth_token 1; and not __fish_seen_subcommand_from $bun_builtin_cmds; and not __fish_seen_subcommand_from (__fish__get_bun_bins) (__fish__get_bun_scripts) and __bun_command_count 1 and __fish_use_subcommand add remove" -F
+	-n "__fish_use_subcommand" -a 'remove' -F -d 'Remove a package from package.json'
+
 
-		  
 for i in (seq (count $bun_install_boolean_flags))
 	complete -c bun \
-		-n "not __fish_seen_subcommand_from $bun_builtin_cmds_without_pm; and not __fish_seen_subcommand_from (__fish__get_bun_bins) (__fish__get_bun_scripts); and __fish_seen_subcommand_from install add remove;" -l "$bun_install_boolean_flags[$i]" -d "$bun_install_boolean_flags_descriptions[$i]"
+		-n "__fish_seen_subcommand_from install add remove" -l "$bun_install_boolean_flags[$i]" -d "$bun_install_boolean_flags_descriptions[$i]"
 end
 
 complete -c bun \
-	-n "not __fish_seen_subcommand_from $bun_builtin_cmds_without_pm; and not __fish_seen_subcommand_from (__fish__get_bun_bins) (__fish__get_bun_scripts); and __fish_seen_subcommand_from install add remove;" -l 'cwd' -d 'Change working directory'
+	-n "__fish_seen_subcommand_from install add remove" -l 'cwd' -d 'Change working directory'
 
 complete -c bun \
-	-n "not __fish_seen_subcommand_from $bun_builtin_cmds_without_pm; and not __fish_seen_subcommand_from (__fish__get_bun_bins) (__fish__get_bun_scripts); and __fish_seen_subcommand_from install add remove;" -l 'cache-dir' -d 'Choose a cache directory (default: $HOME/.bun/install/cache)'
+	-n "__fish_seen_subcommand_from install add remove" -l 'cache-dir' -d 'Choose a cache directory (default: $HOME/.bun/install/cache)'
 
 complete -c bun \
-	-n "not __fish_seen_subcommand_from $bun_builtin_cmds_without_pm; and not __fish_seen_subcommand_from (__fish__get_bun_bins) (__fish__get_bun_scripts); and __fish_seen_subcommand_from add;" -d 'Popular' -a '(__fish__get_bun_packages)'
+	-n "__fish_seen_subcommand_from add" -d 'Popular' -a '(__fish__get_bun_packages)'
 
 complete -c bun \
-	-n "not __fish_seen_subcommand_from $bun_builtin_cmds_without_pm; and not __fish_seen_subcommand_from (__fish__get_bun_bins) (__fish__get_bun_scripts); and __fish_seen_subcommand_from add;" -d 'History' -a '(__history_completions)'
-  
+	-n "__fish_seen_subcommand_from add" -d 'History' -a '(__history_completions)'
+
 complete -c bun \
 	-n "__fish_seen_subcommand_from pm; and not __fish_seen_subcommand_from (__fish__get_bun_bins) (__fish__get_bun_scripts) cache;" -a 'bin ls cache hash hash-print hash-string' -f
 
 complete -c bun \
 	-n "__fish_seen_subcommand_from pm; and __fish_seen_subcommand_from cache; and not __fish_seen_subcommand_from (__fish__get_bun_bins) (__fish__get_bun_scripts);" -a 'rm' -f
 
-complete -c bun -n "not __fish_seen_subcommand_from $bun_builtin_cmds (__fish__get_bun_bins) (__fish__get_bun_scripts)" -a "$bun_builtin_cmds" -f
+# Add built-in subcommands with descriptions.
+complete -c bun -n "__fish_use_subcommand" -a "create" -f -d "Create a new project from a template"
+complete -c bun -n "__fish_use_subcommand" -a "build bun" --require-parameter -F -d "Transpile and bundle one or more files"
+complete -c bun -n "__fish_use_subcommand" -a "upgrade" -d "Upgrade Bun"
+complete -c bun -n "__fish_use_subcommand" -a "run" -d "Run a script or package binary"
+complete -c bun -n "__fish_use_subcommand" -a "install" -d "Install dependencies from package.json" -f
+complete -c bun -n "__fish_use_subcommand" -a "remove" -d "Remove a dependency from package.json" -f
+complete -c bun -n "__fish_use_subcommand" -a "add" -d "Add a dependency to package.json" -f
+complete -c bun -n "__fish_use_subcommand" -a "init" -d "Initialize a Bun project in this directory" -f
+complete -c bun -n "__fish_use_subcommand" -a "link" -d "Register or link a local npm package" -f
+complete -c bun -n "__fish_use_subcommand" -a "link" -d "Unregister a local npm package" -f
+complete -c bun -n "__fish_use_subcommand" -a "pm" -d "Additional package management utilities" -f
+complete -c bun -n "__fish_use_subcommand" -a "x" -d "Execute a package binary, installing if needed" -f

completions/bun.zsh

@@ -425,6 +425,7 @@ _bun_run_completion() {
         '--external[Exclude module from transpilation (can use * wildcards). ex: -e react]:external' \
         '-e[Exclude module from transpilation (can use * wildcards). ex: -e react]:external' \
         '--loader[Parse files with .ext:loader, e.g. --loader .js:jsx. Valid loaders: js, jsx, ts, tsx, json, toml, text, file, wasm, napi]:loader' \
+        '--packages[Exclude dependencies from bundle, e.g. --packages external. Valid options: bundle, external]:packages' \
         '-l[Parse files with .ext:loader, e.g. --loader .js:jsx. Valid loaders: js, jsx, ts, tsx, json, toml, text, file, wasm, napi]:loader' \
         '--origin[Rewrite import URLs to start with --origin. Default: ""]:origin' \
         '-u[Rewrite import URLs to start with --origin. Default: ""]:origin' \

docs/api/binary-data.md

@@ -61,7 +61,7 @@ To do anything interesting we need a construct known as a "view". A view is a cl
 
 The `DataView` class is a lower-level interface for reading and manipulating the data in an `ArrayBuffer`.
 
-Below we create a new `DataView` and set the first byte to 5.
+Below we create a new `DataView` and set the first byte to 3.
 
 ```ts
 const buf = new ArrayBuffer(4);
@@ -395,7 +395,7 @@ Bun implements `Buffer`, a Node.js API for working with binary data that pre-dat
 
 ```ts
 const buf = Buffer.from("hello world");
-// => Buffer(16) [ 116, 104, 105, 115, 32, 105, 115, 32, 97, 32, 115, 116, 114, 105, 110, 103 ]
+// => Buffer(11) [ 104, 101, 108, 108, 111, 32, 119, 111, 114, 108, 100 ]
 
 buf.length; // => 11
 buf[0]; // => 104, ascii for 'h'
@@ -886,15 +886,25 @@ new Response(stream).arrayBuffer();
 Bun.readableStreamToArrayBuffer(stream);
 ```
 
+#### To `Uint8Array`
+
+```ts
+// with Response
+new Response(stream).bytes();
+
+// with Bun function
+Bun.readableStreamToBytes(stream);
+```
+
 #### To `TypedArray`
 
 ```ts
 // with Response
 const buf = await new Response(stream).arrayBuffer();
-new Uint8Array(buf);
+new Int8Array(buf);
 
 // with Bun function
-new Uint8Array(Bun.readableStreamToArrayBuffer(stream));
+new Int8Array(Bun.readableStreamToArrayBuffer(stream));
 ```
 
 #### To `DataView`

docs/api/dns.md

@@ -8,34 +8,106 @@ console.log(addrs);
 // => [{ address: "172.67.161.226", family: 4, ttl: 0 }, ...]
 ```
 
-<!--
-## `Bun.dns` - lookup a domain
-`Bun.dns` includes utilities to make DNS requests, similar to `node:dns`. As of Bun v0.5.0, the only implemented function is `dns.lookup`, though more will be implemented soon.
-You can lookup the IP addresses of a hostname by using `dns.lookup`.
-```ts
-import { dns } from "bun";
-const [{ address }] = await dns.lookup("example.com");
-console.log(address); // "93.184.216.34"
-```
-If you need to limit IP addresses to either IPv4 or IPv6, you can specify the `family` as an option.
-```ts
-import { dns } from "bun";
-const [{ address }] = await dns.lookup("example.com", { family: 6 });
-console.log(address); // "2606:2800:220:1:248:1893:25c8:1946"
-```
-Bun supports three backends for DNS resolution:
-- `c-ares` - This is the default on Linux, and it uses the [c-ares](https://c-ares.org/) library to perform DNS resolution.
-- `system` - Uses the system's non-blocking DNS resolver, if available. Otherwise, falls back to `getaddrinfo`. This is the default on macOS, and the same as `getaddrinfo` on Linux.
-- `getaddrinfo` - Uses the POSIX standard `getaddrinfo` function, which may cause performance issues under concurrent load.
+## DNS caching in Bun
+
+In Bun v1.1.9, we added support for DNS caching. This cache makes repeated connections to the same hosts faster. 
+
+At the time of writing, we cache up to 255 entries for a maximum of 30 seconds (each). If any connections to a host fail, we remove the entry from the cache. When multiple connections are made to the same host simultaneously, DNS lookups are deduplicated to avoid making multiple requests for the same host.
+
+This cache is automatically used by;
+
+- `bun install`
+- `fetch()`
+- `node:http` (client)
+- `Bun.connect`
+- `node:net`
+- `node:tls`
+
+### When should I prefetch a DNS entry?
+
+Web browsers expose [`<link rel="dns-prefetch">`](https://developer.mozilla.org/en-US/docs/Web/Performance/dns-prefetch) to allow developers to prefetch DNS entries. This is useful when you know you'll need to connect to a host in the near future and want to avoid the initial DNS lookup.
+
+In Bun, you can use the `dns.prefetch` API to achieve the same effect. 
 
-You can choose a particular backend by specifying `backend` as an option.
 ```ts
-import { dns } from "bun";
-const [{ address, ttl }] = await dns.lookup("example.com", {
-  backend: "c-ares"
-});
-console.log(address); // "93.184.216.34"
-console.log(ttl); // 21237
+import {dns} from "bun";
+
+dns.prefetch("my.database-host.com", 5432);
 ```
-Note: the `ttl` property is only accurate when the `backend` is c-ares. Otherwise, `ttl` will be `0`.
-This was added in Bun v0.5.0. -->
+
+An example where you might want to use this is a database driver. When your application first starts up, you can prefetch the DNS entry for the database host so that by the time it finishes loading everything, the DNS query to resolve the database host may already be completed.
+
+### `dns.prefetch`
+
+{% callout %}
+**🚧** — This API is experimental and may change in the future.
+{% /callout %}
+
+To prefetch a DNS entry, you can use the `dns.prefetch` API. This API is useful when you know you'll need to connect to a host soon and want to avoid the initial DNS lookup.
+
+```ts
+dns.prefetch(hostname: string, port: number): void;
+```
+
+Here's an example:
+
+```ts
+import {dns} from "bun";
+
+dns.prefetch("bun.sh", 443);
+//
+// ... sometime later ...
+await fetch("https://bun.sh");
+```
+
+### `dns.getCacheStats()`
+
+{% callout %}
+**🚧** — This API is experimental and may change in the future.
+{% /callout %}
+
+To get the current cache stats, you can use the `dns.getCacheStats` API. 
+
+This API returns an object with the following properties:
+
+```ts
+{
+  // Cache hits 
+  cacheHitsCompleted: number;
+  cacheHitsInflight: number;
+  cacheMisses: number;
+  // Number of items in the DNS cache
+  size: number;
+
+  // Number of times a connection failed
+  errors: number;
+
+  // Number of times a connection was requested at all (including cache hits and misses)
+  totalCount: number;
+}
+```
+
+Example:
+
+```ts
+import {dns} from "bun";
+
+const stats = dns.getCacheStats();
+console.log(stats);
+// => { cacheHitsCompleted: 0, cacheHitsInflight: 0, cacheMisses: 0, size: 0, errors: 0, totalCount: 0 }
+```
+
+### Configuring DNS cache TTL
+
+Bun defaults to 30 seconds for the TTL of DNS cache entries. To change this, you can set the envionrment variable `$BUN_CONFIG_DNS_TIME_TO_LIVE_SECONDS`. For example, to set the TTL to 5 seconds:
+
+```sh
+BUN_CONFIG_DNS_TIME_TO_LIVE_SECONDS=5 bun run my-script.ts
+```
+
+#### Why is 30 seconds the default?
+
+Unfortunately, the system API underneath (`getaddrinfo`) does not provide a way to get the TTL of a DNS entry. This means we have to pick a number arbitrarily. We chose 30 seconds because it's long enough to see the benefits of caching, and short enough to be unlikely to cause issues if a DNS entry changes. [Amazon Web Services recommends 5 seconds](https://docs.aws.amazon.com/sdk-for-java/v1/developer-guide/jvm-ttl-dns.html) for the Java Virtual Machine, however the JVM defaults to cache indefinitely. 
+
+
+

docs/api/fetch.md

@@ -0,0 +1,308 @@
+Bun implements the WHATWG `fetch` standard, with some extensions to meet the needs of server-side JavaScript.
+
+Bun also implements `node:http`, but `fetch` is generally recommended instead.
+
+## Sending an HTTP request
+
+To send an HTTP request, use `fetch`
+
+```ts
+const response = await fetch("http://example.com");
+
+console.log(response.status); // => 200
+
+const text = await response.text(); // or response.json(), response.formData(), etc.
+```
+
+`fetch` also works with HTTPS URLs.
+
+```ts
+const response = await fetch("https://example.com");
+```
+
+You can also pass `fetch` a [`Request`](https://developer.mozilla.org/en-US/docs/Web/API/Request) object.
+
+```ts
+const request = new Request("http://example.com", {
+  method: "POST",
+  body: "Hello, world!",
+});
+
+const response = await fetch(request);
+```
+
+### Sending a POST request
+
+To send a POST request, pass an object with the `method` property set to `"POST"`.
+
+```ts
+const response = await fetch("http://example.com", {
+  method: "POST",
+  body: "Hello, world!",
+});
+```
+
+`body` can be a string, a `FormData` object, an `ArrayBuffer`, a `Blob`, and more. See the [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/API/Body/body) for more information.
+
+### Proxying requests
+
+To proxy a request, pass an object with the `proxy` property set to a URL.
+
+```ts
+const response = await fetch("http://example.com", {
+  proxy: "http://proxy.com",
+});
+```
+
+### Custom headers
+
+To set custom headers, pass an object with the `headers` property set to an object.
+
+```ts
+const response = await fetch("http://example.com", {
+  headers: {
+    "X-Custom-Header": "value",
+  },
+});
+```
+
+You can also set headers using the [Headers](https://developer.mozilla.org/en-US/docs/Web/API/Headers) object.
+
+```ts
+const headers = new Headers();
+headers.append("X-Custom-Header", "value");
+
+const response = await fetch("http://example.com", {
+  headers,
+});
+```
+
+### Response bodies
+
+To read the response body, use one of the following methods:
+
+- `response.text(): Promise<string>`: Returns a promise that resolves with the response body as a string.
+- `response.json(): Promise<any>`: Returns a promise that resolves with the response body as a JSON object.
+- `response.formData(): Promise<FormData>`: Returns a promise that resolves with the response body as a `FormData` object.
+- `response.bytes(): Promise<Uint8Array>`: Returns a promise that resolves with the response body as a `Uint8Array`.
+- `response.arrayBuffer(): Promise<ArrayBuffer>`: Returns a promise that resolves with the response body as an `ArrayBuffer`.
+- `response.blob(): Promise<Blob>`: Returns a promise that resolves with the response body as a `Blob`.
+
+#### Streaming response bodies
+
+You can use async iterators to stream the response body.
+
+```ts
+const response = await fetch("http://example.com");
+
+for await (const chunk of response.body) {
+  console.log(chunk);
+}
+```
+
+You can also more directly access the `ReadableStream` object.
+
+```ts
+const response = await fetch("http://example.com");
+
+const stream = response.body;
+
+const reader = stream.getReader();
+const { value, done } = await reader.read();
+```
+
+### Fetching a URL with a timeout
+
+To fetch a URL with a timeout, use `AbortSignal.timeout`:
+
+```ts
+const response = await fetch("http://example.com", {
+  signal: AbortSignal.timeout(1000),
+});
+```
+
+#### Canceling a request
+
+To cancel a request, use an `AbortController`:
+
+```ts
+const controller = new AbortController();
+
+const response = await fetch("http://example.com", {
+  signal: controller.signal,
+});
+
+controller.abort();
+```
+
+### Unix domain sockets
+
+To fetch a URL using a Unix domain socket, use the `unix: string` option:
+
+```ts
+const response = await fetch("https://hostname/a/path", {
+  unix: "/var/run/path/to/unix.sock",
+  method: "POST",
+  body: JSON.stringify({ message: "Hello from Bun!" }),
+  headers: {
+    "Content-Type": "application/json",
+  },
+});
+```
+
+### TLS
+
+To use a client certificate, use the `tls` option:
+
+```ts
+await fetch("https://example.com", {
+  tls: {
+    key: Bun.file("/path/to/key.pem"),
+    cert: Bun.file("/path/to/cert.pem"),
+    // ca: [Bun.file("/path/to/ca.pem")],
+  },
+});
+```
+
+#### Custom TLS Validation
+
+To customize the TLS validation, use the `checkServerIdentity` option in `tls`
+
+```ts
+await fetch("https://example.com", {
+  tls: {
+    checkServerIdentity: (hostname, peerCertificate) => {
+      // Return an error if the certificate is invalid
+    },
+  },
+});
+```
+
+This is similar to how it works in Node's `net` module.
+
+## Debugging
+
+To help with debugging, you can pass `verbose: true` to `fetch`:
+
+```ts
+const response = await fetch("http://example.com", {
+  verbose: true,
+});
+```
+
+This will print the request and response headers to your terminal:
+
+```sh
+[fetch] > HTTP/1.1 GET http://example.com/
+[fetch] > Connection: keep-alive
+[fetch] > User-Agent: Bun/1.1.21
+[fetch] > Accept: */*
+[fetch] > Host: example.com
+[fetch] > Accept-Encoding: gzip, deflate, br
+
+[fetch] < 200 OK
+[fetch] < Content-Encoding: gzip
+[fetch] < Age: 201555
+[fetch] < Cache-Control: max-age=604800
+[fetch] < Content-Type: text/html; charset=UTF-8
+[fetch] < Date: Sun, 21 Jul 2024 02:41:14 GMT
+[fetch] < Etag: "3147526947+gzip"
+[fetch] < Expires: Sun, 28 Jul 2024 02:41:14 GMT
+[fetch] < Last-Modified: Thu, 17 Oct 2019 07:18:26 GMT
+[fetch] < Server: ECAcc (sac/254F)
+[fetch] < Vary: Accept-Encoding
+[fetch] < X-Cache: HIT
+[fetch] < Content-Length: 648
+```
+
+Note: `verbose: boolean` is not part of the Web standard `fetch` API and is specific to Bun.
+
+## Performance
+
+Before an HTTP request can be sent, the DNS lookup must be performed. This can take a significant amount of time, especially if the DNS server is slow or the network connection is poor.
+
+After the DNS lookup, the TCP socket must be connected and the TLS handshake might need to be performed. This can also take a significant amount of time.
+
+After the request completes, consuming the response body can also take a significant amount of time and memory.
+
+At every step of the way, Bun provides APIs to help you optimize the performance of your application.
+
+### DNS prefetching
+
+To prefetch a DNS entry, you can use the `dns.prefetch` API. This API is useful when you know you'll need to connect to a host soon and want to avoid the initial DNS lookup.
+
+```ts
+import { dns } from "bun";
+
+dns.prefetch("bun.sh", 443);
+```
+
+#### DNS caching
+
+By default, Bun caches and deduplicates DNS queries in-memory for up to 30 seconds. You can see the cache stats by calling `dns.getCacheStats()`:
+
+To learn more about DNS caching in Bun, see the [DNS caching](/docs/api/dns) documentation.
+
+### Preconnect to a host
+
+To preconnect to a host, you can use the `fetch.preconnect` API. This API is useful when you know you'll need to connect to a host soon and want to start the initial DNS lookup, TCP socket connection, and TLS handshake early.
+
+```ts
+import { fetch } from "bun";
+
+fetch.preconnect("https://bun.sh");
+```
+
+Note: calling `fetch` immediately after `fetch.preconnect` will not make your request faster. Preconnecting only helps if you know you'll need to connect to a host soon, but you're not ready to make the request yet.
+
+#### Preconnect at startup
+
+To preconnect to a host at startup, you can pass `--fetch-preconnect`:
+
+```sh
+$ bun --fetch-preconnect https://bun.sh ./my-script.ts
+```
+
+This is sort of like `<link rel="preconnect">` in HTML.
+
+This feature is not implemented on Windows yet. If you're interested in using this feature on Windows, please file an issue and we can implement support for it on Windows.
+
+### Connection pooling & HTTP keep-alive
+
+Bun automatically reuses connections to the same host. This is known as connection pooling. This can significantly reduce the time it takes to establish a connection. You don't need to do anything to enable this; it's automatic.
+
+#### Simultaneous connection limit
+
+By default, Bun limits the maximum number of simultaneous `fetch` requests to 256. We do this for several reasons:
+
+- It improves overall system stability. Operating systems have an upper limit on the number of simultaneous open TCP sockets, usually in the low thousands. Nearing this limit causes your entire computer to behave strangely. Applications hang and crash.
+- It encourages HTTP Keep-Alive connection reuse. For short-lived HTTP requests, the slowest step is often the initial connection setup. Reusing connections can save a lot of time.
+
+When the limit is exceeded, the requests are queued and sent as soon as the next request ends.
+
+You can increase the maximum number of simultaneous connections via the `BUN_CONFIG_MAX_HTTP_REQUESTS` environment variable:
+
+```sh
+$ BUN_CONFIG_MAX_HTTP_REQUESTS=512 bun ./my-script.ts
+```
+
+The max value for this limit is currently set to 65,336. The maximum port number is 65,535, so it's quite difficult for any one computer to exceed this limit.
+
+### Response buffering
+
+Bun goes to great lengths to optimize the performance of reading the response body. The fastest way to read the response body is to use one of these methods:
+
+- `response.text(): Promise<string>`
+- `response.json(): Promise<any>`
+- `response.formData(): Promise<FormData>`
+- `response.bytes(): Promise<Uint8Array>`
+- `response.arrayBuffer(): Promise<ArrayBuffer>`
+- `response.blob(): Promise<Blob>`
+
+You can also use `Bun.write` to write the response body to a file on disk:
+
+```ts
+import { write } from "bun";
+
+await write("output.txt", response);
+```

docs/api/file-io.md

@@ -28,6 +28,7 @@ const foo = Bun.file("foo.txt");
 await foo.text(); // contents as a string
 await foo.stream(); // contents as ReadableStream
 await foo.arrayBuffer(); // contents as ArrayBuffer
+await foo.bytes(); // contents as Uint8Array
 ```
 
 File references can also be created using numerical [file descriptors](https://en.wikipedia.org/wiki/File_descriptor) or `file://` URLs.

docs/api/hashing.md

@@ -112,6 +112,7 @@ Bun.hash.murmur64v2("data", 1234);
 `Bun.CryptoHasher` is a general-purpose utility class that lets you incrementally compute a hash of string or binary data using a range of cryptographic hash algorithms. The following algorithms are supported:
 
 - `"blake2b256"`
+- `"blake2b512"`
 - `"md4"`
 - `"md5"`
 - `"ripemd160"`
@@ -120,7 +121,14 @@ Bun.hash.murmur64v2("data", 1234);
 - `"sha256"`
 - `"sha384"`
 - `"sha512"`
+- `"sha512-224"`
 - `"sha512-256"`
+- `"sha3-224"`
+- `"sha3-256"`
+- `"sha3-384"`
+- `"sha3-512"`
+- `"shake128"`
+- `"shake256"`
 
 ```ts
 const hasher = new Bun.CryptoHasher("sha256");

docs/api/http.md

@@ -18,6 +18,8 @@ Bun.serve({
 });
 ```
 
+### `fetch` request handler
+
 The `fetch` handler handles incoming requests. It receives a [`Request`](https://developer.mozilla.org/en-US/docs/Web/API/Request) object and returns a [`Response`](https://developer.mozilla.org/en-US/docs/Web/API/Response) or `Promise<Response>`.
 
 ```ts
@@ -31,7 +33,46 @@ Bun.serve({
 });
 ```
 
-To configure which port and hostname the server will listen on:
+The `fetch` handler supports async/await:
+
+```ts
+import { sleep, serve } from "bun";
+serve({
+  async fetch(req) {
+    const start = performance.now();
+    await sleep(10);
+    const end = performance.now();
+    return new Response(`Slept for ${end - start}ms`);
+  },
+});
+```
+
+Promise-based responses are also supported:
+
+```ts
+Bun.serve({
+  fetch(req) {
+    // Forward the request to another server.
+    return fetch("https://example.com");
+  },
+});
+```
+
+You can also access the `Server` object from the `fetch` handler. It's the second argument passed to the `fetch` function.
+
+```ts
+// `server` is passed in as the second argument to `fetch`.
+const server = Bun.serve({
+  fetch(req, server) {
+    const ip = server.requestIP(req);
+    return new Response(`Your IP is ${ip}`);
+  },
+});
+```
+
+### Changing the `port` and `hostname`
+
+To configure which port and hostname the server will listen on, set `port` and `hostname` in the options object.
 
 ```ts
 Bun.serve({
@@ -43,7 +84,58 @@ Bun.serve({
 });
 ```
 
-To listen on a [unix domain socket](https://en.wikipedia.org/wiki/Unix_domain_socket):
+To randomly select an available port, set `port` to `0`.
+
+```ts
+const server = Bun.serve({
+  port: 0, // random port
+  fetch(req) {
+    return new Response("404!");
+  },
+});
+
+// server.port is the randomly selected port
+console.log(server.port);
+```
+
+You can view the chosen port by accessing the `port` property on the server object, or by accessing the `url` property.
+
+```ts
+console.log(server.port); // 3000
+console.log(server.url); // http://localhost:3000
+```
+
+#### Configuring a default port
+
+Bun supports several options and environment variables to configure the default port. The default port is used when the `port` option is not set.
+
+- `--port` CLI flag
+
+```sh
+$ bun --port=4002 server.ts
+```
+
+- `BUN_PORT` environment variable
+
+```sh
+$ BUN_PORT=4002 bun server.ts
+```
+
+- `PORT` environment variable
+
+```sh
+$ PORT=4002 bun server.ts
+```
+
+- `NODE_PORT` environment variable
+
+```sh
+$ NODE_PORT=4002 bun server.ts
+```
+
+### Unix domain sockets
+
+To listen on a [unix domain socket](https://en.wikipedia.org/wiki/Unix_domain_socket), pass the `unix` option with the path to the socket.
 
 ```ts
 Bun.serve({
@@ -54,9 +146,24 @@ Bun.serve({
 });
 ```
 
+### Abstract namespace sockets
+
+Bun supports Linux abstract namespace sockets. To use an abstract namespace socket, prefix the `unix` path with a null byte.
+
+```ts
+Bun.serve({
+  unix: "\0my-abstract-socket", // abstract namespace socket
+  fetch(req) {
+    return new Response(`404!`);
+  },
+});
+```
+
+Unlike unix domain sockets, abstract namespace sockets are not bound to the filesystem and are automatically removed when the last reference to the socket is closed.
+
 ## Error handling
 
-To activate development mode, set `development: true`. By default, development mode is _enabled_ unless `NODE_ENV` is `production`.
+To activate development mode, set `development: true`.
 
 ```ts
 Bun.serve({
@@ -71,6 +178,8 @@ In development mode, Bun will surface errors in-browser with a built-in error pa
 
 {% image src="/images/exception_page.png" caption="Bun's built-in 500 page" /%}
 
+### `error` callback
+
 To handle server-side errors, implement an `error` handler. This function should return a `Response` to serve to the client when an error occurs. This response will supersede Bun's default error page in `development` mode.
 
 ```ts
@@ -183,6 +292,40 @@ Bun.serve({
 });
 ```
 
+### Sever name indication (SNI)
+
+To configure the server name indication (SNI) for the server, set the `serverName` field in the `tls` object.
+
+```ts
+Bun.serve({
+  // ...
+  tls: {
+    // ... other config
+    serverName: "my-server.com", // SNI
+  },
+});
+```
+
+To allow multiple server names, pass an array of objects to `tls`, each with a `serverName` field.
+
+```ts
+Bun.serve({
+  // ...
+  tls: [
+    {
+      key: Bun.file("./key1.pem"),
+      cert: Bun.file("./cert1.pem"),
+      serverName: "my-server1.com",
+    },
+    {
+      key: Bun.file("./key2.pem"),
+      cert: Bun.file("./cert2.pem"),
+      serverName: "my-server2.com",
+    },
+  ],
+});
+```
+
 ## Object syntax
 
 Thus far, the examples on this page have used the explicit `Bun.serve` API. Bun also supports an alternate syntax.
@@ -293,37 +436,98 @@ The `Bun.serve` server can handle roughly 2.5x more requests per second than Nod
 ```ts
 interface Bun {
   serve(options: {
-    fetch: (req: Request, server: Server) => Response | Promise<Response>;
-    hostname?: string;
-    port?: number;
     development?: boolean;
-    error?: (error: Error) => Response | Promise<Response>;
-    tls?: {
-      key?:
-        | string
-        | TypedArray
-        | BunFile
-        | Array<string | TypedArray | BunFile>;
-      cert?:
-        | string
-        | TypedArray
-        | BunFile
-        | Array<string | TypedArray | BunFile>;
-      ca?: string | TypedArray | BunFile | Array<string | TypedArray | BunFile>;
-      passphrase?: string;
-      dhParamsFile?: string;
-    };
+    error?: (
+      request: ErrorLike,
+    ) => Response | Promise<Response> | undefined | Promise<undefined>;
+    fetch(request: Request, server: Server): Response | Promise<Response>;
+    hostname?: string;
+    id?: string | null;
     maxRequestBodySize?: number;
-    lowMemoryMode?: boolean;
+    port?: string | number;
+    reusePort?: boolean;
+    tls?: TLSOptions | Array<TLSOptions>;
+    unix: string;
+    websocket: WebSocketHandler<WebSocketDataType>;
   }): Server;
 }
 
+interface TLSOptions {
+  ca?: string | Buffer | BunFile | Array<string | Buffer | BunFile> | undefined;
+  cert?:
+    | string
+    | Buffer
+    | BunFile
+    | Array<string | Buffer | BunFile>
+    | undefined;
+  dhParamsFile?: string;
+  key?:
+    | string
+    | Buffer
+    | BunFile
+    | Array<string | Buffer | BunFile>
+    | undefined;
+  lowMemoryMode?: boolean;
+  passphrase?: string;
+  secureOptions?: number | undefined;
+  serverName?: string;
+}
+
+interface WebSocketHandler<T = undefined> {
+  backpressureLimit?: number;
+  close?(
+    ws: ServerWebSocket<T>,
+    code: number,
+    reason: string,
+  ): void | Promise<void>;
+  closeOnBackpressureLimit?: boolean;
+  drain?(ws: ServerWebSocket<T>): void | Promise<void>;
+  idleTimeout?: number;
+  maxPayloadLength?: number;
+  message(
+    ws: ServerWebSocket<T>,
+    message: string | Buffer,
+  ): void | Promise<void>;
+  open?(ws: ServerWebSocket<T>): void | Promise<void>;
+  perMessageDeflate?:
+    | boolean
+    | {
+        compress?: WebSocketCompressor | boolean;
+        decompress?: WebSocketCompressor | boolean;
+      };
+  ping?(ws: ServerWebSocket<T>, data: Buffer): void | Promise<void>;
+  pong?(ws: ServerWebSocket<T>, data: Buffer): void | Promise<void>;
+  publishToSelf?: boolean;
+  sendPings?: boolean;
+}
+
 interface Server {
-  development: boolean;
-  hostname: string;
-  port: number;
-  pendingRequests: number;
-  stop(): void;
+  fetch(request: Request | string): Response | Promise<Response>;
+  publish(
+    compress?: boolean,
+    data: string | ArrayBufferView | ArrayBuffer | SharedArrayBuffer,
+    topic: string,
+  ): ServerWebSocketSendStatus;
+  ref(): void;
+  reload(options: Serve): void;
+  requestIP(request: Request): SocketAddress | null;
+  stop(closeActiveConnections?: boolean): void;
+  unref(): void;
+  upgrade<T = undefined>(
+    options?: {
+      data?: T;
+      headers?: Bun.HeadersInit;
+    },
+    request: Request,
+  ): boolean;
+
+  readonly development: boolean;
+  readonly hostname: string;
+  readonly id: string;
+  readonly pendingRequests: number;
+  readonly pendingWebSockets: number;
+  readonly port: number;
+  readonly url: URL;
 }
 ```
 

docs/api/spawn.md

@@ -5,13 +5,14 @@ Spawn child processes with `Bun.spawn` or `Bun.spawnSync`.
 Provide a command as an array of strings. The result of `Bun.spawn()` is a `Bun.Subprocess` object.
 
 ```ts
-Bun.spawn(["echo", "hello"]);
+const proc = Bun.spawn(["bun", "--version"]);
+console.log(await proc.exited); // 0
 ```
 
 The second argument to `Bun.spawn` is a parameters object that can be used to configure the subprocess.
 
 ```ts
-const proc = Bun.spawn(["echo", "hello"], {
+const proc = Bun.spawn(["bun", "--version"], {
   cwd: "./path/to/subdir", // specify a working directory
   env: { ...process.env, FOO: "bar" }, // specify environment variables
   onExit(proc, exitCode, signalCode, error) {
@@ -107,9 +108,9 @@ proc.stdin.end();
 You can read results from the subprocess via the `stdout` and `stderr` properties. By default these are instances of `ReadableStream`.
 
 ```ts
-const proc = Bun.spawn(["echo", "hello"]);
+const proc = Bun.spawn(["bun", "--version"]);
 const text = await new Response(proc.stdout).text();
-console.log(text); // => "hello"
+console.log(text); // => "1.1.7"
 ```
 
 Configure the output stream by passing one of the following values to `stdout/stderr`:
@@ -148,7 +149,7 @@ Configure the output stream by passing one of the following values to `stdout/st
 Use the `onExit` callback to listen for the process exiting or being killed.
 
 ```ts
-const proc = Bun.spawn(["echo", "hello"], {
+const proc = Bun.spawn(["bun", "--version"], {
   onExit(proc, exitCode, signalCode, error) {
     // exit handler
   },
@@ -158,7 +159,7 @@ const proc = Bun.spawn(["echo", "hello"], {
 For convenience, the `exited` property is a `Promise` that resolves when the process exits.
 
 ```ts
-const proc = Bun.spawn(["echo", "hello"]);
+const proc = Bun.spawn(["bun", "--version"]);
 
 await proc.exited; // resolves when process exit
 proc.killed; // boolean — was the process killed?
@@ -169,7 +170,7 @@ proc.signalCode; // null | "SIGABRT" | "SIGALRM" | ...
 To kill a process:
 
 ```ts
-const proc = Bun.spawn(["echo", "hello"]);
+const proc = Bun.spawn(["bun", "--version"]);
 proc.kill();
 proc.killed; // true
 
@@ -179,7 +180,7 @@ proc.kill(); // specify an exit code
 The parent `bun` process will not terminate until all child processes have exited. Use `proc.unref()` to detach the child process from the parent.
 
 ```
-const proc = Bun.spawn(["echo", "hello"]);
+const proc = Bun.spawn(["bun", "--version"]);
 proc.unref();
 ```
 
@@ -187,10 +188,6 @@ proc.unref();
 
 Bun supports direct inter-process communication channel between two `bun` processes. To receive messages from a spawned Bun subprocess, specify an `ipc` handler.
 
-{%callout%}
-**Note** — This API is only compatible with other `bun` processes. Use `process.execPath` to get a path to the currently running `bun` executable.
-{%/callout%}
-
 ```ts#parent.ts
 const child = Bun.spawn(["bun", "child.ts"], {
   ipc(message) {
@@ -241,6 +238,34 @@ The `ipcMode` option controls the underlying communication format between the tw
 - `advanced`: (default) Messages are serialized using the JSC `serialize` API, which supports cloning [everything `structuredClone` supports](https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API/Structured_clone_algorithm). This does not support transferring ownership of objects.
 - `json`: Messages are serialized using `JSON.stringify` and `JSON.parse`, which does not support as many object types as `advanced` does.
 
+### IPC between Bun & Node.js
+
+To use IPC between a `bun` process and a Node.js process, set `serialization: "json"` in `Bun.spawn`. This is because Node.js and Bun use different JavaScript engines with different object serialization formats.
+
+```js#bun-node-ipc.js
+if (typeof Bun !== "undefined") {
+  const prefix = `[bun ${process.versions.bun} 🐇]`;
+  const node = Bun.spawn({
+    cmd: ["node", __filename],
+    ipc({ message }) {
+      console.log(message);
+      node.send({ message: `${prefix} 👋 hey node` });
+      node.kill();
+    },
+    stdio: ["inherit", "inherit", "inherit"],
+    serialization: "json",
+  });
+
+  node.send({ message: `${prefix} 👋 hey node` });
+} else {
+  const prefix = `[node ${process.version}]`;
+  process.on("message", ({ message }) => {
+    console.log(message);
+    process.send({ message: `${prefix} 👋 hey bun` });
+  });
+}
+```
+
 ## Blocking API (`Bun.spawnSync()`)
 
 Bun provides a synchronous equivalent of `Bun.spawn` called `Bun.spawnSync`. This is a blocking API that supports the same inputs and parameters as `Bun.spawn`. It returns a `SyncSubprocess` object, which differs from `Subprocess` in a few ways.

docs/api/sqlite.md

@@ -16,7 +16,10 @@ Features include:
 - Parameters (named & positional)
 - Prepared statements
 - Datatype conversions (`BLOB` becomes `Uint8Array`)
+- Map query results to classes without an ORM - `query.as(MyClass)`
 - The fastest performance of any SQLite driver for JavaScript
+- `bigint` support
+- Multi-query statements (e.g. `SELECT 1; SELECT 2;`) in a single call to database.run(query)
 
 The `bun:sqlite` module is roughly 3-6x faster than `better-sqlite3` and 8-9x faster than `deno.land/x/sqlite` for read queries. Each driver was benchmarked against the [Northwind Traders](https://github.com/jpwhite3/northwind-SQLite3/blob/46d5f8a64f396f87cd374d1600dbf521523980e8/Northwind_large.sqlite.zip) dataset. View and run the [benchmark source](https://github.com/oven-sh/bun/tree/main/bench/sqlite).
 
@@ -57,6 +60,39 @@ import { Database } from "bun:sqlite";
 const db = new Database("mydb.sqlite", { create: true });
 ```
 
+### Strict mode
+
+{% callout %}
+Added in Bun v1.1.14
+{% /callout %}
+
+By default, `bun:sqlite` requires binding parameters to include the `$`, `:`, or `@` prefix, and does not throw an error if a parameter is missing.
+
+To instead throw an error when a parameter is missing and allow binding without a prefix, set `strict: true` on the `Database` constructor:
+
+<!-- prettier-ignore -->
+```ts
+import { Database } from "bun:sqlite";
+
+const strict = new Database(
+  ":memory:", 
+  { strict: true }
+);
+
+// throws error because of the typo:
+const query = strict
+  .query("SELECT $message;")
+  .all({ messag: "Hello world" });
+
+const notStrict = new Database(
+  ":memory:"
+);
+// does not throw error:
+notStrict
+  .query("SELECT $message;")
+  .all({ messag: "Hello world" });
+```
+
 ### Load via ES module import
 
 You can also use an import attribute to load a database.
@@ -174,6 +210,47 @@ const query = db.query(`SELECT $param1, $param2;`);
 
 Values are bound to these parameters when the query is executed. A `Statement` can be executed with several different methods, each returning the results in a different form.
 
+### Binding values
+
+To bind values to a statement, pass an object to the `.all()`, `.get()`, `.run()`, or `.values()` method.
+
+```ts
+const query = db.query(`select $message;`);
+query.all({ $message: "Hello world" });
+```
+
+You can bind using positional parameters too:
+
+```ts
+const query = db.query(`select ?1;`);
+query.all("Hello world");
+```
+
+#### `strict: true` lets you bind values without prefixes
+
+{% callout %}
+Added in Bun v1.1.14
+{% /callout %}
+
+By default, the `$`, `:`, and `@` prefixes are **included** when binding values to named parameters. To bind without these prefixes, use the `strict` option in the `Database` constructor.
+
+```ts
+import { Database } from "bun:sqlite";
+
+const db = new Database(":memory:", {
+  // bind values without prefixes
+  strict: true,
+});
+
+const query = db.query(`select $message;`);
+
+// strict: true
+query.all({ message: "Hello world" });
+
+// strict: false
+// query.all({ $message: "Hello world" });
+```
+
 ### `.all()`
 
 Use `.all()` to run a query and get back the results as an array of objects.
@@ -200,16 +277,54 @@ Internally, this calls [`sqlite3_reset`](https://www.sqlite.org/capi3ref.html#sq
 
 ### `.run()`
 
-Use `.run()` to run a query and get back `undefined`. This is useful for queries schema-modifying queries (e.g. `CREATE TABLE`) or bulk write operations.
+Use `.run()` to run a query and get back `undefined`. This is useful for schema-modifying queries (e.g. `CREATE TABLE`) or bulk write operations.
 
 ```ts
 const query = db.query(`create table foo;`);
 query.run();
-// => undefined
+// {
+//   lastInsertRowid: 0,
+//   changes: 0,
+// }
 ```
 
 Internally, this calls [`sqlite3_reset`](https://www.sqlite.org/capi3ref.html#sqlite3_reset) and calls [`sqlite3_step`](https://www.sqlite.org/capi3ref.html#sqlite3_step) once. Stepping through all the rows is not necessary when you don't care about the results.
 
+{% callout %}
+Since Bun v1.1.14, `.run()` returns an object with two properties: `lastInsertRowid` and `changes`.
+{% /callout %}
+
+The `lastInsertRowid` property returns the ID of the last row inserted into the database. The `changes` property is the number of rows affected by the query.
+
+### `.as(Class)` - Map query results to a class
+
+{% callout %}
+Added in Bun v1.1.14
+{% /callout %}
+
+Use `.as(Class)` to run a query and get back the results as instances of a class. This lets you attach methods & getters/setters to results.
+
+```ts
+class Movie {
+  title: string;
+  year: number;
+
+  get isMarvel() {
+    return this.title.includes("Marvel");
+  }
+}
+
+const query = db.query("SELECT title, year FROM movies").as(Movie);
+const movies = query.all();
+const first = query.get();
+console.log(movies[0].isMarvel); // => true
+console.log(first.isMarvel); // => true
+```
+
+As a performance optimization, the class constructor is not called, default initializers are not run, and private fields are not accessible. This is more like using `Object.create` than `new`. The class's prototype is assigned to the object, methods are attached, and getters/setters are set up, but the constructor is not called.
+
+The database columns are set as properties on the class instance.
+
 ### `.values()`
 
 Use `values()` to run a query and get back all results as an array of arrays.
@@ -300,6 +415,65 @@ const results = query.all("hello", "goodbye");
 
 {% /codetabs %}
 
+## Integers
+
+sqlite supports signed 64 bit integers, but JavaScript only supports signed 52 bit integers or arbitrary precision integers with `bigint`.
+
+`bigint` input is supported everywhere, but by default `bun:sqlite` returns integers as `number` types. If you need to handle integers larger than 2^53, set `safeInteger` option to `true` when creating a `Database` instance. This also validates that `bigint` passed to `bun:sqlite` do not exceed 64 bits.
+
+By default, `bun:sqlite` returns integers as `number` types. If you need to handle integers larger than 2^53, you can use the `bigint` type.
+
+### `safeIntegers: true`
+
+{% callout %}
+Added in Bun v1.1.14
+{% /callout %}
+
+When `safeIntegers` is `true`, `bun:sqlite` will return integers as `bigint` types:
+
+```ts
+import { Database } from "bun:sqlite";
+
+const db = new Database(":memory:", { safeIntegers: true });
+const query = db.query(
+  `SELECT ${BigInt(Number.MAX_SAFE_INTEGER) + 102n} as max_int`,
+);
+const result = query.get();
+console.log(result.max_int); // => 9007199254741093n
+```
+
+When `safeIntegers` is `true`, `bun:sqlite` will throw an error if a `bigint` value in a bound parameter exceeds 64 bits:
+
+```ts
+import { Database } from "bun:sqlite";
+
+const db = new Database(":memory:", { safeIntegers: true });
+db.run("CREATE TABLE test (id INTEGER PRIMARY KEY, value INTEGER)");
+
+const query = db.query("INSERT INTO test (value) VALUES ($value)");
+
+try {
+  query.run({ $value: BigInt(Number.MAX_SAFE_INTEGER) ** 2n });
+} catch (e) {
+  console.log(e.message); // => BigInt value '81129638414606663681390495662081' is out of range
+}
+```
+
+### `safeIntegers: false` (default)
+
+When `safeIntegers` is `false`, `bun:sqlite` will return integers as `number` types and truncate any bits beyond 53:
+
+```ts
+import { Database } from "bun:sqlite";
+
+const db = new Database(":memory:", { safeIntegers: false });
+const query = db.query(
+  `SELECT ${BigInt(Number.MAX_SAFE_INTEGER) + 102n} as max_int`,
+);
+const result = query.get();
+console.log(result.max_int); // => 9007199254741092
+```
+
 ## Transactions
 
 Transactions are a mechanism for executing multiple queries in an _atomic_ way; that is, either all of the queries succeed or none of them do. Create a transaction with the `db.transaction()` method:
@@ -447,12 +621,20 @@ class Database {
   );
 
   query<Params, ReturnType>(sql: string): Statement<Params, ReturnType>;
+  run(
+    sql: string,
+    params?: SQLQueryBindings,
+  ): { lastInsertRowid: number; changes: number };
+  exec = this.run;
 }
 
 class Statement<Params, ReturnType> {
   all(params: Params): ReturnType[];
   get(params: Params): ReturnType | undefined;
-  run(params: Params): void;
+  run(params: Params): {
+    lastInsertRowid: number;
+    changes: number;
+  };
   values(params: Params): unknown[][];
 
   finalize(): void; // destroy statement and clean up resources
@@ -461,6 +643,8 @@ class Statement<Params, ReturnType> {
   columnNames: string[]; // the column names of the result set
   paramsCount: number; // the number of parameters expected by the statement
   native: any; // the native object representing the statement
+
+  as(Class: new () => ReturnType): this;
 }
 
 type SQLQueryBindings =

docs/api/udp.md

@@ -0,0 +1,125 @@
+Use Bun's UDP API to implement services with advanced real-time requirements, such as voice chat.
+
+## Bind a UDP socket (`Bun.udpSocket()`)
+
+To create a new (bound) UDP socket:
+
+```ts
+const socket = await Bun.udpSocket({})
+console.log(socket.port); // assigned by the operating system
+```
+
+Specify a port:
+```ts
+const socket = await Bun.udpSocket({
+  port: 41234
+})
+console.log(socket.port); // 41234
+```
+
+### Send a datagram
+
+Specify the data to send, as well as the destination port and address.
+
+```ts
+socket.send("Hello, world!", 41234, "127.0.0.1");
+```
+
+Note that the address must be a valid IP address - `send` does not perform
+DNS resolution, as it is intended for low-latency operations.
+
+
+### Receive datagrams
+
+When creating your socket, add a callback to specify what should be done when packets are received:
+
+```ts
+const server = await Bun.udpSocket({
+  socket: {
+    data(socket, buf, port, addr) {
+      console.log(`message from ${addr}:${port}:`)
+      console.log(buf.toString());
+    } 
+  }
+})
+
+const client = await Bun.udpSocket({});
+client.send("Hello!", server.port, "127.0.0.1");
+```
+
+### Connections
+
+While UDP does not have a concept of a connection, many UDP communications (especially as a client) involve only one peer.
+In such cases it can be beneficial to connect the socket to that peer, which specifies to which address all packets are sent
+and restricts incoming packets to that peer only.
+
+```ts
+
+const server = await Bun.udpSocket({
+  socket: {
+    data(socket, buf, port, addr) {
+      console.log(`message from ${addr}:${port}:`)
+      console.log(buf.toString());
+    } 
+  }
+})
+const client = await Bun.udpSocket({
+  connect: {
+    port: server.port,
+    hostname: '127.0.0.1',
+  }
+});
+
+client.send("Hello");
+
+```
+
+Because connections are implemented on the operating system level, you can potentially observe performance benefits, too.
+
+
+### Send many packets at once using `sendMany()`
+
+If you want to send a large volume of packets at once, it can make sense to batch them all together to avoid the overhead
+of making a system call for each. This is made possible by the `sendMany()` API:
+
+For an unconnected socket, `sendMany` takes an array as its only argument. Each set of three array elements describes a packet:
+The first item is the data to be sent, the second is the target port, and the last is the target address.
+
+```ts
+const socket = await Bun.udpSocket({})
+// sends 'Hello' to 127.0.0.1:41234, and 'foo' to 1.1.1.1:53 in a single operation
+socket.sendMany(['Hello', 41234, '127.0.0.1', 'foo', 53, '1.1.1.1'])
+```
+
+With a connected socket, `sendMany` simply takes an array, where each element represents the data to be sent to the peer.
+
+```ts
+const socket = await Bun.udpSocket({
+  connect: {
+    port: 41234,
+    hostname: 'localhost',
+  }
+});
+socket.sendMany(['foo', 'bar', 'baz']);
+```
+
+`sendMany` returns the number of packets that were successfully sent. As with `send`, `sendMany` only takes valid IP addresses
+as destinations, as it does not perform DNS resolution.
+
+### Handle backpressure
+
+It may happen that a packet that you're sending does not fit into the operating system's packet buffer. You can detect that this
+has happened when:
+- `send` returns `false` 
+- `sendMany` returns a number smaller than the number of packets you specified
+In this case, the `drain` socket handler will be called once the socket becomes writable again:
+
+```ts
+const socket = await Bun.udpSocket({
+  socket: {
+    drain(socket) {
+      // continue sending data
+    }
+  }
+});
+```

docs/api/utils.md

@@ -183,7 +183,7 @@ const currentFile = import.meta.url;
 Bun.openInEditor(currentFile);
 ```
 
-You can override this via the `debug.editor` setting in your [`bunfig.toml`](/docs/runtime/bunfig)
+You can override this via the `debug.editor` setting in your [`bunfig.toml`](/docs/runtime/bunfig).
 
 ```toml-diff#bunfig.toml
 + [debug]
@@ -200,8 +200,6 @@ Bun.openInEditor(import.meta.url, {
 });
 ```
 
-Bun.ArrayBufferSink;
-
 ## `Bun.deepEquals()`
 
 Recursively checks if two objects are equivalent. This is used internally by `expect().toEqual()` in `bun:test`.
@@ -251,11 +249,11 @@ Bun.deepEquals(new Foo(), { a: 1 }, true); // false
 
 Escapes the following characters from an input string:
 
-- `"` becomes `"""`
-- `&` becomes `"&"`
-- `'` becomes `"'"`
-- `<` becomes `"&lt;"`
-- `>` becomes `"&gt;"`
+- `"` becomes `&quot;`
+- `&` becomes `&amp;`
+- `'` becomes `&#x27;`
+- `<` becomes `&lt;`
+- `>` becomes `&gt;`
 
 This function is optimized for large input. On an M1X, it processes 480 MB/s -
 20 GB/s, depending on how much data is being escaped and whether there is non-ascii
@@ -275,6 +273,7 @@ Bun.stringWidth("\u001b[31mhello\u001b[0m", { countAnsiEscapeCodes: true }); //
 ```
 
 This is useful for:
+
 - Aligning text in a terminal
 - Quickly checking if a string contains ANSI escape codes
 - Measuring the width of a string in a terminal
@@ -372,7 +371,6 @@ npm/string-width 95,000 chars ansi+emoji+ascii     3.68 s/iter        (3.66 s
 
 {% /details %}
 
-
 TypeScript definition:
 
 ```ts
@@ -400,7 +398,6 @@ namespace Bun {
 }
 ```
 
-
 <!-- ## `Bun.enableANSIColors()` -->
 
 ## `Bun.fileURLToPath()`
@@ -603,6 +600,9 @@ stream; // => ReadableStream
 await Bun.readableStreamToArrayBuffer(stream);
 // => ArrayBuffer
 
+await Bun.readableStreamToBytes(stream);
+// => Uint8Array
+
 await Bun.readableStreamToBlob(stream);
 // => Blob
 

docs/api/websockets.md

@@ -23,7 +23,7 @@ Bun.serve({
     if (server.upgrade(req)) {
       return; // do not return a Response
     }
-    return new Response("Upgrade failed :(", { status: 500 });
+    return new Response("Upgrade failed", { status: 500 });
   },
   websocket: {}, // handlers
 });
@@ -321,7 +321,7 @@ namespace Bun {
         message: string | ArrayBuffer | Uint8Array,
       ) => void;
       open?: (ws: ServerWebSocket) => void;
-      close?: (ws: ServerWebSocket) => void;
+      close?: (ws: ServerWebSocket, code: number, reason: string) => void;
       error?: (ws: ServerWebSocket, error: Error) => void;
       drain?: (ws: ServerWebSocket) => void;
 
@@ -356,7 +356,7 @@ type Compressor =
   | `"256KB"`;
 
 interface Server {
-  pendingWebsockets: number;
+  pendingWebSockets: number;
   publish(
     topic: string,
     data: string | ArrayBufferView | ArrayBuffer,

docs/api/workers.md

@@ -13,8 +13,7 @@ Like in browsers, [`Worker`](https://developer.mozilla.org/en-US/docs/Web/API/Wo
 ### From the main thread
 
 ```js#Main_thread
-const workerURL = new URL("worker.ts", import.meta.url).href;
-const worker = new Worker(workerURL);
+const worker = new Worker("./worker.ts");
 
 worker.postMessage("hello");
 worker.onmessage = event => {
@@ -51,6 +50,38 @@ const worker = new Worker("/not-found.js");
 
 The specifier passed to `Worker` is resolved relative to the project root (like typing `bun ./path/to/file.js`).
 
+### `blob:` URLs
+
+As of Bun v1.1.13, you can also pass a `blob:` URL to `Worker`. This is useful for creating workers from strings or other sources.
+
+```js
+const blob = new Blob(
+  [
+    `
+  self.onmessage = (event: MessageEvent) => postMessage(event.data)`,
+  ],
+  {
+    type: "application/typescript",
+  },
+);
+const url = URL.createObjectURL(blob);
+const worker = new Worker(url);
+```
+
+Like the rest of Bun, workers created from `blob:` URLs support TypeScript, JSX, and other file types out of the box. You can communicate it should be loaded via typescript either via `type` or by passing a `filename` to the `File` constructor.
+
+```js
+const file = new File(
+  [
+    `
+  self.onmessage = (event: MessageEvent) => postMessage(event.data)`,
+  ],
+  "worker.ts",
+);
+const url = URL.createObjectURL(file);
+const worker = new Worker(url);
+```
+
 ### `"open"`
 
 The `"open"` event is emitted when a worker is created and ready to receive messages. This can be used to send an initial message to a worker once it's ready. (This event does not exist in browsers.)

docs/bundler/executables.md

@@ -21,21 +21,76 @@ Hello world!
 
 All imported files and packages are bundled into the executable, along with a copy of the Bun runtime. All built-in Bun and Node.js APIs are supported.
 
-{% callout %}
+## Cross-compile to other platforms
 
-**Note** — Currently, the `--compile` flag can only accept a single entrypoint at a time and does not support the following flags:
+The `--target` flag lets you compile your standalone executable for a different operating system, architecture, or version of Bun than the machine you're running `bun build` on.
 
-- `--outdir` — use `outfile` instead.
-- `--splitting`
-- `--public-path`
+To build for Linux x64 (most servers):
 
-{% /callout %}
+```sh
+bun build --compile --target=bun-linux-x64 ./index.ts --outfile myapp
+
+# To support CPUs from before 2013, use the baseline version (nehalem)
+bun build --compile --target=bun-linux-x64-baseline ./index.ts --outfile myapp
+
+# To explicitly only support CPUs from 2013 and later, use the modern version (haswell)
+# modern is faster, but baseline is more compatible.
+bun build --compile --target=bun-linux-x64-modern ./index.ts --outfile myapp
+```
+
+To build for Linux ARM64 (e.g. Graviton or Raspberry Pi):
+
+```sh
+# Note: the default architecture is x64 if no architecture is specified.
+bun build --compile --target=bun-linux-arm64 ./index.ts --outfile myapp
+```
+
+To build for Windows x64:
+
+```sh
+bun build --compile --target=bun-windows-x64 ./path/to/my/app.ts --outfile myapp
+
+# To support CPUs from before 2013, use the baseline version (nehalem)
+bun build --compile --target=bun-windows-x64-baseline ./path/to/my/app.ts --outfile myapp
+
+# To explicitly only support CPUs from 2013 and later, use the modern version (haswell)
+bun build --compile --target=bun-windows-x64-modern ./path/to/my/app.ts --outfile myapp
+
+# note: if no .exe extension is provided, Bun will automatically add it for Windows executables
+```
+
+To build for macOS arm64:
+
+```sh
+bun build --compile --target=bun-darwin-arm64 ./path/to/my/app.ts --outfile myapp
+```
+
+To build for macOS x64:
+
+```sh
+bun build --compile --target=bun-darwin-x64 ./path/to/my/app.ts --outfile myapp
+```
+
+#### Supported targets
+
+The order of the `--target` flag does not matter, as long as they're delimited by a `-`.
+
+| --target              | Operating System | Architecture | Modern | Baseline |
+| --------------------- | ---------------- | ------------ | ------ | -------- |
+| bun-linux-x64         | Linux            | x64          | ✅     | ✅       |
+| bun-linux-arm64       | Linux            | arm64        | ✅     | N/A      |
+| bun-windows-x64       | Windows          | x64          | ✅     | ✅       |
+| ~~bun-windows-arm64~~ | Windows          | arm64        | ❌     | ❌       |
+| bun-darwin-x64        | macOS            | x64          | ✅     | ✅       |
+| bun-darwin-arm64      | macOS            | arm64        | ✅     | N/A      |
+
+On x64 platforms, Bun uses SIMD optimizations which require a modern CPU supporting AVX2 instructions. The `-baseline` build of Bun is for older CPUs that don't support these optimizations. Normally, when you install Bun we automatically detect which version to use but this can be harder to do when cross-compiling since you might not know the target CPU. You usually don't need to worry about it on Darwin x64, but it is relevant for Windows x64 and Linux x64. If you or your users see `"Illegal instruction"` errors, you might need to use the baseline version.
 
 ## Deploying to production
 
 Compiled executables reduce memory usage and improve Bun's start time.
 
-Normally, Bun reads and transpiles JavaScript and TypeScript files on `import` and `require`. This is part of what makes so much of Bun "just work", but it's not free. It costs time and memory to read files from disk, resolve file paths, parse, transpile, and print source code. 
+Normally, Bun reads and transpiles JavaScript and TypeScript files on `import` and `require`. This is part of what makes so much of Bun "just work", but it's not free. It costs time and memory to read files from disk, resolve file paths, parse, transpile, and print source code.
 
 With compiled executables, you can move that cost from runtime to build-time.
 
@@ -58,7 +113,7 @@ You can use `bun:sqlite` imports with `bun build --compile`.
 By default, the database is resolved relative to the current working directory of the process.
 
 ```js
-import db from './my.db' with {type: "sqlite"};
+import db from "./my.db" with { type: "sqlite" };
 
 console.log(db.query("select * from users LIMIT 1").get());
 ```
@@ -70,42 +125,49 @@ $ cd /home/me/Desktop
 $ ./hello
 ```
 
-## Embedding files
+## Embed assets & files
 
 Standalone executables support embedding files.
 
 To embed files into an executable with `bun build --compile`, import the file in your code
 
-```js
+```ts
 // this becomes an internal file path
-import icon from "./icon.png";
-
+import icon from "./icon.png" with { type: "file" };
 import { file } from "bun";
 
 export default {
   fetch(req) {
+    // Embedded files can be streamed from Response objects
     return new Response(file(icon));
   },
 };
 ```
 
-You may need to specify a `--loader` for it to be treated as a `"file"` loader (so you get back a file path).
-
 Embedded files can be read using `Bun.file`'s functions or the Node.js `fs.readFile` function (in `"node:fs"`).
 
-### Embedding SQLite databases
+For example, to read the contents of the embedded file:
+
+```js
+import icon from "./icon.png" with { type: "file" };
+import { file } from "bun";
+
+const bytes = await file(icon).arrayBuffer();
+```
+
+### Embed SQLite databases
 
 If your application wants to embed a SQLite database, set `type: "sqlite"` in the import attribute and the `embed` attribute to `"true"`.
 
 ```js
-import myEmbeddedDb from "./my.db" with {type: "sqlite", embed: "true"};
+import myEmbeddedDb from "./my.db" with { type: "sqlite", embed: "true" };
 
 console.log(myEmbeddedDb.query("select * from users LIMIT 1").get());
 ```
 
 This database is read-write, but all changes are lost when the executable exits (since it's stored in memory).
 
-### Embedding N-API Addons
+### Embed N-API Addons
 
 As of Bun v1.0.23, you can embed `.node` files into executables.
 
@@ -120,3 +182,14 @@ Unfortunately, if you're using `@mapbox/node-pre-gyp` or other similar tools, yo
 ## Minification
 
 To trim down the size of the executable a little, pass `--minify` to `bun build --compile`. This uses Bun's minifier to reduce the code size. Overall though, Bun's binary is still way too big and we need to make it smaller.
+
+## Unsupported CLI arguments
+
+Currently, the `--compile` flag can only accept a single entrypoint at a time and does not support the following flags:
+
+- `--outdir` — use `outfile` instead.
+- `--splitting`
+- `--public-path`
+- `--target=node` or `--target=browser`
+- `--format` - always outputs a binary executable. Internally, it's almost esm.
+- `--no-bundle` - we always bundle everything into the executable.

docs/bundler/index.md

@@ -563,12 +563,12 @@ Specifies the type of sourcemap to generate.
 await Bun.build({
   entrypoints: ['./index.tsx'],
   outdir: './out',
-  sourcemap: "external", // default "none"
+  sourcemap: 'linked', // default 'none'
 })
 ```
 
 ```bash#CLI
-$ bun build ./index.tsx --outdir ./out --sourcemap=external
+$ bun build ./index.tsx --outdir ./out --sourcemap=linked
 ```
 
 {% /codetabs %}
@@ -582,19 +582,19 @@ $ bun build ./index.tsx --outdir ./out --sourcemap=external
 
 ---
 
-- `"inline"`
-- A sourcemap is generated and appended to the end of the generated bundle as a base64 payload.
+- `"linked"`
+- A separate `*.js.map` file is created alongside each `*.js` bundle using a `//# sourceMappingURL` comment to link the two. Requires `--outdir` to be set. The base URL of this can be customized with `--public-path`.
 
   ```ts
   // <bundled code here>
 
-  //# sourceMappingURL=data:application/json;base64,<encoded sourcemap here>
+  //# sourceMappingURL=bundle.js.map
   ```
 
 ---
 
 - `"external"`
-- A separate `*.js.map` file is created alongside each `*.js` bundle.
+- A separate `*.js.map` file is created alongside each `*.js` bundle without inserting a `//# sourceMappingURL` comment.
 
 {% /table %}
 
@@ -608,7 +608,18 @@ Generated bundles contain a [debug id](https://sentry.engineering/blog/the-case-
 //# debugId=<DEBUG ID>
 ```
 
-The associated `*.js.map` sourcemap will be a JSON file containing an equivalent `debugId` property.
+---
+
+- `"inline"`
+- A sourcemap is generated and appended to the end of the generated bundle as a base64 payload.
+
+  ```ts
+  // <bundled code here>
+
+  //# sourceMappingURL=data:application/json;base64,<encoded sourcemap here>
+  ```
+
+  The associated `*.js.map` sourcemap will be a JSON file containing an equivalent `debugId` property.
 
 {% /callout %}
 
@@ -745,6 +756,25 @@ $ bun build ./index.tsx --outdir ./out --external '*'
 
 {% /codetabs %}
 
+### `packages`
+
+Control whatever package dependencies are included to bundle or not. Possible values: `bundle` (default), `external`. Bun threats any import which path do not start with `.`, `..` or `/` as package.
+
+{% codetabs group="a" %}
+
+```ts#JavaScript
+await Bun.build({
+  entrypoints: ['./index.ts'],
+  packages: 'external',
+})
+```
+
+```bash#CLI
+$ bun build ./index.ts --packages external
+```
+
+{% /codetabs %}
+
 ### `naming`
 
 Customizes the generated file names. Defaults to `./[dir]/[name].[ext]`.
@@ -792,7 +822,7 @@ The names and locations of the generated files can be customized with the `namin
 - `[name]` - The name of the entrypoint file, without the extension.
 - `[ext]` - The extension of the generated bundle.
 - `[hash]` - A hash of the bundle contents.
-- `[dir]` - The relative path from the build root to the parent directory of the file.
+- `[dir]` - The relative path from the project root to the parent directory of the source file.
 
 For example:
 
@@ -1096,6 +1126,7 @@ const build = await Bun.build({
 
 for (const output of build.outputs) {
   await output.arrayBuffer(); // => ArrayBuffer
+  await output.bytes(); // => Uint8Array
   await output.text(); // string
 }
 ```
@@ -1245,7 +1276,7 @@ interface BuildOptions {
   loader?: { [k in string]: Loader }; // See https://bun.sh/docs/bundler/loaders
   manifest?: boolean; // false
   external?: string[]; // []
-  sourcemap?: "none" | "inline" | "external"; // "none"
+  sourcemap?: "none" | "inline" | "linked" | "external" | boolean; // "none"
   root?: string; // computed from entrypoints
   naming?:
     | string

docs/bundler/loaders.md

@@ -80,6 +80,9 @@ TOML files can be directly imported. Bun will parse them with its fast native TO
 ```ts
 import config from "./bunfig.toml";
 config.logLevel; // => "debug"
+
+// via import attribute:
+// import myCustomTOML from './my.config' with {type: "toml"};
 ```
 
 During bundling, the parsed TOML is inlined into the bundle as a JavaScript object.
@@ -122,6 +125,10 @@ Text files can be directly imported. The file is read and returned as a string.
 ```ts
 import contents from "./file.txt";
 console.log(contents); // => "Hello, world!"
+
+// To import an html file as text
+// The "type' attribute can be used to override the default loader.
+import html from "./index.html" with { type: "text" };
 ```
 
 When referenced during a build, the contents are into the bundle as a string.
@@ -175,7 +182,7 @@ In the bundler, `.node` files are handled using the [`file`](#file) loader.
 
 **SQLite loader**. `with { "type": "sqlite" }` import attribute
 
-In the runtime and bundler, SQLite databases can be directly imported. This will load the database using [`bun:sqlite`](/docs/api/sqlite.md).
+In the runtime and bundler, SQLite databases can be directly imported. This will load the database using [`bun:sqlite`](/docs/api/sqlite).
 
 ```ts
 import db from "./my.db" with { type: "sqlite" };

docs/bundler/vs-esbuild.md

@@ -94,8 +94,8 @@ In Bun's CLI, simple boolean flags like `--minify` do not accept an argument. Ot
 ---
 
 - `--packages`
-- n/a
-- Not supported
+- `--packages`
+- No differences
 
 ---
 

docs/cli/add.md

@@ -35,6 +35,10 @@ $ bun add --optional lodash
 
 ## `--exact`
 
+{% callout %}
+**Alias** — `-E`
+{% /callout %}
+
 To add a package and pin to the resolved version, use `--exact`. This will resolve the version of the package and add it to your `package.json` with an exact version number instead of a version range.
 
 ```bash
@@ -117,12 +121,16 @@ Bun reads this field and will run lifecycle scripts for `my-trusted-package`.
 
 ## Git dependencies
 
-To add a dependency from a git repository:
+To add a dependency from a public or private git repository:
 
 ```bash
 $ bun add git@github.com:moment/moment.git
 ```
 
+{% callout %}
+**Note** — To install private repositories, your system needs the appropriate SSH credentials to access the repository.
+{% /callout %}
+
 Bun supports a variety of protocols, including [`github`](https://docs.npmjs.com/cli/v9/configuring-npm/package-json#github-urls), [`git`](https://docs.npmjs.com/cli/v9/configuring-npm/package-json#git-urls-as-dependencies), `git+ssh`, `git+https`, and many more.
 
 ```json

docs/cli/bun-create.md

@@ -207,8 +207,8 @@ After cloning a template, `bun create` will automatically remove the `"bun-creat
 
 ---
 
-- `GITHUB_ACCESS_TOKEN`
-- This lets `bun create` work with private repositories or if you get rate-limited
+- `GITHUB_TOKEN` (or `GITHUB_ACCESS_TOKEN`)
+- This lets `bun create` work with private repositories or if you get rate-limited. `GITHUB_TOKEN` is chosen over `GITHUB_ACCESS_TOKEN` if both exist.
 
 {% /table %}
 

docs/cli/filter.md

@@ -39,7 +39,7 @@ Path patterns are specified by starting the pattern with `./`, and will select a
 
 ## Workspaces
 
-Filters respect your [workspace configuration](/docs/install/workspaces.md): If you have a `package.json` file that specifies which packages are part of the workspace,
+Filters respect your [workspace configuration](/docs/install/workspaces): If you have a `package.json` file that specifies which packages are part of the workspace,
 `--filter` will be restricted to only these packages. Also, in a workspace you can use `--filter` to run scripts in packages that are located anywhere in the workspace:
 
 ```bash

docs/cli/patch-commit.md

@@ -0,0 +1,9 @@
+An alias for `bun patch --commit` to maintain compatibility with pnpm.
+
+You must prepare the package for patching with [`bun patch <pkg>`](/docs/cli/patch) first.
+
+### `--patches-dir`
+
+By default, `bun patch-commit` will use the `patches` directory in the temporary directory.
+
+You can specify a different directory with the `--patches-dir` flag.

docs/cli/pm.md

@@ -56,3 +56,17 @@ To clear Bun's global module cache:
 ```bash
 $ bun pm cache rm
 ```
+
+## List global installs
+
+To list all globally installed packages:
+
+```bash
+$ bun pm ls -g
+```
+
+To list all globally installed packages, including nth-order dependencies:
+
+```bash
+$ bun pm ls -g --all
+```

docs/cli/run.md

@@ -162,7 +162,7 @@ bun run --filter 'ba*' <script>
 ```
 will execute `<script>` in both `bar` and `baz`, but not in `foo`.
 
-Find more details in the docs page for [filter](/docs/cli/filter.md).
+Find more details in the docs page for [filter](/docs/cli/filter).
 
 ## `bun run -` to pipe code from stdin
 

docs/cli/update.md

@@ -1,17 +1,34 @@
-To update all dependencies to the latest version _that's compatible with the version range specified in your `package.json`_:
+To update all dependencies to the latest version:
 
 ```sh
 $ bun update
 ```
 
-## `--force`
-
-{% callout %}
-**Alias** — `-f`
-{% /callout %}
-
-By default, Bun respects the version range defined in your package.json. To ignore this and update to the latest version, you can pass in the `force` flag.
+To update a specific dependency to the latest version:
 
 ```sh
-$ bun update --force
+$ bun update [package]
 ```
+
+## `--latest`
+
+By default, `bun update` will update to the latest version of a dependency that satisfies the version range specified in your `package.json`.
+
+To update to the latest version, regardless of if it's compatible with the current version range, use the `--latest` flag:
+
+```sh
+$ bun update --latest
+```
+
+For example, with the following `package.json`:
+
+```json
+{
+  "dependencies": {
+    "react": "^17.0.2"
+  }
+}
+```
+
+- `bun update` would update to a version that matches `17.x`.
+- `bun update --latest` would update to a version that matches `18.x` or later.

docs/guides/ecosystem/docker.md

@@ -15,7 +15,7 @@ To _containerize_ our application, we define a `Dockerfile`. This file contains
 ```docker#Dockerfile
 # use the official Bun image
 # see all versions at https://hub.docker.com/r/oven/bun/tags
-FROM oven/bun:1 as base
+FROM oven/bun:1 AS base
 WORKDIR /usr/src/app
 
 # install dependencies into temp directory
@@ -77,7 +77,7 @@ coverage*
 
 ---
 
-We'll now use `docker build` to convert this `Dockerfile` into a _Docker image_, is a self-contained template containing all the dependencies and configuration required to run the application.
+We'll now use `docker build` to convert this `Dockerfile` into a _Docker image_, a self-contained template containing all the dependencies and configuration required to run the application.
 
 The `-t` flag lets us specify a name for the image, and `--pull` tells Docker to automatically download the latest version of the base image (`oven/bun`). The initial build will take longer, as Docker will download all the base images and dependencies.
 

docs/guides/ecosystem/drizzle.md

@@ -69,7 +69,7 @@ export const movies = sqliteTable("movies", {
 We can use the `drizzle-kit` CLI to generate an initial SQL migration.
 
 ```sh
-$ bunx drizzle-kit generate:sqlite --schema ./schema.ts
+$ bunx drizzle-kit generate --dialect sqlite --schema ./schema.ts
 ```
 
 ---

docs/guides/ecosystem/neon-drizzle.md

@@ -0,0 +1,220 @@
+---
+name: Use Neon Postgres through Drizzle ORM
+---
+
+[Neon](https://neon.tech/) is a fully managed serverless Postgres, separating compute and storage to offer features like autoscaling, branching and bottomless storage. Neon can be used from Bun directly using the `@neondatabase/serverless` driver or through an ORM like `Drizzle`. 
+
+Drizzle ORM supports both a SQL-like "query builder" API and an ORM-like [Queries API](https://orm.drizzle.team/docs/rqb). Get started by creating a project directory, initializing the directory using `bun init`, and installing Drizzle and the [Neon serverless driver](https://github.com/neondatabase/serverless/). 
+
+```sh
+$ mkdir bun-drizzle-neon
+$ cd bun-drizzle-neon
+$ bun init -y
+$ bun add drizzle-orm @neondatabase/serverless
+$ bun add -D drizzle-kit
+```
+
+---
+
+Create a `.env.local` file and add your [Neon Postgres connection string](https://neon.tech/docs/connect/connect-from-any-app) to it.
+
+```sh
+DATBASE_URL=postgresql://username:password@ep-adj-noun-guid.us-east-1.aws.neon.tech/neondb?sslmode=require
+```
+
+---
+
+We will connect to the Neon database using the Neon serverless driver, wrapped in a Drizzle database instance.
+
+```ts#db.ts
+import { neon } from '@neondatabase/serverless';
+import { drizzle } from 'drizzle-orm/neon-http';
+
+// Bun automatically loads the DATABASE_URL from .env.local
+// Refer to: https://bun.sh/docs/runtime/env for more information
+const sql = neon(process.env.DATABASE_URL!);
+
+export const db = drizzle(sql);
+```
+
+---
+
+To see the database in action, add these lines to `index.ts`.
+
+```ts#index.ts
+import { db } from "./db";
+import { sql } from "drizzle-orm";
+
+const query = sql`select 'hello world' as text`;
+const result = await db.execute(query);
+console.log(result.rows);
+```
+
+---
+
+Then run `index.ts` with Bun. 
+
+```sh
+$ bun run index.ts
+[
+  {
+    text: "hello world",
+  }
+]
+```
+
+---
+
+We can define a schema for our database using Drizzle ORM primitives. Create a `schema.ts` file and add this code. 
+
+```ts#schema.ts
+import { pgTable, integer, serial, text, timestamp } from "drizzle-orm/pg-core";
+
+export const authors = pgTable("authors", {
+  id: serial("id").primaryKey(),
+  name: text("name").notNull(),
+  bio: text("bio"),
+  createdAt: timestamp("created_at").notNull().defaultNow(),
+});
+```
+
+---
+
+We then use the `drizzle-kit` CLI to generate an initial SQL migration.
+
+```sh
+$ bunx drizzle-kit generate --dialect postgresql --schema ./schema.ts --out ./drizzle
+```
+
+---
+
+This creates a new `drizzle` directory containing a `.sql` migration file and `meta` directory.
+
+```txt
+drizzle
+├── 0000_aspiring_post.sql
+└── meta
+    ├── 0000_snapshot.json
+    └── _journal.json
+```
+
+---
+
+We can execute these migrations with a simple `migrate.ts` script. This script creates a new connection to the Neon database and executes all unexecuted migrations in the `drizzle` directory.
+
+```ts#migrate.ts
+import { db } from './db';
+import { migrate } from "drizzle-orm/neon-http/migrator";
+
+const main = async () => {
+  try {
+    await migrate(db, { migrationsFolder: "drizzle" });
+    console.log("Migration completed");
+  } catch (error) {
+    console.error("Error during migration:", error);
+    process.exit(1);
+  }
+};
+
+main();
+```
+
+---
+
+We can run this script with `bun` to execute the migration.
+
+```sh
+$ bun run migrate.ts
+Migration completed
+```
+
+---
+
+We can now add some data to our database. Create a `seed.ts` file with the following contents.
+
+```ts#seed.ts
+import { db } from "./db";
+import * as schema from "./schema";
+
+async function seed() {
+  await db.insert(schema.authors).values([
+    {
+      name: "J.R.R. Tolkien",
+      bio: "The creator of Middle-earth and author of The Lord of the Rings.",
+    },
+    {
+      name: "George R.R. Martin",
+      bio: "The author of the epic fantasy series A Song of Ice and Fire.",
+    },
+    {
+      name: "J.K. Rowling",
+      bio: "The creator of the Harry Potter series.",
+    },
+  ]);
+}
+
+async function main() {
+  try {
+    await seed();
+    console.log("Seeding completed");
+  } catch (error) {
+    console.error("Error during seeding:", error);
+    process.exit(1);
+  }
+}
+
+main();
+```
+
+---
+
+Then run this file.
+
+```sh
+$ bun run seed.ts
+Seeding completed
+```
+
+---
+
+We now have a database with a schema and sample data. We can use Drizzle to query it. Replace the contents of `index.ts` with the following.
+
+```ts#index.ts
+import * as schema from "./schema";
+import { db } from "./db";
+
+const result = await db.select().from(schema.authors);
+console.log(result);
+```
+
+---
+
+Then run the file. You should see the three authors we inserted.
+
+```sh
+$ bun run index.ts
+[
+  {
+    id: 1,
+    name: "J.R.R. Tolkien",
+    bio: "The creator of Middle-earth and author of The Lord of the Rings.",
+    createdAt: 2024-05-11T10:28:46.029Z,
+  }, {
+    id: 2,
+    name: "George R.R. Martin",
+    bio: "The author of the epic fantasy series A Song of Ice and Fire.",
+    createdAt: 2024-05-11T10:28:46.029Z,
+  }, {
+    id: 3,
+    name: "J.K. Rowling",
+    bio: "The creator of the Harry Potter series.",
+    createdAt: 2024-05-11T10:28:46.029Z,
+  }
+]
+```
+
+---
+
+This example used the Neon serverless driver's SQL-over-HTTP functionality. Neon's serverless driver also exposes `Client` and `Pool` constructors to enable sessions, interactive transactions, and node-postgres compatibility. Refer to [Neon's documentation](https://neon.tech/docs/serverless/serverless-driver) for a complete overview. 
+
+Refer to the [Drizzle website](https://orm.drizzle.team/docs/overview) for more documentation on using the Drizzle ORM.

docs/guides/ecosystem/neon-serverless-postgres.md

@@ -20,7 +20,7 @@ $ bun add @neondatabase/serverless
 Create a `.env.local` file and add your [Neon Postgres connection string](https://neon.tech/docs/connect/connect-from-any-app) to it.
 
 ```sh
-DATBASE_URL=postgresql://username:password@ep-adj-noun-guid.us-east-1.aws.neon.tech/neondb?sslmode=require
+DATABASE_URL=postgresql://username:password@ep-adj-noun-guid.us-east-1.aws.neon.tech/neondb?sslmode=require
 ```
 
 ---

docs/guides/ecosystem/render.md

@@ -0,0 +1,79 @@
+---
+name: Deploy a Bun application on Render
+---
+
+[Render](https://render.com/) is a cloud platform that lets you flexibly build, deploy, and scale your apps.
+
+It offers features like auto deploys from GitHub, a global CDN, private networks, automatic HTTPS setup, and managed PostgreSQL and Redis.
+
+Render supports Bun natively. You can deploy Bun apps as web services, background workers, cron jobs, and more.
+
+---
+
+As an example, let's deploy a simple Express HTTP server to Render.
+
+---
+
+Create a new GitHub repo named `myapp`. Git clone it locally.
+
+```bash
+git clone git@github.com:my-github-username/myapp.git
+cd myapp
+```
+
+---
+
+Add the Express library.
+
+```bash
+bun add express
+```
+
+---
+
+Define a simple server with Express:
+
+```ts#app.ts
+import express from "express";
+
+const app = express();
+const port = process.env.PORT || 3001;
+
+app.get("/", (req, res) => {
+  res.send("Hello World!");
+});
+
+app.listen(port, () => {
+  console.log(`Listening on port ${port}...`);
+});
+```
+
+---
+
+Commit your changes and push to GitHub.
+
+```bash
+git add app.ts bun.lockb package.json
+git commit -m "Create simple Express app"
+git push origin main
+```
+
+---
+
+In your [Render Dashboard](https://dashboard.render.com/), click `New` > `Web Service` and connect your `myapp` repo.
+
+---
+
+In the Render UI, provide the following values during web service creation:
+
+|                   |               |
+| ----------------- | ------------- |
+| **Runtime**       | `Node`        |
+| **Build Command** | `bun install` |
+| **Start Command** | `bun app.js`  |
+
+---
+
+That's it! Your web service will be live at its assigned `onrender.com` URL as soon as the build finishes.
+
+You can view the [deploy logs](https://docs.render.com/logging#logs-for-an-individual-deploy-or-job) for details. Refer to [Render's documentation](https://docs.render.com/deploys) for a complete overview of deploying on Render.

docs/guides/ecosystem/sentry.md

@@ -0,0 +1,52 @@
+---
+name: Add Sentry to a Bun app
+---
+
+[Sentry](https://sentry.io) is a developer-first error tracking and performance monitoring platform. Sentry has a first-class SDK for Bun, `@sentry/bun`, that instruments your Bun application to automatically collect error and performance data.
+
+Don't already have an account and Sentry project established? Head over to [sentry.io](https://sentry.io/signup/), then return to this page.
+
+---
+
+To start using Sentry with Bun, first install the Sentry Bun SDK.
+
+```bash
+bun add @sentry/bun
+```
+
+---
+
+Then, initialize the Sentry SDK with your Sentry DSN in your app's entry file. You can find your DSN in your Sentry project settings.
+
+```js
+import * as Sentry from "@sentry/bun";
+
+// Ensure to call this before importing any other modules!
+Sentry.init({
+  dsn: "__SENTRY_DSN__",
+
+  // Add Performance Monitoring by setting tracesSampleRate
+  // We recommend adjusting this value in production
+  tracesSampleRate: 1.0,
+});
+```
+
+---
+
+You can verify that Sentry is working by capturing a test error:
+
+```js
+setTimeout(() => {
+  try {
+    foo();
+  } catch (e) {
+    Sentry.captureException(e);
+  }
+}, 99);
+```
+
+To view and resolve the recorded error, log into [sentry.io](https://sentry.io/) and open your project. Clicking on the error's title will open a page where you can see detailed information and mark it as resolved.
+
+---
+
+To learn more about Sentry and using the Sentry Bun SDK, view the [Sentry documentation](https://docs.sentry.io/platforms/javascript/guides/bun).

docs/guides/ecosystem/solidstart.md

@@ -55,4 +55,4 @@ Open [localhost:3000](http://localhost:3000). Any changes you make to `src/route
 
 ---
 
-Refer to the [SolidStart website](start.solidjs.com/getting-started/what-is-solidstart) for complete framework documentation.
+Refer to the [SolidStart website](https://start.solidjs.com/getting-started/what-is-solidstart) for complete framework documentation.

docs/guides/ecosystem/ssr-react.md

@@ -2,6 +2,15 @@
 name: Server-side render (SSR) a React component
 ---
 
+To get started, install the canary version of `react` & `react-dom`:
+
+```sh
+# Any package manager can be used
+$ bun add react@canary react-dom@canary
+```
+
+---
+
 To render a React component to an HTML stream server-side (SSR):
 
 ```tsx
@@ -39,4 +48,4 @@ Bun.serve({
 
 ---
 
-React `18.3` and later includes an [SSR optimization](https://github.com/facebook/react/pull/25597) that takes advantage of Bun's "direct" `ReadableStream` implementation.
+React `19` and later includes an [SSR optimization](https://github.com/facebook/react/pull/25597) that takes advantage of Bun's "direct" `ReadableStream` implementation. If you run into an error like `export named 'renderToReadableStream' not found`, please make sure to install the canary version of `react` & `react-dom`, or import from `react-dom/server.browser` instead of `react-dom/server`. See [facebook/react#28941](https://github.com/facebook/react/issues/28941) for more information.

docs/guides/http/cluster.md

@@ -0,0 +1,66 @@
+---
+name: Start a cluster of HTTP servers
+description: Run multiple HTTP servers concurrently via the "reusePort" option to share the same port across multiple processes
+---
+
+To run multiple HTTP servers concurrently, use the `reusePort` option in `Bun.serve()` which shares the same port across multiple processes.
+
+This automatically load balances incoming requests across multiple instances of Bun.
+
+```ts#server.ts
+import { serve } from "bun";
+
+const id = = Math.random().toString(36).slice(2);
+
+serve({
+  port: process.env.PORT || 8080,
+  development: false,
+
+  // Share the same port across multiple processes
+  // This is the important part!
+  reusePort: true,
+
+  async fetch(request) {
+    return new Response("Hello from Bun #" + id + "!\n");
+  }
+});
+```
+
+---
+
+{% callout %}
+**Linux only** — Windows and macOS ignore the `reusePort` option. This is an operating system limitation with `SO_REUSEPORT`, unfortunately.
+{% /callout %}
+
+After saving the file, start your servers on the same port.
+
+Under the hood, this uses the Linux `SO_REUSEPORT` and `SO_REUSEADDR` socket options to ensure fair load balancing across multiple processes. [Learn more about `SO_REUSEPORT` and `SO_REUSEADDR`](https://lwn.net/Articles/542629/)
+
+```ts#cluster.ts
+import { spawn } from "bun";
+
+const cpus = navigator.hardwareConcurrency; // Number of CPU cores
+const buns = new Array(cpus);
+
+for (let i = 0; i < cpus; i++) {
+  buns[i] = spawn({
+    cmd: ["bun", "./server.ts"],
+    stdout: "inherit",
+    stderr: "inherit",
+    stdin: "inherit",
+  });
+}
+
+function kill() {
+  for (const bun of buns) {
+    bun.kill();
+  }
+}
+
+process.on("SIGINT", kill);
+process.on("exit", kill);
+```
+
+---
+
+At the time of writing, Bun hasn't implemented the `node:cluster` module yet, but this is a faster, simple, and limited alternative. We will also implement `node:cluster` in the future.

docs/guides/http/proxy.md

@@ -0,0 +1,24 @@
+---
+name: Proxy HTTP requests using fetch()
+---
+
+In Bun, `fetch` supports sending requests through an HTTP or HTTPS proxy. This is useful on corporate networks or when you need to ensure a request is sent through a specific IP address.
+
+```ts
+await fetch("https://example.com", {
+  // The URL of the proxy server
+  proxy: "https://username:password@proxy.example.com:8080",
+});
+```
+
+---
+
+The `proxy` option is a URL string that specifies the proxy server. It can include the username and password if the proxy requires authentication. It can be `http://` or `https://`.
+
+---
+
+You can also set the `$HTTP_PROXY` or `$HTTPS_PROXY` environment variable to the proxy URL. This is useful when you want to use the same proxy for all requests.
+
+```sh
+HTTPS_PROXY=https://username:password@proxy.example.com:8080 bun run index.ts
+```

docs/guides/http/server.md

@@ -18,7 +18,7 @@ const server = Bun.serve({
     if (path === "/abc") return Response.redirect("/source", 301);
 
     // send back a file (in this case, *this* file)
-    if (path === "/source") return new Response(Bun.file(import.meta.file));
+    if (path === "/source") return new Response(Bun.file(import.meta.path));
 
     // respond with JSON
     if (path === "/api") return Response.json({ some: "buns", for: "you" });

docs/guides/install/azure-artifacts.md

@@ -26,7 +26,7 @@ password = "$NPM_PASSWORD"
 
 ---
 
-Then assign your Azure Personal Access Token to the the `NPM_PASSWORD` environment variable. Bun [automatically reads](/docs/runtime/env) `.env` files, so create a file called `.env` in your project root. There is no need to base-64 encode this token! Bun will do this for you.
+Then assign your Azure Personal Access Token to the `NPM_PASSWORD` environment variable. Bun [automatically reads](/docs/runtime/env) `.env` files, so create a file called `.env` in your project root. There is no need to base-64 encode this token! Bun will do this for you.
 
 ```txt#.env
 NPM_PASSWORD=<paste token here>

docs/guides/install/git-diff-bun-lockfile.md

@@ -0,0 +1,38 @@
+---
+name: Configure git to diff Bun's lockb lockfile
+---
+
+To teach `git` how to generate a human-readable diff of Bun's binary lockfile format (`.lockb`), add the following to your local or global `.gitattributes` file:
+
+```js
+*.lockb binary diff=lockb
+```
+
+---
+
+Then add the following to you local git config with:
+
+```sh
+$ git config diff.lockb.textconv bun
+$ git config diff.lockb.binary true
+```
+
+---
+
+To globally configure git to diff Bun's lockfile, add the following to your global git config with:
+
+```sh
+$ git config --global diff.lockb.textconv bun
+$ git config --global diff.lockb.binary true
+```
+
+---
+
+## How this works
+
+Why this works:
+
+- `textconv` tells git to run bun on the file before diffing
+- `binary` tells git to treat the file as binary (so it doesn't try to diff it line-by-line)
+
+In Bun, you can execute Bun's lockfile (`bun ./bun.lockb`) to generate a human-readable version of the lockfile and `git diff` can then use that to generate a human-readable diff.

docs/guides/install/trusted.md

@@ -19,7 +19,9 @@ If you are seeing one of the following errors, you are probably trying to use a
 
 To tell Bun to allow lifecycle scripts for a particular package, add the package to `trustedDependencies` in your package.json.
 
+{% callout %}
 Note that this only allows lifecycle scripts for the specific package listed in `trustedDependencies`, _not_ the dependencies of that dependency!
+{% /callout %}
 
 <!-- Bun maintains an allow-list of popular packages containing `postinstall` scripts that are known to be safe. To run lifecycle scripts for packages that aren't on this list, add the package to `trustedDependencies` in your package.json. -->
 
@@ -43,8 +45,4 @@ $ bun install
 
 ---
 
-Note that this only allows lifecycle scripts for the specific package listed in `trustedDependencies`, _not_ the dependencies of that dependency!
-
----
-
 See [Docs > Package manager > Trusted dependencies](/docs/install/lifecycle) for complete documentation of trusted dependencies.

docs/guides/process/argv.md

@@ -13,7 +13,7 @@ console.log(Bun.argv);
 Running this file with arguments results in the following:
 
 ```sh
-$ bun run cli.tsx --flag1 --flag2 value
+$ bun run cli.ts --flag1 --flag2 value
 [ '/path/to/bun', '/path/to/cli.ts', '--flag1', '--flag2', 'value' ]
 ```
 
@@ -47,7 +47,7 @@ console.log(positionals);
 then it outputs
 
 ```
-$ bun run cli.tsx --flag1 --flag2 value
+$ bun run cli.ts --flag1 --flag2 value
 {
   flag1: true,
   flag2: "value",

docs/guides/process/spawn.md

@@ -16,7 +16,7 @@ await proc.exited;
 The second argument accepts a configuration object.
 
 ```ts
-const proc = Bun.spawn("echo", ["Hello, world!"], {
+const proc = Bun.spawn(["echo", "Hello, world!"], {
   cwd: "/tmp",
   env: { FOO: "bar" },
   onExit(proc, exitCode, signalCode, error) {

docs/guides/read-file/arraybuffer.md

@@ -13,11 +13,11 @@ const buffer = await file.arrayBuffer();
 
 ---
 
-The binary content in the `ArrayBuffer` can then be read as a typed array, such as `Uint8Array`.
+The binary content in the `ArrayBuffer` can then be read as a typed array, such as `Int8Array`. For `Uint8Array`, use [`.bytes()`](./uint8array).
 
 ```ts
 const buffer = await file.arrayBuffer();
-const bytes = new Uint8Array(buffer);
+const bytes = new Int8Array(buffer);
 
 bytes[0];
 bytes.length;

docs/guides/read-file/uint8array.md

@@ -4,14 +4,13 @@ name: Read a file to a Uint8Array
 
 The `Bun.file()` function accepts a path and returns a `BunFile` instance. The `BunFile` class extends `Blob` and allows you to lazily read the file in a variety of formats.
 
-To read the file into a `Uint8Array` instance, retrieve the contents of the `BunFile` as an `ArrayBuffer` with `.arrayBuffer()`, then pass it into the `Uint8Array` constructor.
+To read the file into a `Uint8Array` instance, retrieve the contents of the `BunFile` with `.bytes()`.
 
 ```ts
 const path = "/path/to/package.json";
 const file = Bun.file(path);
 
-const arrBuffer = await file.arrayBuffer();
-const byteArray = new Uint8Array(arrBuffer);
+const byteArray = await file.bytes();
 
 byteArray[0]; // first byteArray
 byteArray.length; // length of byteArray

docs/guides/runtime/cicd.md

@@ -13,7 +13,7 @@ jobs:
     steps:
       # ...
       - uses: actions/checkout@v4
-+     - uses: oven-sh/setup-bun@v1
++     - uses: oven-sh/setup-bun@v2
 
       # run any `bun` or `bunx` command
 +     - run: bun install
@@ -33,7 +33,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       # ...
-      - uses: oven-sh/setup-bun@v1
+      - uses: oven-sh/setup-bun@v2
 +       with:
 +         bun-version: 1.0.11 # or "latest", "canary", <sha>
 ```

docs/guides/runtime/define-constant.md

@@ -0,0 +1,145 @@
+---
+name: Define and replace static globals & constants
+---
+
+The `--define` flag lets you declare statically-analyzable constants and globals. It replace all usages of an identifier or property in a JavaScript or TypeScript file with a constant value. This feature is supported at runtime and also in `bun build`. This is sort of similar to `#define` in C/C++, except for JavaScript.
+
+```ts
+bun --define:process.env.NODE_ENV="'production'" src/index.ts # Runtime
+bun build --define:process.env.NODE_ENV="'production'" src/index.ts # Build
+```
+
+---
+
+These statically-known values are used by Bun for dead code elimination and other optimizations.
+
+```ts
+if (process.env.NODE_ENV === "production") {
+  console.log("Production mode");
+} else {
+  console.log("Development mode");
+}
+```
+
+---
+
+Before the code reaches the JavaScript engine, Bun replaces `process.env.NODE_ENV` with `"production"`.
+
+```ts
+if ("production" === "production") {
+  console.log("Production mode");
+} else {
+  console.log("Development mode");
+}
+```
+
+---
+
+It doesn't stop there. Bun's optimizing transpiler is smart enough to do some basic constant folding.
+
+Since `"production" === "production"` is always `true`, Bun replaces the entire expression with the `true` value.
+
+```ts
+if (true) {
+  console.log("Production mode");
+} else {
+  console.log("Development mode");
+}
+```
+
+---
+
+And finally, Bun detects the `else` branch is not reachable, and eliminates it.
+
+```ts
+console.log("Production mode");
+```
+
+---
+
+## What types of values are supported?
+
+Values can be strings, identifiers, properties, or JSON.
+
+### Replace global identifiers
+
+To make all usages of `window` be `undefined`, you can use the following command.
+
+```sh
+bun --define window="undefined" src/index.ts
+```
+
+This can be useful when Server-Side Rendering (SSR) or when you want to make sure that the code doesn't depend on the `window` object.
+
+```js
+if (typeof window !== "undefined") {
+  console.log("Client-side code");
+} else {
+  console.log("Server-side code");
+}
+```
+
+You can also set the value to be another identifier. For example, to make all usages of `global` be `globalThis`, you can use the following command.
+
+```sh
+bun --define global="globalThis" src/index.ts
+```
+
+`global` is a global object in Node.js, but not in web browsers. So, you can use this to fix some cases where the code assumes that `global` is available.
+
+### Replace values with JSON
+
+`--define` can also be used to replace values with JSON objects and arrays.
+
+To replace all usages of `AWS` with the JSON object `{"ACCESS_KEY":"abc","SECRET_KEY":"def"}`, you can use the following command.
+
+```sh
+# JSON
+bun --define:AWS='{"ACCESS_KEY":"abc","SECRET_KEY":"def"}' src/index.ts
+```
+
+Those will be transformed into the equivalent JavaScript code.
+
+From:
+
+```ts
+console.log(AWS.ACCESS_KEY); // => "abc"
+```
+
+To:
+
+```ts
+console.log("abc");
+```
+
+### Replace values with other properties
+
+You can also pass properties to the `--define` flag.
+
+For example, to replace all usages of `console.write` with `console.log`, you can use the following command (requires Bun v1.1.5 or later)
+
+```sh
+bun --define:console.write=console.log src/index.ts
+```
+
+That transforms the following input:
+
+```ts
+console.write("Hello, world!");
+```
+
+Into the following output:
+
+```ts
+console.log("Hello, world!");
+```
+
+## How is this different than setting a variable?
+
+You can also set `process.env.NODE_ENV` to `"production"` in your code, but that won't help with dead code elimination. In JavaScript, property accesses can have side effects. Getters & setters can be functions, and even dynamically defined (due to prototype chains and Proxy). Even if you set `process.env.NODE_ENV` to `"production"`, on the next line, it is not safe for static analysis tools to assume that `process.env.NODE_ENV`is`"production"`.
+
+## How is this different than find-and-replace or string replacement?
+
+The `--define` flag operates on the AST (Abstract Syntax Tree) level, not on the text level. It happens during the transpilation process, which means it can be used in optimizations like dead code elimination.
+
+String replacement tools tend to have escaping issues and replace unintended parts of the code.