Don't call the onTimeout handler if the socket is closed, shutdown, or detached

.buildkite/bootstrap.yml

@@ -10,10 +10,9 @@ steps:
     blocked_state: "running"
 
   - label: ":pipeline:"
+    command: "buildkite-agent pipeline upload .buildkite/ci.yml"
     agents:
-      queue: "build-darwin"
-    command:
-      - ".buildkite/scripts/prepare-build.sh"
+      queue: "build-linux"
 
   - if: "build.branch == 'main' && !build.pull_request.repository.fork"
     label: ":github:"

.buildkite/scripts/build-bun.sh

@@ -1,55 +0,0 @@
-#!/bin/bash
-
-set -eo pipefail
-source "$(dirname "$0")/env.sh"
-
-function run_command() {
-  set -x
-  "$@"
-  { set +x; } 2>/dev/null
-}
-
-cwd="$(pwd)"
-
-mkdir -p build
-source "$(dirname "$0")/download-artifact.sh" "build/bun-deps/**" --step "$BUILDKITE_GROUP_KEY-build-deps"
-source "$(dirname "$0")/download-artifact.sh" "build/bun-zig.o" --step "$BUILDKITE_GROUP_KEY-build-zig"
-source "$(dirname "$0")/download-artifact.sh" "build/bun-cpp-objects.a" --step "$BUILDKITE_GROUP_KEY-build-cpp" --split
-cd build
-
-run_command cmake .. "${CMAKE_FLAGS[@]}" \
-  -GNinja \
-  -DBUN_LINK_ONLY="1" \
-  -DNO_CONFIGURE_DEPENDS="1" \
-  -DBUN_ZIG_OBJ_DIR="$cwd/build" \
-  -DBUN_CPP_ARCHIVE="$cwd/build/bun-cpp-objects.a" \
-  -DBUN_DEPS_OUT_DIR="$cwd/build/bun-deps" \
-  -DCMAKE_BUILD_TYPE="$CMAKE_BUILD_TYPE" \
-  -DCPU_TARGET="$CPU_TARGET" \
-  -DUSE_LTO="$USE_LTO" \
-  -DUSE_DEBUG_JSC="$USE_DEBUG_JSC" \
-  -DCANARY="$CANARY" \
-  -DGIT_SHA="$GIT_SHA"
-run_command ninja -v -j "$CPUS"
-run_command ls
-
-tag="bun-$BUILDKITE_GROUP_KEY"
-if [ "$USE_LTO" == "OFF" ]; then
-  # Remove OS check when LTO is enabled on macOS again
-  if [[ "$tag" == *"darwin"* ]]; then
-    tag="$tag-nolto"
-  fi
-fi
-
-for name in bun bun-profile; do
-  dir="$tag"
-  if [ "$name" == "bun-profile" ]; then
-    dir="$tag-profile"
-  fi
-  run_command chmod +x "$name"
-  run_command "./$name" --revision
-  run_command mkdir -p "$dir"
-  run_command mv "$name" "$dir/$name"
-  run_command zip -r "$dir.zip" "$dir"
-  source "$cwd/.buildkite/scripts/upload-artifact.sh" "$dir.zip"
-done

.buildkite/scripts/build-cpp.sh

@@ -1,34 +0,0 @@
-#!/bin/bash
-
-set -eo pipefail
-source "$(dirname "$0")/env.sh"
-source "$(realpath $(dirname "$0")/../../scripts/update-submodules.sh)"
-{ set +x; } 2>/dev/null
-
-function run_command() {
-  set -x
-  "$@"
-  { set +x; } 2>/dev/null
-}
-
-mkdir -p build
-cd build
-mkdir -p tmp_modules tmp_functions js codegen
-
-run_command cmake .. "${CMAKE_FLAGS[@]}" \
-  -GNinja \
-  -DBUN_CPP_ONLY="1" \
-  -DNO_CONFIGURE_DEPENDS="1" \
-  -DCMAKE_BUILD_TYPE="$CMAKE_BUILD_TYPE" \
-  -DCPU_TARGET="$CPU_TARGET" \
-  -DUSE_LTO="$USE_LTO" \
-  -DUSE_DEBUG_JSC="$USE_DEBUG_JSC" \
-  -DCANARY="$CANARY" \
-  -DGIT_SHA="$GIT_SHA"
-
-chmod +x compile-cpp-only.sh
-source compile-cpp-only.sh -v -j "$CPUS"
-{ set +x; } 2>/dev/null
-
-cd ..
-source "$(dirname "$0")/upload-artifact.sh" "build/bun-cpp-objects.a" --split

.buildkite/scripts/build-deps.sh

@@ -1,22 +0,0 @@
-#!/bin/bash
-
-set -eo pipefail
-source "$(dirname "$0")/env.sh"
-source "$(realpath $(dirname "$0")/../../scripts/all-dependencies.sh)"
-
-artifacts=(
-  libcrypto.a libssl.a libdecrepit.a
-  libcares.a
-  libarchive.a
-  liblolhtml.a
-  libmimalloc.a libmimalloc.o
-  libtcc.a
-  libz.a
-  libzstd.a
-  libdeflate.a
-  liblshpack.a
-)
-
-for artifact in "${artifacts[@]}"; do
-  source "$(dirname "$0")/upload-artifact.sh" "build/bun-deps/$artifact"
-done

.buildkite/scripts/build-old-js.sh

@@ -1,40 +0,0 @@
-#!/bin/bash
-
-set -eo pipefail
-source "$(dirname "$0")/env.sh"
-
-function assert_bun() {
-  if ! command -v bun &>/dev/null; then
-    echo "error: bun is not installed" 1>&2
-    exit 1
-  fi
-}
-
-function assert_make() {
-  if ! command -v make &>/dev/null; then
-    echo "error: make is not installed" 1>&2
-    exit 1
-  fi
-}
-
-function run_command() {
-  set -x
-  "$@"
-  { set +x; } 2>/dev/null
-}
-
-function build_node_fallbacks() {
-  local cwd="src/node-fallbacks"
-  run_command bun install --cwd "$cwd" --frozen-lockfile
-  run_command bun run --cwd "$cwd" build
-}
-
-function build_old_js() {
-  run_command bun install --frozen-lockfile
-  run_command make runtime_js fallback_decoder bun_error
-}
-
-assert_bun
-assert_make
-build_node_fallbacks
-build_old_js

.buildkite/scripts/build-zig.sh

@@ -1,80 +0,0 @@
-#!/bin/bash
-
-set -eo pipefail
-source "$(dirname "$0")/env.sh"
-
-function assert_target() {
-  local arch="${2-$(uname -m)}"
-  case "$(echo "$arch" | tr '[:upper:]' '[:lower:]')" in
-    x64 | x86_64 | amd64)
-      export ZIG_ARCH="x86_64"
-      if [[ "$BUILDKITE_STEP_KEY" == *"baseline"* ]]; then
-        export ZIG_CPU_TARGET="nehalem"
-      else
-        export ZIG_CPU_TARGET="haswell"
-      fi
-      ;;
-    aarch64 | arm64)
-      export ZIG_ARCH="aarch64"
-      export ZIG_CPU_TARGET="native"
-      ;;
-    *)
-      echo "error: Unsupported architecture: $arch" 1>&2
-      exit 1
-      ;;
-  esac
-  local os="${1-$(uname -s)}"
-  case "$(echo "$os" | tr '[:upper:]' '[:lower:]')" in
-    linux)
-      export ZIG_TARGET="$ZIG_ARCH-linux-gnu" ;;
-    darwin)
-      export ZIG_TARGET="$ZIG_ARCH-macos-none" ;;
-    windows)
-      export ZIG_TARGET="$ZIG_ARCH-windows-msvc" ;;
-    *)
-      echo "error: Unsupported operating system: $os" 1>&2
-      exit 1
-      ;;
-  esac
-}
-
-function run_command() {
-  set -x
-  "$@"
-  { set +x; } 2>/dev/null
-}
-
-assert_target "$@"
-
-# Since the zig build depends on files from the zig submodule,
-# make sure to update the submodule before building.
-run_command git submodule update --init --recursive --progress --depth=1 --checkout src/deps/zig
-
-# TODO: Move these to be part of the CMake build
-source "$(dirname "$0")/build-old-js.sh"
-
-cwd="$(pwd)"
-mkdir -p build
-cd build
-
-run_command cmake .. "${CMAKE_FLAGS[@]}" \
-  -GNinja \
-  -DNO_CONFIGURE_DEPENDS="1" \
-  -DNO_CODEGEN="0" \
-  -DWEBKIT_DIR="omit" \
-  -DBUN_ZIG_OBJ_DIR="$cwd/build" \
-  -DZIG_LIB_DIR="$cwd/src/deps/zig/lib" \
-  -DCMAKE_BUILD_TYPE="$CMAKE_BUILD_TYPE" \
-  -DARCH="$ZIG_ARCH" \
-  -DCPU_TARGET="$ZIG_CPU_TARGET" \
-  -DZIG_TARGET="$ZIG_TARGET" \
-  -DUSE_LTO="$USE_LTO" \
-  -DUSE_DEBUG_JSC="$USE_DEBUG_JSC" \
-  -DCANARY="$CANARY" \
-  -DGIT_SHA="$GIT_SHA"
-
-export ONLY_ZIG="1"
-run_command ninja "$cwd/build/bun-zig.o" -v -j "$CPUS"
-
-cd ..
-source "$(dirname "$0")/upload-artifact.sh" "build/bun-zig.o"

.buildkite/scripts/download-artifact.ps1

@@ -1,47 +0,0 @@
-param (
-  [Parameter(Mandatory=$true)]
-  [string[]] $Paths,
-  [switch] $Split
-)
-
-$ErrorActionPreference = "Stop"
-
-function Assert-Buildkite-Agent() {
-  if (-not (Get-Command "buildkite-agent" -ErrorAction SilentlyContinue)) {
-    Write-Error "Cannot find buildkite-agent, please install it: https://buildkite.com/docs/agent/v3/install"
-    exit 1
-  }
-}
-
-function Assert-Join-File() {
-  if (-not (Get-Command "Join-File" -ErrorAction SilentlyContinue)) {
-    Write-Error "Cannot find Join-File, please install it: https://www.powershellgallery.com/packages/FileSplitter/1.3"
-    exit 1
-  }
-}
-
-function Download-Buildkite-Artifact() {
-  param (
-    [Parameter(Mandatory=$true)]
-    [string] $Path,
-  )
-  if ($Split) {
-    & buildkite-agent artifact download "$Path.*" --debug --debug-http
-    Join-File -Path "$(Resolve-Path .)\$Path" -Verbose -DeletePartFiles
-  } else {
-    & buildkite-agent artifact download "$Path" --debug --debug-http
-  }
-  if (-not (Test-Path $Path)) {
-    Write-Error "Could not find artifact: $Path"
-    exit 1
-  }
-}
-
-Assert-Buildkite-Agent
-if ($Split) {
-  Assert-Join-File
-}
-
-foreach ($Path in $Paths) {
-  Download-Buildkite-Artifact $Path
-}

.buildkite/scripts/download-artifact.sh

@@ -1,46 +0,0 @@
-#!/bin/bash
-
-set -eo pipefail
-
-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 download_buildkite_artifact() {
-  local path="$1"; shift
-  local split="0"
-  local args=()
-  while true; do
-    if [ -z "$1" ]; then
-      break
-    fi
-    case "$1" in
-      --split) split="1"; shift ;;
-      *) args+=("$1"); shift ;;
-    esac
-  done
-  if [ "$split" == "1" ]; then
-    run_command buildkite-agent artifact download "$path.*" . "${args[@]}"
-    run_command cat $path.?? > "$path"
-    run_command rm -f $path.??
-  else
-    run_command buildkite-agent artifact download "$path" . "${args[@]}"
-  fi
-  if [[ "$path" != *"*"* ]] && [ ! -f "$path" ]; then
-    echo "error: Could not find artifact: $path"
-    exit 1
-  fi
-}
-
-function run_command() {
-  set -x
-  "$@"
-  { set +x; } 2>/dev/null
-}
-
-assert_buildkite_agent
-download_buildkite_artifact "$@"

.buildkite/scripts/env.sh

@@ -1,118 +0,0 @@
-#!/bin/bash
-
-set -eo pipefail
-
-function assert_os() {
-  local os="$(uname -s)"
-  case "$os" in
-    Linux)
-      echo "linux" ;;
-    Darwin)
-      echo "darwin" ;;
-    *)
-      echo "error: Unsupported operating system: $os" 1>&2
-      exit 1
-      ;;
-  esac
-}
-
-function assert_arch() {
-  local arch="$(uname -m)"
-  case "$arch" in
-    aarch64 | arm64)
-      echo "aarch64" ;;
-    x86_64 | amd64)
-      echo "x64" ;;
-    *)
-      echo "error: Unknown architecture: $arch" 1>&2
-      exit 1
-      ;;
-  esac
-}
-
-function assert_build() {
-  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 [ -z "$BUILDKITE_STEP_KEY" ]; then
-    echo "error: Cannot find step key for this build"
-    exit 1
-  fi
-  if [ -n "$BUILDKITE_GROUP_KEY" ] && [[ "$BUILDKITE_STEP_KEY" != "$BUILDKITE_GROUP_KEY"* ]]; then
-    echo "error: Build step '$BUILDKITE_STEP_KEY' does not start with group key '$BUILDKITE_GROUP_KEY'"
-    exit 1
-  fi
-  # Skip os and arch checks for Zig, since it's cross-compiled on macOS
-  if [[ "$BUILDKITE_STEP_KEY" != *"zig"* ]]; then
-    local os="$(assert_os)"
-    if [[ "$BUILDKITE_STEP_KEY" != *"$os"* ]]; then
-      echo "error: Build step '$BUILDKITE_STEP_KEY' does not match operating system '$os'"
-      exit 1
-    fi
-    local arch="$(assert_arch)"
-    if [[ "$BUILDKITE_STEP_KEY" != *"$arch"* ]]; then
-      echo "error: Build step '$BUILDKITE_STEP_KEY' does not match architecture '$arch'"
-      exit 1
-    fi
-  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 export_environment() {
-  source "$(realpath $(dirname "$0")/../../scripts/env.sh)"
-  { set +x; } 2>/dev/null
-  export GIT_SHA="$BUILDKITE_COMMIT"
-  export CCACHE_DIR="$HOME/.cache/ccache/$BUILDKITE_STEP_KEY"
-  export SCCACHE_DIR="$HOME/.cache/sccache/$BUILDKITE_STEP_KEY"
-  export ZIG_LOCAL_CACHE_DIR="$HOME/.cache/zig-cache/$BUILDKITE_STEP_KEY"
-  export BUN_DEPS_CACHE_DIR="$HOME/.cache/bun-deps/$BUILDKITE_STEP_KEY"
-  if [ "$(assert_arch)" == "aarch64" ]; then
-    export CPU_TARGET="native"
-  elif [[ "$BUILDKITE_STEP_KEY" == *"baseline"* ]]; then
-    export CPU_TARGET="nehalem"
-  else
-    export CPU_TARGET="haswell"
-  fi
-  if [[ "$BUILDKITE_STEP_KEY" == *"nolto"* ]]; then
-    export USE_LTO="OFF"
-  else
-    export USE_LTO="ON"
-  fi
-  if $(buildkite-agent meta-data exists release &> /dev/null); then
-    export CMAKE_BUILD_TYPE="$(buildkite-agent meta-data get release)"
-  else
-    export CMAKE_BUILD_TYPE="Release"
-  fi
-  if $(buildkite-agent meta-data exists canary &> /dev/null); then
-    export CANARY="$(buildkite-agent meta-data get canary)"
-  else
-    export CANARY="1"
-  fi
-  if $(buildkite-agent meta-data exists assertions &> /dev/null); then
-    export USE_DEBUG_JSC="$(buildkite-agent meta-data get assertions)"
-  else
-    export USE_DEBUG_JSC="OFF"
-  fi
-  if [ "$BUILDKITE_CLEAN_CHECKOUT" == "true" ]; then
-    rm -rf "$CCACHE_DIR"
-    rm -rf "$SCCACHE_DIR"
-    rm -rf "$ZIG_LOCAL_CACHE_DIR"
-    rm -rf "$BUN_DEPS_CACHE_DIR"
-  fi
-}
-
-assert_build
-assert_buildkite_agent
-export_environment

.buildkite/scripts/prepare-build.sh

@@ -1,97 +0,0 @@
-#!/bin/bash
-
-set -eo pipefail
-
-function assert_build() {
-  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
-}
-
-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_jq() {
-  assert_command "jq" "jq" "https://stedolan.github.io/jq/"
-}
-
-function assert_curl() {
-  assert_command "curl" "curl" "https://curl.se/download.html"
-}
-
-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 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_release() {
-  if [ "$RELEASE" == "1" ]; then
-    run_command buildkite-agent meta-data set canary "0"
-  fi
-}
-
-function assert_canary() {
-  local canary="$(buildkite-agent meta-data get canary 2>/dev/null)"
-  if [ -z "$canary" ]; then
-    local repo=$(echo "$BUILDKITE_REPO" | sed -E 's#https://github.com/([^/]+)/([^/]+).git#\1/\2#g')
-    local tag="$(curl -sL "https://api.github.com/repos/$repo/releases/latest" | jq -r ".tag_name")"
-    if [ "$tag" == "null" ]; then
-      canary="1"
-    else
-      local revision=$(curl -sL "https://api.github.com/repos/$repo/compare/$tag...$BUILDKITE_COMMIT" | jq -r ".ahead_by")
-      if [ "$revision" == "null" ]; then
-        canary="1"
-      else
-        canary="$revision"
-      fi
-    fi
-    run_command buildkite-agent meta-data set canary "$canary"
-  fi
-}
-
-function upload_buildkite_pipeline() {
-  local path="$1"
-  if [ ! -f "$path" ]; then
-    echo "error: Cannot find pipeline: $path"
-    exit 1
-  fi
-  run_command buildkite-agent pipeline upload "$path"
-}
-
-function run_command() {
-  set -x
-  "$@"
-  { set +x; } 2>/dev/null
-}
-
-assert_build
-assert_buildkite_agent
-assert_jq
-assert_curl
-assert_release
-assert_canary
-upload_buildkite_pipeline ".buildkite/ci.yml"

.buildkite/scripts/upload-artifact.ps1

@@ -1,47 +0,0 @@
-param (
-  [Parameter(Mandatory=$true)]
-  [string[]] $Paths,
-  [switch] $Split
-)
-
-$ErrorActionPreference = "Stop"
-
-function Assert-Buildkite-Agent() {
-  if (-not (Get-Command "buildkite-agent" -ErrorAction SilentlyContinue)) {
-    Write-Error "Cannot find buildkite-agent, please install it: https://buildkite.com/docs/agent/v3/install"
-    exit 1
-  }
-}
-
-function Assert-Split-File() {
-  if (-not (Get-Command "Split-File" -ErrorAction SilentlyContinue)) {
-    Write-Error "Cannot find Split-File, please install it: https://www.powershellgallery.com/packages/FileSplitter/1.3"
-    exit 1
-  }
-}
-
-function Upload-Buildkite-Artifact() {
-  param (
-    [Parameter(Mandatory=$true)]
-    [string] $Path,
-  )
-  if (-not (Test-Path $Path)) {
-    Write-Error "Could not find artifact: $Path"
-    exit 1
-  }
-  if ($Split) {
-    Remove-Item -Path "$Path.*" -Force
-    Split-File -Path (Resolve-Path $Path) -PartSizeBytes "50MB" -Verbose
-    $Path = "$Path.*"
-  }
-  & buildkite-agent artifact upload "$Path" --debug --debug-http
-}
-
-Assert-Buildkite-Agent
-if ($Split) {
-  Assert-Split-File
-}
-
-foreach ($Path in $Paths) {
-  Upload-Buildkite-Artifact $Path
-}

.buildkite/scripts/upload-artifact.sh

@@ -1,54 +0,0 @@
-#!/bin/bash
-
-set -eo pipefail
-
-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_split() {
-  if ! command -v split &> /dev/null; then
-    echo "error: Cannot find split, please install it:"
-    echo "https://www.gnu.org/software/coreutils/split"
-    exit 1
-  fi
-}
-
-function upload_buildkite_artifact() {
-  local path="$1"; shift
-  local split="0"
-  local args=()
-  while true; do
-    if [ -z "$1" ]; then
-      break
-    fi
-    case "$1" in
-      --split) split="1"; shift ;;
-      *) args+=("$1"); shift ;;
-    esac
-  done
-  if [ ! -f "$path" ]; then
-    echo "error: Could not find artifact: $path"
-    exit 1
-  fi
-  if [ "$split" == "1" ]; then
-    run_command rm -f "$path."*
-    run_command split -b 50MB -d "$path" "$path."
-    run_command buildkite-agent artifact upload "$path.*" "${args[@]}"
-  else
-    run_command buildkite-agent artifact upload "$path" "${args[@]}"
-  fi
-}
-
-function run_command() {
-  set -x
-  "$@"
-  { set +x; } 2>/dev/null
-}
-
-assert_buildkite_agent
-upload_buildkite_artifact "$@"

.buildkite/scripts/upload-release.sh

@@ -3,15 +3,7 @@
 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
+  if [[ "$BUILDKITE_PULL_REQUEST_REPO" && "$BUILDKITE_REPO" != "$BUILDKITE_PULL_REQUEST_REPO" ]]; then
     echo "error: Cannot upload release from a fork"
     exit 1
   fi
@@ -33,158 +25,70 @@ function assert_buildkite_agent() {
   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 AWS_BUCKET; do
-    assert_buildkite_secret "$secret"
-  done
-}
-
-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..."
+function assert_gh() {
+  if ! command -v gh &> /dev/null; then
+    echo "warning: gh is not installed, installing..."
     if command -v brew &> /dev/null; then
-      HOMEBREW_NO_AUTO_UPDATE=1 run_command brew install "$package"
+      brew install gh
     else
-      echo "error: Cannot install $command, please install it"
-      if [ -n "$help_url" ]; then
-        echo ""
-        echo "hint: See $help_url for help"
-      fi
+      echo "error: Cannot install gh, please install it:"
+      echo "https://github.com/cli/cli#installation"
       exit 1
     fi
   fi
 }
 
-function assert_buildkite_secret() {
-  local key="$1"
-  local value=$(buildkite-agent secret get "$key")
-  if [ -z "$value" ]; then
-    echo "error: Cannot find $key secret"
+function assert_gh_token() {
+  local token=$(buildkite-agent secret get GITHUB_TOKEN)
+  if [ -z "$token" ]; then
+    echo "error: Cannot find GITHUB_TOKEN secret"
     echo ""
-    echo "hint: Create a secret named $key with a value:"
+    echo "hint: Create a secret named GITHUB_TOKEN with a GitHub access token:"
     echo "https://buildkite.com/docs/pipelines/buildkite-secrets"
     exit 1
   fi
-  export "$key"="$value"
+  export GH_TOKEN="$token"
 }
 
-function release_tag() {
-  local version="$1"
-  if [ "$version" == "canary" ]; then
-    echo "canary"
-  else
-    echo "bun-v$version"
+function download_artifact() {
+  local name=$1
+  buildkite-agent artifact download "$name" .
+  if [ ! -f "$name" ]; then
+    echo "error: Cannot find Buildkite artifact: $name"
+    exit 1
   fi
 }
 
-function 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 upload_assets() {
+  local tag=$1
+  local files=${@:2}
+  gh release upload "$tag" $files --clobber --repo "$BUILDKITE_REPO"
 }
 
-function download_buildkite_artifacts() {
-  local dir="$1"
-  local names="${@:2}"
-  for name in "${names[@]}"; do
-    run_command buildkite-agent artifact download "$name" "$dir"
-    if [ ! -f "$dir/$name" ]; then
-      echo "error: Cannot find Buildkite artifact: $name"
-      exit 1
-    fi
-  done
-}
+assert_main
+assert_buildkite_agent
+assert_gh
+assert_gh_token
 
-function upload_github_assets() {
-  local version="$1"
-  local tag="$(release_tag "$version")"
-  local files="${@:2}"
-  for file in "${files[@]}"; do
-    run_command gh release upload "$tag" "$file" --clobber --repo "$BUILDKITE_REPO"
-  done
-  if [ "$version" == "canary" ]; then
-    run_command gh release edit "$tag" --repo "$BUILDKITE_REPO" \
-      --notes "This canary release of Bun corresponds to the commit: $BUILDKITE_COMMIT"
-  fi
-}
+declare artifacts=(
+  bun-darwin-aarch64.zip
+  bun-darwin-aarch64-profile.zip
+  bun-darwin-x64.zip
+  bun-darwin-x64-profile.zip
+  bun-linux-aarch64.zip
+  bun-linux-aarch64-profile.zip
+  bun-linux-x64.zip
+  bun-linux-x64-profile.zip
+  bun-linux-x64-baseline.zip
+  bun-linux-x64-baseline-profile.zip
+  bun-windows-x64.zip
+  bun-windows-x64-profile.zip
+  bun-windows-x64-baseline.zip
+  bun-windows-x64-baseline-profile.zip
+)
 
-function upload_s3_files() {
-  local folder="$1"
-  local files="${@:2}"
-  for file in "${files[@]}"; do
-    run_command aws --endpoint-url="$AWS_ENDPOINT" s3 cp "$file" "s3://$AWS_BUCKET/$folder/$file"
-  done
-}
+for artifact in "${artifacts[@]}"; do
+  download_artifact $artifact
+done
 
-function create_release() {
-  assert_main
-  assert_buildkite_agent
-  assert_github
-  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-windows-x64.zip
-    bun-windows-x64-profile.zip
-    bun-windows-x64-baseline.zip
-    bun-windows-x64-baseline-profile.zip
-  )
-
-  download_buildkite_artifacts "." "${artifacts[@]}"
-  upload_s3_files "releases/$BUILDKITE_COMMIT" "${artifacts[@]}"
-  upload_s3_files "releases/$tag" "${artifacts[@]}"
-  upload_github_assets "$tag" "${artifacts[@]}"
-  create_sentry_release "$tag"
-}
-
-function assert_canary() {
-  local canary="$(buildkite-agent meta-data get canary 2>/dev/null)"
-  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"
+upload_assets "canary" "${artifacts[@]}"

.github/workflows/build-darwin.yml

@@ -0,0 +1,286 @@
+name: Build Darwin
+
+permissions:
+  contents: read
+  actions: write
+
+on:
+  workflow_call:
+    inputs:
+      runs-on:
+        type: string
+        default: macos-13-large
+      tag:
+        type: string
+        required: true
+      arch:
+        type: string
+        required: true
+      cpu:
+        type: string
+        required: true
+      assertions:
+        type: boolean
+      canary:
+        type: boolean
+      no-cache:
+        type: boolean
+
+env:
+  LLVM_VERSION: 18
+  BUN_VERSION: 1.1.8
+  LC_CTYPE: "en_US.UTF-8"
+  LC_ALL: "en_US.UTF-8"
+  # LTO is disabled because we cannot use lld on macOS currently
+  BUN_ENABLE_LTO: "0"
+
+jobs:
+  build-submodules:
+    name: Build Submodules
+    runs-on: ${{ inputs.runs-on }}
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          sparse-checkout: |
+            .gitmodules
+            src/deps
+            scripts
+      - name: Hash Submodules
+        id: hash
+        run: |
+          print_versions() {
+            git submodule | grep -v WebKit
+            echo "LLVM_VERSION=${{ env.LLVM_VERSION }}"
+            cat $(echo scripts/build*.sh scripts/all-dependencies.sh | tr " " "\n" | sort)
+          }
+          echo "hash=$(print_versions | shasum)" >> $GITHUB_OUTPUT
+      - name: Install Dependencies
+        env:
+          HOMEBREW_NO_INSTALLED_DEPENDENTS_CHECK: 1
+          HOMEBREW_NO_AUTO_UPDATE: 1
+          HOMEBREW_NO_INSTALL_CLEANUP: 1
+        run: |
+          brew install \
+            llvm@${{ env.LLVM_VERSION }} \
+            ccache \
+            rust \
+            pkg-config \
+            coreutils \
+            libtool \
+            cmake \
+            libiconv \
+            automake \
+            openssl@1.1 \
+            ninja \
+            golang \
+            gnu-sed --force --overwrite
+          echo "$(brew --prefix ccache)/bin" >> $GITHUB_PATH
+          echo "$(brew --prefix coreutils)/libexec/gnubin" >> $GITHUB_PATH
+          echo "$(brew --prefix llvm@$LLVM_VERSION)/bin" >> $GITHUB_PATH
+          brew link --overwrite llvm@$LLVM_VERSION
+      - name: Clone Submodules
+        run: |
+          ./scripts/update-submodules.sh
+      - name: Build Submodules
+        env:
+          CPU_TARGET: ${{ inputs.cpu }}
+          BUN_DEPS_OUT_DIR: ${{ runner.temp }}/bun-deps
+        run: |
+          mkdir -p $BUN_DEPS_OUT_DIR
+          ./scripts/all-dependencies.sh
+      - name: Upload bun-${{ inputs.tag }}-deps
+        uses: actions/upload-artifact@v4
+        with:
+          name: bun-${{ inputs.tag }}-deps
+          path: ${{ runner.temp }}/bun-deps
+          if-no-files-found: error
+  build-cpp:
+    name: Build C++
+    runs-on: ${{ inputs.runs-on }}
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          submodules: recursive
+      # TODO: Figure out how to cache homebrew dependencies
+      - name: Install Dependencies
+        env:
+          HOMEBREW_NO_INSTALLED_DEPENDENTS_CHECK: 1
+          HOMEBREW_NO_AUTO_UPDATE: 1
+          HOMEBREW_NO_INSTALL_CLEANUP: 1
+        run: |
+          brew install \
+            llvm@${{ env.LLVM_VERSION }} \
+            ccache \
+            rust \
+            pkg-config \
+            coreutils \
+            libtool \
+            cmake \
+            libiconv \
+            automake \
+            openssl@1.1 \
+            ninja \
+            golang \
+            gnu-sed --force --overwrite
+          echo "$(brew --prefix ccache)/bin" >> $GITHUB_PATH
+          echo "$(brew --prefix coreutils)/libexec/gnubin" >> $GITHUB_PATH
+          echo "$(brew --prefix llvm@$LLVM_VERSION)/bin" >> $GITHUB_PATH
+          brew link --overwrite llvm@$LLVM_VERSION
+      - name: Setup Bun
+        uses: ./.github/actions/setup-bun
+        with:
+          bun-version: ${{ env.BUN_VERSION }}
+      - name: Compile
+        env:
+          CPU_TARGET: ${{ inputs.cpu }}
+          SOURCE_DIR: ${{ github.workspace }}
+          OBJ_DIR: ${{ runner.temp }}/bun-cpp-obj
+          BUN_DEPS_OUT_DIR: ${{ runner.temp }}/bun-deps
+          CCACHE_DIR: ${{ runner.temp }}/ccache
+        run: |
+          mkdir -p $OBJ_DIR
+          cd $OBJ_DIR
+          cmake -S $SOURCE_DIR -B $OBJ_DIR \
+            -G Ninja \
+            -DCMAKE_BUILD_TYPE=Release \
+            -DUSE_LTO=ON \
+            -DBUN_CPP_ONLY=1 \
+            -DNO_CONFIGURE_DEPENDS=1
+          chmod +x compile-cpp-only.sh
+          ./compile-cpp-only.sh -v
+      - name: Upload bun-${{ inputs.tag }}-cpp
+        uses: actions/upload-artifact@v4
+        with:
+          name: bun-${{ inputs.tag }}-cpp
+          path: ${{ runner.temp }}/bun-cpp-obj/bun-cpp-objects.a
+          if-no-files-found: error
+  build-zig:
+    name: Build Zig
+    uses: ./.github/workflows/build-zig.yml
+    with:
+      os: darwin
+      only-zig: true
+      tag: ${{ inputs.tag }}
+      arch: ${{ inputs.arch }}
+      cpu: ${{ inputs.cpu }}
+      assertions: ${{ inputs.assertions }}
+      canary: ${{ inputs.canary }}
+      no-cache: ${{ inputs.no-cache }}
+  link:
+    name: Link
+    runs-on: ${{ inputs.runs-on }}
+    needs:
+      - build-submodules
+      - build-cpp
+      - build-zig
+    steps:
+      - uses: actions/checkout@v4
+      # TODO: Figure out how to cache homebrew dependencies
+      - name: Install Dependencies
+        env:
+          HOMEBREW_NO_INSTALLED_DEPENDENTS_CHECK: 1
+          HOMEBREW_NO_AUTO_UPDATE: 1
+          HOMEBREW_NO_INSTALL_CLEANUP: 1
+        run: |
+          brew install \
+            llvm@${{ env.LLVM_VERSION }} \
+            ccache \
+            rust \
+            pkg-config \
+            coreutils \
+            libtool \
+            cmake \
+            libiconv \
+            automake \
+            openssl@1.1 \
+            ninja \
+            golang \
+            gnu-sed --force --overwrite
+          echo "$(brew --prefix ccache)/bin" >> $GITHUB_PATH
+          echo "$(brew --prefix coreutils)/libexec/gnubin" >> $GITHUB_PATH
+          echo "$(brew --prefix llvm@$LLVM_VERSION)/bin" >> $GITHUB_PATH
+          brew link --overwrite llvm@$LLVM_VERSION
+      - name: Setup Bun
+        uses: ./.github/actions/setup-bun
+        with:
+          bun-version: ${{ env.BUN_VERSION }}
+      - name: Download bun-${{ inputs.tag }}-deps
+        uses: actions/download-artifact@v4
+        with:
+          name: bun-${{ inputs.tag }}-deps
+          path: ${{ runner.temp }}/bun-deps
+      - name: Download bun-${{ inputs.tag }}-cpp
+        uses: actions/download-artifact@v4
+        with:
+          name: bun-${{ inputs.tag }}-cpp
+          path: ${{ runner.temp }}/bun-cpp-obj
+      - name: Download bun-${{ inputs.tag }}-zig
+        uses: actions/download-artifact@v4
+        with:
+          name: bun-${{ inputs.tag }}-zig
+          path: ${{ runner.temp }}/release
+      - name: Link
+        env:
+          CPU_TARGET: ${{ inputs.cpu }}
+        run: |
+          SRC_DIR=$PWD
+          mkdir ${{ runner.temp }}/link-build
+          cd ${{ runner.temp }}/link-build
+          cmake $SRC_DIR \
+            -G Ninja \
+            -DCMAKE_BUILD_TYPE=Release \
+            -DUSE_LTO=ON \
+            -DBUN_LINK_ONLY=1 \
+            -DBUN_ZIG_OBJ_DIR="${{ runner.temp }}/release" \
+            -DBUN_CPP_ARCHIVE="${{ runner.temp }}/bun-cpp-obj/bun-cpp-objects.a" \
+            -DBUN_DEPS_OUT_DIR="${{ runner.temp }}/bun-deps" \
+            -DNO_CONFIGURE_DEPENDS=1
+          ninja -v
+      - name: Prepare
+        run: |
+          cd ${{ runner.temp }}/link-build
+          chmod +x bun-profile bun
+          mkdir -p bun-${{ inputs.tag }}-profile/ bun-${{ inputs.tag }}/
+          mv bun-profile bun-${{ inputs.tag }}-profile/bun-profile
+          if [ -f bun-profile.dSYM || -d bun-profile.dSYM ]; then
+            mv bun-profile.dSYM bun-${{ inputs.tag }}-profile/bun-profile.dSYM
+          fi
+          if [ -f bun.dSYM || -d bun.dSYM ]; then
+            mv bun.dSYM bun-${{ inputs.tag }}-profile/bun-profile.dSYM
+          fi
+          mv bun bun-${{ inputs.tag }}/bun
+          zip -r bun-${{ inputs.tag }}-profile.zip bun-${{ inputs.tag }}-profile
+          zip -r bun-${{ inputs.tag }}.zip bun-${{ inputs.tag }}
+      - name: Upload bun-${{ inputs.tag }}
+        uses: actions/upload-artifact@v4
+        with:
+          name: bun-${{ inputs.tag }}
+          path: ${{ runner.temp }}/link-build/bun-${{ inputs.tag }}.zip
+          if-no-files-found: error
+      - name: Upload bun-${{ inputs.tag }}-profile
+        uses: actions/upload-artifact@v4
+        with:
+          name: bun-${{ inputs.tag }}-profile
+          path: ${{ runner.temp }}/link-build/bun-${{ inputs.tag }}-profile.zip
+          if-no-files-found: error
+  on-failure:
+    if: ${{ github.repository_owner == 'oven-sh' && failure() }}
+    name: On Failure
+    needs: link
+    runs-on: ubuntu-latest
+    steps:
+      - name: Send Message
+        uses: sarisia/actions-status-discord@v1
+        with:
+          webhook: ${{ secrets.DISCORD_WEBHOOK }}
+          nodetail: true
+          color: "#FF0000"
+          title: ""
+          description: |
+            ### ❌ [${{ github.event.pull_request.title }}](${{ github.event.pull_request.html_url }})
+
+            @${{ github.actor }}, the build for bun-${{ inputs.tag }} failed.
+
+            **[View logs](https://github.com/${{ github.repository }}/actions/runs/${{ github.run_id }})**

.github/workflows/build-linux.yml

@@ -0,0 +1,64 @@
+name: Build Linux
+
+permissions:
+  contents: read
+  actions: write
+
+on:
+  workflow_call:
+    inputs:
+      runs-on:
+        type: string
+        required: true
+      tag:
+        type: string
+        required: true
+      arch:
+        type: string
+        required: true
+      cpu:
+        type: string
+        required: true
+      assertions:
+        type: boolean
+      zig-optimize:
+        type: string
+      canary:
+        type: boolean
+      no-cache:
+        type: boolean
+
+jobs:
+  build:
+    name: Build Linux
+    uses: ./.github/workflows/build-zig.yml
+    with:
+      os: linux
+      only-zig: false
+      runs-on: ${{ inputs.runs-on }}
+      tag: ${{ inputs.tag }}
+      arch: ${{ inputs.arch }}
+      cpu: ${{ inputs.cpu }}
+      assertions: ${{ inputs.assertions }}
+      zig-optimize: ${{ inputs.zig-optimize }}
+      canary: ${{ inputs.canary }}
+      no-cache: ${{ inputs.no-cache }}
+  on-failure:
+    if: ${{ github.repository_owner == 'oven-sh' && failure() }}
+    name: On Failure
+    needs: build
+    runs-on: ubuntu-latest
+    steps:
+      - name: Send Message
+        uses: sarisia/actions-status-discord@v1
+        with:
+          webhook: ${{ secrets.DISCORD_WEBHOOK }}
+          nodetail: true
+          color: "#FF0000"
+          title: ""
+          description: |
+            ### ❌ [${{ github.event.pull_request.title }}](${{ github.event.pull_request.html_url }})
+
+            @${{ github.actor }}, the build for bun-${{ inputs.tag }} failed.
+
+            **[View logs](https://github.com/${{ github.repository }}/actions/runs/${{ github.run_id }})**

.github/workflows/build-windows.yml

@@ -0,0 +1,348 @@
+name: Build Windows
+
+permissions:
+  contents: read
+  actions: write
+
+on:
+  workflow_call:
+    inputs:
+      runs-on:
+        type: string
+        default: windows
+      tag:
+        type: string
+        required: true
+      arch:
+        type: string
+        required: true
+      cpu:
+        type: string
+        required: true
+      assertions:
+        type: boolean
+      canary:
+        type: boolean
+      no-cache:
+        type: boolean
+      bun-version:
+        type: string
+        default: 1.1.7
+
+env:
+  # Must specify exact version of LLVM for Windows
+  LLVM_VERSION: 18.1.8
+  BUN_VERSION: ${{ inputs.bun-version }}
+  BUN_GARBAGE_COLLECTOR_LEVEL: 1
+  BUN_FEATURE_FLAG_INTERNAL_FOR_TESTING: 1
+  CI: true
+  USE_LTO: 1
+
+jobs:
+  build-submodules:
+    name: Build Submodules
+    runs-on: ${{ inputs.runs-on }}
+    steps:
+      - name: Install Scoop
+        run: |
+          Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser
+          Invoke-RestMethod -Uri https://get.scoop.sh | Invoke-Expression
+          Join-Path (Resolve-Path ~).Path "scoop\shims" >> $Env:GITHUB_PATH
+      - name: Setup Git
+        run: |
+          git config --global core.autocrlf false
+          git config --global core.eol lf
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          sparse-checkout: |
+            .gitmodules
+            src/deps
+            scripts
+      - name: Hash Submodules
+        id: hash
+        run: |
+          $data = "$(& {
+            git submodule | Where-Object { $_ -notmatch 'WebKit' }
+            echo "LLVM_VERSION=${{ env.LLVM_VERSION }}"
+            Get-Content -Path (Get-ChildItem -Path 'scripts/build*.ps1', 'scripts/all-dependencies.ps1', 'scripts/env.ps1' | Sort-Object -Property Name).FullName | Out-String
+            echo 1
+          })"
+          $hash = ( -join ((New-Object -TypeName System.Security.Cryptography.SHA1CryptoServiceProvider).ComputeHash([System.Text.Encoding]::UTF8.GetBytes($data)) | ForEach-Object { $_.ToString("x2") } )).Substring(0, 10)
+          echo "hash=${hash}" >> $env:GITHUB_OUTPUT
+      - if: ${{ !inputs.no-cache }}
+        name: Restore Cache
+        id: cache
+        uses: actions/cache/restore@v4
+        with:
+          path: bun-deps
+          key: bun-${{ inputs.tag }}-deps-${{ steps.hash.outputs.hash }}
+      - if: ${{ inputs.no-cache || !steps.cache.outputs.cache-hit }}
+        name: Install LLVM and Ninja
+        run: |
+          scoop install ninja
+          scoop install llvm@${{ env.LLVM_VERSION }}
+          scoop install nasm@2.16.01
+      - if: ${{ inputs.no-cache || !steps.cache.outputs.cache-hit }}
+        name: Clone Submodules
+        run: |
+          .\scripts\update-submodules.ps1
+      - if: ${{ inputs.no-cache || !steps.cache.outputs.cache-hit }}
+        name: Build Dependencies
+        env:
+          CPU_TARGET: ${{ inputs.cpu }}
+          CCACHE_DIR: ccache
+          USE_LTO: 1
+        run: |
+          .\scripts\env.ps1 ${{ contains(inputs.tag, '-baseline') && '-Baseline' || '' }}
+          $env:BUN_DEPS_OUT_DIR = (mkdir -Force "./bun-deps")
+          .\scripts\all-dependencies.ps1
+      - name: Save Cache
+        if: ${{ inputs.no-cache || !steps.cache.outputs.cache-hit }}
+        uses: actions/cache/save@v4
+        with:
+          path: bun-deps
+          key: ${{ steps.cache.outputs.cache-primary-key }}
+      - name: Upload bun-${{ inputs.tag }}-deps
+        uses: actions/upload-artifact@v4
+        with:
+          name: bun-${{ inputs.tag }}-deps
+          path: bun-deps
+          if-no-files-found: error
+  codegen:
+    name: Codegen
+    runs-on: ubuntu-latest
+    steps:
+      - name: Setup Git
+        run: |
+          git config --global core.autocrlf false
+          git config --global core.eol lf
+      - name: Checkout
+        uses: actions/checkout@v4
+      - name: Setup Bun
+        uses: ./.github/actions/setup-bun
+        with:
+          bun-version: ${{ inputs.bun-version }}
+      - name: Codegen
+        run: |
+          ./scripts/cross-compile-codegen.sh win32 x64
+      - if: ${{ inputs.canary }}
+        name: Calculate Revision
+        run: |
+          echo "canary_revision=$(GITHUB_TOKEN="${{ github.token }}"
+          bash ./scripts/calculate-canary-revision.sh --raw)" > build-codegen-win32-x64/.canary_revision
+      - name: Upload bun-${{ inputs.tag }}-codegen
+        uses: actions/upload-artifact@v4
+        with:
+          name: bun-${{ inputs.tag }}-codegen
+          path: build-codegen-win32-x64
+          if-no-files-found: error
+  build-cpp:
+    name: Build C++
+    needs: codegen
+    runs-on: ${{ inputs.runs-on }}
+    steps:
+      - name: Install Scoop
+        run: |
+          Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser
+          Invoke-RestMethod -Uri https://get.scoop.sh | Invoke-Expression
+          Join-Path (Resolve-Path ~).Path "scoop\shims" >> $Env:GITHUB_PATH
+      - name: Setup Git
+        run: |
+          git config --global core.autocrlf false
+          git config --global core.eol lf
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          submodules: recursive
+      - name: Install LLVM and Ninja
+        run: |
+          scoop install ninja
+          scoop install llvm@${{ env.LLVM_VERSION }}
+      - name: Setup Bun
+        uses: ./.github/actions/setup-bun
+        with:
+          bun-version: ${{ inputs.bun-version }}
+      - if: ${{ !inputs.no-cache }}
+        name: Restore Cache
+        uses: actions/cache@v4
+        with:
+          path: ccache
+          key: bun-${{ inputs.tag }}-cpp-${{ hashFiles('Dockerfile', 'Makefile', 'CMakeLists.txt', 'build.zig', 'scripts/**', 'src/**', 'packages/bun-usockets/src/**', 'packages/bun-uws/src/**') }}
+          restore-keys: |
+            bun-${{ inputs.tag }}-cpp-
+      - name: Download bun-${{ inputs.tag }}-codegen
+        uses: actions/download-artifact@v4
+        with:
+          name: bun-${{ inputs.tag }}-codegen
+          path: build
+      - name: Compile
+        env:
+          CPU_TARGET: ${{ inputs.cpu }}
+          CCACHE_DIR: ccache
+          USE_LTO: 1
+        run: |
+          # $CANARY_REVISION = if (Test-Path build/.canary_revision) { Get-Content build/.canary_revision } else { "0" }
+          $CANARY_REVISION = 0
+          .\scripts\env.ps1 ${{ contains(inputs.tag, '-baseline') && '-Baseline' || '' }}
+          .\scripts\update-submodules.ps1
+          .\scripts\build-libuv.ps1 -CloneOnly $True
+          cd build
+          cmake .. -G Ninja -DCMAKE_BUILD_TYPE=Release `
+            -DNO_CODEGEN=1 `
+            -DUSE_LTO=1 `
+            -DNO_CONFIGURE_DEPENDS=1 `
+            "-DCANARY=${CANARY_REVISION}" `
+            -DBUN_CPP_ONLY=1 ${{ contains(inputs.tag, '-baseline') && '-DUSE_BASELINE_BUILD=1' || '' }}
+          if ($LASTEXITCODE -ne 0) { throw "CMake configuration failed" }
+          .\compile-cpp-only.ps1 -v
+          if ($LASTEXITCODE -ne 0) { throw "C++ compilation failed" }
+      - name: Upload bun-${{ inputs.tag }}-cpp
+        uses: actions/upload-artifact@v4
+        with:
+          name: bun-${{ inputs.tag }}-cpp
+          path: build/bun-cpp-objects.a
+          if-no-files-found: error
+  build-zig:
+    name: Build Zig
+    uses: ./.github/workflows/build-zig.yml
+    with:
+      os: windows
+      zig-optimize: ReleaseSafe
+      only-zig: true
+      tag: ${{ inputs.tag }}
+      arch: ${{ inputs.arch }}
+      cpu: ${{ inputs.cpu }}
+      assertions: ${{ inputs.assertions }}
+      canary: ${{ inputs.canary }}
+      no-cache: ${{ inputs.no-cache }}
+  link:
+    name: Link
+    runs-on: ${{ inputs.runs-on }}
+    needs:
+      - build-submodules
+      - build-cpp
+      - build-zig
+      - codegen
+    steps:
+      - name: Install Scoop
+        run: |
+          Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser
+          Invoke-RestMethod -Uri https://get.scoop.sh | Invoke-Expression
+          Join-Path (Resolve-Path ~).Path "scoop\shims" >> $Env:GITHUB_PATH
+      - name: Setup Git
+        run: |
+          git config --global core.autocrlf false
+          git config --global core.eol lf
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          submodules: recursive
+      - name: Install Ninja
+        run: |
+          scoop install ninja
+          scoop install llvm@${{ env.LLVM_VERSION }}
+      - name: Setup Bun
+        uses: ./.github/actions/setup-bun
+        with:
+          bun-version: ${{ inputs.bun-version }}
+      - name: Download bun-${{ inputs.tag }}-deps
+        uses: actions/download-artifact@v4
+        with:
+          name: bun-${{ inputs.tag }}-deps
+          path: bun-deps
+      - name: Download bun-${{ inputs.tag }}-cpp
+        uses: actions/download-artifact@v4
+        with:
+          name: bun-${{ inputs.tag }}-cpp
+          path: bun-cpp
+      - name: Download bun-${{ inputs.tag }}-zig
+        uses: actions/download-artifact@v4
+        with:
+          name: bun-${{ inputs.tag }}-zig
+          path: bun-zig
+      - name: Download bun-${{ inputs.tag }}-codegen
+        uses: actions/download-artifact@v4
+        with:
+          name: bun-${{ inputs.tag }}-codegen
+          path: build
+      - if: ${{ !inputs.no-cache }}
+        name: Restore Cache
+        uses: actions/cache@v4
+        with:
+          path: ccache
+          key: bun-${{ inputs.tag }}-cpp-${{ hashFiles('Dockerfile', 'Makefile', 'CMakeLists.txt', 'build.zig', 'scripts/**', 'src/**', 'packages/bun-usockets/src/**', 'packages/bun-uws/src/**') }}
+          restore-keys: |
+            bun-${{ inputs.tag }}-cpp-
+      - name: Link
+        env:
+          CPU_TARGET: ${{ inputs.cpu }}
+          CCACHE_DIR: ccache
+        run: |
+          .\scripts\update-submodules.ps1
+          .\scripts\env.ps1 ${{ contains(inputs.tag, '-baseline') && '-Baseline' || '' }}
+          Set-Location build
+          # $CANARY_REVISION = if (Test-Path build/.canary_revision) { Get-Content build/.canary_revision } else { "0" }
+          $CANARY_REVISION = 0
+          cmake .. -G Ninja -DCMAKE_BUILD_TYPE=Release `
+            -DNO_CODEGEN=1 `
+            -DNO_CONFIGURE_DEPENDS=1 `
+            "-DCANARY=${CANARY_REVISION}" `
+            -DBUN_LINK_ONLY=1 `
+            -DUSE_LTO=1 `
+            "-DBUN_DEPS_OUT_DIR=$(Resolve-Path ../bun-deps)" `
+            "-DBUN_CPP_ARCHIVE=$(Resolve-Path ../bun-cpp/bun-cpp-objects.a)" `
+            "-DBUN_ZIG_OBJ_DIR=$(Resolve-Path ../bun-zig)" `
+            ${{ contains(inputs.tag, '-baseline') && '-DUSE_BASELINE_BUILD=1' || '' }}
+          if ($LASTEXITCODE -ne 0) { throw "CMake configuration failed" }
+          ninja -v
+          if ($LASTEXITCODE -ne 0) { throw "Link failed!" }
+      - name: Prepare
+        run: |
+          $Dist = mkdir -Force "bun-${{ inputs.tag }}"
+          cp -r build\bun.exe "$Dist\bun.exe"
+          Compress-Archive -Force "$Dist" "${Dist}.zip"
+          $Dist = "$Dist-profile"
+          MkDir -Force "$Dist"
+          cp -r build\bun.exe "$Dist\bun.exe"
+          cp -r build\bun.pdb "$Dist\bun.pdb"
+          Compress-Archive -Force "$Dist" "$Dist.zip"
+          .\build\bun.exe --print "JSON.stringify(require('bun:internal-for-testing').crash_handler.getFeatureData())" > .\features.json
+      - name: Upload bun-${{ inputs.tag }}
+        uses: actions/upload-artifact@v4
+        with:
+          name: bun-${{ inputs.tag }}
+          path: bun-${{ inputs.tag }}.zip
+          if-no-files-found: error
+      - name: Upload bun-${{ inputs.tag }}-profile
+        uses: actions/upload-artifact@v4
+        with:
+          name: bun-${{ inputs.tag }}-profile
+          path: bun-${{ inputs.tag }}-profile.zip
+          if-no-files-found: error
+      - name: Upload bun-feature-data
+        uses: actions/upload-artifact@v4
+        with:
+          name: bun-feature-data
+          path: features.json
+          if-no-files-found: error
+          overwrite: true
+  on-failure:
+    if: ${{ github.repository_owner == 'oven-sh' && failure() }}
+    name: On Failure
+    needs: link
+    runs-on: ubuntu-latest
+    steps:
+      - name: Send Message
+        uses: sarisia/actions-status-discord@v1
+        with:
+          webhook: ${{ secrets.DISCORD_WEBHOOK }}
+          nodetail: true
+          color: "#FF0000"
+          title: ""
+          description: |
+            ### ❌ [${{ github.event.pull_request.title }}](${{ github.event.pull_request.html_url }})
+
+            @${{ github.actor }}, the build for bun-${{ inputs.tag }} failed.
+
+            **[View logs](https://github.com/${{ github.repository }}/actions/runs/${{ github.run_id }})**

.github/workflows/build-zig.yml

@@ -0,0 +1,122 @@
+name: Build Zig
+
+permissions:
+  contents: read
+  actions: write
+
+on:
+  workflow_call:
+    inputs:
+      runs-on:
+        type: string
+        default: ${{ github.repository_owner != 'oven-sh' && 'ubuntu-latest' || inputs.only-zig && 'namespace-profile-bun-ci-linux-x64' || inputs.arch == 'x64' && 'namespace-profile-bun-ci-linux-x64' || 'namespace-profile-bun-ci-linux-aarch64' }}
+      tag:
+        type: string
+        required: true
+      os:
+        type: string
+        required: true
+      arch:
+        type: string
+        required: true
+      cpu:
+        type: string
+        required: true
+      assertions:
+        type: boolean
+        default: false
+      zig-optimize:
+        type: string # 'ReleaseSafe' or 'ReleaseFast'
+        default: ReleaseFast
+      canary:
+        type: boolean
+        default: ${{ github.ref == 'refs/heads/main' }}
+      only-zig:
+        type: boolean
+        default: true
+      no-cache:
+        type: boolean
+        default: false
+
+jobs:
+  build-zig:
+    name: ${{ inputs.only-zig && 'Build Zig' || 'Build & Link' }}
+    runs-on: ${{ inputs.runs-on }}
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+      - name: Calculate Cache Key
+        id: cache
+        run: |
+          echo "key=${{ hashFiles('Dockerfile', 'Makefile', 'CMakeLists.txt', 'build.zig', 'scripts/**', 'src/**', 'packages/bun-usockets/src/**', 'packages/bun-uws/src/**') }}-canary-${{inputs.canary}}" >> $GITHUB_OUTPUT
+      - if: ${{ !inputs.no-cache }}
+        name: Restore Cache
+        uses: actions/cache@v4
+        with:
+          key: bun-${{ inputs.tag }}-docker-${{ steps.cache.outputs.key }}
+          restore-keys: |
+            bun-${{ inputs.tag }}-docker-
+          path: |
+            ${{ runner.temp }}/dockercache
+      - name: Setup Docker
+        uses: docker/setup-buildx-action@v3
+        with:
+          install: true
+          platforms: |
+            linux/${{ runner.arch == 'X64' && 'amd64' || 'arm64' }}
+      - name: Build
+        uses: docker/build-push-action@v5
+        with:
+          push: false
+          target: ${{ inputs.only-zig && 'build_release_obj' || 'artifact' }}
+          cache-from: |
+            type=local,src=${{ runner.temp }}/dockercache
+          cache-to: |
+            type=local,dest=${{ runner.temp }}/dockercache,mode=max
+          outputs: |
+            type=local,dest=${{ runner.temp }}/release
+          platforms: |
+            linux/${{ runner.arch == 'X64' && 'amd64' || 'arm64' }}
+          build-args: |
+            GIT_SHA=${{ github.event.workflow_run.head_sha || github.sha }}
+            TRIPLET=${{ inputs.os == 'darwin' && format('{0}-macos-none', inputs.arch == 'x64' && 'x86_64' || 'aarch64') || inputs.os == 'windows' && format('{0}-windows-msvc', inputs.arch == 'x64' && 'x86_64' || 'aarch64') || format('{0}-linux-gnu', inputs.arch == 'x64' && 'x86_64' || 'aarch64') }}
+            ARCH=${{ inputs.arch == 'x64' && 'x86_64' || 'aarch64' }}
+            BUILDARCH=${{ inputs.arch == 'x64' && 'amd64' || 'arm64' }}
+            BUILD_MACHINE_ARCH=${{ inputs.arch == 'x64' && 'x86_64' || 'aarch64' }}
+            CPU_TARGET=${{ inputs.arch == 'x64' && inputs.cpu || 'native' }}
+            ASSERTIONS=${{ inputs.assertions && 'ON' || 'OFF' }}
+            ZIG_OPTIMIZE=${{ inputs.zig-optimize }}
+            CANARY=${{ inputs.canary && '1' || '0' }}
+      - if: ${{ inputs.only-zig }}
+        name: Upload bun-${{ inputs.tag }}-zig
+        uses: actions/upload-artifact@v4
+        with:
+          name: bun-${{ inputs.tag }}-zig
+          path: ${{ runner.temp }}/release/bun-zig.o
+          if-no-files-found: error
+      - if: ${{ !inputs.only-zig }}
+        name: Prepare
+        run: |
+          cd ${{ runner.temp }}/release
+          chmod +x bun-profile bun
+          mkdir bun-${{ inputs.tag }}-profile
+          mkdir bun-${{ inputs.tag }}
+          strip bun
+          mv bun-profile bun-${{ inputs.tag }}-profile/bun-profile
+          mv bun bun-${{ inputs.tag }}/bun
+          zip -r bun-${{ inputs.tag }}-profile.zip bun-${{ inputs.tag }}-profile
+          zip -r bun-${{ inputs.tag }}.zip bun-${{ inputs.tag }}
+      - if: ${{ !inputs.only-zig }}
+        name: Upload bun-${{ inputs.tag }}
+        uses: actions/upload-artifact@v4
+        with:
+          name: bun-${{ inputs.tag }}
+          path: ${{ runner.temp }}/release/bun-${{ inputs.tag }}.zip
+          if-no-files-found: error
+      - if: ${{ !inputs.only-zig }}
+        name: Upload bun-${{ inputs.tag }}-profile
+        uses: actions/upload-artifact@v4
+        with:
+          name: bun-${{ inputs.tag }}-profile
+          path: ${{ runner.temp }}/release/bun-${{ inputs.tag }}-profile.zip
+          if-no-files-found: error

.github/workflows/ci.yml

@@ -0,0 +1,245 @@
+name: CI
+
+permissions:
+  contents: read
+  actions: write
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.event_name == 'workflow_dispatch' && inputs.run-id  || github.ref }}
+  cancel-in-progress: true
+
+on:
+  workflow_dispatch:
+    inputs:
+      run-id:
+        type: string
+        description: The workflow ID to download artifacts (skips the build step)
+  pull_request:
+    paths-ignore:
+      - .vscode/**/*
+      - docs/**/*
+      - examples/**/*
+  push:
+    branches:
+      - main
+    paths-ignore:
+      - .vscode/**/*
+      - docs/**/*
+      - examples/**/*
+
+jobs:
+  format:
+    if: ${{ !inputs.run-id }}
+    name: Format
+    uses: ./.github/workflows/run-format.yml
+    secrets: inherit
+    with:
+      zig-version: 0.13.0
+    permissions:
+      contents: write
+  lint:
+    if: ${{ !inputs.run-id }}
+    name: Lint
+    uses: ./.github/workflows/run-lint.yml
+    secrets: inherit
+  linux-x64:
+    if: ${{ !inputs.run-id }}
+    name: Build linux-x64
+    uses: ./.github/workflows/build-linux.yml
+    secrets: inherit
+    with:
+      runs-on: ${{ github.repository_owner == 'oven-sh' && 'namespace-profile-bun-ci-linux-x64' || 'ubuntu-latest' }}
+      tag: linux-x64
+      arch: x64
+      cpu: haswell
+      canary: true
+      no-cache: true
+  linux-x64-baseline:
+    if: ${{ !inputs.run-id }}
+    name: Build linux-x64-baseline
+    uses: ./.github/workflows/build-linux.yml
+    secrets: inherit
+    with:
+      runs-on: ${{ github.repository_owner == 'oven-sh' && 'namespace-profile-bun-ci-linux-x64' || 'ubuntu-latest' }}
+      tag: linux-x64-baseline
+      arch: x64
+      cpu: nehalem
+      canary: true
+      no-cache: true
+  linux-aarch64:
+    if: ${{ !inputs.run-id && github.repository_owner == 'oven-sh' }}
+    name: Build linux-aarch64
+    uses: ./.github/workflows/build-linux.yml
+    secrets: inherit
+    with:
+      runs-on: namespace-profile-bun-ci-linux-aarch64
+      tag: linux-aarch64
+      arch: aarch64
+      cpu: native
+      canary: true
+      no-cache: true
+  darwin-x64:
+    if: ${{ !inputs.run-id }}
+    name: Build darwin-x64
+    uses: ./.github/workflows/build-darwin.yml
+    secrets: inherit
+    with:
+      runs-on: ${{ github.repository_owner == 'oven-sh' && 'macos-13-large' || 'macos-13' }}
+      tag: darwin-x64
+      arch: x64
+      cpu: haswell
+      canary: true
+  darwin-x64-baseline:
+    if: ${{ !inputs.run-id }}
+    name: Build darwin-x64-baseline
+    uses: ./.github/workflows/build-darwin.yml
+    secrets: inherit
+    with:
+      runs-on: ${{ github.repository_owner == 'oven-sh' && 'macos-13-large' || 'macos-13' }}
+      tag: darwin-x64-baseline
+      arch: x64
+      cpu: nehalem
+      canary: true
+  darwin-aarch64:
+    if: ${{ !inputs.run-id }}
+    name: Build darwin-aarch64
+    uses: ./.github/workflows/build-darwin.yml
+    secrets: inherit
+    with:
+      runs-on: ${{ github.repository_owner == 'oven-sh' && 'namespace-profile-bun-ci-darwin-aarch64' || 'macos-13' }}
+      tag: darwin-aarch64
+      arch: aarch64
+      cpu: native
+      canary: true
+  windows-x64:
+    if: ${{ !inputs.run-id }}
+    name: Build windows-x64
+    uses: ./.github/workflows/build-windows.yml
+    secrets: inherit
+    with:
+      runs-on: windows
+      tag: windows-x64
+      arch: x64
+      cpu: haswell
+      canary: true
+  windows-x64-baseline:
+    if: ${{ !inputs.run-id }}
+    name: Build windows-x64-baseline
+    uses: ./.github/workflows/build-windows.yml
+    secrets: inherit
+    with:
+      runs-on: windows
+      tag: windows-x64-baseline
+      arch: x64
+      cpu: nehalem
+      canary: true
+  linux-x64-test:
+    if: ${{ inputs.run-id || github.event_name == 'pull_request' }}
+    name: Test linux-x64
+    needs: linux-x64
+    uses: ./.github/workflows/run-test.yml
+    secrets: inherit
+    with:
+      run-id: ${{ inputs.run-id }}
+      pr-number: ${{ github.event.number }}
+      runs-on: ${{ github.repository_owner == 'oven-sh' && 'namespace-profile-bun-ci-linux-x64' || 'ubuntu-latest' }}
+      tag: linux-x64
+  linux-x64-baseline-test:
+    if: ${{ inputs.run-id || github.event_name == 'pull_request' }}
+    name: Test linux-x64-baseline
+    needs: linux-x64-baseline
+    uses: ./.github/workflows/run-test.yml
+    secrets: inherit
+    with:
+      run-id: ${{ inputs.run-id }}
+      pr-number: ${{ github.event.number }}
+      runs-on: ${{ github.repository_owner == 'oven-sh' && 'namespace-profile-bun-ci-linux-x64' || 'ubuntu-latest' }}
+      tag: linux-x64-baseline
+  linux-aarch64-test:
+    if: ${{ inputs.run-id || github.event_name == 'pull_request' && github.repository_owner == 'oven-sh'}}
+    name: Test linux-aarch64
+    needs: linux-aarch64
+    uses: ./.github/workflows/run-test.yml
+    secrets: inherit
+    with:
+      run-id: ${{ inputs.run-id }}
+      pr-number: ${{ github.event.number }}
+      runs-on: namespace-profile-bun-ci-linux-aarch64
+      tag: linux-aarch64
+  darwin-x64-test:
+    if: ${{ inputs.run-id || github.event_name == 'pull_request' }}
+    name: Test darwin-x64
+    needs: darwin-x64
+    uses: ./.github/workflows/run-test.yml
+    secrets: inherit
+    with:
+      run-id: ${{ inputs.run-id }}
+      pr-number: ${{ github.event.number }}
+      runs-on: ${{ github.repository_owner == 'oven-sh' && 'macos-13-large' || 'macos-13' }}
+      tag: darwin-x64
+  darwin-x64-baseline-test:
+    if: ${{ inputs.run-id || github.event_name == 'pull_request' }}
+    name: Test darwin-x64-baseline
+    needs: darwin-x64-baseline
+    uses: ./.github/workflows/run-test.yml
+    secrets: inherit
+    with:
+      run-id: ${{ inputs.run-id }}
+      pr-number: ${{ github.event.number }}
+      runs-on: ${{ github.repository_owner == 'oven-sh' && 'macos-13-large' || 'macos-13' }}
+      tag: darwin-x64-baseline
+  darwin-aarch64-test:
+    if: ${{ inputs.run-id || github.event_name == 'pull_request' }}
+    name: Test darwin-aarch64
+    needs: darwin-aarch64
+    uses: ./.github/workflows/run-test.yml
+    secrets: inherit
+    with:
+      run-id: ${{ inputs.run-id }}
+      pr-number: ${{ github.event.number }}
+      runs-on: ${{ github.repository_owner == 'oven-sh' && 'namespace-profile-bun-ci-darwin-aarch64' || 'macos-13' }}
+      tag: darwin-aarch64
+  windows-x64-test:
+    if: ${{ inputs.run-id || github.event_name == 'pull_request' }}
+    name: Test windows-x64
+    needs: windows-x64
+    uses: ./.github/workflows/run-test.yml
+    secrets: inherit
+    with:
+      run-id: ${{ inputs.run-id }}
+      pr-number: ${{ github.event.number }}
+      runs-on: windows
+      tag: windows-x64
+  windows-x64-baseline-test:
+    if: ${{ inputs.run-id || github.event_name == 'pull_request' }}
+    name: Test windows-x64-baseline
+    needs: windows-x64-baseline
+    uses: ./.github/workflows/run-test.yml
+    secrets: inherit
+    with:
+      run-id: ${{ inputs.run-id }}
+      pr-number: ${{ github.event.number }}
+      runs-on: windows
+      tag: windows-x64-baseline
+  cleanup:
+    if: ${{ always() }}
+    name: Cleanup
+    needs:
+      - linux-x64
+      - linux-x64-baseline
+      - linux-aarch64
+      - darwin-x64
+      - darwin-x64-baseline
+      - darwin-aarch64
+      - windows-x64
+      - windows-x64-baseline
+    runs-on: ubuntu-latest
+    steps:
+      - name: Cleanup Artifacts
+        uses: geekyeggo/delete-artifact@v5
+        with:
+          name: |
+            bun-*-cpp
+            bun-*-zig
+            bun-*-deps
+            bun-*-codegen

.github/workflows/comment.yml

@@ -0,0 +1,55 @@
+name: Comment
+
+permissions:
+  actions: read
+  pull-requests: write
+
+on:
+  workflow_run:
+    workflows:
+      - CI
+    types:
+      - completed
+
+jobs:
+  comment:
+    if: ${{ github.repository_owner == 'oven-sh' }}
+    name: Comment
+    runs-on: ubuntu-latest
+    steps:
+      - name: Download Tests
+        uses: actions/download-artifact@v4
+        with:
+          path: bun
+          pattern: bun-*-tests
+          github-token: ${{ github.token }}
+          run-id: ${{ github.event.workflow_run.id }}
+      - name: Setup Environment
+        id: env
+        shell: bash
+        run: |
+          echo "pr-number=$(<bun/bun-linux-x64-tests/pr-number.txt)" >> $GITHUB_OUTPUT
+      - name: Generate Comment
+        run: |
+          cat bun/bun-*-tests/comment.md > comment.md
+          if [ -s comment.md ]; then
+            echo -e "❌ @${{ github.actor }}, your commit has failing tests :(\n\n$(cat comment.md)" > comment.md
+          else
+            echo -e "✅ @${{ github.actor }}, all tests passed!" > comment.md
+          fi
+          echo -e "\n**[View logs](https://github.com/${{ github.repository }}/actions/runs/${{ github.event.workflow_run.id }})**" >> comment.md
+          echo -e "<!-- generated-comment workflow=${{ github.workflow }} -->" >> comment.md
+      - name: Find Comment
+        id: comment
+        uses: peter-evans/find-comment@v3
+        with:
+          issue-number: ${{ steps.env.outputs.pr-number }}
+          comment-author: github-actions[bot]
+          body-includes: <!-- generated-comment workflow=${{ github.workflow }} -->
+      - name: Write Comment
+        uses: peter-evans/create-or-update-comment@v4
+        with:
+          comment-id: ${{ steps.comment.outputs.comment-id }}
+          issue-number: ${{ steps.env.outputs.pr-number }}
+          body-path: comment.md
+          edit-mode: replace

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

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

.github/workflows/release.yml

@@ -1,6 +1,3 @@
-# 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
 

.github/workflows/run-test.yml

@@ -0,0 +1,224 @@
+name: Test
+
+permissions:
+  contents: read
+  actions: read
+
+on:
+  workflow_call:
+    inputs:
+      runs-on:
+        type: string
+        required: true
+      tag:
+        type: string
+        required: true
+      pr-number:
+        type: string
+        required: true
+      run-id:
+        type: string
+        default: ${{ github.run_id }}
+
+jobs:
+  test:
+    name: Tests
+    runs-on: ${{ inputs.runs-on }}
+    steps:
+      - if: ${{ runner.os == 'Windows' }}
+        name: Setup Git
+        run: |
+          git config --global core.autocrlf false
+          git config --global core.eol lf
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          sparse-checkout: |
+            package.json
+            bun.lockb
+            test
+            packages/bun-internal-test
+            packages/bun-types
+      - name: Setup Environment
+        shell: bash
+        run: |
+          echo "${{ inputs.pr-number }}" > pr-number.txt
+      - name: Download Bun
+        uses: actions/download-artifact@v4
+        with:
+          name: bun-${{ inputs.tag }}
+          path: bun
+          github-token: ${{ github.token }}
+          run-id: ${{ inputs.run-id || github.run_id }}
+      - name: Download pnpm
+        uses: pnpm/action-setup@v4
+        with:
+          version: 8
+      - if: ${{ runner.os != 'Windows' }}
+        name: Setup Bun
+        shell: bash
+        run: |
+          unzip bun/bun-*.zip
+          cd bun-*
+          pwd >> $GITHUB_PATH
+      - if: ${{ runner.os == 'Windows' }}
+        name: Setup Cygwin
+        uses: secondlife/setup-cygwin@v3
+        with:
+          packages: bash
+      - if: ${{ runner.os == 'Windows' }}
+        name: Setup Bun (Windows)
+        run: |
+          unzip bun/bun-*.zip
+          cd bun-*
+          pwd >> $env:GITHUB_PATH
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: 20
+      - name: Install Dependencies
+        timeout-minutes: 5
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          bun install
+      - name: Install Dependencies (test)
+        timeout-minutes: 5
+        run: |
+          bun install --cwd test
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      - name: Install Dependencies (runner)
+        timeout-minutes: 5
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          bun install --cwd packages/bun-internal-test
+      - name: Run Tests
+        id: test
+        timeout-minutes: 90
+        shell: bash
+        env:
+          IS_BUN_CI: 1
+          TMPDIR: ${{ runner.temp }}
+          BUN_TAG: ${{ inputs.tag }}
+          BUN_FEATURE_FLAG_INTERNAL_FOR_TESTING: "true"
+          SMTP_SENDGRID_SENDER: ${{ secrets.SMTP_SENDGRID_SENDER }}
+          TLS_MONGODB_DATABASE_URL: ${{ secrets.TLS_MONGODB_DATABASE_URL }}
+          TLS_POSTGRES_DATABASE_URL: ${{ secrets.TLS_POSTGRES_DATABASE_URL }}
+          TEST_INFO_STRIPE: ${{ secrets.TEST_INFO_STRIPE }}
+          TEST_INFO_AZURE_SERVICE_BUS: ${{ secrets.TEST_INFO_AZURE_SERVICE_BUS }}
+          SHELLOPTS: igncr
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          node packages/bun-internal-test/src/runner.node.mjs $(which bun)
+      - if: ${{ always() }}
+        name: Upload Results
+        uses: actions/upload-artifact@v4
+        with:
+          name: bun-${{ inputs.tag }}-tests
+          path: |
+            test-report.*
+            comment.md
+            pr-number.txt
+          if-no-files-found: error
+          overwrite: true
+      - if: ${{ always() && steps.test.outputs.failing_tests != '' && github.event.pull_request && github.repository_owner == 'oven-sh' }}
+        name: Send Message
+        uses: sarisia/actions-status-discord@v1
+        with:
+          webhook: ${{ secrets.DISCORD_WEBHOOK }}
+          nodetail: true
+          color: "#FF0000"
+          title: ""
+          description: |
+            ### ❌ [${{ github.event.pull_request.title }}](${{ github.event.pull_request.html_url }})
+
+            @${{ github.actor }}, there are ${{ steps.test.outputs.failing_tests_count || 'some' }} failing tests on bun-${{ inputs.tag }}.
+
+            ${{ steps.test.outputs.failing_tests }}
+
+            **[View logs](https://github.com/${{ github.repository }}/actions/runs/${{ github.run_id }})**
+      - name: Fail
+        if: ${{ failure() || always() && steps.test.outputs.failing_tests != '' }}
+        run: |
+          echo "There are ${{ steps.test.outputs.failing_tests_count || 'some' }} failing tests on bun-${{ inputs.tag }}."
+          exit 1
+  test-node:
+    name: Node.js Tests
+    # TODO: enable when we start paying attention to the results. In the meantime, this causes CI to queue jobs wasting developer time.
+    if: 0
+    runs-on: ${{ inputs.runs-on }}
+    steps:
+      - if: ${{ runner.os == 'Windows' }}
+        name: Setup Git
+        run: |
+          git config --global core.autocrlf false
+          git config --global core.eol lf
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          sparse-checkout: |
+            test/node.js
+      - name: Setup Environment
+        shell: bash
+        run: |
+          echo "${{ inputs.pr-number }}" > pr-number.txt
+      - name: Download Bun
+        uses: actions/download-artifact@v4
+        with:
+          name: bun-${{ inputs.tag }}
+          path: bun
+          github-token: ${{ github.token }}
+          run-id: ${{ inputs.run-id || github.run_id }}
+      - if: ${{ runner.os != 'Windows' }}
+        name: Setup Bun
+        shell: bash
+        run: |
+          unzip bun/bun-*.zip
+          cd bun-*
+          pwd >> $GITHUB_PATH
+      - if: ${{ runner.os == 'Windows' }}
+        name: Setup Cygwin
+        uses: secondlife/setup-cygwin@v3
+        with:
+          packages: bash
+      - if: ${{ runner.os == 'Windows' }}
+        name: Setup Bun (Windows)
+        run: |
+          unzip bun/bun-*.zip
+          cd bun-*
+          pwd >> $env:GITHUB_PATH
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: 20
+      - name: Checkout Tests
+        shell: bash
+        working-directory: test/node.js
+        run: |
+          node runner.mjs --pull
+      - name: Install Dependencies
+        timeout-minutes: 5
+        shell: bash
+        working-directory: test/node.js
+        run: |
+          bun install
+      - name: Run Tests
+        timeout-minutes: 10 # Increase when more tests are added
+        shell: bash
+        working-directory: test/node.js
+        env:
+          TMPDIR: ${{ runner.temp }}
+          BUN_GARBAGE_COLLECTOR_LEVEL: "0"
+          BUN_FEATURE_FLAG_INTERNAL_FOR_TESTING: "true"
+        run: |
+          node runner.mjs
+      - name: Upload Results
+        uses: actions/upload-artifact@v4
+        with:
+          name: bun-${{ inputs.tag }}-node-tests
+          path: |
+            test/node.js/summary/*.json
+          if-no-files-found: error
+          overwrite: true

.github/workflows/upload.yml

@@ -0,0 +1,94 @@
+name: Upload Artifacts
+run-name: Canary release ${{github.sha}} upload
+
+permissions:
+  contents: write
+
+on:
+  workflow_run:
+    workflows:
+      - CI
+    types:
+      - completed
+    branches:
+      - main
+
+jobs:
+  upload:
+    if: ${{ github.repository_owner == 'oven-sh' }}
+    name: Upload Artifacts
+    runs-on: ubuntu-latest
+    steps:
+      - name: Download Artifacts
+        uses: actions/download-artifact@v4
+        with:
+          path: bun
+          pattern: bun-*
+          merge-multiple: true
+          github-token: ${{ github.token }}
+          run-id: ${{ github.event.workflow_run.id }}
+      - name: Check for Artifacts
+        run: |
+          if [ ! -d "bun" ] || [ -z "$(ls -A bun)" ]; then
+            echo "Error: No artifacts were downloaded or 'bun' directory does not exist."
+            exit 1  # Fail the job if the condition is met
+          else
+            echo "Artifacts downloaded successfully."
+          fi
+      - name: Upload to GitHub Releases
+        uses: ncipollo/release-action@v1
+        with:
+          tag: canary
+          name: Canary (${{ github.sha }})
+          prerelease: true
+          body: This canary release of Bun corresponds to the commit [${{ github.sha }}]
+          allowUpdates: true
+          replacesArtifacts: true
+          generateReleaseNotes: true
+          artifactErrorsFailBuild: true
+          artifacts: bun/**/bun-*.zip
+          token: ${{ github.token }}
+      - name: Upload to S3 (using SHA)
+        uses: shallwefootball/s3-upload-action@4350529f410221787ccf424e50133cbc1b52704e
+        with:
+          endpoint: ${{ secrets.AWS_ENDPOINT }}
+          aws_key_id: ${{ secrets.AWS_ACCESS_KEY_ID }}
+          aws_secret_access_key: ${{ secrets.AWS_SECRET_ACCESS_KEY}}
+          aws_bucket: ${{ secrets.AWS_BUCKET }}
+          source_dir: bun
+          destination_dir: releases/${{ github.event.workflow_run.head_sha || github.sha }}-canary
+      - name: Upload to S3 (using tag)
+        uses: shallwefootball/s3-upload-action@4350529f410221787ccf424e50133cbc1b52704e
+        with:
+          endpoint: ${{ secrets.AWS_ENDPOINT }}
+          aws_key_id: ${{ secrets.AWS_ACCESS_KEY_ID }}
+          aws_secret_access_key: ${{ secrets.AWS_SECRET_ACCESS_KEY}}
+          aws_bucket: ${{ secrets.AWS_BUCKET }}
+          source_dir: bun
+          destination_dir: releases/canary
+      - name: Announce on Discord
+        uses: sarisia/actions-status-discord@v1
+        with:
+          webhook: ${{ secrets.BUN_DISCORD_GITHUB_CHANNEL_WEBHOOK }}
+          nodetail: true
+          color: "#1F6FEB"
+          title: "New Bun Canary available"
+          url: https://github.com/oven-sh/bun/commit/${{ github.sha }}
+          description: |
+            A new canary build of Bun has been automatically uploaded. To upgrade, run:
+            ```sh
+            bun upgrade --canary
+            # bun upgrade --stable <- to downgrade
+            ```
+      # If notifying sentry fails, don't fail the rest of the build.
+      - name: Notify Sentry
+        uses: getsentry/action-release@v1.7.0
+        env:
+          SENTRY_AUTH_TOKEN: ${{ secrets.SENTRY_AUTH_TOKEN }}
+          SENTRY_ORG: ${{ secrets.SENTRY_ORG }}
+          SENTRY_PROJECT: ${{ secrets.SENTRY_PROJECT }}
+        with:
+          ignore_missing: true
+          ignore_empty: true
+          version: ${{ github.event.workflow_run.head_sha || github.sha }}-canary
+          environment: canary

.vscode/launch.json

@@ -17,7 +17,6 @@
       "cwd": "${workspaceFolder}/test",
       "env": {
         "FORCE_COLOR": "1",
-        "BUN_DEBUG_QUIET_LOGS": "1",
         "BUN_GARBAGE_COLLECTOR_LEVEL": "1",
       },
       "console": "internalConsole",

packages/bun-uws/capi/Makefile

@@ -0,0 +1,38 @@
+CAPI_EXAMPLE_FILES := HelloWorld HelloWorldAsync ServerName UpgradeSync UpgradeAsync EchoServer Broadcast BroadcastEchoServer
+RUST_EXAMPLE_FILES := RustHelloWorld
+LIBRARY_NAME := libuwebsockets
+
+default:
+	$(MAKE) capi
+	$(CXX) -O3 -flto -I ../src -I ../uSockets/src examples/HelloWorld.c *.o -lz -luv -lssl -lcrypto -lstdc++ ../uSockets/uSockets.a -o HelloWorld
+
+capi:
+	$(MAKE) clean
+	cd ../uSockets && $(CC) -pthread -DUWS_WITH_PROXY -DLIBUS_USE_OPENSSL -DLIBUS_USE_LIBUV -std=c11 -Isrc -flto -fPIC -O3 -c src/*.c src/eventing/*.c src/crypto/*.c
+	cd ../uSockets && $(CXX) -std=c++17 -flto -fPIC -O3 -c src/crypto/*.cpp 
+	cd ../uSockets && $(AR) rvs uSockets.a *.o
+
+	$(CXX) -DUWS_WITH_PROXY -c -O3 -std=c++17 -lz -luv -flto -fPIC -I ../src -I ../uSockets/src $(LIBRARY_NAME).cpp
+	$(AR) rvs $(LIBRARY_NAME).a $(LIBRARY_NAME).o ../uSockets/uSockets.a
+shared:
+	$(MAKE) clean
+
+	cd ../uSockets && $(CC) -pthread -DUWS_WITH_PROXY  -DLIBUS_USE_OPENSSL -DLIBUS_USE_LIBUV -std=c11 -Isrc -flto -fPIC -O3 -c src/*.c src/eventing/*.c src/crypto/*.c
+	cd ../uSockets && $(CXX) -std=c++17 -flto -fPIC -O3 -c src/crypto/*.cpp 
+	cd ../uSockets && $(AR) rvs uSockets.a *.o
+
+	$(CXX) -DUWS_WITH_PROXY  -c -O3 -std=c++17 -lz -luv -flto -fPIC -I ../src -I ../uSockets/src $(LIBRARY_NAME).cpp 
+	$(CXX) -shared -o $(LIBRARY_NAME).so  $(LIBRARY_NAME).o ../uSockets/uSockets.a -fPIC  -lz -luv -lssl -lcrypto
+misc:
+	mkdir -p ../misc && openssl req -newkey rsa:2048 -new -nodes -x509 -days 3650 -passout pass:1234 -keyout ../misc/key.pem -out ../misc/cert.pem
+rust:
+	$(MAKE) capi
+	rustc -C link-arg=$(LIBRARY_NAME).a -C link-args="-lstdc++ -luv" -C opt-level=3 -C lto -L all=. examples/RustHelloWorld.rs -o RustHelloWorld
+
+clean:
+	rm -f *.o $(CAPI_EXAMPLE_FILES) $(RUST_EXAMPLE_FILES) $(LIBRARY_NAME).a $(LIBRARY_NAME).so
+
+all:
+	for FILE in $(CAPI_EXAMPLE_FILES); do  $(CXX) -O3 -flto -I ../src -I ../uSockets/src examples/$$FILE.c *.o -luv -lstdc++ ../uSockets/uSockets.a -o $$FILE & done; \
+	wait
+	

packages/bun-uws/capi/examples/Broadcast.c

@@ -0,0 +1,157 @@
+#include "../libuwebsockets.h"
+#include <stdio.h>
+#include <malloc.h>
+#include <time.h>
+#include <string.h>
+#include <stdarg.h>
+#define SSL 1
+
+
+//Timer close helper
+void uws_timer_close(struct us_timer_t *timer)
+{
+    struct us_timer_t *t = (struct us_timer_t *)timer;
+    struct timer_handler_data *data;
+    memcpy(&data, us_timer_ext(t), sizeof(struct timer_handler_data *));
+    free(data);
+    us_timer_close(t, 0);
+}
+//Timer create helper
+struct us_timer_t *uws_create_timer(int ms, int repeat_ms, void (*handler)(void *data), void *data)
+{
+    struct us_loop_t *loop = uws_get_loop();
+    struct us_timer_t *delayTimer = us_create_timer(loop, 0, sizeof(void *));
+
+    struct timer_handler_data
+    {
+        void *data;
+        void (*handler)(void *data);
+        bool repeat;
+    };
+
+    struct timer_handler_data *timer_data = (struct timer_handler_data *)malloc(sizeof(timer_handler_data));
+    timer_data->data = data;
+    timer_data->handler = handler;
+    timer_data->repeat = repeat_ms > 0;
+    memcpy(us_timer_ext(delayTimer), &timer_data, sizeof(struct timer_handler_data *));
+
+    us_timer_set(
+        delayTimer, [](struct us_timer_t *t)
+        {
+            /* We wrote the pointer to the timer's extension */
+            struct timer_handler_data *data;
+            memcpy(&data, us_timer_ext(t), sizeof(struct timer_handler_data *));
+
+            data->handler(data->data);
+
+            if (!data->repeat)
+            {
+                free(data);
+                us_timer_close(t, 0);
+            }
+        },
+        ms, repeat_ms);
+
+    return (struct us_timer_t *)delayTimer;
+}
+
+/* This is a simple WebSocket "sync" upgrade example.
+ * You may compile it with "WITH_OPENSSL=1 make" or with "make" */
+
+/* ws->getUserData returns one of these */
+struct PerSocketData {
+    /* Fill with user data */
+};
+
+int buffer_size(const char* format, ...) {
+    va_list args;
+    va_start(args, format);
+    int result = vsnprintf(NULL, 0, format, args);
+    va_end(args);
+    return result + 1; // safe byte for \0
+}
+
+void listen_handler(struct us_listen_socket_t *listen_socket, uws_app_listen_config_t config,  void* user_data)
+{
+    if (listen_socket){
+        printf("Listening on port wss://localhost:%d\n", config.port);
+    }
+}
+
+void open_handler(uws_websocket_t* ws){
+
+     /* Open event here, you may access uws_ws_get_user_data(WS) which points to a PerSocketData struct */
+    uws_ws_subscribe(SSL, ws, "broadcast", 9);
+}
+
+void message_handler(uws_websocket_t* ws, const char* message, size_t length, uws_opcode_t opcode){
+}
+
+void close_handler(uws_websocket_t* ws, int code, const char* message, size_t length){
+    /* You may access uws_ws_get_user_data(ws) here, but sending or
+     * doing any kind of I/O with the socket is not valid. */
+}
+
+void drain_handler(uws_websocket_t* ws){
+    /* Check uws_ws_get_buffered_amount(ws) here */
+}
+
+void ping_handler(uws_websocket_t* ws, const char* message, size_t length){
+    /* You don't need to handle this one, we automatically respond to pings as per standard */
+}
+
+void pong_handler(uws_websocket_t* ws, const char* message, size_t length){
+
+    /* You don't need to handle this one either */
+}
+
+void on_timer_interval(void* data){
+
+    // broadcast the unix time as millis
+
+    uws_app_t * app = (uws_app_t *)data;
+    struct timespec ts;
+    timespec_get(&ts, TIME_UTC);
+
+    int64_t millis = ts.tv_sec * 1000 + ts.tv_nsec / 1000000;
+
+    
+    char* message = (char*)malloc((size_t)buffer_size("%ld", millis));
+    size_t message_length = sprintf(message, "%ld", millis);
+
+    uws_publish(SSL, app, "broadcast", 9, message, message_length, uws_opcode_t::TEXT, false);
+    free(message);
+}
+
+int main()
+{
+
+
+    uws_app_t *app = uws_create_app(SSL, (struct us_socket_context_options_t){
+        /* There are example certificates in uWebSockets.js repo */
+	    .key_file_name = "../misc/key.pem",
+	    .cert_file_name = "../misc/cert.pem",
+	    .passphrase = "1234"
+    });
+
+	uws_ws(SSL, app, "/*", (uws_socket_behavior_t){
+		.compression = uws_compress_options_t::SHARED_COMPRESSOR,
+        .maxPayloadLength = 16 * 1024,
+        .idleTimeout = 12,
+        .maxBackpressure = 1 * 1024 * 1024,
+		.upgrade = NULL,
+        .open = open_handler,
+        .message = message_handler,
+        .drain = drain_handler,
+        .ping = ping_handler,
+        .pong = pong_handler,
+        .close = close_handler,
+	});
+
+    uws_app_listen(SSL, app, 9001, listen_handler, NULL);
+
+    // broadcast the unix time as millis every 8 millis
+    uws_create_timer(8, 8, on_timer_interval,  app);
+
+	uws_app_run(SSL, app);
+}

packages/bun-uws/capi/examples/BroadcastEchoServer.c

@@ -0,0 +1,175 @@
+#include "../libuwebsockets.h"
+#include <stdio.h>
+#include <malloc.h>
+#include <time.h>
+#include <string.h>
+#include <stdarg.h>
+
+#define SSL 1
+
+
+/* This is a simple WebSocket "sync" upgrade example.
+ * You may compile it with "WITH_OPENSSL=1 make" or with "make" */
+
+typedef struct
+{
+    size_t length;
+    char *name;
+} topic_t;
+
+/* ws->getUserData returns one of these */
+struct PerSocketData
+{
+    /* Fill with user data */
+    topic_t **topics;
+    int topics_quantity;
+    int nr;
+};
+
+uws_app_t *app;
+
+int buffer_size(const char *format, ...)
+{
+    va_list args;
+    va_start(args, format);
+    int result = vsnprintf(NULL, 0, format, args);
+    va_end(args);
+    return result + 1; // safe byte for \0
+}
+
+void listen_handler(struct us_listen_socket_t *listen_socket, uws_app_listen_config_t config, void* user_data)
+{
+    if (listen_socket)
+    {
+        printf("Listening on port wss://localhost:%d\n", config.port);
+    }
+}
+
+void upgrade_handler(uws_res_t *response, uws_req_t *request, uws_socket_context_t *context)
+{
+
+    /* You may read from req only here, and COPY whatever you need into your PerSocketData.
+     * PerSocketData is valid from .open to .close event, accessed with uws_ws_get_user_data(ws).
+     * HttpRequest (req) is ONLY valid in this very callback, so any data you will need later
+     * has to be COPIED into PerSocketData here. */
+
+    /* Immediately upgrading without doing anything "async" before, is simple */
+
+    struct PerSocketData *data = (struct PerSocketData *)malloc(sizeof(struct PerSocketData));
+    data->topics = (topic_t **)calloc(32, sizeof(topic_t *));
+    data->topics_quantity = 32;
+    data->nr = 0;
+
+    const char *ws_key = NULL;
+    const char *ws_protocol = NULL;
+    const char *ws_extensions = NULL;
+    
+    size_t ws_key_length = uws_req_get_header(request, "sec-websocket-key", 17, &ws_key);
+    size_t ws_protocol_length = uws_req_get_header(request, "sec-websocket-protocol", 22, &ws_protocol);
+    size_t ws_extensions_length = uws_req_get_header(request, "sec-websocket-extensions", 24, &ws_extensions);
+
+    uws_res_upgrade(SSL,
+                    response,
+                    (void *)data,
+                    ws_key,
+                    ws_key_length,
+                    ws_protocol,
+                    ws_protocol_length,
+                    ws_extensions,
+                    ws_extensions_length,
+                    context);
+}
+
+void open_handler(uws_websocket_t *ws)
+{
+
+    /* Open event here, you may access  uws_ws_get_user_data(ws) which points to a PerSocketData struct */
+    struct PerSocketData *data = (struct PerSocketData *)uws_ws_get_user_data(SSL, ws);
+    for (int i = 0; i < data->topics_quantity; i++)
+    {
+
+        char *topic = (char *)malloc((size_t)buffer_size("%ld-%d", (uintptr_t)ws, i));
+        size_t topic_length = sprintf(topic, "%ld-%d", (uintptr_t)ws, i);
+
+        topic_t *new_topic = (topic_t*) malloc(sizeof(topic_t));
+        new_topic->length = topic_length;
+        new_topic->name = topic;
+        data->topics[i] = new_topic;
+        uws_ws_subscribe(SSL, ws, topic, topic_length);
+    }
+}
+
+void message_handler(uws_websocket_t *ws, const char *message, size_t length, uws_opcode_t opcode)
+{
+    struct PerSocketData *data = (struct PerSocketData *)uws_ws_get_user_data(SSL, ws);
+    topic_t *topic = data->topics[(size_t)(++data->nr % data->topics_quantity)];
+    uws_publish(SSL, app, topic->name, topic->length, message, length, opcode, false);
+
+    topic = data->topics[(size_t)(++data->nr % data->topics_quantity)];
+    uws_ws_publish(SSL, ws, topic->name, topic->length, message, length);
+}
+
+void close_handler(uws_websocket_t *ws, int code, const char *message, size_t length)
+{
+    /* You may access uws_ws_get_user_data(ws) here, but sending or
+     * doing any kind of I/O with the socket is not valid. */
+    struct PerSocketData *data = (struct PerSocketData *)uws_ws_get_user_data(SSL, ws);
+    if (data)
+    {
+        for (int i = 0; i < data->topics_quantity; i++)
+        {
+
+            topic_t* topic = data->topics[i];
+            free(topic->name);
+            free(topic);
+        }
+        free(data->topics);
+        free(data);
+    }
+}
+
+void drain_handler(uws_websocket_t *ws)
+{
+    /* Check uws_ws_get_buffered_amount(ws) here */
+}
+
+void ping_handler(uws_websocket_t *ws, const char *message, size_t length)
+{
+    /* You don't need to handle this one, we automatically respond to pings as per standard */
+}
+
+void pong_handler(uws_websocket_t *ws, const char *message, size_t length)
+{
+
+    /* You don't need to handle this one either */
+}
+
+int main()
+{
+
+
+    uws_app_t *app = uws_create_app(SSL, (struct us_socket_context_options_t){
+        /* There are example certificates in uWebSockets.js repo */
+	    .key_file_name = "../misc/key.pem",
+	    .cert_file_name = "../misc/cert.pem",
+	    .passphrase = "1234"
+    });
+
+    uws_ws(SSL, app, "/*", (uws_socket_behavior_t){
+                          .compression = uws_compress_options_t::SHARED_COMPRESSOR,
+                          .maxPayloadLength = 16 * 1024,
+                          .idleTimeout = 12,
+                          .maxBackpressure = 1 * 1024 * 1024,
+                          .upgrade = upgrade_handler,
+                          .open = open_handler,
+                          .message = message_handler,
+                          .drain = drain_handler,
+                          .ping = ping_handler,
+                          .pong = pong_handler,
+                          .close = close_handler,
+                      });
+
+    uws_app_listen(SSL, app, 9001, listen_handler, NULL);
+
+    uws_app_run(SSL, app);
+}

packages/bun-uws/capi/examples/EchoServer.c

@@ -0,0 +1,81 @@
+#include "../libuwebsockets.h"
+#include <stdio.h>
+#include <malloc.h>
+
+#define SSL 1
+
+
+/* This is a simple WebSocket "sync" upgrade example.
+ * You may compile it with "WITH_OPENSSL=1 make" or with "make" */
+
+/* ws->getUserData returns one of these */
+struct PerSocketData {
+    /* Fill with user data */
+};
+
+void listen_handler(struct us_listen_socket_t *listen_socket, uws_app_listen_config_t config, void* user_data)
+{
+    if (listen_socket){
+        printf("Listening on port wss://localhost:%d\n", config.port);
+    }
+}
+
+void open_handler(uws_websocket_t* ws){
+
+     /* Open event here, you may access uws_ws_get_user_data(WS) which points to a PerSocketData struct */
+}
+
+void message_handler(uws_websocket_t* ws, const char* message, size_t length, uws_opcode_t opcode){
+    uws_ws_send(SSL, ws, message, length, opcode);
+}
+
+void close_handler(uws_websocket_t* ws, int code, const char* message, size_t length){
+
+    /* You may access uws_ws_get_user_data(ws) here, but sending or
+     * doing any kind of I/O with the socket is not valid. */
+}
+
+void drain_handler(uws_websocket_t* ws){
+    /* Check uws_ws_get_buffered_amount(ws) here */
+}
+
+void ping_handler(uws_websocket_t* ws, const char* message, size_t length){
+    /* You don't need to handle this one, we automatically respond to pings as per standard */
+}
+
+void pong_handler(uws_websocket_t* ws, const char* message, size_t length){
+
+    /* You don't need to handle this one either */
+}
+
+
+int main()
+{
+
+
+    uws_app_t *app = uws_create_app(SSL, (struct us_socket_context_options_t){
+        /* There are example certificates in uWebSockets.js repo */
+	    .key_file_name = "../misc/key.pem",
+	    .cert_file_name = "../misc/cert.pem",
+	    .passphrase = "1234"
+    });
+
+	uws_ws(SSL, app, "/*", (uws_socket_behavior_t){
+		.compression = uws_compress_options_t::SHARED_COMPRESSOR,
+        .maxPayloadLength = 16 * 1024,
+        .idleTimeout = 12,
+        .maxBackpressure = 1 * 1024 * 1024,
+		.upgrade = NULL,
+        .open = open_handler,
+        .message = message_handler,
+        .drain = drain_handler,
+        .ping = ping_handler,
+        .pong = pong_handler,
+        .close = close_handler,
+	});
+
+    uws_app_listen(SSL,app, 9001, listen_handler, NULL);
+    
+
+	uws_app_run(SSL, app);
+}

packages/bun-uws/capi/examples/HelloWorld.c

@@ -0,0 +1,33 @@
+#include "../libuwebsockets.h"
+#include "libusockets.h"
+#include <stdio.h>
+
+#define SSL 1
+
+void get_handler(uws_res_t *res, uws_req_t *req, void *user_data)
+{
+    uws_res_end(SSL, res, "Hello CAPI!", 11, false);
+}
+
+void listen_handler(struct us_listen_socket_t *listen_socket, uws_app_listen_config_t config, void *user_data)
+{
+    if (listen_socket)
+    {
+        printf("Listening on port https://localhost:%d now\n", config.port);
+    }
+}
+
+int main()
+{
+    /* Overly simple hello world app */
+
+    uws_app_t *app = uws_create_app(SSL, (struct us_socket_context_options_t){
+        /* There are example certificates in uWebSockets.js repo */
+	    .key_file_name = "../misc/key.pem",
+	    .cert_file_name = "../misc/cert.pem",
+	    .passphrase = "1234"
+    });
+    uws_app_get(SSL, app, "/*", get_handler, NULL);
+    uws_app_listen(SSL, app, 3000, listen_handler, NULL);
+    uws_app_run(SSL, app);
+}

packages/bun-uws/capi/examples/HelloWorldAsync.c

@@ -0,0 +1,123 @@
+#include "../libuwebsockets.h"
+#include "libusockets.h"
+
+#include <stdio.h>
+#include <malloc.h>
+#include <string.h>
+
+#define SSL 0
+
+typedef struct {
+    uws_res_t* res;
+    bool aborted;
+} async_request_t;
+
+//Timer close helper
+void uws_timer_close(struct us_timer_t *timer)
+{
+    struct us_timer_t *t = (struct us_timer_t *)timer;
+    struct timer_handler_data *data;
+    memcpy(&data, us_timer_ext(t), sizeof(struct timer_handler_data *));
+    free(data);
+    us_timer_close(t, 0);
+}
+//Timer create helper
+struct us_timer_t *uws_create_timer(int ms, int repeat_ms, void (*handler)(void *data), void *data)
+{
+    struct us_loop_t *loop = uws_get_loop();
+    struct us_timer_t *delayTimer = us_create_timer(loop, 0, sizeof(void *));
+
+    struct timer_handler_data
+    {
+        void *data;
+        void (*handler)(void *data);
+        bool repeat;
+    };
+
+    struct timer_handler_data *timer_data = (struct timer_handler_data *)malloc(sizeof(timer_handler_data));
+    timer_data->data = data;
+    timer_data->handler = handler;
+    timer_data->repeat = repeat_ms > 0;
+    memcpy(us_timer_ext(delayTimer), &timer_data, sizeof(struct timer_handler_data *));
+
+    us_timer_set(
+        delayTimer, [](struct us_timer_t *t)
+        {
+            /* We wrote the pointer to the timer's extension */
+            struct timer_handler_data *data;
+            memcpy(&data, us_timer_ext(t), sizeof(struct timer_handler_data *));
+
+            data->handler(data->data);
+
+            if (!data->repeat)
+            {
+                free(data);
+                us_timer_close(t, 0);
+            }
+        },
+        ms, repeat_ms);
+
+    return (struct us_timer_t *)delayTimer;
+}
+
+void on_res_aborted(uws_res_t *response, void* data){
+    async_request_t* request_data =  (async_request_t*)data;
+    /* We don't implement any kind of cancellation here,
+     * so simply flag us as aborted */
+    request_data->aborted = true;
+}
+
+void on_res_corked(uws_res_t *response, void* data){
+    uws_res_end(SSL, response, "Hello CAPI!", 11, false);
+}
+void on_timer_done(void *data){
+    async_request_t* request_data = (async_request_t*)data;
+    /* Were'nt we aborted before our async task finished? Okay, send a message! */
+    if(!request_data->aborted){
+
+        uws_res_cork(SSL, request_data->res,on_res_corked, request_data);
+    }
+}
+
+void get_handler(uws_res_t *res, uws_req_t *req,  void* user_data)
+{
+
+    /* We have to attach an abort handler for us to be aware
+     * of disconnections while we perform async tasks */
+    async_request_t* request_data = (async_request_t*) malloc(sizeof(async_request_t));
+    request_data->res = res;
+    request_data->aborted = false;
+
+    uws_res_on_aborted(SSL, res, on_res_aborted, request_data);
+
+   /* Simulate checking auth for 5 seconds. This looks like crap, never write
+    * code that utilize us_timer_t like this; they are high-cost and should
+    * not be created and destroyed more than rarely!
+    * Either way, here we go!*/
+    uws_create_timer(1, 0, on_timer_done, request_data);
+}
+
+
+void listen_handler(struct us_listen_socket_t *listen_socket, uws_app_listen_config_t config,  void* user_data)
+{
+    if (listen_socket)
+    {
+        printf("Listening on port https://localhost:%d now\n", config.port);
+    }
+}
+
+int main()
+{
+  	/* Overly simple hello world app with async response */
+
+
+    uws_app_t *app = uws_create_app(SSL, (struct us_socket_context_options_t){
+        /* There are example certificates in uWebSockets.js repo */
+	    .key_file_name = "../misc/key.pem",
+	    .cert_file_name = "../misc/cert.pem",
+	    .passphrase = "1234"
+    });
+    uws_app_get(SSL, app, "/*", get_handler, NULL);
+    uws_app_listen(SSL, app, 3000, listen_handler, NULL);
+    uws_app_run(SSL, app);
+}

packages/bun-uws/capi/examples/RustHelloWorld.rs

@@ -0,0 +1,309 @@
+/* automatically generated by rust-bindgen 0.59.2 */
+use std::convert::TryInto;
+use std::ffi::CString;
+
+pub type SizeT = ::std::os::raw::c_ulong;
+pub type WcharT = ::std::os::raw::c_uint;
+#[repr(C)]
+#[repr(align(16))]
+#[derive(Debug, Copy, Clone)]
+pub struct max_align_t {
+    pub __clang_max_align_nonce1: ::std::os::raw::c_longlong,
+    pub __bindgen_padding_0: u64,
+    pub __clang_max_align_nonce2: u128,
+}
+#[test]
+fn bindgen_test_layout_max_align_t() {
+    assert_eq!(
+        ::std::mem::size_of::<max_align_t>(),
+        32usize,
+        concat!("Size of: ", stringify!(max_align_t))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<max_align_t>(),
+        16usize,
+        concat!("Alignment of ", stringify!(max_align_t))
+    );
+    assert_eq!(
+        unsafe {
+            &(*(::std::ptr::null::<max_align_t>())).__clang_max_align_nonce1 as *const _ as usize
+        },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(max_align_t),
+            "::",
+            stringify!(__clang_max_align_nonce1)
+        )
+    );
+    assert_eq!(
+        unsafe {
+            &(*(::std::ptr::null::<max_align_t>())).__clang_max_align_nonce2 as *const _ as usize
+        },
+        16usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(max_align_t),
+            "::",
+            stringify!(__clang_max_align_nonce2)
+        )
+    );
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct uws_app_s {
+    _unused: [u8; 0],
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct uws_req_s {
+    _unused: [u8; 0],
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct uws_res_s {
+    _unused: [u8; 0],
+}
+
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct uws_app_listen_config_s {
+    port: ::std::os::raw::c_int,
+    host: *const ::std::os::raw::c_char,
+    options: ::std::os::raw::c_int,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct us_socket_context_options_s {
+    key_file_name: *const ::std::os::raw::c_char,
+    cert_file_name: *const ::std::os::raw::c_char,
+    passphrase: *const ::std::os::raw::c_char,
+    dh_params_file_name: *const ::std::os::raw::c_char,
+    ca_file_name: *const ::std::os::raw::c_char,
+    ssl_prefer_low_memory_usage: ::std::os::raw::c_int,
+}
+
+pub type UwsAppListenConfigT = uws_app_listen_config_s;
+pub type UsSocketContextOptionsT = us_socket_context_options_s;
+pub struct UsSocketContextOptions<'a> {
+    key_file_name: &'a str,
+    cert_file_name: &'a str,
+    passphrase: &'a str,
+    dh_params_file_name: &'a str,
+    ca_file_name: &'a str,
+    ssl_prefer_low_memory_usage: i32,
+}
+pub type UwsAppT = uws_app_s;
+pub type UwsReqT = uws_req_s;
+pub type UwsResT = uws_res_s;
+extern "C" {
+    pub fn uws_create_app(
+        ssl: ::std::os::raw::c_int,
+        options: UsSocketContextOptionsT,
+    ) -> *mut UwsAppT;
+    pub fn uws_app_get(
+        ssl: ::std::os::raw::c_int,
+        app: *mut UwsAppT,
+        pattern: *const ::std::os::raw::c_char,
+        handler: ::std::option::Option<
+            unsafe extern "C" fn(
+                res: *mut UwsResT,
+                req: *mut UwsReqT,
+                user_data: *mut ::std::os::raw::c_void,
+            ),
+        >,
+        user_data: *mut ::std::os::raw::c_void,
+    );
+    pub fn uws_app_run(ssl: ::std::os::raw::c_int, app: *mut UwsAppT);
+
+    pub fn uws_app_listen(
+        ssl: ::std::os::raw::c_int,
+        app: *mut UwsAppT,
+        port: ::std::os::raw::c_int,
+        handler: ::std::option::Option<
+            unsafe extern "C" fn(
+                listen_socket: *mut ::std::os::raw::c_void,
+                config: UwsAppListenConfigT,
+                user_data: *mut ::std::os::raw::c_void,
+            ),
+        >,
+        user_data: *mut ::std::os::raw::c_void,
+    );
+    pub fn uws_res_end(
+        ssl: ::std::os::raw::c_int,
+        res: *mut UwsResT,
+        data: *const ::std::os::raw::c_char,
+        length: SizeT,
+        close_connection: bool,
+    );
+}
+
+pub struct AppResponse<const SSL: i32> {
+    native: *mut UwsResT,
+}
+pub struct AppRequest {
+    native: *mut UwsReqT,
+}
+impl AppRequest {
+    pub fn new(native: *mut UwsReqT) -> AppRequest {
+        AppRequest { native: native }
+    }
+}
+impl<const SSL: i32> AppResponse<SSL> {
+    pub fn new(native: *mut UwsResT) -> AppResponse<SSL> {
+        AppResponse::<SSL> { native: native }
+    }
+    fn end(self, message: &str) -> AppResponse<SSL> {
+        unsafe {
+            let c_message =
+                ::std::ffi::CString::new(message).expect("Failed to create message CString");
+            //This will now const fold :/ performance impact needs refactor
+            uws_res_end(
+                SSL,
+                self.native,
+                c_message.as_ptr(),
+                message.len().try_into().unwrap(),
+                false,
+            );
+        }
+        self
+    }
+}
+
+pub type UwsMethodHandler<const SSL: i32> = fn(res: AppResponse<SSL>, req: AppRequest);
+pub type UwsListenHandler =
+    fn(listen_socket: *mut ::std::os::raw::c_void, config: UwsAppListenConfigT);
+
+pub struct TemplateApp<const SSL: i32> {
+    native: *mut UwsAppT,
+}
+
+extern "C" fn uws_generic_listen_handler(
+    listen_socket: *mut ::std::os::raw::c_void,
+    config: UwsAppListenConfigT,
+    user_data: *mut ::std::os::raw::c_void,
+) {
+    unsafe {
+        let callback = &mut *(user_data as *mut UwsListenHandler);
+        callback(listen_socket, config);
+    }
+}
+
+extern "C" fn uws_generic_method_handler(
+    res: *mut UwsResT,
+    req: *mut UwsReqT,
+    user_data: *mut ::std::os::raw::c_void,
+) {
+    unsafe {
+        let response = AppResponse::<0>::new(res);
+        let request = AppRequest::new(req);
+        let callback = &mut *(user_data as *mut UwsMethodHandler<0>);
+        callback(response, request);
+    }
+}
+extern "C" fn uws_ssl_generic_method_handler(
+    res: *mut UwsResT,
+    req: *mut UwsReqT,
+    user_data: *mut ::std::os::raw::c_void,
+) {
+    unsafe {
+        let response = AppResponse::<1>::new(res);
+        let request = AppRequest::new(req);
+        let callback = &mut *(user_data as *mut UwsMethodHandler<1>);
+        callback(response, request);
+    }
+}
+
+impl<const SSL: i32> TemplateApp<SSL> {
+    pub fn new(config: UsSocketContextOptions) -> TemplateApp<SSL> {
+        unsafe {
+            let key_file_name_s =
+                CString::new(config.key_file_name).expect("Failed to create key_file_name CString");
+            let cert_file_name_s = CString::new(config.cert_file_name)
+                .expect("Failed to create cert_file_name CString");
+            let passphrase_s =
+                CString::new(config.passphrase).expect("Failed to create passphrase CString");
+            let dh_params_file_name_s = CString::new(config.dh_params_file_name)
+                .expect("Failed to create dh_params_file_name CString");
+            let ca_file_name_s =
+                CString::new(config.ca_file_name).expect("Failed to create ca_file_name CString");
+
+            let native_options = UsSocketContextOptionsT {
+                key_file_name: key_file_name_s.as_ptr(),
+                cert_file_name: cert_file_name_s.as_ptr(),
+                passphrase: passphrase_s.as_ptr(),
+                dh_params_file_name: dh_params_file_name_s.as_ptr(),
+                ca_file_name: ca_file_name_s.as_ptr(),
+                ssl_prefer_low_memory_usage: config.ssl_prefer_low_memory_usage,
+            };
+            TemplateApp::<SSL> {
+                native: uws_create_app(SSL, native_options),
+            }
+        }
+    }
+    pub fn get(self, route: &str, mut handler: UwsMethodHandler<SSL>) -> TemplateApp<SSL> {
+        unsafe {
+            let c_route = ::std::ffi::CString::new(route).expect("Failed to create route CString");
+            if SSL == 1 {
+                uws_app_get(
+                    SSL,
+                    self.native,
+                    c_route.as_ptr(),
+                    std::option::Option::Some(uws_ssl_generic_method_handler),
+                    &mut handler as *mut _ as *mut ::std::os::raw::c_void,
+                );
+            } else {
+                uws_app_get(
+                    SSL,
+                    self.native,
+                    c_route.as_ptr(),
+                    std::option::Option::Some(uws_generic_method_handler),
+                    &mut handler as *mut _ as *mut ::std::os::raw::c_void,
+                );
+            }
+        }
+        self
+    }
+
+    pub fn listen(self, port: i32, mut handler: UwsListenHandler) -> TemplateApp<SSL> {
+        unsafe {
+            uws_app_listen(
+                SSL,
+                self.native,
+                port,
+                ::std::option::Option::Some(uws_generic_listen_handler),
+                &mut handler as *mut _ as *mut ::std::os::raw::c_void,
+            );
+        }
+        self
+    }
+
+    pub fn run(self) -> TemplateApp<SSL> {
+        unsafe {
+            uws_app_run(SSL, self.native);
+        }
+        self
+    }
+}
+pub type App = TemplateApp<0>;
+pub type SSLApp = TemplateApp<1>;
+
+fn main() {
+    let config = UsSocketContextOptions {
+        key_file_name: "../misc/key.pem",
+        cert_file_name: "../misc/cert.pem",
+        passphrase: "1234",
+        ca_file_name: "",
+        dh_params_file_name: "",
+        ssl_prefer_low_memory_usage: 0,
+    };
+
+    SSLApp::new(config)
+        .get("/", |res, _req| {
+            res.end("Hello Rust!");
+        })
+        .listen(3000, |_listen_socket, config| {
+            println!("Listening on port https://127.0.0.1:{}", config.port);
+        })
+        .run();
+}

packages/bun-uws/capi/examples/ServerName.c

@@ -0,0 +1,59 @@
+#include "../libuwebsockets.h"
+#include <stdio.h>
+#include <string.h>
+#define SSL 1
+
+
+struct us_listen_socket_t *globalListenSocket;
+uws_app_t *app;
+void get_handler(uws_res_t *res, uws_req_t *req, void* user_data)
+{
+	
+    uws_res_end(SSL, res, "Hello CAPI!", 11, false);
+}
+
+void exit_handler(uws_res_t *res, uws_req_t *req, void* user_data)
+{
+	uws_res_end(SSL, res, "Shutting down!",14, false);
+    /* We use this to check graceful closedown */
+    us_listen_socket_close(false, globalListenSocket);
+}
+
+void missing_server_name_handler(const char *hostname,  void* user_data){
+	printf("We are missing server name: <%s>\n", hostname);
+	
+	/* Assume it is localhost, so add it */
+	uws_add_server_name(SSL, app, "localhost");
+}
+
+void listen_handler(struct us_listen_socket_t *listen_socket, uws_app_listen_config_t config, void* user_data)
+{
+    if (listen_socket){
+        printf("Listening on port https://localhost:%d\n", config.port);
+		globalListenSocket = listen_socket;
+    }else{
+		printf("Failed to listen on port https://localhost:%d\n", config.port);
+	}
+	
+}
+
+int main()
+{
+  	/* Overly simple hello world app (SNI)*/
+
+    app = uws_create_app(SSL, (struct us_socket_context_options_t){
+        /* There are example certificates in uWebSockets.js repo */
+	    .key_file_name = "../misc/key.pem",
+	    .cert_file_name = "../misc/cert.pem",
+	    .passphrase = "1234"
+    });    
+	uws_missing_server_name(SSL, app, missing_server_name_handler, NULL);
+	uws_app_get(SSL, app, "/*", get_handler, NULL);
+	uws_app_get(SSL, app, "/exit", exit_handler, NULL);
+    uws_app_listen(SSL, app, 3000, listen_handler, NULL);
+    
+	/* Let's add a wildcard SNI to begin with */
+	uws_add_server_name(SSL, app, "*.google.*");
+
+	uws_app_run(SSL, app);
+}

packages/bun-uws/capi/examples/UpgradeAsync.c

@@ -0,0 +1,255 @@
+#include "../libuwebsockets.h"
+#include "libusockets.h"
+#include <stdio.h>
+#include <malloc.h>
+#include <string.h>
+/* This is a simple WebSocket "sync" upgrade example.
+ * You may compile it with "WITH_OPENSSL=1 make" or with "make" */
+
+#define SSL 1
+
+typedef struct
+{
+    char *value;
+    size_t length;
+} header_t;
+struct PerSocketData
+{
+    /* Define your user data */
+    int something;
+};
+
+struct UpgradeData
+{
+    header_t *secWebSocketKey;
+    header_t *secWebSocketProtocol;
+    header_t *secWebSocketExtensions;
+    uws_socket_context_t *context;
+    uws_res_t *response;
+    bool aborted;
+};
+
+header_t *create_header(size_t length, const char* value)
+{
+    header_t *header = (header_t *)malloc(sizeof(header_t));
+    if(length > 0){
+        header->value = (char *)calloc(sizeof(char), length);
+        header->length = length;
+        memcpy(header->value, value, length);
+    }else{
+        header->value = NULL;
+        header->length = 0;
+    }
+    return header;
+}
+void free_header(header_t *header)
+{
+
+    free(header->value);
+    free(header);
+}
+void listen_handler(struct us_listen_socket_t *listen_socket, uws_app_listen_config_t config, void *user_data)
+{
+    if (listen_socket)
+    {
+        printf("Listening on port wss://localhost:%d\n", config.port);
+    }
+}
+//Timer close helper
+void uws_timer_close(struct us_timer_t *timer)
+{
+    struct us_timer_t *t = (struct us_timer_t *)timer;
+    struct timer_handler_data *data;
+    memcpy(&data, us_timer_ext(t), sizeof(struct timer_handler_data *));
+    free(data);
+    us_timer_close(t, 0);
+}
+//Timer create helper
+struct us_timer_t *uws_create_timer(int ms, int repeat_ms, void (*handler)(void *data), void *data)
+{
+    struct us_loop_t *loop = uws_get_loop();
+    struct us_timer_t *delayTimer = us_create_timer(loop, 0, sizeof(void *));
+
+    struct timer_handler_data
+    {
+        void *data;
+        void (*handler)(void *data);
+        bool repeat;
+    };
+
+    struct timer_handler_data *timer_data = (struct timer_handler_data *)malloc(sizeof(timer_handler_data));
+    timer_data->data = data;
+    timer_data->handler = handler;
+    timer_data->repeat = repeat_ms > 0;
+    memcpy(us_timer_ext(delayTimer), &timer_data, sizeof(struct timer_handler_data *));
+
+    us_timer_set(
+        delayTimer, [](struct us_timer_t *t)
+        {
+            /* We wrote the pointer to the timer's extension */
+            struct timer_handler_data *data;
+            memcpy(&data, us_timer_ext(t), sizeof(struct timer_handler_data *));
+
+            data->handler(data->data);
+
+            if (!data->repeat)
+            {
+                free(data);
+                us_timer_close(t, 0);
+            }
+        },
+        ms, repeat_ms);
+
+    return (struct us_timer_t *)delayTimer;
+}
+void on_timer_done(void *data)
+{
+
+    struct UpgradeData *upgrade_data = (struct UpgradeData *)data;
+
+    /* Were'nt we aborted before our async task finished? Okay, upgrade then! */
+    if (!upgrade_data->aborted)
+    {
+        struct PerSocketData *socket_data = (struct PerSocketData *)malloc(sizeof(struct PerSocketData));
+        socket_data->something = 15;
+        printf("Async task done, upgrading to WebSocket now!\n");
+
+        uws_res_upgrade(SSL, 
+                        upgrade_data->response,
+                        (void *)socket_data,
+                        upgrade_data->secWebSocketKey->value,
+                        upgrade_data->secWebSocketKey->length,
+                        upgrade_data->secWebSocketProtocol->value,
+                        upgrade_data->secWebSocketProtocol->length,
+                        upgrade_data->secWebSocketExtensions->value,
+                        upgrade_data->secWebSocketExtensions->length,
+                        upgrade_data->context);
+    }
+    else
+    {
+        printf("Async task done, but the HTTP socket was closed. Skipping upgrade to WebSocket!\n");
+    }
+    free_header(upgrade_data->secWebSocketKey);
+    free_header(upgrade_data->secWebSocketProtocol);
+    free_header(upgrade_data->secWebSocketExtensions);
+    free(upgrade_data);
+}
+
+void on_res_aborted(uws_res_t *response, void *data)
+{
+    struct UpgradeData *upgrade_data = (struct UpgradeData *)data;
+    /* We don't implement any kind of cancellation here,
+     * so simply flag us as aborted */
+    upgrade_data->aborted = true;
+}
+void upgrade_handler(uws_res_t *response, uws_req_t *request, uws_socket_context_t *context)
+{
+
+    /* HttpRequest (req) is only valid in this very callback, so we must COPY the headers
+     * we need later on while upgrading to WebSocket. You must not access req after first return.
+     * Here we create a heap allocated struct holding everything we will need later on. */
+
+    struct UpgradeData *data = (struct UpgradeData *)malloc(sizeof(struct UpgradeData));
+    data->aborted = false;
+    data->context = context;
+    data->response = response;
+    
+    const char *ws_key = NULL;
+    const char *ws_protocol = NULL;
+    const char *ws_extensions = NULL;
+    
+    size_t ws_key_length = uws_req_get_header(request, "sec-websocket-key", 17, &ws_key);
+    size_t ws_protocol_length = uws_req_get_header(request, "sec-websocket-protocol", 22, &ws_protocol);
+    size_t ws_extensions_length = uws_req_get_header(request, "sec-websocket-extensions", 24, &ws_extensions);
+
+    
+    data->secWebSocketKey = create_header(ws_key_length, ws_key);
+    data->secWebSocketProtocol = create_header(ws_protocol_length, ws_protocol);
+    data->secWebSocketExtensions = create_header(ws_extensions_length, ws_extensions);
+
+    /* We have to attach an abort handler for us to be aware
+     * of disconnections while we perform async tasks */
+
+    uws_res_on_aborted(SSL, response, on_res_aborted, data);
+
+    /* Simulate checking auth for 5 seconds. This looks like crap, never write
+    * code that utilize us_timer_t like this; they are high-cost and should
+    * not be created and destroyed more than rarely!
+    * Either way, here we go!*/
+    uws_create_timer(5000, 0, on_timer_done, data);
+}
+
+void open_handler(uws_websocket_t *ws)
+{
+
+    /* Open event here, you may access uws_ws_get_user_data(ws) which points to a PerSocketData struct.
+    * Here we simply validate that indeed, something == 15 as set in upgrade handler. */
+
+    struct PerSocketData *data = (struct PerSocketData *)uws_ws_get_user_data(SSL, ws);
+    data->something = 15;
+    printf("Something is: %d\n", data->something);
+}
+
+void message_handler(uws_websocket_t *ws, const char *message, size_t length, uws_opcode_t opcode)
+{
+
+    /* We simply echo whatever data we get */
+    uws_ws_send(SSL, ws, message, length, opcode);
+}
+
+void close_handler(uws_websocket_t *ws, int code, const char *message, size_t length)
+{
+
+    /* You may access uws_ws_get_user_data(ws) here, but sending or
+     * doing any kind of I/O with the socket is not valid. */
+    struct PerSocketData *data = (struct PerSocketData *)uws_ws_get_user_data(SSL, ws);
+    if (data)
+    {
+        free(data);
+    }
+}
+
+void drain_handler(uws_websocket_t *ws)
+{
+    /* Check uws_ws_get_buffered_amount(ws) here */
+}
+
+void ping_handler(uws_websocket_t *ws, const char *message, size_t length)
+{
+    /* You don't need to handle this one, we automatically respond to pings as per standard */
+}
+
+void pong_handler(uws_websocket_t *ws, const char *message, size_t length)
+{
+
+    /* You don't need to handle this one either */
+}
+
+int main()
+{
+
+    uws_app_t *app = uws_create_app(SSL, (struct us_socket_context_options_t){
+        /* There are example certificates in uWebSockets.js repo */
+	    .key_file_name = "../misc/key.pem",
+	    .cert_file_name = "../misc/cert.pem",
+	    .passphrase = "1234"
+    });
+
+    uws_ws(SSL, app, "/*", (uws_socket_behavior_t){
+                          .compression = uws_compress_options_t::SHARED_COMPRESSOR,
+                          .maxPayloadLength = 16 * 1024,
+                          .idleTimeout = 12,
+                          .maxBackpressure = 1 * 1024 * 1024,
+                          .upgrade = upgrade_handler,
+                          .open = open_handler,
+                          .message = message_handler,
+                          .drain = drain_handler,
+                          .ping = ping_handler,
+                          .pong = pong_handler,
+                          .close = close_handler,
+                      });
+
+    uws_app_listen(SSL, app, 9001, listen_handler, NULL);
+
+    uws_app_run(SSL, app);
+}

packages/bun-uws/capi/examples/UpgradeSync.c

@@ -0,0 +1,117 @@
+#include "../libuwebsockets.h"
+#include <stdio.h>
+#include <malloc.h>
+
+#define SSL 1
+
+/* This is a simple WebSocket "sync" upgrade example.
+ * You may compile it with "WITH_OPENSSL=1 make" or with "make" */
+
+/* uws_ws_get_user_data(ws) returns one of these */
+
+struct PerSocketData
+{
+    /* Define your user data */
+    int something;
+};
+
+void listen_handler(struct us_listen_socket_t *listen_socket, uws_app_listen_config_t config, void *user_data)
+{
+    if (listen_socket)
+    {
+        printf("Listening on port wss://localhost:%d\n", config.port);
+    }
+}
+
+void upgrade_handler(uws_res_t *response, uws_req_t *request, uws_socket_context_t *context)
+{
+
+    /* You may read from req only here, and COPY whatever you need into your PerSocketData.
+     * PerSocketData is valid from .open to .close event, accessed with uws_ws_get_user_data(ws).
+     * HttpRequest (req) is ONLY valid in this very callback, so any data you will need later
+     * has to be COPIED into PerSocketData here. */
+
+    /* Immediately upgrading without doing anything "async" before, is simple */
+
+    struct PerSocketData *data = (struct PerSocketData *)malloc(sizeof(struct PerSocketData));
+    data->something = 15;
+
+    const char *ws_key = NULL;
+    const char *ws_protocol = NULL;
+    const char *ws_extensions = NULL;
+    
+    size_t ws_key_length = uws_req_get_header(request, "sec-websocket-key", 17, &ws_key);
+    size_t ws_protocol_length = uws_req_get_header(request, "sec-websocket-protocol", 22, &ws_protocol);
+    size_t ws_extensions_length = uws_req_get_header(request, "sec-websocket-extensions", 24, &ws_extensions);
+
+    uws_res_upgrade(SSL,
+                    response,
+                    (void *)data,
+                    ws_key,
+                    ws_key_length,
+                    ws_protocol,
+                    ws_protocol_length,
+                    ws_extensions,
+                    ws_extensions_length,
+                    context);
+}
+
+void open_handler(uws_websocket_t *ws)
+{
+
+    /* Open event here, you may access uws_ws_get_user_data(ws) which points to a PerSocketData struct.
+    * Here we simply validate that indeed, something == 15 as set in upgrade handler. */
+
+    struct PerSocketData *data = (struct PerSocketData *)uws_ws_get_user_data(SSL, ws);
+    data->something = 15;
+    printf("Something is: %d\n", data->something);
+}
+
+void message_handler(uws_websocket_t *ws, const char *message, size_t length, uws_opcode_t opcode)
+{
+    /* We simply echo whatever data we get */
+    uws_ws_send(SSL, ws, message, length, opcode);
+}
+
+void close_handler(uws_websocket_t *ws, int code, const char *message, size_t length)
+{
+
+    /* You may access uws_ws_get_user_data(ws) here, but sending or
+     * doing any kind of I/O with the socket is not valid. */
+    struct PerSocketData *data = (struct PerSocketData *)uws_ws_get_user_data(SSL, ws);
+    if (data)
+        free(data);
+}
+
+void drain_handler(uws_websocket_t *ws)
+{
+    /* Check uws_ws_get_buffered_amount(ws) here */
+}
+
+void ping_handler(uws_websocket_t *ws, const char *message, size_t length)
+{
+    /* You don't need to handle this one, we automatically respond to pings as per standard */
+}
+
+void pong_handler(uws_websocket_t *ws, const char *message, size_t length)
+{
+
+    /* You don't need to handle this one either */
+}
+
+int main()
+{
+
+    uws_app_t *app = uws_create_app(SSL, (struct us_socket_context_options_t){
+        /* There are example certificates in uWebSockets.js repo */
+	    .key_file_name = "../misc/key.pem",
+	    .cert_file_name = "../misc/cert.pem",
+	    .passphrase = "1234"
+    });
+
+    uws_ws(SSL, app, "/*", (uws_socket_behavior_t){.compression = uws_compress_options_t::SHARED_COMPRESSOR, .maxPayloadLength = 16 * 1024, .idleTimeout = 12, .maxBackpressure = 1 * 1024 * 1024, .upgrade = upgrade_handler, .open = open_handler, .message = message_handler, .drain = drain_handler, .ping = ping_handler, .pong = pong_handler, .close = close_handler});
+
+    uws_app_listen(SSL, app, 9001, listen_handler, NULL);
+
+    uws_app_run(SSL, app);
+}

packages/bun-uws/capi/libuwebsockets.h

@@ -0,0 +1,260 @@
+/*
+ * Copyright 2022 Ciro Spaciari
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+// clang-format off
+#ifndef LIBUWS_CAPI_HEADER
+#define LIBUWS_CAPI_HEADER
+
+#include <stddef.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include "libusockets.h"
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+#ifdef _WIN32
+#  define DLL_EXPORT __declspec( dllexport )
+#else
+#  define DLL_EXPORT
+#endif
+
+    DLL_EXPORT typedef enum
+    {
+        /* These are not actual compression options */
+        _COMPRESSOR_MASK = 0x00FF,
+        _DECOMPRESSOR_MASK = 0x0F00,
+        /* Disabled, shared, shared are "special" values */
+        DISABLED = 0,
+        SHARED_COMPRESSOR = 1,
+        SHARED_DECOMPRESSOR = 1 << 8,
+        /* Highest 4 bits describe decompressor */
+        DEDICATED_DECOMPRESSOR_32KB = 15 << 8,
+        DEDICATED_DECOMPRESSOR_16KB = 14 << 8,
+        DEDICATED_DECOMPRESSOR_8KB = 13 << 8,
+        DEDICATED_DECOMPRESSOR_4KB = 12 << 8,
+        DEDICATED_DECOMPRESSOR_2KB = 11 << 8,
+        DEDICATED_DECOMPRESSOR_1KB = 10 << 8,
+        DEDICATED_DECOMPRESSOR_512B = 9 << 8,
+        /* Same as 32kb */
+        DEDICATED_DECOMPRESSOR = 15 << 8,
+
+        /* Lowest 8 bit describe compressor */
+        DEDICATED_COMPRESSOR_3KB = 9 << 4 | 1,
+        DEDICATED_COMPRESSOR_4KB = 9 << 4 | 2,
+        DEDICATED_COMPRESSOR_8KB = 10 << 4 | 3,
+        DEDICATED_COMPRESSOR_16KB = 11 << 4 | 4,
+        DEDICATED_COMPRESSOR_32KB = 12 << 4 | 5,
+        DEDICATED_COMPRESSOR_64KB = 13 << 4 | 6,
+        DEDICATED_COMPRESSOR_128KB = 14 << 4 | 7,
+        DEDICATED_COMPRESSOR_256KB = 15 << 4 | 8,
+        /* Same as 256kb */
+        DEDICATED_COMPRESSOR = 15 << 4 | 8
+    } uws_compress_options_t;
+
+    DLL_EXPORT typedef enum
+    {
+        CONTINUATION = 0,
+        TEXT = 1,
+        BINARY = 2,
+        CLOSE = 8,
+        PING = 9,
+        PONG = 10
+    } uws_opcode_t;
+
+    DLL_EXPORT typedef enum
+    {
+        BACKPRESSURE,
+        SUCCESS,
+        DROPPED
+    } uws_sendstatus_t;
+
+    DLL_EXPORT typedef struct
+    {
+
+        int port;
+        const char *host;
+        int options;
+    } uws_app_listen_config_t;
+
+    DLL_EXPORT typedef struct {
+        bool ok;
+        bool has_responded;
+    } uws_try_end_result_t;
+
+    DLL_EXPORT struct uws_app_s;
+    DLL_EXPORT struct uws_req_s;
+    DLL_EXPORT struct uws_res_s;
+    DLL_EXPORT struct uws_websocket_s;
+    DLL_EXPORT struct uws_header_iterator_s;
+    DLL_EXPORT typedef struct uws_app_s uws_app_t;
+    DLL_EXPORT typedef struct uws_req_s uws_req_t;
+    DLL_EXPORT typedef struct uws_res_s uws_res_t;
+    DLL_EXPORT typedef struct uws_socket_context_s uws_socket_context_t;
+    DLL_EXPORT typedef struct uws_websocket_s uws_websocket_t;
+
+    DLL_EXPORT typedef void (*uws_websocket_handler)(uws_websocket_t *ws, void* user_data);
+    DLL_EXPORT typedef void (*uws_websocket_message_handler)(uws_websocket_t *ws, const char *message, size_t length, uws_opcode_t opcode, void* user_data);
+    DLL_EXPORT typedef void (*uws_websocket_ping_pong_handler)(uws_websocket_t *ws, const char *message, size_t length, void* user_data);
+    DLL_EXPORT typedef void (*uws_websocket_close_handler)(uws_websocket_t *ws, int code, const char *message, size_t length, void* user_data);
+    DLL_EXPORT typedef void (*uws_websocket_upgrade_handler)(uws_res_t *response, uws_req_t *request, uws_socket_context_t *context, void* user_data);
+    DLL_EXPORT typedef void (*uws_websocket_subscription_handler)(uws_websocket_t *ws, const char *topic_name, size_t topic_name_length, int new_number_of_subscriber, int old_number_of_subscriber, void* user_data);
+
+    DLL_EXPORT typedef struct
+    {
+        uws_compress_options_t compression;
+        /* Maximum message size we can receive */
+        unsigned int maxPayloadLength;
+        /* 2 minutes timeout is good */
+        unsigned short idleTimeout;
+        /* 64kb backpressure is probably good */
+        unsigned int maxBackpressure;
+        bool closeOnBackpressureLimit;
+        /* This one depends on kernel timeouts and is a bad default */
+        bool resetIdleTimeoutOnSend;
+        /* A good default, esp. for newcomers */
+        bool sendPingsAutomatically;
+        /* Maximum socket lifetime in seconds before forced closure (defaults to disabled) */
+        unsigned short maxLifetime;
+        uws_websocket_upgrade_handler upgrade;
+        uws_websocket_handler open;
+        uws_websocket_message_handler message;
+        uws_websocket_handler drain;
+        uws_websocket_ping_pong_handler ping;
+        uws_websocket_ping_pong_handler pong;
+        uws_websocket_close_handler close;
+        uws_websocket_subscription_handler subscription;
+    } uws_socket_behavior_t;
+
+    DLL_EXPORT typedef void (*uws_listen_handler)(struct us_listen_socket_t *listen_socket, uws_app_listen_config_t config, void *user_data);
+    DLL_EXPORT typedef void (*uws_listen_domain_handler)(struct us_listen_socket_t *listen_socket, const char* domain, size_t domain_length, int options, void *user_data);
+    DLL_EXPORT typedef void (*uws_method_handler)(uws_res_t *response, uws_req_t *request, void *user_data);
+    DLL_EXPORT typedef void (*uws_filter_handler)(uws_res_t *response, int, void *user_data);
+    DLL_EXPORT typedef void (*uws_missing_server_handler)(const char *hostname, size_t hostname_length, void *user_data);
+    DLL_EXPORT typedef void (*uws_get_headers_server_handler)(const char *header_name, size_t header_name_size, const char *header_value, size_t header_value_size, void *user_data);
+    //Basic HTTP
+    DLL_EXPORT uws_app_t *uws_create_app(int ssl, struct us_bun_socket_context_options_t options);
+    DLL_EXPORT void uws_app_destroy(int ssl, uws_app_t *app);
+    DLL_EXPORT void uws_app_get(int ssl, uws_app_t *app, const char *pattern, uws_method_handler handler, void *user_data);
+    DLL_EXPORT void uws_app_post(int ssl, uws_app_t *app, const char *pattern, uws_method_handler handler, void *user_data);
+    DLL_EXPORT void uws_app_options(int ssl, uws_app_t *app, const char *pattern, uws_method_handler handler, void *user_data);
+    DLL_EXPORT void uws_app_delete(int ssl, uws_app_t *app, const char *pattern, uws_method_handler handler, void *user_data);
+    DLL_EXPORT void uws_app_patch(int ssl, uws_app_t *app, const char *pattern, uws_method_handler handler, void *user_data);
+    DLL_EXPORT void uws_app_put(int ssl, uws_app_t *app, const char *pattern, uws_method_handler handler, void *user_data);
+    DLL_EXPORT void uws_app_head(int ssl, uws_app_t *app, const char *pattern, uws_method_handler handler, void *user_data);
+    DLL_EXPORT void uws_app_connect(int ssl, uws_app_t *app, const char *pattern, uws_method_handler handler, void *user_data);
+    DLL_EXPORT void uws_app_trace(int ssl, uws_app_t *app, const char *pattern, uws_method_handler handler, void *user_data);
+    DLL_EXPORT void uws_app_any(int ssl, uws_app_t *app, const char *pattern, uws_method_handler handler, void *user_data);
+
+    DLL_EXPORT void uws_app_run(int ssl, uws_app_t *);
+
+    DLL_EXPORT void uws_app_listen(int ssl, uws_app_t *app, int port, uws_listen_handler handler, void *user_data);
+    DLL_EXPORT void uws_app_listen_with_config(int ssl, uws_app_t *app, uws_app_listen_config_t config, uws_listen_handler handler, void *user_data);
+    DLL_EXPORT void uws_app_listen_domain(int ssl, uws_app_t *app, const char *domain, size_t domain_length, uws_listen_domain_handler handler, void *user_data);
+    DLL_EXPORT void uws_app_listen_domain_with_options(int ssl, uws_app_t *app, const char *domain,size_t domain_length, int options, uws_listen_domain_handler handler, void *user_data);
+    DLL_EXPORT void uws_app_domain(int ssl, uws_app_t *app, const char* server_name, size_t server_name_length);
+
+    DLL_EXPORT bool uws_constructor_failed(int ssl, uws_app_t *app);
+    DLL_EXPORT unsigned int uws_num_subscribers(int ssl, uws_app_t *app, const char *topic, size_t topic_length);
+    DLL_EXPORT bool uws_publish(int ssl, uws_app_t *app, const char *topic, size_t topic_length, const char *message, size_t message_length, uws_opcode_t opcode, bool compress);
+    DLL_EXPORT void *uws_get_native_handle(int ssl, uws_app_t *app);
+    DLL_EXPORT void uws_remove_server_name(int ssl, uws_app_t *app, const char *hostname_pattern, size_t hostname_pattern_length);
+    DLL_EXPORT void uws_add_server_name(int ssl, uws_app_t *app, const char *hostname_pattern, size_t hostname_pattern_length);
+    DLL_EXPORT void uws_add_server_name_with_options(int ssl, uws_app_t *app, const char *hostname_pattern, size_t hostname_pattern_length, struct us_bun_socket_context_options_t options);
+    DLL_EXPORT void uws_missing_server_name(int ssl, uws_app_t *app, uws_missing_server_handler handler, void *user_data);
+    DLL_EXPORT void uws_filter(int ssl, uws_app_t *app, uws_filter_handler handler, void *user_data);
+
+    //WebSocket
+    DLL_EXPORT void uws_ws(int ssl, uws_app_t *app, const char *pattern, uws_socket_behavior_t behavior, void* user_data);
+    DLL_EXPORT void *uws_ws_get_user_data(int ssl, uws_websocket_t *ws);
+    DLL_EXPORT void uws_ws_close(int ssl, uws_websocket_t *ws);
+    DLL_EXPORT uws_sendstatus_t uws_ws_send(int ssl, uws_websocket_t *ws, const char *message, size_t length, uws_opcode_t opcode);
+    DLL_EXPORT uws_sendstatus_t uws_ws_send_with_options(int ssl, uws_websocket_t *ws, const char *message, size_t length, uws_opcode_t opcode, bool compress, bool fin);
+    DLL_EXPORT uws_sendstatus_t uws_ws_send_fragment(int ssl, uws_websocket_t *ws, const char *message, size_t length, bool compress);
+    DLL_EXPORT uws_sendstatus_t uws_ws_send_first_fragment(int ssl, uws_websocket_t *ws, const char *message, size_t length, bool compress);
+    DLL_EXPORT uws_sendstatus_t uws_ws_send_first_fragment_with_opcode(int ssl, uws_websocket_t *ws, const char *message, size_t length, uws_opcode_t opcode, bool compress);
+    DLL_EXPORT uws_sendstatus_t uws_ws_send_last_fragment(int ssl, uws_websocket_t *ws, const char *message, size_t length, bool compress);
+    DLL_EXPORT void uws_ws_end(int ssl, uws_websocket_t *ws, int code, const char *message, size_t length);
+    DLL_EXPORT void uws_ws_cork(int ssl, uws_websocket_t *ws, void (*handler)(void *user_data), void *user_data);
+
+    DLL_EXPORT bool uws_ws_subscribe(int ssl, uws_websocket_t *ws, const char *topic, size_t length);
+    DLL_EXPORT bool uws_ws_unsubscribe(int ssl, uws_websocket_t *ws, const char *topic, size_t length);
+    DLL_EXPORT bool uws_ws_is_subscribed(int ssl, uws_websocket_t *ws, const char *topic, size_t length);
+    DLL_EXPORT void uws_ws_iterate_topics(int ssl, uws_websocket_t *ws, void (*callback)(const char *topic, size_t length, void *user_data), void *user_data);
+    DLL_EXPORT bool uws_ws_publish(int ssl, uws_websocket_t *ws, const char *topic, size_t topic_length, const char *message, size_t message_length);
+    DLL_EXPORT bool uws_ws_publish_with_options(int ssl, uws_websocket_t *ws, const char *topic, size_t topic_length, const char *message, size_t message_length, uws_opcode_t opcode, bool compress);
+    DLL_EXPORT unsigned int uws_ws_get_buffered_amount(int ssl, uws_websocket_t *ws);
+    DLL_EXPORT size_t uws_ws_get_remote_address(int ssl, uws_websocket_t *ws, const char **dest);
+    DLL_EXPORT size_t uws_ws_get_remote_address_as_text(int ssl, uws_websocket_t *ws, const char **dest);
+    DLL_EXPORT void uws_res_get_remote_address_info(uws_res_t *res, const char **dest, size_t *length, unsigned int *port);
+
+    //Response
+    DLL_EXPORT void uws_res_end(int ssl, uws_res_t *res, const char *data, size_t length, bool close_connection);
+    DLL_EXPORT uws_try_end_result_t uws_res_try_end(int ssl, uws_res_t *res, const char *data, size_t length, uint64_t total_size, bool close_connection);
+    DLL_EXPORT void uws_res_cork(int ssl, uws_res_t *res, void(*callback)(uws_res_t *res, void* user_data) ,void* user_data);
+    DLL_EXPORT void uws_res_pause(int ssl, uws_res_t *res);
+    DLL_EXPORT void uws_res_resume(int ssl, uws_res_t *res);
+    DLL_EXPORT void uws_res_write_continue(int ssl, uws_res_t *res);
+    DLL_EXPORT void uws_res_write_status(int ssl, uws_res_t *res, const char *status, size_t length);
+    DLL_EXPORT void uws_res_write_header(int ssl, uws_res_t *res, const char *key, size_t key_length, const char *value, size_t value_length);
+
+    DLL_EXPORT void uws_res_write_header_int(int ssl, uws_res_t *res, const char *key, size_t key_length, uint64_t value);
+    DLL_EXPORT void uws_res_end_without_body(int ssl, uws_res_t *res, bool close_connection);
+    DLL_EXPORT bool uws_res_write(int ssl, uws_res_t *res, const char *data, size_t length);
+    DLL_EXPORT uint64_t uws_res_get_write_offset(int ssl, uws_res_t *res);
+    DLL_EXPORT void uws_res_override_write_offset(int ssl, uws_res_t *res, uint64_t offset);
+    DLL_EXPORT bool uws_res_has_responded(int ssl, uws_res_t *res);
+    DLL_EXPORT void uws_res_on_writable(int ssl, uws_res_t *res, bool (*handler)(uws_res_t *res, uint64_t, void *optional_data), void *user_data);
+    DLL_EXPORT void uws_res_on_aborted(int ssl, uws_res_t *res, void (*handler)(uws_res_t *res, void *optional_data), void *optional_data);
+    DLL_EXPORT void uws_res_on_data(int ssl, uws_res_t *res, void (*handler)(uws_res_t *res, const char *chunk, size_t chunk_length, bool is_end, void *optional_data), void *optional_data);
+    DLL_EXPORT void uws_res_upgrade(int ssl, uws_res_t *res, void *data, const char *sec_web_socket_key, size_t sec_web_socket_key_length, const char *sec_web_socket_protocol, size_t sec_web_socket_protocol_length, const char *sec_web_socket_extensions, size_t sec_web_socket_extensions_length, uws_socket_context_t *ws);
+    DLL_EXPORT size_t uws_res_get_remote_address(int ssl, uws_res_t *res, const char **dest);
+    DLL_EXPORT size_t uws_res_get_remote_address_as_text(int ssl, uws_res_t *res, const char **dest);
+#ifdef UWS_WITH_PROXY
+    DLL_EXPORT size_t uws_res_get_proxied_remote_address(int ssl, uws_res_t *res, const char **dest);
+    DLL_EXPORT size_t uws_res_get_proxied_remote_address_as_text(int ssl, uws_res_t *res, const char **dest);
+#endif
+    DLL_EXPORT void *uws_res_get_native_handle(int ssl, uws_res_t *res);
+
+    //Request
+    DLL_EXPORT bool uws_req_is_ancient(uws_req_t *res);
+    DLL_EXPORT bool uws_req_get_yield(uws_req_t *res);
+    DLL_EXPORT void uws_req_set_yield(uws_req_t *res, bool yield);
+    DLL_EXPORT size_t uws_req_get_url(uws_req_t *res, const char **dest);
+    DLL_EXPORT size_t uws_req_get_full_url(uws_req_t *res, const char **dest);
+    DLL_EXPORT size_t uws_req_get_method(uws_req_t *res, const char **dest);
+    DLL_EXPORT size_t uws_req_get_case_sensitive_method(uws_req_t *res, const char **dest);
+
+    DLL_EXPORT size_t uws_req_get_header(uws_req_t *res, const char *lower_case_header, size_t lower_case_header_length, const char **dest);
+    DLL_EXPORT void uws_req_for_each_header(uws_req_t *res, uws_get_headers_server_handler handler, void *user_data);
+    DLL_EXPORT size_t uws_req_get_query(uws_req_t *res, const char *key, size_t key_length, const char **dest);
+    DLL_EXPORT size_t uws_req_get_parameter(uws_req_t *res, unsigned short index, const char **dest);
+
+    DLL_EXPORT struct us_loop_t *uws_get_loop();
+    DLL_EXPORT struct us_loop_t *uws_get_loop_with_native(void* existing_native_loop);
+    DLL_EXPORT void uws_loop_defer(struct us_loop_t *loop, void( cb(void *user_data) ), void *user_data);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

packages/bun-uws/src/HttpContext.h

@@ -124,7 +124,7 @@ private:
 
             /* Signal broken HTTP request only if we have a pending request */
             if (httpResponseData->onAborted) {
-                httpResponseData->onAborted((HttpResponse<SSL> *)s, httpResponseData->userData);
+                httpResponseData->onAborted();
             }
 
             /* Destruct socket ext */
@@ -258,7 +258,7 @@ private:
                     }
 
                     /* We might respond in the handler, so do not change timeout after this */
-                    httpResponseData->inStream(static_cast<HttpResponse<SSL>*>(user), data.data(), data.length(), fin, httpResponseData->userData);
+                    httpResponseData->inStream(data, fin);
 
                     /* Was the socket closed? */
                     if (us_socket_is_closed(SSL, (struct us_socket_t *) user)) {
@@ -366,7 +366,7 @@ private:
 
                 /* We expect the developer to return whether or not write was successful (true).
                  * If write was never called, the developer should still return true so that we may drain. */
-                bool success = httpResponseData->callOnWritable((HttpResponse<SSL> *)asyncSocket, httpResponseData->offset);
+                bool success = httpResponseData->callOnWritable(httpResponseData->offset);
 
                 /* The developer indicated that their onWritable failed. */
                 if (!success) {

packages/bun-uws/src/HttpResponse.h

@@ -558,11 +558,10 @@ public:
     }
 
     /* Attach handler for writable HTTP response */
-    HttpResponse *onWritable(void* userData, HttpResponseData<SSL>::OnWritableCallback handler) {
+    HttpResponse *onWritable(MoveOnlyFunction<bool(uint64_t)> &&handler) {
         HttpResponseData<SSL> *httpResponseData = getHttpResponseData();
 
-        httpResponseData->userData = userData;
-        httpResponseData->onWritable = handler;
+        httpResponseData->onWritable = std::move(handler);
         return this;
     }
 
@@ -575,11 +574,10 @@ public:
     }
 
     /* Attach handler for aborted HTTP request */
-    HttpResponse *onAborted(void* userData,  HttpResponseData<SSL>::OnAbortedCallback handler) {
+    HttpResponse *onAborted(MoveOnlyFunction<void()> &&handler) {
         HttpResponseData<SSL> *httpResponseData = getHttpResponseData();
-        
-        httpResponseData->userData = userData;
-        httpResponseData->onAborted = handler;
+
+        httpResponseData->onAborted = std::move(handler);
         return this;
     }
     HttpResponse* clearOnWritableAndAborted() {
@@ -596,10 +594,9 @@ public:
         return this;
     }
     /* Attach a read handler for data sent. Will be called with FIN set true if last segment. */
-    void onData(void* userData, HttpResponseData<SSL>::OnDataCallback handler) { 
+    void onData(MoveOnlyFunction<void(std::string_view, bool)> &&handler) {
         HttpResponseData<SSL> *data = getHttpResponseData();
-        data->userData = userData;
-        data->inStream = handler;
+        data->inStream = std::move(handler);
 
         /* Always reset this counter here */
         data->received_bytes_per_timeout = 0;

packages/bun-uws/src/HttpResponseData.h

@@ -33,10 +33,6 @@ struct HttpResponseData : AsyncSocketData<SSL>, HttpParser {
     template <bool> friend struct HttpResponse;
     template <bool> friend struct HttpContext;
     public:
-    using OnWritableCallback = bool (*)(uWS::HttpResponse<SSL>*, uint64_t, void*);
-    using OnAbortedCallback = void (*)(uWS::HttpResponse<SSL>*, void*);
-    using OnDataCallback = void (*)(uWS::HttpResponse<SSL>* response, const char* chunk, size_t chunk_length, bool, void*);
-
     /* When we are done with a response we mark it like so */
     void markDone() {
         onAborted = nullptr;
@@ -50,15 +46,15 @@ struct HttpResponseData : AsyncSocketData<SSL>, HttpParser {
     }
 
     /* Caller of onWritable. It is possible onWritable calls markDone so we need to borrow it. */
-    bool callOnWritable( uWS::HttpResponse<SSL>* response, uint64_t offset) {
+    bool callOnWritable(uint64_t offset) {
         /* Borrow real onWritable */
-        auto* borrowedOnWritable = std::move(onWritable);
+        MoveOnlyFunction<bool(uint64_t)> borrowedOnWritable = std::move(onWritable);
 
         /* Set onWritable to placeholder */
-        onWritable = [](uWS::HttpResponse<SSL>*, uint64_t, void*) {return true;};
+        onWritable = [](uint64_t) {return true;};
 
         /* Run borrowed onWritable */
-        bool ret = borrowedOnWritable(response, offset, userData);
+        bool ret = borrowedOnWritable(offset);
 
         /* If we still have onWritable (the placeholder) then move back the real one */
         if (onWritable) {
@@ -78,13 +74,10 @@ struct HttpResponseData : AsyncSocketData<SSL>, HttpParser {
         HTTP_CONNECTION_CLOSE = 16 // used
     };
 
-    /* Shared context pointer */
-    void* userData = nullptr;
-
     /* Per socket event handlers */
-    OnWritableCallback onWritable = nullptr;
-    OnAbortedCallback onAborted = nullptr;
-    OnDataCallback inStream = nullptr;
+    MoveOnlyFunction<bool(uint64_t)> onWritable;
+    MoveOnlyFunction<void()> onAborted;
+    MoveOnlyFunction<void(std::string_view, bool)> inStream; // onData
     /* Outgoing offset */
     uint64_t offset = 0;
 

scripts/all-dependencies.sh

@@ -36,11 +36,9 @@ fi
 dep() {
     local submodule="$1"
     local script="$2"
+    CACHE_KEY=
     if [ "$CACHE" == "1" ]; then
-        local hash="$(echo "$SUBMODULES" | grep "$submodule" | awk '{print $1}')"
-        local os="$(uname -s | tr '[:upper:]' '[:lower:]')"
-        local arch="$(uname -m)"
-        CACHE_KEY="$submodule/$hash-$os-$arch-$CPU_TARGET"
+        CACHE_KEY="$submodule/$(echo "$SUBMODULES" | grep "$submodule" | git hash-object --stdin)"
     fi
     if [ -z "$FORCE" ]; then
         HAS_ALL_DEPS=1

scripts/build-boringssl.ps1

@@ -3,7 +3,6 @@ $ErrorActionPreference = 'Stop'  # Setting strict mode, similar to 'set -euo pip
 
 Push-Location (Join-Path $BUN_DEPS_DIR 'boringssl')
 try {
-  Remove-Item -ErrorAction SilentlyContinue -Recurse -Force build
   Set-Location (mkdir -Force build)
   
   Run cmake @CMAKE_FLAGS ..

scripts/build-bun-cpp.ps1

@@ -1,29 +1,29 @@
+param (
+  [switch] $Baseline = $False,
+  [switch] $Fast = $False
+)
+
 $ErrorActionPreference = 'Stop'  # Setting strict mode, similar to 'set -euo pipefail' in bash
 
-.\scripts\env.ps1
+$Tag = If ($Baseline) { "-Baseline" } Else { "" }
+$UseBaselineBuild = If ($Baseline) { "ON" } Else { "OFF" }
+$UseLto = If ($Fast) { "OFF" } Else { "ON" }
+
+# $CANARY_REVISION = if (Test-Path build/.canary_revision) { Get-Content build/.canary_revision } else { "0" }
+$CANARY_REVISION = 0
+.\scripts\env.ps1 $Tag
 .\scripts\update-submodules.ps1
 .\scripts\build-libuv.ps1 -CloneOnly $True
-
-# libdeflate.h is needed otherwise the build fails
-git submodule update --init --recursive --progress --depth=1 --checkout src/deps/libdeflate
-
 cd build
-cmake .. @CMAKE_FLAGS `
-  -G Ninja `
-  -DCMAKE_BUILD_TYPE=Release `
+
+cmake .. -G Ninja -DCMAKE_BUILD_TYPE=Release `
   -DNO_CODEGEN=0 `
   -DNO_CONFIGURE_DEPENDS=1 `
-  -DBUN_CPP_ONLY=1
+  "-DUSE_BASELINE_BUILD=${UseBaselineBuild}" `
+  "-DUSE_LTO=${UseLto}" `
+  "-DCANARY=${CANARY_REVISION}" `
+  -DBUN_CPP_ONLY=1 $Flags
 if ($LASTEXITCODE -ne 0) { throw "CMake configuration failed" }
 
-.\compile-cpp-only.ps1 -v -j $env:CPUS
-if ($LASTEXITCODE -ne 0) { throw "C++ compilation failed" }
-
-# HACK: For some reason, the buildkite agent is hanging when uploading bun-cpp-objects.a
-# Best guess is that there is an issue when uploading files larger than 500 MB
-#
-# For now, use FileSplitter to split the file into smaller chunks:
-# https://www.powershellgallery.com/packages/FileSplitter/1.3
-if ($env:BUILDKITE) {
-  Split-File -Path (Resolve-Path "bun-cpp-objects.a") -PartSizeBytes "50MB" -Verbose
-}
+.\compile-cpp-only.ps1 -v
+if ($LASTEXITCODE -ne 0) { throw "C++ compilation failed" }

scripts/build-bun-cpp.sh

@@ -0,0 +1,48 @@
+#!/usr/bin/env bash
+set -exo pipefail
+source $(dirname -- "${BASH_SOURCE[0]}")/env.sh
+
+export USE_LTO="${USE_LTO:-ON}"
+case "$(uname -m)" in
+  aarch64|arm64)
+    export CPU_TARGET="${CPU_TARGET:-native}"
+    ;;
+  *)
+    export CPU_TARGET="${CPU_TARGET:-haswell}"
+    ;;
+esac
+
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --fast|--no-lto)
+      export USE_LTO="OFF"
+      shift
+      ;;
+    --baseline)
+      export CPU_TARGET="nehalem"
+      shift
+      ;;
+    --cpu)
+      export CPU_TARGET="$2"
+      shift
+      shift
+      ;;
+    *|-*|--*)
+      echo "Unknown option $1"
+      exit 1
+      ;;
+  esac
+done
+
+mkdir -p build
+cd build
+mkdir -p tmp_modules tmp_functions js codegen
+cmake .. \
+  -GNinja \
+  -DCMAKE_BUILD_TYPE=Release \
+  -DUSE_LTO=${USE_LTO} \
+  -DCPU_TARGET=${CPU_TARGET} \
+  -DBUN_CPP_ONLY=1 \
+  -DNO_CONFIGURE_DEPENDS=1
+chmod +x ./compile-cpp-only.sh
+bash ./compile-cpp-only.sh -v

scripts/build-bun-zig.sh

@@ -0,0 +1,95 @@
+#!/usr/bin/env bash
+set -exo pipefail
+source $(dirname -- "${BASH_SOURCE[0]}")/env.sh
+
+cwd=$(pwd)
+zig=
+
+if [[ "$CI" ]]; then
+  # Since the zig build depends on files from the zig submodule,
+  # make sure to update the submodule before building.
+  git submodule update --init --recursive --progress --depth=1 --checkout src/deps/zig
+
+  # Also update the correct version of zig in the submodule.
+  $(dirname -- "${BASH_SOURCE[0]}")/download-zig.sh
+fi
+
+if [ -f "$cwd/.cache/zig/zig" ]; then
+  zig="$cwd/.cache/zig/zig"
+else
+  zig=$(which zig)
+fi
+
+ZIG_OPTIMIZE="${ZIG_OPTIMIZE:-ReleaseFast}"
+CANARY="${CANARY:-0}"
+GIT_SHA="${GIT_SHA:-$(git rev-parse HEAD)}"
+
+BUILD_MACHINE_ARCH="${BUILD_MACHINE_ARCH:-$(uname -m)}"
+DOCKER_MACHINE_ARCH=""
+if [[ "$BUILD_MACHINE_ARCH" == "x86_64" || "$BUILD_MACHINE_ARCH" == "amd64" ]]; then
+  BUILD_MACHINE_ARCH="x86_64"
+  DOCKER_MACHINE_ARCH="amd64"
+elif [[ "$BUILD_MACHINE_ARCH" == "aarch64" || "$BUILD_MACHINE_ARCH" == "arm64" ]]; then
+  BUILD_MACHINE_ARCH="aarch64"
+  DOCKER_MACHINE_ARCH="arm64"
+fi
+
+TARGET_OS="${1:-linux}"
+TARGET_ARCH="${2:-x64}"
+TARGET_CPU="${3:-${CPU_TARGET:-native}}"
+
+BUILDARCH=""
+if [[ "$TARGET_ARCH" == "x64" || "$TARGET_ARCH" == "x86_64" || "$TARGET_ARCH" == "amd64" ]]; then
+  TARGET_ARCH="x86_64"
+  BUILDARCH="amd64"
+elif [[ "$TARGET_ARCH" == "aarch64" || "$TARGET_ARCH" == "arm64" ]]; then
+  TARGET_ARCH="aarch64"
+  BUILDARCH="arm64"
+fi
+
+TRIPLET=""
+if [[ "$TARGET_OS" == "linux" ]]; then
+  TRIPLET="$TARGET_ARCH-linux-gnu"
+elif [[ "$TARGET_OS" == "darwin" ]]; then
+  TRIPLET="$TARGET_ARCH-macos-none"
+elif [[ "$TARGET_OS" == "windows" ]]; then
+  TRIPLET="$TARGET_ARCH-windows-msvc"
+fi
+
+echo "--- Building identifier-cache"
+$zig run src/js_lexer/identifier_data.zig
+
+echo "--- Building node-fallbacks"
+cd src/node-fallbacks
+bun install --frozen-lockfile
+bun run build
+cd "$cwd"
+
+echo "--- Building codegen"
+bun install --frozen-lockfile
+make runtime_js fallback_decoder bun_error
+
+echo "--- Building modules"
+mkdir -p build
+bun run src/codegen/bundle-modules.ts --debug=OFF build
+
+echo "--- Building zig"
+cd build
+cmake .. \
+  -GNinja \
+  -DCMAKE_BUILD_TYPE=Release \
+  -DUSE_LTO=ON \
+  -DZIG_OPTIMIZE="${ZIG_OPTIMIZE}" \
+  -DGIT_SHA="${GIT_SHA}" \
+  -DARCH="${TARGET_ARCH}" \
+  -DBUILDARCH="${BUILDARCH}" \
+  -DCPU_TARGET="${TARGET_CPU}" \
+  -DZIG_TARGET="${TRIPLET}" \
+  -DASSERTIONS="OFF" \
+  -DWEBKIT_DIR="omit" \
+  -DNO_CONFIGURE_DEPENDS=1 \
+  -DNO_CODEGEN=1 \
+  -DBUN_ZIG_OBJ_DIR="$cwd/build" \
+  -DCANARY="$CANARY" \
+  -DZIG_LIB_DIR=src/deps/zig/lib
+ONLY_ZIG=1 ninja "$cwd/build/bun-zig.o" -v

scripts/build-mimalloc.ps1

@@ -3,7 +3,6 @@ $ErrorActionPreference = 'Stop'  # Setting strict mode, similar to 'set -euo pip
 
 Push-Location (Join-Path $BUN_DEPS_DIR 'mimalloc')
 try {
-  Remove-Item -ErrorAction SilentlyContinue -Recurse -Force build
   Set-Location (mkdir -Force build)
   
   Run cmake .. @CMAKE_FLAGS `

scripts/build-tinycc.ps1

@@ -20,6 +20,8 @@ try {
   Run clang-cl -DTCC_TARGET_PE -DTCC_TARGET_X86_64 config.h -DC2STR -o c2str.exe conftest.c
   Run .\c2str.exe .\include\tccdefs.h tccdefs_.h
 
+  $Baseline = $env:BUN_DEV_ENV_SET -eq "Baseline=True"
+
   Run clang-cl @($env:CFLAGS -split ' ') libtcc.c -o tcc.obj "-DTCC_TARGET_PE" "-DTCC_TARGET_X86_64" "-O2" "-W2" "-Zi" "-MD" "-GS-" "-c" "-MT"
   Run llvm-lib "tcc.obj" "-OUT:tcc.lib"
 

scripts/buildkite-link-bun.ps1

@@ -1,13 +1,17 @@
-param(
-  [switch]$Baseline = $false
+param (
+  [switch] $Baseline = $False,
+  [switch] $Fast = $False
 )
 
 $ErrorActionPreference = 'Stop'  # Setting strict mode, similar to 'set -euo pipefail' in bash
 
 $Target = If ($Baseline) { "windows-x64-baseline" } Else { "windows-x64" }
 $Tag = "bun-$Target"
+$TagSuffix = If ($Baseline) { "-Baseline" } Else { "" }
+$UseBaselineBuild = If ($Baseline) { "ON" } Else { "OFF" }
+$UseLto = If ($Fast) { "OFF" } Else { "ON" }
 
-.\scripts\env.ps1
+.\scripts\env.ps1 $TagSuffix
 
 mkdir -Force build
 buildkite-agent artifact download "**" build --step "${Target}-build-zig"
@@ -17,24 +21,29 @@ mv -Force -ErrorAction SilentlyContinue build\build\bun-deps\* build\bun-deps
 mv -Force -ErrorAction SilentlyContinue build\build\* build
 
 Set-Location build
-
-# HACK: See scripts/build-bun-cpp.ps1
-Join-File -Path "$(Resolve-Path .)\bun-cpp-objects.a" -Verbose -DeletePartFiles
-
-cmake .. @CMAKE_FLAGS `
-  -G Ninja `
-  -DCMAKE_BUILD_TYPE=Release `
+$CANARY_REVISION = 0
+cmake .. -G Ninja -DCMAKE_BUILD_TYPE=Release `
   -DNO_CODEGEN=1 `
   -DNO_CONFIGURE_DEPENDS=1 `
+  "-DCPU_TARGET=${CPU_TARGET}" `
+  "-DCANARY=${CANARY_REVISION}" `
   -DBUN_LINK_ONLY=1 `
+  "-DUSE_BASELINE_BUILD=${UseBaselineBuild}" `
+  "-DUSE_LTO=${UseLto}" `
   "-DBUN_DEPS_OUT_DIR=$(Resolve-Path bun-deps)" `
   "-DBUN_CPP_ARCHIVE=$(Resolve-Path bun-cpp-objects.a)" `
-  "-DBUN_ZIG_OBJ_DIR=$(Resolve-Path .)"
+  "-DBUN_ZIG_OBJ_DIR=$(Resolve-Path .)" `
+  "$Flags"
 if ($LASTEXITCODE -ne 0) { throw "CMake configuration failed" }
 
-ninja -v -j $env:CPUS
+ninja -v
 if ($LASTEXITCODE -ne 0) { throw "Link failed!" }
 
+ls
+if ($Fast) {
+  $Tag = "$Tag-nolto"
+}
+
 Set-Location ..
 $Dist = mkdir -Force "${Tag}"
 cp -r build\bun.exe "$Dist\bun.exe"

scripts/buildkite-link-bun.sh

@@ -0,0 +1,80 @@
+#!/usr/bin/env bash
+set -exo pipefail
+source $(dirname -- "${BASH_SOURCE[0]}")/env.sh
+
+export USE_LTO="${USE_LTO:-ON}"
+case "$(uname -m)" in
+  aarch64|arm64)
+    export CPU_TARGET="${CPU_TARGET:-native}"
+    ;;
+  *)
+    export CPU_TARGET="${CPU_TARGET:-haswell}"
+    ;;
+esac
+
+export TAG=""
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --tag)
+      export TAG="$2"
+      shift
+      shift
+      ;;
+    --fast|--no-lto)
+      export USE_LTO="OFF"
+      shift
+      ;;
+    --baseline)
+      export CPU_TARGET="nehalem"
+      shift
+      ;;
+    --cpu)
+      export CPU_TARGET="$2"
+      shift
+      shift
+      ;;
+    *|-*|--*)
+      echo "Unknown option $1"
+      exit 1
+      ;;
+  esac
+done
+
+if [[ -z "$TAG" ]]; then
+  echo "--tag <name> is required"
+  exit 1
+fi
+
+rm -rf release
+mkdir -p release
+buildkite-agent artifact download '**' release --step $TAG-build-deps
+buildkite-agent artifact download '**' release --step $TAG-build-zig
+buildkite-agent artifact download '**' release --step $TAG-build-cpp
+
+cd release
+cmake .. \
+  -GNinja \
+  -DCMAKE_BUILD_TYPE=Release \
+  -DCPU_TARGET=${CPU_TARGET} \
+  -DUSE_LTO=${USE_LTO} \
+  -DBUN_LINK_ONLY=1 \
+  -DBUN_ZIG_OBJ_DIR="$(pwd)/build" \
+  -DBUN_CPP_ARCHIVE="$(pwd)/build/bun-cpp-objects.a" \
+  -DBUN_DEPS_OUT_DIR="$(pwd)/build/bun-deps" \
+  -DNO_CONFIGURE_DEPENDS=1
+ninja -v
+
+if [[ "${USE_LTO}" == "OFF" ]]; then
+  TAG="${TAG}-nolto"
+fi
+
+chmod +x bun-profile bun
+mkdir -p bun-$TAG-profile/ bun-$TAG/
+mv bun-profile bun-$TAG-profile/bun-profile
+mv bun bun-$TAG/bun
+zip -r bun-$TAG-profile.zip bun-$TAG-profile
+zip -r bun-$TAG.zip bun-$TAG
+
+cd ..
+mv release/bun-$TAG.zip bun-$TAG.zip
+mv release/bun-$TAG-profile.zip bun-$TAG-profile.zip

scripts/env.ps1

@@ -1,3 +1,11 @@
+param(
+  [switch]$Baseline = $false
+)
+
+if ($ENV:BUN_DEV_ENV_SET -eq "Baseline=True") {
+  $Baseline = $true
+}
+
 $ErrorActionPreference = 'Stop' # Setting strict mode, similar to 'set -euo pipefail' in bash
 
 # this is the environment script for building bun's dependencies
@@ -30,19 +38,13 @@ if($Env:VSCMD_ARG_TGT_ARCH -eq "x86") {
   throw "Visual Studio environment is targetting 32 bit. This configuration is definetly a mistake."
 }
 
+$ENV:BUN_DEV_ENV_SET = "Baseline=$Baseline";
+
 $BUN_BASE_DIR = if ($env:BUN_BASE_DIR) { $env:BUN_BASE_DIR } else { Join-Path $ScriptDir '..' }
 $BUN_DEPS_DIR = if ($env:BUN_DEPS_DIR) { $env:BUN_DEPS_DIR } else { Join-Path $BUN_BASE_DIR 'src\deps' }
 $BUN_DEPS_OUT_DIR = if ($env:BUN_DEPS_OUT_DIR) { $env:BUN_DEPS_OUT_DIR } else { Join-Path $BUN_BASE_DIR 'build\bun-deps' }
 
 $CPUS = if ($env:CPUS) { $env:CPUS } else { (Get-CimInstance -Class Win32_Processor).NumberOfCores }
-$Lto = if ($env:USE_LTO) { $env:USE_LTO -eq "1" } else { True }
-$Baseline = if ($env:USE_BASELINE_BUILD) {
-  $env:USE_BASELINE_BUILD -eq "1"
-} elseif ($env:BUILDKITE_STEP_KEY -match "baseline") {
-  True
-} else {
-  False
-}
 
 $CC = "clang-cl"
 $CXX = "clang-cl"
@@ -50,7 +52,7 @@ $CXX = "clang-cl"
 $CFLAGS = '/O2 /Z7 /MT /O2 /Ob2 /DNDEBUG /U_DLL'
 $CXXFLAGS = '/O2 /Z7 /MT /O2 /Ob2 /DNDEBUG /U_DLL'
 
-if ($Lto) {
+if ($env:USE_LTO -eq "1") {
   $CXXFLAGS += " -fuse-ld=lld -flto -Xclang -emit-llvm-bc"
   $CFLAGS += " -fuse-ld=lld -flto -Xclang -emit-llvm-bc"
 }
@@ -61,14 +63,6 @@ $env:CPU_TARGET = $CPU_NAME
 $CFLAGS += " -march=${CPU_NAME}"
 $CXXFLAGS += " -march=${CPU_NAME}"
 
-$Canary = If ($env:CANARY) {
-  $env:CANARY
-} ElseIf ($env:BUILDKITE -eq "true") {
-  (buildkite-agent meta-data get canary)
-} Else {
-  "1"
-}
-
 $CMAKE_FLAGS = @(
   "-GNinja",
   "-DCMAKE_BUILD_TYPE=Release",
@@ -78,15 +72,15 @@ $CMAKE_FLAGS = @(
   "-DCMAKE_CXX_FLAGS=$CXXFLAGS",
   "-DCMAKE_C_FLAGS_RELEASE=$CFLAGS",
   "-DCMAKE_CXX_FLAGS_RELEASE=$CXXFLAGS",
-  "-DCMAKE_MSVC_RUNTIME_LIBRARY=MultiThreaded",
-  "-DCANARY=$Canary"
+  "-DCMAKE_MSVC_RUNTIME_LIBRARY=MultiThreaded"
 )
 
-if (Get-Command llvm-lib -ErrorAction SilentlyContinue) { 
-  $AR_CMD = Get-Command llvm-lib -ErrorAction SilentlyContinue
-  $AR = $AR_CMD.Path
-  $env:AR = $AR
-  $CMAKE_FLAGS += "-DCMAKE_AR=$AR"
+if ($env:USE_LTO -eq "1") {
+  if (Get-Command lld-lib -ErrorAction SilentlyContinue) { 
+    $AR = Get-Command lld-lib -ErrorAction SilentlyContinue
+    $env:AR = $AR
+    $CMAKE_FLAGS += "-DCMAKE_AR=$AR"
+  }
 }
 
 $env:CC = "clang-cl"
@@ -99,10 +93,6 @@ if ($Baseline) {
   $CMAKE_FLAGS += "-DUSE_BASELINE_BUILD=ON"
 }
 
-if ($Lto) {
-  $CMAKE_FLAGS += "-DUSE_LTO=ON"
-}
-
 if (Get-Command sccache -ErrorAction SilentlyContinue) {
   # Continue with local compiler if sccache has an error
   $env:SCCACHE_IGNORE_SERVER_IO_ERROR = "1"

scripts/env.sh

@@ -1,6 +1,6 @@
 #!/usr/bin/env bash
 
-# Hack for buildkite sometimes not having the right path
+# Hack for Buildkite sometimes not having the right path
 if [[ "${CI:-}" == "1" || "${CI:-}" == "true" ]]; then
   if [ -f ~/.bashrc ]; then
     source ~/.bashrc

scripts/experimental-build.mjs

@@ -6,162 +6,16 @@ import { copyFileSync, existsSync, mkdirSync, mkdtempSync, readFileSync, readdir
 import { basename, dirname, join } from "node:path";
 import { tmpdir } from "node:os";
 
+const projectPath = dirname(import.meta.dirname);
+const vendorPath = process.env.BUN_VENDOR_PATH || join(projectPath, "vendor");
+
 const isWindows = process.platform === "win32";
 const isMacOS = process.platform === "darwin";
 const isLinux = process.platform === "linux";
 
-const cwd = dirname(import.meta.dirname);
 const spawnSyncTimeout = 1000 * 60;
 const spawnTimeout = 1000 * 60 * 3;
 
-/**
- * @typedef {Object} S3UploadOptions
- * @property {string} [bucket]
- * @property {string} filename
- * @property {string} content
- * @property {Record<string, string>} [headers]
- */
-
-/**
- * @param {S3UploadOptions} options
- */
-async function uploadFileToS3(options) {
-  const { AwsV4Signer } = await import("aws4fetch");
-
-  const { bucket, filename, content, ...extra } = options;
-  const baseUrl = getEnv(["S3_ENDPOINT", "S3_BASE_URL", "AWS_ENDPOINT"], "https://s3.amazonaws.com");
-  const bucketUrl = new URL(bucket || getEnv(["S3_BUCKET", "AWS_BUCKET"]), baseUrl);
-
-  const signer = new AwsV4Signer({
-    accessKeyId: getSecret(["S3_ACCESS_KEY_ID", "AWS_ACCESS_KEY_ID"]),
-    secretAccessKey: getSecret(["S3_SECRET_ACCESS_KEY", "AWS_SECRET_ACCESS_KEY"]),
-    url: new URL(filename, bucketUrl),
-    method: "PUT",
-    body: content,
-    ...extra,
-  });
-
-  const { url, method, headers, body } = signer.sign();
-  await fetchSafe(url, {
-    method,
-    headers,
-    body,
-  });
-
-  console.log("Uploaded file to S3:", {
-    url: `${bucketUrl}`,
-    filename,
-  });
-}
-
-/**
- * @typedef {Object} SentryRelease
- * @property {string} organizationId
- * @property {string} projectId
- * @property {string} version
- * @property {string} [url]
- * @property {string} [ref]
- * @property {string} [dateReleased]
- */
-
-/**
- * @param {SentryRelease} options
- * @returns {Promise<void>}
- */
-async function createSentryRelease(options) {
-  const { organizationId, projectId, ...body } = options;
-
-  const baseUrl = getEnv("SENTRY_BASE_URL", "https://sentry.io");
-  const url = new URL(`api/0/organizations/${organizationId}/releases`, baseUrl);
-  const accessToken = getSecret(["SENTRY_AUTH_TOKEN", "SENTRY_TOKEN"]);
-
-  const release = await fetchSafe(url, {
-    method: "POST",
-    headers: {
-      "Authorization": `Bearer ${accessToken}`,
-      "Content-Type": "application/json",
-    },
-    body: JSON.stringify(body),
-    format: "json",
-  });
-
-  console.log("Created Sentry release:", release);
-}
-
-/**
- * @return {string}
- */
-function getGithubToken() {
-  const token = getEnv("GITHUB_TOKEN", null);
-  if (token) {
-    return token;
-  }
-
-  const gh = which("gh");
-  if (gh) {
-    const { exitCode, stdout } = spawnSyncSafe(gh, ["auth", "token"]);
-    if (exitCode === 0) {
-      return stdout.trim();
-    }
-  }
-
-  throw new Error("Failed to get GitHub token (set GITHUB_TOKEN or run `gh auth login`)");
-}
-
-/**
- * @param {string | string[]} name
- * @return {string}
- */
-function getSecret(name) {
-  return getEnv(name);
-}
-
-/**
- * @param {string | string[]} name
- * @param {string | null} [defaultValue]
- * @returns {string | undefined}
- */
-function getEnv(name, defaultValue) {
-  let result = defaultValue;
-
-  for (const key of typeof name === "string" ? [name] : name) {
-    const value = process.env[key];
-    if (value) {
-      result = value;
-      break;
-    }
-  }
-
-  if (result || result === null) {
-    return result;
-  }
-
-  throw new Error(`Environment variable is required: ${name}`);
-}
-
-/**
- * @typedef {Object} SpawnOptions
- * @property {boolean} [throwOnError]
- * @property {string} [cwd]
- * @property {string} [env]
- * @property {string} [encoding]
- * @property {number} [timeout]
- */
-
-/**
- * @typedef {Object} SpawnResult
- * @property {number | null} exitCode
- * @property {number | null} signalCode
- * @property {string} stdout
- * @property {string} stderr
- */
-
-/**
- * @param {string} command
- * @param {string[]} [args]
- * @param {SpawnOptions} [options]
- * @returns {Promise<SpawnResult>}
- */
 async function spawnSafe(command, args, options = {}) {
   const result = new Promise((resolve, reject) => {
     let stdout = "";
@@ -206,12 +60,6 @@ async function spawnSafe(command, args, options = {}) {
   }
 }
 
-/**
- * @param {string} command
- * @param {string[]} [args]
- * @param {SpawnOptions} [options]
- * @returns {SpawnResult}
- */
 function spawnSyncSafe(command, args, options = {}) {
   try {
     const { error, status, signal, stdout, stderr } = spawnSync(command, args, {
@@ -238,20 +86,6 @@ function spawnSyncSafe(command, args, options = {}) {
   }
 }
 
-/**
- * @typedef {Object} FetchOptions
- * @property {string} [method]
- * @property {Record<string, string>} [headers]
- * @property {string | Uint8Array} [body]
- * @property {"json" | "text" | "bytes"} [format]
- * @property {boolean} [throwOnError]
- */
-
-/**
- * @param {string | URL} url
- * @param {FetchOptions} [options]
- * @returns {Promise<Response | string | Uint8Array>}
- */
 async function fetchSafe(url, options = {}) {
   let response;
   try {
@@ -304,6 +138,47 @@ function which(command, path) {
   return result.trimEnd();
 }
 
+function getZigTarget(os = process.platform, arch = process.arch) {
+  if (arch === "x64") {
+    if (os === "linux") return "linux-x86_64";
+    if (os === "darwin") return "macos-x86_64";
+    if (os === "win32") return "windows-x86_64";
+  }
+  if (arch === "arm64") {
+    if (os === "linux") return "linux-aarch64";
+    if (os === "darwin") return "macos-aarch64";
+  }
+  throw new Error(`Unsupported zig target: os=${os}, arch=${arch}`);
+}
+
+function getRecommendedZigVersion() {
+  const scriptPath = join(projectPath, "build.zig");
+  try {
+    const scriptContent = readFileSync(scriptPath, "utf-8");
+    const match = scriptContent.match(/recommended_zig_version = "([^"]+)"/);
+    if (!match) {
+      throw new Error("File does not contain string: 'recommended_zig_version'");
+    }
+    return match[1];
+  } catch (cause) {
+    throw new Error("Failed to find recommended Zig version", { cause });
+  }
+}
+
+/**
+ * @returns {Promise<string>}
+ */
+async function getLatestZigVersion() {
+  try {
+    const response = await fetchSafe("https://ziglang.org/download/index.json", { format: "json" });
+    const { master } = response;
+    const { version } = master;
+    return version;
+  } catch (cause) {
+    throw new Error("Failed to get latest Zig version", { cause });
+  }
+}
+
 /**
  * @param {string} execPath
  * @returns {string | undefined}
@@ -316,3 +191,110 @@ function getVersion(execPath) {
   }
   return result.trim();
 }
+
+/**
+ * @returns {string}
+ */
+function getTmpdir() {
+  if (isMacOS && existsSync("/tmp")) {
+    return "/tmp";
+  }
+  return tmpdir();
+}
+
+/**
+ * @returns {string}
+ */
+function mkTmpdir() {
+  return mkdtempSync(join(getTmpdir(), "bun-"));
+}
+
+/**
+ * @param {string} url
+ * @param {string} [path]
+ * @returns {Promise<string>}
+ */
+async function downloadFile(url, path) {
+  const outPath = path || join(mkTmpdir(), basename(url));
+  const bytes = await fetchSafe(url, { format: "bytes" });
+  mkdirSync(dirname(outPath), { recursive: true });
+  writeFileSync(outPath, bytes);
+  return outPath;
+}
+
+/**
+ * @param {string} tarPath
+ * @param {string} [path]
+ * @returns {Promise<string>}
+ */
+async function extractFile(tarPath, path) {
+  const outPath = path || join(mkTmpdir(), basename(tarPath));
+  mkdirSync(outPath, { recursive: true });
+  await spawnSafe("tar", ["-xf", tarPath, "-C", outPath, "--strip-components=1"]);
+  return outPath;
+}
+
+const dependencies = [
+  {
+    name: "zig",
+    version: getRecommendedZigVersion(),
+    download: downloadZig,
+  },
+];
+
+async function getDependencyPath(name) {
+  let dependency;
+  for (const entry of dependencies) {
+    if (name === entry.name) {
+      dependency = entry;
+      break;
+    }
+  }
+  if (!dependency) {
+    throw new Error(`Unknown dependency: ${name}`);
+  }
+  const { version, download } = dependency;
+  mkdirSync(vendorPath, { recursive: true });
+  for (const path of readdirSync(vendorPath)) {
+    if (!path.startsWith(name)) {
+      continue;
+    }
+    const dependencyPath = join(vendorPath, path);
+    const dependencyVersion = getVersion(dependencyPath);
+    if (dependencyVersion === version) {
+      return dependencyPath;
+    }
+  }
+  if (!download) {
+    throw new Error(`Dependency not found: ${name}`);
+  }
+  return await download(version);
+}
+
+/**
+ * @param {string} [version]
+ */
+async function downloadZig(version) {
+  const target = getZigTarget();
+  const expectedVersion = version || getRecommendedZigVersion();
+  const url = `https://ziglang.org/builds/zig-${target}-${expectedVersion}.tar.xz`;
+  const tarPath = await downloadFile(url);
+  const extractedPath = await extractFile(tarPath);
+  const zigPath = join(extractedPath, exePath("zig"));
+  const actualVersion = getVersion(zigPath);
+  const outPath = join(vendorPath, exePath(`zig-${actualVersion}`));
+  mkdirSync(dirname(outPath), { recursive: true });
+  copyFileSync(zigPath, outPath);
+  return outPath;
+}
+
+/**
+ * @param {string} path
+ * @returns {string}
+ */
+function exePath(path) {
+  return isWindows ? `${path}.exe` : path;
+}
+
+const execPath = await getDependencyPath("zig");
+console.log(execPath);

scripts/runner.node.mjs

@@ -26,7 +26,7 @@ import { normalize as normalizeWindows } from "node:path/win32";
 import { isIP } from "node:net";
 import { parseArgs } from "node:util";
 
-const spawnTimeout = 5_000;
+const spawnTimeout = 30_000;
 const testTimeout = 3 * 60_000;
 const integrationTimeout = 5 * 60_000;
 
@@ -136,12 +136,6 @@ async function runTests() {
   }
   console.log("Bun:", execPath);
 
-  console.log("HACK: Testing the last canary build of Bun");
-  await spawnSafe({
-    command: execPath,
-    args: ["upgrade", "--canary"],
-  });
-
   const revision = getRevision(execPath);
   console.log("Revision:", revision);
 
@@ -237,20 +231,18 @@ async function runTests() {
  */
 
 /**
- * @param {SpawnOptions} options
+ * @param {SpawnOptions} request
  * @returns {Promise<SpawnResult>}
  */
-async function spawnSafe(options) {
-  const {
-    command,
-    args,
-    cwd,
-    env,
-    timeout = spawnTimeout,
-    stdout = process.stdout.write.bind(process.stdout),
-    stderr = process.stderr.write.bind(process.stderr),
-    retries = 0,
-  } = options;
+async function spawnSafe({
+  command,
+  args,
+  cwd,
+  env,
+  timeout = spawnTimeout,
+  stdout = process.stdout.write.bind(process.stdout),
+  stderr = process.stderr.write.bind(process.stderr),
+}) {
   let exitCode;
   let signalCode;
   let spawnError;
@@ -326,16 +318,6 @@ async function spawnSafe(options) {
       resolve();
     }
   });
-  if (spawnError && retries < 5) {
-    const { code } = spawnError;
-    if (code === "EBUSY" || code === "UNKNOWN") {
-      await new Promise(resolve => setTimeout(resolve, 1000 * (retries + 1)));
-      return spawnSafe({
-        ...options,
-        retries: retries + 1,
-      });
-    }
-  }
   let error;
   if (exitCode === 0) {
     // ...
@@ -1350,7 +1332,7 @@ function formatTestToMarkdown(result, concise) {
 
   let markdown = "";
   for (const { testPath, ok, tests, error, stdoutPreview: stdout } of results) {
-    if (ok || error === "SIGTERM") {
+    if (ok) {
       continue;
     }
 

src/brotli.zig

@@ -12,7 +12,7 @@ const mimalloc = bun.Mimalloc;
 const BrotliAllocator = struct {
     pub fn alloc(_: ?*anyopaque, len: usize) callconv(.C) *anyopaque {
         if (bun.heap_breakdown.enabled) {
-            const zone = bun.heap_breakdown.getZone("brotli");
+            const zone = bun.heap_breakdown.getZone(BrotliAllocator);
             return zone.malloc_zone_malloc(len) orelse bun.outOfMemory();
         }
 
@@ -21,7 +21,7 @@ const BrotliAllocator = struct {
 
     pub fn free(_: ?*anyopaque, data: ?*anyopaque) callconv(.C) void {
         if (bun.heap_breakdown.enabled) {
-            const zone = bun.heap_breakdown.getZone("brotli");
+            const zone = bun.heap_breakdown.getZone(BrotliAllocator);
             zone.malloc_zone_free(data);
             return;
         }

src/bun.js/api/bun/socket.zig

@@ -1197,7 +1197,6 @@ fn NewSocket(comptime ssl: bool) type {
         this_value: JSC.JSValue = .zero,
         poll_ref: Async.KeepAlive = Async.KeepAlive.init(),
         is_active: bool = false,
-        last_4: [4]u8 = .{ 0, 0, 0, 0 },
         authorized: bool = false,
         connection: ?Listener.UnixOrHost = null,
         protos: ?[]const u8,
@@ -1297,7 +1296,7 @@ fn NewSocket(comptime ssl: bool) type {
         ) void {
             JSC.markBinding(@src());
             log("onTimeout", .{});
-            if (this.detached) return;
+            if (this.detached or this.socket.isShutdown() or this.socket.isClosed()) return;
 
             const handlers = this.handlers;
             const callback = handlers.onTimeout;
@@ -1758,12 +1757,15 @@ fn NewSocket(comptime ssl: bool) type {
                 return .zero;
             }
             const t = args.ptr[0].coerce(i32, globalObject);
+            if (globalObject.hasException())
+                return .zero;
+
             if (t < 0) {
                 globalObject.throw("Timeout must be a positive integer", .{});
                 return .zero;
             }
 
-            this.socket.setTimeout(@as(c_uint, @intCast(t)));
+            this.socket.setTimeout(@intCast(t));
 
             return JSValue.jsUndefined();
         }

src/bun.js/javascript.zig

@@ -985,10 +985,6 @@ pub const VirtualMachine = struct {
             this.hide_bun_stackframes = false;
         }
 
-        if (bun.getRuntimeFeatureFlag("BUN_FEATURE_FLAG_DISABLE_ASYNC_TRANSPILER")) {
-            this.transpiler_store.enabled = false;
-        }
-
         if (map.map.fetchSwapRemove("NODE_CHANNEL_FD")) |kv| {
             const mode = if (map.map.fetchSwapRemove("NODE_CHANNEL_SERIALIZATION_MODE")) |mode_kv|
                 IPC.Mode.fromString(mode_kv.value.value) orelse .json

src/bun.zig

@@ -50,13 +50,6 @@ pub fn typedAllocator(comptime T: type) std.mem.Allocator {
     return default_allocator;
 }
 
-pub inline fn namedAllocator(comptime name: [:0]const u8) std.mem.Allocator {
-    if (heap_breakdown.enabled)
-        return heap_breakdown.namedAllocator(name);
-
-    return default_allocator;
-}
-
 pub const C = @import("root").C;
 pub const sha = @import("./sha.zig");
 pub const FeatureFlags = @import("feature_flags.zig");
@@ -2952,7 +2945,7 @@ pub const heap_breakdown = @import("./heap_breakdown.zig");
 /// to dump the heap.
 pub inline fn new(comptime T: type, init: T) *T {
     const ptr = if (heap_breakdown.enabled)
-        heap_breakdown.getZoneT(T).create(T, init)
+        heap_breakdown.getZone(T).create(T, init)
     else ptr: {
         const ptr = default_allocator.create(T) catch outOfMemory();
         ptr.* = init;
@@ -2978,7 +2971,7 @@ pub inline fn destroy(ptr: anytype) void {
     }
 
     if (comptime heap_breakdown.enabled) {
-        heap_breakdown.getZoneT(T).destroy(T, ptr);
+        heap_breakdown.getZone(T).destroy(T, ptr);
     } else {
         default_allocator.destroy(ptr);
     }

src/deps/libuwsockets.cpp

@@ -1224,14 +1224,14 @@ extern "C"
     if (ssl)
     {
       uWS::HttpResponse<true> *uwsRes = (uWS::HttpResponse<true> *)res;
-      auto onWritable = reinterpret_cast<bool (*)(uWS::HttpResponse<true>*, uint64_t, void*)>(handler);
-      uwsRes->onWritable(opcional_data, onWritable);
+      uwsRes->onWritable([handler, res, opcional_data](uint64_t a)
+                         { return handler(res, a, opcional_data); });
     }
     else
     {
       uWS::HttpResponse<false> *uwsRes = (uWS::HttpResponse<false> *)res;
-      auto onWritable = reinterpret_cast<bool (*)(uWS::HttpResponse<false>*, uint64_t, void*)>(handler);
-      uwsRes->onWritable(opcional_data, onWritable);
+      uwsRes->onWritable([handler, res, opcional_data](uint64_t a)
+                         { return handler(res, a, opcional_data); });
     }
   }
   
@@ -1252,10 +1252,11 @@ extern "C"
     if (ssl)
     {
       uWS::HttpResponse<true> *uwsRes = (uWS::HttpResponse<true> *)res;
-      auto* onAborted = reinterpret_cast<void (*)(uWS::HttpResponse<true>*, void*)>(handler);
       if (handler)
       {
-        uwsRes->onAborted(opcional_data, onAborted);
+        uwsRes->onAborted(
+            [handler, res, opcional_data]
+            { handler(res, opcional_data); });
       }
       else
       {
@@ -1265,10 +1266,11 @@ extern "C"
     else
     {
       uWS::HttpResponse<false> *uwsRes = (uWS::HttpResponse<false> *)res;
-      auto* onAborted = reinterpret_cast<void (*)(uWS::HttpResponse<false>*, void*)>(handler);
       if (handler)
       {
-        uwsRes->onAborted(opcional_data, onAborted);
+        uwsRes->onAborted(
+            [handler, res, opcional_data]
+            { handler(res, opcional_data); });
       }
       else
       {
@@ -1286,21 +1288,21 @@ extern "C"
     if (ssl)
     {
       uWS::HttpResponse<true> *uwsRes = (uWS::HttpResponse<true> *)res;
-      auto onData = reinterpret_cast<void (*)(uWS::HttpResponse<true>* response, const char* chunk, size_t chunk_length, bool, void*)>(handler);
       if (handler) {
-        uwsRes->onData(opcional_data, onData);
+        uwsRes->onData([handler, res, opcional_data](auto chunk, bool is_end)
+                       { handler(res, chunk.data(), chunk.length(), is_end, opcional_data); });
       } else {
-        uwsRes->onData(opcional_data, nullptr);
+        uwsRes->onData(nullptr);
       }
     }
     else
     {
       uWS::HttpResponse<false> *uwsRes = (uWS::HttpResponse<false> *)res;
-      auto onData = reinterpret_cast<void (*)(uWS::HttpResponse<false>* response, const char* chunk, size_t chunk_length, bool, void*)>(handler);
       if (handler) {
-        uwsRes->onData(opcional_data, onData);
+        uwsRes->onData([handler, res, opcional_data](auto chunk, bool is_end)
+                       { handler(res, chunk.data(), chunk.length(), is_end, opcional_data); });
       } else {
-        uwsRes->onData(opcional_data, nullptr);
+        uwsRes->onData(nullptr);
       }
     }
   }

src/feature_flags.zig

@@ -155,7 +155,8 @@ pub const export_star_redirect = false;
 
 pub const streaming_file_uploads_for_http_client = true;
 
-pub const concurrent_transpiler = true;
+// TODO: fix concurrent transpiler on Windows
+pub const concurrent_transpiler = !env.isWindows;
 
 // https://github.com/oven-sh/bun/issues/5426#issuecomment-1813865316
 pub const disable_auto_js_to_ts_in_node_modules = true;

src/heap_breakdown.zig

@@ -6,46 +6,44 @@ const vm_size_t = usize;
 
 pub const enabled = Environment.allow_assert and Environment.isMac;
 
-fn heapLabel(comptime T: type) [:0]const u8 {
-    const base_name = if (@hasDecl(T, "heap_label"))
-        T.heap_label
-    else
-        bun.meta.typeBaseName(@typeName(T));
-    return "Bun__" ++ base_name;
-}
-
 pub fn allocator(comptime T: type) std.mem.Allocator {
-    return namedAllocator(comptime heapLabel(T));
-}
-pub fn namedAllocator(comptime name: [:0]const u8) std.mem.Allocator {
-    return getZone(name).allocator();
+    return getZone(T).allocator();
 }
 
-pub fn getZoneT(comptime T: type) *Zone {
-    return getZone(comptime heapLabel(T));
-}
-
-pub fn getZone(comptime name: [:0]const u8) *Zone {
+pub fn getZone(comptime T: type) *Zone {
     comptime bun.assert(enabled);
 
     const static = struct {
-        pub var zone: *Zone = undefined;
-        pub fn initOnce() void {
-            zone = Zone.init(name);
-        }
-
-        pub var once = std.once(initOnce);
+        pub var zone: std.atomic.Value(?*Zone) = .{ .raw = null };
+        pub var lock: bun.Lock = bun.Lock.init();
     };
 
-    static.once.call();
-    return static.zone;
+    return static.zone.load(.monotonic) orelse brk: {
+        static.lock.lock();
+        defer static.lock.unlock();
+
+        if (static.zone.load(.monotonic)) |z| {
+            break :brk z;
+        }
+
+        const z = Zone.init(T);
+        static.zone.store(z, .monotonic);
+        break :brk z;
+    };
 }
 
 pub const Zone = opaque {
-    pub fn init(comptime name: [:0]const u8) *Zone {
+    pub fn init(comptime T: type) *Zone {
         const zone = malloc_create_zone(0, 0);
 
-        malloc_set_zone_name(zone, name.ptr);
+        const title: [:0]const u8 = comptime title: {
+            const base_name = if (@hasDecl(T, "heap_label"))
+                T.heap_label
+            else
+                bun.meta.typeBaseName(@typeName(T));
+            break :title "Bun__" ++ base_name;
+        };
+        malloc_set_zone_name(zone, title.ptr);
 
         return zone;
     }
@@ -80,8 +78,8 @@ pub const Zone = opaque {
         return false;
     }
 
-    fn rawFree(zone: *anyopaque, buf: []u8, _: u8, _: usize) void {
-        malloc_zone_free(@ptrCast(zone), @ptrCast(buf.ptr));
+    fn rawFree(zone: *anyopaque, buf: [*]u8, _: u8, _: usize) void {
+        malloc_zone_free(@ptrCast(zone), @ptrCast(buf));
     }
 
     pub const vtable = std.mem.Allocator.VTable{

src/js/node/net.ts

@@ -32,6 +32,17 @@ var IPv4Reg;
 const v6Seg = "(?:[0-9a-fA-F]{1,4})";
 var IPv6Reg;
 
+function convertTimeout(timeout) {
+  // uSockets timeouts are in seconds...
+  // Node.js timeouts are in milliseconds...
+  if (typeof timeout === "number") {
+    // Math.ceil() because if you set a timeout to 1 you don't want to disable it.
+    return Math.ceil(timeout / 1000);
+  }
+
+  return 0;
+}
+
 function isIPv4(s) {
   return (IPv4Reg ??= new RegExp(`^${v4Str}$`)).test(s);
 }
@@ -124,8 +135,8 @@ const Socket = (function (InternalSocket) {
       open(socket) {
         const self = socket.data;
         if (!self) return;
-
-        socket.timeout(self.timeout);
+        const timeout = self.timeout;
+        socket.timeout(convertTimeout(timeout));
         if (self.#unrefOnConnected) socket.unref();
         self[bunSocketInternal] = socket;
         self.connecting = false;
@@ -182,7 +193,7 @@ const Socket = (function (InternalSocket) {
         const self = socket.data;
         if (!self) return;
 
-        self.emit("timeout", self);
+        self._onTimeout();
       },
       binaryType: "buffer",
     };
@@ -399,10 +410,23 @@ const Socket = (function (InternalSocket) {
       return this.writableLength;
     }
 
+    // Node implements `_onTimeout()`:
+    // https://github.com/nodejs/node/blob/2eff28fb7a93d3f672f80b582f664a7c701569fb/lib/net.js#L577-L593
+    _onTimeout() {
+      if (
+        this.timeout &&
+        // node suppresses the timeout if there is an active write in progress
+        !this.#writeCallback
+      ) {
+        this.emit("timeout");
+      }
+    }
+
     #attach(port, socket) {
       this.remotePort = port;
       socket.data = this;
-      socket.timeout(this.timeout);
+      const timeout = this.timeout;
+      socket.timeout(convertTimeout(timeout));
       if (this.#unrefOnConnected) socket.unref();
       this[bunSocketInternal] = socket;
       this.connecting = false;
@@ -517,8 +541,8 @@ const Socket = (function (InternalSocket) {
         this._secureEstablished = false;
         this._securePending = true;
 
-        if (connectListener) this.on("secureConnect", connectListener);
-      } else if (connectListener) this.on("connect", connectListener);
+        if (connectListener) this.once("secureConnect", connectListener);
+      } else if (connectListener) this.once("connect", connectListener);
 
       // start using existing connection
       try {
@@ -537,7 +561,7 @@ const Socket = (function (InternalSocket) {
               const [raw, tls] = result;
               // replace socket
               connection[bunSocketInternal] = raw;
-              raw.timeout(raw.timeout);
+              raw.timeout(convertTimeout(this.timeout));
               this.once("end", this.#closeRawConnection);
               raw.connecting = false;
               this[bunSocketInternal] = tls;
@@ -563,7 +587,7 @@ const Socket = (function (InternalSocket) {
                 const [raw, tls] = result;
                 // replace socket
                 connection[bunSocketInternal] = raw;
-                raw.timeout(raw.timeout);
+                raw.timeout(convertTimeout(this.timeout));
                 this.once("end", this.#closeRawConnection);
                 raw.connecting = false;
                 this[bunSocketInternal] = tls;
@@ -683,9 +707,14 @@ const Socket = (function (InternalSocket) {
     }
 
     setTimeout(timeout, callback) {
-      this[bunSocketInternal]?.timeout(timeout);
+      if (this.destroyed) return this;
+
+      const handle = this[bunSocketInternal];
+      if (handle) {
+        handle.timeout(convertTimeout(timeout));
+      }
       this.timeout = timeout;
-      if (callback) this.once("timeout", callback);
+      if (callback && $isCallable(callback)) this.once("timeout", callback);
       return this;
     }
 

src/zlib.zig

@@ -291,7 +291,7 @@ pub const ZlibError = error{
 const ZlibAllocator = struct {
     pub fn alloc(_: *anyopaque, items: uInt, len: uInt) callconv(.C) *anyopaque {
         if (bun.heap_breakdown.enabled) {
-            const zone = bun.heap_breakdown.getZone("zlib");
+            const zone = bun.heap_breakdown.getZone(ZlibAllocator);
             return zone.malloc_zone_calloc(items, len) orelse bun.outOfMemory();
         }
 
@@ -300,7 +300,7 @@ const ZlibAllocator = struct {
 
     pub fn free(_: *anyopaque, data: *anyopaque) callconv(.C) void {
         if (bun.heap_breakdown.enabled) {
-            const zone = bun.heap_breakdown.getZone("zlib");
+            const zone = bun.heap_breakdown.getZone(ZlibAllocator);
             zone.malloc_zone_free(data);
             return;
         }

test/cli/run/run-crash-handler.test.ts

@@ -13,11 +13,13 @@ test.if(process.platform === "darwin")("macOS has the assumed image offset", ()
 
 test("raise ignoring panic handler does not trigger the panic handler", async () => {
   let sent = false;
+  let onresolve = Promise.withResolvers();
 
   using server = Bun.serve({
     port: 0,
     fetch(request, server) {
       sent = true;
+      onresolve.resolve();
       return new Response("OK");
     },
   });
@@ -32,8 +34,11 @@ test("raise ignoring panic handler does not trigger the panic handler", async ()
       },
     ]),
   });
+  await proc.exited;
 
-  expect(proc.exited).resolves.not.toBe(0);
+  await Promise.race([onresolve.promise, Bun.sleep(1000)]);
+
+  expect(proc.exitCode).not.toBe(0);
   expect(sent).toBe(false);
 });
 
@@ -41,6 +46,7 @@ describe("automatic crash reporter", () => {
   for (const approach of ["panic", "segfault", "outOfMemory"]) {
     test(`${approach} should report`, async () => {
       let sent = false;
+      let onresolve = Promise.withResolvers();
 
       // Self host the crash report backend.
       using server = Bun.serve({
@@ -48,6 +54,7 @@ describe("automatic crash reporter", () => {
         fetch(request, server) {
           expect(request.url).toEndWith("/ack");
           sent = true;
+          onresolve.resolve();
           return new Response("OK");
         },
       });
@@ -65,12 +72,15 @@ describe("automatic crash reporter", () => {
         ]),
         stdio: ["ignore", "pipe", "pipe"],
       });
-      const exitCode = await proc.exited;
+      await proc.exited;
+
+      await Promise.race([onresolve.promise, Bun.sleep(1000)]);
+
       const stderr = await Bun.readableStreamToText(proc.stderr);
 
       console.log(stderr);
 
-      expect(exitCode).not.toBe(0);
+      expect(proc.exitCode).not.toBe(0);
       expect(stderr).toContain(server.url.toString());
       if (approach !== "outOfMemory") {
         expect(stderr).toContain("oh no: Bun has crashed. This indicates a bug in Bun, not your code");

test/js/bun/dns/resolve-dns.test.ts

@@ -107,7 +107,7 @@ describe("dns", () => {
     test.each(malformedHostnames)("'%s'", hostname => {
       // @ts-expect-error
       expect(dns.lookup(hostname, { backend })).rejects.toMatchObject({
-        code: expect.stringMatching(/^DNS_ENOTFOUND|DNS_ESERVFAIL|DNS_ENOTIMP$/),
+        code: "DNS_ENOTFOUND",
         name: "DNSException",
       });
     });

test/js/node/net/node-net.test.ts

@@ -490,3 +490,52 @@ it("socket should keep process alive if unref is not called", async () => {
   });
   expect(await process.exited).toBe(1);
 });
+
+it("onTimeout shouldn't happen if there is a write in progress", async () => {
+  let otherSocket;
+  using listener = Bun.listen({
+    port: 0,
+    hostname: "localhost",
+    socket: {
+      open(socket) {
+        console.log("Open");
+        otherSocket = socket;
+        socket.write("HTTP/1.1 200 OK\r\nContent-Length: 0\r\n\r\n");
+      },
+      data() {},
+      close() {},
+    },
+  });
+
+  const socket = createConnection(listener.port, "localhost");
+  // 1. Verify the timeout happens.
+  let { promise, resolve } = Promise.withResolvers();
+  socket.setTimeout(1, () => {
+    resolve();
+  });
+  socket.write("abc");
+  await promise;
+
+  {
+    let hasTimeout = false;
+    ({ promise, resolve } = Promise.withResolvers());
+    // Verify the timeout doesn't happen when disabled.
+    socket.setTimeout(0, () => {
+      hasTimeout = true;
+    });
+    await Bun.sleep(2000);
+    expect(hasTimeout).toBe(false);
+  }
+
+  {
+    // Verify the timeout doesn't happen after end().
+    let hasTimeout = false;
+    ({ promise, resolve } = Promise.withResolvers());
+    socket.setTimeout(1, () => {
+      hasTimeout = true;
+    });
+    otherSocket.end();
+    await Bun.sleep(2000);
+    expect(hasTimeout).toBe(false);
+  }
+}, 30_000);