print better errors on bytecode generation error

### What does this PR do?

Fixes #22425
Fixes #22431

### How did you verify your code works?

bun-types integration test

.buildkite/Dockerfile

@@ -0,0 +1,164 @@
+ARG LLVM_VERSION="19"
+ARG REPORTED_LLVM_VERSION="19.1.7"
+ARG OLD_BUN_VERSION="1.1.38"
+ARG BUILDKITE_AGENT_TAGS="queue=linux,os=linux,arch=${TARGETARCH}"
+
+FROM --platform=$BUILDPLATFORM ubuntu:20.04 as base-arm64
+FROM --platform=$BUILDPLATFORM ubuntu:20.04 as base-amd64
+FROM base-$TARGETARCH as base
+
+ARG LLVM_VERSION
+ARG OLD_BUN_VERSION
+ARG TARGETARCH
+ARG REPORTED_LLVM_VERSION
+
+ENV DEBIAN_FRONTEND=noninteractive \
+   CI=true \
+   DOCKER=true
+
+RUN echo "Acquire::Queue-Mode \"host\";" > /etc/apt/apt.conf.d/99-apt-queue-mode.conf \
+    && echo "Acquire::Timeout \"120\";" >> /etc/apt/apt.conf.d/99-apt-timeout.conf \
+    && echo "Acquire::Retries \"3\";" >> /etc/apt/apt.conf.d/99-apt-retries.conf \
+    && echo "APT::Install-Recommends \"false\";" >> /etc/apt/apt.conf.d/99-apt-install-recommends.conf \
+    && echo "APT::Install-Suggests \"false\";" >> /etc/apt/apt.conf.d/99-apt-install-suggests.conf
+
+RUN apt-get update && apt-get install -y --no-install-recommends \
+   wget curl git python3 python3-pip ninja-build \
+   software-properties-common apt-transport-https \
+   ca-certificates gnupg lsb-release unzip \
+   libxml2-dev ruby ruby-dev bison gawk perl make golang \
+   && add-apt-repository ppa:ubuntu-toolchain-r/test \
+   && apt-get update \
+   && apt-get install -y gcc-13 g++-13 libgcc-13-dev libstdc++-13-dev \
+       libasan6 libubsan1 libatomic1 libtsan0 liblsan0 \
+       libgfortran5 libc6-dev \
+   && wget https://apt.llvm.org/llvm.sh \
+   && chmod +x llvm.sh \
+   && ./llvm.sh ${LLVM_VERSION} all \
+   && rm llvm.sh
+
+
+RUN --mount=type=tmpfs,target=/tmp \
+    cmake_version="3.30.5" && \
+    if [ "$TARGETARCH" = "arm64" ]; then \
+        cmake_url="https://github.com/Kitware/CMake/releases/download/v${cmake_version}/cmake-${cmake_version}-linux-aarch64.sh"; \
+    else \
+        cmake_url="https://github.com/Kitware/CMake/releases/download/v${cmake_version}/cmake-${cmake_version}-linux-x86_64.sh"; \
+    fi && \
+    wget -O /tmp/cmake.sh "$cmake_url" && \
+    sh /tmp/cmake.sh --skip-license --prefix=/usr
+
+RUN update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-13 130 \
+   --slave /usr/bin/g++ g++ /usr/bin/g++-13 \
+   --slave /usr/bin/gcc-ar gcc-ar /usr/bin/gcc-ar-13 \
+   --slave /usr/bin/gcc-nm gcc-nm /usr/bin/gcc-nm-13 \
+   --slave /usr/bin/gcc-ranlib gcc-ranlib /usr/bin/gcc-ranlib-13
+
+RUN echo "ARCH_PATH=$([ "$TARGETARCH" = "arm64" ] && echo "aarch64-linux-gnu" || echo "x86_64-linux-gnu")" >> /etc/environment \
+   && echo "BUN_ARCH=$([ "$TARGETARCH" = "arm64" ] && echo "aarch64" || echo "x64")" >> /etc/environment
+
+ENV LD_LIBRARY_PATH=/usr/lib/gcc/${ARCH_PATH}/13:/usr/lib/${ARCH_PATH} \
+   LIBRARY_PATH=/usr/lib/gcc/${ARCH_PATH}/13:/usr/lib/${ARCH_PATH} \
+   CPLUS_INCLUDE_PATH=/usr/include/c++/13:/usr/include/${ARCH_PATH}/c++/13 \
+   C_INCLUDE_PATH=/usr/lib/gcc/${ARCH_PATH}/13/include
+
+RUN if [ "$TARGETARCH" = "arm64" ]; then \
+       export ARCH_PATH="aarch64-linux-gnu"; \
+   else \
+       export ARCH_PATH="x86_64-linux-gnu"; \
+   fi \
+   && mkdir -p /usr/lib/gcc/${ARCH_PATH}/13 \
+   && ln -sf /usr/lib/${ARCH_PATH}/libstdc++.so.6 /usr/lib/gcc/${ARCH_PATH}/13/ \
+   && echo "/usr/lib/gcc/${ARCH_PATH}/13" > /etc/ld.so.conf.d/gcc-13.conf \
+   && echo "/usr/lib/${ARCH_PATH}" >> /etc/ld.so.conf.d/gcc-13.conf \
+   && ldconfig
+
+RUN 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/clang /usr/bin/cc \
+   && ln -sf /usr/bin/clang++ /usr/bin/c++
+
+ENV CC="clang" \
+   CXX="clang++" \
+   AR="llvm-ar-${LLVM_VERSION}" \
+   RANLIB="llvm-ranlib-${LLVM_VERSION}" \
+   LD="lld-${LLVM_VERSION}"
+
+RUN --mount=type=tmpfs,target=/tmp \
+   bash -c '\
+      set -euxo pipefail && \
+      source /etc/environment && \
+      echo "Downloading bun-v${OLD_BUN_VERSION}/bun-linux-$BUN_ARCH.zip from https://pub-5e11e972747a44bf9aaf9394f185a982.r2.dev/releases/bun-v${OLD_BUN_VERSION}/bun-linux-$BUN_ARCH.zip" && \
+      curl -fsSL https://pub-5e11e972747a44bf9aaf9394f185a982.r2.dev/releases/bun-v${OLD_BUN_VERSION}/bun-linux-$BUN_ARCH.zip -o /tmp/bun.zip && \
+      unzip /tmp/bun.zip -d /tmp/bun && \
+      mv /tmp/bun/*/bun /usr/bin/bun && \
+      chmod +x /usr/bin/bun'
+
+ENV LLVM_VERSION=${REPORTED_LLVM_VERSION}
+
+WORKDIR /workspace
+
+
+FROM --platform=$BUILDPLATFORM base as buildkite
+ARG BUILDKITE_AGENT_TAGS
+
+
+# Install Rust nightly
+RUN curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y \ 
+    && export PATH=$HOME/.cargo/bin:$PATH \
+    && rustup install nightly \
+    && rustup default nightly
+
+
+RUN ARCH=$(if [ "$TARGETARCH" = "arm64" ]; then echo "arm64"; else echo "amd64"; fi) && \
+    echo "Downloading buildkite" && \ 
+    curl -fsSL "https://github.com/buildkite/agent/releases/download/v3.87.0/buildkite-agent-linux-${ARCH}-3.87.0.tar.gz" -o /tmp/buildkite-agent.tar.gz && \
+    mkdir -p /tmp/buildkite-agent && \
+    tar -xzf /tmp/buildkite-agent.tar.gz -C /tmp/buildkite-agent && \
+    mv /tmp/buildkite-agent/buildkite-agent /usr/bin/buildkite-agent
+
+RUN mkdir -p /var/cache/buildkite-agent /var/log/buildkite-agent /var/run/buildkite-agent /etc/buildkite-agent /var/lib/buildkite-agent/cache/bun
+
+COPY  ../*/agent.mjs /var/bun/scripts/
+
+ENV BUN_INSTALL_CACHE=/var/lib/buildkite-agent/cache/bun
+ENV BUILDKITE_AGENT_TAGS=${BUILDKITE_AGENT_TAGS}
+
+
+WORKDIR /var/bun/scripts
+
+ENV PATH=/root/.cargo/bin:$PATH
+
+
+CMD ["bun", "/var/bun/scripts/agent.mjs", "start"]
+
+FROM --platform=$BUILDPLATFORM base as bun-build-linux-local
+
+ARG LLVM_VERSION
+WORKDIR /workspace/bun
+
+COPY . /workspace/bun
+
+
+# Install Rust nightly
+RUN curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y \ 
+    && export PATH=$HOME/.cargo/bin:$PATH \
+    && rustup install nightly \
+    && rustup default nightly
+
+ENV PATH=/root/.cargo/bin:$PATH
+
+ENV LLVM_VERSION=${REPORTED_LLVM_VERSION}
+
+
+RUN --mount=type=tmpfs,target=/workspace/bun/build \
+    ls -la \
+    && bun run build:release \
+    && mkdir -p /target \
+    && cp -r /workspace/bun/build/release/bun /target/bun

.buildkite/Dockerfile-bootstrap.sh

@@ -0,0 +1,122 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# Check if running as root
+if [ "$EUID" -ne 0 ]; then
+    echo "error: must run as root"
+    exit 1
+fi
+
+# Check OS compatibility
+if ! command -v dnf &> /dev/null; then
+    echo "error: this script requires dnf (RHEL/Fedora/CentOS)"
+    exit 1
+fi
+
+# Ensure /tmp/agent.mjs, /tmp/Dockerfile are present
+if [ ! -f /tmp/agent.mjs ] || [ ! -f /tmp/Dockerfile ]; then
+    # Print each missing file
+    if [ ! -f /tmp/agent.mjs ]; then
+        echo "error: /tmp/agent.mjs is missing"
+    fi
+    if [ ! -f /tmp/Dockerfile ]; then
+        echo "error: /tmp/Dockerfile is missing"
+    fi
+    exit 1
+fi
+
+# Install Docker
+dnf update -y
+dnf install -y docker
+
+systemctl enable docker
+systemctl start docker || {
+    echo "error: failed to start Docker"
+    exit 1
+}
+
+# Create builder
+docker buildx create --name builder --driver docker-container --bootstrap --use || {
+    echo "error: failed to create Docker buildx builder"
+    exit 1
+}
+
+# Set up Docker to start on boot
+cat << 'EOF' > /etc/systemd/system/buildkite-agent.service
+[Unit]
+Description=Buildkite Docker Container
+After=docker.service network-online.target
+Requires=docker.service network-online.target
+
+[Service]
+TimeoutStartSec=0
+Restart=always
+RestartSec=5
+ExecStartPre=-/usr/bin/docker stop buildkite
+ExecStartPre=-/usr/bin/docker rm buildkite
+ExecStart=/usr/bin/docker run \
+    --name buildkite \
+    --restart=unless-stopped \
+    --network host \
+    -v /var/run/docker.sock:/var/run/docker.sock \
+    -v /tmp:/tmp \
+    buildkite:latest
+
+[Install]
+WantedBy=multi-user.target
+EOF
+
+echo "Building Buildkite image"
+
+# Clean up any previous build artifacts
+rm -rf /tmp/fakebun
+mkdir -p /tmp/fakebun/scripts /tmp/fakebun/.buildkite
+
+# Copy required files
+cp /tmp/agent.mjs /tmp/fakebun/scripts/ || {
+    echo "error: failed to copy agent.mjs"
+    exit 1
+}
+cp /tmp/Dockerfile /tmp/fakebun/.buildkite/Dockerfile || {
+    echo "error: failed to copy Dockerfile"
+    exit 1
+}
+
+cd /tmp/fakebun || {
+    echo "error: failed to change directory"
+    exit 1
+}
+
+# Build the Buildkite image
+docker buildx build \
+    --platform $(uname -m | sed 's/aarch64/linux\/arm64/;s/x86_64/linux\/amd64/') \
+    --tag buildkite:latest \
+    --target buildkite \
+    -f .buildkite/Dockerfile \
+    --load \
+    . || {
+    echo "error: Docker build failed"
+    exit 1
+}
+
+# Create container to ensure image is cached in AMI
+docker container create \
+    --name buildkite \
+    --restart=unless-stopped \
+    buildkite:latest || {
+    echo "error: failed to create buildkite container"
+    exit 1
+}
+
+# Reload systemd to pick up new service
+systemctl daemon-reload
+
+# Enable the service, but don't start it yet
+systemctl enable buildkite-agent || {
+    echo "error: failed to enable buildkite-agent service"
+    exit 1
+}
+
+echo "Bootstrap complete"
+echo "To start the Buildkite agent, run: "
+echo "  systemctl start buildkite-agent"

.buildkite/bootstrap.yml

@@ -0,0 +1,16 @@
+# 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:"
+    agents:
+      queue: "build-darwin"
+    command:
+      - "node .buildkite/ci.mjs"

.buildkite/scripts/sign-windows.ps1

@@ -0,0 +1,464 @@
+# Windows Code Signing Script for Bun
+# Uses DigiCert KeyLocker for Authenticode signing
+# Native PowerShell implementation - no path translation issues
+
+param(
+    [Parameter(Mandatory=$true)]
+    [string]$BunProfileExe,
+    
+    [Parameter(Mandatory=$true)]
+    [string]$BunExe
+)
+
+$ErrorActionPreference = "Stop"
+$ProgressPreference = "SilentlyContinue"
+
+# Logging functions
+function Log-Info {
+    param([string]$Message)
+    Write-Host "[INFO] $Message" -ForegroundColor Cyan
+}
+
+function Log-Success {
+    param([string]$Message)
+    Write-Host "[SUCCESS] $Message" -ForegroundColor Green
+}
+
+function Log-Error {
+    param([string]$Message)
+    Write-Host "[ERROR] $Message" -ForegroundColor Red
+}
+
+function Log-Debug {
+    param([string]$Message)
+    if ($env:DEBUG -eq "true" -or $env:DEBUG -eq "1") {
+        Write-Host "[DEBUG] $Message" -ForegroundColor Gray
+    }
+}
+
+# Load Visual Studio environment if not already loaded
+function Ensure-VSEnvironment {
+    if ($null -eq $env:VSINSTALLDIR) {
+        Log-Info "Loading Visual Studio environment..."
+        
+        $vswhere = "C:\Program Files (x86)\Microsoft Visual Studio\Installer\vswhere.exe"
+        if (!(Test-Path $vswhere)) {
+            throw "Command not found: vswhere (did you install Visual Studio?)"
+        }
+        
+        $vsDir = & $vswhere -prerelease -latest -property installationPath
+        if ($null -eq $vsDir) {
+            $vsDir = Get-ChildItem -Path "C:\Program Files\Microsoft Visual Studio\2022" -Directory -ErrorAction SilentlyContinue
+            if ($null -eq $vsDir) {
+                throw "Visual Studio directory not found."
+            }
+            $vsDir = $vsDir.FullName
+        }
+        
+        Push-Location $vsDir
+        try {
+            $vsShell = Join-Path -Path $vsDir -ChildPath "Common7\Tools\Launch-VsDevShell.ps1"
+            . $vsShell -Arch amd64 -HostArch amd64
+        } finally {
+            Pop-Location
+        }
+        
+        Log-Success "Visual Studio environment loaded"
+    }
+    
+    if ($env:VSCMD_ARG_TGT_ARCH -eq "x86") {
+        throw "Visual Studio environment is targeting 32 bit, but only 64 bit is supported."
+    }
+}
+
+# Check for required environment variables
+function Check-Environment {
+    Log-Info "Checking environment variables..."
+    
+    $required = @{
+        "SM_API_KEY" = $env:SM_API_KEY
+        "SM_CLIENT_CERT_PASSWORD" = $env:SM_CLIENT_CERT_PASSWORD
+        "SM_KEYPAIR_ALIAS" = $env:SM_KEYPAIR_ALIAS
+        "SM_HOST" = $env:SM_HOST
+        "SM_CLIENT_CERT_FILE" = $env:SM_CLIENT_CERT_FILE
+    }
+    
+    $missing = @()
+    foreach ($key in $required.Keys) {
+        if ([string]::IsNullOrEmpty($required[$key])) {
+            $missing += $key
+        } else {
+            Log-Debug "$key is set (length: $($required[$key].Length))"
+        }
+    }
+    
+    if ($missing.Count -gt 0) {
+        throw "Missing required environment variables: $($missing -join ', ')"
+    }
+    
+    Log-Success "All required environment variables are present"
+}
+
+# Setup certificate file
+function Setup-Certificate {
+    Log-Info "Setting up certificate..."
+    
+    # Always try to decode as base64 first
+    # If it fails, then treat as file path
+    try {
+        Log-Info "Attempting to decode certificate as base64..."
+        Log-Debug "Input string length: $($env:SM_CLIENT_CERT_FILE.Length) characters"
+        
+        $tempCertPath = Join-Path $env:TEMP "digicert_cert_$(Get-Random).p12"
+        
+        # Try to decode as base64
+        $certBytes = [System.Convert]::FromBase64String($env:SM_CLIENT_CERT_FILE)
+        [System.IO.File]::WriteAllBytes($tempCertPath, $certBytes)
+        
+        # Validate the decoded certificate size
+        $fileSize = (Get-Item $tempCertPath).Length
+        if ($fileSize -lt 100) {
+            throw "Decoded certificate too small: $fileSize bytes (expected >100 bytes)"
+        }
+        
+        # Update environment to point to file
+        $env:SM_CLIENT_CERT_FILE = $tempCertPath
+        
+        Log-Success "Certificate decoded and written to: $tempCertPath"
+        Log-Debug "Decoded certificate file size: $fileSize bytes"
+        
+        # Register cleanup
+        $global:TEMP_CERT_PATH = $tempCertPath
+        
+    } catch {
+        # If base64 decode fails, check if it's a file path
+        Log-Info "Base64 decode failed, checking if it's a file path..."
+        Log-Debug "Decode error: $_"
+        
+        if (Test-Path $env:SM_CLIENT_CERT_FILE) {
+            $fileSize = (Get-Item $env:SM_CLIENT_CERT_FILE).Length
+            
+            # Validate file size
+            if ($fileSize -lt 100) {
+                throw "Certificate file too small: $fileSize bytes at $env:SM_CLIENT_CERT_FILE (possibly corrupted)"
+            }
+            
+            Log-Info "Using certificate file: $env:SM_CLIENT_CERT_FILE"
+            Log-Debug "Certificate file size: $fileSize bytes"
+        } else {
+            throw "SM_CLIENT_CERT_FILE is neither valid base64 nor an existing file: $env:SM_CLIENT_CERT_FILE"
+        }
+    }
+}
+
+# Install DigiCert KeyLocker tools
+function Install-KeyLocker {
+    Log-Info "Setting up DigiCert KeyLocker tools..."
+    
+    # Define our controlled installation directory
+    $installDir = "C:\BuildTools\DigiCert"
+    $smctlPath = Join-Path $installDir "smctl.exe"
+    
+    # Check if already installed in our controlled location
+    if (Test-Path $smctlPath) {
+        Log-Success "KeyLocker tools already installed at: $smctlPath"
+        
+        # Add to PATH if not already there
+        if ($env:PATH -notlike "*$installDir*") {
+            $env:PATH = "$installDir;$env:PATH"
+            Log-Info "Added to PATH: $installDir"
+        }
+        
+        return $smctlPath
+    }
+    
+    Log-Info "Installing KeyLocker tools to: $installDir"
+    
+    # Create the installation directory if it doesn't exist
+    if (!(Test-Path $installDir)) {
+        Log-Info "Creating installation directory: $installDir"
+        try {
+            New-Item -ItemType Directory -Path $installDir -Force | Out-Null
+            Log-Success "Created directory: $installDir"
+        } catch {
+            throw "Failed to create directory $installDir : $_"
+        }
+    }
+    
+    # Download MSI installer
+    $msiUrl = "https://bun-ci-assets.bun.sh/Keylockertools-windows-x64.msi"
+    $msiPath = Join-Path $env:TEMP "Keylockertools-windows-x64.msi"
+    
+    Log-Info "Downloading MSI from: $msiUrl"
+    Log-Info "Downloading to: $msiPath"
+    
+    try {
+        # Remove existing MSI if present
+        if (Test-Path $msiPath) {
+            Remove-Item $msiPath -Force
+            Log-Debug "Removed existing MSI file"
+        }
+        
+        # Download with progress tracking
+        $webClient = New-Object System.Net.WebClient
+        $webClient.DownloadFile($msiUrl, $msiPath)
+        
+        if (!(Test-Path $msiPath)) {
+            throw "MSI download failed - file not found"
+        }
+        
+        $fileSize = (Get-Item $msiPath).Length
+        Log-Success "MSI downloaded successfully (size: $fileSize bytes)"
+        
+    } catch {
+        throw "Failed to download MSI: $_"
+    }
+    
+    # Install MSI
+    Log-Info "Installing MSI..."
+    Log-Debug "MSI path: $msiPath"
+    Log-Debug "File exists: $(Test-Path $msiPath)"
+    Log-Debug "File size: $((Get-Item $msiPath).Length) bytes"
+    
+    # Check if running as administrator
+    $isAdmin = ([Security.Principal.WindowsPrincipal][Security.Principal.WindowsIdentity]::GetCurrent()).IsInRole([Security.Principal.WindowsBuiltInRole]::Administrator)
+    Log-Info "Running as administrator: $isAdmin"
+    
+    # Install MSI silently to our controlled directory
+    $arguments = @(
+        "/i", "`"$msiPath`"",
+        "/quiet",
+        "/norestart",
+        "TARGETDIR=`"$installDir`"",
+        "INSTALLDIR=`"$installDir`"",
+        "ACCEPT_EULA=1",
+        "ADDLOCAL=ALL"
+    )
+    
+    Log-Debug "Running: msiexec.exe $($arguments -join ' ')"
+    Log-Info "Installing to: $installDir"
+    
+    $process = Start-Process -FilePath "msiexec.exe" -ArgumentList $arguments -Wait -PassThru -NoNewWindow
+    
+    if ($process.ExitCode -ne 0) {
+        Log-Error "MSI installation failed with exit code: $($process.ExitCode)"
+        
+        # Try to get error details from event log
+        try {
+            $events = Get-WinEvent -LogName "Application" -MaxEvents 10 | 
+                Where-Object { $_.ProviderName -eq "MsiInstaller" -and $_.TimeCreated -gt (Get-Date).AddMinutes(-1) }
+            
+            foreach ($event in $events) {
+                Log-Debug "MSI Event: $($event.Message)"
+            }
+        } catch {
+            Log-Debug "Could not retrieve MSI installation events"
+        }
+        
+        throw "MSI installation failed with exit code: $($process.ExitCode)"
+    }
+    
+    Log-Success "MSI installation completed"
+    
+    # Wait for installation to complete
+    Start-Sleep -Seconds 2
+    
+    # Verify smctl.exe exists in our controlled location
+    if (Test-Path $smctlPath) {
+        Log-Success "KeyLocker tools installed successfully at: $smctlPath"
+        
+        # Add to PATH
+        $env:PATH = "$installDir;$env:PATH"
+        Log-Info "Added to PATH: $installDir"
+        
+        return $smctlPath
+    }
+    
+    # If not in our expected location, check if it installed somewhere in the directory
+    $found = Get-ChildItem -Path $installDir -Filter "smctl.exe" -Recurse -ErrorAction SilentlyContinue | 
+        Select-Object -First 1
+    
+    if ($found) {
+        Log-Success "Found smctl.exe at: $($found.FullName)"
+        $smctlDir = $found.DirectoryName
+        $env:PATH = "$smctlDir;$env:PATH"
+        return $found.FullName
+    }
+    
+    throw "KeyLocker tools installation succeeded but smctl.exe not found in $installDir"
+}
+
+# Configure KeyLocker
+function Configure-KeyLocker {
+    param([string]$SmctlPath)
+    
+    Log-Info "Configuring KeyLocker..."
+    
+    # Verify smctl is accessible
+    try {
+        $version = & $SmctlPath --version 2>&1
+        Log-Debug "smctl version: $version"
+    } catch {
+        throw "Failed to run smctl: $_"
+    }
+    
+    # Configure KeyLocker credentials and environment
+    Log-Info "Configuring KeyLocker credentials..."
+    
+    try {
+        # Save credentials (API key and password)
+        Log-Info "Saving credentials to OS store..."
+        $saveOutput = & $SmctlPath credentials save $env:SM_API_KEY $env:SM_CLIENT_CERT_PASSWORD 2>&1 | Out-String
+        Log-Debug "Credentials save output: $saveOutput"
+        
+        if ($saveOutput -like "*Credentials saved*") {
+            Log-Success "Credentials saved successfully"
+        }
+        
+        # Set environment variables for smctl
+        Log-Info "Setting KeyLocker environment variables..."
+        $env:SM_HOST = $env:SM_HOST  # Already set, but ensure it's available
+        $env:SM_API_KEY = $env:SM_API_KEY  # Already set
+        $env:SM_CLIENT_CERT_FILE = $env:SM_CLIENT_CERT_FILE  # Path to decoded cert file
+        Log-Debug "SM_HOST: $env:SM_HOST"
+        Log-Debug "SM_CLIENT_CERT_FILE: $env:SM_CLIENT_CERT_FILE"
+        
+        # Run health check
+        Log-Info "Running KeyLocker health check..."
+        $healthOutput = & $SmctlPath healthcheck 2>&1 | Out-String
+        Log-Debug "Health check output: $healthOutput"
+        
+        if ($healthOutput -like "*Healthy*" -or $healthOutput -like "*SUCCESS*" -or $LASTEXITCODE -eq 0) {
+            Log-Success "KeyLocker health check passed"
+        } else {
+            Log-Error "Health check failed: $healthOutput"
+            # Don't throw here, sometimes healthcheck is flaky but signing still works
+        }
+        
+        # Sync certificates to Windows certificate store
+        Log-Info "Syncing certificates to Windows store..."
+        $syncOutput = & $SmctlPath windows certsync 2>&1 | Out-String
+        Log-Debug "Certificate sync output: $syncOutput"
+        
+        if ($syncOutput -like "*success*" -or $syncOutput -like "*synced*" -or $LASTEXITCODE -eq 0) {
+            Log-Success "Certificates synced to Windows store"
+        } else {
+            Log-Info "Certificate sync output: $syncOutput"
+        }
+        
+    } catch {
+        throw "Failed to configure KeyLocker: $_"
+    }
+}
+
+# Sign an executable
+function Sign-Executable {
+    param(
+        [string]$ExePath,
+        [string]$SmctlPath
+    )
+    
+    if (!(Test-Path $ExePath)) {
+        throw "Executable not found: $ExePath"
+    }
+    
+    $fileName = Split-Path $ExePath -Leaf
+    Log-Info "Signing $fileName..."
+    Log-Debug "Full path: $ExePath"
+    Log-Debug "File size: $((Get-Item $ExePath).Length) bytes"
+    
+    # Check if already signed
+    $existingSig = Get-AuthenticodeSignature $ExePath
+    if ($existingSig.Status -eq "Valid") {
+        Log-Info "$fileName is already signed by: $($existingSig.SignerCertificate.Subject)"
+        Log-Info "Skipping re-signing"
+        return
+    }
+    
+    # Sign the executable using smctl
+    try {
+        # smctl sign command with keypair-alias
+        $signArgs = @(
+            "sign",
+            "--keypair-alias", $env:SM_KEYPAIR_ALIAS,
+            "--input", $ExePath,
+            "--verbose"
+        )
+        
+        Log-Debug "Running: $SmctlPath $($signArgs -join ' ')"
+        
+        $signOutput = & $SmctlPath $signArgs 2>&1 | Out-String
+        
+        if ($LASTEXITCODE -ne 0) {
+            Log-Error "Signing output: $signOutput"
+            throw "Signing failed with exit code: $LASTEXITCODE"
+        }
+        
+        Log-Debug "Signing output: $signOutput"
+        Log-Success "Signing command completed"
+        
+    } catch {
+        throw "Failed to sign $fileName : $_"
+    }
+    
+    # Verify signature
+    $newSig = Get-AuthenticodeSignature $ExePath
+    
+    if ($newSig.Status -eq "Valid") {
+        Log-Success "$fileName signed successfully"
+        Log-Info "Signed by: $($newSig.SignerCertificate.Subject)"
+        Log-Info "Thumbprint: $($newSig.SignerCertificate.Thumbprint)"
+        Log-Info "Valid from: $($newSig.SignerCertificate.NotBefore) to $($newSig.SignerCertificate.NotAfter)"
+    } else {
+        throw "$fileName signature verification failed: $($newSig.Status) - $($newSig.StatusMessage)"
+    }
+}
+
+# Cleanup function
+function Cleanup {
+    if ($global:TEMP_CERT_PATH -and (Test-Path $global:TEMP_CERT_PATH)) {
+        try {
+            Remove-Item $global:TEMP_CERT_PATH -Force
+            Log-Info "Cleaned up temporary certificate"
+        } catch {
+            Log-Error "Failed to cleanup temporary certificate: $_"
+        }
+    }
+}
+
+# Main execution
+try {
+    Write-Host "========================================" -ForegroundColor Cyan
+    Write-Host "  Windows Code Signing for Bun" -ForegroundColor Cyan
+    Write-Host "========================================" -ForegroundColor Cyan
+    
+    # Ensure we're in a VS environment
+    Ensure-VSEnvironment
+    
+    # Check environment variables
+    Check-Environment
+    
+    # Setup certificate
+    Setup-Certificate
+    
+    # Install and configure KeyLocker
+    $smctlPath = Install-KeyLocker
+    Configure-KeyLocker -SmctlPath $smctlPath
+    
+    # Sign both executables
+    Sign-Executable -ExePath $BunProfileExe -SmctlPath $smctlPath
+    Sign-Executable -ExePath $BunExe -SmctlPath $smctlPath
+    
+    Write-Host "========================================" -ForegroundColor Green
+    Write-Host "  Code signing completed successfully!" -ForegroundColor Green
+    Write-Host "========================================" -ForegroundColor Green
+    
+    exit 0
+    
+} catch {
+    Log-Error "Code signing failed: $_"
+    exit 1
+    
+} finally {
+    Cleanup
+}

.buildkite/scripts/upload-benchmark.mjs

@@ -0,0 +1,7 @@
+import { getCommit, getSecret } from "../../scripts/utils.mjs";
+
+console.log("Submitting...");
+const response = await fetch(getSecret("BENCHMARK_URL") + "?tag=_&commit=" + getCommit() + "&artifact_url=_", {
+  method: "POST",
+});
+console.log("Got status " + response.status);

.buildkite/scripts/upload-release.sh

@@ -0,0 +1,254 @@
+#!/bin/bash
+
+set -eo pipefail
+
+function assert_main() {
+  if [ -z "$BUILDKITE_REPO" ]; then
+    echo "error: Cannot find repository for this build"
+    exit 1
+  fi
+  if [ -z "$BUILDKITE_COMMIT" ]; then
+    echo "error: Cannot find commit for this build"
+    exit 1
+  fi
+  if [ -n "$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_github() {
+  assert_command "gh" "gh" "https://github.com/cli/cli#installation"
+  assert_buildkite_secret "GITHUB_TOKEN"
+  # gh expects the token in $GH_TOKEN
+  export GH_TOKEN="$GITHUB_TOKEN"
+}
+
+function assert_aws() {
+  assert_command "aws" "awscli" "https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html"
+  for secret in "AWS_ACCESS_KEY_ID" "AWS_SECRET_ACCESS_KEY" "AWS_ENDPOINT"; do
+    assert_buildkite_secret "$secret"
+  done
+  assert_buildkite_secret "AWS_BUCKET" --skip-redaction
+}
+
+function assert_sentry() {
+  assert_command "sentry-cli" "getsentry/tools/sentry-cli" "https://docs.sentry.io/cli/installation/"
+  for secret in "SENTRY_AUTH_TOKEN" "SENTRY_ORG" "SENTRY_PROJECT"; do
+    assert_buildkite_secret "$secret"
+  done
+}
+
+function run_command() {
+  set -x
+  "$@"
+  { set +x; } 2>/dev/null
+}
+
+function assert_command() {
+  local command="$1"
+  local package="$2"
+  local help_url="$3"
+  if ! command -v "$command" &> /dev/null; then
+    echo "warning: $command is not installed, installing..."
+    if command -v brew &> /dev/null; then
+      HOMEBREW_NO_AUTO_UPDATE=1 run_command brew install "$package"
+    else
+      echo "error: Cannot install $command, please install it"
+      if [ -n "$help_url" ]; then
+        echo ""
+        echo "hint: See $help_url for help"
+      fi
+      exit 1
+    fi
+  fi
+}
+
+function assert_buildkite_secret() {
+  local key="$1"
+  local value=$(buildkite-agent secret get "$key" ${@:2})
+  if [ -z "$value" ]; then
+    echo "error: Cannot find $key secret"
+    echo ""
+    echo "hint: Create a secret named $key with a value:"
+    echo "https://buildkite.com/docs/pipelines/buildkite-secrets"
+    exit 1
+  fi
+  export "$key"="$value"
+}
+
+function release_tag() {
+  local version="$1"
+  if [ "$version" == "canary" ]; then
+    echo "canary"
+  else
+    echo "bun-v$version"
+  fi
+}
+
+function create_sentry_release() {
+  local version="$1"
+  local release="$version"
+  if [ "$version" == "canary" ]; then
+    release="$BUILDKITE_COMMIT-canary"
+  fi
+  run_command sentry-cli releases new "$release" --finalize
+  run_command sentry-cli releases set-commits "$release" --auto --ignore-missing
+  if [ "$version" == "canary" ]; then
+    run_command sentry-cli deploys new --env="canary" --release="$release"
+  fi
+}
+
+function download_buildkite_artifact() {
+  local name="$1"
+  local dir="$2"
+  if [ -z "$dir" ]; then
+    dir="."
+  fi
+  run_command buildkite-agent artifact download "$name" "$dir"
+  if [ ! -f "$dir/$name" ]; then
+    echo "error: Cannot find Buildkite artifact: $name"
+    exit 1
+  fi
+}
+
+function upload_github_asset() {
+  local version="$1"
+  local tag="$(release_tag "$version")"
+  local file="$2"
+  run_command gh release upload "$tag" "$file" --clobber --repo "$BUILDKITE_REPO"
+
+  # Sometimes the upload fails, maybe this is a race condition in the gh CLI?
+  while [ "$(gh release view "$tag" --repo "$BUILDKITE_REPO" | grep -c "$file")" -eq 0 ]; do
+    echo "warn: Uploading $file to $tag failed, retrying..."
+    sleep "$((RANDOM % 5 + 1))"
+    run_command gh release upload "$tag" "$file" --clobber --repo "$BUILDKITE_REPO"
+  done
+}
+
+function update_github_release() {
+  local version="$1"
+  local tag="$(release_tag "$version")"
+  if [ "$tag" == "canary" ]; then
+    sleep 5 # There is possibly a race condition where this overwrites artifacts?
+    run_command gh release edit "$tag" --repo "$BUILDKITE_REPO" \
+      --notes "This release of Bun corresponds to the commit: $BUILDKITE_COMMIT"
+  fi
+}
+
+function upload_s3_file() {
+  local folder="$1"
+  local file="$2"
+  run_command aws --endpoint-url="$AWS_ENDPOINT" s3 cp "$file" "s3://$AWS_BUCKET/$folder/$file"
+}
+
+function send_discord_announcement() {
+  local value=$(buildkite-agent secret get "BUN_ANNOUNCE_CANARY_WEBHOOK_URL")
+  if [ -z "$value" ]; then
+    echo "warn: BUN_ANNOUNCE_CANARY_WEBHOOK_URL not set, skipping Discord announcement"
+    return
+  fi
+
+  local version="$1"
+  local commit="$BUILDKITE_COMMIT"
+  local short_sha="${commit:0:7}"
+  local commit_url="https://github.com/oven-sh/bun/commit/$commit"
+
+  if [ "$version" == "canary" ]; then
+    local json_payload=$(cat <<EOF
+{
+  "embeds": [{
+    "title": "New Bun Canary now available",
+    "description": "A new canary build of Bun has been automatically uploaded ([${short_sha}](${commit_url})). To upgrade, run:\n\n\`\`\`shell\nbun upgrade --canary\n\`\`\`\nCommit: \`${commit}\`",
+    "color": 16023551,
+    "timestamp": "$(date -u +%Y-%m-%dT%H:%M:%SZ)"
+  }]
+}
+EOF
+)
+    
+    curl -H "Content-Type: application/json" \
+         -d "$json_payload" \
+         -sf \
+         "$value" >/dev/null
+  fi
+}
+
+function create_release() {
+  assert_main
+  assert_buildkite_agent
+  assert_github
+  assert_aws
+  assert_sentry
+
+  local tag="$1" # 'canary' or 'x.y.z'
+  local 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-linux-aarch64-musl.zip
+    bun-linux-aarch64-musl-profile.zip
+    bun-linux-x64-musl.zip
+    bun-linux-x64-musl-profile.zip
+    bun-linux-x64-musl-baseline.zip
+    bun-linux-x64-musl-baseline-profile.zip
+    bun-windows-x64.zip
+    bun-windows-x64-profile.zip
+    bun-windows-x64-baseline.zip
+    bun-windows-x64-baseline-profile.zip
+  )
+
+  function upload_artifact() {
+    local artifact="$1"
+    download_buildkite_artifact "$artifact"
+    if [ "$tag" == "canary" ]; then
+      upload_s3_file "releases/$BUILDKITE_COMMIT-canary" "$artifact" &
+    else
+      upload_s3_file "releases/$BUILDKITE_COMMIT" "$artifact" &
+    fi
+    upload_s3_file "releases/$tag" "$artifact" &
+    upload_github_asset "$tag" "$artifact" &
+    wait
+  }
+
+  for artifact in "${artifacts[@]}"; do
+    upload_artifact "$artifact"
+  done
+
+  update_github_release "$tag"
+  create_sentry_release "$tag"
+  send_discord_announcement "$tag"
+}
+
+function assert_canary() {
+  if [ -z "$CANARY" ] || [ "$CANARY" == "0" ]; then
+    echo "warn: Skipping release because this is not a canary build"
+    exit 0
+  fi
+}
+
+assert_canary
+create_release "canary"

.clang-tidy

@@ -0,0 +1,9 @@
+WarningsAsErrors: "*"
+FormatStyle: webkit
+Checks: >
+  -*,
+  clang-analyzer-*,
+  -clang-analyzer-optin.core.EnumCastOutOfRange
+  -clang-analyzer-webkit.UncountedLambdaCapturesChecker
+  -clang-analyzer-optin.core.EnumCastOutOfRange
+  -clang-analyzer-webkit.RefCntblBaseVirtualDtor

.clangd

@@ -0,0 +1,8 @@
+Index:
+  Background: Skip # Disable slow background indexing of these files.
+
+CompileFlags:
+  CompilationDatabase: build/debug
+
+Diagnostics:
+  UnusedIncludes: None

.claude/commands/upgrade-nodejs.md

@@ -0,0 +1,92 @@
+# Upgrading Bun's Self-Reported Node.js Version
+
+This guide explains how to upgrade the Node.js version that Bun reports for compatibility with Node.js packages and native addons.
+
+## Overview
+
+Bun reports a Node.js version for compatibility with the Node.js ecosystem. This affects:
+- `process.version` output
+- Node-API (N-API) compatibility
+- Native addon ABI compatibility
+- V8 API compatibility for addons using V8 directly
+
+## Files That Always Need Updates
+
+### 1. Bootstrap Scripts
+- `scripts/bootstrap.sh` - Update `NODEJS_VERSION=`
+- `scripts/bootstrap.ps1` - Update `$NODEJS_VERSION =`
+
+### 2. CMake Configuration
+- `cmake/Options.cmake`
+  - `NODEJS_VERSION` - The Node.js version string (e.g., "24.3.0")
+  - `NODEJS_ABI_VERSION` - The ABI version number (find using command below)
+
+### 3. Version Strings
+- `src/bun.js/bindings/BunProcess.cpp`
+  - Update `Bun__versions_node` with the Node.js version
+  - Update `Bun__versions_v8` with the V8 version (find using command below)
+
+### 4. N-API Version
+- `src/napi/js_native_api.h`
+  - Update `NAPI_VERSION` define (check Node.js release notes)
+
+## Files That May Need Updates
+
+Only check these if the build fails or tests crash after updating version numbers:
+- V8 compatibility files in `src/bun.js/bindings/v8/` (if V8 API changed)
+- Test files (if Node.js requires newer C++ standard)
+
+## Quick Commands to Find Version Info
+
+```bash
+# Get latest Node.js version info
+curl -s https://nodejs.org/dist/index.json | jq '.[0]'
+
+# Get V8 version for a specific Node.js version (replace v24.3.0)
+curl -s https://nodejs.org/dist/v24.3.0/node-v24.3.0-headers.tar.gz | tar -xzO node-v24.3.0/include/node/node_version.h | grep V8_VERSION
+
+# Get ABI version for a specific Node.js version
+curl -s https://nodejs.org/dist/v24.3.0/node-v24.3.0-headers.tar.gz | tar -xzO node-v24.3.0/include/node/node_version.h | grep NODE_MODULE_VERSION
+
+# Or use the ABI registry
+curl -s https://raw.githubusercontent.com/nodejs/node/main/doc/abi_version_registry.json | jq '.NODE_MODULE_VERSION."<version>"'
+```
+
+## Update Process
+
+1. **Gather version info** using the commands above
+2. **Update the required files** listed in the sections above
+3. **Build and test**:
+   ```bash
+   bun bd
+   bun bd -e "console.log(process.version)"
+   bun bd -e "console.log(process.versions.v8)"
+   bun bd test test/v8/v8.test.ts
+   bun bd test test/napi/napi.test.ts
+   ```
+
+4. **Check for V8 API changes** only if build fails or tests crash:
+   - Compare v8-function-callback.h between versions
+   - Check v8-internal.h for Isolate size changes
+   - Look for new required APIs in build errors
+
+## If Build Fails or Tests Crash
+
+The V8 API rarely has breaking changes between minor Node.js versions. If you encounter issues:
+1. Check build errors for missing symbols or type mismatches
+2. Compare V8 headers between old and new Node.js versions
+3. Most issues can be resolved by implementing missing functions or adjusting structures
+
+## Testing Checklist
+
+- [ ] `process.version` returns correct version
+- [ ] `process.versions.v8` returns correct V8 version  
+- [ ] `process.config.variables.node_module_version` returns correct ABI
+- [ ] V8 tests pass
+- [ ] N-API tests pass
+
+## Notes
+
+- Most upgrades only require updating version numbers
+- Major V8 version changes (rare) may require API updates
+- The V8 shim implements only APIs used by common native addons

.claude/commands/upgrade-webkit.md

@@ -0,0 +1,23 @@
+Upgrade Bun's Webkit fork to the latest upstream version of Webkit.
+
+To do that:
+
+- cd vendor/WebKit
+- git fetch upstream
+- git merge upstream main
+- Fix the merge conflicts
+- cd ../../ (back to bun)
+- make jsc-build (this will take about 7 minutes)
+- While it compiles, in another task review the JSC commits between the last version of Webkit and the new version. Write up a summary of the webkit changes in a file called "webkit-changes.md"
+- bun run build:local (build a build of Bun with the new Webkit, make sure it compiles)
+- After making sure it compiles, run some code to make sure things work. something like ./build/debug-local/bun-debug --print '42' should be all you need
+- cd vendor/WebKit
+- git commit -am "Upgrade Webkit to the latest version"
+- git push
+- get the commit SHA in the vendor/WebKit directory of your new commit
+- cd ../../ (back to bun)
+- Update WEBKIT_VERSION in cmake/tools/SetupWebKit.cmake to the commit SHA of your new commit
+- git checkout -b bun/webkit-upgrade-<commit-sha>
+- commit + push (without adding the webkit-changes.md file)
+- create PR titled "Upgrade Webkit to the <commit-sha>", paste your webkit-changes.md into the PR description
+- delete the webkit-changes.md file

.cursor/environment.json

@@ -0,0 +1,10 @@
+{
+  "snapshot": "snapshot-20250706-71021aff-cc0d-4a7f-a468-d443b16c4bf1",
+  "install": "bun install",
+  "terminals": [
+    {
+      "name": "bun build",
+      "command": "bun run build"
+    }
+  ]
+}

.cursor/rules/building-bun.mdc

@@ -0,0 +1,41 @@
+---
+description:
+globs: src/**/*.cpp,src/**/*.zig
+alwaysApply: false
+---
+
+### Build Commands
+
+- **Build debug version**: `bun bd` or `bun run build:debug`
+  - Creates a debug build at `./build/debug/bun-debug`
+  - Compilation takes ~2.5 minutes
+- **Run tests with your debug build**: `bun bd test <test-file>`
+  - **CRITICAL**: Never use `bun test` directly - it won't include your changes
+- **Run any command with debug build**: `bun bd <command>`
+
+### Run a file
+
+To run a file, use:
+
+```sh
+bun bd <file> <...args>
+```
+
+**CRITICAL**: Never use `bun <file>` directly. It will not have your changes.
+
+### Logging
+
+`BUN_DEBUG_$(SCOPE)=1` enables debug logs for a specific debug log scope.
+
+Debug logs look like this:
+
+```zig
+const log = bun.Output.scoped(.${SCOPE}, false);
+
+// ...later
+log("MY DEBUG LOG", .{})
+```
+
+### Code Generation
+
+Code generation happens automatically as part of the build process. There are no commands to run.

.cursor/rules/dev-server-tests.mdc

@@ -0,0 +1,139 @@
+---
+description: Writing HMR/Dev Server tests
+globs: test/bake/*
+---
+
+# Writing HMR/Dev Server tests
+
+Dev server tests validate that hot-reloading is robust, correct, and reliable. Remember to write thorough, yet concise tests.
+
+## File Structure
+
+- `test/bake/bake-harness.ts` - shared utilities and test harness
+  - primary test functions `devTest` / `prodTest` / `devAndProductionTest`
+  - class `Dev` (controls subprocess for dev server)
+  - class `Client` (controls a happy-dom subprocess for having the page open)
+  - more helpers
+- `test/bake/client-fixture.mjs` - subprocess for what `Client` controls. it loads a page and uses IPC to query parts of the page, run javascript, and much more.
+- `test/bake/dev/*.test.ts` - these call `devTest` to test dev server and hot reloading
+- `test/bake/dev-and-prod.ts` - these use `devAndProductionTest` to run the same test on dev and production mode. these tests cannot really test hot reloading for obvious reasons.
+
+## Categories
+
+bundle.test.ts - Bundle tests are tests concerning bundling bugs that only occur in DevServer.
+css.test.ts - CSS tests concern bundling bugs with CSS files
+plugins.test.ts - Plugin tests concern plugins in development mode.
+ecosystem.test.ts - These tests involve ensuring certain libraries are correct. It is preferred to test more concrete bugs than testing entire packages.
+esm.test.ts - ESM tests are about various esm features in development mode.
+html.test.ts - HTML tests are tests relating to HTML files themselves.
+react-spa.test.ts - Tests relating to React, our react-refresh transform, and basic server component transforms.
+sourcemap.test.ts - Tests verifying source-maps are correct.
+
+## `devTest` Basics
+
+A test takes in two primary inputs: `files` and `async test(dev) {`
+
+```ts
+import { devTest, emptyHtmlFile } from "../bake-harness";
+
+devTest("html file is watched", {
+  files: {
+    "index.html": emptyHtmlFile({
+      scripts: ["/script.ts"],
+      body: "<h1>Hello</h1>",
+    }),
+    "script.ts": `
+      console.log("hello");
+    `,
+  },
+  async test(dev) {
+    await dev.fetch("/").expect.toInclude("<h1>Hello</h1>");
+    await dev.fetch("/").expect.toInclude("<h1>Hello</h1>");
+    await dev.patch("index.html", {
+      find: "Hello",
+      replace: "World",
+    });
+    await dev.fetch("/").expect.toInclude("<h1>World</h1>");
+
+    // Works
+    await using c = await dev.client("/");
+    await c.expectMessage("hello");
+
+    // Editing HTML reloads
+    await c.expectReload(async () => {
+      await dev.patch("index.html", {
+        find: "World",
+        replace: "Hello",
+      });
+      await dev.fetch("/").expect.toInclude("<h1>Hello</h1>");
+    });
+    await c.expectMessage("hello");
+
+    await c.expectReload(async () => {
+      await dev.patch("index.html", {
+        find: "Hello",
+        replace: "Bar",
+      });
+      await dev.fetch("/").expect.toInclude("<h1>Bar</h1>");
+    });
+    await c.expectMessage("hello");
+
+    await c.expectReload(async () => {
+      await dev.patch("script.ts", {
+        find: "hello",
+        replace: "world",
+      });
+    });
+    await c.expectMessage("world");
+  },
+});
+```
+
+`files` holds the initial state, and the callback runs with the server running. `dev.fetch()` runs HTTP requests, while `dev.client()` opens a browser instance to the code.
+
+Functions `dev.write` and `dev.patch` and `dev.delete` mutate the filesystem. Do not use `node:fs` APIs, as the dev server ones are hooked to wait for hot-reload, and all connected clients to receive changes.
+
+When a change performs a hard-reload, that must be explicitly annotated with `expectReload`. This tells `client-fixture.mjs` that the test is meant to reload the page once; All other hard reloads automatically fail the test.
+
+Client's have `console.log` instrumented, so that any unasserted logs fail the test. This makes it more obvious when an extra reload or re-evaluation. Messages are awaited via `c.expectMessage("log")` or with multiple arguments if there are multiple logs.
+
+## Testing for bundling errors
+
+By default, a client opening a page to an error will fail the test. This makes testing errors explicit.
+
+```ts
+devTest("import then create", {
+  files: {
+    "index.html": `
+      <!DOCTYPE html>
+      <html>
+      <head></head>
+      <body>
+        <script type="module" src="/script.ts"></script>
+      </body>
+      </html>
+    `,
+    "script.ts": `
+      import data from "./data";
+      console.log(data);
+    `,
+  },
+  async test(dev) {
+    const c = await dev.client("/", {
+      errors: ['script.ts:1:18: error: Could not resolve: "./data"'],
+    });
+    await c.expectReload(async () => {
+      await dev.write("data.ts", "export default 'data';");
+    });
+    await c.expectMessage("data");
+  },
+});
+```
+
+Many functions take an options value to allow specifying it will produce errors. For example, this delete is going to cause a resolution failure.
+
+```ts
+await dev.delete("other.ts", {
+  errors: ['index.ts:1:16: error: Could not resolve: "./other"'],
+});
+```

.cursor/rules/javascriptcore-class.mdc

@@ -0,0 +1,413 @@
+---
+description: JavaScript class implemented in C++
+globs: *.cpp
+alwaysApply: false
+---
+
+# Implementing JavaScript classes in C++
+
+If there is a publicly accessible Constructor and Prototype, then there are 3 classes:
+
+- IF there are C++ class members we need a destructor, so `class Foo : public JSC::DestructibleObject`, if no C++ class fields (only JS properties) then we don't need a class at all usually. We can instead use JSC::constructEmptyObject(vm, structure) and `putDirectOffset` like in [NodeFSStatBinding.cpp](mdc:src/bun.js/bindings/NodeFSStatBinding.cpp).
+- class FooPrototype : public JSC::JSNonFinalObject
+- class FooConstructor : public JSC::InternalFunction
+
+If there is no publicly accessible Constructor, just the Prototype and the class is necessary. In some cases, we can avoid the prototype entirely (but that's rare).
+
+If there are C++ fields on the Foo class, the Foo class will need an iso subspace added to [DOMClientIsoSubspaces.h](mdc:src/bun.js/bindings/webcore/DOMClientIsoSubspaces.h) and [DOMIsoSubspaces.h](mdc:src/bun.js/bindings/webcore/DOMIsoSubspaces.h). Prototype and Constructor do not need subspaces.
+
+Usually you'll need to #include "root.h" at the top of C++ files or you'll get lint errors.
+
+Generally, defining the subspace looks like this:
+
+```c++
+
+class Foo : public JSC::DestructibleObject {
+
+// ...
+
+ template<typename MyClassT, JSC::SubspaceAccess mode>
+    static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+    {
+        if constexpr (mode == JSC::SubspaceAccess::Concurrently)
+            return nullptr;
+        return WebCore::subspaceForImpl<MyClassT, WebCore::UseCustomHeapCellType::No>(
+            vm,
+            [](auto& spaces) { return spaces.m_clientSubspaceFor${MyClassT}.get(); },
+            [](auto& spaces, auto&& space) { spaces.m_clientSubspaceFor${MyClassT} = std::forward<decltype(space)>(space); },
+            [](auto& spaces) { return spaces.m_subspaceFo${MyClassT}.get(); },
+            [](auto& spaces, auto&& space) { spaces.m_subspaceFor${MyClassT} = std::forward<decltype(space)>(space); });
+    }
+
+
+```
+
+It's better to put it in the .cpp file instead of the .h file, when possible.
+
+## Defining properties
+
+Define properties on the prototype. Use a const HashTableValues like this:
+
+```C++
+static JSC_DECLARE_HOST_FUNCTION(jsX509CertificateProtoFuncCheckEmail);
+static JSC_DECLARE_HOST_FUNCTION(jsX509CertificateProtoFuncCheckHost);
+static JSC_DECLARE_HOST_FUNCTION(jsX509CertificateProtoFuncCheckIP);
+static JSC_DECLARE_HOST_FUNCTION(jsX509CertificateProtoFuncCheckIssued);
+static JSC_DECLARE_HOST_FUNCTION(jsX509CertificateProtoFuncCheckPrivateKey);
+static JSC_DECLARE_HOST_FUNCTION(jsX509CertificateProtoFuncToJSON);
+static JSC_DECLARE_HOST_FUNCTION(jsX509CertificateProtoFuncToLegacyObject);
+static JSC_DECLARE_HOST_FUNCTION(jsX509CertificateProtoFuncToString);
+static JSC_DECLARE_HOST_FUNCTION(jsX509CertificateProtoFuncVerify);
+
+static JSC_DECLARE_CUSTOM_GETTER(jsX509CertificateGetter_ca);
+static JSC_DECLARE_CUSTOM_GETTER(jsX509CertificateGetter_fingerprint);
+static JSC_DECLARE_CUSTOM_GETTER(jsX509CertificateGetter_fingerprint256);
+static JSC_DECLARE_CUSTOM_GETTER(jsX509CertificateGetter_fingerprint512);
+static JSC_DECLARE_CUSTOM_GETTER(jsX509CertificateGetter_subject);
+static JSC_DECLARE_CUSTOM_GETTER(jsX509CertificateGetter_subjectAltName);
+static JSC_DECLARE_CUSTOM_GETTER(jsX509CertificateGetter_infoAccess);
+static JSC_DECLARE_CUSTOM_GETTER(jsX509CertificateGetter_keyUsage);
+static JSC_DECLARE_CUSTOM_GETTER(jsX509CertificateGetter_issuer);
+static JSC_DECLARE_CUSTOM_GETTER(jsX509CertificateGetter_issuerCertificate);
+static JSC_DECLARE_CUSTOM_GETTER(jsX509CertificateGetter_publicKey);
+static JSC_DECLARE_CUSTOM_GETTER(jsX509CertificateGetter_raw);
+static JSC_DECLARE_CUSTOM_GETTER(jsX509CertificateGetter_serialNumber);
+static JSC_DECLARE_CUSTOM_GETTER(jsX509CertificateGetter_validFrom);
+static JSC_DECLARE_CUSTOM_GETTER(jsX509CertificateGetter_validTo);
+static JSC_DECLARE_CUSTOM_GETTER(jsX509CertificateGetter_validFromDate);
+static JSC_DECLARE_CUSTOM_GETTER(jsX509CertificateGetter_validToDate);
+
+static const HashTableValue JSX509CertificatePrototypeTableValues[] = {
+    { "ca"_s, static_cast<unsigned>(PropertyAttribute::ReadOnly | PropertyAttribute::CustomAccessor), NoIntrinsic, { HashTableValue::GetterSetterType, jsX509CertificateGetter_ca, 0 } },
+    { "checkEmail"_s, static_cast<unsigned>(PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, jsX509CertificateProtoFuncCheckEmail, 2 } },
+    { "checkHost"_s, static_cast<unsigned>(PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, jsX509CertificateProtoFuncCheckHost, 2 } },
+    { "checkIP"_s, static_cast<unsigned>(PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, jsX509CertificateProtoFuncCheckIP, 1 } },
+    { "checkIssued"_s, static_cast<unsigned>(PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, jsX509CertificateProtoFuncCheckIssued, 1 } },
+    { "checkPrivateKey"_s, static_cast<unsigned>(PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, jsX509CertificateProtoFuncCheckPrivateKey, 1 } },
+    { "fingerprint"_s, static_cast<unsigned>(PropertyAttribute::ReadOnly | PropertyAttribute::CustomAccessor), NoIntrinsic, { HashTableValue::GetterSetterType, jsX509CertificateGetter_fingerprint, 0 } },
+    { "fingerprint256"_s, static_cast<unsigned>(PropertyAttribute::ReadOnly | PropertyAttribute::CustomAccessor), NoIntrinsic, { HashTableValue::GetterSetterType, jsX509CertificateGetter_fingerprint256, 0 } },
+    { "fingerprint512"_s, static_cast<unsigned>(PropertyAttribute::ReadOnly | PropertyAttribute::CustomAccessor), NoIntrinsic, { HashTableValue::GetterSetterType, jsX509CertificateGetter_fingerprint512, 0 } },
+    { "infoAccess"_s, static_cast<unsigned>(PropertyAttribute::ReadOnly | PropertyAttribute::CustomAccessor), NoIntrinsic, { HashTableValue::GetterSetterType, jsX509CertificateGetter_infoAccess, 0 } },
+    { "issuer"_s, static_cast<unsigned>(PropertyAttribute::ReadOnly | PropertyAttribute::CustomAccessor), NoIntrinsic, { HashTableValue::GetterSetterType, jsX509CertificateGetter_issuer, 0 } },
+    { "issuerCertificate"_s, static_cast<unsigned>(PropertyAttribute::ReadOnly | PropertyAttribute::CustomAccessor), NoIntrinsic, { HashTableValue::GetterSetterType, jsX509CertificateGetter_issuerCertificate, 0 } },
+    { "keyUsage"_s, static_cast<unsigned>(PropertyAttribute::ReadOnly | PropertyAttribute::CustomAccessor), NoIntrinsic, { HashTableValue::GetterSetterType, jsX509CertificateGetter_keyUsage, 0 } },
+    { "publicKey"_s, static_cast<unsigned>(PropertyAttribute::ReadOnly | PropertyAttribute::CustomAccessor), NoIntrinsic, { HashTableValue::GetterSetterType, jsX509CertificateGetter_publicKey, 0 } },
+    { "raw"_s, static_cast<unsigned>(PropertyAttribute::ReadOnly | PropertyAttribute::CustomAccessor), NoIntrinsic, { HashTableValue::GetterSetterType, jsX509CertificateGetter_raw, 0 } },
+    { "serialNumber"_s, static_cast<unsigned>(PropertyAttribute::ReadOnly | PropertyAttribute::CustomAccessor), NoIntrinsic, { HashTableValue::GetterSetterType, jsX509CertificateGetter_serialNumber, 0 } },
+    { "subject"_s, static_cast<unsigned>(PropertyAttribute::ReadOnly | PropertyAttribute::CustomAccessor), NoIntrinsic, { HashTableValue::GetterSetterType, jsX509CertificateGetter_subject, 0 } },
+    { "subjectAltName"_s, static_cast<unsigned>(PropertyAttribute::ReadOnly | PropertyAttribute::CustomAccessor), NoIntrinsic, { HashTableValue::GetterSetterType, jsX509CertificateGetter_subjectAltName, 0 } },
+    { "toJSON"_s, static_cast<unsigned>(PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, jsX509CertificateProtoFuncToJSON, 0 } },
+    { "toLegacyObject"_s, static_cast<unsigned>(PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, jsX509CertificateProtoFuncToLegacyObject, 0 } },
+    { "toString"_s, static_cast<unsigned>(PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, jsX509CertificateProtoFuncToString, 0 } },
+    { "validFrom"_s, static_cast<unsigned>(PropertyAttribute::ReadOnly | PropertyAttribute::CustomAccessor), NoIntrinsic, { HashTableValue::GetterSetterType, jsX509CertificateGetter_validFrom, 0 } },
+    { "validFromDate"_s, static_cast<unsigned>(PropertyAttribute::ReadOnly | PropertyAttribute::CustomAccessorOrValue), NoIntrinsic, { HashTableValue::GetterSetterType, jsX509CertificateGetter_validFromDate, 0 } },
+    { "validTo"_s, static_cast<unsigned>(PropertyAttribute::ReadOnly | PropertyAttribute::CustomAccessor), NoIntrinsic, { HashTableValue::GetterSetterType, jsX509CertificateGetter_validTo, 0 } },
+    { "validToDate"_s, static_cast<unsigned>(PropertyAttribute::ReadOnly | PropertyAttribute::CustomAccessorOrValue), NoIntrinsic, { HashTableValue::GetterSetterType, jsX509CertificateGetter_validToDate, 0 } },
+    { "verify"_s, static_cast<unsigned>(PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, jsX509CertificateProtoFuncVerify, 1 } },
+};
+```
+
+### Creating a prototype class
+
+Follow a pattern like this:
+
+```c++
+class JSX509CertificatePrototype final : public JSC::JSNonFinalObject {
+public:
+    using Base = JSC::JSNonFinalObject;
+    static constexpr unsigned StructureFlags = Base::StructureFlags;
+
+    static JSX509CertificatePrototype* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure)
+    {
+        JSX509CertificatePrototype* prototype = new (NotNull, allocateCell<JSX509CertificatePrototype>(vm)) JSX509CertificatePrototype(vm, structure);
+        prototype->finishCreation(vm);
+        return prototype;
+    }
+
+    template<typename, JSC::SubspaceAccess>
+    static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+    {
+        return &vm.plainObjectSpace();
+    }
+
+    DECLARE_INFO;
+
+    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+    {
+        auto* structure = JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
+        structure->setMayBePrototype(true);
+        return structure;
+    }
+
+private:
+    JSX509CertificatePrototype(JSC::VM& vm, JSC::Structure* structure)
+        : Base(vm, structure)
+    {
+    }
+
+    void finishCreation(JSC::VM& vm);
+};
+
+const ClassInfo JSX509CertificatePrototype::s_info = { "X509Certificate"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSX509CertificatePrototype) };
+
+void JSX509CertificatePrototype::finishCreation(VM& vm)
+{
+    Base::finishCreation(vm);
+    reifyStaticProperties(vm, JSX509Certificate::info(), JSX509CertificatePrototypeTableValues, *this);
+    JSC_TO_STRING_TAG_WITHOUT_TRANSITION();
+}
+
+} // namespace Bun
+```
+
+### Getter definition:
+
+```C++
+
+JSC_DEFINE_CUSTOM_GETTER(jsX509CertificateGetter_ca, (JSGlobalObject * globalObject, EncodedJSValue thisValue, PropertyName))
+{
+    VM& vm = globalObject->vm();
+    auto scope = DECLARE_THROW_SCOPE(vm);
+
+    JSX509Certificate* thisObject = jsDynamicCast<JSX509Certificate*>(JSValue::decode(thisValue));
+    if (UNLIKELY(!thisObject)) {
+        Bun::throwThisTypeError(*globalObject, scope, "JSX509Certificate"_s, "ca"_s);
+        return {};
+    }
+
+    return JSValue::encode(jsBoolean(thisObject->view().isCA()));
+}
+```
+
+### Setter definition
+
+```C++
+JSC_DEFINE_CUSTOM_SETTER(jsImportMetaObjectSetter_require, (JSGlobalObject * jsGlobalObject, JSC::EncodedJSValue thisValue, JSC::EncodedJSValue encodedValue, PropertyName propertyName))
+{
+    ImportMetaObject* thisObject = jsDynamicCast<ImportMetaObject*>(JSValue::decode(thisValue));
+    if (UNLIKELY(!thisObject))
+        return false;
+
+    JSValue value = JSValue::decode(encodedValue);
+    if (!value.isCell()) {
+        // TODO:
+        return true;
+    }
+
+    thisObject->requireProperty.set(thisObject->vm(), thisObject, value.asCell());
+    return true;
+}
+```
+
+### Function definition
+
+```C++
+JSC_DEFINE_HOST_FUNCTION(jsX509CertificateProtoFuncToJSON, (JSGlobalObject * globalObject, CallFrame* callFrame))
+{
+    VM& vm = globalObject->vm();
+    auto scope = DECLARE_THROW_SCOPE(vm);
+    auto *thisObject = jsDynamicCast<MyClassT*>(callFrame->thisValue());
+     if (UNLIKELY(!thisObject)) {
+        Bun::throwThisTypeError(*globalObject, scope, "MyClass"_s, "myFunctionName"_s);
+        return {};
+    }
+
+    return JSValue::encode(functionThatReturnsJSValue(vm, globalObject, thisObject));
+}
+```
+
+### Constructor definition
+
+```C++
+
+JSC_DECLARE_HOST_FUNCTION(callStats);
+JSC_DECLARE_HOST_FUNCTION(constructStats);
+
+class JSStatsConstructor final : public JSC::InternalFunction {
+public:
+    using Base = JSC::InternalFunction;
+    static constexpr unsigned StructureFlags = Base::StructureFlags;
+
+    static JSStatsConstructor* create(JSC::VM& vm, JSC::Structure* structure, JSC::JSObject* prototype)
+    {
+        JSStatsConstructor* constructor = new (NotNull, JSC::allocateCell<JSStatsConstructor>(vm)) JSStatsConstructor(vm, structure);
+        constructor->finishCreation(vm, prototype);
+        return constructor;
+    }
+
+    DECLARE_INFO;
+
+    template<typename CellType, JSC::SubspaceAccess>
+    static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+    {
+        return &vm.internalFunctionSpace();
+    }
+
+    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+    {
+        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::InternalFunctionType, StructureFlags), info());
+    }
+
+private:
+    JSStatsConstructor(JSC::VM& vm, JSC::Structure* structure)
+        : Base(vm, structure, callStats, constructStats)
+    {
+    }
+
+    void finishCreation(JSC::VM& vm, JSC::JSObject* prototype)
+    {
+        Base::finishCreation(vm, 0, "Stats"_s);
+        putDirectWithoutTransition(vm, vm.propertyNames->prototype, prototype, JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::DontDelete | JSC::PropertyAttribute::ReadOnly);
+    }
+};
+```
+
+### Structure caching
+
+If there's a class, prototype, and constructor:
+
+1. Add the `JSC::LazyClassStructure` to [ZigGlobalObject.h](mdc:src/bun.js/bindings/ZigGlobalObject.h)
+2. Initialize the class structure in [ZigGlobalObject.cpp](mdc:src/bun.js/bindings/ZigGlobalObject.cpp) in `void GlobalObject::finishCreation(VM& vm)`
+3. Visit the class structure in visitChildren in [ZigGlobalObject.cpp](mdc:src/bun.js/bindings/ZigGlobalObject.cpp) in `void GlobalObject::visitChildrenImpl`
+
+```c++#ZigGlobalObject.cpp
+void GlobalObject::finishCreation(VM& vm) {
+// ...
+    m_JSStatsBigIntClassStructure.initLater(
+        [](LazyClassStructure::Initializer& init) {
+            // Call the function to initialize our class structure.
+            Bun::initJSBigIntStatsClassStructure(init);
+        });
+```
+
+Then, implement the function that creates the structure:
+
+```c++
+void setupX509CertificateClassStructure(LazyClassStructure::Initializer& init)
+{
+    auto* prototypeStructure = JSX509CertificatePrototype::createStructure(init.vm, init.global, init.global->objectPrototype());
+    auto* prototype = JSX509CertificatePrototype::create(init.vm, init.global, prototypeStructure);
+
+    auto* constructorStructure = JSX509CertificateConstructor::createStructure(init.vm, init.global, init.global->functionPrototype());
+
+    auto* constructor = JSX509CertificateConstructor::create(init.vm, init.global, constructorStructure, prototype);
+
+    auto* structure = JSX509Certificate::createStructure(init.vm, init.global, prototype);
+    init.setPrototype(prototype);
+    init.setStructure(structure);
+    init.setConstructor(constructor);
+}
+```
+
+If there's only a class, use `JSC::LazyProperty<JSGlobalObject, Structure>` instead of `JSC::LazyClassStructure`:
+
+1. Add the `JSC::LazyProperty<JSGlobalObject, Structure>` to @ZigGlobalObject.h
+2. Initialize the class structure in @ZigGlobalObject.cpp in `void GlobalObject::finishCreation(VM& vm)`
+3. Visit the lazy property in visitChildren in @ZigGlobalObject.cpp in `void GlobalObject::visitChildrenImpl`
+   void GlobalObject::finishCreation(VM& vm) {
+   // ...
+   this.m_myLazyProperty.initLater([](const JSC::LazyProperty<JSC::JSGlobalObject, JSC::Structure>::Initializer& init) {
+   init.set(Bun::initMyStructure(init.vm, reinterpret_cast<Zig::GlobalObject\*>(init.owner)));
+   });
+
+```
+
+Then, implement the function that creates the structure:
+```c++
+Structure* setupX509CertificateStructure(JSC::VM &vm, Zig::GlobalObject* globalObject)
+{
+    // If there is a prototype:
+    auto* prototypeStructure = JSX509CertificatePrototype::createStructure(init.vm, init.global, init.global->objectPrototype());
+    auto* prototype = JSX509CertificatePrototype::create(init.vm, init.global, prototypeStructure);
+
+    // If there is no prototype or it only has
+
+    auto* structure = JSX509Certificate::createStructure(init.vm, init.global, prototype);
+    init.setPrototype(prototype);
+    init.setStructure(structure);
+    init.setConstructor(constructor);
+}
+```
+
+Then, use the structure by calling `globalObject.m_myStructureName.get(globalObject)`
+
+```C++
+JSC_DEFINE_HOST_FUNCTION(x509CertificateConstructorConstruct, (JSGlobalObject * globalObject, CallFrame* callFrame))
+{
+    VM& vm = globalObject->vm();
+    auto scope = DECLARE_THROW_SCOPE(vm);
+
+    if (!callFrame->argumentCount()) {
+        Bun::throwError(globalObject, scope, ErrorCode::ERR_MISSING_ARGS, "X509Certificate constructor requires at least one argument"_s);
+        return {};
+    }
+
+    JSValue arg = callFrame->uncheckedArgument(0);
+    if (!arg.isCell()) {
+        Bun::throwError(globalObject, scope, ErrorCode::ERR_INVALID_ARG_TYPE, "X509Certificate constructor argument must be a Buffer, TypedArray, or string"_s);
+        return {};
+    }
+
+    auto* zigGlobalObject = defaultGlobalObject(globalObject);
+    Structure* structure = zigGlobalObject->m_JSX509CertificateClassStructure.get(zigGlobalObject);
+    JSValue newTarget = callFrame->newTarget();
+    if (UNLIKELY(zigGlobalObject->m_JSX509CertificateClassStructure.constructor(zigGlobalObject) != newTarget)) {
+        auto scope = DECLARE_THROW_SCOPE(vm);
+        if (!newTarget) {
+            throwTypeError(globalObject, scope, "Class constructor X509Certificate cannot be invoked without 'new'"_s);
+            return {};
+        }
+
+        auto* functionGlobalObject = defaultGlobalObject(getFunctionRealm(globalObject, newTarget.getObject()));
+        RETURN_IF_EXCEPTION(scope, {});
+        structure = InternalFunction::createSubclassStructure(globalObject, newTarget.getObject(), functionGlobalObject->NodeVMScriptStructure());
+        RETURN_IF_EXCEPTION(scope, {});
+    }
+
+    return JSValue::encode(createX509Certificate(vm, globalObject, structure, arg));
+}
+```
+
+### Expose to Zig
+
+To expose the constructor to zig:
+
+```c++
+extern "C" JSC::EncodedJSValue Bun__JSBigIntStatsObjectConstructor(Zig::GlobalObject* globalobject)
+{
+    return JSValue::encode(globalobject->m_JSStatsBigIntClassStructure.constructor(globalobject));
+}
+```
+
+Zig:
+
+```zig
+extern "c" fn Bun__JSBigIntStatsObjectConstructor(*JSC.JSGlobalObject) JSC.JSValue;
+pub const getBigIntStatsConstructor =  Bun__JSBigIntStatsObjectConstructor;
+```
+
+To create an object (instance) of a JS class defined in C++ from Zig, follow the \_\_toJS convention like this:
+
+```c++
+// X509* is whatever we need to create the object
+extern "C" EncodedJSValue Bun__X509__toJS(Zig::GlobalObject* globalObject, X509* cert)
+{
+    // ... implementation details
+    auto* structure = globalObject->m_JSX509CertificateClassStructure.get(globalObject);
+    return JSValue::encode(JSX509Certificate::create(globalObject->vm(), structure, globalObject, WTFMove(cert)));
+}
+```
+
+And from Zig:
+
+```zig
+const X509 = opaque {
+    // ... class
+
+    extern fn Bun__X509__toJS(*JSC.JSGlobalObject, *X509) JSC.JSValue;
+
+    pub fn toJS(this: *X509, globalObject: *JSC.JSGlobalObject) JSC.JSValue {
+        return Bun__X509__toJS(globalObject, this);
+    }
+};
+```

.cursor/rules/registering-bun-modules.mdc

@@ -0,0 +1,203 @@
+# Registering Functions, Objects, and Modules in Bun
+
+This guide documents the process of adding new functionality to the Bun global object and runtime.
+
+## Overview
+
+Bun's architecture exposes functionality to JavaScript through a set of carefully registered functions, objects, and modules. Most core functionality is implemented in Zig, with JavaScript bindings that make these features accessible to users.
+
+There are several key ways to expose functionality in Bun:
+
+1. **Global Functions**: Direct methods on the `Bun` object (e.g., `Bun.serve()`)
+2. **Getter Properties**: Lazily initialized properties on the `Bun` object (e.g., `Bun.sqlite`)
+3. **Constructor Classes**: Classes available through the `Bun` object (e.g., `Bun.ValkeyClient`)
+4. **Global Modules**: Modules that can be imported directly (e.g., `import {X} from "bun:*"`)
+
+## The Registration Process
+
+Adding new functionality to Bun involves several coordinated steps across multiple files:
+
+### 1. Implement the Core Functionality in Zig
+
+First, implement your feature in Zig, typically in its own directory in `src/`. Examples:
+
+- `src/valkey/` for Redis/Valkey client
+- `src/semver/` for SemVer functionality
+- `src/smtp/` for SMTP client
+
+### 2. Create JavaScript Bindings
+
+Create bindings that expose your Zig functionality to JavaScript:
+
+- Create a class definition file (e.g., `js_bindings.classes.ts`) to define the JavaScript interface
+- Implement `JSYourFeature` struct in a file like `js_your_feature.zig`
+
+Example from a class definition file:
+
+```typescript
+// Example from a .classes.ts file
+import { define } from "../../codegen/class-definitions";
+
+export default [
+  define({
+    name: "YourFeature",
+    construct: true,
+    finalize: true,
+    hasPendingActivity: true,
+    memoryCost: true,
+    klass: {},
+    JSType: "0b11101110",
+    proto: {
+      yourMethod: {
+        fn: "yourZigMethod",
+        length: 1,
+      },
+      property: {
+        getter: "getProperty",
+      },
+    },
+    values: ["cachedValues"],
+  }),
+];
+```
+
+### 3. Register with BunObject in `src/bun.js/bindings/BunObject+exports.h`
+
+Add an entry to the `FOR_EACH_GETTER` macro:
+
+```c
+// In BunObject+exports.h
+#define FOR_EACH_GETTER(macro) \
+    macro(CSRF) \
+    macro(CryptoHasher) \
+    ... \
+    macro(YourFeature) \
+```
+
+### 4. Create a Getter Function in `src/bun.js/api/BunObject.zig`
+
+Implement a getter function in `BunObject.zig` that returns your feature:
+
+```zig
+// In BunObject.zig
+pub const YourFeature = toJSGetter(Bun.getYourFeatureConstructor);
+
+// In the exportAll() function:
+@export(&BunObject.YourFeature, .{ .name = getterName("YourFeature") });
+```
+
+### 5. Implement the Getter Function in a Relevant Zig File
+
+Implement the function that creates your object:
+
+```zig
+// In your main module file (e.g., src/your_feature/your_feature.zig)
+pub fn getYourFeatureConstructor(globalThis: *JSC.JSGlobalObject, _: *JSC.JSObject) JSC.JSValue {
+    return JSC.API.YourFeature.getConstructor(globalThis);
+}
+```
+
+### 6. Add to Build System
+
+Ensure your files are included in the build system by adding them to the appropriate targets.
+
+## Example: Adding a New Module
+
+Here's a comprehensive example of adding a hypothetical SMTP module:
+
+1. Create implementation files in `src/smtp/`:
+
+   - `index.zig`: Main entry point that exports everything
+   - `SmtpClient.zig`: Core SMTP client implementation
+   - `js_smtp.zig`: JavaScript bindings
+   - `js_bindings.classes.ts`: Class definition
+
+2. Define your JS class in `js_bindings.classes.ts`:
+
+```typescript
+import { define } from "../../codegen/class-definitions";
+
+export default [
+  define({
+    name: "EmailClient",
+    construct: true,
+    finalize: true,
+    hasPendingActivity: true,
+    configurable: false,
+    memoryCost: true,
+    klass: {},
+    JSType: "0b11101110",
+    proto: {
+      send: {
+        fn: "send",
+        length: 1,
+      },
+      verify: {
+        fn: "verify",
+        length: 0,
+      },
+      close: {
+        fn: "close",
+        length: 0,
+      },
+    },
+    values: ["connectionPromise"],
+  }),
+];
+```
+
+3. Add getter to `BunObject+exports.h`:
+
+```c
+#define FOR_EACH_GETTER(macro) \
+    macro(CSRF) \
+    ... \
+    macro(SMTP) \
+```
+
+4. Add getter function to `BunObject.zig`:
+
+```zig
+pub const SMTP = toJSGetter(Bun.getSmtpConstructor);
+
+// In exportAll:
+@export(&BunObject.SMTP, .{ .name = getterName("SMTP") });
+```
+
+5. Implement getter in your module:
+
+```zig
+pub fn getSmtpConstructor(globalThis: *JSC.JSGlobalObject, _: *JSC.JSObject) JSC.JSValue {
+    return JSC.API.JSEmailClient.getConstructor(globalThis);
+}
+```
+
+## Best Practices
+
+1. **Follow Naming Conventions**: Align your naming with existing patterns
+2. **Reference Existing Modules**: Study similar modules like Valkey or S3Client for guidance
+3. **Memory Management**: Be careful with memory management and reference counting
+4. **Error Handling**: Use `bun.JSError!JSValue` for proper error propagation
+5. **Documentation**: Add JSDoc comments to your JavaScript bindings
+6. **Testing**: Add tests for your new functionality
+
+## Common Gotchas
+
+- Be sure to handle reference counting properly with `ref()`/`deref()`
+- Always implement proper cleanup in `deinit()` and `finalize()`
+- For network operations, manage socket lifetimes correctly
+- Use `JSC.Codegen` correctly to generate necessary binding code
+
+## Related Files
+
+- `src/bun.js/bindings/BunObject+exports.h`: Registration of getters and functions
+- `src/bun.js/api/BunObject.zig`: Implementation of getters and object creation
+- `src/bun.js/api/BunObject.classes.ts`: Class definitions
+- `.cursor/rules/zig-javascriptcore-classes.mdc`: More details on class bindings
+
+## Additional Resources
+
+For more detailed information on specific topics:
+
+- See `zig-javascriptcore-classes.mdc` for details on creating JS class bindings
+- Review existing modules like `valkey`, `sqlite`, or `s3` for real-world examples

.cursor/rules/writing-tests.mdc

@@ -0,0 +1,91 @@
+---
+description: Writing tests for Bun
+globs: 
+---
+# Writing tests for Bun
+
+## Where tests are found
+
+You'll find all of Bun's tests in the `test/` directory.
+
+* `test/`
+  * `cli/` - CLI command tests, like `bun install` or `bun init`
+  * `js/` - JavaScript & TypeScript tests
+    * `bun/` - `Bun` APIs tests, separated by category, for example: `glob/` for `Bun.Glob` tests
+    * `node/` - Node.js module tests, separated by module, for example: `assert/` for `node:assert` tests
+      * `test/` - Vendored Node.js tests, taken from the Node.js repository (does not conform to Bun's test style)
+    * `web/` - Web API tests, separated by category, for example: `fetch/` for `Request` and `Response` tests
+    * `third_party/` - npm package tests, to validate that basic usage works in Bun
+  * `napi/` - N-API tests
+  * `v8/` - V8 C++ API tests
+  * `bundler/` - Bundler, transpiler, CSS, and `bun build` tests
+  * `regression/issue/[number]` - Regression tests, always make one when fixing a particular issue
+
+## How tests are written
+
+Bun's tests are written as JavaScript and TypeScript files with the Jest-style APIs, like `test`, `describe`, and `expect`. They are tested using Bun's own test runner, `bun test`. 
+
+```js
+import { describe, test, expect } from "bun:test";
+import assert, { AssertionError } from "assert";
+
+describe("assert(expr)", () => {
+  test.each([true, 1, "foo"])(`assert(%p) does not throw`, expr => {
+    expect(() => assert(expr)).not.toThrow();
+  });
+
+  test.each([false, 0, "", null, undefined])(`assert(%p) throws`, expr => {
+    expect(() => assert(expr)).toThrow(AssertionError);
+  });
+});
+```
+
+## Testing conventions
+
+* See `test/harness.ts` for common test utilities and helpers
+* Be rigorous and test for edge-cases and unexpected inputs
+* Use data-driven tests, e.g. `test.each`, to reduce boilerplate when possible
+* When you need to test Bun as a CLI, use the following pattern:
+
+```js
+import { test, expect } from "bun:test";
+import { spawn } from "bun";
+import { bunExe, bunEnv } from "harness";
+
+test("bun --version", async () => {
+  const { exited, stdout: stdoutStream, stderr: stderrStream } = spawn({
+    cmd: [bunExe(), "--version"],
+    env: bunEnv,
+    stdout: "pipe",
+    stderr: "pipe",
+  });
+  const [ exitCode, stdout, stderr ] = await Promise.all([
+    exited,
+    new Response(stdoutStream).text(),
+    new Response(stderrStream).text(),
+  ]);
+  expect({ exitCode, stdout, stderr }).toMatchObject({
+    exitCode: 0,
+    stdout: expect.stringContaining(Bun.version),
+    stderr: "",
+  });
+});
+```
+
+## Before writing a test
+
+* If you are fixing a bug, write the test first and make sure it fails (as expected) with the canary version of Bun
+* If you are fixing a Node.js compatibility bug, create a throw-away snippet of code and test that it works as you expect in Node.js, then that it fails (as expected) with the canary version of Bun
+* When the expected behaviour is ambigious, defer to matching what happens in Node.js
+* Always attempt to find related tests in an existing test file before creating a new test file
+
+
+
+
+
+
+
+
+
+
+

.cursor/rules/zig-javascriptcore-classes.mdc

@@ -0,0 +1,509 @@
+---
+description: How Zig works with JavaScriptCore bindings generator
+globs:
+alwaysApply: false
+---
+
+# Bun's JavaScriptCore Class Bindings Generator
+
+This document explains how Bun's class bindings generator works to bridge Zig and JavaScript code through JavaScriptCore (JSC).
+
+## Architecture Overview
+
+Bun's binding system creates a seamless bridge between JavaScript and Zig, allowing Zig implementations to be exposed as JavaScript classes. The system has several key components:
+
+1. **Zig Implementation** (.zig files)
+2. **JavaScript Interface Definition** (.classes.ts files)
+3. **Generated Code** (C++/Zig files that connect everything)
+
+## Class Definition Files
+
+### JavaScript Interface (.classes.ts)
+
+The `.classes.ts` files define the JavaScript API using a declarative approach:
+
+```typescript
+// Example: encoding.classes.ts
+define({
+  name: "TextDecoder",
+  constructor: true,
+  JSType: "object",
+  finalize: true,
+  proto: {
+    decode: {
+      // Function definition
+      args: 1,
+    },
+    encoding: {
+      // Getter with caching
+      getter: true,
+      cache: true,
+    },
+    fatal: {
+      // Read-only property
+      getter: true,
+    },
+    ignoreBOM: {
+      // Read-only property
+      getter: true,
+    },
+  },
+});
+```
+
+Each class definition specifies:
+
+- The class name
+- Whether it has a constructor
+- JavaScript type (object, function, etc.)
+- Properties and methods in the `proto` field
+- Caching strategy for properties
+- Finalization requirements
+
+### Zig Implementation (.zig)
+
+The Zig files implement the native functionality:
+
+```zig
+// Example: TextDecoder.zig
+pub const TextDecoder = struct {
+    // Expose generated bindings as `js` namespace with trait conversion methods
+    pub const js = JSC.Codegen.JSTextDecoder;
+    pub const toJS = js.toJS;
+    pub const fromJS = js.fromJS;
+    pub const fromJSDirect = js.fromJSDirect;
+
+    // Internal state
+    encoding: []const u8,
+    fatal: bool,
+    ignoreBOM: bool,
+
+    // Constructor implementation - note use of globalObject
+    pub fn constructor(
+        globalObject: *JSGlobalObject,
+        callFrame: *JSC.CallFrame,
+    ) bun.JSError!*TextDecoder {
+        // Implementation
+
+        return bun.new(TextDecoder, .{
+            // Fields
+        });
+    }
+
+    // Prototype methods - note return type includes JSError
+    pub fn decode(
+        this: *TextDecoder,
+        globalObject: *JSGlobalObject,
+        callFrame: *JSC.CallFrame,
+    ) bun.JSError!JSC.JSValue {
+        // Implementation
+    }
+
+    // Getters
+    pub fn getEncoding(this: *TextDecoder, globalObject: *JSGlobalObject) JSC.JSValue {
+        return JSC.JSValue.createStringFromUTF8(globalObject, this.encoding);
+    }
+
+    pub fn getFatal(this: *TextDecoder, globalObject: *JSGlobalObject) JSC.JSValue {
+        return JSC.JSValue.jsBoolean(this.fatal);
+    }
+
+    // Cleanup - note standard pattern of using deinit/deref
+    fn deinit(this: *TextDecoder) void {
+        // Release any retained resources
+        // Free the pointer at the end.
+        bun.destroy(this);
+    }
+
+    // Finalize - called by JS garbage collector. This should call deinit, or deref if reference counted.
+    pub fn finalize(this: *TextDecoder) void {
+        this.deinit();
+    }
+};
+```
+
+Key components in the Zig file:
+
+- The struct containing native state
+- `pub const js = JSC.Codegen.JS<ClassName>` to include generated code
+- Constructor and methods using `bun.JSError!JSValue` return type for proper error handling
+- Consistent use of `globalObject` parameter name instead of `ctx`
+- Methods matching the JavaScript interface
+- Getters/setters for properties
+- Proper resource cleanup pattern with `deinit()` and `finalize()`
+- Update `src/bun.js/bindings/generated_classes_list.zig` to include the new class
+
+## Code Generation System
+
+The binding generator produces C++ code that connects JavaScript and Zig:
+
+1. **JSC Class Structure**: Creates C++ classes for the JS object, prototype, and constructor
+2. **Memory Management**: Handles GC integration through JSC's WriteBarrier
+3. **Method Binding**: Connects JS function calls to Zig implementations
+4. **Type Conversion**: Converts between JS values and Zig types
+5. **Property Caching**: Implements the caching system for properties
+
+The generated C++ code includes:
+
+- A JSC wrapper class (`JSTextDecoder`)
+- A prototype class (`JSTextDecoderPrototype`)
+- A constructor function (`JSTextDecoderConstructor`)
+- Function bindings (`TextDecoderPrototype__decodeCallback`)
+- Property getters/setters (`TextDecoderPrototype__encodingGetterWrap`)
+
+## CallFrame Access
+
+The `CallFrame` object provides access to JavaScript execution context:
+
+```zig
+pub fn decode(
+    this: *TextDecoder,
+    globalObject: *JSGlobalObject,
+    callFrame: *JSC.CallFrame
+) bun.JSError!JSC.JSValue {
+    // Get arguments
+    const input = callFrame.argument(0);
+    const options = callFrame.argument(1);
+
+    // Get this value
+    const thisValue = callFrame.thisValue();
+
+    // Implementation with error handling
+    if (input.isUndefinedOrNull()) {
+        return globalObject.throw("Input cannot be null or undefined", .{});
+    }
+
+    // Return value or throw error
+    return JSC.JSValue.jsString(globalObject, "result");
+}
+```
+
+CallFrame methods include:
+
+- `argument(i)`: Get the i-th argument
+- `argumentCount()`: Get the number of arguments
+- `thisValue()`: Get the `this` value
+- `callee()`: Get the function being called
+
+## Property Caching and GC-Owned Values
+
+The `cache: true` option in property definitions enables JSC's WriteBarrier to efficiently store values:
+
+```typescript
+encoding: {
+  getter: true,
+  cache: true, // Enable caching
+}
+```
+
+### C++ Implementation
+
+In the generated C++ code, caching uses JSC's WriteBarrier:
+
+```cpp
+JSC_DEFINE_CUSTOM_GETTER(TextDecoderPrototype__encodingGetterWrap, (...)) {
+    auto& vm = JSC::getVM(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    auto throwScope = DECLARE_THROW_SCOPE(vm);
+    JSTextDecoder* thisObject = jsCast<JSTextDecoder*>(JSValue::decode(encodedThisValue));
+    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+
+    // Check for cached value and return if present
+    if (JSValue cachedValue = thisObject->m_encoding.get())
+        return JSValue::encode(cachedValue);
+
+    // Get value from Zig implementation
+    JSC::JSValue result = JSC::JSValue::decode(
+        TextDecoderPrototype__getEncoding(thisObject->wrapped(), globalObject)
+    );
+    RETURN_IF_EXCEPTION(throwScope, {});
+
+    // Store in cache for future access
+    thisObject->m_encoding.set(vm, thisObject, result);
+    RELEASE_AND_RETURN(throwScope, JSValue::encode(result));
+}
+```
+
+### Zig Accessor Functions
+
+For each cached property, the generator creates Zig accessor functions that allow Zig code to work with these GC-owned values:
+
+```zig
+// External function declarations
+extern fn TextDecoderPrototype__encodingSetCachedValue(JSC.JSValue, *JSC.JSGlobalObject, JSC.JSValue) callconv(JSC.conv) void;
+extern fn TextDecoderPrototype__encodingGetCachedValue(JSC.JSValue) callconv(JSC.conv) JSC.JSValue;
+
+/// `TextDecoder.encoding` setter
+/// This value will be visited by the garbage collector.
+pub fn encodingSetCached(thisValue: JSC.JSValue, globalObject: *JSC.JSGlobalObject, value: JSC.JSValue) void {
+    JSC.markBinding(@src());
+    TextDecoderPrototype__encodingSetCachedValue(thisValue, globalObject, value);
+}
+
+/// `TextDecoder.encoding` getter
+/// This value will be visited by the garbage collector.
+pub fn encodingGetCached(thisValue: JSC.JSValue) ?JSC.JSValue {
+    JSC.markBinding(@src());
+    const result = TextDecoderPrototype__encodingGetCachedValue(thisValue);
+    if (result == .zero)
+        return null;
+
+    return result;
+}
+```
+
+### Benefits of GC-Owned Values
+
+This system provides several key benefits:
+
+1. **Automatic Memory Management**: The JavaScriptCore GC tracks and manages these values
+2. **Proper Garbage Collection**: The WriteBarrier ensures values are properly visited during GC
+3. **Consistent Access**: Zig code can easily get/set these cached JS values
+4. **Performance**: Cached values avoid repeated computation or serialization
+
+### Use Cases
+
+GC-owned cached values are particularly useful for:
+
+1. **Computed Properties**: Store expensive computation results
+2. **Lazily Created Objects**: Create objects only when needed, then cache them
+3. **References to Other Objects**: Store references to other JS objects that need GC tracking
+4. **Memoization**: Cache results based on input parameters
+
+The WriteBarrier mechanism ensures that any JS values stored in this way are properly tracked by the garbage collector.
+
+## Memory Management and Finalization
+
+The binding system handles memory management across the JavaScript/Zig boundary:
+
+1. **Object Creation**: JavaScript `new TextDecoder()` creates both a JS wrapper and a Zig struct
+2. **Reference Tracking**: JSC's GC tracks all JS references to the object
+3. **Finalization**: When the JS object is collected, the finalizer releases Zig resources
+
+Bun uses a consistent pattern for resource cleanup:
+
+```zig
+// Resource cleanup method - separate from finalization
+pub fn deinit(this: *TextDecoder) void {
+    // Release resources like strings
+    this._encoding.deref(); // String deref pattern
+
+    // Free any buffers
+    if (this.buffer) |buffer| {
+        bun.default_allocator.free(buffer);
+    }
+}
+
+// Called by the GC when object is collected
+pub fn finalize(this: *TextDecoder) void {
+    JSC.markBinding(@src()); // For debugging
+    this.deinit(); // Clean up resources
+    bun.default_allocator.destroy(this); // Free the object itself
+}
+```
+
+Some objects that hold references to other JS objects use `.deref()` instead:
+
+```zig
+pub fn finalize(this: *SocketAddress) void {
+    JSC.markBinding(@src());
+    this._presentation.deref(); // Release references
+    this.destroy();
+}
+```
+
+## Error Handling with JSError
+
+Bun uses `bun.JSError!JSValue` return type for proper error handling:
+
+```zig
+pub fn decode(
+    this: *TextDecoder,
+    globalObject: *JSGlobalObject,
+    callFrame: *JSC.CallFrame
+) bun.JSError!JSC.JSValue {
+    // Throwing an error
+    if (callFrame.argumentCount() < 1) {
+        return globalObject.throw("Missing required argument", .{});
+    }
+
+    // Or returning a success value
+    return JSC.JSValue.jsString(globalObject, "Success!");
+}
+```
+
+This pattern allows Zig functions to:
+
+1. Return JavaScript values on success
+2. Throw JavaScript exceptions on error
+3. Propagate errors automatically through the call stack
+
+## Type Safety and Error Handling
+
+The binding system includes robust error handling:
+
+```cpp
+// Example of type checking in generated code
+JSTextDecoder* thisObject = jsDynamicCast<JSTextDecoder*>(callFrame->thisValue());
+if (UNLIKELY(!thisObject)) {
+    scope.throwException(lexicalGlobalObject,
+        Bun::createInvalidThisError(lexicalGlobalObject, callFrame->thisValue(), "TextDecoder"_s));
+    return {};
+}
+```
+
+## Prototypal Inheritance
+
+The binding system creates proper JavaScript prototype chains:
+
+1. **Constructor**: JSTextDecoderConstructor with standard .prototype property
+2. **Prototype**: JSTextDecoderPrototype with methods and properties
+3. **Instances**: Each JSTextDecoder instance with **proto** pointing to prototype
+
+This ensures JavaScript inheritance works as expected:
+
+```cpp
+// From generated code
+void JSTextDecoderConstructor::finishCreation(VM& vm, JSC::JSGlobalObject* globalObject, JSTextDecoderPrototype* prototype)
+{
+    Base::finishCreation(vm, 0, "TextDecoder"_s, PropertyAdditionMode::WithoutStructureTransition);
+
+    // Set up the prototype chain
+    putDirectWithoutTransition(vm, vm.propertyNames->prototype, prototype, PropertyAttribute::DontEnum | PropertyAttribute::DontDelete | PropertyAttribute::ReadOnly);
+    ASSERT(inherits(info()));
+}
+```
+
+## Performance Considerations
+
+The binding system is optimized for performance:
+
+1. **Direct Pointer Access**: JavaScript objects maintain a direct pointer to Zig objects
+2. **Property Caching**: WriteBarrier caching avoids repeated native calls for stable properties
+3. **Memory Management**: JSC garbage collection integrated with Zig memory management
+4. **Type Conversion**: Fast paths for common JavaScript/Zig type conversions
+
+## Creating a New Class Binding
+
+To create a new class binding in Bun:
+
+1. **Define the class interface** in a `.classes.ts` file:
+
+   ```typescript
+   define({
+     name: "MyClass",
+     constructor: true,
+     finalize: true,
+     proto: {
+       myMethod: {
+         args: 1,
+       },
+       myProperty: {
+         getter: true,
+         cache: true,
+       },
+     },
+   });
+   ```
+
+2. **Implement the native functionality** in a `.zig` file:
+
+   ```zig
+   pub const MyClass = struct {
+       // Generated bindings
+       pub const js = JSC.Codegen.JSMyClass;
+       pub const toJS = js.toJS;
+       pub const fromJS = js.fromJS;
+       pub const fromJSDirect = js.fromJSDirect;
+
+       // State
+       value: []const u8,
+
+       pub const new = bun.TrivialNew(@This());
+
+       // Constructor
+       pub fn constructor(
+           globalObject: *JSGlobalObject,
+           callFrame: *JSC.CallFrame,
+       ) bun.JSError!*MyClass {
+           const arg = callFrame.argument(0);
+           // Implementation
+       }
+
+       // Method
+       pub fn myMethod(
+           this: *MyClass,
+           globalObject: *JSGlobalObject,
+           callFrame: *JSC.CallFrame,
+       ) bun.JSError!JSC.JSValue {
+           // Implementation
+       }
+
+       // Getter
+       pub fn getMyProperty(this: *MyClass, globalObject: *JSGlobalObject) JSC.JSValue {
+           return JSC.JSValue.jsString(globalObject, this.value);
+       }
+
+       // Resource cleanup
+       pub fn deinit(this: *MyClass) void {
+           // Clean up resources
+       }
+
+       pub fn finalize(this: *MyClass) void {
+           this.deinit();
+           bun.destroy(this);
+       }
+   };
+   ```
+
+3. **The binding generator** creates all necessary C++ and Zig glue code to connect JavaScript and Zig, including:
+   - C++ class definitions
+   - Method and property bindings
+   - Memory management utilities
+   - GC integration code
+
+## Generated Code Structure
+
+The binding generator produces several components:
+
+### 1. C++ Classes
+
+For each Zig class, the system generates:
+
+- **JS<Class>**: Main wrapper that holds a pointer to the Zig object (`JSTextDecoder`)
+- **JS<Class>Prototype**: Contains methods and properties (`JSTextDecoderPrototype`)
+- **JS<Class>Constructor**: Implementation of the JavaScript constructor (`JSTextDecoderConstructor`)
+
+### 2. C++ Methods and Properties
+
+- **Method Callbacks**: `TextDecoderPrototype__decodeCallback`
+- **Property Getters/Setters**: `TextDecoderPrototype__encodingGetterWrap`
+- **Initialization Functions**: `finishCreation` methods for setting up the class
+
+### 3. Zig Bindings
+
+- **External Function Declarations**:
+
+  ```zig
+  extern fn TextDecoderPrototype__decode(*TextDecoder, *JSC.JSGlobalObject, *JSC.CallFrame) callconv(JSC.conv) JSC.EncodedJSValue;
+  ```
+
+- **Cached Value Accessors**:
+
+  ```zig
+  pub fn encodingGetCached(thisValue: JSC.JSValue) ?JSC.JSValue { ... }
+  pub fn encodingSetCached(thisValue: JSC.JSValue, globalObject: *JSC.JSGlobalObject, value: JSC.JSValue) void { ... }
+  ```
+
+- **Constructor Helpers**:
+  ```zig
+  pub fn create(globalObject: *JSC.JSGlobalObject) bun.JSError!JSC.JSValue { ... }
+  ```
+
+### 4. GC Integration
+
+- **Memory Cost Calculation**: `estimatedSize` method
+- **Child Visitor Methods**: `visitChildrenImpl` and `visitAdditionalChildren`
+- **Heap Analysis**: `analyzeHeap` for debugging memory issues
+
+This architecture makes it possible to implement high-performance native functionality in Zig while exposing a clean, idiomatic JavaScript API to users.

.cursorignore

@@ -0,0 +1,7 @@
+# Add directories or file patterns to ignore during indexing (e.g. foo/ or *.csv)
+bench
+vendor
+*-fixture.{js,ts}
+zig-cache
+packages/bun-uws/fuzzing
+build

.devcontainer/devcontainer.json

@@ -1,65 +0,0 @@
-// For format details, see https://aka.ms/devcontainer.json. For config options, see the README at:
-// https://github.com/microsoft/vscode-dev-containers/tree/v0.209.6/containers/docker-existing-dockerfile
-{
-  "name": "bun (Ubuntu)",
-
-  // Sets the run context to one level up instead of the .devcontainer folder.
-  "context": "..",
-
-  // Update the 'dockerFile' property if you aren't using the standard 'Dockerfile' filename.
-  "dockerFile": "../Dockerfile",
-
-  // Set *default* container specific settings.json values on container create.
-  "settings": {
-    "terminal.integrated.shell.linux": "/bin/zsh",
-    "zigLanguageClient.path": "/home/ubuntu/zls/zig-out/bin/zls",
-    "zig.zigPath": "/build/zig/zig",
-    "editor.defaultFormatter": "esbenp.prettier-vscode"
-  },
-
-  // Add the IDs of extensions you want installed when the container is created.
-  "extensions": [
-    "AugusteRame.zls-vscode",
-    "ms-vscode.cpptools",
-    "/home/ubuntu/vscode-zig.vsix",
-    "vadimcn.vscode-lldb",
-    "esbenp.prettier-vscode",
-    "xaver.clang-format"
-  ],
-  "postCreateCommand": "cd /build/bun; bash /build/getting-started.sh; zsh",
-
-  "build": {
-    "target": "bun.devcontainer",
-    "cacheFrom": ["bun.devcontainer:latest"],
-    "args": {}
-  },
-  "runArgs": [
-    "--ulimit",
-    "memlock=-1:-1",
-    "--ulimit",
-    "nofile=65536:65536",
-    "--cap-add=SYS_PTRACE",
-    "--security-opt",
-    "seccomp=unconfined"
-  ],
-  "workspaceMount": "source=bun,target=/build/bun,type=volume",
-  "workspaceFolder": "/build/bun",
-  "mounts": [
-    "source=bun-install,target=/home/ubuntu/.bun,type=volume",
-    "source=bun-config,target=/home/ubuntu/.config,type=volume"
-  ],
-
-  // Use 'forwardPorts' to make a list of ports inside the container available locally.
-  "forwardPorts": [3000, 8081, 8080]
-
-  // Uncomment the next line to run commands after the container is created - for example installing curl.
-  // "postCreateCommand": "apt-get update && apt-get install -y curl",
-
-  // Uncomment when using a ptrace-based debugger like C++, Go, and Rust
-
-  // Uncomment to use the Docker CLI from inside the container. See https://aka.ms/vscode-remote/samples/docker-from-docker.
-  // "mounts": [ "source=/var/run/docker.sock,target=/var/run/docker.sock,type=bind" ],
-
-  // Uncomment to connect as a non-root user if you've added one. See https://aka.ms/vscode-remote/containers/non-root.
-  // "remoteUser": "vscode"
-}

.devcontainer/limits.conf

@@ -1,61 +0,0 @@
-# /etc/security/limits.conf
-#
-#Each line describes a limit for a user in the form:
-#
-#<domain>        <type>  <item>  <value>
-#
-#Where:
-#<domain> can be:
-#        - a user name
-#        - a group name, with @group syntax
-#        - the wildcard *, for default entry
-#        - the wildcard %, can be also used with %group syntax,
-#                 for maxlogin limit
-#        - NOTE: group and wildcard limits are not applied to root.
-#          To apply a limit to the root user, <domain> must be
-#          the literal username root.
-#
-#<type> can have the two values:
-#        - "soft" for enforcing the soft limits
-#        - "hard" for enforcing hard limits
-#
-#<item> can be one of the following:
-#        - core - limits the core file size (KB)
-#        - data - max data size (KB)
-#        - fsize - maximum filesize (KB)
-#        - memlock - max locked-in-memory address space (KB)
-#        - nofile - max number of open file descriptors
-#        - rss - max resident set size (KB)
-#        - stack - max stack size (KB)
-#        - cpu - max CPU time (MIN)
-#        - nproc - max number of processes
-#        - as - address space limit (KB)
-#        - maxlogins - max number of logins for this user
-#        - maxsyslogins - max number of logins on the system
-#        - priority - the priority to run user process with
-#        - locks - max number of file locks the user can hold
-#        - sigpending - max number of pending signals
-#        - msgqueue - max memory used by POSIX message queues (bytes)
-#        - nice - max nice priority allowed to raise to values: [-20, 19]
-#        - rtprio - max realtime priority
-#        - chroot - change root to directory (Debian-specific)
-#
-#<domain>      <type>  <item>         <value>
-#
-
-* soft memlock 33554432
-* hard memlock 33554432
-* soft nofile 33554432
-* hard nofile 33554432
-
-#*               soft    core            0
-#root            hard    core            100000
-#*               hard    rss             10000
-#@student        hard    nproc           20
-#@faculty        soft    nproc           20
-#@faculty        hard    nproc           50
-#ftp             hard    nproc           0
-#ftp             -       chroot          /ftp
-#@student        -       maxlogins       4
-
-# End of file

.devcontainer/scripts/common-debian.sh

@@ -1,445 +0,0 @@
-#!/usr/bin/env bash
-#-------------------------------------------------------------------------------------------------------------
-# Copyright (c) Microsoft Corporation. All rights reserved.
-# Licensed under the MIT License. See https://go.microsoft.com/fwlink/?linkid=2090316 for license information.
-#-------------------------------------------------------------------------------------------------------------
-#
-# Docs: https://github.com/microsoft/vscode-dev-containers/blob/main/script-library/docs/common.md
-# Maintainer: The VS Code and Codespaces Teams
-#
-# Syntax: ./common-debian.sh [install zsh flag] [username] [user UID] [user GID] [upgrade packages flag] [install Oh My Zsh! flag] [Add non-free packages]
-
-set -e
-
-INSTALL_ZSH=${1:-"true"}
-USERNAME=${2:-"automatic"}
-USER_UID=${3:-"automatic"}
-USER_GID=${4:-"automatic"}
-UPGRADE_PACKAGES=${5:-"true"}
-INSTALL_OH_MYS=${6:-"true"}
-ADD_NON_FREE_PACKAGES=${7:-"false"}
-SCRIPT_DIR="$(cd $(dirname "${BASH_SOURCE[0]}") && pwd)"
-MARKER_FILE="/usr/local/etc/vscode-dev-containers/common"
-
-if [ "$(id -u)" -ne 0 ]; then
-    echo -e 'Script must be run as root. Use sudo, su, or add "USER root" to your Dockerfile before running this script.'
-    exit 1
-fi
-
-# Ensure that login shells get the correct path if the user updated the PATH using ENV.
-rm -f /etc/profile.d/00-restore-env.sh
-echo "export PATH=${PATH//$(sh -lc 'echo $PATH')/\$PATH}" >/etc/profile.d/00-restore-env.sh
-chmod +x /etc/profile.d/00-restore-env.sh
-
-# If in automatic mode, determine if a user already exists, if not use vscode
-if [ "${USERNAME}" = "auto" ] || [ "${USERNAME}" = "automatic" ]; then
-    USERNAME=""
-    POSSIBLE_USERS=("vscode" "node" "codespace" "$(awk -v val=1000 -F ":" '$3==val{print $1}' /etc/passwd)")
-    for CURRENT_USER in ${POSSIBLE_USERS[@]}; do
-        if id -u ${CURRENT_USER} >/dev/null 2>&1; then
-            USERNAME=${CURRENT_USER}
-            break
-        fi
-    done
-    if [ "${USERNAME}" = "" ]; then
-        USERNAME=vscode
-    fi
-elif [ "${USERNAME}" = "none" ]; then
-    USERNAME=root
-    USER_UID=0
-    USER_GID=0
-fi
-
-# Load markers to see which steps have already run
-if [ -f "${MARKER_FILE}" ]; then
-    echo "Marker file found:"
-    cat "${MARKER_FILE}"
-    source "${MARKER_FILE}"
-fi
-
-# Ensure apt is in non-interactive to avoid prompts
-export DEBIAN_FRONTEND=noninteractive
-
-# Function to call apt-get if needed
-apt_get_update_if_needed() {
-    if [ ! -d "/var/lib/apt/lists" ] || [ "$(ls /var/lib/apt/lists/ | wc -l)" = "0" ]; then
-        echo "Running apt-get update..."
-        apt-get update
-    else
-        echo "Skipping apt-get update."
-    fi
-}
-
-# Run install apt-utils to avoid debconf warning then verify presence of other common developer tools and dependencies
-if [ "${PACKAGES_ALREADY_INSTALLED}" != "true" ]; then
-
-    package_list="apt-utils \
-        openssh-client \
-        gnupg2 \
-        dirmngr \
-        iproute2 \
-        procps \
-        lsof \
-        htop \
-        net-tools \
-        psmisc \
-        curl \
-        wget \
-        rsync \
-        ca-certificates \
-        unzip \
-        zip \
-        nano \
-        vim-tiny \
-        less \
-        jq \
-        lsb-release \
-        apt-transport-https \
-        dialog \
-        libc6 \
-        libgcc1 \
-        libkrb5-3 \
-        libgssapi-krb5-2 \
-        libicu[0-9][0-9] \
-        liblttng-ust0 \
-        libstdc++6 \
-        zlib1g \
-        locales \
-        sudo \
-        ncdu \
-        man-db \
-        strace \
-        manpages \
-        manpages-dev \
-        init-system-helpers"
-
-    # Needed for adding manpages-posix and manpages-posix-dev which are non-free packages in Debian
-    if [ "${ADD_NON_FREE_PACKAGES}" = "true" ]; then
-        # Bring in variables from /etc/os-release like VERSION_CODENAME
-        . /etc/os-release
-        sed -i -E "s/deb http:\/\/(deb|httpredir)\.debian\.org\/debian ${VERSION_CODENAME} main/deb http:\/\/\1\.debian\.org\/debian ${VERSION_CODENAME} main contrib non-free/" /etc/apt/sources.list
-        sed -i -E "s/deb-src http:\/\/(deb|httredir)\.debian\.org\/debian ${VERSION_CODENAME} main/deb http:\/\/\1\.debian\.org\/debian ${VERSION_CODENAME} main contrib non-free/" /etc/apt/sources.list
-        sed -i -E "s/deb http:\/\/(deb|httpredir)\.debian\.org\/debian ${VERSION_CODENAME}-updates main/deb http:\/\/\1\.debian\.org\/debian ${VERSION_CODENAME}-updates main contrib non-free/" /etc/apt/sources.list
-        sed -i -E "s/deb-src http:\/\/(deb|httpredir)\.debian\.org\/debian ${VERSION_CODENAME}-updates main/deb http:\/\/\1\.debian\.org\/debian ${VERSION_CODENAME}-updates main contrib non-free/" /etc/apt/sources.list
-        sed -i "s/deb http:\/\/security\.debian\.org\/debian-security ${VERSION_CODENAME}\/updates main/deb http:\/\/security\.debian\.org\/debian-security ${VERSION_CODENAME}\/updates main contrib non-free/" /etc/apt/sources.list
-        sed -i "s/deb-src http:\/\/security\.debian\.org\/debian-security ${VERSION_CODENAME}\/updates main/deb http:\/\/security\.debian\.org\/debian-security ${VERSION_CODENAME}\/updates main contrib non-free/" /etc/apt/sources.list
-        sed -i "s/deb http:\/\/deb\.debian\.org\/debian ${VERSION_CODENAME}-backports main/deb http:\/\/deb\.debian\.org\/debian ${VERSION_CODENAME}-backports main contrib non-free/" /etc/apt/sources.list
-        sed -i "s/deb-src http:\/\/deb\.debian\.org\/debian ${VERSION_CODENAME}-backports main/deb http:\/\/deb\.debian\.org\/debian ${VERSION_CODENAME}-backports main contrib non-free/" /etc/apt/sources.list
-        # Handle bullseye location for security https://www.debian.org/releases/bullseye/amd64/release-notes/ch-information.en.html
-        sed -i "s/deb http:\/\/security\.debian\.org\/debian-security ${VERSION_CODENAME}-security main/deb http:\/\/security\.debian\.org\/debian-security ${VERSION_CODENAME}-security main contrib non-free/" /etc/apt/sources.list
-        sed -i "s/deb-src http:\/\/security\.debian\.org\/debian-security ${VERSION_CODENAME}-security main/deb http:\/\/security\.debian\.org\/debian-security ${VERSION_CODENAME}-security main contrib non-free/" /etc/apt/sources.list
-        echo "Running apt-get update..."
-        apt-get update
-        package_list="${package_list} manpages-posix manpages-posix-dev"
-    else
-        apt_get_update_if_needed
-    fi
-
-    # Install libssl1.1 if available
-    if [[ ! -z $(apt-cache --names-only search ^libssl1.1$) ]]; then
-        package_list="${package_list}       libssl1.1"
-    fi
-
-    # Install appropriate version of libssl1.0.x if available
-    libssl_package=$(dpkg-query -f '${db:Status-Abbrev}\t${binary:Package}\n' -W 'libssl1\.0\.?' 2>&1 || echo '')
-    if [ "$(echo "$LIlibssl_packageBSSL" | grep -o 'libssl1\.0\.[0-9]:' | uniq | sort | wc -l)" -eq 0 ]; then
-        if [[ ! -z $(apt-cache --names-only search ^libssl1.0.2$) ]]; then
-            # Debian 9
-            package_list="${package_list}       libssl1.0.2"
-        elif [[ ! -z $(apt-cache --names-only search ^libssl1.0.0$) ]]; then
-            # Ubuntu 18.04, 16.04, earlier
-            package_list="${package_list}       libssl1.0.0"
-        fi
-    fi
-
-    echo "Packages to verify are installed: ${package_list}"
-    apt-get -y install --no-install-recommends ${package_list} 2> >(grep -v 'debconf: delaying package configuration, since apt-utils is not installed' >&2)
-
-    # Install git if not already installed (may be more recent than distro version)
-    if ! type git >/dev/null 2>&1; then
-        apt-get -y install --no-install-recommends git
-    fi
-
-    PACKAGES_ALREADY_INSTALLED="true"
-fi
-
-# Get to latest versions of all packages
-if [ "${UPGRADE_PACKAGES}" = "true" ]; then
-    apt_get_update_if_needed
-    apt-get -y upgrade --no-install-recommends
-    apt-get autoremove -y
-fi
-
-# Ensure at least the en_US.UTF-8 UTF-8 locale is available.
-# Common need for both applications and things like the agnoster ZSH theme.
-if [ "${LOCALE_ALREADY_SET}" != "true" ] && ! grep -o -E '^\s*en_US.UTF-8\s+UTF-8' /etc/locale.gen >/dev/null; then
-    echo "en_US.UTF-8 UTF-8" >>/etc/locale.gen
-    locale-gen
-    LOCALE_ALREADY_SET="true"
-fi
-
-# Create or update a non-root user to match UID/GID.
-group_name="${USERNAME}"
-if id -u ${USERNAME} >/dev/null 2>&1; then
-    # User exists, update if needed
-    if [ "${USER_GID}" != "automatic" ] && [ "$USER_GID" != "$(id -g $USERNAME)" ]; then
-        group_name="$(id -gn $USERNAME)"
-        groupmod --gid $USER_GID ${group_name}
-        usermod --gid $USER_GID $USERNAME
-    fi
-    if [ "${USER_UID}" != "automatic" ] && [ "$USER_UID" != "$(id -u $USERNAME)" ]; then
-        usermod --uid $USER_UID $USERNAME
-    fi
-else
-    # Create user
-    if [ "${USER_GID}" = "automatic" ]; then
-        groupadd $USERNAME
-    else
-        groupadd --gid $USER_GID $USERNAME
-    fi
-    if [ "${USER_UID}" = "automatic" ]; then
-        useradd -s /bin/bash --gid $USERNAME -m $USERNAME
-    else
-        useradd -s /bin/bash --uid $USER_UID --gid $USERNAME -m $USERNAME
-    fi
-fi
-
-# Add add sudo support for non-root user
-if [ "${USERNAME}" != "root" ] && [ "${EXISTING_NON_ROOT_USER}" != "${USERNAME}" ]; then
-    echo $USERNAME ALL=\(root\) NOPASSWD:ALL >/etc/sudoers.d/$USERNAME
-    chmod 0440 /etc/sudoers.d/$USERNAME
-    EXISTING_NON_ROOT_USER="${USERNAME}"
-fi
-
-# ** Shell customization section **
-if [ "${USERNAME}" = "root" ]; then
-    user_rc_path="/root"
-else
-    user_rc_path="/home/${USERNAME}"
-fi
-
-# Restore user .bashrc defaults from skeleton file if it doesn't exist or is empty
-if [ ! -f "${user_rc_path}/.bashrc" ] || [ ! -s "${user_rc_path}/.bashrc" ]; then
-    cp /etc/skel/.bashrc "${user_rc_path}/.bashrc"
-fi
-
-# Restore user .profile defaults from skeleton file if it doesn't exist or is empty
-if [ ! -f "${user_rc_path}/.profile" ] || [ ! -s "${user_rc_path}/.profile" ]; then
-    cp /etc/skel/.profile "${user_rc_path}/.profile"
-fi
-
-# .bashrc/.zshrc snippet
-rc_snippet="$(
-    cat <<'EOF'
-if [ -z "${USER}" ]; then export USER=$(whoami); fi
-if [[ "${PATH}" != *"$HOME/.local/bin"* ]]; then export PATH="${PATH}:$HOME/.local/bin"; fi
-# Display optional first run image specific notice if configured and terminal is interactive
-if [ -t 1 ] && [[ "${TERM_PROGRAM}" = "vscode" || "${TERM_PROGRAM}" = "codespaces" ]] && [ ! -f "$HOME/.config/vscode-dev-containers/first-run-notice-already-displayed" ]; then
-    if [ -f "/usr/local/etc/vscode-dev-containers/first-run-notice.txt" ]; then
-        cat "/usr/local/etc/vscode-dev-containers/first-run-notice.txt"
-    elif [ -f "/workspaces/.codespaces/shared/first-run-notice.txt" ]; then
-        cat "/workspaces/.codespaces/shared/first-run-notice.txt"
-    fi
-    mkdir -p "$HOME/.config/vscode-dev-containers"
-    # Mark first run notice as displayed after 10s to avoid problems with fast terminal refreshes hiding it
-    ((sleep 10s; touch "$HOME/.config/vscode-dev-containers/first-run-notice-already-displayed") &)
-fi
-# Set the default git editor if not already set
-if [ -z "$(git config --get core.editor)" ] && [ -z "${GIT_EDITOR}" ]; then
-    if  [ "${TERM_PROGRAM}" = "vscode" ]; then
-        if [[ -n $(command -v code-insiders) &&  -z $(command -v code) ]]; then 
-            export GIT_EDITOR="code-insiders --wait"
-        else 
-            export GIT_EDITOR="code --wait"
-        fi
-    fi
-fi
-EOF
-)"
-
-# code shim, it fallbacks to code-insiders if code is not available
-cat <<'EOF' >/usr/local/bin/code
-#!/bin/sh
-get_in_path_except_current() {
-    which -a "$1" | grep -A1 "$0" | grep -v "$0"
-}
-code="$(get_in_path_except_current code)"
-if [ -n "$code" ]; then
-    exec "$code" "$@"
-elif [ "$(command -v code-insiders)" ]; then
-    exec code-insiders "$@"
-else
-    echo "code or code-insiders is not installed" >&2
-    exit 127
-fi
-EOF
-chmod +x /usr/local/bin/code
-
-# systemctl shim - tells people to use 'service' if systemd is not running
-cat <<'EOF' >/usr/local/bin/systemctl
-#!/bin/sh
-set -e
-if [ -d "/run/systemd/system" ]; then
-    exec /bin/systemctl/systemctl "$@"
-else
-    echo '\n"systemd" is not running in this container due to its overhead.\nUse the "service" command to start services intead. e.g.: \n\nservice --status-all'
-fi
-EOF
-chmod +x /usr/local/bin/systemctl
-
-# Codespaces bash and OMZ themes - partly inspired by https://github.com/ohmyzsh/ohmyzsh/blob/master/themes/robbyrussell.zsh-theme
-codespaces_bash="$(
-    cat \
-        <<'EOF'
-# Codespaces bash prompt theme
-__bash_prompt() {
-    local userpart='`export XIT=$? \
-        && [ ! -z "${GITHUB_USER}" ] && echo -n "\[\033[0;32m\]@${GITHUB_USER} " || echo -n "\[\033[0;32m\]\u " \
-        && [ "$XIT" -ne "0" ] && echo -n "\[\033[1;31m\]➜" || echo -n "\[\033[0m\]➜"`'
-    local gitbranch='`\
-        if [ "$(git config --get codespaces-theme.hide-status 2>/dev/null)" != 1 ]; then \
-            export BRANCH=$(git symbolic-ref --short HEAD 2>/dev/null || git rev-parse --short HEAD 2>/dev/null); \
-            if [ "${BRANCH}" != "" ]; then \
-                echo -n "\[\033[0;36m\](\[\033[1;31m\]${BRANCH}" \
-                && if git ls-files --error-unmatch -m --directory --no-empty-directory -o --exclude-standard ":/*" > /dev/null 2>&1; then \
-                        echo -n " \[\033[1;33m\]✗"; \
-                fi \
-                && echo -n "\[\033[0;36m\]) "; \
-            fi; \
-        fi`'
-    local lightblue='\[\033[1;34m\]'
-    local removecolor='\[\033[0m\]'
-    PS1="${userpart} ${lightblue}\w ${gitbranch}${removecolor}\$ "
-    unset -f __bash_prompt
-}
-__bash_prompt
-EOF
-)"
-
-codespaces_zsh="$(
-    cat \
-        <<'EOF'
-# Codespaces zsh prompt theme
-__zsh_prompt() {
-    local prompt_username
-    if [ ! -z "${GITHUB_USER}" ]; then 
-        prompt_username="@${GITHUB_USER}"
-    else
-        prompt_username="%n"
-    fi
-    PROMPT="%{$fg[green]%}${prompt_username} %(?:%{$reset_color%}➜ :%{$fg_bold[red]%}➜ )" # User/exit code arrow
-    PROMPT+='%{$fg_bold[blue]%}%(5~|%-1~/…/%3~|%4~)%{$reset_color%} ' # cwd
-    PROMPT+='$([ "$(git config --get codespaces-theme.hide-status 2>/dev/null)" != 1 ] && git_prompt_info)' # Git status
-    PROMPT+='%{$fg[white]%}$ %{$reset_color%}'
-    unset -f __zsh_prompt
-}
-ZSH_THEME_GIT_PROMPT_PREFIX="%{$fg_bold[cyan]%}(%{$fg_bold[red]%}"
-ZSH_THEME_GIT_PROMPT_SUFFIX="%{$reset_color%} "
-ZSH_THEME_GIT_PROMPT_DIRTY=" %{$fg_bold[yellow]%}✗%{$fg_bold[cyan]%})"
-ZSH_THEME_GIT_PROMPT_CLEAN="%{$fg_bold[cyan]%})"
-__zsh_prompt
-EOF
-)"
-
-# Add RC snippet and custom bash prompt
-if [ "${RC_SNIPPET_ALREADY_ADDED}" != "true" ]; then
-    echo "${rc_snippet}" >>/etc/bash.bashrc
-    echo "${codespaces_bash}" >>"${user_rc_path}/.bashrc"
-    echo 'export PROMPT_DIRTRIM=4' >>"${user_rc_path}/.bashrc"
-    if [ "${USERNAME}" != "root" ]; then
-        echo "${codespaces_bash}" >>"/root/.bashrc"
-        echo 'export PROMPT_DIRTRIM=4' >>"/root/.bashrc"
-    fi
-    chown ${USERNAME}:${group_name} "${user_rc_path}/.bashrc"
-    RC_SNIPPET_ALREADY_ADDED="true"
-fi
-
-# Optionally install and configure zsh and Oh My Zsh!
-if [ "${INSTALL_ZSH}" = "true" ]; then
-    if ! type zsh >/dev/null 2>&1; then
-        apt_get_update_if_needed
-        apt-get install -y zsh
-    fi
-    if [ "${ZSH_ALREADY_INSTALLED}" != "true" ]; then
-        echo "${rc_snippet}" >>/etc/zsh/zshrc
-        ZSH_ALREADY_INSTALLED="true"
-    fi
-
-    # Adapted, simplified inline Oh My Zsh! install steps that adds, defaults to a codespaces theme.
-    # See https://github.com/ohmyzsh/ohmyzsh/blob/master/tools/install.sh for official script.
-    oh_my_install_dir="${user_rc_path}/.oh-my-zsh"
-    if [ ! -d "${oh_my_install_dir}" ] && [ "${INSTALL_OH_MYS}" = "true" ]; then
-        template_path="${oh_my_install_dir}/templates/zshrc.zsh-template"
-        user_rc_file="${user_rc_path}/.zshrc"
-        umask g-w,o-w
-        mkdir -p ${oh_my_install_dir}
-        git clone --depth=1 \
-            -c core.eol=lf \
-            -c core.autocrlf=false \
-            -c fsck.zeroPaddedFilemode=ignore \
-            -c fetch.fsck.zeroPaddedFilemode=ignore \
-            -c receive.fsck.zeroPaddedFilemode=ignore \
-            "https://github.com/ohmyzsh/ohmyzsh" "${oh_my_install_dir}" 2>&1
-        echo -e "$(cat "${template_path}")\nDISABLE_AUTO_UPDATE=true\nDISABLE_UPDATE_PROMPT=true" >${user_rc_file}
-        sed -i -e 's/ZSH_THEME=.*/ZSH_THEME="codespaces"/g' ${user_rc_file}
-
-        mkdir -p ${oh_my_install_dir}/custom/themes
-        echo "${codespaces_zsh}" >"${oh_my_install_dir}/custom/themes/codespaces.zsh-theme"
-        # Shrink git while still enabling updates
-        cd "${oh_my_install_dir}"
-        git repack -a -d -f --depth=1 --window=1
-        # Copy to non-root user if one is specified
-        if [ "${USERNAME}" != "root" ]; then
-            cp -rf "${user_rc_file}" "${oh_my_install_dir}" /root
-            chown -R ${USERNAME}:${group_name} "${user_rc_path}"
-        fi
-    fi
-fi
-
-# Persist image metadata info, script if meta.env found in same directory
-meta_info_script="$(
-    cat <<'EOF'
-#!/bin/sh
-. /usr/local/etc/vscode-dev-containers/meta.env
-# Minimal output
-if [ "$1" = "version" ] || [ "$1" = "image-version" ]; then
-    echo "${VERSION}"
-    exit 0
-elif [ "$1" = "release" ]; then
-    echo "${GIT_REPOSITORY_RELEASE}"
-    exit 0
-elif [ "$1" = "content" ] || [ "$1" = "content-url" ] || [ "$1" = "contents" ] || [ "$1" = "contents-url" ]; then
-    echo "${CONTENTS_URL}"
-    exit 0
-fi
-#Full output
-echo
-echo "Development container image information"
-echo
-if [ ! -z "${VERSION}" ]; then echo "- Image version: ${VERSION}"; fi
-if [ ! -z "${DEFINITION_ID}" ]; then echo "- Definition ID: ${DEFINITION_ID}"; fi
-if [ ! -z "${VARIANT}" ]; then echo "- Variant: ${VARIANT}"; fi
-if [ ! -z "${GIT_REPOSITORY}" ]; then echo "- Source code repository: ${GIT_REPOSITORY}"; fi
-if [ ! -z "${GIT_REPOSITORY_RELEASE}" ]; then echo "- Source code release/branch: ${GIT_REPOSITORY_RELEASE}"; fi
-if [ ! -z "${BUILD_TIMESTAMP}" ]; then echo "- Timestamp: ${BUILD_TIMESTAMP}"; fi
-if [ ! -z "${CONTENTS_URL}" ]; then echo && echo "More info: ${CONTENTS_URL}"; fi
-echo
-EOF
-)"
-if [ -f "${SCRIPT_DIR}/meta.env" ]; then
-    mkdir -p /usr/local/etc/vscode-dev-containers/
-    cp -f "${SCRIPT_DIR}/meta.env" /usr/local/etc/vscode-dev-containers/meta.env
-    echo "${meta_info_script}" >/usr/local/bin/devcontainer-info
-    chmod +x /usr/local/bin/devcontainer-info
-fi
-
-# Write marker file
-mkdir -p "$(dirname "${MARKER_FILE}")"
-echo -e "\
-    PACKAGES_ALREADY_INSTALLED=${PACKAGES_ALREADY_INSTALLED}\n\
-    LOCALE_ALREADY_SET=${LOCALE_ALREADY_SET}\n\
-    EXISTING_NON_ROOT_USER=${EXISTING_NON_ROOT_USER}\n\
-    RC_SNIPPET_ALREADY_ADDED=${RC_SNIPPET_ALREADY_ADDED}\n\
-    ZSH_ALREADY_INSTALLED=${ZSH_ALREADY_INSTALLED}" >"${MARKER_FILE}"
-
-echo "Done!"

.devcontainer/scripts/getting-started.sh

@@ -1,16 +0,0 @@
-#!/bin/bash
-
-echo "To get started, login to GitHub and clone bun's GitHub repo into /workspaces/bun"
-echo "Make sure to login with a Personal Access Token"
-echo "# First time setup"
-echo "gh auth login"
-echo "gh repo clone Jarred-Sumner/bun . -- --depth=1 --progress -j8"
-echo ""
-echo "# Compile bun dependencies (zig is already compiled)"
-echo "make devcontainer"
-echo ""
-echo "# Build bun for development"
-echo "make dev"
-echo ""
-echo "# Run bun"
-echo "bun-debug"

.devcontainer/scripts/github.sh

@@ -1,185 +0,0 @@
-#!/usr/bin/env bash
-#-------------------------------------------------------------------------------------------------------------
-# Copyright (c) Microsoft Corporation. All rights reserved.
-# Licensed under the MIT License. See https://go.microsoft.com/fwlink/?linkid=2090316 for license information.
-#-------------------------------------------------------------------------------------------------------------
-#
-# Docs: https://github.com/microsoft/vscode-dev-containers/blob/main/script-library/docs/github.md
-# Maintainer: The VS Code and Codespaces Teams
-#
-# Syntax: ./github-debian.sh [version]
-
-CLI_VERSION=${1:-"latest"}
-
-GITHUB_CLI_ARCHIVE_GPG_KEY=C99B11DEB97541F0
-GPG_KEY_SERVERS="keyserver hkp://keyserver.ubuntu.com:80
-keyserver hkps://keys.openpgp.org
-keyserver hkp://keyserver.pgp.com"
-
-set -e
-
-if [ "$(id -u)" -ne 0 ]; then
-    echo -e 'Script must be run as root. Use sudo, su, or add "USER root" to your Dockerfile before running this script.'
-    exit 1
-fi
-
-# Get central common setting
-get_common_setting() {
-    if [ "${common_settings_file_loaded}" != "true" ]; then
-        curl -sfL "https://aka.ms/vscode-dev-containers/script-library/settings.env" -o /tmp/vsdc-settings.env 2>/dev/null || echo "Could not download settings file. Skipping."
-        common_settings_file_loaded=true
-    fi
-    if [ -f "/tmp/vsdc-settings.env" ]; then
-        local multi_line=""
-        if [ "$2" = "true" ]; then multi_line="-z"; fi
-        local result="$(grep ${multi_line} -oP "$1=\"?\K[^\"]+" /tmp/vsdc-settings.env | tr -d '\0')"
-        if [ ! -z "${result}" ]; then declare -g $1="${result}"; fi
-    fi
-    echo "$1=${!1}"
-}
-
-# Import the specified key in a variable name passed in as
-receive_gpg_keys() {
-    get_common_setting $1
-    local keys=${!1}
-    get_common_setting GPG_KEY_SERVERS true
-
-    # Use a temporary locaiton for gpg keys to avoid polluting image
-    export GNUPGHOME="/tmp/tmp-gnupg"
-    mkdir -p ${GNUPGHOME}
-    chmod 700 ${GNUPGHOME}
-    echo -e "disable-ipv6\n${GPG_KEY_SERVERS}" >${GNUPGHOME}/dirmngr.conf
-    # GPG key download sometimes fails for some reason and retrying fixes it.
-    local retry_count=0
-    local gpg_ok="false"
-    set +e
-    until [ "${gpg_ok}" = "true" ] || [ "${retry_count}" -eq "5" ]; do
-        echo "(*) Downloading GPG key..."
-        (echo "${keys}" | xargs -n 1 gpg --recv-keys) 2>&1 && gpg_ok="true"
-        if [ "${gpg_ok}" != "true" ]; then
-            echo "(*) Failed getting key, retring in 10s..."
-            ((retry_count++))
-            sleep 10s
-        fi
-    done
-    set -e
-    if [ "${gpg_ok}" = "false" ]; then
-        echo "(!) Failed to get gpg key."
-        exit 1
-    fi
-}
-
-# Figure out correct version of a three part version number is not passed
-find_version_from_git_tags() {
-    local variable_name=$1
-    local requested_version=${!variable_name}
-    if [ "${requested_version}" = "none" ]; then return; fi
-    local repository=$2
-    local prefix=${3:-"tags/v"}
-    local separator=${4:-"."}
-    local last_part_optional=${5:-"false"}
-    if [ "$(echo "${requested_version}" | grep -o "." | wc -l)" != "2" ]; then
-        local escaped_separator=${separator//./\\.}
-        local last_part
-        if [ "${last_part_optional}" = "true" ]; then
-            last_part="(${escaped_separator}[0-9]+)?"
-        else
-            last_part="${escaped_separator}[0-9]+"
-        fi
-        local regex="${prefix}\\K[0-9]+${escaped_separator}[0-9]+${last_part}$"
-        local version_list="$(git ls-remote --tags ${repository} | grep -oP "${regex}" | tr -d ' ' | tr "${separator}" "." | sort -rV)"
-        if [ "${requested_version}" = "latest" ] || [ "${requested_version}" = "current" ] || [ "${requested_version}" = "lts" ]; then
-            declare -g ${variable_name}="$(echo "${version_list}" | head -n 1)"
-        else
-            set +e
-            declare -g ${variable_name}="$(echo "${version_list}" | grep -E -m 1 "^${requested_version//./\\.}([\\.\\s]|$)")"
-            set -e
-        fi
-    fi
-    if [ -z "${!variable_name}" ] || ! echo "${version_list}" | grep "^${!variable_name//./\\.}$" >/dev/null 2>&1; then
-        echo -e "Invalid ${variable_name} value: ${requested_version}\nValid values:\n${version_list}" >&2
-        exit 1
-    fi
-    echo "${variable_name}=${!variable_name}"
-}
-
-# Import the specified key in a variable name passed in as
-receive_gpg_keys() {
-    get_common_setting $1
-    local keys=${!1}
-    get_common_setting GPG_KEY_SERVERS true
-    local keyring_args=""
-    if [ ! -z "$2" ]; then
-        keyring_args="--no-default-keyring --keyring $2"
-    fi
-
-    # Use a temporary locaiton for gpg keys to avoid polluting image
-    export GNUPGHOME="/tmp/tmp-gnupg"
-    mkdir -p ${GNUPGHOME}
-    chmod 700 ${GNUPGHOME}
-    echo -e "disable-ipv6\n${GPG_KEY_SERVERS}" >${GNUPGHOME}/dirmngr.conf
-    # GPG key download sometimes fails for some reason and retrying fixes it.
-    local retry_count=0
-    local gpg_ok="false"
-    set +e
-    until [ "${gpg_ok}" = "true" ] || [ "${retry_count}" -eq "5" ]; do
-        echo "(*) Downloading GPG key..."
-        (echo "${keys}" | xargs -n 1 gpg -q ${keyring_args} --recv-keys) 2>&1 && gpg_ok="true"
-        if [ "${gpg_ok}" != "true" ]; then
-            echo "(*) Failed getting key, retring in 10s..."
-            ((retry_count++))
-            sleep 10s
-        fi
-    done
-    set -e
-    if [ "${gpg_ok}" = "false" ]; then
-        echo "(!) Failed to get gpg key."
-        exit 1
-    fi
-}
-
-# Function to run apt-get if needed
-apt_get_update_if_needed() {
-    if [ ! -d "/var/lib/apt/lists" ] || [ "$(ls /var/lib/apt/lists/ | wc -l)" = "0" ]; then
-        echo "Running apt-get update..."
-        apt-get update
-    else
-        echo "Skipping apt-get update."
-    fi
-}
-
-# Checks if packages are installed and installs them if not
-check_packages() {
-    if ! dpkg -s "$@" >/dev/null 2>&1; then
-        apt_get_update_if_needed
-        apt-get -y install --no-install-recommends "$@"
-    fi
-}
-
-export DEBIAN_FRONTEND=noninteractive
-
-# Install curl, apt-transport-https, curl, gpg, or dirmngr, git if missing
-check_packages curl ca-certificates apt-transport-https dirmngr gnupg2
-if ! type git >/dev/null 2>&1; then
-    apt_get_update_if_needed
-    apt-get -y install --no-install-recommends git
-fi
-
-# Soft version matching
-if [ "${CLI_VERSION}" != "latest" ] && [ "${CLI_VERSION}" != "lts" ] && [ "${CLI_VERSION}" != "stable" ]; then
-    find_version_from_git_tags CLI_VERSION "https://github.com/cli/cli"
-    version_suffix="=${CLI_VERSION}"
-else
-    version_suffix=""
-fi
-
-# Install the GitHub CLI
-echo "Downloading github CLI..."
-# Import key safely (new method rather than deprecated apt-key approach) and install
-. /etc/os-release
-receive_gpg_keys GITHUB_CLI_ARCHIVE_GPG_KEY /usr/share/keyrings/githubcli-archive-keyring.gpg
-echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/githubcli-archive-keyring.gpg] https://cli.github.com/packages ${VERSION_CODENAME} main" >/etc/apt/sources.list.d/github-cli.list
-apt-get update
-apt-get -y install "gh${version_suffix}"
-rm -rf "/tmp/gh/gnupg"
-echo "Done!"

.devcontainer/scripts/nice.sh

@@ -1,7 +0,0 @@
-#!/bin/bash
-
-chsh -s $(which zsh)
-sh -c "$(curl -fsSL https://starship.rs/install.sh) -- --platform linux_musl"
-echo "eval \"$(starship init zsh)\"" >>~/.zshrc
-
-curl https://github.com/Jarred-Sumner/vscode-zig/releases/download/fork-v1/zig-0.2.5.vsix >/home/ubuntu/vscode-zig.vsix

.devcontainer/scripts/zig-env.sh

@@ -1,7 +0,0 @@
-#!/bin/bash
-
-curl -L https://github.com/Jarred-Sumner/vscode-zig/releases/download/fork-v1/zig-0.2.5.vsix >/home/ubuntu/vscode-zig.vsix
-git clone https://github.com/zigtools/zls /home/ubuntu/zls
-cd /home/ubuntu/zls
-git submodule update --init --recursive --progress --depth=1
-zig build -Drelease-fast

.devcontainer/workspace.code-workspace

@@ -1,9 +0,0 @@
-{
-  "folders": [
-    {
-      // Source code
-      "name": "bun",
-      "path": "bun"
-    },
-  ]
-}

.devcontainer/zls.json

@@ -1,9 +0,0 @@
-{
-  "zig_exe_path": "/build/zig/zig",
-  "enable_snippets": true,
-  "warn_style": false,
-  "enable_semantic_tokens": true,
-  "operator_completions": true,
-  "include_at_in_builtins": false,
-  "max_detail_length": 1048576
-}

.docker/build-base-images.sh

@@ -1,15 +0,0 @@
-#!/bin/bash
-
-set -euxo pipefail
-
-export DOCKER_BUILDKIT=1
-
-docker login --username bunbunbunbun
-
-docker build -f Dockerfile.base -t bunbunbunbun/bun-test-base --target bun-test-base . --platform=linux/$BUILDARCH --build-arg BUILDARCH=$BUILDARCH
-docker build -f Dockerfile.base -t bunbunbunbun/bun-base-with-zig-and-webkit --target bun-base-with-zig-and-webkit . --platform=linux/$BUILDARCH --build-arg BUILDARCH=$BUILDARCH
-docker build -f Dockerfile.base -t bunbunbunbun/bun-base --target bun-base --platform=linux/$BUILDARCH . --build-arg BUILDARCH=$BUILDARCH
-
-docker push bunbunbunbun/bun-test-base:latest
-docker push bunbunbunbun/bun-base-with-zig-and-webkit:latest
-docker push bunbunbunbun/bun-base:latest

.docker/build-base.sh

@@ -1,24 +0,0 @@
-#!/bin/bash
-
-set -euxo pipefail
-
-export DOCKER_BUILDKIT=1
-
-docker buildx build \
-    -t bunbunbunbun/bun-test-base:latest -f Dockerfile.base \
-    --target bun-test-base \
-    --platform=linux/$BUILDARCH --build-arg BUILDARCH=$BUILDARCH .
-docker buildx build \
-    --target bun-base \
-    -f Dockerfile.base \
-    -t bunbunbunbun/bun-base:latest --platform=linux/$BUILDARCH \
-    --build-arg BUILDARCH=$BUILDARCH .
-docker buildx build \
-    -t bunbunbunbun/bun-base-with-zig-and-webkit:latest \
-    -f Dockerfile.base \
-    --target bun-base-with-zig-and-webkit \
-    --platform=linux/$BUILDARCH --build-arg BUILDARCH=$BUILDARCH .
-
-docker push bunbunbunbun/bun-test-base:latest
-docker push bunbunbunbun/bun-base:latest
-docker push bunbunbunbun/bun-base-with-zig-and-webkit:latest

.docker/chromium.pref

@@ -1,14 +0,0 @@
-# Note: 2 blank lines are required between entries
- Package: *
- Pin: release a=eoan
- Pin-Priority: 500
-
- Package: *
- Pin: origin "ftp.debian.org"
- Pin-Priority: 300
-
- # Pattern includes 'chromium', 'chromium-browser' and similarly
- # named dependencies:
- Package: chromium*
- Pin: origin "ftp.debian.org"
- Pin-Priority: 700

.docker/copy-bun-binary.sh

@@ -1,8 +0,0 @@
-#!/bin/bash
-
-set -euxo pipefail
-
-name=$(openssl rand -hex 12)
-id=$(docker create --name=bun-binary-$name $CONTAINER_TAG)
-docker container cp bun-binary-$name:$BUN_RELEASE_DIR bun-binary
-echo -e "bun-binary-$name"

.docker/debian.list

@@ -1,3 +0,0 @@
- deb http://deb.debian.org/debian buster main
- deb http://deb.debian.org/debian buster-updates main
- deb http://deb.debian.org/debian-security buster/updates main

.docker/dockerfile-common.sh

@@ -1,34 +0,0 @@
-export DOCKER_BUILDKIT=1
-
-export BUILDKIT_ARCH=$(uname -m)
-export ARCH=${BUILDKIT_ARCH}
-
-if [ "$BUILDKIT_ARCH" == "amd64" ]; then
-    export BUILDKIT_ARCH="amd64"
-    export ARCH=x64
-fi
-
-if [ "$BUILDKIT_ARCH" == "x86_64" ]; then
-    export BUILDKIT_ARCH="amd64"
-    export ARCH=x64
-fi
-
-if [ "$BUILDKIT_ARCH" == "arm64" ]; then
-    export BUILDKIT_ARCH="arm64"
-    export ARCH=aarch64
-fi
-
-if [ "$BUILDKIT_ARCH" == "aarch64" ]; then
-    export BUILDKIT_ARCH="arm64"
-    export ARCH=aarch64
-fi
-
-if [ "$BUILDKIT_ARCH" == "armv7l" ]; then
-    echo "Unsupported platform: $BUILDKIT_ARCH"
-    exit 1
-fi
-
-export BUILD_ID=$(cat build-id)
-export CONTAINER_NAME=bun-linux-$ARCH
-export DEBUG_CONTAINER_NAME=debug-bun-linux-$ARCH
-export TEMP=/tmp/bun-0.0.$BUILD_ID

.docker/pull.sh

@@ -1,11 +0,0 @@
-#!/bin/bash
-
-set -euxo pipefail
-
-docker pull bunbunbunbun/bun-test-base:latest --platform=linux/amd64
-docker pull bunbunbunbun/bun-base:latest --platform=linux/amd64
-docker pull bunbunbunbun/bun-base-with-zig-and-webkit:latest --platform=linux/amd64
-
-docker tag bunbunbunbun/bun-test-base:latest bun-base:latest
-docker tag bunbunbunbun/bun-base:latest bun-base:latest
-docker tag bunbunbunbun/bun-base-with-zig-and-webkit:latest bun-base-with-zig-and-webkit:latest

.docker/run-dockerfile.sh

@@ -1,47 +0,0 @@
-#!/bin/bash
-
-source "dockerfile-common.sh"
-
-export $CONTAINER_NAME=$CONTAINER_NAME-local
-
-rm -rf $TEMP
-mkdir -p $TEMP
-
-docker build . --target release --progress=plain -t $CONTAINER_NAME:latest --build-arg BUILDKIT_INLINE_CACHE=1 --platform=linux/$BUILDKIT_ARCH --cache-from $CONTAINER_NAME:latest
-
-if (($?)); then
-  echo "Failed to build container"
-  exit 1
-fi
-
-id=$(docker create $CONTAINER_NAME:latest)
-docker cp $id:/home/ubuntu/bun-release $TEMP/$CONTAINER_NAME
-if (($?)); then
-  echo "Failed to cp container"
-  exit 1
-fi
-
-cd $TEMP
-mkdir -p $TEMP/$CONTAINER_NAME $TEMP/$DEBUG_CONTAINER_NAME
-mv $CONTAINER_NAME/bun-profile $DEBUG_CONTAINER_NAME/bun
-zip -r $CONTAINER_NAME.zip $CONTAINER_NAME
-zip -r $DEBUG_CONTAINER_NAME.zip $DEBUG_CONTAINER_NAME
-docker rm -v $id
-abs=$(realpath $TEMP/$CONTAINER_NAME.zip)
-debug_abs=$(realpath $TEMP/$DEBUG_CONTAINER_NAME.zip)
-
-case $(uname -s) in
-"Linux") target="linux" ;;
-*) target="other" ;;
-esac
-
-if [ "$target" = "linux" ]; then
-  if command -v bun --version >/dev/null; then
-    cp $TEMP/$CONTAINER_NAME/bun $(which bun)
-    cp $TEMP/$DEBUG_CONTAINER_NAME/bun $(which bun-profile)
-  fi
-fi
-
-echo "Saved to:"
-echo $debug_abs
-echo $abs

.docker/run-test.sh

@@ -1,9 +0,0 @@
-#!/bin/bash
-
-set -euxo pipefail
-
-bun install
-bun install --cwd ./integration/snippets
-bun install --cwd ./integration/scripts
-
-make $BUN_TEST_NAME

.docker/runner.sh

@@ -1,5 +0,0 @@
-#!/bin/bash
-
-set -euxo pipefail
-
-docker container run --security-opt seccomp=.docker/chrome.json --env GITHUB_WORKSPACE=$GITHUB_WORKSPACE --env BUN_TEST_NAME=$BUN_TEST_NAME --ulimit memlock=-1:-1 --init --rm bun-test:latest

.docker/unit-tests.sh

@@ -1,5 +0,0 @@
-#!/bin/bash
-
-set -euxo pipefail
-
-docker container run --security-opt seccomp=.docker/chrome.json --env GITHUB_WORKSPACE=$GITHUB_WORKSPACE --ulimit memlock=-1:-1 --init --rm bun-unit-tests:latest

.dockerignore

@@ -1,17 +1,21 @@
-node_modules
-**/node_modules
-src/javascript/jsc/WebKit/LayoutTests
-zig-out
-zig-build
-**/*.o
 **/*.a
-
-examples
-
+**/*.o
 **/.next
-.git
-src/javascript/jsc/WebKit
 **/CMakeCache.txt
+**/node_modules
+.git
+examples
+node_modules
 packages/**/bun
 packages/**/bun-profile
-zig-cache
+src/bun.js/WebKit
+src/bun.js/WebKit/LayoutTests
+zig-build
+.zig-cache
+zig-out
+build
+vendor
+node_modules
+*.trace
+
+packages/bun-uws/fuzzing

.editorconfig

@@ -0,0 +1,8 @@
+# https://EditorConfig.org
+root = true
+
+[*]
+charset = utf-8
+insert_final_newline = true
+trim_trailing_whitespace = true
+end_of_line = lf

.git-blame-ignore-revs

@@ -0,0 +1,10 @@
+# Add commits to ignore in `git blame`. This allows large stylistic refactors to
+# avoid mucking up blames.
+#
+# To configure git to use this, run: 
+#
+#    git config blame.ignoreRevsFile .git-blame-ignore-revs
+#
+4ec410e0d7c5f6a712c323444edbf56b48d432d8 # make @import("bun") work in zig (#19096)
+dedd433cbf2e2fe38e51bc166e08fbcc601ad42b # JSValue.undefined -> .jsUndefined()
+6b4662ff55f58247cc2fd22e85b4f9805b0950a5 # JSValue.jsUndefined() -> .js_undefined

.gitattributes

@@ -1,4 +1,57 @@
+*.css text eol=lf whitespace=blank-at-eol,-blank-at-eof,-space-before-tab,tab-in-indent,tabwidth=2
+*.js text eol=lf whitespace=blank-at-eol,-blank-at-eof,-space-before-tab,tab-in-indent,tabwidth=2
+*.jsx text eol=lf whitespace=blank-at-eol,-blank-at-eof,-space-before-tab,tab-in-indent,tabwidth=2
+*.tsx text eol=lf whitespace=blank-at-eol,-blank-at-eof,-space-before-tab,tab-in-indent,tabwidth=2
+*.ts text eol=lf whitespace=blank-at-eol,-blank-at-eof,-space-before-tab,tab-in-indent,tabwidth=2
+*.c text eol=lf whitespace=blank-at-eol,-blank-at-eof,-space-before-tab,tab-in-indent,tabwidth=2
+*.cpp text eol=lf whitespace=blank-at-eol,-blank-at-eof,-space-before-tab,tab-in-indent,tabwidth=2
+*.cc text eol=lf whitespace=blank-at-eol,-blank-at-eof,-space-before-tab,tab-in-indent,tabwidth=2
+*.yml text eol=lf whitespace=blank-at-eol,-blank-at-eof,-space-before-tab,tab-in-indent,tabwidth=2
+*.toml text eol=lf whitespace=blank-at-eol,-blank-at-eof,-space-before-tab,tab-in-indent,tabwidth=2
+*.zig text eol=lf whitespace=blank-at-eol,-blank-at-eof,-space-before-tab,tab-in-indent,tabwidth=2
+*.rs text eol=lf whitespace=blank-at-eol,-blank-at-eof,-space-before-tab,tab-in-indent,tabwidth=2
+*.h text eol=lf whitespace=blank-at-eol,-blank-at-eof,-space-before-tab,tab-in-indent,tabwidth=2
+*.json text eol=lf whitespace=blank-at-eol,-blank-at-eof,-space-before-tab,tab-in-indent,tabwidth=2
+*.lock text eol=lf whitespace=blank-at-eol,-blank-at-eof,-space-before-tab,tab-in-indent,tabwidth=2
+*.map text eol=lf whitespace=blank-at-eol,-blank-at-eof,-space-before-tab,tab-in-indent,tabwidth=2
+*.md text eol=lf whitespace=blank-at-eol,-blank-at-eof,-space-before-tab,tab-in-indent,tabwidth=2
+*.mdc text eol=lf whitespace=blank-at-eol,-blank-at-eof,-space-before-tab,tab-in-indent,tabwidth=2
+*.mjs text eol=lf whitespace=blank-at-eol,-blank-at-eof,-space-before-tab,tab-in-indent,tabwidth=2
+*.mts text eol=lf whitespace=blank-at-eol,-blank-at-eof,-space-before-tab,tab-in-indent,tabwidth=2
+
+*.lockb binary diff=lockb
+
 .vscode/launch.json linguist-generated
 src/api/schema.d.ts linguist-generated
+fixture.*.c linguist-generated
 src/api/schema.js linguist-generated
-*.lockb binary diff=lockb
+*-fixture* linguist-generated
+src/bun.js/bindings/ZigGeneratedCode.h linguist-generated
+src/bun.js/bindings/ZigGeneratedCode.cpp linguist-generated
+src/bun.js/bindings/headers.h linguist-generated
+src/bun.js/bindings/headers.zig linguist-generated
+
+packages/bun-uws/fuzzing/seed-corpus/**/* linguist-generated
+
+src/bun.js/bindings/sqlite/sqlite3.c linguist-vendored
+src/bun.js/bindings/sqlite/sqlite3_local.h linguist-vendored
+src/bun.js/bindings/simdutf.cpp linguist-vendored
+src/bun.js/bindings/simdutf.h linguist-vendored
+
+docs/**/* linguist-documentation
+
+# Don't count tests in the language stats - https://github.com/github-linguist/linguist/blob/master/docs/overrides.md
+test/**/* linguist-documentation
+bench/**/* linguist-documentation
+examples/**/* linguist-documentation
+
+vendor/*.c linguist-vendored
+vendor/brotli/** linguist-vendored
+
+test/js/node/test/fixtures linguist-vendored
+test/js/node/test/common linguist-vendored
+
+test/js/bun/css/files linguist-vendored
+
+.vscode/*.json linguist-language=JSON-with-Comments
+src/cli/init/tsconfig.default.json linguist-language=JSON-with-Comments

.github/CODEOWNERS

@@ -0,0 +1,5 @@
+# Project
+/.github/CODEOWNERS @Jarred-Sumner
+
+# Tests
+/test/expectations.txt @Jarred-Sumner

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

@@ -0,0 +1,47 @@
+name: 🐛 Bug Report
+description: Report an issue that should be fixed
+labels:
+  - bug
+  - needs triage
+body:
+  - type: markdown
+    attributes:
+      value: |
+        Thank you for submitting a bug report. It helps make Bun better.
+
+        If you need help or support using Bun, and are not reporting a bug, please
+        join our [Discord](https://discord.gg/CXdq2DP29u) server, where you can ask questions in the [`#help`](https://discord.gg/32EtH6p7HN) forum.
+
+        Make sure you are running the [latest](https://bun.com/docs/installation#upgrading) version of Bun.
+        The bug you are experiencing may already have been fixed.
+
+        Please try to include as much information as possible.
+
+  - type: input
+    attributes:
+      label: What version of Bun is running?
+      description: Copy the output of `bun --revision`
+  - type: input
+    attributes:
+      label: What platform is your computer?
+      description: |
+        For MacOS and Linux: copy the output of `uname -mprs`
+        For Windows: copy the output of `"$([Environment]::OSVersion | ForEach-Object VersionString) $(if ([Environment]::Is64BitOperatingSystem) { "x64" } else { "x86" })"` in the PowerShell console
+  - type: textarea
+    attributes:
+      label: What steps can reproduce the bug?
+      description: Explain the bug and provide a code snippet that can reproduce it.
+    validations:
+      required: true
+  - type: textarea
+    attributes:
+      label: What is the expected behavior?
+      description: If possible, please provide text instead of a screenshot.
+  - type: textarea
+    attributes:
+      label: What do you see instead?
+      description: If possible, please provide text instead of a screenshot.
+  - type: textarea
+    attributes:
+      label: Additional information
+      description: Is there anything else you think we should know?

.github/ISSUE_TEMPLATE/3-typescript-bug-report.yml

@@ -0,0 +1,45 @@
+name: 🇹 TypeScript Type Bug Report
+description: Report an issue with TypeScript types
+labels: [bug, types]
+body:
+  - type: markdown
+    attributes:
+      value: |
+        Thank you for submitting a bug report. It helps make Bun better.
+
+        If you need help or support using Bun, and are not reporting a bug, please
+        join our [Discord](https://discord.gg/CXdq2DP29u) server, where you can ask questions in the [`#help`](https://discord.gg/32EtH6p7HN) forum.
+
+        Make sure you are running the [latest](https://bun.com/docs/installation#upgrading) version of Bun.
+        The bug you are experiencing may already have been fixed.
+
+        Please try to include as much information as possible.
+
+  - type: input
+    attributes:
+      label: What version of Bun is running?
+      description: Copy the output of `bun --revision`
+  - type: input
+    attributes:
+      label: What platform is your computer?
+      description: |
+        For MacOS and Linux: copy the output of `uname -mprs`
+        For Windows: copy the output of `"$([Environment]::OSVersion | ForEach-Object VersionString) $(if ([Environment]::Is64BitOperatingSystem) { "x64" } else { "x86" })"` in the PowerShell console
+  - type: textarea
+    attributes:
+      label: What steps can reproduce the bug?
+      description: Explain the bug and provide a code snippet that can reproduce it.
+    validations:
+      required: true
+  - type: textarea
+    attributes:
+      label: What is the expected behavior?
+      description: If possible, please provide text instead of a screenshot.
+  - type: textarea
+    attributes:
+      label: What do you see instead?
+      description: If possible, please provide text instead of a screenshot.
+  - type: textarea
+    attributes:
+      label: Additional information
+      description: Is there anything else you think we should know?

.github/ISSUE_TEMPLATE/4-feature-request.yml

@@ -0,0 +1,24 @@
+name: 🚀 Feature Request
+description: Suggest an idea, feature, or enhancement
+labels: [enhancement]
+body:
+  - type: markdown
+    attributes:
+      value: |
+        Thank you for submitting an idea. It helps make Bun better.
+
+        If you want to discuss Bun, or learn how others are using Bun, please
+        join our [Discord](https://discord.gg/CXdq2DP29u) server, where you can share in the [`#feedback`](https://discord.gg/unwUnHBNqy) channel.
+  - type: textarea
+    attributes:
+      label: What is the problem this feature would solve?
+    validations:
+      required: true
+  - type: textarea
+    attributes:
+      label: What is the feature you are proposing to solve the problem?
+    validations:
+      required: true
+  - type: textarea
+    attributes:
+      label: What alternatives have you considered?

.github/ISSUE_TEMPLATE/5-docs-issue.yml

@@ -0,0 +1,29 @@
+name: 📗 Documentation Issue
+description: Tell us if there is missing or incorrect documentation
+labels: [docs]
+body:
+  - type: markdown
+    attributes:
+      value: |
+        Thank you for submitting a documentation request. It helps make Bun better.
+
+        We are working on moving documentation from the [README](https://github.com/oven-sh/bun#table-of-contents) to a documentation website. Please report as many issues or missing content requests as you can so we can incoperate that in the new documentation.  
+  - type: dropdown
+    attributes:
+      label: What is the type of issue?
+      multiple: true
+      options:
+        - Documentation is missing
+        - Documentation is incorrect
+        - Documentation is confusing
+        - Example code is not working
+        - Something else
+  - type: textarea
+    attributes:
+      label: What is the issue?
+    validations:
+      required: true
+  - type: textarea
+    attributes:
+      label: Where did you find it?
+      description: If possible, please provide the URL(s) where you found this issue.

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

@@ -0,0 +1,28 @@
+name: Prefilled crash report
+description: Report a crash in Bun
+labels:
+  - crash
+  - needs triage
+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: code
+    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/ISSUE_TEMPLATE/7-install-crash-report.yml

@@ -0,0 +1,34 @@
+name: bun install crash report
+description: Report a crash in bun install
+labels:
+  - npm
+  - crash
+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: package_json
+    attributes:
+      label: "`package.json` file"
+      description: "Can you upload your `package.json` file? This helps us reproduce the crash."
+      render: json
+  - 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/ISSUE_TEMPLATE/config.yml

@@ -0,0 +1,5 @@
+blank_issues_enabled: true
+contact_links:
+  - name: 💬 Ask a Question
+    url: https://discord.com/invite/CXdq2DP29u
+    about: Join our Discord server for questions, support requests, or just to chat.

.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/actions/setup-bun/action.yml

@@ -0,0 +1,51 @@
+name: Setup Bun
+description: An internal version of the 'oven-sh/setup-bun' action.
+
+inputs:
+  bun-version:
+    type: string
+    description: "The version of bun to install: 'latest', 'canary', 'bun-v1.2.0', etc."
+    default: latest
+    required: false
+  baseline:
+    type: boolean
+    description: "Whether to use the baseline version of bun."
+    default: false
+    required: false
+  download-url:
+    type: string
+    description: "The base URL to download bun from."
+    default: "https://pub-5e11e972747a44bf9aaf9394f185a982.r2.dev/releases"
+    required: false
+
+runs:
+  using: composite
+  steps:
+    - name: Setup Bun
+      shell: bash
+      run: |
+        case "$(uname -s)" in
+          Linux*)  os=linux;;
+          Darwin*) os=darwin;;
+          *)       os=windows;;
+        esac
+        case "$(uname -m)" in
+          arm64 | aarch64)  arch=aarch64;;
+          *)                arch=x64;;
+        esac
+        case "${{ inputs.baseline }}" in
+          true | 1) target="bun-${os}-${arch}-baseline";;
+          *)        target="bun-${os}-${arch}";;
+        esac
+        case "${{ inputs.bun-version }}" in
+          latest) release="latest";;
+          canary) release="canary";;
+          *)      release="bun-v${{ inputs.bun-version }}";;
+        esac
+        curl -LO "${{ inputs.download-url }}/${release}/${target}.zip" --retry 5
+        unzip ${target}.zip
+        mkdir -p ${{ runner.temp }}/.bun/bin
+        mv ${target}/bun* ${{ runner.temp }}/.bun/bin/
+        chmod +x ${{ runner.temp }}/.bun/bin/*
+        ln -fs ${{ runner.temp }}/.bun/bin/bun ${{ runner.temp }}/.bun/bin/bunx
+        echo "${{ runner.temp }}/.bun/bin" >> ${GITHUB_PATH}

.github/pull_request_template.md

@@ -0,0 +1,3 @@
+### What does this PR do?
+
+### How did you verify your code works?

.github/workflows/CLAUDE.md

@@ -0,0 +1,103 @@
+# GitHub Actions Workflow Maintenance Guide
+
+This document provides guidance for maintaining the GitHub Actions workflows in this repository.
+
+## format.yml Workflow
+
+### Overview
+The `format.yml` workflow runs code formatters (Prettier, clang-format, and Zig fmt) on pull requests and pushes to main. It's optimized for speed by running all formatters in parallel.
+
+### Key Components
+
+#### 1. Clang-format Script (`scripts/run-clang-format.sh`)
+- **Purpose**: Formats C++ source and header files
+- **What it does**:
+  - Reads C++ files from `cmake/sources/CxxSources.txt`
+  - Finds all header files in `src/` and `packages/`
+  - Excludes third-party directories (libuv, napi, deps, vendor, sqlite, etc.)
+  - Requires specific clang-format version (no fallbacks)
+
+**Important exclusions**:
+- `src/napi/` - Node API headers (third-party)
+- `src/bun.js/bindings/libuv/` - libuv headers (third-party)
+- `src/bun.js/bindings/sqlite/` - SQLite headers (third-party)
+- `src/bun.js/api/ffi-*.h` - FFI headers (generated/third-party)
+- `src/deps/` - Dependencies (third-party)
+- Files in `vendor/`, `third_party/`, `generated/` directories
+
+#### 2. Parallel Execution
+The workflow runs all three formatters simultaneously:
+- Each formatter outputs with a prefix (`[prettier]`, `[clang-format]`, `[zig]`)
+- Output is streamed in real-time without blocking
+- Uses GitHub Actions groups (`::group::`) for collapsible sections
+
+#### 3. Tool Installation
+
+##### Clang-format-19
+- Installs ONLY `clang-format-19` package (not the entire LLVM toolchain)
+- Uses `--no-install-recommends --no-install-suggests` to skip unnecessary packages
+- Quiet installation with `-qq` and `-o=Dpkg::Use-Pty=0`
+
+##### Zig
+- Downloads from `oven-sh/zig` releases (musl build for static linking)
+- URL: `https://github.com/oven-sh/zig/releases/download/autobuild-{COMMIT}/bootstrap-x86_64-linux-musl.zip`
+- Extracts to temp directory to avoid polluting the repository
+- Directory structure: `bootstrap-x86_64-linux-musl/zig`
+
+### Updating the Workflow
+
+#### To update Zig version:
+1. Find the new commit hash from https://github.com/oven-sh/zig/releases
+2. Replace the hash in the wget URL (line 65 of format.yml)
+3. Test that the URL is valid and the binary works
+
+#### To update clang-format version:
+1. Update `LLVM_VERSION_MAJOR` environment variable at the top of format.yml
+2. Update the version check in `scripts/run-clang-format.sh`
+
+#### To add/remove file exclusions:
+1. Edit the exclusion patterns in `scripts/run-clang-format.sh` (lines 34-39)
+2. Test locally to ensure the right files are being formatted
+
+### Performance Optimizations
+1. **Parallel execution**: All formatters run simultaneously
+2. **Minimal installations**: Only required packages, no extras
+3. **Temp directories**: Tools downloaded to temp dirs, cleaned up after use
+4. **Streaming output**: Real-time feedback without buffering
+5. **Early start**: Formatting begins immediately after each tool is ready
+
+### Troubleshooting
+
+**If formatters appear to run sequentially:**
+- Check if output is being buffered (should use `sed` for line prefixing)
+- Ensure background processes use `&` and proper wait commands
+
+**If third-party files are being formatted:**
+- Review exclusion patterns in `scripts/run-clang-format.sh`
+- Check if new third-party directories were added that need exclusion
+
+**If clang-format installation is slow:**
+- Ensure using minimal package installation flags
+- Check if apt cache needs updating
+- Consider caching the clang-format binary between runs
+
+### Testing Changes Locally
+
+```bash
+# Test the clang-format script
+export LLVM_VERSION_MAJOR=19
+./scripts/run-clang-format.sh format
+
+# Test with check mode (no modifications)
+./scripts/run-clang-format.sh check
+
+# Test specific file exclusions
+./scripts/run-clang-format.sh format 2>&1 | grep -E "(libuv|napi|deps)"
+# Should return nothing if exclusions work correctly
+```
+
+### Important Notes
+- The script defaults to **format** mode (modifies files)
+- Always test locally before pushing workflow changes
+- The musl Zig build works on glibc systems due to static linking
+- Keep the exclusion list updated as new third-party code is added

.github/workflows/auto-label-claude-prs.yml

@@ -0,0 +1,24 @@
+name: Auto-label Claude PRs
+
+on:
+  pull_request:
+    types: [opened]
+
+jobs:
+  auto-label:
+    if: github.event.pull_request.user.login == 'robobun' || contains(github.event.pull_request.body, '🤖 Generated with')
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      pull-requests: write
+    steps:
+      - name: Add claude label to PRs from robobun
+        uses: actions/github-script@v7
+        with:
+          script: |
+            github.rest.issues.addLabels({
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              issue_number: context.issue.number,
+              labels: ['claude']
+            });

.github/workflows/bun-framework-next.yml

@@ -1,41 +0,0 @@
-name: bun-framework-next
-on:
-  push:
-    paths:
-      - packages/bun-framework-next/**/*
-    branches: [main, bun-framework-next-actions]
-  pull_request:
-    paths:
-      - packages/bun-framework-next/**/*
-    branches: [main]
-
-jobs:
-  build:
-    name: lint, test and build on Node ${{ matrix.node }} and ${{ matrix.os }}
-
-    runs-on: ${{ matrix.os }}
-
-    strategy:
-      matrix:
-        node: ["14.x"]
-        os: [macOS-latest]
-
-    steps:
-      - name: Checkout repo
-        uses: actions/checkout@v2
-
-      - name: Use Node ${{ matrix.node }}
-        uses: actions/setup-node@v2
-        with:
-          node-version: ${{ matrix.node }}
-
-      - name: Install PNPM
-        uses: pnpm/action-setup@v2.0.1
-        with:
-          version: 6.21.0
-
-      - name: Install dependencies
-        run: cd packages/bun-framework-next && pnpm install
-
-      - name: Type check bun-framework-next
-        run: cd packages/bun-framework-next && pnpm check

.github/workflows/bun.yml

@@ -1,167 +0,0 @@
-name: bun
-on:
-  push:
-    branches: [main, bun-actions]
-    paths-ignore:
-      - "examples/**"
-      - "bench/**"
-      - "README.*"
-      - "LICENSE"
-      - ".vscode"
-      - ".devcontainer"
-  pull_request:
-    branches: [main]
-    paths-ignore:
-      - "examples/**"
-      - "bench/**"
-      - README.*
-
-env:
-  REGISTRY: ghcr.io
-  IMAGE_NAME: ${{ github.repository }}
-  TEST_TAG: bun-test'
-
-jobs:
-  e2e:
-    runs-on: self-hosted
-    name: "Integration tests"
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v2
-      - name: Checkout submodules
-        run: git -c submodule."src/javascript/jsc/WebKit".update=none submodule update --init --recursive --depth=1 --progress -j 8
-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v1
-      - name: Login to Dockerhub
-        uses: docker/login-action@v1
-        with:
-          username: ${{ secrets.DOCKERHUB_USERNAME }}
-          password: ${{ secrets.DOCKERHUB_PASSWORD }}
-      - name: Pull Base Image
-        run: bash .docker/pull.sh
-      - name: Build tests
-        uses: docker/build-push-action@v2
-        with:
-          context: .
-          target: test_base
-          tags: bun-test:latest
-          load: true
-          cache-from: type=gha
-          cache-to: type=gha,mode=max
-          builder: ${{ steps.buildx.outputs.name }}
-      - name: Run test-with-hmr
-        env:
-          BUN_TEST_NAME: test-with-hmr
-          GITHUB_WORKSPACE: $GITHUB_WORKSPACE
-          RUNNER_TEMP: ${RUNNER_TEMP}
-        run: bash .docker/runner.sh
-      - name: Run test-no-hmr
-        env:
-          BUN_TEST_NAME: test-no-hmr
-          GITHUB_WORKSPACE: $GITHUB_WORKSPACE
-          RUNNER_TEMP: ${RUNNER_TEMP}
-        run: bash .docker/runner.sh
-      - name: Run test-bun-create-next
-        env:
-          RUNNER_TEMP: ${RUNNER_TEMP}
-          BUN_TEST_NAME: test-create-next
-          GITHUB_WORKSPACE: $GITHUB_WORKSPACE
-        run: bash .docker/runner.sh
-      - name: Run test-bun-create-react
-        env:
-          RUNNER_TEMP: ${RUNNER_TEMP}
-          BUN_TEST_NAME: test-create-react
-          GITHUB_WORKSPACE: $GITHUB_WORKSPACE
-        run: bash .docker/runner.sh
-      - name: Run test-bun-run
-        env:
-          RUNNER_TEMP: ${RUNNER_TEMP}
-          BUN_TEST_NAME: test-bun-run
-          GITHUB_WORKSPACE: $GITHUB_WORKSPACE
-        run: bash .docker/runner.sh
-      - name: Run test-bun-install
-        env:
-          RUNNER_TEMP: ${RUNNER_TEMP}
-          BUN_TEST_NAME: test-bun-install
-          GITHUB_WORKSPACE: $GITHUB_WORKSPACE
-        run: bash .docker/runner.sh
-  # This is commented out because zig test does not work on the CI
-  # Which sucks
-  # zig-unit-tests:
-  #   runs-on: self-hosted
-  #   name: "Unit tests (Zig)"
-  #   steps:
-  #     - name: Checkout
-  #       uses: actions/checkout@v2
-  #     - name: Checkout submodules
-  #       run: git -c submodule."src/javascript/jsc/WebKit".update=none submodule update --init --recursive --depth=1 --progress -j 8
-  #     - name: Set up Docker Buildx
-  #       uses: docker/setup-buildx-action@v1
-  #     - name: Login to Dockerhub
-  #       uses: docker/login-action@v1
-  #       with:
-  #         username: ${{ secrets.DOCKERHUB_USERNAME }}
-  #         password: ${{ secrets.DOCKERHUB_PASSWORD }}
-  #     - name: Pull Base Image
-  #       run: bash .docker/pull.sh
-  #     - name: Build tests
-  #       uses: docker/build-push-action@v2
-  #       with:
-  #         context: .
-  #         target: build_unit
-  #         tags: bun-unit-tests:latest
-  #         load: true
-  #         cache-from: type=gha
-  #         cache-to: type=gha,mode=max
-  #         builder: ${{ steps.buildx.outputs.name }}
-  #     - name: Run tests
-  #       env:
-  #         GITHUB_WORKSPACE: $GITHUB_WORKSPACE
-  #         RUNNER_TEMP: ${RUNNER_TEMP}
-  #       run: bash .docker/unit-tests.sh
-  release:
-    runs-on: self-hosted
-    needs: ["e2e"]
-    if: github.ref == 'refs/heads/main'
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v2
-      - name: Checkout submodules
-        run: git -c submodule."src/javascript/jsc/WebKit".update=none submodule update --init --recursive --depth=1 --progress -j 8
-      - name: Login to GitHub Container Registry
-        uses: docker/login-action@v1
-        with:
-          registry: ghcr.io
-          username: ${{ github.actor }}
-          password: ${{ secrets.GITHUB_TOKEN }}
-      - name: Login to DockerHub
-        uses: docker/login-action@v1
-        with:
-          username: jarredsumner
-          password: ${{ secrets.DOCKERHUB_ALT }}
-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v1
-        with:
-          install: true
-      - name: Pull Base Image
-        run: bash .docker/pull.sh
-      - name: Build release image
-        uses: docker/build-push-action@v2
-        with:
-          context: .
-          target: release
-          tags: |
-            ghcr.io/jarred-sumner/bun:${{github.sha}}
-            ghcr.io/jarred-sumner/bun:edge
-            jarredsumner/bun:${{github.sha}}
-            jarredsumner/bun:edge
-          platforms: |
-            linux/amd64
-          labels: |
-            org.opencontainers.image.title=bun
-            org.opencontainers.image.description=bun is a fast bundler, transpiler, JavaScript Runtime environment and package manager for web software. The image is an Ubuntu 20.04 image with bun preinstalled into /opt/bun.
-            org.opencontainers.image.vendor=bun
-            org.opencontainers.image.source=https://github.com/Jarred-Sumner/bun
-            org.opencontainers.image.url=https://bun.sh
-          builder: ${{ steps.buildx.outputs.name }}
-          push: true

.github/workflows/claude.yml

@@ -0,0 +1,67 @@
+name: Claude Code
+
+on:
+  issue_comment:
+    types: [created]
+  pull_request_review_comment:
+    types: [created]
+  issues:
+    types: [opened, assigned]
+  pull_request_review:
+    types: [submitted]
+
+jobs:
+  claude:
+    if: |
+      github.repository == 'oven-sh/bun' &&
+      (
+        (github.event_name == 'issue_comment' && (github.event.comment.author_association == 'MEMBER' || github.event.comment.author_association == 'OWNER' || github.event.comment.author_association == 'COLLABORATOR')) ||
+        (github.event_name == 'pull_request_review_comment' && (github.event.comment.author_association == 'MEMBER' || github.event.comment.author_association == 'OWNER' || github.event.comment.author_association == 'COLLABORATOR')) ||
+        (github.event_name == 'pull_request_review' && (github.event.review.author_association == 'MEMBER' || github.event.review.author_association == 'OWNER' || github.event.review.author_association == 'COLLABORATOR')) ||
+        (github.event_name == 'issues' && (github.event.issue.author_association == 'MEMBER' || github.event.issue.author_association == 'OWNER' || github.event.issue.author_association == 'COLLABORATOR'))
+      ) &&
+      (github.event_name == 'issue_comment' && contains(github.event.comment.body, '@claude')) ||
+      (github.event_name == 'pull_request_review_comment' && contains(github.event.comment.body, '@claude')) ||
+      (github.event_name == 'pull_request_review' && contains(github.event.review.body, '@claude')) ||
+      (github.event_name == 'issues' && (contains(github.event.issue.body, '@claude') || contains(github.event.issue.title, '@claude')))
+    runs-on: claude
+    env:
+      IS_SANDBOX: 1
+    container:
+      image: localhost:5000/claude-bun:latest
+      options: --privileged --user 1000:1000
+    permissions:
+      contents: read
+      id-token: write
+    steps:
+      - name: Checkout repository
+        working-directory: /workspace/bun
+        run: |
+          git config --global user.email "claude-bot@bun.sh" && \
+          git config --global user.name "Claude Bot" && \
+          git config --global url."git@github.com:".insteadOf "https://github.com/" && \
+          git config --global url."git@github.com:".insteadOf "http://github.com/" && \
+          git config --global --add safe.directory /workspace/bun && \
+          git config --global push.default current && \
+          git config --global pull.rebase true && \
+          git config --global init.defaultBranch main && \
+          git config --global core.editor "vim" && \
+          git config --global color.ui auto && \
+          git config --global fetch.prune true && \
+          git config --global diff.colorMoved zebra && \
+          git config --global merge.conflictStyle diff3 && \
+          git config --global rerere.enabled true && \
+          git config --global core.autocrlf input
+          git fetch origin ${{ github.event.pull_request.head.sha }}
+          git checkout ${{ github.event.pull_request.head.ref }}
+          git reset --hard origin/${{ github.event.pull_request.head.ref }}
+      - name: Run Claude Code
+        id: claude
+        # TODO: switch this out once they merge their v1
+        uses: km-anthropic/claude-code-action@v1-dev
+        with:
+          timeout_minutes: "180"
+          claude_args: |
+            --dangerously-skip-permissions
+            --system-prompt "You are working on the Bun codebase"
+          claude_code_oauth_token: ${{ secrets.CLAUDE_CODE_OAUTH_TOKEN }}

.github/workflows/codex-test-sync.yml

@@ -0,0 +1,58 @@
+name: Codex Test Sync
+
+on:
+  pull_request:
+    types: [labeled, opened]
+
+env:
+  BUN_VERSION: "1.2.15"
+
+jobs:
+  sync-node-tests:
+    runs-on: ubuntu-latest
+    if: |
+      (github.event.action == 'labeled' && github.event.label.name == 'codex') ||
+      (github.event.action == 'opened' && contains(github.event.pull_request.labels.*.name, 'codex')) ||
+      contains(github.head_ref, 'codex')
+    permissions:
+      contents: write
+      pull-requests: write
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          token: ${{ secrets.GITHUB_TOKEN }}
+          fetch-depth: 0
+
+      - name: Setup Bun
+        uses: ./.github/actions/setup-bun
+        with:
+          bun-version: ${{ env.BUN_VERSION }}
+
+      - name: Get changed files
+        id: changed-files
+        uses: tj-actions/changed-files@v44
+        with:
+          files: |
+            test/js/node/test/parallel/**/*.{js,mjs,ts}
+            test/js/node/test/sequential/**/*.{js,mjs,ts}
+
+      - name: Sync tests
+        if: steps.changed-files.outputs.any_changed == 'true'
+        shell: bash
+        run: |
+          echo "Changed test files:"
+          echo "${{ steps.changed-files.outputs.all_changed_files }}"
+
+          # Process each changed test file
+          for file in ${{ steps.changed-files.outputs.all_changed_files }}; do
+            # Extract test name from file path
+            test_name=$(basename "$file" | sed 's/\.[^.]*$//')
+            echo "Syncing test: $test_name"
+            bun node:test:cp "$test_name"
+          done
+
+      - name: Commit changes
+        uses: stefanzweifel/git-auto-commit-action@v5
+        with:
+          commit_message: "Sync Node.js tests with upstream"

.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/docs.yml

@@ -0,0 +1,24 @@
+name: Docs
+
+on:
+  push:
+    paths:
+      - "docs/**"
+      - "packages/bun-types/**.d.ts"
+      - "CONTRIBUTING.md"
+      - "src/cli/install.sh"
+      - "src/cli/install.ps1"
+    branches:
+      - main
+
+jobs:
+  deploy:
+    name: Deploy
+    runs-on: ubuntu-latest
+    if: ${{ github.repository_owner == 'oven-sh' }}
+    steps:
+      # redeploy Vercel site when a file in `docs` changes
+      # using VERCEL_DEPLOY_HOOK environment variable
+      - name: Trigger Webhook
+        run: |
+          curl -v ${{ secrets.VERCEL_DEPLOY_HOOK }}

.github/workflows/format.yml

@@ -0,0 +1,109 @@
+name: autofix.ci
+
+permissions:
+  contents: read
+
+on:
+  workflow_call:
+  workflow_dispatch:
+  pull_request:
+  merge_group:
+env:
+  BUN_VERSION: "1.2.20"
+  LLVM_VERSION: "19.1.7"
+  LLVM_VERSION_MAJOR: "19"
+
+jobs:
+  autofix:
+    name: Format
+    runs-on: ubuntu-latest
+    concurrency:
+      group: ${{ github.workflow }}-${{ github.ref }}
+      cancel-in-progress: true
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+      - name: Configure Git
+        run: |
+          git config --global core.autocrlf true
+          git config --global core.ignorecase true
+          git config --global core.precomposeUnicode true
+      - name: Setup Bun
+        uses: ./.github/actions/setup-bun
+        with:
+          bun-version: ${{ env.BUN_VERSION }}
+      - name: Setup Dependencies
+        run: |
+          bun install
+          bun scripts/glob-sources.mjs
+      - name: Format Code
+        run: |
+          # Start prettier in background with prefixed output
+          echo "::group::Prettier"
+          (bun run prettier 2>&1 | sed 's/^/[prettier] /' || echo "[prettier] Failed with exit code $?") &
+          PRETTIER_PID=$!
+
+          # Start clang-format installation and formatting in background with prefixed output
+          echo "::group::Clang-format"
+          (
+            echo "[clang-format] Installing clang-format-${{ env.LLVM_VERSION_MAJOR }}..."
+            wget -qO- https://apt.llvm.org/llvm-snapshot.gpg.key | sudo tee /etc/apt/trusted.gpg.d/apt.llvm.org.asc > /dev/null
+            echo "deb http://apt.llvm.org/$(lsb_release -cs)/ llvm-toolchain-$(lsb_release -cs)-${{ env.LLVM_VERSION_MAJOR }} main" | sudo tee /etc/apt/sources.list.d/llvm.list > /dev/null
+            sudo apt-get update -qq
+            sudo apt-get install -y -qq --no-install-recommends --no-install-suggests -o=Dpkg::Use-Pty=0 clang-format-${{ env.LLVM_VERSION_MAJOR }}
+            echo "[clang-format] Running clang-format..."
+            LLVM_VERSION_MAJOR=${{ env.LLVM_VERSION_MAJOR }} ./scripts/run-clang-format.sh format 2>&1 | sed 's/^/[clang-format] /'
+          ) &
+          CLANG_PID=$!
+
+          # Setup Zig in temp directory and run zig fmt in background with prefixed output
+          echo "::group::Zig fmt"
+          (
+            ZIG_TEMP=$(mktemp -d)
+            echo "[zig] Downloading Zig (musl build)..."
+            wget -q -O "$ZIG_TEMP/zig.zip" https://github.com/oven-sh/zig/releases/download/autobuild-e0b7c318f318196c5f81fdf3423816a7b5bb3112/bootstrap-x86_64-linux-musl.zip
+            unzip -q -d "$ZIG_TEMP" "$ZIG_TEMP/zig.zip"
+            export PATH="$ZIG_TEMP/bootstrap-x86_64-linux-musl:$PATH"
+            echo "[zig] Running zig fmt..."
+            zig fmt src 2>&1 | sed 's/^/[zig] /'
+            ./scripts/sort-imports.ts src 2>&1 | sed 's/^/[zig] /'
+            zig fmt src 2>&1 | sed 's/^/[zig] /'
+            rm -rf "$ZIG_TEMP"
+          ) &
+          ZIG_PID=$!
+
+          # Wait for all formatting tasks to complete
+          echo ""
+          echo "Running formatters in parallel..."
+          FAILED=0
+
+          if ! wait $PRETTIER_PID; then
+            echo "::error::Prettier failed"
+            FAILED=1
+          fi
+          echo "::endgroup::"
+
+          if ! wait $CLANG_PID; then
+            echo "::error::Clang-format failed"
+            FAILED=1
+          fi
+          echo "::endgroup::"
+
+          if ! wait $ZIG_PID; then
+            echo "::error::Zig fmt failed"
+            FAILED=1
+          fi
+          echo "::endgroup::"
+
+          # Exit with error if any formatter failed
+          if [ $FAILED -eq 1 ]; then
+            echo "::error::One or more formatters failed"
+            exit 1
+          fi
+
+          echo "✅ All formatters completed successfully"
+      - name: Ban Words
+        run: |
+          bun ./test/internal/ban-words.test.ts
+          git rm -f cmake/sources/*.txt || true
+      - uses: autofix-ci/action@635ffb0c9798bd160680f18fd73371e355b85f27

.github/workflows/labeled.yml

@@ -0,0 +1,223 @@
+name: Issue Labeled
+env:
+  BUN_VERSION: 1.1.44
+
+on:
+  issues:
+    types: [labeled]
+  pull_request_target:
+    types: [labeled, opened, reopened, synchronize, unlabeled]
+
+jobs:
+  # on-bug:
+  #   runs-on: ubuntu-latest
+  #   if: github.event.label.name == 'bug' || github.event.label.name == 'crash'
+  #   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: ${{ env.BUN_VERSION }}
+  #     - name: "categorize bug"
+  #       id: add-labels
+  #       env:
+  #         GITHUB_ISSUE_BODY: ${{ github.event.issue.body }}
+  #         GITHUB_ISSUE_TITLE: ${{ github.event.issue.title }}
+  #         ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
+  #       shell: bash
+  #       run: |
+  #         echo '{"dependencies": { "@anthropic-ai/sdk": "latest" }}' > scripts/package.json && bun install --cwd=./scripts
+  #         LABELS=$(bun scripts/label-issue.ts)
+  #         echo "labels=$LABELS" >> $GITHUB_OUTPUT
+  #     - name: Add labels
+  #       uses: actions-cool/issues-helper@v3
+  #       if: steps.add-labels.outputs.labels != ''
+  #       with:
+  #         actions: "add-labels"
+  #         token: ${{ secrets.GITHUB_TOKEN }}
+  #         issue-number: ${{ github.event.issue.number }}
+  #         labels: ${{ steps.add-labels.outputs.labels }}
+  on-slop:
+    runs-on: ubuntu-latest
+    if: github.event_name == 'pull_request_target' && contains(github.event.pull_request.labels.*.name, 'slop')
+    permissions:
+      issues: write
+      pull-requests: write
+      contents: write
+    steps:
+      - name: Update PR title and body for slop and close
+        uses: actions/github-script@v7
+        with:
+          script: |
+            const pr = await github.rest.pulls.get({
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              pull_number: context.issue.number
+            });
+
+            await github.rest.pulls.update({
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              pull_number: context.issue.number,
+              title: 'ai slop',
+              body: 'This PR has been marked as AI slop and the description has been updated to avoid confusion or misleading reviewers.\n\nMany AI PRs are fine, but sometimes they submit a PR too early, fail to test if the problem is real, fail to reproduce the problem, or fail to test that the problem is fixed. If you think this PR is not AI slop, please leave a comment.',
+              state: 'closed'
+            });
+
+            // Delete the branch if it's from a fork or if it's not a protected branch
+            try {
+              await github.rest.git.deleteRef({
+                owner: context.repo.owner,
+                repo: context.repo.repo,
+                ref: `heads/${pr.data.head.ref}`
+              });
+            } catch (error) {
+              console.log('Could not delete branch:', error.message);
+            }
+  on-labeled:
+    runs-on: ubuntu-latest
+    if: github.event_name == 'issues' && (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: ${{ env.BUN_VERSION }}
+      - 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)
+          bun scripts/is-outdated.ts
+
+          if [[ -f "is-outdated.txt" ]]; then
+            echo "is-outdated=true" >> $GITHUB_OUTPUT
+          fi
+
+          if [[ -f "outdated.txt" ]]; then
+            echo "outdated=$(cat outdated.txt)" >> $GITHUB_OUTPUT
+          fi
+
+          if [[ -f "is-very-outdated.txt" ]]; then
+            echo "is-very-outdated=true" >> $GITHUB_OUTPUT
+            LABELS="$LABELS,old-version"
+          else
+            echo "is-very-outdated=false" >> $GITHUB_OUTPUT
+          fi
+
+          echo "latest=$(cat LATEST)" >> $GITHUB_OUTPUT
+          echo "labels=$LABELS" >> $GITHUB_OUTPUT
+          rm -rf is-outdated.txt outdated.txt latest.txt is-very-outdated.txt
+      - name: Generate comment text with Sentry Link
+        if: github.event.label.name == 'crash'
+        # ignore if fail
+        continue-on-error: true
+        id: generate-comment-text
+        env:
+          GITHUB_ISSUE_BODY: ${{ github.event.issue.body }}
+          SENTRY_AUTH_TOKEN: ${{ secrets.SENTRY_EVENTS_SECRET }}
+        shell: bash
+        run: |
+          bun scripts/associate-issue-with-sentry.ts
+
+          if [[ -f "sentry-link.txt" ]]; then
+            echo "sentry-link=$(cat sentry-link.txt)" >> $GITHUB_OUTPUT
+          fi
+
+          if [[ -f "sentry-id.txt" ]]; then
+            echo "sentry-id=$(cat sentry-id.txt)" >> $GITHUB_OUTPUT
+          fi
+      - name: Remove old labels
+        uses: actions-cool/issues-helper@v3
+        if: github.event.label.name == 'crash' && steps.add-labels.outputs.is-very-outdated == 'false'
+        with:
+          actions: "remove-labels"
+          token: ${{ secrets.GITHUB_TOKEN }}
+          issue-number: ${{ github.event.issue.number }}
+          labels: old-version
+      - 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' && steps.generate-comment-text.outputs.sentry-link == ''
+        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.outdated }}.
+
+            Are you able to reproduce this crash on the latest version of Bun?
+
+            ```sh
+            bun upgrade
+            ```
+      - name: Comment with Sentry Link and outdated version
+        if: steps.generate-comment-text.outputs.sentry-link != '' && github.event.label.name == 'crash' && steps.add-labels.outputs.is-outdated == 'true'
+        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 }}, thank you for reporting this crash. The latest version of Bun is v${{ steps.add-labels.outputs.latest }}, but this crash was reported on Bun v${{ steps.add-labels.outputs.outdated }}.
+
+            Are you able to reproduce this crash on the latest version of Bun?
+
+            ```sh
+            bun upgrade
+            ```
+
+            For Bun's internal tracking, this issue is [${{ steps.generate-comment-text.outputs.sentry-id }}](${{ steps.generate-comment-text.outputs.sentry-link }}).
+
+            <!-- sentry-id: ${{ steps.generate-comment-text.outputs.sentry-id }} -->
+            <!-- sentry-link: ${{ steps.generate-comment-text.outputs.sentry-link }} -->
+      - name: Comment with Sentry Link
+        if: steps.generate-comment-text.outputs.sentry-link != '' && github.event.label.name == 'crash' && steps.add-labels.outputs.is-outdated != 'true'
+        uses: actions-cool/issues-helper@v3
+        with:
+          actions: "create-comment"
+          token: ${{ secrets.GITHUB_TOKEN }}
+          issue-number: ${{ github.event.issue.number }}
+          body: |
+            Thank you for reporting this crash.
+
+            For Bun's internal tracking, this issue is [${{ steps.generate-comment-text.outputs.sentry-id }}](${{ steps.generate-comment-text.outputs.sentry-link }}).
+
+            <!-- sentry-id: ${{ steps.generate-comment-text.outputs.sentry-id }} -->
+            <!-- sentry-link: ${{ steps.generate-comment-text.outputs.sentry-link }} -->
+      - 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), [CodeSandbox](https://codesandbox.io/templates/bun), or provide a bulleted list of commands to run that reproduce this issue. Issues marked with `needs repro` will be closed if they have no activity within 3 days.

.github/workflows/lint.yml

@@ -0,0 +1,21 @@
+name: Lint
+
+on:
+  pull_request:
+  workflow_dispatch:
+
+env:
+  BUN_VERSION: "1.2.10"
+
+jobs:
+  lint-js:
+    name: "Lint JavaScript"
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Setup Bun
+        uses: ./.github/actions/setup-bun
+        with:
+          bun-version: ${{ env.BUN_VERSION }}
+      - name: Lint
+        run: bun lint

.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/packages-ci.yml

@@ -0,0 +1,55 @@
+name: Packages CI
+
+on:
+  push:
+    branches:
+      - main
+    paths:
+      - "packages/**"
+      - .prettierrc
+      - .prettierignore
+      - tsconfig.json
+      - oxlint.json
+      - "!**/*.md"
+  pull_request:
+    branches:
+      - main
+    paths:
+      - "packages/**"
+      - .prettierrc
+      - .prettierignore
+      - tsconfig.json
+      - oxlint.json
+      - "!**/*.md"
+
+env:
+  BUN_VERSION: "canary"
+
+jobs:
+  bun-plugin-svelte:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Setup Bun
+        uses: ./.github/actions/setup-bun
+        with:
+          bun-version: ${{ env.BUN_VERSION }}
+
+      - name: Install dependencies
+        run: |
+          bun install
+          pushd ./packages/bun-plugin-svelte && bun install
+
+      - name: Lint
+        run: |
+          bunx oxlint@0.15 --format github --deny-warnings
+          bunx prettier --config ../../.prettierrc --check .
+        working-directory: ./packages/bun-plugin-svelte
+
+      - name: Check types
+        run: bun check:types
+        working-directory: ./packages/bun-plugin-svelte
+
+      - name: Test
+        run: bun test
+        working-directory: ./packages/bun-plugin-svelte

.github/workflows/release.yml

@@ -0,0 +1,368 @@
+# TODO: Move this to bash scripts intead of Github Actions
+# so it can be run from Buildkite, see: .buildkite/scripts/release.sh
+
+name: Release
+concurrency: release
+
+env:
+  BUN_VERSION: ${{ github.event.inputs.tag || github.event.release.tag_name || 'canary' }}
+  BUN_LATEST: ${{ (github.event.inputs.is-latest || github.event.release.tag_name) && 'true' || 'false' }}
+
+on:
+  release:
+    types:
+      - published
+  schedule:
+    - cron: "0 14 * * *" # every day at 6am PST
+  workflow_dispatch:
+    inputs:
+      is-latest:
+        description: Is this the latest release?
+        type: boolean
+        default: false
+      tag:
+        type: string
+        description: What is the release tag? (e.g. "1.0.2", "canary")
+        required: true
+      use-docker:
+        description: Should Docker images be released?
+        type: boolean
+        default: false
+      use-npm:
+        description: Should npm packages be published?
+        type: boolean
+        default: false
+      use-homebrew:
+        description: Should binaries be released to Homebrew?
+        type: boolean
+        default: false
+      use-s3:
+        description: Should binaries be uploaded to S3?
+        type: boolean
+        default: false
+      use-types:
+        description: Should types be released to npm?
+        type: boolean
+        default: false
+      use-definitelytyped:
+        description: "Should types be PR'd to DefinitelyTyped?"
+        type: boolean
+        default: false
+
+jobs:
+  sign:
+    name: Sign Release
+    runs-on: ubuntu-latest
+    if: ${{ github.repository_owner == 'oven-sh' }}
+    permissions:
+      contents: write
+    defaults:
+      run:
+        working-directory: packages/bun-release
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+      - name: Setup GPG
+        uses: crazy-max/ghaction-import-gpg@v5
+        with:
+          gpg_private_key: ${{ secrets.GPG_PRIVATE_KEY }}
+          passphrase: ${{ secrets.GPG_PASSPHRASE }}
+      - name: Setup Bun
+        uses: ./.github/actions/setup-bun
+        with:
+          bun-version: "1.2.3"
+      - name: Install Dependencies
+        run: bun install
+      - name: Sign Release
+        run: |
+          echo "$GPG_PASSPHRASE" | bun upload-assets -- "${{ env.BUN_VERSION }}"
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          GPG_PASSPHRASE: ${{ secrets.GPG_PASSPHRASE }}
+  npm:
+    name: Release to NPM
+    runs-on: ubuntu-latest
+    needs: sign
+    if: ${{ github.event_name != 'workflow_dispatch' || github.event.inputs.use-npm == 'true' }}
+    permissions:
+      contents: read
+    defaults:
+      run:
+        working-directory: packages/bun-release
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          # To workaround issue
+          ref: main
+      - name: Setup Bun
+        uses: ./.github/actions/setup-bun
+        with:
+          bun-version: "1.2.3"
+      - name: Install Dependencies
+        run: bun install
+      - name: Release
+        run: bun upload-npm -- "${{ env.BUN_VERSION }}" publish
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          NPM_TOKEN: ${{ secrets.NPM_TOKEN }}
+  npm-types:
+    name: Release types to NPM
+    runs-on: ubuntu-latest
+    needs: sign
+    if: ${{ github.event_name != 'workflow_dispatch' || github.event.inputs.use-types == 'true' }}
+    permissions:
+      contents: read
+    defaults:
+      run:
+        working-directory: packages/bun-types
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+      - name: Setup Node.js
+        uses: actions/setup-node@v3
+        with:
+          node-version: latest
+      - name: Setup Bun
+        if: ${{ env.BUN_VERSION != 'canary' }}
+        uses: ./.github/actions/setup-bun
+        with:
+          bun-version: "1.2.3"
+      - name: Setup Bun
+        if: ${{ env.BUN_VERSION == 'canary' }}
+        uses: ./.github/actions/setup-bun
+        with:
+          bun-version: "canary" # Must be 'canary' so tag is correct
+      - name: Install Dependencies
+        run: bun install
+      - name: Setup Tag
+        if: ${{ env.BUN_VERSION == 'canary' }}
+        run: |
+          VERSION=$(bun --version)
+          TAG="${VERSION}-canary.$(date +'%Y%m%dT%H%M%S')"
+          echo "Setup tag: ${TAG}"
+          echo "TAG=${TAG}" >> ${GITHUB_ENV}
+      - name: Build
+        run: bun run build
+        env:
+          BUN_VERSION: ${{ env.TAG || env.BUN_VERSION }}
+      - name: Release (canary)
+        if: ${{ env.BUN_VERSION == 'canary' }}
+        uses: JS-DevTools/npm-publish@v1
+        with:
+          package: packages/bun-types/package.json
+          token: ${{ secrets.NPM_TOKEN }}
+          tag: canary
+      - name: Release (latest)
+        if: ${{ env.BUN_LATEST == 'true' }}
+        uses: JS-DevTools/npm-publish@v1
+        with:
+          package: packages/bun-types/package.json
+          token: ${{ secrets.NPM_TOKEN }}
+  definitelytyped:
+    name: Make pr to DefinitelyTyped to update `bun-types` version
+    runs-on: ubuntu-latest
+    needs: npm-types
+    if: ${{ github.event_name == 'release' || github.event.inputs.use-definitelytyped == 'true' }}
+    permissions:
+      contents: read
+    steps:
+      - name: Checkout (DefinitelyTyped)
+        uses: actions/checkout@v4
+        with:
+          repository: DefinitelyTyped/DefinitelyTyped
+      - name: Checkout (bun)
+        uses: actions/checkout@v4
+        with:
+          path: bun
+      - name: Setup Bun
+        uses: ./bun/.github/actions/setup-bun
+        with:
+          bun-version: "1.2.0"
+      - id: bun-version
+        run: echo "BUN_VERSION=${BUN_VERSION#bun-v}" >> "$GITHUB_OUTPUT"
+      - name: Update bun-types version in package.json
+        run: |
+          bun -e '
+          const file = Bun.file("./types/bun/package.json");
+          const json = await file.json();
+          const version = "${{ steps.bun-version.outputs.BUN_VERSION }}"; 
+          json.dependencies["bun-types"] = version;
+          json.version = version.slice(0, version.lastIndexOf(".")) + ".9999";
+          await file.write(JSON.stringify(json, null, 4) + "\n");
+          '
+      - name: Create Pull Request
+        uses: peter-evans/create-pull-request@v7
+        if: ${{ env.BUN_LATEST == 'true' && env.BUN_VERSION != 'canary'}}
+        with:
+          token: ${{ secrets.ROBOBUN_TOKEN }}
+          add-paths: ./types/bun/package.json
+          title: "[bun] update to ${{ steps.bun-version.outputs.BUN_VERSION }}"
+          commit-message: "[bun] update to ${{ steps.bun-version.outputs.BUN_VERSION }}"
+          body: |
+            Update `bun-types` version to ${{ steps.bun-version.outputs.BUN_VERSION }}
+
+            https://bun.com/blog/${{ env.BUN_VERSION }}
+          push-to-fork: oven-sh/DefinitelyTyped
+          branch: ${{env.BUN_VERSION}}
+  docker:
+    name: Release to Dockerhub
+    runs-on: ubuntu-latest
+    needs: sign
+    if: ${{ github.event_name != 'workflow_dispatch' || github.event.inputs.use-docker == 'true' }}
+    permissions:
+      contents: read
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - variant: debian
+            suffix: ""
+          - variant: debian
+            suffix: -debian
+          - variant: slim
+            suffix: -slim
+            dir: debian-slim
+          - variant: alpine
+            suffix: -alpine
+          - variant: distroless
+            suffix: -distroless
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+      - name: Setup Docker emulator
+        uses: docker/setup-qemu-action@v3
+      - id: buildx
+        name: Setup Docker buildx
+        uses: docker/setup-buildx-action@v3
+        with:
+          platforms: linux/amd64,linux/arm64
+      - id: metadata
+        name: Setup Docker metadata
+        uses: docker/metadata-action@v5
+        with:
+          images: oven/bun
+          flavor: |
+            latest=false
+          tags: |
+            type=raw,value=latest,enable=${{ env.BUN_LATEST == 'true' && matrix.suffix == '' }}
+            type=raw,value=${{ matrix.variant }},enable=${{ env.BUN_LATEST == 'true' }}
+            type=match,pattern=(bun-v)?(canary|\d+.\d+.\d+),group=2,value=${{ env.BUN_VERSION }},suffix=${{ matrix.suffix }}
+            type=match,pattern=(bun-v)?(canary|\d+.\d+),group=2,value=${{ env.BUN_VERSION }},suffix=${{ matrix.suffix }}
+            type=match,pattern=(bun-v)?(canary|\d+),group=2,value=${{ env.BUN_VERSION }},suffix=${{ matrix.suffix }}
+      - name: Login to Docker
+        uses: docker/login-action@v3
+        with:
+          username: ${{ secrets.DOCKER_USERNAME }}
+          password: ${{ secrets.DOCKER_PASSWORD }}
+      - name: Push to Docker
+        uses: docker/build-push-action@v6
+        with:
+          context: ./dockerhub/${{ matrix.dir || matrix.variant }}
+          platforms: linux/amd64,linux/arm64
+          builder: ${{ steps.buildx.outputs.name }}
+          push: true
+          tags: ${{ steps.metadata.outputs.tags }}
+          labels: ${{ steps.metadata.outputs.labels }}
+          build-args: |
+            BUN_VERSION=${{ env.BUN_VERSION }}
+  homebrew:
+    name: Release to Homebrew
+    runs-on: ubuntu-latest
+    needs: sign
+    permissions:
+      contents: read
+    if: ${{ github.event_name == 'release' || github.event.inputs.use-homebrew == 'true' }}
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          repository: oven-sh/homebrew-bun
+          token: ${{ secrets.ROBOBUN_TOKEN }}
+      - id: gpg
+        name: Setup GPG
+        uses: crazy-max/ghaction-import-gpg@v5
+        with:
+          gpg_private_key: ${{ secrets.GPG_PRIVATE_KEY }}
+          passphrase: ${{ secrets.GPG_PASSPHRASE }}
+      - name: Setup Ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: "2.6"
+      - name: Update Tap
+        run: ruby scripts/release.rb "${{ env.BUN_VERSION }}"
+      - name: Commit Tap
+        uses: stefanzweifel/git-auto-commit-action@v4
+        with:
+          commit_options: --gpg-sign=${{ steps.gpg.outputs.keyid }}
+          commit_message: Release ${{ env.BUN_VERSION }}
+          commit_user_name: robobun
+          commit_user_email: robobun@oven.sh
+          commit_author: robobun <robobun@oven.sh>
+  s3:
+    name: Upload to S3
+    runs-on: ubuntu-latest
+    needs: sign
+    if: ${{ github.event_name != 'workflow_dispatch' || github.event.inputs.use-s3 == 'true' }}
+    permissions:
+      contents: read
+    defaults:
+      run:
+        working-directory: packages/bun-release
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+      - name: Setup Bun
+        uses: ./.github/actions/setup-bun
+        with:
+          bun-version: "1.2.0"
+      - name: Install Dependencies
+        run: bun install
+      - name: Release
+        run: bun upload-s3 -- "${{ env.BUN_VERSION }}"
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          AWS_ACCESS_KEY_ID: ${{ secrets.AWS_ACCESS_KEY_ID }}
+          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.2.0"
+      - name: Bump version
+        uses: ./.github/actions/bump
+        if: ${{ env.BUN_LATEST == 'true' }}
+        with:
+          version: ${{ env.BUN_VERSION }}
+          token: ${{ github.token }}

.github/workflows/stale.yaml

@@ -0,0 +1,30 @@
+name: Close inactive issues
+on:
+  # schedule:
+  #   - cron: "15 * * * *"
+  workflow_dispatch:
+
+jobs:
+  close-issues:
+    runs-on: ubuntu-latest
+    permissions:
+      issues: write
+      pull-requests: write
+    steps:
+      - uses: actions/stale@v5
+        with:
+          days-before-issue-close: 5
+          any-of-issue-labels: "needs repro,waiting-for-author"
+          exempt-issue-labels: "neverstale"
+          exempt-pr-labels: "neverstale"
+          remove-stale-when-updated: true
+          stale-issue-label: "stale"
+          stale-pr-label: "stale"
+          stale-issue-message: "This issue is stale and may be closed due to inactivity. If you're still running into this, please leave a comment."
+          close-issue-message: "This issue was closed because it has been inactive for 5 days since being marked as stale."
+          days-before-pr-stale: 30
+          days-before-pr-close: 14
+          stale-pr-message: "This pull request is stale and may be closed due to inactivity."
+          close-pr-message: "This pull request has been closed due to inactivity."
+          repo-token: ${{ github.token }}
+          operations-per-run: 1000

.github/workflows/test-bump.yml

@@ -0,0 +1,32 @@
+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
+
+env:
+  BUN_VERSION: "1.2.0"
+
+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: ${{ env.BUN_VERSION }}
+      - name: Bump version
+        uses: ./.github/actions/bump
+        with:
+          version: ${{ inputs.version }}
+          token: ${{ github.token }}

.github/workflows/typos.yml

@@ -0,0 +1,19 @@
+name: Typos
+
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+    branches:
+      - main
+
+jobs:
+  docs:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Spellcheck
+        uses: crate-ci/typos@v1.29.4
+        with:
+          files: docs/**/*

.github/workflows/update-cares.yml

@@ -0,0 +1,99 @@
+name: Update c-ares
+
+on:
+  schedule:
+    - cron: "0 4 * * 0"
+  workflow_dispatch:
+
+jobs:
+  check-update:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+      pull-requests: write
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Check c-ares version
+        id: check-version
+        run: |
+          set -euo pipefail
+
+          # Extract the commit hash from the line after COMMIT
+          CURRENT_VERSION=$(awk '/[[:space:]]*COMMIT[[:space:]]*$/{getline; gsub(/^[[:space:]]+|[[:space:]]+$/,"",$0); print}' cmake/targets/BuildCares.cmake)
+
+          if [ -z "$CURRENT_VERSION" ]; then
+            echo "Error: Could not find COMMIT line in BuildCares.cmake"
+            exit 1
+          fi
+
+          # Validate that it looks like a git hash
+          if ! [[ $CURRENT_VERSION =~ ^[0-9a-f]{40}$ ]]; then
+            echo "Error: Invalid git hash format in BuildCares.cmake"
+            echo "Found: $CURRENT_VERSION"
+            echo "Expected: 40 character hexadecimal string"
+            exit 1
+          fi
+
+          echo "current=$CURRENT_VERSION" >> $GITHUB_OUTPUT
+
+          LATEST_RELEASE=$(curl -sL https://api.github.com/repos/c-ares/c-ares/releases/latest)
+          if [ -z "$LATEST_RELEASE" ]; then
+            echo "Error: Failed to fetch latest release from GitHub API"
+            exit 1
+          fi
+
+          LATEST_TAG=$(echo "$LATEST_RELEASE" | jq -r '.tag_name')
+          if [ -z "$LATEST_TAG" ] || [ "$LATEST_TAG" = "null" ]; then
+            echo "Error: Could not extract tag name from GitHub API response"
+            exit 1
+          fi
+
+          LATEST_TAG_SHA=$(curl -sL "https://api.github.com/repos/c-ares/c-ares/git/refs/tags/$LATEST_TAG" | jq -r '.object.sha')
+          if [ -z "$LATEST_TAG_SHA" ] || [ "$LATEST_TAG_SHA" = "null" ]; then
+            echo "Error: Could not fetch SHA for tag $LATEST_TAG"
+            exit 1
+          fi
+          LATEST_SHA=$(curl -sL "https://api.github.com/repos/c-ares/c-ares/git/tags/$LATEST_TAG_SHA" | jq -r '.object.sha')
+          if [ -z "$LATEST_SHA" ] || [ "$LATEST_SHA" = "null" ]; then
+            echo "Error: Could not fetch SHA for tag $LATEST_TAG @ $LATEST_TAG_SHA"
+            exit 1
+          fi
+
+          if ! [[ $LATEST_SHA =~ ^[0-9a-f]{40}$ ]]; then
+            echo "Error: Invalid SHA format received from GitHub"
+            echo "Found: $LATEST_SHA"
+            echo "Expected: 40 character hexadecimal string"
+            exit 1
+          fi
+
+          echo "latest=$LATEST_SHA" >> $GITHUB_OUTPUT
+          echo "tag=$LATEST_TAG" >> $GITHUB_OUTPUT
+
+      - name: Update version if needed
+        if: success() && steps.check-version.outputs.current != steps.check-version.outputs.latest
+        run: |
+          set -euo pipefail
+          # Handle multi-line format where COMMIT and its value are on separate lines
+          sed -i -E '/[[:space:]]*COMMIT[[:space:]]*$/{n;s/[[:space:]]*([0-9a-f]+)[[:space:]]*$/    ${{ steps.check-version.outputs.latest }}/}' cmake/targets/BuildCares.cmake
+
+      - name: Create Pull Request
+        if: success() && steps.check-version.outputs.current != steps.check-version.outputs.latest
+        uses: peter-evans/create-pull-request@v4
+        with:
+          token: ${{ secrets.GITHUB_TOKEN }}
+          add-paths: |
+            cmake/targets/BuildCares.cmake
+          commit-message: "deps: update c-ares to ${{ steps.check-version.outputs.tag }} (${{ steps.check-version.outputs.latest }})"
+          title: "deps: update c-ares to ${{ steps.check-version.outputs.tag }}"
+          delete-branch: true
+          branch: deps/update-cares-${{ github.run_number }}
+          body: |
+            ## What does this PR do?
+
+            Updates c-ares to version ${{ steps.check-version.outputs.tag }}
+
+            Compare: https://github.com/c-ares/c-ares/compare/${{ steps.check-version.outputs.current }}...${{ steps.check-version.outputs.latest }}
+
+            Auto-updated by [this workflow](https://github.com/oven-sh/bun/actions/workflows/update-cares.yml)

.github/workflows/update-hdrhistogram.yml

@@ -0,0 +1,102 @@
+name: Update hdrhistogram
+
+on:
+  schedule:
+    - cron: "0 4 * * 0"
+  workflow_dispatch:
+
+jobs:
+  check-update:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+      pull-requests: write
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Check hdrhistogram version
+        id: check-version
+        run: |
+          set -euo pipefail
+
+          # Extract the commit hash from the line after COMMIT
+          CURRENT_VERSION=$(awk '/[[:space:]]*COMMIT[[:space:]]*$/{getline; gsub(/^[[:space:]]+|[[:space:]]+$/,"",$0); print}' cmake/targets/BuildHdrHistogram.cmake)
+
+          if [ -z "$CURRENT_VERSION" ]; then
+            echo "Error: Could not find COMMIT line in BuildHdrHistogram.cmake"
+            exit 1
+          fi
+
+          # Validate that it looks like a git hash
+          if ! [[ $CURRENT_VERSION =~ ^[0-9a-f]{40}$ ]]; then
+            echo "Error: Invalid git hash format in BuildHdrHistogram.cmake"
+            echo "Found: $CURRENT_VERSION"
+            echo "Expected: 40 character hexadecimal string"
+            exit 1
+          fi
+
+          echo "current=$CURRENT_VERSION" >> $GITHUB_OUTPUT
+
+          LATEST_RELEASE=$(curl -sL https://api.github.com/repos/HdrHistogram/HdrHistogram_c/releases/latest)
+          if [ -z "$LATEST_RELEASE" ]; then
+            echo "Error: Failed to fetch latest release from GitHub API"
+            exit 1
+          fi
+
+          LATEST_TAG=$(echo "$LATEST_RELEASE" | jq -r '.tag_name')
+          if [ -z "$LATEST_TAG" ] || [ "$LATEST_TAG" = "null" ]; then
+            echo "Error: Could not extract tag name from GitHub API response"
+            exit 1
+          fi
+
+          LATEST_TAG_SHA=$(curl -sL "https://api.github.com/repos/HdrHistogram/HdrHistogram_c/git/refs/tags/$LATEST_TAG" | jq -r '.object.sha')
+          if [ -z "$LATEST_TAG_SHA" ] || [ "$LATEST_TAG_SHA" = "null" ]; then
+            echo "Error: Could not fetch SHA for tag $LATEST_TAG"
+            exit 1
+          fi
+          
+          # Try to get commit SHA from tag object (for annotated tags)
+          # If it fails, assume it's a lightweight tag pointing directly to commit
+          LATEST_SHA=$(curl -sL "https://api.github.com/repos/HdrHistogram/HdrHistogram_c/git/tags/$LATEST_TAG_SHA" 2>/dev/null | jq -r '.object.sha // empty')
+          if [ -z "$LATEST_SHA" ]; then
+            # Lightweight tag - SHA points directly to commit
+            LATEST_SHA="$LATEST_TAG_SHA"
+          fi
+
+          if ! [[ $LATEST_SHA =~ ^[0-9a-f]{40}$ ]]; then
+            echo "Error: Invalid SHA format received from GitHub"
+            echo "Found: $LATEST_SHA"
+            echo "Expected: 40 character hexadecimal string"
+            exit 1
+          fi
+
+          echo "latest=$LATEST_SHA" >> $GITHUB_OUTPUT
+          echo "tag=$LATEST_TAG" >> $GITHUB_OUTPUT
+
+      - name: Update version if needed
+        if: success() && steps.check-version.outputs.current != steps.check-version.outputs.latest
+        run: |
+          set -euo pipefail
+          # Handle multi-line format where COMMIT and its value are on separate lines
+          sed -i -E '/[[:space:]]*COMMIT[[:space:]]*$/{n;s/[[:space:]]*([0-9a-f]+)[[:space:]]*$/    ${{ steps.check-version.outputs.latest }}/}' cmake/targets/BuildHdrHistogram.cmake
+
+      - name: Create Pull Request
+        if: success() && steps.check-version.outputs.current != steps.check-version.outputs.latest
+        uses: peter-evans/create-pull-request@v4
+        with:
+          token: ${{ secrets.GITHUB_TOKEN }}
+          add-paths: |
+            cmake/targets/BuildHdrHistogram.cmake
+          commit-message: "deps: update hdrhistogram to ${{ steps.check-version.outputs.tag }} (${{ steps.check-version.outputs.latest }})"
+          title: "deps: update hdrhistogram to ${{ steps.check-version.outputs.tag }}"
+          delete-branch: true
+          branch: deps/update-hdrhistogram-${{ github.run_number }}
+          body: |
+            ## What does this PR do?
+
+            Updates hdrhistogram to version ${{ steps.check-version.outputs.tag }}
+
+            Compare: https://github.com/HdrHistogram/HdrHistogram_c/compare/${{ steps.check-version.outputs.current }}...${{ steps.check-version.outputs.latest }}
+
+            Auto-updated by [this workflow](https://github.com/oven-sh/bun/actions/workflows/update-hdrhistogram.yml)

.github/workflows/update-highway.yml

@@ -0,0 +1,118 @@
+name: Update highway
+
+on:
+  schedule:
+    - cron: "0 4 * * 0"
+  workflow_dispatch:
+
+jobs:
+  check-update:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+      pull-requests: write
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Check highway version
+        id: check-version
+        run: |
+          set -euo pipefail
+
+          # Extract the commit hash from the line after COMMIT
+          CURRENT_VERSION=$(awk '/[[:space:]]*COMMIT[[:space:]]*$/{getline; gsub(/^[[:space:]]+|[[:space:]]+$/,"",$0); print}' cmake/targets/BuildHighway.cmake)
+
+          if [ -z "$CURRENT_VERSION" ]; then
+            echo "Error: Could not find COMMIT line in BuildHighway.cmake"
+            exit 1
+          fi
+
+          # Validate that it looks like a git hash
+          if ! [[ $CURRENT_VERSION =~ ^[0-9a-f]{40}$ ]]; then
+            echo "Error: Invalid git hash format in BuildHighway.cmake"
+            echo "Found: $CURRENT_VERSION"
+            echo "Expected: 40 character hexadecimal string"
+            exit 1
+          fi
+
+          echo "current=$CURRENT_VERSION" >> $GITHUB_OUTPUT
+
+          LATEST_RELEASE=$(curl -sL https://api.github.com/repos/google/highway/releases/latest)
+          if [ -z "$LATEST_RELEASE" ]; then
+            echo "Error: Failed to fetch latest release from GitHub API"
+            exit 1
+          fi
+
+          LATEST_TAG=$(echo "$LATEST_RELEASE" | jq -r '.tag_name')
+          if [ -z "$LATEST_TAG" ] || [ "$LATEST_TAG" = "null" ]; then
+            echo "Error: Could not extract tag name from GitHub API response"
+            exit 1
+          fi
+
+          TAG_REF=$(curl -sL "https://api.github.com/repos/google/highway/git/refs/tags/$LATEST_TAG")
+          if [ -z "$TAG_REF" ]; then
+            echo "Error: Could not fetch tag reference for $LATEST_TAG"
+            exit 1
+          fi
+
+          TAG_OBJECT_SHA=$(echo "$TAG_REF" | jq -r '.object.sha')
+          TAG_OBJECT_TYPE=$(echo "$TAG_REF" | jq -r '.object.type')
+          
+          if [ -z "$TAG_OBJECT_SHA" ] || [ "$TAG_OBJECT_SHA" = "null" ]; then
+            echo "Error: Could not fetch SHA for tag $LATEST_TAG"
+            exit 1
+          fi
+
+          # Handle both lightweight tags (type: commit) and annotated tags (type: tag)
+          if [ "$TAG_OBJECT_TYPE" = "commit" ]; then
+            # Lightweight tag - object.sha is already the commit SHA
+            LATEST_SHA="$TAG_OBJECT_SHA"
+          elif [ "$TAG_OBJECT_TYPE" = "tag" ]; then
+            # Annotated tag - need to fetch the tag object to get the commit SHA
+            LATEST_SHA=$(curl -sL "https://api.github.com/repos/google/highway/git/tags/$TAG_OBJECT_SHA" | jq -r '.object.sha')
+            if [ -z "$LATEST_SHA" ] || [ "$LATEST_SHA" = "null" ]; then
+              echo "Error: Could not fetch commit SHA for annotated tag $LATEST_TAG @ $TAG_OBJECT_SHA"
+              exit 1
+            fi
+          else
+            echo "Error: Unexpected tag object type: $TAG_OBJECT_TYPE"
+            exit 1
+          fi
+
+          if ! [[ $LATEST_SHA =~ ^[0-9a-f]{40}$ ]]; then
+            echo "Error: Invalid SHA format received from GitHub"
+            echo "Found: $LATEST_SHA"
+            echo "Expected: 40 character hexadecimal string"
+            exit 1
+          fi
+
+          echo "latest=$LATEST_SHA" >> $GITHUB_OUTPUT
+          echo "tag=$LATEST_TAG" >> $GITHUB_OUTPUT
+
+      - name: Update version if needed
+        if: success() && steps.check-version.outputs.current != steps.check-version.outputs.latest
+        run: |
+          set -euo pipefail
+          # Handle multi-line format where COMMIT and its value are on separate lines
+          sed -i -E '/[[:space:]]*COMMIT[[:space:]]*$/{n;s/[[:space:]]*([0-9a-f]+)[[:space:]]*$/    ${{ steps.check-version.outputs.latest }}/}' cmake/targets/BuildHighway.cmake
+
+      - name: Create Pull Request
+        if: success() && steps.check-version.outputs.current != steps.check-version.outputs.latest
+        uses: peter-evans/create-pull-request@v4
+        with:
+          token: ${{ secrets.GITHUB_TOKEN }}
+          add-paths: |
+            cmake/targets/BuildHighway.cmake
+          commit-message: "deps: update highway to ${{ steps.check-version.outputs.tag }} (${{ steps.check-version.outputs.latest }})"
+          title: "deps: update highway to ${{ steps.check-version.outputs.tag }}"
+          delete-branch: true
+          branch: deps/update-highway-${{ github.run_number }}
+          body: |
+            ## What does this PR do?
+
+            Updates highway to version ${{ steps.check-version.outputs.tag }}
+
+            Compare: https://github.com/google/highway/compare/${{ steps.check-version.outputs.current }}...${{ steps.check-version.outputs.latest }}
+
+            Auto-updated by [this workflow](https://github.com/oven-sh/bun/actions/workflows/update-highway.yml)

.github/workflows/update-libarchive.yml

@@ -0,0 +1,99 @@
+name: Update libarchive
+
+on:
+  schedule:
+    - cron: "0 3 * * 0"
+  workflow_dispatch:
+
+jobs:
+  check-update:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+      pull-requests: write
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Check libarchive version
+        id: check-version
+        run: |
+          set -euo pipefail
+
+          # Extract the commit hash from the line after COMMIT
+          CURRENT_VERSION=$(awk '/[[:space:]]*COMMIT[[:space:]]*$/{getline; gsub(/^[[:space:]]+|[[:space:]]+$/,"",$0); print}' cmake/targets/BuildLibArchive.cmake)
+
+          if [ -z "$CURRENT_VERSION" ]; then
+            echo "Error: Could not find COMMIT line in BuildLibArchive.cmake"
+            exit 1
+          fi
+
+          # Validate that it looks like a git hash
+          if ! [[ $CURRENT_VERSION =~ ^[0-9a-f]{40}$ ]]; then
+            echo "Error: Invalid git hash format in BuildLibArchive.cmake"
+            echo "Found: $CURRENT_VERSION"
+            echo "Expected: 40 character hexadecimal string"
+            exit 1
+          fi
+
+          echo "current=$CURRENT_VERSION" >> $GITHUB_OUTPUT
+
+          LATEST_RELEASE=$(curl -sL https://api.github.com/repos/libarchive/libarchive/releases/latest)
+          if [ -z "$LATEST_RELEASE" ]; then
+            echo "Error: Failed to fetch latest release from GitHub API"
+            exit 1
+          fi
+
+          LATEST_TAG=$(echo "$LATEST_RELEASE" | jq -r '.tag_name')
+          if [ -z "$LATEST_TAG" ] || [ "$LATEST_TAG" = "null" ]; then
+            echo "Error: Could not extract tag name from GitHub API response"
+            exit 1
+          fi
+
+          LATEST_TAG_SHA=$(curl -sL "https://api.github.com/repos/libarchive/libarchive/git/refs/tags/$LATEST_TAG" | jq -r '.object.sha')
+          if [ -z "$LATEST_TAG_SHA" ] || [ "$LATEST_TAG_SHA" = "null" ]; then
+            echo "Error: Could not fetch SHA for tag $LATEST_TAG"
+            exit 1
+          fi
+          LATEST_SHA=$(curl -sL "https://api.github.com/repos/libarchive/libarchive/git/tags/$LATEST_TAG_SHA" | jq -r '.object.sha')
+          if [ -z "$LATEST_SHA" ] || [ "$LATEST_SHA" = "null" ]; then
+            echo "Error: Could not fetch SHA for tag $LATEST_TAG @ $LATEST_TAG_SHA"
+            exit 1
+          fi
+
+          if ! [[ $LATEST_SHA =~ ^[0-9a-f]{40}$ ]]; then
+            echo "Error: Invalid SHA format received from GitHub"
+            echo "Found: $LATEST_SHA"
+            echo "Expected: 40 character hexadecimal string"
+            exit 1
+          fi
+
+          echo "latest=$LATEST_SHA" >> $GITHUB_OUTPUT
+          echo "tag=$LATEST_TAG" >> $GITHUB_OUTPUT
+
+      - name: Update version if needed
+        if: success() && steps.check-version.outputs.current != steps.check-version.outputs.latest
+        run: |
+          set -euo pipefail
+          # Handle multi-line format where COMMIT and its value are on separate lines
+          sed -i -E '/[[:space:]]*COMMIT[[:space:]]*$/{n;s/[[:space:]]*([0-9a-f]+)[[:space:]]*$/    ${{ steps.check-version.outputs.latest }}/}' cmake/targets/BuildLibArchive.cmake
+
+      - name: Create Pull Request
+        if: success() && steps.check-version.outputs.current != steps.check-version.outputs.latest
+        uses: peter-evans/create-pull-request@v4
+        with:
+          token: ${{ secrets.GITHUB_TOKEN }}
+          add-paths: |
+            cmake/targets/BuildLibArchive.cmake
+          commit-message: "deps: update libarchive to ${{ steps.check-version.outputs.tag }} (${{ steps.check-version.outputs.latest }})"
+          title: "deps: update libarchive to ${{ steps.check-version.outputs.tag }}"
+          delete-branch: true
+          branch: deps/update-libarchive-${{ github.run_number }}
+          body: |
+            ## What does this PR do?
+
+            Updates libarchive to version ${{ steps.check-version.outputs.tag }}
+
+            Compare: https://github.com/libarchive/libarchive/compare/${{ steps.check-version.outputs.current }}...${{ steps.check-version.outputs.latest }}
+
+            Auto-updated by [this workflow](https://github.com/oven-sh/bun/actions/workflows/update-libarchive.yml)

.github/workflows/update-libdeflate.yml

@@ -0,0 +1,99 @@
+name: Update libdeflate
+
+on:
+  schedule:
+    - cron: "0 2 * * 0"
+  workflow_dispatch:
+
+jobs:
+  check-update:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+      pull-requests: write
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Check libdeflate version
+        id: check-version
+        run: |
+          set -euo pipefail
+
+          # Extract the commit hash from the line after COMMIT
+          CURRENT_VERSION=$(awk '/[[:space:]]*COMMIT[[:space:]]*$/{getline; gsub(/^[[:space:]]+|[[:space:]]+$/,"",$0); print}' cmake/targets/BuildLibDeflate.cmake)
+
+          if [ -z "$CURRENT_VERSION" ]; then
+            echo "Error: Could not find COMMIT line in BuildLibDeflate.cmake"
+            exit 1
+          fi
+
+          # Validate that it looks like a git hash
+          if ! [[ $CURRENT_VERSION =~ ^[0-9a-f]{40}$ ]]; then
+            echo "Error: Invalid git hash format in BuildLibDeflate.cmake"
+            echo "Found: $CURRENT_VERSION"
+            echo "Expected: 40 character hexadecimal string"
+            exit 1
+          fi
+
+          echo "current=$CURRENT_VERSION" >> $GITHUB_OUTPUT
+
+          LATEST_RELEASE=$(curl -sL https://api.github.com/repos/ebiggers/libdeflate/releases/latest)
+          if [ -z "$LATEST_RELEASE" ]; then
+            echo "Error: Failed to fetch latest release from GitHub API"
+            exit 1
+          fi
+
+          LATEST_TAG=$(echo "$LATEST_RELEASE" | jq -r '.tag_name')
+          if [ -z "$LATEST_TAG" ] || [ "$LATEST_TAG" = "null" ]; then
+            echo "Error: Could not extract tag name from GitHub API response"
+            exit 1
+          fi
+
+          LATEST_TAG_SHA=$(curl -sL "https://api.github.com/repos/ebiggers/libdeflate/git/refs/tags/$LATEST_TAG" | jq -r '.object.sha')
+          if [ -z "$LATEST_TAG_SHA" ] || [ "$LATEST_TAG_SHA" = "null" ]; then
+            echo "Error: Could not fetch SHA for tag $LATEST_TAG"
+            exit 1
+          fi
+          LATEST_SHA=$(curl -sL "https://api.github.com/repos/ebiggers/libdeflate/git/tags/$LATEST_TAG_SHA" | jq -r '.object.sha')
+          if [ -z "$LATEST_SHA" ] || [ "$LATEST_SHA" = "null" ]; then
+            echo "Error: Could not fetch SHA for tag $LATEST_TAG @ $LATEST_TAG_SHA"
+            exit 1
+          fi
+
+          if ! [[ $LATEST_SHA =~ ^[0-9a-f]{40}$ ]]; then
+            echo "Error: Invalid SHA format received from GitHub"
+            echo "Found: $LATEST_SHA"
+            echo "Expected: 40 character hexadecimal string"
+            exit 1
+          fi
+
+          echo "latest=$LATEST_SHA" >> $GITHUB_OUTPUT
+          echo "tag=$LATEST_TAG" >> $GITHUB_OUTPUT
+
+      - name: Update version if needed
+        if: success() && steps.check-version.outputs.current != steps.check-version.outputs.latest
+        run: |
+          set -euo pipefail
+          # Handle multi-line format where COMMIT and its value are on separate lines
+          sed -i -E '/[[:space:]]*COMMIT[[:space:]]*$/{n;s/[[:space:]]*([0-9a-f]+)[[:space:]]*$/    ${{ steps.check-version.outputs.latest }}/}' cmake/targets/BuildLibDeflate.cmake
+
+      - name: Create Pull Request
+        if: success() && steps.check-version.outputs.current != steps.check-version.outputs.latest
+        uses: peter-evans/create-pull-request@v4
+        with:
+          token: ${{ secrets.GITHUB_TOKEN }}
+          add-paths: |
+            cmake/targets/BuildLibDeflate.cmake
+          commit-message: "deps: update libdeflate to ${{ steps.check-version.outputs.tag }} (${{ steps.check-version.outputs.latest }})"
+          title: "deps: update libdeflate to ${{ steps.check-version.outputs.tag }}"
+          delete-branch: true
+          branch: deps/update-libdeflate-${{ github.run_number }}
+          body: |
+            ## What does this PR do?
+
+            Updates libdeflate to version ${{ steps.check-version.outputs.tag }}
+
+            Compare: https://github.com/ebiggers/libdeflate/compare/${{ steps.check-version.outputs.current }}...${{ steps.check-version.outputs.latest }}
+
+            Auto-updated by [this workflow](https://github.com/oven-sh/bun/actions/workflows/update-libdeflate.yml)

.github/workflows/update-lolhtml.yml

@@ -0,0 +1,111 @@
+name: Update lolhtml
+
+on:
+  schedule:
+    - cron: "0 1 * * 0"
+  workflow_dispatch:
+
+jobs:
+  check-update:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+      pull-requests: write
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Check lolhtml version
+        id: check-version
+        run: |
+          set -euo pipefail
+
+          # Extract the commit hash from the line after COMMIT
+          CURRENT_VERSION=$(awk '/[[:space:]]*COMMIT[[:space:]]*$/{getline; gsub(/^[[:space:]]+|[[:space:]]+$/,"",$0); print}' cmake/targets/BuildLolHtml.cmake)
+
+          if [ -z "$CURRENT_VERSION" ]; then
+            echo "Error: Could not find COMMIT line in BuildLolHtml.cmake"
+            exit 1
+          fi
+
+          # Validate that it looks like a git hash
+          if ! [[ $CURRENT_VERSION =~ ^[0-9a-f]{40}$ ]]; then
+            echo "Error: Invalid git hash format in BuildLolHtml.cmake"
+            echo "Found: $CURRENT_VERSION"
+            echo "Expected: 40 character hexadecimal string"
+            exit 1
+          fi
+
+          echo "current=$CURRENT_VERSION" >> $GITHUB_OUTPUT
+
+          LATEST_RELEASE=$(curl -sL https://api.github.com/repos/cloudflare/lol-html/releases/latest)
+          if [ -z "$LATEST_RELEASE" ]; then
+            echo "Error: Failed to fetch latest release from GitHub API"
+            exit 1
+          fi
+
+          LATEST_TAG=$(echo "$LATEST_RELEASE" | jq -r '.tag_name')
+          if [ -z "$LATEST_TAG" ] || [ "$LATEST_TAG" = "null" ]; then
+            echo "Error: Could not extract tag name from GitHub API response"
+            exit 1
+          fi
+
+          # Get the commit SHA that the tag points to
+          # This handles both lightweight tags (direct commit refs) and annotated tags (tag objects)
+          TAG_REF_RESPONSE=$(curl -sL "https://api.github.com/repos/cloudflare/lol-html/git/refs/tags/$LATEST_TAG")
+          LATEST_TAG_SHA=$(echo "$TAG_REF_RESPONSE" | jq -r '.object.sha')
+          TAG_OBJECT_TYPE=$(echo "$TAG_REF_RESPONSE" | jq -r '.object.type')
+          
+          if [ -z "$LATEST_TAG_SHA" ] || [ "$LATEST_TAG_SHA" = "null" ]; then
+            echo "Error: Could not fetch SHA for tag $LATEST_TAG"
+            exit 1
+          fi
+          
+          if [ "$TAG_OBJECT_TYPE" = "tag" ]; then
+            # This is an annotated tag, we need to get the commit it points to
+            LATEST_SHA=$(curl -sL "https://api.github.com/repos/cloudflare/lol-html/git/tags/$LATEST_TAG_SHA" | jq -r '.object.sha')
+            if [ -z "$LATEST_SHA" ] || [ "$LATEST_SHA" = "null" ]; then
+              echo "Error: Could not fetch commit SHA for annotated tag $LATEST_TAG @ $LATEST_TAG_SHA"
+              exit 1
+            fi
+          else
+            # This is a lightweight tag pointing directly to a commit
+            LATEST_SHA="$LATEST_TAG_SHA"
+          fi
+
+          if ! [[ $LATEST_SHA =~ ^[0-9a-f]{40}$ ]]; then
+            echo "Error: Invalid SHA format received from GitHub"
+            echo "Found: $LATEST_SHA"
+            echo "Expected: 40 character hexadecimal string"
+            exit 1
+          fi
+
+          echo "latest=$LATEST_SHA" >> $GITHUB_OUTPUT
+          echo "tag=$LATEST_TAG" >> $GITHUB_OUTPUT
+
+      - name: Update version if needed
+        if: success() && steps.check-version.outputs.current != steps.check-version.outputs.latest
+        run: |
+          set -euo pipefail
+          # Handle multi-line format where COMMIT and its value are on separate lines
+          sed -i -E '/[[:space:]]*COMMIT[[:space:]]*$/{n;s/[[:space:]]*([0-9a-f]+)[[:space:]]*$/    ${{ steps.check-version.outputs.latest }}/}' cmake/targets/BuildLolHtml.cmake
+
+      - name: Create Pull Request
+        if: success() && steps.check-version.outputs.current != steps.check-version.outputs.latest
+        uses: peter-evans/create-pull-request@v4
+        with:
+          token: ${{ secrets.GITHUB_TOKEN }}
+          add-paths: |
+            cmake/targets/BuildLolHtml.cmake
+          commit-message: "deps: update lolhtml to ${{ steps.check-version.outputs.tag }} (${{ steps.check-version.outputs.latest }})"
+          title: "deps: update lolhtml to ${{ steps.check-version.outputs.tag }}"
+          delete-branch: true
+          branch: deps/update-lolhtml-${{ github.run_number }}
+          body: |
+            ## What does this PR do?
+
+            Updates lolhtml to version ${{ steps.check-version.outputs.tag }}
+
+            Compare: https://github.com/cloudflare/lol-html/compare/${{ steps.check-version.outputs.current }}...${{ steps.check-version.outputs.latest }}
+
+            Auto-updated by [this workflow](https://github.com/oven-sh/bun/actions/workflows/update-lolhtml.yml)

.github/workflows/update-lshpack.yml

@@ -0,0 +1,116 @@
+name: Update lshpack
+
+on:
+  schedule:
+    - cron: "0 5 * * 0"
+  workflow_dispatch:
+
+jobs:
+  check-update:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+      pull-requests: write
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Check lshpack version
+        id: check-version
+        run: |
+          set -euo pipefail
+
+          # Extract the commit hash from the line after COMMIT
+          CURRENT_VERSION=$(awk '/[[:space:]]*COMMIT[[:space:]]*$/{getline; gsub(/^[[:space:]]+|[[:space:]]+$/,"",$0); print}' cmake/targets/BuildLshpack.cmake)
+
+          if [ -z "$CURRENT_VERSION" ]; then
+            echo "Error: Could not find COMMIT line in BuildLshpack.cmake"
+            exit 1
+          fi
+
+          # Validate that it looks like a git hash
+          if ! [[ $CURRENT_VERSION =~ ^[0-9a-f]{40}$ ]]; then
+            echo "Error: Invalid git hash format in BuildLshpack.cmake"
+            echo "Found: $CURRENT_VERSION"
+            echo "Expected: 40 character hexadecimal string"
+            exit 1
+          fi
+
+          echo "current=$CURRENT_VERSION" >> $GITHUB_OUTPUT
+
+          LATEST_RELEASE=$(curl -sL https://api.github.com/repos/litespeedtech/ls-hpack/releases/latest)
+          if [ -z "$LATEST_RELEASE" ]; then
+            echo "Error: Failed to fetch latest release from GitHub API"
+            exit 1
+          fi
+
+          LATEST_TAG=$(echo "$LATEST_RELEASE" | jq -r '.tag_name')
+          if [ -z "$LATEST_TAG" ] || [ "$LATEST_TAG" = "null" ]; then
+            echo "Error: Could not extract tag name from GitHub API response"
+            exit 1
+          fi
+
+          # Get the tag reference, which contains both SHA and type
+          TAG_REF=$(curl -sL "https://api.github.com/repos/litespeedtech/ls-hpack/git/refs/tags/$LATEST_TAG")
+          if [ -z "$TAG_REF" ]; then
+            echo "Error: Could not fetch tag reference for $LATEST_TAG"
+            exit 1
+          fi
+
+          LATEST_TAG_SHA=$(echo "$TAG_REF" | jq -r '.object.sha')
+          TAG_TYPE=$(echo "$TAG_REF" | jq -r '.object.type')
+          
+          if [ -z "$LATEST_TAG_SHA" ] || [ "$LATEST_TAG_SHA" = "null" ]; then
+            echo "Error: Could not fetch SHA for tag $LATEST_TAG"
+            exit 1
+          fi
+
+          # If it's an annotated tag, we need to dereference it to get the commit SHA
+          # If it's a lightweight tag, the SHA already points to the commit
+          if [ "$TAG_TYPE" = "tag" ]; then
+            LATEST_SHA=$(curl -sL "https://api.github.com/repos/litespeedtech/ls-hpack/git/tags/$LATEST_TAG_SHA" | jq -r '.object.sha')
+            if [ -z "$LATEST_SHA" ] || [ "$LATEST_SHA" = "null" ]; then
+              echo "Error: Could not fetch commit SHA for annotated tag $LATEST_TAG"
+              exit 1
+            fi
+          else
+            # For lightweight tags, the SHA is already the commit SHA
+            LATEST_SHA="$LATEST_TAG_SHA"
+          fi
+
+          if ! [[ $LATEST_SHA =~ ^[0-9a-f]{40}$ ]]; then
+            echo "Error: Invalid SHA format received from GitHub"
+            echo "Found: $LATEST_SHA"
+            echo "Expected: 40 character hexadecimal string"
+            exit 1
+          fi
+
+          echo "latest=$LATEST_SHA" >> $GITHUB_OUTPUT
+          echo "tag=$LATEST_TAG" >> $GITHUB_OUTPUT
+
+      - name: Update version if needed
+        if: success() && steps.check-version.outputs.current != steps.check-version.outputs.latest
+        run: |
+          set -euo pipefail
+          # Handle multi-line format where COMMIT and its value are on separate lines
+          sed -i -E '/[[:space:]]*COMMIT[[:space:]]*$/{n;s/[[:space:]]*([0-9a-f]+)[[:space:]]*$/    ${{ steps.check-version.outputs.latest }}/}' cmake/targets/BuildLshpack.cmake
+
+      - name: Create Pull Request
+        if: success() && steps.check-version.outputs.current != steps.check-version.outputs.latest
+        uses: peter-evans/create-pull-request@v4
+        with:
+          token: ${{ secrets.GITHUB_TOKEN }}
+          add-paths: |
+            cmake/targets/BuildLshpack.cmake
+          commit-message: "deps: update lshpack to ${{ steps.check-version.outputs.tag }} (${{ steps.check-version.outputs.latest }})"
+          title: "deps: update lshpack to ${{ steps.check-version.outputs.tag }}"
+          delete-branch: true
+          branch: deps/update-lshpack-${{ github.run_number }}
+          body: |
+            ## What does this PR do?
+
+            Updates lshpack to version ${{ steps.check-version.outputs.tag }}
+
+            Compare: https://github.com/litespeedtech/ls-hpack/compare/${{ steps.check-version.outputs.current }}...${{ steps.check-version.outputs.latest }}
+
+            Auto-updated by [this workflow](https://github.com/oven-sh/bun/actions/workflows/update-lshpack.yml)

.github/workflows/update-root-certs.yml

@@ -0,0 +1,82 @@
+name: Daily Root Certs Update Check
+
+on:
+  schedule:
+    - cron: "0 0 * * *" # Runs at 00:00 UTC every day
+  workflow_dispatch: # Allows manual trigger
+
+jobs:
+  check-and-update:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+      pull-requests: write
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Setup Bun
+        uses: oven-sh/setup-bun@v1
+        with:
+          bun-version: latest
+
+      - name: Generate root certs and capture output
+        id: generate-certs
+        run: |
+          cd packages/bun-usockets/
+          OUTPUT=$(bun generate-root-certs.mjs -v)
+          echo "cert_output<<EOF" >> $GITHUB_ENV
+          echo "$OUTPUT" >> $GITHUB_ENV
+          echo "EOF" >> $GITHUB_ENV
+
+      - name: Check for changes and stage files
+        id: check-changes
+        run: |
+          if [[ -n "$(git status --porcelain)" ]]; then
+            echo "Found changes, staging modified files..."
+            git config --global user.name "github-actions[bot]"
+            git config --global user.email "github-actions[bot]@users.noreply.github.com"
+            
+            # Get list of modified files and add them
+            git status --porcelain | while read -r status file; do
+              # Remove leading status and whitespace
+              file=$(echo "$file" | sed 's/^.* //')
+              echo "Adding changed file: $file"
+              git add "$file"
+            done
+            
+            echo "changes=true" >> $GITHUB_OUTPUT
+            
+            # Store the list of changed files
+            CHANGED_FILES=$(git status --porcelain)
+            echo "changed_files<<EOF" >> $GITHUB_ENV
+            echo "$CHANGED_FILES" >> $GITHUB_ENV
+            echo "EOF" >> $GITHUB_ENV
+          else
+            echo "No changes detected"
+            echo "changes=false" >> $GITHUB_OUTPUT
+          fi
+
+      - name: Create Pull Request
+        if: steps.check-changes.outputs.changes == 'true'
+        uses: peter-evans/create-pull-request@v5
+        with:
+          token: ${{ secrets.GITHUB_TOKEN }}
+          commit-message: "update(root_certs): Update root certificates $(date +'%Y-%m-%d')"
+          title: "update(root_certs) $(date +'%Y-%m-%d')"
+          body: |
+            Automated root certificates update
+
+            ${{ env.cert_output }}
+
+            ## Changed Files:
+            ```
+            ${{ env.changed_files }}
+            ```
+          branch: certs/update-root-certs-${{ github.run_number }}
+          base: main
+          delete-branch: true
+          labels:
+            - "automation"
+            - "root-certs"

.github/workflows/update-sqlite3.yml

@@ -0,0 +1,111 @@
+name: Update SQLite3
+
+on:
+  schedule:
+    - cron: "0 6 * * 0" # Run weekly
+  workflow_dispatch:
+
+jobs:
+  check-update:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+      pull-requests: write
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Check SQLite version
+        id: check-version
+        run: |
+          set -euo pipefail
+
+          # Get current version from the header file using SQLITE_VERSION_NUMBER
+          CURRENT_VERSION_NUM=$(grep -o '#define SQLITE_VERSION_NUMBER [0-9]\+' src/bun.js/bindings/sqlite/sqlite3_local.h | awk '{print $3}' | tr -d '\n\r')
+          if [ -z "$CURRENT_VERSION_NUM" ]; then
+            echo "Error: Could not find SQLITE_VERSION_NUMBER in sqlite3_local.h"
+            exit 1
+          fi
+
+          # Convert numeric version to semantic version for display
+          CURRENT_MAJOR=$((CURRENT_VERSION_NUM / 1000000))
+          CURRENT_MINOR=$((($CURRENT_VERSION_NUM / 1000) % 1000))
+          CURRENT_PATCH=$((CURRENT_VERSION_NUM % 1000))
+          CURRENT_VERSION="$CURRENT_MAJOR.$CURRENT_MINOR.$CURRENT_PATCH"
+
+          echo "current=$CURRENT_VERSION" >> $GITHUB_OUTPUT
+          echo "current_num=$CURRENT_VERSION_NUM" >> $GITHUB_OUTPUT
+
+          # Fetch SQLite download page
+          DOWNLOAD_PAGE=$(curl -sL https://sqlite.org/download.html)
+          if [ -z "$DOWNLOAD_PAGE" ]; then
+            echo "Error: Failed to fetch SQLite download page"
+            exit 1
+          fi
+
+          # Extract latest version and year from the amalgamation link
+          LATEST_INFO=$(echo "$DOWNLOAD_PAGE" | grep -o 'sqlite-amalgamation-[0-9]\{7\}.zip' | head -n1)
+          LATEST_YEAR=$(echo "$DOWNLOAD_PAGE" | grep -o '[0-9]\{4\}/sqlite-amalgamation-[0-9]\{7\}.zip' | head -n1 | cut -d'/' -f1 | tr -d '\n\r')
+          LATEST_VERSION_NUM=$(echo "$LATEST_INFO" | grep -o '[0-9]\{7\}' | tr -d '\n\r')
+
+          if [ -z "$LATEST_VERSION_NUM" ] || [ -z "$LATEST_YEAR" ]; then
+            echo "Error: Could not extract latest version info"
+            exit 1
+          fi
+
+          # Convert numeric version to semantic version for display
+          LATEST_MAJOR=$((10#$LATEST_VERSION_NUM / 1000000))
+          LATEST_MINOR=$((($LATEST_VERSION_NUM / 10000) % 100))
+          LATEST_PATCH=$((10#$LATEST_VERSION_NUM % 1000))
+          LATEST_VERSION="$LATEST_MAJOR.$LATEST_MINOR.$LATEST_PATCH"
+
+          echo "latest=$LATEST_VERSION" >> $GITHUB_OUTPUT
+          echo "latest_year=$LATEST_YEAR" >> $GITHUB_OUTPUT
+          echo "latest_num=$LATEST_VERSION_NUM" >> $GITHUB_OUTPUT
+
+          # Debug output
+          echo "Current version: $CURRENT_VERSION ($CURRENT_VERSION_NUM)"
+          echo "Latest version: $LATEST_VERSION ($LATEST_VERSION_NUM)"
+
+      - name: Update SQLite if needed
+        if: success() && steps.check-version.outputs.current_num < steps.check-version.outputs.latest_num
+        run: |
+          set -euo pipefail
+
+          TEMP_DIR=$(mktemp -d)
+          cd $TEMP_DIR
+
+          echo "Downloading from: https://sqlite.org/${{ steps.check-version.outputs.latest_year }}/sqlite-amalgamation-${{ steps.check-version.outputs.latest_num }}.zip"
+
+          # Download and extract latest version
+          wget "https://sqlite.org/${{ steps.check-version.outputs.latest_year }}/sqlite-amalgamation-${{ steps.check-version.outputs.latest_num }}.zip"
+          unzip "sqlite-amalgamation-${{ steps.check-version.outputs.latest_num }}.zip"
+          cd "sqlite-amalgamation-${{ steps.check-version.outputs.latest_num }}"
+
+          # Add header comment and copy files
+          echo "// clang-format off" > $GITHUB_WORKSPACE/src/bun.js/bindings/sqlite/sqlite3.c
+          cat sqlite3.c >> $GITHUB_WORKSPACE/src/bun.js/bindings/sqlite/sqlite3.c
+
+          echo "// clang-format off" > $GITHUB_WORKSPACE/src/bun.js/bindings/sqlite/sqlite3_local.h
+          cat sqlite3.h >> $GITHUB_WORKSPACE/src/bun.js/bindings/sqlite/sqlite3_local.h
+
+      - name: Create Pull Request
+        if: success() && steps.check-version.outputs.current_num < steps.check-version.outputs.latest_num
+        uses: peter-evans/create-pull-request@v4
+        with:
+          token: ${{ secrets.GITHUB_TOKEN }}
+          add-paths: |
+            src/bun.js/bindings/sqlite/sqlite3.c
+            src/bun.js/bindings/sqlite/sqlite3_local.h
+          commit-message: "deps: update sqlite to ${{ steps.check-version.outputs.latest }}"
+          title: "deps: update sqlite to ${{ steps.check-version.outputs.latest }}"
+          delete-branch: true
+          branch: deps/update-sqlite-${{ steps.check-version.outputs.latest }}
+          body: |
+            ## What does this PR do?
+
+            Updates SQLite to version ${{ steps.check-version.outputs.latest }}
+
+            Compare: https://sqlite.org/src/vdiff?from=${{ steps.check-version.outputs.current }}&to=${{ steps.check-version.outputs.latest }}
+
+            Auto-updated by [this workflow](https://github.com/oven-sh/bun/actions/workflows/update-sqlite3.yml)

.github/workflows/update-zstd.yml

@@ -0,0 +1,99 @@
+name: Update zstd
+
+on:
+  schedule:
+    - cron: "0 1 * * 0"
+  workflow_dispatch:
+
+jobs:
+  check-update:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+      pull-requests: write
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Check zstd version
+        id: check-version
+        run: |
+          set -euo pipefail
+
+          # Extract the commit hash from the line after COMMIT
+          CURRENT_VERSION=$(awk '/[[:space:]]*COMMIT[[:space:]]*$/{getline; gsub(/^[[:space:]]+|[[:space:]]+$/,"",$0); print}' cmake/targets/CloneZstd.cmake)
+
+          if [ -z "$CURRENT_VERSION" ]; then
+            echo "Error: Could not find COMMIT line in CloneZstd.cmake"
+            exit 1
+          fi
+
+          # Validate that it looks like a git hash
+          if ! [[ $CURRENT_VERSION =~ ^[0-9a-f]{40}$ ]]; then
+            echo "Error: Invalid git hash format in CloneZstd.cmake"
+            echo "Found: $CURRENT_VERSION"
+            echo "Expected: 40 character hexadecimal string"
+            exit 1
+          fi
+
+          echo "current=$CURRENT_VERSION" >> $GITHUB_OUTPUT
+
+          LATEST_RELEASE=$(curl -sL https://api.github.com/repos/facebook/zstd/releases/latest)
+          if [ -z "$LATEST_RELEASE" ]; then
+            echo "Error: Failed to fetch latest release from GitHub API"
+            exit 1
+          fi
+
+          LATEST_TAG=$(echo "$LATEST_RELEASE" | jq -r '.tag_name')
+          if [ -z "$LATEST_TAG" ] || [ "$LATEST_TAG" = "null" ]; then
+            echo "Error: Could not extract tag name from GitHub API response"
+            exit 1
+          fi
+
+          LATEST_TAG_SHA=$(curl -sL "https://api.github.com/repos/facebook/zstd/git/refs/tags/$LATEST_TAG" | jq -r '.object.sha')
+          if [ -z "$LATEST_TAG_SHA" ] || [ "$LATEST_TAG_SHA" = "null" ]; then
+            echo "Error: Could not fetch SHA for tag $LATEST_TAG"
+            exit 1
+          fi
+          LATEST_SHA=$(curl -sL "https://api.github.com/repos/facebook/zstd/git/tags/$LATEST_TAG_SHA" | jq -r '.object.sha')
+          if [ -z "$LATEST_SHA" ] || [ "$LATEST_SHA" = "null" ]; then
+            echo "Error: Could not fetch SHA for tag $LATEST_TAG @ $LATEST_TAG_SHA"
+            exit 1
+          fi
+
+          if ! [[ $LATEST_SHA =~ ^[0-9a-f]{40}$ ]]; then
+            echo "Error: Invalid SHA format received from GitHub"
+            echo "Found: $LATEST_SHA"
+            echo "Expected: 40 character hexadecimal string"
+            exit 1
+          fi
+
+          echo "latest=$LATEST_SHA" >> $GITHUB_OUTPUT
+          echo "tag=$LATEST_TAG" >> $GITHUB_OUTPUT
+
+      - name: Update version if needed
+        if: success() && steps.check-version.outputs.current != steps.check-version.outputs.latest
+        run: |
+          set -euo pipefail
+          # Handle multi-line format where COMMIT and its value are on separate lines
+          sed -i -E '/[[:space:]]*COMMIT[[:space:]]*$/{n;s/[[:space:]]*([0-9a-f]+)[[:space:]]*$/    ${{ steps.check-version.outputs.latest }}/}' cmake/targets/CloneZstd.cmake
+
+      - name: Create Pull Request
+        if: success() && steps.check-version.outputs.current != steps.check-version.outputs.latest
+        uses: peter-evans/create-pull-request@v4
+        with:
+          token: ${{ secrets.GITHUB_TOKEN }}
+          add-paths: |
+            cmake/targets/CloneZstd.cmake
+          commit-message: "deps: update zstd to ${{ steps.check-version.outputs.tag }} (${{ steps.check-version.outputs.latest }})"
+          title: "deps: update zstd to ${{ steps.check-version.outputs.tag }}"
+          delete-branch: true
+          branch: deps/update-zstd-${{ github.run_number }}
+          body: |
+            ## What does this PR do?
+
+            Updates zstd to version ${{ steps.check-version.outputs.tag }}
+
+            Compare: https://github.com/facebook/zstd/compare/${{ steps.check-version.outputs.current }}...${{ steps.check-version.outputs.latest }}
+
+            Auto-updated by [this workflow](https://github.com/oven-sh/bun/actions/workflows/update-zstd.yml)

.github/workflows/vscode-release.yml

@@ -0,0 +1,47 @@
+name: VSCode Extension Publish
+on:
+  workflow_dispatch:
+    inputs:
+      version:
+        description: "Version to publish (e.g. 0.0.25) - Check the marketplace for the latest version"
+        required: true
+        type: string
+
+jobs:
+  publish:
+    name: "Publish to VS Code Marketplace"
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Setup Bun
+        uses: ./.github/actions/setup-bun
+        with:
+          bun-version: "1.2.18"
+
+      - name: Install dependencies (root)
+        run: bun install
+
+      - name: Install dependencies
+        run: bun install
+        working-directory: packages/bun-vscode
+
+      - name: Set Version
+        run: bun pm version ${{ github.event.inputs.version }} --no-git-tag-version --allow-same-version
+        working-directory: packages/bun-vscode
+
+      - name: Build (inspector protocol)
+        run: bun install && bun run build
+        working-directory: packages/bun-inspector-protocol
+
+      - name: Build (vscode extension)
+        run: bun run build
+        working-directory: packages/bun-vscode
+
+      - name: Publish
+        if: success()
+        run: bunx vsce publish
+        env:
+          VSCE_PAT: ${{ secrets.VSCODE_EXTENSION }}
+        working-directory: packages/bun-vscode/extension

.gitignore

@@ -1,91 +1,192 @@
 .DS_Store
-zig-cache
-*.wasm
-
-*.o
-*.a
-profile.json
-
-node_modules
+.env
+.envrc
+.eslintcache
+.idea
+.next
+.ninja_deps
+.ninja_log
+.npm
+.npm.gz
+.parcel-cache
 .swcrc
-yarn.lock
-dist
+.trace
+.uuid
+.vs
+.vscode/clang*
+.vscode/cpp*
+.zig-cache
+.bake-debug
+*.a
+*.bc
+*.big
+*.blob
+*.bun
+*.crash
+*.database
+*.db
+*.dmg
+*.dSYM
+*.generated.ts
+*.jsb
+*.lib
 *.log
+*.o
 *.out.js
 *.out.refresh.js
-/package-lock.json
-build
+*.pdb
+*.sqlite
+*.swp
+*.tmp
+*.trace
 *.wat
-zig-out
-pnpm-lock.yaml
-README.md.template
-src/deps/zig-clap/example
-src/deps/zig-clap/README.md
-src/deps/zig-clap/.github
-src/deps/zig-clap/.gitattributes
-out
-outdir
-
-.trace
+*.zip
+**/.verdaccio-db.json
+**/*.dir
+**/*.pdb
+**/*.sln*
+**/*.vcxproj*
+**/package-lock.json
+/.cache
+/.webkit-cache
+/build-*/
+/bun-webkit
+/kcov-out
+/test-report.json
+/test-report.md
+/test.js
+/test.ts
+/test.zig
+/testdir
+build
+build.ninja
+bun-binary
+bun-mimalloc
+bun-nomimalloc
+bun-singlehtreaded
+bun-test-scratch
+bun-zigld
+cmake_install.cmake
+CMakeCache.txt
+CMakeFiles
+cold-jsc-start
+cold-jsc-start.d
+compile_commands.json
 cover
 coverage
 coverv
-*.trace
-github
-out.*
-out
-.parcel-cache
+dist
 esbuilddir
-*.bun
-parceldist
-esbuilddir
-outdir/
-outcss
-.next
-txt.js
-.idea
-.vscode/cpp*
-
-node_modules_*
-*.jsb
-*.zip
-bun-zigld
-bun-singlehtreaded
-bun-nomimalloc
-bun-mimalloc
-examples/lotta-modules/bun-yday
-examples/lotta-modules/bun-old
 examples/lotta-modules/bun-nofscache
-
-src/node-fallbacks/out/*
-src/node-fallbacks/node_modules
-sign.json
-release/
-*.dmg
-sign.*.json
-packages/debug-*
-packages/bun-cli/postinstall.js
+examples/lotta-modules/bun-old
+examples/lotta-modules/bun-yday
+failing-tests.txt
+github
+make-dev-stats.csv
+misctools/fetch
+misctools/machbench
+misctools/sha
+myscript.sh
+node_modules
+node_modules_*
+out
+out.*
+outcss
+outdir
+outdir/
+packages/*/*.wasm
+packages/bun-*/*.o
 packages/bun-*/bun
 packages/bun-*/bun-profile
 packages/bun-*/debug-bun
-packages/bun-*/*.o
-packages/bun-cli/postinstall.js
-
 packages/bun-cli/bin/*
-bun-test-scratch
-misctools/fetch
-
-src/deps/libiconv
-src/deps/openssl
+packages/bun-cli/postinstall.js
+packages/bun-wasm/*.cjs
+packages/bun-wasm/*.d.cts
+packages/bun-wasm/*.d.mts
+packages/bun-wasm/*.d.ts
+packages/bun-wasm/*.js
+packages/bun-wasm/*.map
+packages/bun-wasm/*.mjs
+packages/debug-*
+parceldist
+pnpm-lock.yaml
+profile.json
+README.md.template
+release/
+scripts/env.local
+sign.*.json
+sign.json
+src/bake/generated.ts
+src/generated_enum_extractor.zig
+src/bun.js/bindings-obj
+src/bun.js/bindings/GeneratedJS2Native.zig
+src/bun.js/bindings/GeneratedBindings.zig
+src/bun.js/debug-bindings-obj
+src/deps/zig-clap/.gitattributes
+src/deps/zig-clap/.github
+src/deps/zig-clap/example
+src/deps/zig-clap/README.md
+src/fallback.version
+src/js/out/DebugPath.h
+src/js/out/functions*
+src/js/out/modules*
+src/js/out/tmp
+src/node-fallbacks/node_modules
+src/node-fallbacks/out/*
+src/runtime.version
 src/tests.zig
-*.blob
-src/deps/s2n-tls
-.npm
-.npm.gz
+test.txt
+test/js/bun/glob/fixtures
+test/node.js/upstream
+tsconfig.tsbuildinfo
+txt.js
+x64
+yarn.lock
+zig-cache
+zig-out
+test/node.js/upstream
+.zig-cache
+scripts/env.local
+*.generated.ts
+src/bake/generated.ts
+test/cli/install/registry/packages/publish-pkg-*
+test/cli/install/registry/packages/@secret/publish-pkg-8
+test/js/third_party/prisma/prisma/sqlite/dev.db-journal
+tmp
+codegen-for-zig-team.tar.gz
 
-bun-binary
+# Dependencies
+/vendor
 
-src/deps/PLCrashReporter/
+# Dependencies (before CMake)
+# These can be removed in the far future
+/src/bun.js/WebKit
+/src/deps/boringssl
+/src/deps/brotli
+/src/deps/c*ares
+/src/deps/libarchive
+/src/deps/libdeflate
+/src/deps/libuv
+/src/deps/lol*html
+/src/deps/ls*hpack
+/src/deps/mimalloc
+/src/deps/picohttpparser
+/src/deps/tinycc
+/src/deps/WebKit
+/src/deps/zig
+/src/deps/zlib
+/src/deps/zstd
 
-*.dSYM
-*.crash
+# Generated files
+
+.buildkite/ci.yml
+*.sock
+scratch*.{js,ts,tsx,cjs,mjs}
+
+*.bun-build
+
+scripts/lldb-inline
+
+# We regenerate these in all the build scripts
+cmake/sources/*.txt

.gitmodules

@@ -1,39 +0,0 @@
-# [submodule "src/deps/zig-clap"]
-# 	path = src/deps/zig-clap
-# 	url = https://github.com/Hejsil/zig-clap
-[submodule "src/deps/picohttpparser"]
-	path = src/deps/picohttpparser
-	url = https://github.com/h2o/picohttpparser.git
-	ignore = dirty
-[submodule "src/javascript/jsc/WebKit"]
-	path = src/javascript/jsc/WebKit
-	url = https://github.com/Jarred-Sumner/WebKit.git
-	ignore = dirty
-[submodule "src/deps/mimalloc"]
-	path = src/deps/mimalloc
-	url = https://github.com/Jarred-Sumner/mimalloc.git
-	ignore = dirty
-[submodule "src/deps/zlib"]
-	path = src/deps/zlib
-	url = https://github.com/cloudflare/zlib.git
-	ignore = dirty
-[submodule "src/deps/libarchive"]
-	path = src/deps/libarchive
-	url = https://github.com/libarchive/libarchive.git
-	ignore = dirty
-[submodule "src/deps/boringssl"]
-	path = src/deps/boringssl
-	url = https://github.com/google/boringssl.git
-	ignore = dirty
-[submodule "src/deps/libbacktrace"]
-	path = src/deps/libbacktrace
-	url = https://github.com/ianlancetaylor/libbacktrace
-	ignore = dirty
-[submodule "src/deps/lol-html"]
-	path = src/deps/lol-html
-	url = https://github.com/cloudflare/lol-html
-	ignore = dirty
-[submodule "src/deps/uws"]
-	path = src/deps/uws
-	url = https://github.com/Jarred-Sumner/uWebSockets
-	ignore = dirty

.lldbinit

@@ -0,0 +1 @@
+command source -C -s true -e true misctools/lldb/init.lldb

.mailmap

@@ -0,0 +1,2 @@
+# To learn more about git's mailmap: https://ntietz.com/blog/git-mailmap-for-name-changes
+chloe caruso <git@paperclover.net> <me@paperdave.net>

.prettierignore

@@ -0,0 +1,10 @@
+src/bun.js/WebKit
+vendor
+test/snapshots
+test/js/deno
+test/node.js
+src/react-refresh.js
+*.min.js
+test/snippets
+test/js/node/test
+bun.lock

.prettierrc

@@ -0,0 +1,24 @@
+{
+  "arrowParens": "avoid",
+  "printWidth": 120,
+  "trailingComma": "all",
+  "useTabs": false,
+  "quoteProps": "preserve",
+  "overrides": [
+    {
+      "files": [".vscode/*.json"],
+      "options": {
+        "parser": "jsonc",
+        "quoteProps": "preserve",
+        "singleQuote": false,
+        "trailingComma": "all"
+      }
+    },
+    {
+      "files": ["*.md"],
+      "options": {
+        "printWidth": 80
+      }
+    }
+  ]
+}

.scripts/write-versions.sh

@@ -1,25 +0,0 @@
-#!/bin/bash
-set -euxo pipefail
-
-WEBKIT_VERSION=$(git rev-parse HEAD:./src/javascript/jsc/WebKit)
-MIMALLOC_VERSION=$(git rev-parse HEAD:./src/deps/mimalloc)
-LIBARCHIVE_VERSION=$(git rev-parse HEAD:./src/deps/libarchive)
-PICOHTTPPARSER_VERSION=$(git rev-parse HEAD:./src/deps/picohttpparser)
-BORINGSSL_VERSION=$(git rev-parse HEAD:./src/deps/boringssl)
-ZLIB_VERSION=$(git rev-parse HEAD:./src/deps/zlib)
-UWS_VERSION=$(git rev-parse HEAD:./src/deps/uws)
-
-rm -rf src/generated_versions_list.zig
-echo "// AUTO-GENERATED FILE. Created via .scripts/write-versions.sh" >src/generated_versions_list.zig
-echo "" >>src/generated_versions_list.zig
-echo "pub const boringssl = \"$BORINGSSL_VERSION\";" >>src/generated_versions_list.zig
-echo "pub const libarchive = \"$LIBARCHIVE_VERSION\";" >>src/generated_versions_list.zig
-echo "pub const mimalloc = \"$MIMALLOC_VERSION\";" >>src/generated_versions_list.zig
-echo "pub const picohttpparser = \"$PICOHTTPPARSER_VERSION\";" >>src/generated_versions_list.zig
-echo "pub const uws = \"$UWS_VERSION\";" >>src/generated_versions_list.zig
-echo "pub const webkit = \"$WEBKIT_VERSION\";" >>src/generated_versions_list.zig
-echo "pub const zig = @import(\"std\").fmt.comptimePrint(\"{}\", .{@import(\"builtin\").zig_version});" >>src/generated_versions_list.zig
-echo "pub const zlib = \"$ZLIB_VERSION\";" >>src/generated_versions_list.zig
-echo "" >>src/generated_versions_list.zig
-
-zig fmt src/generated_versions_list.zig

.typos.toml

@@ -0,0 +1,2 @@
+[type.md]
+extend-ignore-words-re = ["^ba"]

.vscode/c_cpp_properties.json

@@ -1,30 +1,39 @@
 {
   "configurations": [
     {
-      "name": "Mac",
-      "forcedInclude": [
-        "${workspaceFolder}/src/javascript/jsc/bindings/root.h"
-      ],
+      "name": "Debug",
+      "forcedInclude": ["${workspaceFolder}/src/bun.js/bindings/root.h"],
+      "compileCommands": "${workspaceFolder}/build/debug/compile_commands.json",
       "includePath": [
-        "${workspaceFolder}/src/JavaScript/jsc/WebKit/WebKitBuild/Release/JavaScriptCore/PrivateHeaders/",
-        "${workspaceFolder}/src/JavaScript/jsc/WebKit/WebKitBuild/Release/WTF/Headers",
-        "${workspaceFolder}/src/JavaScript/jsc/WebKit/WebKitBuild/Release/*",
-        "${workspaceFolder}/src/JavaScript/jsc/bindings/",
-        "${workspaceFolder}/src/JavaScript/jsc/WebKit/Source/bmalloc/",
-        "${workspaceFolder}/src/javascript/jsc/WebKit/WebKitBuild/Release/ICU/Headers/"
+        "${workspaceFolder}/build/bun-webkit/include",
+        "${workspaceFolder}/build/debug/codegen",
+        "${workspaceFolder}/src/bun.js/bindings/",
+        "${workspaceFolder}/src/bun.js/bindings/webcore/",
+        "${workspaceFolder}/src/bun.js/bindings/sqlite/",
+        "${workspaceFolder}/src/bun.js/bindings/webcrypto/",
+        "${workspaceFolder}/src/bun.js/modules/",
+        "${workspaceFolder}/src/js/builtins/",
+        "${workspaceFolder}/vendor/boringssl/include/",
+        "${workspaceFolder}/vendor",
+        "${workspaceFolder}/src/napi/*",
+        "${workspaceFolder}/packages/bun-usockets/src",
+        "${workspaceFolder}/packages/",
       ],
       "browse": {
         "path": [
-          "${workspaceFolder}/src/javascript/jsc/bindings/*",
-          "${workspaceFolder}/src/JavaScript/jsc/WebKit/WebKitBuild/Release/JavaScriptCore/PrivateHeaders/",
-          "${workspaceFolder}/src/JavaScript/jsc/WebKit/WebKitBuild/Release/WTF/Headers/**",
-          "${workspaceFolder}/src/JavaScript/jsc/WebKit/WebKitBuild/Release/*",
-          "${workspaceFolder}/src/JavaScript/jsc/bindings/**",
-          "${workspaceFolder}/src/JavaScript/jsc/WebKit/Source/bmalloc/**",
-          "${workspaceFolder}/src/javascript/jsc/WebKit/WebKitBuild/Release/ICU/Headers/"
+          "${workspaceFolder}/build/bun-webkit/include",
+          "${workspaceFolder}/src/bun.js/bindings",
+          "${workspaceFolder}/src/napi/*",
+          "${workspaceFolder}/src/js/builtins/*",
+          "${workspaceFolder}/src/bun.js/modules/*",
+          "${workspaceFolder}/vendor/*",
+          "${workspaceFolder}/vendor/boringssl/include/*",
+          "${workspaceFolder}/packages/bun-usockets/*",
+          "${workspaceFolder}/packages/bun-uws/*",
+          "${workspaceFolder}/src/napi/*",
         ],
         "limitSymbolsToIncludedHeaders": true,
-        "databaseFilename": ".vscode/cppdb"
+        "databaseFilename": ".vscode/cppdb",
       },
       "defines": [
         "STATICALLY_LINKED_WITH_JavaScriptCore=1",
@@ -34,15 +43,78 @@
         "ENABLE_INSPECTOR_ALTERNATE_DISPATCHERS=0",
         "BUILDING_JSCONLY__",
         "USE_FOUNDATION=1",
-        "ASSERT_ENABLED=0",
-        "DU_DISABLE_RENAMING=1"
+        "ASSERT_ENABLED=1",
+        "DU_DISABLE_RENAMING=1",
       ],
       "macFrameworkPath": [],
-      "compilerPath": "/usr/local/opt/llvm/bin/clang",
+      "compilerPath": "${workspaceFolder}/.vscode/clang++",
       "cStandard": "c17",
-      "cppStandard": "c++11",
-      "intelliSenseMode": "macos-clang-x64"
-    }
+      "cppStandard": "c++20",
+    },
+    {
+      "name": "BunWithJSCDebug",
+      "forcedInclude": ["${workspaceFolder}/src/bun.js/bindings/root.h"],
+      "includePath": [
+        "${workspaceFolder}/build/debug/codegen",
+        "${workspaceFolder}/vendor/WebKit/WebKitBuild/Debug/",
+        "${workspaceFolder}/vendor/WebKit/WebKitBuild/Debug/ICU/Headers/",
+        "${workspaceFolder}/vendor/WebKit/WebKitBuild/Debug/JavaScriptCore/PrivateHeaders/",
+        "${workspaceFolder}/vendor/WebKit/WebKitBuild/Debug/WTF/Headers",
+        "${workspaceFolder}/vendor/WebKit/WebKitBuild/Debug/bmalloc/Headers/",
+        "${workspaceFolder}/src/bun.js/bindings/",
+        "${workspaceFolder}/src/bun.js/bindings/webcore/",
+        "${workspaceFolder}/src/bun.js/bindings/sqlite/",
+        "${workspaceFolder}/src/bun.js/bindings/webcrypto/",
+        "${workspaceFolder}/src/bun.js/modules/",
+        "${workspaceFolder}/src/js/builtins/",
+        "${workspaceFolder}/src/js/out",
+        "${workspaceFolder}/vendor/boringssl/include/",
+        "${workspaceFolder}/vendor",
+        "${workspaceFolder}/src/napi/*",
+        "${workspaceFolder}/packages/bun-usockets/src",
+        "${workspaceFolder}/packages/",
+      ],
+      "browse": {
+        "path": [
+          "${workspaceFolder}/vendor/WebKit/WebKitBuild/Debug/",
+          "${workspaceFolder}/vendor/WebKit/WebKitBuild/Debug/ICU/Headers/",
+          "${workspaceFolder}/vendor/WebKit/WebKitBuild/Debug/JavaScriptCore/PrivateHeaders/**",
+          "${workspaceFolder}/vendor/WebKit/WebKitBuild/Debug/WTF/Headers/**",
+          "${workspaceFolder}/vendor/WebKit/WebKitBuild/Debug/bmalloc/Headers/**",
+          "${workspaceFolder}/src/bun.js/bindings/*",
+          "${workspaceFolder}/src/bun.js/bindings/*",
+          "${workspaceFolder}/src/napi/*",
+          "${workspaceFolder}/src/bun.js/bindings/sqlite/",
+          "${workspaceFolder}/src/bun.js/bindings/webcrypto/",
+          "${workspaceFolder}/src/bun.js/bindings/webcore/",
+          "${workspaceFolder}/src/js/builtins/*",
+          "${workspaceFolder}/src/js/out/*",
+          "${workspaceFolder}/src/bun.js/modules/*",
+          "${workspaceFolder}/vendor",
+          "${workspaceFolder}/vendor/boringssl/include/",
+          "${workspaceFolder}/packages/bun-usockets/",
+          "${workspaceFolder}/packages/bun-uws/",
+          "${workspaceFolder}/src/napi",
+        ],
+        "limitSymbolsToIncludedHeaders": true,
+        "databaseFilename": ".vscode/cppdb_debug",
+      },
+      "defines": [
+        "STATICALLY_LINKED_WITH_JavaScriptCore=1",
+        "STATICALLY_LINKED_WITH_WTF=1",
+        "BUILDING_WITH_CMAKE=1",
+        "NOMINMAX",
+        "ENABLE_INSPECTOR_ALTERNATE_DISPATCHERS=0",
+        "BUILDING_JSCONLY__",
+        "USE_FOUNDATION=1",
+        "ASSERT_ENABLED=1",
+        "DU_DISABLE_RENAMING=1",
+      ],
+      "macFrameworkPath": [],
+      "compilerPath": "${workspaceFolder}/.vscode/clang++",
+      "cStandard": "c17",
+      "cppStandard": "c++20",
+    },
   ],
-  "version": 4
+  "version": 4,
 }

.vscode/extensions.json

@@ -0,0 +1,33 @@
+{
+  "recommendations": [
+    // Zig
+    "ziglang.vscode-zig",
+
+    // C/C++
+    "clang.clangd",
+    "ms-vscode.cmake-tools",
+    "xaver.clang-format",
+    "vadimcn.vscode-lldb",
+
+    // JavaScript
+    "oven.bun-vscode",
+    "esbenp.prettier-vscode",
+
+    // TypeScript
+    "better-ts-errors.better-ts-errors",
+    "MylesMurphy.prettify-ts",
+
+    // Markdown
+    "bierner.markdown-preview-github-styles",
+    "bierner.markdown-emoji",
+    "bierner.emojisense",
+    "bierner.markdown-checkbox",
+    "bierner.jsdoc-markdown-highlighting",
+
+    // TOML
+    "tamasfe.even-better-toml",
+
+    // Other
+    "bierner.comment-tagged-templates",
+  ],
+}

.vscode/settings.json

@@ -1,25 +1,133 @@
 {
-  "git.autoRepositoryDetection": "openEditors",
+  // Editor
+  "editor.tabSize": 2,
+  "editor.insertSpaces": true,
+  "editor.formatOnSave": true,
+  "editor.formatOnSaveMode": "file",
+
+  // Search
   "search.quickOpen.includeSymbols": false,
   "search.seedWithNearestWord": true,
   "search.smartCase": true,
-  "search.exclude": {},
+  "search.exclude": {
+    "node_modules": true,
+    ".git": true,
+    "vendor/*/**": true,
+    "test/node.js/upstream": true,
+    // This will fill up your whole search history.
+    "test/js/node/test/fixtures": true,
+    "test/js/node/test/common": true,
+  },
   "search.followSymlinks": false,
   "search.useIgnoreFiles": true,
-  "zig.buildOnSave": false,
-  "[zig]": {
-    "editor.defaultFormatter": "AugusteRame.zls-vscode"
-  },
-  "[ts]": {
-    "editor.defaultFormatter": "esbenp.prettier-vscode"
-  },
-  "[tsx]": {
-    "editor.defaultFormatter": "esbenp.prettier-vscode"
-  },
-  "zig.beforeDebugCmd": "make build-unit ${file} ${filter} ${bin}",
-  "zig.testCmd": "make test ${file} ${filter} ${bin}",
 
+  // Git
+  "git.autoRepositoryDetection": "openEditors",
+  "git.ignoreSubmodules": true,
+  "git.ignoreLimitWarning": true,
+
+  // Zig
+  "zig.initialSetupDone": true,
+  "zig.buildOption": "build",
+  "zig.zls.zigLibPath": "${workspaceFolder}/vendor/zig/lib",
+  "zig.buildArgs": ["-Dgenerated-code=./build/debug/codegen", "--watch", "-fincremental"],
+  "zig.zls.buildOnSaveStep": "check",
+  // "zig.zls.enableBuildOnSave": true,
+  // "zig.buildOnSave": true,
+  "zig.buildFilePath": "${workspaceFolder}/build.zig",
+  "zig.path": "${workspaceFolder}/vendor/zig/zig.exe",
+  "zig.zls.path": "${workspaceFolder}/vendor/zig/zls.exe",
+  "zig.formattingProvider": "zls",
+  "zig.zls.enableInlayHints": false,
+  "[zig]": {
+    "editor.tabSize": 4,
+    "editor.useTabStops": false,
+    "editor.defaultFormatter": "ziglang.vscode-zig",
+    "editor.codeActionsOnSave": {
+      "source.organizeImports": "never",
+    },
+  },
+
+  // lldb
+  "lldb.launch.initCommands": ["command source ${workspaceFolder}/.lldbinit"],
   "lldb.verboseLogging": false,
+
+  // C++
+  "cmake.configureOnOpen": false,
+  "C_Cpp.errorSquiggles": "enabled",
+  "[cpp]": {
+    "editor.tabSize": 4,
+    "editor.defaultFormatter": "xaver.clang-format",
+  },
+  "[c]": {
+    "editor.tabSize": 4,
+    "editor.defaultFormatter": "xaver.clang-format",
+  },
+  "[h]": {
+    "editor.tabSize": 4,
+    "editor.defaultFormatter": "xaver.clang-format",
+  },
+  "clangd.arguments": ["--header-insertion=never"],
+
+  // JavaScript
+  "prettier.enable": true,
+  "prettier.configPath": ".prettierrc",
+  "eslint.workingDirectories": ["${workspaceFolder}/packages/bun-types"],
+  "[javascript]": {
+    "editor.defaultFormatter": "esbenp.prettier-vscode",
+  },
+  "[javascriptreact]": {
+    "editor.defaultFormatter": "esbenp.prettier-vscode",
+  },
+  "prettier.prettierPath": "./node_modules/prettier",
+
+  // TypeScript
+  "typescript.tsdk": "node_modules/typescript/lib",
+  "[typescript]": {
+    "editor.defaultFormatter": "esbenp.prettier-vscode",
+  },
+  "[typescriptreact]": {
+    "editor.defaultFormatter": "esbenp.prettier-vscode",
+  },
+
+  // JSON
+  "[json]": {
+    "editor.defaultFormatter": "esbenp.prettier-vscode",
+  },
+  "[jsonc]": {
+    "editor.defaultFormatter": "esbenp.prettier-vscode",
+  },
+
+  // Markdown
+  "[markdown]": {
+    "editor.defaultFormatter": "esbenp.prettier-vscode",
+    "editor.unicodeHighlight.ambiguousCharacters": true,
+    "editor.unicodeHighlight.invisibleCharacters": true,
+    "diffEditor.ignoreTrimWhitespace": false,
+    "editor.wordWrap": "on",
+    "editor.quickSuggestions": {
+      "comments": "off",
+      "strings": "off",
+      "other": "off",
+    },
+  },
+
+  // TOML
+  "[toml]": {
+    "editor.defaultFormatter": "esbenp.prettier-vscode",
+  },
+
+  // YAML
+  "[yaml]": {
+    "editor.defaultFormatter": "esbenp.prettier-vscode",
+  },
+
+  // Docker
+  "[dockerfile]": {
+    "editor.formatOnSave": false,
+  },
+
+  // Files
   "files.exclude": {
     "**/.git": true,
     "**/.svn": true,
@@ -29,129 +137,36 @@
     "**/Thumbs.db": true,
     "**/*.xcworkspacedata": true,
     "**/*.xcscheme": true,
-    "**/*.pem": true,
     "**/*.xcodeproj": true,
-
-    "integration/snapshots": true,
-    "integration/snapshots-no-hmr": true,
-    "src/javascript/jsc/WebKit": true,
-    "src/deps/libarchive": true,
-    "src/deps/mimalloc": true,
-    "src/deps/s2n-tls": true,
-    "src/deps/boringssl": true,
-    "src/deps/openssl": true,
-    "src/deps/uws": true,
-    "src/deps/zlib": true,
-    "src/deps/lol-html": true,
-    "integration/snippets/package-json-exports/_node_modules_copy": true
+    "**/*.i": true,
+  },
+  "files.associations": {
+    "*.css": "tailwindcss",
+    "*.idl": "cpp",
+    "*.mdc": "markdown",
+    "array": "cpp",
+    "ios": "cpp",
+    "oxlint.json": "jsonc",
+    "bun.lock": "jsonc",
   },
   "C_Cpp.files.exclude": {
     "**/.vscode": true,
-    "src/javascript/jsc/WebKit/JSTests": true,
-    "src/javascript/jsc/WebKit/Tools": true,
-    "src/javascript/jsc/WebKit/WebDriverTests": true,
-    "src/javascript/jsc/WebKit/WebKit.xcworkspace": true,
-    "src/javascript/jsc/WebKit/WebKitLibraries": true,
-    "src/javascript/jsc/WebKit/Websites": true,
-    "src/javascript/jsc/WebKit/resources": true,
-    "src/javascript/jsc/WebKit/LayoutTests": true,
-    "src/javascript/jsc/WebKit/ManualTests": true,
-    "src/javascript/jsc/WebKit/PerformanceTests": true,
-    "src/javascript/jsc/WebKit/WebKitLegacy": true,
-    "src/javascript/jsc/WebKit/WebCore": true,
-    "src/javascript/jsc/WebKit/WebDriver": true,
-    "src/javascript/jsc/WebKit/WebKitBuild": true,
-    "src/javascript/jsc/WebKit/WebInspectorUI": true
+    "WebKit/JSTests": true,
+    "WebKit/Tools": true,
+    "WebKit/WebDriverTests": true,
+    "WebKit/WebKit.xcworkspace": true,
+    "WebKit/WebKitLibraries": true,
+    "WebKit/Websites": true,
+    "WebKit/resources": true,
+    "WebKit/LayoutTests": true,
+    "WebKit/ManualTests": true,
+    "WebKit/PerformanceTests": true,
+    "WebKit/WebKitLegacy": true,
+    "WebKit/WebCore": true,
+    "WebKit/WebDriver": true,
+    "WebKit/WebKitBuild": true,
+    "WebKit/WebInspectorUI": true,
   },
-  "[cpp]": {
-    "editor.defaultFormatter": "xaver.clang-format"
-  },
-  "[h]": {
-    "editor.defaultFormatter": "xaver.clang-format"
-  },
-  "[c]": {
-    "editor.defaultFormatter": "xaver.clang-format"
-  },
-  "files.associations": {
-    "*.idl": "cpp",
-    "memory": "cpp",
-    "iostream": "cpp",
-    "algorithm": "cpp",
-    "random": "cpp",
-    "ios": "cpp",
-    "filesystem": "cpp",
-    "__locale": "cpp",
-    "type_traits": "cpp",
-    "__mutex_base": "cpp",
-    "__string": "cpp",
-    "string": "cpp",
-    "string_view": "cpp",
-    "typeinfo": "cpp",
-    "__config": "cpp",
-    "__nullptr": "cpp",
-    "exception": "cpp",
-    "__bit_reference": "cpp",
-    "atomic": "cpp",
-    "utility": "cpp",
-    "sstream": "cpp",
-    "__functional_base": "cpp",
-    "new": "cpp",
-    "__debug": "cpp",
-    "__errc": "cpp",
-    "__hash_table": "cpp",
-    "__node_handle": "cpp",
-    "__split_buffer": "cpp",
-    "__threading_support": "cpp",
-    "__tuple": "cpp",
-    "array": "cpp",
-    "bit": "cpp",
-    "bitset": "cpp",
-    "cctype": "cpp",
-    "chrono": "cpp",
-    "clocale": "cpp",
-    "cmath": "cpp",
-    "complex": "cpp",
-    "condition_variable": "cpp",
-    "cstdarg": "cpp",
-    "cstddef": "cpp",
-    "cstdint": "cpp",
-    "cstdio": "cpp",
-    "cstdlib": "cpp",
-    "cstring": "cpp",
-    "ctime": "cpp",
-    "cwchar": "cpp",
-    "cwctype": "cpp",
-    "deque": "cpp",
-    "fstream": "cpp",
-    "functional": "cpp",
-    "initializer_list": "cpp",
-    "iomanip": "cpp",
-    "iosfwd": "cpp",
-    "istream": "cpp",
-    "iterator": "cpp",
-    "limits": "cpp",
-    "locale": "cpp",
-    "mutex": "cpp",
-    "optional": "cpp",
-    "ostream": "cpp",
-    "ratio": "cpp",
-    "stack": "cpp",
-    "stdexcept": "cpp",
-    "streambuf": "cpp",
-    "system_error": "cpp",
-    "thread": "cpp",
-    "tuple": "cpp",
-    "unordered_map": "cpp",
-    "unordered_set": "cpp",
-    "vector": "cpp",
-    "__bits": "cpp",
-    "__tree": "cpp",
-    "map": "cpp",
-    "numeric": "cpp",
-    "set": "cpp",
-    "__memory": "cpp",
-    "memory_resource": "cpp"
-  },
-  "go.logging.level": "off",
-  "cmake.configureOnOpen": false
+  "git.detectSubmodules": false,
+  "bun.test.customScript": "./build/debug/bun-debug test",
 }

.vscode/tasks.json

@@ -2,33 +2,58 @@
   "version": "2.0.0",
   "tasks": [
     {
-      "label": "build",
-      "type": "process",
-      "command": "zig",
-      "args": ["build"],
-      "presentation": {
-        "echo": true,
-        "reveal": "silent",
-        "focus": false,
-        "panel": "shared",
-        "showReuseMessage": false,
-        "clear": false
-      },
+      "label": "Build Bun",
+      "type": "shell",
+      "command": "bun run build",
       "group": {
         "kind": "build",
-        "isDefault": true
-      }
-    },
-    {
-      "label": "run",
-      "type": "process",
-      "command": "zig",
-      "args": ["run", "${file}"],
-      "group": "build",
+        "isDefault": true,
+      },
+      "problemMatcher": [
+        {
+          "owner": "zig",
+          "fileLocation": ["relative", "${workspaceFolder}"],
+          "pattern": [
+            {
+              "regexp": "^(.+?):(\\d+):(\\d+): (error|warning|note): (.+)$",
+              "file": 1,
+              "line": 2,
+              "column": 3,
+              "severity": 4,
+              "message": 5,
+            },
+            {
+              "regexp": "^\\s+(.+)$",
+              "message": 1,
+              "loop": true,
+            },
+          ],
+        },
+        {
+          "owner": "clang",
+          "fileLocation": ["relative", "${workspaceFolder}"],
+          "pattern": [
+            {
+              "regexp": "^([^:]+):(\\d+):(\\d+):\\s+(warning|error|note|remark):\\s+(.*)$",
+              "file": 1,
+              "line": 2,
+              "column": 3,
+              "severity": 4,
+              "message": 5,
+            },
+            {
+              "regexp": "^\\s*(.*)$",
+              "message": 1,
+              "loop": true,
+            },
+          ],
+        },
+      ],
       "presentation": {
-        "showReuseMessage": false,
-        "clear": true
-      }
-    }
-  ]
+        "reveal": "always",
+        "panel": "shared",
+        "clear": true,
+      },
+    },
+  ],
 }

AGENTS.md

@@ -0,0 +1 @@
+CLAUDE.md

CLAUDE.md

@@ -0,0 +1,251 @@
+This is the Bun repository - an all-in-one JavaScript runtime & toolkit designed for speed, with a bundler, test runner, and Node.js-compatible package manager. It's written primarily in Zig with C++ for JavaScriptCore integration, powered by WebKit's JavaScriptCore engine.
+
+## Building and Running Bun
+
+### Build Commands
+
+- **Build debug version**: `bun bd`
+  - Creates a debug build at `./build/debug/bun-debug`
+  - **CRITICAL**: DO NOT set a build timeout. Compilation takes ~5 minutes. Be patient.
+- **Run tests with your debug build**: `bun bd test <test-file>`
+  - **CRITICAL**: Never use `bun test` directly - it won't include your changes
+- **Run any command with debug build**: `bun bd <command>`
+
+### Other Build Variants
+
+- `bun run build:release` - Release build
+
+Address sanitizer is enabled by default in debug builds of Bun.
+
+## Testing
+
+### Running Tests
+
+- **Single test file**: `bun bd test test/js/bun/http/serve.test.ts`
+- **Fuzzy match test file**: `bun bd test http/serve.test.ts`
+- **With filter**: `bun bd test test/js/bun/http/serve.test.ts -t "should handle"`
+
+### Test Organization
+
+- `test/js/bun/` - Bun-specific API tests (http, crypto, ffi, shell, etc.)
+- `test/js/node/` - Node.js compatibility tests
+- `test/js/web/` - Web API tests (fetch, WebSocket, streams, etc.)
+- `test/cli/` - CLI command tests (install, run, test, etc.)
+- `test/regression/issue/` - Regression tests (create one per bug fix)
+- `test/bundler/` - Bundler and transpiler tests
+- `test/integration/` - End-to-end integration tests
+- `test/napi/` - N-API compatibility tests
+- `test/v8/` - V8 C++ API compatibility tests
+
+### Writing Tests
+
+Tests use Bun's Jest-compatible test runner with proper test fixtures:
+
+```typescript
+import { test, expect } from "bun:test";
+import { bunEnv, bunExe, normalizeBunSnapshot, tempDir } from "harness";
+
+test("my feature", async () => {
+  // Create temp directory with test files
+  using dir = tempDir("test-prefix", {
+    "index.js": `console.log("hello");`,
+  });
+
+  // Spawn Bun process
+  await using proc = Bun.spawn({
+    cmd: [bunExe(), "index.js"],
+    env: bunEnv,
+    cwd: String(dir),
+    stderr: "pipe",
+  });
+
+  const [stdout, stderr, exitCode] = await Promise.all([
+    proc.stdout.text(),
+    proc.stderr.text(),
+    proc.exited,
+  ]);
+
+  expect(exitCode).toBe(0);
+  // Prefer snapshot tests over expect(stdout).toBe("hello\n");
+  expect(normalizeBunSnapshot(stdout, dir)).toMatchInlineSnapshot(`"hello"`);
+});
+```
+
+- Always use `port: 0`. Do not hardcode ports. Do not use your own random port number function.
+- Use `normalizeBunSnapshot` to normalize snapshot output of the test.
+- NEVER write tests that check for no "panic" or "uncaught exception" or similar in the test output. That is NOT a valid test.
+
+## Code Architecture
+
+### Language Structure
+
+- **Zig code** (`src/*.zig`): Core runtime, JavaScript bindings, package manager
+- **C++ code** (`src/bun.js/bindings/*.cpp`): JavaScriptCore bindings, Web APIs
+- **TypeScript** (`src/js/`): Built-in JavaScript modules with special syntax (see JavaScript Modules section)
+- **Generated code**: Many files are auto-generated from `.classes.ts` and other sources
+
+### Core Source Organization
+
+#### Runtime Core (`src/`)
+
+- `bun.zig` - Main entry point
+- `cli.zig` - CLI command orchestration
+- `js_parser.zig`, `js_lexer.zig`, `js_printer.zig` - JavaScript parsing/printing
+- `transpiler.zig` - Wrapper around js_parser with sourcemap support
+- `resolver/` - Module resolution system
+- `allocators/` - Custom memory allocators for performance
+
+#### JavaScript Runtime (`src/bun.js/`)
+
+- `bindings/` - C++ JavaScriptCore bindings
+  - Generated classes from `.classes.ts` files
+  - Manual bindings for complex APIs
+- `api/` - Bun-specific APIs
+  - `server.zig` - HTTP server implementation
+  - `FFI.zig` - Foreign Function Interface
+  - `crypto.zig` - Cryptographic operations
+  - `glob.zig` - File pattern matching
+- `node/` - Node.js compatibility layer
+  - Module implementations (fs, path, crypto, etc.)
+  - Process and Buffer APIs
+- `webcore/` - Web API implementations
+  - `fetch.zig` - Fetch API
+  - `streams.zig` - Web Streams
+  - `Blob.zig`, `Response.zig`, `Request.zig`
+- `event_loop/` - Event loop and task management
+
+#### Build Tools & Package Manager
+
+- `src/bundler/` - JavaScript bundler
+  - Advanced tree-shaking
+  - CSS processing
+  - HTML handling
+- `src/install/` - Package manager
+  - `lockfile/` - Lockfile handling
+  - `npm.zig` - npm registry client
+  - `lifecycle_script_runner.zig` - Package scripts
+
+#### Other Key Components
+
+- `src/shell/` - Cross-platform shell implementation
+- `src/css/` - CSS parser and processor
+- `src/http/` - HTTP client implementation
+  - `websocket_client/` - WebSocket client (including deflate support)
+- `src/sql/` - SQL database integrations
+- `src/bake/` - Server-side rendering framework
+
+### JavaScript Class Implementation (C++)
+
+When implementing JavaScript classes in C++:
+
+1. Create three classes if there's a public constructor:
+   - `class Foo : public JSC::JSDestructibleObject` (if has C++ fields)
+   - `class FooPrototype : public JSC::JSNonFinalObject`
+   - `class FooConstructor : public JSC::InternalFunction`
+
+2. Define properties using HashTableValue arrays
+3. Add iso subspaces for classes with C++ fields
+4. Cache structures in ZigGlobalObject
+
+## Development Workflow
+
+### Code Formatting
+
+- `bun run prettier` - Format JS/TS files
+- `bun run zig-format` - Format Zig files
+- `bun run clang-format` - Format C++ files
+
+### Watching for Changes
+
+- `bun run watch` - Incremental Zig compilation with error checking
+- `bun run watch-windows` - Windows-specific watch mode
+
+### Code Generation
+
+Code generation happens automatically as part of the build process. The main scripts are:
+
+- `src/codegen/generate-classes.ts` - Generates Zig & C++ bindings from `*.classes.ts` files
+- `src/codegen/generate-jssink.ts` - Generates stream-related classes
+- `src/codegen/bundle-modules.ts` - Bundles built-in modules like `node:fs`
+- `src/codegen/bundle-functions.ts` - Bundles global functions like `ReadableStream`
+
+In development, bundled modules can be reloaded without rebuilding Zig by running `bun run build`.
+
+## JavaScript Modules (`src/js/`)
+
+Built-in JavaScript modules use special syntax and are organized as:
+
+- `node/` - Node.js compatibility modules (`node:fs`, `node:path`, etc.)
+- `bun/` - Bun-specific modules (`bun:ffi`, `bun:sqlite`, etc.)
+- `thirdparty/` - NPM modules we replace (like `ws`)
+- `internal/` - Internal modules not exposed to users
+- `builtins/` - Core JavaScript builtins (streams, console, etc.)
+
+### Special Syntax in Built-in Modules
+
+1. **`$` prefix** - Access to private properties and JSC intrinsics:
+
+   ```js
+   const arr = $Array.from(...);  // Private global
+   map.$set(...);                 // Private method
+   const arr2 = $newArrayWithSize(5); // JSC intrinsic
+   ```
+
+2. **`require()`** - Must use string literals, resolved at compile time:
+
+   ```js
+   const fs = require("fs"); // Directly loads by numeric ID
+   ```
+
+3. **Debug helpers**:
+   - `$debug()` - Like console.log but stripped in release builds
+   - `$assert()` - Assertions stripped in release builds
+   - `if($debug) {}` - Check if debug env var is set
+
+4. **Platform detection**: `process.platform` and `process.arch` are inlined and dead-code eliminated
+
+5. **Export syntax**: Use `export default` which gets converted to a return statement:
+   ```js
+   export default {
+     readFile,
+     writeFile,
+   };
+   ```
+
+Note: These are NOT ES modules. The preprocessor converts `$` to `@` (JSC's actual syntax) and handles the special functions.
+
+## CI
+
+Bun uses BuildKite for CI. To get the status of a PR, you can use the following command:
+
+```bash
+bun ci
+```
+
+## Important Development Notes
+
+1. **Never use `bun test` or `bun <file>` directly** - always use `bun bd test` or `bun bd <command>`. `bun bd` compiles & runs the debug build.
+2. **All changes must be tested** - if you're not testing your changes, you're not done.
+3. **Get your tests to pass**. If you didn't run the tests, your code does not work.
+4. **Follow existing code style** - check neighboring files for patterns
+5. **Create tests in the right folder** in `test/` and the test must end in `.test.ts` or `.test.tsx`
+6. **Use absolute paths** - Always use absolute paths in file operations
+7. **Avoid shell commands** - Don't use `find` or `grep` in tests; use Bun's Glob and built-in tools
+8. **Memory management** - In Zig code, be careful with allocators and use defer for cleanup
+9. **Cross-platform** - Run `bun run zig:check-all` to compile the Zig code on all platforms when making platform-specific changes
+10. **Debug builds** - Use `BUN_DEBUG_QUIET_LOGS=1` to disable debug logging, or `BUN_DEBUG_<scope>=1` to enable specific scopes
+11. **Be humble & honest** - NEVER overstate what you got done or what actually works in commits, PRs or in messages to the user.
+12. **Branch names must start with `claude/`** - This is a requirement for the CI to work.
+
+## Key APIs and Features
+
+### Bun-Specific APIs
+
+- **Bun.serve()** - High-performance HTTP server
+- **Bun.spawn()** - Process spawning with better performance than Node.js
+- **Bun.file()** - Fast file I/O operations
+- **Bun.write()** - Unified API for writing to files, stdout, etc.
+- **Bun.$ (Shell)** - Cross-platform shell scripting
+- **Bun.SQLite** - Native SQLite integration
+- **Bun.FFI** - Call native libraries from JavaScript
+- **Bun.Glob** - Fast file pattern matching

CMakeLists.txt

@@ -0,0 +1,57 @@
+cmake_minimum_required(VERSION 3.24)
+message(STATUS "Configuring Bun")
+
+list(APPEND CMAKE_MODULE_PATH
+  ${CMAKE_SOURCE_DIR}/cmake
+  ${CMAKE_SOURCE_DIR}/cmake/targets
+  ${CMAKE_SOURCE_DIR}/cmake/tools
+  ${CMAKE_SOURCE_DIR}/cmake/analysis
+  ${CMAKE_SOURCE_DIR}/cmake/scripts
+)
+
+include(Policies)
+include(Globals)
+
+if (CMAKE_HOST_WIN32)
+  # Workaround for TLS certificate verification issue on Windows when downloading from GitHub
+  # Remove this once we've bumped the CI machines build image
+  set(CMAKE_TLS_VERIFY 0)
+endif()
+
+# --- Compilers ---
+
+if(CMAKE_HOST_APPLE)
+  include(SetupMacSDK)
+endif()
+include(SetupLLVM)
+include(SetupCcache)
+
+# --- Project ---
+
+parse_package_json(VERSION_VARIABLE DEFAULT_VERSION)
+optionx(VERSION STRING "The version of Bun" DEFAULT ${DEFAULT_VERSION})
+project(Bun VERSION ${VERSION})
+include(Options)
+include(CompilerFlags)
+
+# --- Tools ---
+
+include(SetupGit)
+include(SetupBuildkite)
+include(SetupBun)
+include(SetupEsbuild)
+include(SetupZig)
+include(SetupRust)
+
+# --- Targets ---
+
+include(BuildBun)
+
+# --- Analysis ---
+
+if(ENABLE_ANALYSIS)
+  include(RunClangFormat)
+  include(RunClangTidy)
+  include(RunZigFormat)
+  include(RunPrettier)
+endif()

CODE_OF_CONDUCT.md

@@ -0,0 +1,12 @@
+## Code of conduct
+
+- We are committed to providing a friendly, safe and welcoming environment for all, regardless of level of experience, gender identity and expression, sexual orientation, disability, personal appearance, body size, race, ethnicity, age, religion, nationality, or other similar characteristic.
+- Please avoid using overtly sexual aliases or other nicknames that might detract from a friendly, safe and welcoming environment for all.
+- Please be kind and courteous. There’s no need to be mean or rude.
+- Respect that people have differences of opinion and that every design or implementation choice carries a trade-off and numerous costs. There is seldom a right answer.
+- Please keep unstructured critique to a minimum. If you have solid ideas you want to experiment with, make a fork and see how it works.
+- We will exclude you from interaction if you insult, demean or harass anyone. That is not welcome behavior. We interpret the term “harassment” as including the definition in the [Citizen Code of Conduct](https://github.com/stumpsyn/policies/blob/master/citizen_code_of_conduct.md); if you have any lack of clarity about what might be included in that concept, please read their definition. In particular, we don’t tolerate behavior that excludes people in socially marginalized groups.
+- Private harassment is also unacceptable. No matter who you are, if you feel you have been or are being harassed or made uncomfortable by a community member, please contact one of the channel ops or an employee of Oven immediately. Whether you’re a regular contributor or a newcomer, we care about making this community a safe place for you and we’ve got your back.
+- Likewise any spamming, trolling, flaming, baiting or other attention-stealing behavior is not welcome.
+
+This code of conduct is adapted from the [Rust Code of Conduct](https://www.rust-lang.org/policies/code-of-conduct).