fix: use toWTFString for JSValue string conversion in initgroups

- Replace user.getString(globalObject) with user.toWTFString(globalObject)
- Fix compilation errors: JSString* type mismatch and missing utf8() method
- Proper exception handling with RETURN_IF_EXCEPTION

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

.agent/agent.mjs

@@ -0,0 +1,78 @@
+import { spawnSync } from "node:child_process";
+import { readFileSync, existsSync } from "node:fs";
+import { parseArgs } from "node:util";
+
+const { positionals, values } = parseArgs({
+  allowPositionals: true,
+  options: {
+    help: {
+      type: "boolean",
+      short: "h",
+      default: false,
+    },
+    interactive: {
+      type: "boolean",
+      short: "i",
+      default: false,
+    },
+  },
+});
+
+if (values.help || positionals.length === 0) {
+  console.log("Usage: node agent.mjs <prompt_name> [extra_args...]");
+  console.log("Example: node agent.mjs triage fix bug in authentication");
+  console.log("Options:");
+  console.log("  -h, --help         Show this help message");
+  console.log("  -i, --interactive  Run in interactive mode");
+  process.exit(0);
+}
+
+const promptName = positionals[0].toUpperCase();
+const promptFile = `.agent/${promptName}.md`;
+const extraArgs = positionals.slice(1);
+
+if (!existsSync(promptFile)) {
+  console.error(`Error: Prompt file "${promptFile}" not found`);
+  console.error(`Available prompts should be named like: .agent/triage.md, .agent/debug.md, etc.`);
+  process.exit(1);
+}
+
+try {
+  let prompt = readFileSync(promptFile, "utf-8");
+
+  const githubEnvs = Object.entries(process.env)
+    .filter(([key]) => key.startsWith("GITHUB_"))
+    .sort(([a], [b]) => a.localeCompare(b));
+
+  if (githubEnvs.length > 0) {
+    const githubContext = `## GitHub Environment\n\n${githubEnvs
+      .map(([key, value]) => `**${key}**: \`${value}\``)
+      .join("\n")}\n\n---\n\n`;
+    prompt = githubContext + prompt;
+  }
+
+  if (extraArgs.length > 0) {
+    const extraArgsContext = `\n\n## Additional Arguments\n\n${extraArgs.join(" ")}\n\n---\n\n`;
+    prompt = prompt + extraArgsContext;
+  }
+
+  const claudeArgs = [prompt, "--allowedTools=Edit,Write,Replace,Search", "--output-format=json"];
+  if (!values.interactive) {
+    claudeArgs.unshift("--print");
+  }
+
+  const { status, error } = spawnSync("claude", claudeArgs, {
+    stdio: "inherit",
+    encoding: "utf-8",
+  });
+
+  if (error) {
+    console.error("Error running claude:", error);
+    process.exit(1);
+  }
+
+  process.exit(status || 0);
+} catch (error) {
+  console.error(`Error reading prompt file "${promptFile}":`, error);
+  process.exit(1);
+}

.buildkite/Dockerfile

@@ -1,12 +1,12 @@
-ARG LLVM_VERSION="18"
-ARG REPORTED_LLVM_VERSION="18.1.8"
+ARG LLVM_VERSION="19"
+ARG REPORTED_LLVM_VERSION="19.1.7"
 ARG OLD_BUN_VERSION="1.1.38"
 ARG DEFAULT_CFLAGS="-mno-omit-leaf-frame-pointer -fno-omit-frame-pointer -ffunction-sections -fdata-sections -faddrsig -fno-unwind-tables -fno-asynchronous-unwind-tables"
 ARG DEFAULT_CXXFLAGS="-flto=full -fwhole-program-vtables -fforce-emit-vtables"
 ARG BUILDKITE_AGENT_TAGS="queue=linux,os=linux,arch=${TARGETARCH}"
 
 FROM --platform=$BUILDPLATFORM ubuntu:20.04 as base-arm64
-FROM --platform=$BUILDPLATFORM ubuntu:18.04 as base-amd64
+FROM --platform=$BUILDPLATFORM ubuntu:20.04 as base-amd64
 FROM base-$TARGETARCH as base
 
 ARG LLVM_VERSION

.buildkite/ci.mjs

@@ -35,7 +35,7 @@ import {
  * @typedef {"musl"} Abi
  * @typedef {"debian" | "ubuntu" | "alpine" | "amazonlinux"} Distro
  * @typedef {"latest" | "previous" | "oldest" | "eol"} Tier
- * @typedef {"release" | "assert" | "debug"} Profile
+ * @typedef {"release" | "assert" | "debug" | "asan"} Profile
  */
 
 /**
@@ -107,9 +107,10 @@ const buildPlatforms = [
   { os: "linux", arch: "aarch64", distro: "amazonlinux", release: "2023", features: ["docker"] },
   { os: "linux", arch: "x64", distro: "amazonlinux", release: "2023", features: ["docker"] },
   { os: "linux", arch: "x64", baseline: true, distro: "amazonlinux", release: "2023", features: ["docker"] },
-  { os: "linux", arch: "aarch64", abi: "musl", distro: "alpine", release: "3.20" },
-  { os: "linux", arch: "x64", abi: "musl", distro: "alpine", release: "3.20" },
-  { os: "linux", arch: "x64", abi: "musl", baseline: true, distro: "alpine", release: "3.20" },
+  { os: "linux", arch: "x64", profile: "asan", distro: "amazonlinux", release: "2023", features: ["docker"] },
+  { os: "linux", arch: "aarch64", abi: "musl", distro: "alpine", release: "3.21" },
+  { os: "linux", arch: "x64", abi: "musl", distro: "alpine", release: "3.21" },
+  { os: "linux", arch: "x64", abi: "musl", baseline: true, distro: "alpine", release: "3.21" },
   { os: "windows", arch: "x64", release: "2019" },
   { os: "windows", arch: "x64", baseline: true, release: "2019" },
 ];
@@ -125,18 +126,16 @@ const testPlatforms = [
   { os: "linux", arch: "aarch64", distro: "debian", release: "12", tier: "latest" },
   { os: "linux", arch: "x64", distro: "debian", release: "12", tier: "latest" },
   { os: "linux", arch: "x64", baseline: true, distro: "debian", release: "12", tier: "latest" },
+  { os: "linux", arch: "x64", profile: "asan", distro: "debian", release: "12", tier: "latest" },
   { os: "linux", arch: "aarch64", distro: "ubuntu", release: "24.04", tier: "latest" },
-  { os: "linux", arch: "aarch64", distro: "ubuntu", release: "22.04", tier: "previous" },
   { os: "linux", arch: "aarch64", distro: "ubuntu", release: "20.04", tier: "oldest" },
   { os: "linux", arch: "x64", distro: "ubuntu", release: "24.04", tier: "latest" },
-  { os: "linux", arch: "x64", distro: "ubuntu", release: "22.04", tier: "previous" },
   { os: "linux", arch: "x64", distro: "ubuntu", release: "20.04", tier: "oldest" },
   { os: "linux", arch: "x64", baseline: true, distro: "ubuntu", release: "24.04", tier: "latest" },
-  { os: "linux", arch: "x64", baseline: true, distro: "ubuntu", release: "22.04", tier: "previous" },
   { os: "linux", arch: "x64", baseline: true, distro: "ubuntu", release: "20.04", tier: "oldest" },
-  { os: "linux", arch: "aarch64", abi: "musl", distro: "alpine", release: "3.20", tier: "latest" },
-  { os: "linux", arch: "x64", abi: "musl", distro: "alpine", release: "3.20", tier: "latest" },
-  { os: "linux", arch: "x64", abi: "musl", baseline: true, distro: "alpine", release: "3.20", tier: "latest" },
+  { os: "linux", arch: "aarch64", abi: "musl", distro: "alpine", release: "3.21", tier: "latest" },
+  { os: "linux", arch: "x64", abi: "musl", distro: "alpine", release: "3.21", tier: "latest" },
+  { os: "linux", arch: "x64", abi: "musl", baseline: true, distro: "alpine", release: "3.21", tier: "latest" },
   { os: "windows", arch: "x64", release: "2019", tier: "oldest" },
   { os: "windows", arch: "x64", release: "2019", baseline: true, tier: "oldest" },
 ];
@@ -229,13 +228,7 @@ function getRetry(limit = 0) {
     manual: {
       permit_on_passed: true,
     },
-    automatic: [
-      { exit_status: 1, limit },
-      { exit_status: -1, limit: 1 },
-      { exit_status: 255, limit: 1 },
-      { signal_reason: "cancel", limit: 1 },
-      { signal_reason: "agent_stop", limit: 1 },
-    ],
+    automatic: false,
   };
 }
 
@@ -323,9 +316,25 @@ function getCppAgent(platform, options) {
  */
 function getZigAgent(platform, options) {
   const { arch } = platform;
-  return {
-    queue: "build-zig",
-  };
+
+  // Uncomment to restore to using macOS on-prem for Zig.
+  // return {
+  //   queue: "build-zig",
+  // };
+
+  return getEc2Agent(
+    {
+      os: "linux",
+      arch: "aarch64",
+      abi: "musl",
+      distro: "alpine",
+      release: "3.21",
+    },
+    options,
+    {
+      instanceType: "r8g.large",
+    },
+  );
 }
 
 /**
@@ -378,22 +387,32 @@ function getTestAgent(platform, options) {
  * @returns {Record<string, string | undefined>}
  */
 function getBuildEnv(target, options) {
-  const { profile, baseline, abi } = target;
-  const release = !profile || profile === "release";
+  const { baseline, abi } = target;
   const { canary } = options;
   const revision = typeof canary === "number" ? canary : 1;
 
   return {
-    CMAKE_BUILD_TYPE: release ? "Release" : profile === "debug" ? "Debug" : "RelWithDebInfo",
     ENABLE_BASELINE: baseline ? "ON" : "OFF",
     ENABLE_CANARY: revision > 0 ? "ON" : "OFF",
     CANARY_REVISION: revision,
-    ENABLE_ASSERTIONS: release ? "OFF" : "ON",
-    ENABLE_LOGS: release ? "OFF" : "ON",
     ABI: abi === "musl" ? "musl" : undefined,
+    CMAKE_VERBOSE_MAKEFILE: "ON",
+    CMAKE_TLS_VERIFY: "0",
   };
 }
 
+/**
+ * @param {Target} target
+ * @param {PipelineOptions} options
+ * @returns {string}
+ */
+function getBuildCommand(target, options) {
+  const { profile } = target;
+
+  const label = profile || "release";
+  return `bun run build:${label}`;
+}
+
 /**
  * @param {Platform} platform
  * @param {PipelineOptions} options
@@ -407,7 +426,7 @@ function getBuildVendorStep(platform, options) {
     retry: getRetry(),
     cancel_on_build_failing: isMergeQueue(),
     env: getBuildEnv(platform, options),
-    command: "bun run build:ci --target dependencies",
+    command: `${getBuildCommand(platform, options)} --target dependencies`,
   };
 }
 
@@ -417,6 +436,7 @@ function getBuildVendorStep(platform, options) {
  * @returns {Step}
  */
 function getBuildCppStep(platform, options) {
+  const command = getBuildCommand(platform, options);
   return {
     key: `${getTargetKey(platform)}-build-cpp`,
     label: `${getTargetLabel(platform)} - build-cpp`,
@@ -427,7 +447,10 @@ function getBuildCppStep(platform, options) {
       BUN_CPP_ONLY: "ON",
       ...getBuildEnv(platform, options),
     },
-    command: "bun run build:ci --target bun",
+    // We used to build the C++ dependencies and bun in seperate steps.
+    // However, as long as the zig build takes longer than both sequentially,
+    // it's cheaper to run them in the same step. Can be revisited in the future.
+    command: [`${command} --target bun`, `${command} --target dependencies`],
   };
 }
 
@@ -461,7 +484,8 @@ function getBuildZigStep(platform, options) {
     retry: getRetry(),
     cancel_on_build_failing: isMergeQueue(),
     env: getBuildEnv(platform, options),
-    command: `bun run build:ci --target bun-zig --toolchain ${toolchain}`,
+    command: `${getBuildCommand(platform, options)} --target bun-zig --toolchain ${toolchain}`,
+    timeout_in_minutes: 35,
   };
 }
 
@@ -474,11 +498,7 @@ function getLinkBunStep(platform, options) {
   return {
     key: `${getTargetKey(platform)}-build-bun`,
     label: `${getTargetLabel(platform)} - build-bun`,
-    depends_on: [
-      `${getTargetKey(platform)}-build-vendor`,
-      `${getTargetKey(platform)}-build-cpp`,
-      `${getTargetKey(platform)}-build-zig`,
-    ],
+    depends_on: [`${getTargetKey(platform)}-build-cpp`, `${getTargetKey(platform)}-build-zig`],
     agents: getCppAgent(platform, options),
     retry: getRetry(),
     cancel_on_build_failing: isMergeQueue(),
@@ -486,7 +506,7 @@ function getLinkBunStep(platform, options) {
       BUN_LINK_ONLY: "ON",
       ...getBuildEnv(platform, options),
     },
-    command: "bun run build:ci --target bun",
+    command: `${getBuildCommand(platform, options)} --target bun`,
   };
 }
 
@@ -503,7 +523,7 @@ function getBuildBunStep(platform, options) {
     retry: getRetry(),
     cancel_on_build_failing: isMergeQueue(),
     env: getBuildEnv(platform, options),
-    command: "bun run build:ci",
+    command: getBuildCommand(platform, options),
   };
 }
 
@@ -522,7 +542,7 @@ function getBuildBunStep(platform, options) {
  * @returns {Step}
  */
 function getTestBunStep(platform, options, testOptions = {}) {
-  const { os } = platform;
+  const { os, profile } = platform;
   const { buildId, unifiedTests, testFiles } = testOptions;
 
   const args = [`--step=${getTargetKey(platform)}-build-bun`];
@@ -546,6 +566,7 @@ function getTestBunStep(platform, options, testOptions = {}) {
     retry: getRetry(),
     cancel_on_build_failing: isMergeQueue(),
     parallelism: unifiedTests ? undefined : os === "darwin" ? 2 : 10,
+    timeout_in_minutes: profile === "asan" ? 45 : 30,
     command:
       os === "windows"
         ? `node .\\scripts\\runner.node.mjs ${args.join(" ")}`
@@ -618,6 +639,22 @@ function getReleaseStep(buildPlatforms, options) {
   };
 }
 
+/**
+ * @param {Platform[]} buildPlatforms
+ * @returns {Step}
+ */
+function getBenchmarkStep() {
+  return {
+    key: "benchmark",
+    label: "📊",
+    agents: {
+      queue: "build-image",
+    },
+    depends_on: `linux-x64-build-bun`,
+    command: "node .buildkite/scripts/upload-benchmark.mjs",
+  };
+}
+
 /**
  * @typedef {Object} Pipeline
  * @property {Step[]} [steps]
@@ -704,7 +741,6 @@ function getReleaseStep(buildPlatforms, options) {
  * @property {string | boolean} [buildImages]
  * @property {string | boolean} [publishImages]
  * @property {number} [canary]
- * @property {Profile[]} [buildProfiles]
  * @property {Platform[]} [buildPlatforms]
  * @property {Platform[]} [testPlatforms]
  * @property {string[]} [testFiles]
@@ -799,6 +835,10 @@ function getOptionsStep() {
             label: `${getEmoji("assert")} Release with Assertions`,
             value: "assert",
           },
+          {
+            label: `${getEmoji("asan")} Release with ASAN`,
+            value: "asan",
+          },
           {
             label: `${getEmoji("debug")} Debug`,
             value: "debug",
@@ -921,8 +961,13 @@ async function getPipelineOptions() {
     return;
   }
 
+  let filteredBuildPlatforms = buildPlatforms;
+  if (isMainBranch()) {
+    filteredBuildPlatforms = buildPlatforms.filter(({ profile }) => profile !== "asan");
+  }
+
   const canary = await getCanaryRevision();
-  const buildPlatformsMap = new Map(buildPlatforms.map(platform => [getTargetKey(platform), platform]));
+  const buildPlatformsMap = new Map(filteredBuildPlatforms.map(platform => [getTargetKey(platform), platform]));
   const testPlatformsMap = new Map(testPlatforms.map(platform => [getPlatformKey(platform), platform]));
 
   if (isManual) {
@@ -941,6 +986,7 @@ async function getPipelineOptions() {
         ?.map(item => item.trim())
         ?.filter(Boolean);
 
+    const buildProfiles = parseArray(options["build-profiles"]);
     const buildPlatformKeys = parseArray(options["build-platforms"]);
     const testPlatformKeys = parseArray(options["test-platforms"]);
     return {
@@ -953,12 +999,11 @@ async function getPipelineOptions() {
       testFiles: parseArray(options["test-files"]),
       unifiedBuilds: parseBoolean(options["unified-builds"]),
       unifiedTests: parseBoolean(options["unified-tests"]),
-      buildProfiles: parseArray(options["build-profiles"]),
       buildPlatforms: buildPlatformKeys?.length
-        ? buildPlatformKeys.map(key => buildPlatformsMap.get(key))
+        ? buildPlatformKeys.flatMap(key => buildProfiles.map(profile => ({ ...buildPlatformsMap.get(key), profile })))
         : Array.from(buildPlatformsMap.values()),
       testPlatforms: testPlatformKeys?.length
-        ? testPlatformKeys.map(key => testPlatformsMap.get(key))
+        ? testPlatformKeys.flatMap(key => buildProfiles.map(profile => ({ ...testPlatformsMap.get(key), profile })))
         : Array.from(testPlatformsMap.values()),
       dryRun: parseBoolean(options["dry-run"]),
     };
@@ -993,7 +1038,6 @@ async function getPipelineOptions() {
     publishImages: parseOption(/\[(publish images?)\]/i),
     buildPlatforms: Array.from(buildPlatformsMap.values()),
     testPlatforms: Array.from(testPlatformsMap.values()),
-    buildProfiles: ["release"],
   };
 }
 
@@ -1016,7 +1060,7 @@ async function getPipeline(options = {}) {
     return;
   }
 
-  const { buildProfiles = [], buildPlatforms = [], testPlatforms = [], buildImages, publishImages } = options;
+  const { buildPlatforms = [], testPlatforms = [], buildImages, publishImages } = options;
   const imagePlatforms = new Map(
     buildImages || publishImages
       ? [...buildPlatforms, ...testPlatforms]
@@ -1051,29 +1095,28 @@ async function getPipeline(options = {}) {
     }
   }
 
-  if (!buildId) {
-    steps.push(
-      ...buildPlatforms
-        .flatMap(platform => buildProfiles.map(profile => ({ ...platform, profile })))
-        .map(target => {
-          const imageKey = getImageKey(target);
+  const includeASAN = !isMainBranch();
 
-          return getStepWithDependsOn(
-            {
-              key: getTargetKey(target),
-              group: getTargetLabel(target),
-              steps: unifiedBuilds
-                ? [getBuildBunStep(target, options)]
-                : [
-                    getBuildVendorStep(target, options),
-                    getBuildCppStep(target, options),
-                    getBuildZigStep(target, options),
-                    getLinkBunStep(target, options),
-                  ],
-            },
-            imagePlatforms.has(imageKey) ? `${imageKey}-build-image` : undefined,
-          );
-        }),
+  if (!buildId) {
+    const relevantBuildPlatforms = includeASAN
+      ? buildPlatforms
+      : buildPlatforms.filter(({ profile }) => profile !== "asan");
+
+    steps.push(
+      ...relevantBuildPlatforms.map(target => {
+        const imageKey = getImageKey(target);
+
+        return getStepWithDependsOn(
+          {
+            key: getTargetKey(target),
+            group: getTargetLabel(target),
+            steps: unifiedBuilds
+              ? [getBuildBunStep(target, options)]
+              : [getBuildCppStep(target, options), getBuildZigStep(target, options), getLinkBunStep(target, options)],
+          },
+          imagePlatforms.has(imageKey) ? `${imageKey}-build-image` : undefined,
+        );
+      }),
     );
   }
 
@@ -1081,13 +1124,11 @@ async function getPipeline(options = {}) {
     const { skipTests, forceTests, unifiedTests, testFiles } = options;
     if (!skipTests || forceTests) {
       steps.push(
-        ...testPlatforms
-          .flatMap(platform => buildProfiles.map(profile => ({ ...platform, profile })))
-          .map(target => ({
-            key: getTargetKey(target),
-            group: getTargetLabel(target),
-            steps: [getTestBunStep(target, options, { unifiedTests, testFiles, buildId })],
-          })),
+        ...testPlatforms.map(target => ({
+          key: getTargetKey(target),
+          group: getTargetLabel(target),
+          steps: [getTestBunStep(target, options, { unifiedTests, testFiles, buildId })],
+        })),
       );
     }
   }
@@ -1095,6 +1136,7 @@ async function getPipeline(options = {}) {
   if (isMainBranch()) {
     steps.push(getReleaseStep(buildPlatforms, options));
   }
+  steps.push(getBenchmarkStep());
 
   /** @type {Map<string, GroupStep>} */
   const stepsByGroup = new Map();

.buildkite/scripts/upload-benchmark.mjs

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

.buildkite/scripts/upload-release.sh

@@ -158,25 +158,36 @@ function upload_s3_file() {
   run_command aws --endpoint-url="$AWS_ENDPOINT" s3 cp "$file" "s3://$AWS_BUCKET/$folder/$file"
 }
 
-function send_bench_webhook() {
-  if [ -z "$BENCHMARK_URL" ]; then
-    echo "error: \$BENCHMARK_URL is not set"
-    # exit 1 # TODO: this isn't live yet
+function send_discord_announcement() {
+  local value=$(buildkite-agent secret get "BUN_ANNOUNCE_CANARY_WEBHOOK_URL")
+  if [ -z "$value" ]; then
+    echo "warn: BUN_ANNOUNCE_CANARY_WEBHOOK_URL not set, skipping Discord announcement"
     return
   fi
 
-  local tag="$1"
+  local version="$1"
   local commit="$BUILDKITE_COMMIT"
-  local artifact_path="${commit}"
+  local short_sha="${commit:0:7}"
+  local commit_url="https://github.com/oven-sh/bun/commit/$commit"
 
-  if [ "$tag" == "canary" ]; then
-    artifact_path="${commit}-canary"
+  if [ "$version" == "canary" ]; then
+    local json_payload=$(cat <<EOF
+{
+  "embeds": [{
+    "title": "New Bun Canary now available",
+    "description": "A new canary build of Bun has been automatically uploaded ([${short_sha}](${commit_url})). To upgrade, run:\n\n\`\`\`shell\nbun upgrade --canary\n\`\`\`\nCommit: \`${commit}\`",
+    "color": 16023551,
+    "timestamp": "$(date -u +%Y-%m-%dT%H:%M:%SZ)"
+  }]
+}
+EOF
+)
+    
+    curl -H "Content-Type: application/json" \
+         -d "$json_payload" \
+         -sf \
+         "$value" >/dev/null
   fi
-
-  local artifact_url="https://pub-5e11e972747a44bf9aaf9394f185a982.r2.dev/releases/$artifact_path/bun-linux-x64.zip"
-  local webhook_url="$BENCHMARK_URL?tag=$tag&commit=$commit&artifact_url=$artifact_url"
-  
-  curl -X POST "$webhook_url"
 }
 
 function create_release() {
@@ -190,6 +201,8 @@ function create_release() {
   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
@@ -227,7 +240,7 @@ function create_release() {
 
   update_github_release "$tag"
   create_sentry_release "$tag"
-  send_bench_webhook "$tag"
+  send_discord_announcement "$tag"
 }
 
 function assert_canary() {

.clangd

@@ -6,6 +6,3 @@ CompileFlags:
 
 Diagnostics:
   UnusedIncludes: None
-
-HeaderInsertion:
-  IncludeBlocks: Preserve # Do not auto-include headers.

.cursor/environment.json

@@ -0,0 +1,3 @@
+{
+  "terminals": []
+}

.cursor/rules/building-bun.mdc

@@ -0,0 +1,13 @@
+---
+description: How to build Bun
+globs:
+alwaysApply: false
+---
+
+# How to build Bun
+
+Run:
+
+```bash
+bun bd
+```

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

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

.cursor/rules/javascriptcore-class.mdc

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

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

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

.cursor/rules/writing-tests.mdc

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

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

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

.git-blame-ignore-revs

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

.gitattributes

@@ -15,6 +15,7 @@
 *.lock text eol=lf whitespace=blank-at-eol,-blank-at-eof,-space-before-tab,tab-in-indent,tabwidth=2
 *.map text eol=lf whitespace=blank-at-eol,-blank-at-eof,-space-before-tab,tab-in-indent,tabwidth=2
 *.md text eol=lf whitespace=blank-at-eol,-blank-at-eof,-space-before-tab,tab-in-indent,tabwidth=2
+*.mdc text eol=lf whitespace=blank-at-eol,-blank-at-eof,-space-before-tab,tab-in-indent,tabwidth=2
 *.mjs text eol=lf whitespace=blank-at-eol,-blank-at-eof,-space-before-tab,tab-in-indent,tabwidth=2
 *.mts text eol=lf whitespace=blank-at-eol,-blank-at-eof,-space-before-tab,tab-in-indent,tabwidth=2
 
@@ -51,3 +52,6 @@ test/js/node/test/fixtures linguist-vendored
 test/js/node/test/common linguist-vendored
 
 test/js/bun/css/files linguist-vendored
+
+.vscode/*.json linguist-language=JSON-with-Comments
+src/cli/init/tsconfig.default.json linguist-language=JSON-with-Comments

.github/CODEOWNERS

@@ -0,0 +1,18 @@
+# Project
+/.github/CODEOWNERS @Jarred-Sumner
+
+# Build system
+/CMakeLists.txt @Electroid
+/cmake/*.cmake @Electroid
+/scripts/ @Electroid
+
+# CI
+/.buildkite/ @Electroid
+/.github/workflows/ @Electroid
+
+# Debugger protocol
+/packages/bun-inspector-protocol/ @Electroid
+/packages/bun-debug-adapter-protocol/ @Electroid
+
+# Tests
+/test/expectations.txt @Jarred-Sumner

.github/actions/setup-bun/action.yml

@@ -4,7 +4,7 @@ description: An internal version of the 'oven-sh/setup-bun' action.
 inputs:
   bun-version:
     type: string
-    description: "The version of bun to install: 'latest', 'canary', 'bun-v1.0.0', etc."
+    description: "The version of bun to install: 'latest', 'canary', 'bun-v1.2.0', etc."
     default: latest
     required: false
   baseline:

.github/pull_request_template.md

@@ -28,7 +28,7 @@ This adds a new flag --bail to bun test. When set, it will stop running tests af
 
 - [ ] I checked the lifetime of memory allocated to verify it's (1) freed and (2) only freed when it should be
 - [ ] I included a test for the new code, or an existing test covers it
-- [ ] JSValue used outside outside of the stack is either wrapped in a JSC.Strong or is JSValueProtect'ed
+- [ ] JSValue used outside of the stack is either wrapped in a JSC.Strong or is JSValueProtect'ed
 - [ ] I wrote TypeScript/JavaScript tests and they pass locally (`bun-debug test test-file-name.test`)
 -->
 

.github/workflows/clang-format.yml

@@ -1,41 +0,0 @@
-name: clang-format
-
-permissions:
-  contents: write
-
-on:
-  workflow_call:
-  workflow_dispatch:
-  pull_request:
-  merge_group:
-
-env:
-  BUN_VERSION: "1.1.44"
-  LLVM_VERSION: "18.1.8"
-  LLVM_VERSION_MAJOR: "18"
-
-jobs:
-  clang-format:
-    name: clang-format
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-      - name: Setup Bun
-        uses: ./.github/actions/setup-bun
-        with:
-          bun-version: ${{ env.BUN_VERSION }}
-      - name: Install LLVM
-        run: |
-          curl -fsSL https://apt.llvm.org/llvm.sh | sudo bash -s -- ${{ env.LLVM_VERSION_MAJOR }} all
-      - name: Clang Format
-        env:
-          LLVM_VERSION: ${{ env.LLVM_VERSION }}
-        run: |
-          bun run clang-format
-      - name: Commit
-        uses: stefanzweifel/git-auto-commit-action@v5
-        with:
-          commit_message: "`bun run clang-format`"

.github/workflows/clang-tidy.yml

@@ -1,41 +0,0 @@
-name: clang-tidy
-
-permissions:
-  contents: write
-
-on:
-  workflow_call:
-  workflow_dispatch:
-  pull_request:
-  merge_group:
-
-env:
-  BUN_VERSION: "1.1.44"
-  LLVM_VERSION: "18.1.8"
-  LLVM_VERSION_MAJOR: "18"
-
-jobs:
-  clang-tidy:
-    name: clang-tidy
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-      - name: Setup Bun
-        uses: ./.github/actions/setup-bun
-        with:
-          bun-version: ${{ env.BUN_VERSION }}
-      - name: Install LLVM
-        run: |
-          curl -fsSL https://apt.llvm.org/llvm.sh | sudo bash -s -- ${{ env.LLVM_VERSION_MAJOR }} all
-      - name: Clang Tidy
-        env:
-          LLVM_VERSION: ${{ env.LLVM_VERSION }}
-        run: |
-          bun run clang-tidy:diff
-      - name: Commit
-        uses: stefanzweifel/git-auto-commit-action@v5
-        with:
-          commit_message: "`bun run clang-tidy`"

.github/workflows/claude.yml

@@ -0,0 +1,35 @@
+name: Claude Code
+
+on:
+  issue_comment:
+    types: [created]
+  pull_request_review_comment:
+    types: [created]
+  issues:
+    types: [opened, assigned]
+  pull_request_review:
+    types: [submitted]
+
+jobs:
+  claude:
+    if: |
+      (github.event_name == 'issue_comment' && contains(github.event.comment.body, '@claude')) ||
+      (github.event_name == 'pull_request_review_comment' && contains(github.event.comment.body, '@claude')) ||
+      (github.event_name == 'pull_request_review' && contains(github.event.review.body, '@claude')) ||
+      (github.event_name == 'issues' && (contains(github.event.issue.body, '@claude') || contains(github.event.issue.title, '@claude')))
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      id-token: write
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 1
+
+      - name: Run Claude Code
+        id: claude
+        uses: anthropics/claude-code-action@beta
+        with:
+          anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
+

.github/workflows/docs.yml

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

.github/workflows/format.yml

@@ -0,0 +1,66 @@
+name: format
+
+permissions:
+  contents: write
+
+on:
+  workflow_call:
+  workflow_dispatch:
+  pull_request:
+  merge_group:
+
+env:
+  BUN_VERSION: "1.2.11"
+  LLVM_VERSION: "19.1.7"
+  LLVM_VERSION_MAJOR: "19"
+
+jobs:
+  format:
+    name: Format
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+      - name: Configure Git
+        run: |
+          git config --global core.autocrlf true
+          git config --global core.ignorecase true
+          git config --global core.precomposeUnicode true
+      - name: Setup Bun
+        uses: ./.github/actions/setup-bun
+        with:
+          bun-version: ${{ env.BUN_VERSION }}
+      - name: Setup Dependencies
+        run: |
+          bun install
+      - name: Install LLVM
+        run: |
+          curl -fsSL https://apt.llvm.org/llvm.sh | sudo bash -s -- ${{ env.LLVM_VERSION_MAJOR }} all
+      - name: Setup Zig
+        uses: mlugg/setup-zig@v1
+        with:
+          version: 0.14.0
+      - name: Zig Format
+        run: |
+          bun scripts/zig-remove-unreferenced-top-level-decls.ts src/
+          zig fmt src/**.zig
+      - name: Commit
+        uses: stefanzweifel/git-auto-commit-action@v5
+        with:
+          commit_message: "`bun run zig-format`"
+      - name: Prettier Format
+        run: |
+          bun run prettier
+      - name: Commit
+        uses: stefanzweifel/git-auto-commit-action@v5
+        with:
+          commit_message: "`bun run prettier`"
+      - name: Clang Format
+        run: |
+          bun run clang-format
+      - name: Commit
+        uses: stefanzweifel/git-auto-commit-action@v5
+        with:
+          commit_message: "`bun run clang-format`"

.github/workflows/glob-sources.yml

@@ -0,0 +1,41 @@
+name: Glob Sources
+
+permissions:
+  contents: write
+
+on:
+  workflow_call:
+  workflow_dispatch:
+  pull_request:
+
+env:
+  BUN_VERSION: "1.2.11"
+
+jobs:
+  glob-sources:
+    name: Glob Sources
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+      - name: Configure Git
+        run: |
+          git config --global core.autocrlf true
+          git config --global core.ignorecase true
+          git config --global core.precomposeUnicode true
+      - name: Setup Bun
+        uses: ./.github/actions/setup-bun
+        with:
+          bun-version: ${{ env.BUN_VERSION }}
+      - name: Setup Dependencies
+        run: |
+          bun install
+      - name: Glob sources
+        run: bun scripts/glob-sources.mjs
+      - name: Commit
+        uses: stefanzweifel/git-auto-commit-action@v5
+        with:
+          commit_message: "`bun scripts/glob-sources.mjs`"
+

.github/workflows/labeled.yml

@@ -69,7 +69,6 @@ jobs:
         shell: bash
         run: |
           LABELS=$(bun scripts/read-issue.ts)
-          echo "labels=$LABELS" >> $GITHUB_OUTPUT
           bun scripts/is-outdated.ts
 
           if [[ -f "is-outdated.txt" ]]; then
@@ -77,12 +76,19 @@ jobs:
           fi
 
           if [[ -f "outdated.txt" ]]; then
-            echo "oudated=$(cat outdated.txt)" >> $GITHUB_OUTPUT
+            echo "outdated=$(cat outdated.txt)" >> $GITHUB_OUTPUT
+          fi
+
+          if [[ -f "is-very-outdated.txt" ]]; then
+            echo "is-very-outdated=true" >> $GITHUB_OUTPUT
+            LABELS="$LABELS,old-version"
+          else
+            echo "is-very-outdated=false" >> $GITHUB_OUTPUT
           fi
 
           echo "latest=$(cat LATEST)" >> $GITHUB_OUTPUT
-
-          rm -rf is-outdated.txt outdated.txt latest.txt
+          echo "labels=$LABELS" >> $GITHUB_OUTPUT
+          rm -rf is-outdated.txt outdated.txt latest.txt is-very-outdated.txt
       - name: Generate comment text with Sentry Link
         if: github.event.label.name == 'crash'
         # ignore if fail
@@ -102,7 +108,14 @@ jobs:
           if [[ -f "sentry-id.txt" ]]; then
             echo "sentry-id=$(cat sentry-id.txt)" >> $GITHUB_OUTPUT
           fi
-
+      - name: Remove old labels
+        uses: actions-cool/issues-helper@v3
+        if: github.event.label.name == 'crash' && steps.add-labels.outputs.is-very-outdated == 'false'
+        with:
+          actions: "remove-labels"
+          token: ${{ secrets.GITHUB_TOKEN }}
+          issue-number: ${{ github.event.issue.number }}
+          labels: old-version
       - name: Add labels
         uses: actions-cool/issues-helper@v3
         if: github.event.label.name == 'crash'
@@ -119,7 +132,7 @@ jobs:
           token: ${{ secrets.GITHUB_TOKEN }}
           issue-number: ${{ github.event.issue.number }}
           body: |
-            @${{ github.event.issue.user.login }}, the latest version of Bun is v${{ steps.add-labels.outputs.latest }}, but this crash was reported on Bun v${{ steps.add-labels.outputs.oudated }}.
+            @${{ github.event.issue.user.login }}, the latest version of Bun is v${{ steps.add-labels.outputs.latest }}, but this crash was reported on Bun v${{ steps.add-labels.outputs.outdated }}.
 
             Are you able to reproduce this crash on the latest version of Bun?
 
@@ -134,7 +147,7 @@ jobs:
           token: ${{ secrets.GITHUB_TOKEN }}
           issue-number: ${{ github.event.issue.number }}
           body: |
-            @${{ github.event.issue.user.login }}, thank you for reporting this crash. The latest version of Bun is v${{ steps.add-labels.outputs.latest }}, but this crash was reported on Bun v${{ steps.add-labels.outputs.oudated }}.
+            @${{ github.event.issue.user.login }}, thank you for reporting this crash. The latest version of Bun is v${{ steps.add-labels.outputs.latest }}, but this crash was reported on Bun v${{ steps.add-labels.outputs.outdated }}.
 
             Are you able to reproduce this crash on the latest version of Bun?
 

.github/workflows/lint.yml

@@ -5,8 +5,7 @@ on:
   workflow_dispatch:
 
 env:
-  BUN_VERSION: "1.1.44"
-  OXLINT_VERSION: "0.15.0"
+  BUN_VERSION: "1.2.10"
 
 jobs:
   lint-js:
@@ -19,4 +18,4 @@ jobs:
         with:
           bun-version: ${{ env.BUN_VERSION }}
       - name: Lint
-        run: bunx oxlint --config oxlint.json --quiet --format github
+        run: bun lint

.github/workflows/packages-ci.yml

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

.github/workflows/prettier-format.yml

@@ -1,37 +0,0 @@
-name: prettier-format
-
-permissions:
-  contents: write
-
-on:
-  workflow_call:
-  workflow_dispatch:
-  pull_request:
-  merge_group:
-
-env:
-  BUN_VERSION: "1.1.44"
-
-jobs:
-  prettier-format:
-    name: prettier-format
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-      - name: Setup Bun
-        uses: ./.github/actions/setup-bun
-        with:
-          bun-version: ${{ env.BUN_VERSION }}
-      - name: Setup Dependencies
-        run: |
-          bun install
-      - name: Prettier Format
-        run: |
-          bun run prettier:diff
-      - name: Commit
-        uses: stefanzweifel/git-auto-commit-action@v5
-        with:
-          commit_message: "`bun run prettier:extra`"

.github/workflows/release.yml

@@ -44,6 +44,10 @@ on:
         description: Should types be released to npm?
         type: boolean
         default: false
+      use-definitelytyped:
+        description: "Should types be PR'd to DefinitelyTyped?"
+        type: boolean
+        default: false
 
 jobs:
   sign:
@@ -66,7 +70,7 @@ jobs:
       - name: Setup Bun
         uses: ./.github/actions/setup-bun
         with:
-          bun-version: "1.1.44"
+          bun-version: "1.2.3"
       - name: Install Dependencies
         run: bun install
       - name: Sign Release
@@ -94,7 +98,7 @@ jobs:
       - name: Setup Bun
         uses: ./.github/actions/setup-bun
         with:
-          bun-version: "1.1.44"
+          bun-version: "1.2.3"
       - name: Install Dependencies
         run: bun install
       - name: Release
@@ -123,7 +127,7 @@ jobs:
         if: ${{ env.BUN_VERSION != 'canary' }}
         uses: ./.github/actions/setup-bun
         with:
-          bun-version: "1.1.44"
+          bun-version: "1.2.3"
       - name: Setup Bun
         if: ${{ env.BUN_VERSION == 'canary' }}
         uses: ./.github/actions/setup-bun
@@ -155,6 +159,52 @@ jobs:
         with:
           package: packages/bun-types/package.json
           token: ${{ secrets.NPM_TOKEN }}
+  definitelytyped:
+    name: Make pr to DefinitelyTyped to update `bun-types` version
+    runs-on: ubuntu-latest
+    needs: npm-types
+    if: ${{ github.event_name == 'release' || github.event.inputs.use-definitelytyped == 'true' }}
+    permissions:
+      contents: read
+    steps:
+      - name: Checkout (DefinitelyTyped)
+        uses: actions/checkout@v4
+        with:
+          repository: DefinitelyTyped/DefinitelyTyped
+      - name: Checkout (bun)
+        uses: actions/checkout@v4
+        with:
+          path: bun
+      - name: Setup Bun
+        uses: ./bun/.github/actions/setup-bun
+        with:
+          bun-version: "1.2.0"
+      - id: bun-version
+        run: echo "BUN_VERSION=${BUN_VERSION#bun-v}" >> "$GITHUB_OUTPUT"
+      - name: Update bun-types version in package.json
+        run: |
+          bun -e '
+          const file = Bun.file("./types/bun/package.json");
+          const json = await file.json();
+          const version = "${{ steps.bun-version.outputs.BUN_VERSION }}"; 
+          json.dependencies["bun-types"] = version;
+          json.version = version.slice(0, version.lastIndexOf(".")) + ".9999";
+          await file.write(JSON.stringify(json, null, 4) + "\n");
+          '
+      - name: Create Pull Request
+        uses: peter-evans/create-pull-request@v7
+        if: ${{ env.BUN_LATEST == 'true' && env.BUN_VERSION != 'canary'}}
+        with:
+          token: ${{ secrets.ROBOBUN_TOKEN }}
+          add-paths: ./types/bun/package.json
+          title: "[bun] update to ${{ steps.bun-version.outputs.BUN_VERSION }}"
+          commit-message: "[bun] update to ${{ steps.bun-version.outputs.BUN_VERSION }}"
+          body: |
+            Update `bun-types` version to ${{ steps.bun-version.outputs.BUN_VERSION }}
+
+            https://bun.sh/blog/${{ env.BUN_VERSION }}
+          push-to-fork: oven-sh/DefinitelyTyped
+          branch: ${{env.BUN_VERSION}}
   docker:
     name: Release to Dockerhub
     runs-on: ubuntu-latest
@@ -181,7 +231,7 @@ jobs:
       - name: Checkout
         uses: actions/checkout@v4
       - name: Setup Docker emulator
-        uses: docker/setup-qemu-action@v2
+        uses: docker/setup-qemu-action@v3
       - id: buildx
         name: Setup Docker buildx
         uses: docker/setup-buildx-action@v3
@@ -189,7 +239,7 @@ jobs:
           platforms: linux/amd64,linux/arm64
       - id: metadata
         name: Setup Docker metadata
-        uses: docker/metadata-action@v4
+        uses: docker/metadata-action@v5
         with:
           images: oven/bun
           flavor: |
@@ -206,7 +256,7 @@ jobs:
           username: ${{ secrets.DOCKER_USERNAME }}
           password: ${{ secrets.DOCKER_PASSWORD }}
       - name: Push to Docker
-        uses: docker/build-push-action@v5
+        uses: docker/build-push-action@v6
         with:
           context: ./dockerhub/${{ matrix.dir || matrix.variant }}
           platforms: linux/amd64,linux/arm64
@@ -265,7 +315,7 @@ jobs:
       - name: Setup Bun
         uses: ./.github/actions/setup-bun
         with:
-          bun-version: "1.1.44"
+          bun-version: "1.2.0"
       - name: Install Dependencies
         run: bun install
       - name: Release
@@ -309,7 +359,7 @@ jobs:
         uses: ./.github/actions/setup-bun
         if: ${{ env.BUN_LATEST == 'true' }}
         with:
-          bun-version: "1.1.44"
+          bun-version: "1.2.0"
       - name: Bump version
         uses: ./.github/actions/bump
         if: ${{ env.BUN_LATEST == 'true' }}

.github/workflows/run-lint.yml

@@ -3,8 +3,7 @@ name: Lint
 permissions:
   contents: read
 env:
-  LLVM_VERSION: 16
-  BUN_VERSION: "1.1.44"
+  BUN_VERSION: "1.2.0"
 
 on:
   workflow_call:

.github/workflows/test-bump.yml

@@ -9,7 +9,7 @@ on:
         required: true
 
 env:
-  BUN_VERSION: "1.1.44"
+  BUN_VERSION: "1.2.0"
 
 jobs:
   bump:

.github/workflows/update-cares.yml

@@ -50,11 +50,16 @@ jobs:
             exit 1
           fi
 
-          LATEST_SHA=$(curl -sL "https://api.github.com/repos/c-ares/c-ares/git/ref/tags/$LATEST_TAG" | jq -r '.object.sha')
-          if [ -z "$LATEST_SHA" ] || [ "$LATEST_SHA" = "null" ]; then
+          LATEST_TAG_SHA=$(curl -sL "https://api.github.com/repos/c-ares/c-ares/git/refs/tags/$LATEST_TAG" | jq -r '.object.sha')
+          if [ -z "$LATEST_TAG_SHA" ] || [ "$LATEST_TAG_SHA" = "null" ]; then
             echo "Error: Could not fetch SHA for tag $LATEST_TAG"
             exit 1
           fi
+          LATEST_SHA=$(curl -sL "https://api.github.com/repos/c-ares/c-ares/git/tags/$LATEST_TAG_SHA" | jq -r '.object.sha')
+          if [ -z "$LATEST_SHA" ] || [ "$LATEST_SHA" = "null" ]; then
+            echo "Error: Could not fetch SHA for tag $LATEST_TAG @ $LATEST_TAG_SHA"
+            exit 1
+          fi
 
           if ! [[ $LATEST_SHA =~ ^[0-9a-f]{40}$ ]]; then
             echo "Error: Invalid SHA format received from GitHub"
@@ -89,4 +94,6 @@ jobs:
 
             Updates c-ares to version ${{ steps.check-version.outputs.tag }}
 
+            Compare: https://github.com/c-ares/c-ares/compare/${{ steps.check-version.outputs.current }}...${{ steps.check-version.outputs.latest }}
+
             Auto-updated by [this workflow](https://github.com/oven-sh/bun/actions/workflows/update-cares.yml)

.github/workflows/update-libarchive.yml

@@ -50,11 +50,16 @@ jobs:
             exit 1
           fi
 
-          LATEST_SHA=$(curl -sL "https://api.github.com/repos/libarchive/libarchive/git/ref/tags/$LATEST_TAG" | jq -r '.object.sha')
-          if [ -z "$LATEST_SHA" ] || [ "$LATEST_SHA" = "null" ]; then
+          LATEST_TAG_SHA=$(curl -sL "https://api.github.com/repos/libarchive/libarchive/git/refs/tags/$LATEST_TAG" | jq -r '.object.sha')
+          if [ -z "$LATEST_TAG_SHA" ] || [ "$LATEST_TAG_SHA" = "null" ]; then
             echo "Error: Could not fetch SHA for tag $LATEST_TAG"
             exit 1
           fi
+          LATEST_SHA=$(curl -sL "https://api.github.com/repos/libarchive/libarchive/git/tags/$LATEST_TAG_SHA" | jq -r '.object.sha')
+          if [ -z "$LATEST_SHA" ] || [ "$LATEST_SHA" = "null" ]; then
+            echo "Error: Could not fetch SHA for tag $LATEST_TAG @ $LATEST_TAG_SHA"
+            exit 1
+          fi
 
           if ! [[ $LATEST_SHA =~ ^[0-9a-f]{40}$ ]]; then
             echo "Error: Invalid SHA format received from GitHub"
@@ -89,4 +94,6 @@ jobs:
 
             Updates libarchive to version ${{ steps.check-version.outputs.tag }}
 
+            Compare: https://github.com/libarchive/libarchive/compare/${{ steps.check-version.outputs.current }}...${{ steps.check-version.outputs.latest }}
+
             Auto-updated by [this workflow](https://github.com/oven-sh/bun/actions/workflows/update-libarchive.yml)

.github/workflows/update-libdeflate.yml

@@ -50,11 +50,16 @@ jobs:
             exit 1
           fi
 
-          LATEST_SHA=$(curl -sL "https://api.github.com/repos/ebiggers/libdeflate/git/ref/tags/$LATEST_TAG" | jq -r '.object.sha')
-          if [ -z "$LATEST_SHA" ] || [ "$LATEST_SHA" = "null" ]; then
+          LATEST_TAG_SHA=$(curl -sL "https://api.github.com/repos/ebiggers/libdeflate/git/refs/tags/$LATEST_TAG" | jq -r '.object.sha')
+          if [ -z "$LATEST_TAG_SHA" ] || [ "$LATEST_TAG_SHA" = "null" ]; then
             echo "Error: Could not fetch SHA for tag $LATEST_TAG"
             exit 1
           fi
+          LATEST_SHA=$(curl -sL "https://api.github.com/repos/ebiggers/libdeflate/git/tags/$LATEST_TAG_SHA" | jq -r '.object.sha')
+          if [ -z "$LATEST_SHA" ] || [ "$LATEST_SHA" = "null" ]; then
+            echo "Error: Could not fetch SHA for tag $LATEST_TAG @ $LATEST_TAG_SHA"
+            exit 1
+          fi
 
           if ! [[ $LATEST_SHA =~ ^[0-9a-f]{40}$ ]]; then
             echo "Error: Invalid SHA format received from GitHub"
@@ -89,4 +94,6 @@ jobs:
 
             Updates libdeflate to version ${{ steps.check-version.outputs.tag }}
 
+            Compare: https://github.com/ebiggers/libdeflate/compare/${{ steps.check-version.outputs.current }}...${{ steps.check-version.outputs.latest }}
+
             Auto-updated by [this workflow](https://github.com/oven-sh/bun/actions/workflows/update-libdeflate.yml)

.github/workflows/update-lolhtml.yml

@@ -50,11 +50,16 @@ jobs:
             exit 1
           fi
 
-          LATEST_SHA=$(curl -sL "https://api.github.com/repos/cloudflare/lol-html/git/ref/tags/$LATEST_TAG" | jq -r '.object.sha')
-          if [ -z "$LATEST_SHA" ] || [ "$LATEST_SHA" = "null" ]; then
+          LATEST_TAG_SHA=$(curl -sL "https://api.github.com/repos/cloudflare/lol-html/git/refs/tags/$LATEST_TAG" | jq -r '.object.sha')
+          if [ -z "$LATEST_TAG_SHA" ] || [ "$LATEST_TAG_SHA" = "null" ]; then
             echo "Error: Could not fetch SHA for tag $LATEST_TAG"
             exit 1
           fi
+          LATEST_SHA=$(curl -sL "https://api.github.com/repos/cloudflare/lol-html/git/tags/$LATEST_TAG_SHA" | jq -r '.object.sha')
+          if [ -z "$LATEST_SHA" ] || [ "$LATEST_SHA" = "null" ]; then
+            echo "Error: Could not fetch SHA for tag $LATEST_TAG @ $LATEST_TAG_SHA"
+            exit 1
+          fi
 
           if ! [[ $LATEST_SHA =~ ^[0-9a-f]{40}$ ]]; then
             echo "Error: Invalid SHA format received from GitHub"
@@ -89,4 +94,6 @@ jobs:
 
             Updates lolhtml to version ${{ steps.check-version.outputs.tag }}
 
+            Compare: https://github.com/cloudflare/lol-html/compare/${{ steps.check-version.outputs.current }}...${{ steps.check-version.outputs.latest }}
+
             Auto-updated by [this workflow](https://github.com/oven-sh/bun/actions/workflows/update-lolhtml.yml)

.github/workflows/update-lshpack.yml

@@ -50,11 +50,16 @@ jobs:
             exit 1
           fi
 
-          LATEST_SHA=$(curl -sL "https://api.github.com/repos/litespeedtech/ls-hpack/git/ref/tags/$LATEST_TAG" | jq -r '.object.sha')
-          if [ -z "$LATEST_SHA" ] || [ "$LATEST_SHA" = "null" ]; then
+          LATEST_TAG_SHA=$(curl -sL "https://api.github.com/repos/litespeedtech/ls-hpack/git/refs/tags/$LATEST_TAG" | jq -r '.object.sha')
+          if [ -z "$LATEST_TAG_SHA" ] || [ "$LATEST_TAG_SHA" = "null" ]; then
             echo "Error: Could not fetch SHA for tag $LATEST_TAG"
             exit 1
           fi
+          LATEST_SHA=$(curl -sL "https://api.github.com/repos/litespeedtech/ls-hpack/git/tags/$LATEST_TAG_SHA" | jq -r '.object.sha')
+          if [ -z "$LATEST_SHA" ] || [ "$LATEST_SHA" = "null" ]; then
+            echo "Error: Could not fetch SHA for tag $LATEST_TAG @ $LATEST_TAG_SHA"
+            exit 1
+          fi
 
           if ! [[ $LATEST_SHA =~ ^[0-9a-f]{40}$ ]]; then
             echo "Error: Invalid SHA format received from GitHub"
@@ -89,4 +94,6 @@ jobs:
 
             Updates lshpack to version ${{ steps.check-version.outputs.tag }}
 
+            Compare: https://github.com/litespeedtech/ls-hpack/compare/${{ steps.check-version.outputs.current }}...${{ steps.check-version.outputs.latest }}
+
             Auto-updated by [this workflow](https://github.com/oven-sh/bun/actions/workflows/update-lshpack.yml)

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

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

.github/workflows/update-sqlite3.yml

@@ -55,7 +55,7 @@ jobs:
 
           # Convert numeric version to semantic version for display
           LATEST_MAJOR=$((10#$LATEST_VERSION_NUM / 1000000))
-          LATEST_MINOR=$((($LATEST_VERSION_NUM / 1000) % 1000))
+          LATEST_MINOR=$((($LATEST_VERSION_NUM / 10000) % 100))
           LATEST_PATCH=$((10#$LATEST_VERSION_NUM % 1000))
           LATEST_VERSION="$LATEST_MAJOR.$LATEST_MINOR.$LATEST_PATCH"
 
@@ -106,4 +106,6 @@ jobs:
 
             Updates SQLite to version ${{ steps.check-version.outputs.latest }}
 
+            Compare: https://sqlite.org/src/vdiff?from=${{ steps.check-version.outputs.current }}&to=${{ steps.check-version.outputs.latest }}
+
             Auto-updated by [this workflow](https://github.com/oven-sh/bun/actions/workflows/update-sqlite3.yml)

.github/workflows/update-zstd.yml

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

.github/workflows/zig-format.yml

@@ -1,34 +0,0 @@
-name: zig-format
-
-permissions:
-  contents: write
-
-on:
-  workflow_call:
-  workflow_dispatch:
-  pull_request:
-  merge_group:
-
-env:
-  BUN_VERSION: "1.1.44"
-
-jobs:
-  zig-format:
-    name: zig-format
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-      - name: Setup Bun
-        uses: ./.github/actions/setup-bun
-        with:
-          bun-version: ${{ env.BUN_VERSION }}
-      - name: Zig Format
-        run: |
-          bun run zig-format:diff
-      - name: Commit
-        uses: stefanzweifel/git-auto-commit-action@v5
-        with:
-          commit_message: "`bun run zig-format`"

.gitignore

@@ -16,6 +16,7 @@
 .vscode/clang*
 .vscode/cpp*
 .zig-cache
+.bake-debug
 *.a
 *.bc
 *.big
@@ -151,6 +152,8 @@ src/bake/generated.ts
 test/cli/install/registry/packages/publish-pkg-*
 test/cli/install/registry/packages/@secret/publish-pkg-8
 test/js/third_party/prisma/prisma/sqlite/dev.db-journal
+tmp
+codegen-for-zig-team.tar.gz
 
 # Dependencies
 /vendor
@@ -178,4 +181,6 @@ test/js/third_party/prisma/prisma/sqlite/dev.db-journal
 
 .buildkite/ci.yml
 *.sock
-scratch*.{js,ts,tsx,cjs,mjs}
+scratch*.{js,ts,tsx,cjs,mjs}
+
+*.bun-build

.lldbinit

@@ -1,4 +1,16 @@
-# command script import vendor/zig/tools/lldb_pretty_printers.py
-command script import vendor/WebKit/Tools/lldb/lldb_webkit.py
+# Tell LLDB what to do when the debugged process receives SIGPWR: pass it through to the process
+# (-p), but do not stop the process (-s) or notify the user (-n).
+#
+# JSC's garbage collector sends this signal (as configured by Bun WebKit in
+# Thread::initializePlatformThreading() in ThreadingPOSIX.cpp) to the JS thread to suspend or resume
+# it. So stopping the process would just create noise when debugging any long-running script.
+process handle -p true -s false -n false SIGPWR
 
-# type summary add --summary-string "${var} | inner=${var[0-30]}, source=${var[33-64]}, tag=${var[31-32]}" "unsigned long"
+command script import misctools/lldb/lldb_pretty_printers.py
+type category enable zig.lang
+type category enable zig.std
+
+command script import misctools/lldb/lldb_webkit.py
+
+command script delete btjs
+command alias btjs p {printf("gathering btjs trace...\n");printf("%s\n", (char*)dumpBtjsTrace())}

.prettierignore

@@ -7,3 +7,4 @@ src/react-refresh.js
 *.min.js
 test/snippets
 test/js/node/test
+bun.lock

.vscode/launch.json

@@ -5,6 +5,9 @@
   // - FORCE_COLOR=1 forces colors in the terminal
   // - "${workspaceFolder}/test" is the cwd for `bun test` so it matches CI, we should fix this later
   // - "cppvsdbg" is used instead of "lldb" on Windows, because "lldb" is too slow
+  // - Seeing WebKit files requires `vendor/WebKit` to exist and have code from the right commit.
+  //   Run `bun sync-webkit-source` to ensure that folder is at the right commit. If you haven't
+  //   cloned it at all, that script will suggest how.
   "version": "0.2.0",
   "configurations": [
     // bun test [file]
@@ -13,7 +16,7 @@
       "request": "launch",
       "name": "bun test [file]",
       "program": "${workspaceFolder}/build/debug/bun-debug",
-      "args": ["test", "${file}"],
+      "args": ["test", "--timeout=3600000", "${file}"],
       "cwd": "${workspaceFolder}",
       "env": {
         "BUN_DEBUG_QUIET_LOGS": "1",
@@ -21,15 +24,21 @@
         "BUN_GARBAGE_COLLECTOR_LEVEL": "1",
       },
       "console": "internalConsole",
-      // Don't pause when the GC runs while the debugger is open.
-      "postRunCommands": ["command source '${workspaceFolder}/misctools/lldb/lldb_commands'"],
+      "sourceMap": {
+        // macOS
+        "/Users/runner/work/_temp/webkit-release/vendor/WebKit": "${workspaceFolder}/vendor/WebKit",
+        "/Users/runner/work/_temp/webkit-release/WTF/Headers": "${workspaceFolder}/vendor/WebKit/Source/WTF",
+        // linux
+        "/webkitbuild/vendor/WebKit": "${workspaceFolder}/vendor/WebKit",
+        "/webkitbuild/.WTF/Headers": "${workspaceFolder}/vendor/WebKit/Source/WTF",
+      },
     },
     {
       "type": "lldb",
       "request": "launch",
       "name": "bun test [file] --only",
       "program": "${workspaceFolder}/build/debug/bun-debug",
-      "args": ["test", "--only", "${file}"],
+      "args": ["test", "--timeout=3600000", "--only", "${file}"],
       "cwd": "${workspaceFolder}",
       "env": {
         "BUN_DEBUG_QUIET_LOGS": "1",
@@ -37,21 +46,35 @@
         "BUN_DEBUG_jest": "1",
       },
       "console": "internalConsole",
-      // Don't pause when the GC runs while the debugger is open.
-      "postRunCommands": ["command source '${workspaceFolder}/misctools/lldb/lldb_commands'"],
+      "sourceMap": {
+        // macOS
+        "/Users/runner/work/_temp/webkit-release/vendor/WebKit": "${workspaceFolder}/vendor/WebKit",
+        "/Users/runner/work/_temp/webkit-release/WTF/Headers": "${workspaceFolder}/vendor/WebKit/Source/WTF",
+        // linux
+        "/webkitbuild/vendor/WebKit": "${workspaceFolder}/vendor/WebKit",
+        "/webkitbuild/.WTF/Headers": "${workspaceFolder}/vendor/WebKit/Source/WTF",
+      },
     },
     {
       "type": "lldb",
       "name": "Attach",
       "request": "attach",
       "pid": "${command:pickMyProcess}",
+      "sourceMap": {
+        // macOS
+        "/Users/runner/work/_temp/webkit-release/vendor/WebKit": "${workspaceFolder}/vendor/WebKit",
+        "/Users/runner/work/_temp/webkit-release/WTF/Headers": "${workspaceFolder}/vendor/WebKit/Source/WTF",
+        // linux
+        "/webkitbuild/vendor/WebKit": "${workspaceFolder}/vendor/WebKit",
+        "/webkitbuild/.WTF/Headers": "${workspaceFolder}/vendor/WebKit/Source/WTF",
+      },
     },
     {
       "type": "lldb",
       "request": "launch",
       "name": "bun test [file] (fast)",
       "program": "${workspaceFolder}/build/debug/bun-debug",
-      "args": ["test", "${file}"],
+      "args": ["test", "--timeout=3600000", "${file}"],
       "cwd": "${workspaceFolder}",
       "env": {
         "BUN_DEBUG_QUIET_LOGS": "1",
@@ -59,15 +82,21 @@
         "BUN_GARBAGE_COLLECTOR_LEVEL": "0",
       },
       "console": "internalConsole",
-      // Don't pause when the GC runs while the debugger is open.
-      "postRunCommands": ["command source '${workspaceFolder}/misctools/lldb/lldb_commands'"],
+      "sourceMap": {
+        // macOS
+        "/Users/runner/work/_temp/webkit-release/vendor/WebKit": "${workspaceFolder}/vendor/WebKit",
+        "/Users/runner/work/_temp/webkit-release/WTF/Headers": "${workspaceFolder}/vendor/WebKit/Source/WTF",
+        // linux
+        "/webkitbuild/vendor/WebKit": "${workspaceFolder}/vendor/WebKit",
+        "/webkitbuild/.WTF/Headers": "${workspaceFolder}/vendor/WebKit/Source/WTF",
+      },
     },
     {
       "type": "lldb",
       "request": "launch",
       "name": "bun test [file] (verbose)",
       "program": "${workspaceFolder}/build/debug/bun-debug",
-      "args": ["test", "${file}"],
+      "args": ["test", "--timeout=3600000", "${file}"],
       "cwd": "${workspaceFolder}",
       "env": {
         "BUN_DEBUG_QUIET_LOGS": "0",
@@ -75,15 +104,21 @@
         "BUN_GARBAGE_COLLECTOR_LEVEL": "2",
       },
       "console": "internalConsole",
-      // Don't pause when the GC runs while the debugger is open.
-      "postRunCommands": ["command source '${workspaceFolder}/misctools/lldb/lldb_commands'"],
+      "sourceMap": {
+        // macOS
+        "/Users/runner/work/_temp/webkit-release/vendor/WebKit": "${workspaceFolder}/vendor/WebKit",
+        "/Users/runner/work/_temp/webkit-release/WTF/Headers": "${workspaceFolder}/vendor/WebKit/Source/WTF",
+        // linux
+        "/webkitbuild/vendor/WebKit": "${workspaceFolder}/vendor/WebKit",
+        "/webkitbuild/.WTF/Headers": "${workspaceFolder}/vendor/WebKit/Source/WTF",
+      },
     },
     {
       "type": "lldb",
       "request": "launch",
       "name": "bun test [file] --watch",
       "program": "${workspaceFolder}/build/debug/bun-debug",
-      "args": ["test", "--watch", "${file}"],
+      "args": ["test", "--timeout=3600000", "--watch", "${file}"],
       "cwd": "${workspaceFolder}",
       "env": {
         "BUN_DEBUG_QUIET_LOGS": "1",
@@ -91,15 +126,21 @@
         "BUN_GARBAGE_COLLECTOR_LEVEL": "2",
       },
       "console": "internalConsole",
-      // Don't pause when the GC runs while the debugger is open.
-      "postRunCommands": ["command source '${workspaceFolder}/misctools/lldb/lldb_commands'"],
+      "sourceMap": {
+        // macOS
+        "/Users/runner/work/_temp/webkit-release/vendor/WebKit": "${workspaceFolder}/vendor/WebKit",
+        "/Users/runner/work/_temp/webkit-release/WTF/Headers": "${workspaceFolder}/vendor/WebKit/Source/WTF",
+        // linux
+        "/webkitbuild/vendor/WebKit": "${workspaceFolder}/vendor/WebKit",
+        "/webkitbuild/.WTF/Headers": "${workspaceFolder}/vendor/WebKit/Source/WTF",
+      },
     },
     {
       "type": "lldb",
       "request": "launch",
       "name": "bun test [file] --hot",
       "program": "${workspaceFolder}/build/debug/bun-debug",
-      "args": ["test", "--hot", "${file}"],
+      "args": ["test", "--timeout=3600000", "--hot", "${file}"],
       "cwd": "${workspaceFolder}",
       "env": {
         "BUN_DEBUG_QUIET_LOGS": "1",
@@ -107,15 +148,21 @@
         "BUN_GARBAGE_COLLECTOR_LEVEL": "2",
       },
       "console": "internalConsole",
-      // Don't pause when the GC runs while the debugger is open.
-      "postRunCommands": ["command source '${workspaceFolder}/misctools/lldb/lldb_commands'"],
+      "sourceMap": {
+        // macOS
+        "/Users/runner/work/_temp/webkit-release/vendor/WebKit": "${workspaceFolder}/vendor/WebKit",
+        "/Users/runner/work/_temp/webkit-release/WTF/Headers": "${workspaceFolder}/vendor/WebKit/Source/WTF",
+        // linux
+        "/webkitbuild/vendor/WebKit": "${workspaceFolder}/vendor/WebKit",
+        "/webkitbuild/.WTF/Headers": "${workspaceFolder}/vendor/WebKit/Source/WTF",
+      },
     },
     {
       "type": "lldb",
       "request": "launch",
       "name": "bun test [file] --inspect",
       "program": "${workspaceFolder}/build/debug/bun-debug",
-      "args": ["test", "${file}"],
+      "args": ["test", "--timeout=3600000", "${file}"],
       "cwd": "${workspaceFolder}",
       "env": {
         "BUN_DEBUG_QUIET_LOGS": "1",
@@ -124,8 +171,14 @@
         "BUN_INSPECT": "ws://localhost:0/?wait=1",
       },
       "console": "internalConsole",
-      // Don't pause when the GC runs while the debugger is open.
-      "postRunCommands": ["command source '${workspaceFolder}/misctools/lldb/lldb_commands'"],
+      "sourceMap": {
+        // macOS
+        "/Users/runner/work/_temp/webkit-release/vendor/WebKit": "${workspaceFolder}/vendor/WebKit",
+        "/Users/runner/work/_temp/webkit-release/WTF/Headers": "${workspaceFolder}/vendor/WebKit/Source/WTF",
+        // linux
+        "/webkitbuild/vendor/WebKit": "${workspaceFolder}/vendor/WebKit",
+        "/webkitbuild/.WTF/Headers": "${workspaceFolder}/vendor/WebKit/Source/WTF",
+      },
       "serverReadyAction": {
         "pattern": "https://debug.bun.sh/#localhost:([0-9]+)/",
         "uriFormat": "https://debug.bun.sh/#ws://localhost:%s/",
@@ -137,7 +190,7 @@
       "request": "launch",
       "name": "bun test [file] --inspect-brk",
       "program": "${workspaceFolder}/build/debug/bun-debug",
-      "args": ["test", "${file}"],
+      "args": ["test", "--timeout=3600000", "${file}"],
       "cwd": "${workspaceFolder}",
       "env": {
         "BUN_DEBUG_QUIET_LOGS": "1",
@@ -146,8 +199,14 @@
         "BUN_INSPECT": "ws://localhost:0/?break=1",
       },
       "console": "internalConsole",
-      // Don't pause when the GC runs while the debugger is open.
-      "postRunCommands": ["command source '${workspaceFolder}/misctools/lldb/lldb_commands'"],
+      "sourceMap": {
+        // macOS
+        "/Users/runner/work/_temp/webkit-release/vendor/WebKit": "${workspaceFolder}/vendor/WebKit",
+        "/Users/runner/work/_temp/webkit-release/WTF/Headers": "${workspaceFolder}/vendor/WebKit/Source/WTF",
+        // linux
+        "/webkitbuild/vendor/WebKit": "${workspaceFolder}/vendor/WebKit",
+        "/webkitbuild/.WTF/Headers": "${workspaceFolder}/vendor/WebKit/Source/WTF",
+      },
       "serverReadyAction": {
         "pattern": "https://debug.bun.sh/#localhost:([0-9]+)/",
         "uriFormat": "https://debug.bun.sh/#ws://localhost:%s/",
@@ -168,8 +227,14 @@
         "BUN_GARBAGE_COLLECTOR_LEVEL": "2",
       },
       "console": "internalConsole",
-      // Don't pause when the GC runs while the debugger is open.
-      "postRunCommands": ["command source '${workspaceFolder}/misctools/lldb/lldb_commands'"],
+      "sourceMap": {
+        // macOS
+        "/Users/runner/work/_temp/webkit-release/vendor/WebKit": "${workspaceFolder}/vendor/WebKit",
+        "/Users/runner/work/_temp/webkit-release/WTF/Headers": "${workspaceFolder}/vendor/WebKit/Source/WTF",
+        // linux
+        "/webkitbuild/vendor/WebKit": "${workspaceFolder}/vendor/WebKit",
+        "/webkitbuild/.WTF/Headers": "${workspaceFolder}/vendor/WebKit/Source/WTF",
+      },
     },
     {
       "type": "lldb",
@@ -187,8 +252,14 @@
         "GOMAXPROCS": "1",
       },
       "console": "internalConsole",
-      // Don't pause when the GC runs while the debugger is open.
-      "postRunCommands": ["command source '${workspaceFolder}/misctools/lldb/lldb_commands'"],
+      "sourceMap": {
+        // macOS
+        "/Users/runner/work/_temp/webkit-release/vendor/WebKit": "${workspaceFolder}/vendor/WebKit",
+        "/Users/runner/work/_temp/webkit-release/WTF/Headers": "${workspaceFolder}/vendor/WebKit/Source/WTF",
+        // linux
+        "/webkitbuild/vendor/WebKit": "${workspaceFolder}/vendor/WebKit",
+        "/webkitbuild/.WTF/Headers": "${workspaceFolder}/vendor/WebKit/Source/WTF",
+      },
     },
     {
       "type": "lldb",
@@ -202,8 +273,14 @@
         "BUN_GARBAGE_COLLECTOR_LEVEL": "2",
       },
       "console": "internalConsole",
-      // Don't pause when the GC runs while the debugger is open.
-      "postRunCommands": ["command source '${workspaceFolder}/misctools/lldb/lldb_commands'"],
+      "sourceMap": {
+        // macOS
+        "/Users/runner/work/_temp/webkit-release/vendor/WebKit": "${workspaceFolder}/vendor/WebKit",
+        "/Users/runner/work/_temp/webkit-release/WTF/Headers": "${workspaceFolder}/vendor/WebKit/Source/WTF",
+        // linux
+        "/webkitbuild/vendor/WebKit": "${workspaceFolder}/vendor/WebKit",
+        "/webkitbuild/.WTF/Headers": "${workspaceFolder}/vendor/WebKit/Source/WTF",
+      },
     },
     {
       "type": "lldb",
@@ -213,15 +290,18 @@
       "args": ["run", "--watch", "${file}"],
       "cwd": "${fileDirname}",
       "env": {
-        // "BUN_DEBUG_DEBUGGER": "1",
-        // "BUN_DEBUG_INTERNAL_DEBUGGER": "1",
         "BUN_DEBUG_QUIET_LOGS": "1",
         "BUN_GARBAGE_COLLECTOR_LEVEL": "2",
-        // "BUN_INSPECT": "ws+unix:///var/folders/jk/8fzl9l5119598vsqrmphsw7m0000gn/T/tl15npi7qtf.sock?report=1",
       },
       "console": "internalConsole",
-      // Don't pause when the GC runs while the debugger is open.
-      "postRunCommands": ["command source '${workspaceFolder}/misctools/lldb/lldb_commands'"],
+      "sourceMap": {
+        // macOS
+        "/Users/runner/work/_temp/webkit-release/vendor/WebKit": "${workspaceFolder}/vendor/WebKit",
+        "/Users/runner/work/_temp/webkit-release/WTF/Headers": "${workspaceFolder}/vendor/WebKit/Source/WTF",
+        // linux
+        "/webkitbuild/vendor/WebKit": "${workspaceFolder}/vendor/WebKit",
+        "/webkitbuild/.WTF/Headers": "${workspaceFolder}/vendor/WebKit/Source/WTF",
+      },
     },
     {
       "type": "lldb",
@@ -235,8 +315,14 @@
         "BUN_GARBAGE_COLLECTOR_LEVEL": "2",
       },
       "console": "internalConsole",
-      // Don't pause when the GC runs while the debugger is open.
-      "postRunCommands": ["command source '${workspaceFolder}/misctools/lldb/lldb_commands'"],
+      "sourceMap": {
+        // macOS
+        "/Users/runner/work/_temp/webkit-release/vendor/WebKit": "${workspaceFolder}/vendor/WebKit",
+        "/Users/runner/work/_temp/webkit-release/WTF/Headers": "${workspaceFolder}/vendor/WebKit/Source/WTF",
+        // linux
+        "/webkitbuild/vendor/WebKit": "${workspaceFolder}/vendor/WebKit",
+        "/webkitbuild/.WTF/Headers": "${workspaceFolder}/vendor/WebKit/Source/WTF",
+      },
     },
     {
       "type": "lldb",
@@ -252,8 +338,14 @@
         "BUN_INSPECT": "ws://localhost:0/?wait=1",
       },
       "console": "internalConsole",
-      // Don't pause when the GC runs while the debugger is open.
-      "postRunCommands": ["command source '${workspaceFolder}/misctools/lldb/lldb_commands'"],
+      "sourceMap": {
+        // macOS
+        "/Users/runner/work/_temp/webkit-release/vendor/WebKit": "${workspaceFolder}/vendor/WebKit",
+        "/Users/runner/work/_temp/webkit-release/WTF/Headers": "${workspaceFolder}/vendor/WebKit/Source/WTF",
+        // linux
+        "/webkitbuild/vendor/WebKit": "${workspaceFolder}/vendor/WebKit",
+        "/webkitbuild/.WTF/Headers": "${workspaceFolder}/vendor/WebKit/Source/WTF",
+      },
       "serverReadyAction": {
         "pattern": "https://debug.bun.sh/#localhost:([0-9]+)/",
         "uriFormat": "https://debug.bun.sh/#ws://localhost:%s/",
@@ -274,8 +366,14 @@
         "BUN_INSPECT": "ws://localhost:0/?break=1",
       },
       "console": "internalConsole",
-      // Don't pause when the GC runs while the debugger is open.
-      "postRunCommands": ["command source '${workspaceFolder}/misctools/lldb/lldb_commands'"],
+      "sourceMap": {
+        // macOS
+        "/Users/runner/work/_temp/webkit-release/vendor/WebKit": "${workspaceFolder}/vendor/WebKit",
+        "/Users/runner/work/_temp/webkit-release/WTF/Headers": "${workspaceFolder}/vendor/WebKit/Source/WTF",
+        // linux
+        "/webkitbuild/vendor/WebKit": "${workspaceFolder}/vendor/WebKit",
+        "/webkitbuild/.WTF/Headers": "${workspaceFolder}/vendor/WebKit/Source/WTF",
+      },
       "serverReadyAction": {
         "pattern": "https://debug.bun.sh/#localhost:([0-9]+)/",
         "uriFormat": "https://debug.bun.sh/#ws://localhost:%s/",
@@ -288,7 +386,7 @@
       "request": "launch",
       "name": "bun test [...]",
       "program": "${workspaceFolder}/build/debug/bun-debug",
-      "args": ["test", "${input:testName}"],
+      "args": ["test", "--timeout=3600000", "${input:testName}"],
       "cwd": "${workspaceFolder}",
       "env": {
         "BUN_DEBUG_QUIET_LOGS": "1",
@@ -296,15 +394,21 @@
         "BUN_GARBAGE_COLLECTOR_LEVEL": "2",
       },
       "console": "internalConsole",
-      // Don't pause when the GC runs while the debugger is open.
-      "postRunCommands": ["command source '${workspaceFolder}/misctools/lldb/lldb_commands'"],
+      "sourceMap": {
+        // macOS
+        "/Users/runner/work/_temp/webkit-release/vendor/WebKit": "${workspaceFolder}/vendor/WebKit",
+        "/Users/runner/work/_temp/webkit-release/WTF/Headers": "${workspaceFolder}/vendor/WebKit/Source/WTF",
+        // linux
+        "/webkitbuild/vendor/WebKit": "${workspaceFolder}/vendor/WebKit",
+        "/webkitbuild/.WTF/Headers": "${workspaceFolder}/vendor/WebKit/Source/WTF",
+      },
     },
     {
       "type": "lldb",
       "request": "launch",
       "name": "bun test [...] (fast)",
       "program": "${workspaceFolder}/build/debug/bun-debug",
-      "args": ["test", "${input:testName}"],
+      "args": ["test", "--timeout=3600000", "${input:testName}"],
       "cwd": "${workspaceFolder}",
       "env": {
         "BUN_DEBUG_QUIET_LOGS": "1",
@@ -312,15 +416,21 @@
         "BUN_GARBAGE_COLLECTOR_LEVEL": "0",
       },
       "console": "internalConsole",
-      // Don't pause when the GC runs while the debugger is open.
-      "postRunCommands": ["command source '${workspaceFolder}/misctools/lldb/lldb_commands'"],
+      "sourceMap": {
+        // macOS
+        "/Users/runner/work/_temp/webkit-release/vendor/WebKit": "${workspaceFolder}/vendor/WebKit",
+        "/Users/runner/work/_temp/webkit-release/WTF/Headers": "${workspaceFolder}/vendor/WebKit/Source/WTF",
+        // linux
+        "/webkitbuild/vendor/WebKit": "${workspaceFolder}/vendor/WebKit",
+        "/webkitbuild/.WTF/Headers": "${workspaceFolder}/vendor/WebKit/Source/WTF",
+      },
     },
     {
       "type": "lldb",
       "request": "launch",
       "name": "bun test [...] (verbose)",
       "program": "${workspaceFolder}/build/debug/bun-debug",
-      "args": ["test", "${input:testName}"],
+      "args": ["test", "--timeout=3600000", "${input:testName}"],
       "cwd": "${workspaceFolder}",
       "env": {
         "BUN_DEBUG_QUIET_LOGS": "1",
@@ -328,15 +438,21 @@
         "BUN_GARBAGE_COLLECTOR_LEVEL": "2",
       },
       "console": "internalConsole",
-      // Don't pause when the GC runs while the debugger is open.
-      "postRunCommands": ["command source '${workspaceFolder}/misctools/lldb/lldb_commands'"],
+      "sourceMap": {
+        // macOS
+        "/Users/runner/work/_temp/webkit-release/vendor/WebKit": "${workspaceFolder}/vendor/WebKit",
+        "/Users/runner/work/_temp/webkit-release/WTF/Headers": "${workspaceFolder}/vendor/WebKit/Source/WTF",
+        // linux
+        "/webkitbuild/vendor/WebKit": "${workspaceFolder}/vendor/WebKit",
+        "/webkitbuild/.WTF/Headers": "${workspaceFolder}/vendor/WebKit/Source/WTF",
+      },
     },
     {
       "type": "lldb",
       "request": "launch",
       "name": "bun test [...] --watch",
       "program": "${workspaceFolder}/build/debug/bun-debug",
-      "args": ["test", "--watch", "${input:testName}"],
+      "args": ["test", "--timeout=3600000", "--watch", "${input:testName}"],
       "cwd": "${workspaceFolder}",
       "env": {
         "BUN_DEBUG_QUIET_LOGS": "1",
@@ -344,15 +460,21 @@
         "BUN_GARBAGE_COLLECTOR_LEVEL": "2",
       },
       "console": "internalConsole",
-      // Don't pause when the GC runs while the debugger is open.
-      "postRunCommands": ["command source '${workspaceFolder}/misctools/lldb/lldb_commands'"],
+      "sourceMap": {
+        // macOS
+        "/Users/runner/work/_temp/webkit-release/vendor/WebKit": "${workspaceFolder}/vendor/WebKit",
+        "/Users/runner/work/_temp/webkit-release/WTF/Headers": "${workspaceFolder}/vendor/WebKit/Source/WTF",
+        // linux
+        "/webkitbuild/vendor/WebKit": "${workspaceFolder}/vendor/WebKit",
+        "/webkitbuild/.WTF/Headers": "${workspaceFolder}/vendor/WebKit/Source/WTF",
+      },
     },
     {
       "type": "lldb",
       "request": "launch",
       "name": "bun test [...] --hot",
       "program": "${workspaceFolder}/build/debug/bun-debug",
-      "args": ["test", "--hot", "${input:testName}"],
+      "args": ["test", "--timeout=3600000", "--hot", "${input:testName}"],
       "cwd": "${workspaceFolder}",
       "env": {
         "BUN_DEBUG_QUIET_LOGS": "1",
@@ -360,15 +482,21 @@
         "BUN_GARBAGE_COLLECTOR_LEVEL": "2",
       },
       "console": "internalConsole",
-      // Don't pause when the GC runs while the debugger is open.
-      "postRunCommands": ["command source '${workspaceFolder}/misctools/lldb/lldb_commands'"],
+      "sourceMap": {
+        // macOS
+        "/Users/runner/work/_temp/webkit-release/vendor/WebKit": "${workspaceFolder}/vendor/WebKit",
+        "/Users/runner/work/_temp/webkit-release/WTF/Headers": "${workspaceFolder}/vendor/WebKit/Source/WTF",
+        // linux
+        "/webkitbuild/vendor/WebKit": "${workspaceFolder}/vendor/WebKit",
+        "/webkitbuild/.WTF/Headers": "${workspaceFolder}/vendor/WebKit/Source/WTF",
+      },
     },
     {
       "type": "lldb",
       "request": "launch",
       "name": "bun test [...] --inspect",
       "program": "${workspaceFolder}/build/debug/bun-debug",
-      "args": ["test", "${input:testName}"],
+      "args": ["test", "--timeout=3600000", "${input:testName}"],
       "cwd": "${workspaceFolder}",
       "env": {
         "BUN_DEBUG_QUIET_LOGS": "1",
@@ -377,8 +505,14 @@
         "BUN_INSPECT": "ws://localhost:0/?wait=1",
       },
       "console": "internalConsole",
-      // Don't pause when the GC runs while the debugger is open.
-      "postRunCommands": ["command source '${workspaceFolder}/misctools/lldb/lldb_commands'"],
+      "sourceMap": {
+        // macOS
+        "/Users/runner/work/_temp/webkit-release/vendor/WebKit": "${workspaceFolder}/vendor/WebKit",
+        "/Users/runner/work/_temp/webkit-release/WTF/Headers": "${workspaceFolder}/vendor/WebKit/Source/WTF",
+        // linux
+        "/webkitbuild/vendor/WebKit": "${workspaceFolder}/vendor/WebKit",
+        "/webkitbuild/.WTF/Headers": "${workspaceFolder}/vendor/WebKit/Source/WTF",
+      },
       "serverReadyAction": {
         "pattern": "https://debug.bun.sh/#localhost:([0-9]+)/",
         "uriFormat": "https://debug.bun.sh/#ws://localhost:%s/",
@@ -390,7 +524,7 @@
       "request": "launch",
       "name": "bun test [...] --inspect-brk",
       "program": "${workspaceFolder}/build/debug/bun-debug",
-      "args": ["test", "${input:testName}"],
+      "args": ["test", "--timeout=3600000", "${input:testName}"],
       "cwd": "${workspaceFolder}",
       "env": {
         "BUN_DEBUG_QUIET_LOGS": "1",
@@ -399,8 +533,14 @@
         "BUN_INSPECT": "ws://localhost:0/?break=1",
       },
       "console": "internalConsole",
-      // Don't pause when the GC runs while the debugger is open.
-      "postRunCommands": ["command source '${workspaceFolder}/misctools/lldb/lldb_commands'"],
+      "sourceMap": {
+        // macOS
+        "/Users/runner/work/_temp/webkit-release/vendor/WebKit": "${workspaceFolder}/vendor/WebKit",
+        "/Users/runner/work/_temp/webkit-release/WTF/Headers": "${workspaceFolder}/vendor/WebKit/Source/WTF",
+        // linux
+        "/webkitbuild/vendor/WebKit": "${workspaceFolder}/vendor/WebKit",
+        "/webkitbuild/.WTF/Headers": "${workspaceFolder}/vendor/WebKit/Source/WTF",
+      },
       "serverReadyAction": {
         "pattern": "https://debug.bun.sh/#localhost:([0-9]+)/",
         "uriFormat": "https://debug.bun.sh/#ws://localhost:%s/",
@@ -420,8 +560,14 @@
         "BUN_GARBAGE_COLLECTOR_LEVEL": "2",
       },
       "console": "internalConsole",
-      // Don't pause when the GC runs while the debugger is open.
-      "postRunCommands": ["command source '${workspaceFolder}/misctools/lldb/lldb_commands'"],
+      "sourceMap": {
+        // macOS
+        "/Users/runner/work/_temp/webkit-release/vendor/WebKit": "${workspaceFolder}/vendor/WebKit",
+        "/Users/runner/work/_temp/webkit-release/WTF/Headers": "${workspaceFolder}/vendor/WebKit/Source/WTF",
+        // linux
+        "/webkitbuild/vendor/WebKit": "${workspaceFolder}/vendor/WebKit",
+        "/webkitbuild/.WTF/Headers": "${workspaceFolder}/vendor/WebKit/Source/WTF",
+      },
     },
     // bun test [*]
     {
@@ -436,8 +582,14 @@
         "BUN_GARBAGE_COLLECTOR_LEVEL": "2",
       },
       "console": "internalConsole",
-      // Don't pause when the GC runs while the debugger is open.
-      "postRunCommands": ["command source '${workspaceFolder}/misctools/lldb/lldb_commands'"],
+      "sourceMap": {
+        // macOS
+        "/Users/runner/work/_temp/webkit-release/vendor/WebKit": "${workspaceFolder}/vendor/WebKit",
+        "/Users/runner/work/_temp/webkit-release/WTF/Headers": "${workspaceFolder}/vendor/WebKit/Source/WTF",
+        // linux
+        "/webkitbuild/vendor/WebKit": "${workspaceFolder}/vendor/WebKit",
+        "/webkitbuild/.WTF/Headers": "${workspaceFolder}/vendor/WebKit/Source/WTF",
+      },
     },
     {
       "type": "lldb",
@@ -451,8 +603,14 @@
         "BUN_GARBAGE_COLLECTOR_LEVEL": "0",
       },
       "console": "internalConsole",
-      // Don't pause when the GC runs while the debugger is open.
-      "postRunCommands": ["command source '${workspaceFolder}/misctools/lldb/lldb_commands'"],
+      "sourceMap": {
+        // macOS
+        "/Users/runner/work/_temp/webkit-release/vendor/WebKit": "${workspaceFolder}/vendor/WebKit",
+        "/Users/runner/work/_temp/webkit-release/WTF/Headers": "${workspaceFolder}/vendor/WebKit/Source/WTF",
+        // linux
+        "/webkitbuild/vendor/WebKit": "${workspaceFolder}/vendor/WebKit",
+        "/webkitbuild/.WTF/Headers": "${workspaceFolder}/vendor/WebKit/Source/WTF",
+      },
     },
     {
       "type": "lldb",
@@ -467,8 +625,14 @@
         "BUN_INSPECT": "ws://localhost:0/",
       },
       "console": "internalConsole",
-      // Don't pause when the GC runs while the debugger is open.
-      "postRunCommands": ["command source '${workspaceFolder}/misctools/lldb/lldb_commands'"],
+      "sourceMap": {
+        // macOS
+        "/Users/runner/work/_temp/webkit-release/vendor/WebKit": "${workspaceFolder}/vendor/WebKit",
+        "/Users/runner/work/_temp/webkit-release/WTF/Headers": "${workspaceFolder}/vendor/WebKit/Source/WTF",
+        // linux
+        "/webkitbuild/vendor/WebKit": "${workspaceFolder}/vendor/WebKit",
+        "/webkitbuild/.WTF/Headers": "${workspaceFolder}/vendor/WebKit/Source/WTF",
+      },
       "serverReadyAction": {
         "pattern": "https://debug.bun.sh/#localhost:([0-9]+)/",
         "uriFormat": "https://debug.bun.sh/#ws://localhost:%s/",
@@ -487,8 +651,14 @@
         "BUN_GARBAGE_COLLECTOR_LEVEL": "2",
       },
       "console": "internalConsole",
-      // Don't pause when the GC runs while the debugger is open.
-      "postRunCommands": ["command source '${workspaceFolder}/misctools/lldb/lldb_commands'"],
+      "sourceMap": {
+        // macOS
+        "/Users/runner/work/_temp/webkit-release/vendor/WebKit": "${workspaceFolder}/vendor/WebKit",
+        "/Users/runner/work/_temp/webkit-release/WTF/Headers": "${workspaceFolder}/vendor/WebKit/Source/WTF",
+        // linux
+        "/webkitbuild/vendor/WebKit": "${workspaceFolder}/vendor/WebKit",
+        "/webkitbuild/.WTF/Headers": "${workspaceFolder}/vendor/WebKit/Source/WTF",
+      },
     },
     {
       "type": "lldb",
@@ -502,8 +672,14 @@
         "BUN_GARBAGE_COLLECTOR_LEVEL": "2",
       },
       "console": "internalConsole",
-      // Don't pause when the GC runs while the debugger is open.
-      "postRunCommands": ["command source '${workspaceFolder}/misctools/lldb/lldb_commands'"],
+      "sourceMap": {
+        // macOS
+        "/Users/runner/work/_temp/webkit-release/vendor/WebKit": "${workspaceFolder}/vendor/WebKit",
+        "/Users/runner/work/_temp/webkit-release/WTF/Headers": "${workspaceFolder}/vendor/WebKit/Source/WTF",
+        // linux
+        "/webkitbuild/vendor/WebKit": "${workspaceFolder}/vendor/WebKit",
+        "/webkitbuild/.WTF/Headers": "${workspaceFolder}/vendor/WebKit/Source/WTF",
+      },
     },
     // Windows: bun test [file]
     {
@@ -514,7 +690,7 @@
       "request": "launch",
       "name": "Windows: bun test [file]",
       "program": "${workspaceFolder}/build/debug/bun-debug.exe",
-      "args": ["test", "${file}"],
+      "args": ["test", "--timeout=3600000", "${file}"],
       "cwd": "${workspaceFolder}",
       "environment": [
         {
@@ -539,7 +715,7 @@
       "request": "launch",
       "name": "Windows: bun test --only [file]",
       "program": "${workspaceFolder}/build/debug/bun-debug.exe",
-      "args": ["test", "--only", "${file}"],
+      "args": ["test", "--timeout=3600000", "--only", "${file}"],
       "cwd": "${workspaceFolder}",
       "environment": [
         {
@@ -564,7 +740,7 @@
       "request": "launch",
       "name": "Windows: bun test [file] (fast)",
       "program": "${workspaceFolder}/build/debug/bun-debug.exe",
-      "args": ["test", "${file}"],
+      "args": ["test", "--timeout=3600000", "${file}"],
       "cwd": "${workspaceFolder}",
       "environment": [
         {
@@ -589,7 +765,7 @@
       "request": "launch",
       "name": "Windows: bun test [file] (verbose)",
       "program": "${workspaceFolder}/build/debug/bun-debug.exe",
-      "args": ["test", "${file}"],
+      "args": ["test", "--timeout=3600000", "${file}"],
       "cwd": "${workspaceFolder}",
       "environment": [
         {
@@ -614,7 +790,7 @@
       "request": "launch",
       "name": "Windows: bun test [file] --inspect",
       "program": "${workspaceFolder}/build/debug/bun-debug.exe",
-      "args": ["test", "${file}"],
+      "args": ["test", "--timeout=3600000", "${file}"],
       "cwd": "${workspaceFolder}",
       "environment": [
         {
@@ -648,7 +824,7 @@
       "request": "launch",
       "name": "Windows: bun test [file] --inspect-brk",
       "program": "${workspaceFolder}/build/debug/bun-debug.exe",
-      "args": ["test", "${file}"],
+      "args": ["test", "--timeout=3600000", "${file}"],
       "cwd": "${workspaceFolder}",
       "environment": [
         {
@@ -815,7 +991,7 @@
       "request": "launch",
       "name": "Windows: bun test [...]",
       "program": "${workspaceFolder}/build/debug/bun-debug.exe",
-      "args": ["test", "${input:testName}"],
+      "args": ["test", "--timeout=3600000", "${input:testName}"],
       "cwd": "${workspaceFolder}",
       "environment": [
         {
@@ -840,7 +1016,7 @@
       "request": "launch",
       "name": "Windows: bun test [...] (fast)",
       "program": "${workspaceFolder}/build/debug/bun-debug.exe",
-      "args": ["test", "${input:testName}"],
+      "args": ["test", "--timeout=3600000", "${input:testName}"],
       "cwd": "${workspaceFolder}",
       "environment": [
         {
@@ -865,7 +1041,7 @@
       "request": "launch",
       "name": "Windows: bun test [...] (verbose)",
       "program": "${workspaceFolder}/build/debug/bun-debug.exe",
-      "args": ["test", "${input:testName}"],
+      "args": ["test", "--timeout=3600000", "${input:testName}"],
       "cwd": "${workspaceFolder}",
       "environment": [
         {
@@ -890,7 +1066,7 @@
       "request": "launch",
       "name": "Windows: bun test [...] --watch",
       "program": "${workspaceFolder}/build/debug/bun-debug.exe",
-      "args": ["test", "--watch", "${input:testName}"],
+      "args": ["test", "--timeout=3600000", "--watch", "${input:testName}"],
       "cwd": "${workspaceFolder}",
       "environment": [
         {
@@ -915,7 +1091,7 @@
       "request": "launch",
       "name": "Windows: bun test [...] --hot",
       "program": "${workspaceFolder}/build/debug/bun-debug.exe",
-      "args": ["test", "--hot", "${input:testName}"],
+      "args": ["test", "--timeout=3600000", "--hot", "${input:testName}"],
       "cwd": "${workspaceFolder}",
       "environment": [
         {
@@ -940,7 +1116,7 @@
       "request": "launch",
       "name": "Windows: bun test [...] --inspect",
       "program": "${workspaceFolder}/build/debug/bun-debug.exe",
-      "args": ["test", "${input:testName}"],
+      "args": ["test", "--timeout=3600000", "${input:testName}"],
       "cwd": "${workspaceFolder}",
       "environment": [
         {
@@ -974,7 +1150,7 @@
       "request": "launch",
       "name": "Windows: bun test [...] --inspect-brk",
       "program": "${workspaceFolder}/build/debug/bun-debug.exe",
-      "args": ["test", "${input:testName}"],
+      "args": ["test", "--timeout=3600000", "${input:testName}"],
       "cwd": "${workspaceFolder}",
       "environment": [
         {
@@ -1129,7 +1305,44 @@
       ],
       "console": "internalConsole",
       // Don't pause when the GC runs while the debugger is open.
-      "postRunCommands": ["command source '${workspaceFolder}/misctools/lldb/lldb_commands'"],
+    },
+    {
+      "type": "bun",
+      "name": "[JS] bun test [file]",
+      "runtime": "${workspaceFolder}/build/debug/bun-debug",
+      "runtimeArgs": ["test", "${file}"],
+      "cwd": "${workspaceFolder}",
+      "env": {
+        "BUN_DEBUG_QUIET_LOGS": "1",
+        "BUN_GARBAGE_COLLECTOR_LEVEL": "2",
+      },
+    },
+    {
+      "type": "bun",
+      "name": "[JS] bun run [file]",
+      "runtime": "${workspaceFolder}/build/debug/bun-debug",
+      "runtimeArgs": ["run", "${file}"],
+      "cwd": "${workspaceFolder}",
+      "env": {
+        "BUN_DEBUG_QUIET_LOGS": "1",
+        "BUN_GARBAGE_COLLECTOR_LEVEL": "2",
+      },
+    },
+    {
+      "type": "midas-rr",
+      "request": "attach",
+      "name": "rr",
+      "trace": "Off",
+      "setupCommands": [
+        "handle SIGPWR nostop noprint pass",
+        "source ${workspaceFolder}/misctools/gdb/std_gdb_pretty_printers.py",
+        "source ${workspaceFolder}/misctools/gdb/zig_gdb_pretty_printers.py",
+        "set substitute-path /webkitbuild/vendor/WebKit ${workspaceFolder}/vendor/WebKit",
+        "set substitute-path /webkitbuild/.WTF/Headers ${workspaceFolder}/vendor/WebKit/Source/WTF",
+        // uncomment if you like
+        // "set disassembly-flavor intel",
+        "set print asm-demangle",
+      ],
     },
   ],
   "inputs": [

.vscode/settings.json

@@ -30,18 +30,22 @@
   "zig.initialSetupDone": true,
   "zig.buildOption": "build",
   "zig.zls.zigLibPath": "${workspaceFolder}/vendor/zig/lib",
-  "zig.buildArgs": ["-Dgenerated-code=./build/debug/codegen"],
+  "zig.buildArgs": ["-Dgenerated-code=./build/debug/codegen", "--watch", "-fincremental"],
   "zig.zls.buildOnSaveStep": "check",
   // "zig.zls.enableBuildOnSave": true,
   // "zig.buildOnSave": true,
   "zig.buildFilePath": "${workspaceFolder}/build.zig",
   "zig.path": "${workspaceFolder}/vendor/zig/zig.exe",
+  "zig.zls.path": "${workspaceFolder}/vendor/zig/zls.exe",
   "zig.formattingProvider": "zls",
   "zig.zls.enableInlayHints": false,
   "[zig]": {
     "editor.tabSize": 4,
     "editor.useTabStops": false,
     "editor.defaultFormatter": "ziglang.vscode-zig",
+    "editor.codeActionsOnSave": {
+      "source.organizeImports": "never",
+    },
   },
 
   // lldb
@@ -63,6 +67,7 @@
     "editor.tabSize": 4,
     "editor.defaultFormatter": "xaver.clang-format",
   },
+  "clangd.arguments": ["--header-insertion=never"],
 
   // JavaScript
   "prettier.enable": true,
@@ -134,13 +139,15 @@
     "**/*.xcscheme": true,
     "**/*.xcodeproj": true,
     "**/*.i": true,
-
-    // uws WebSocket.cpp conflicts with webcore WebSocket.cpp
-    "packages/bun-uws/fuzzing": true,
   },
   "files.associations": {
+    "*.css": "tailwindcss",
     "*.idl": "cpp",
+    "*.mdc": "markdown",
     "array": "cpp",
+    "ios": "cpp",
+    "oxlint.json": "jsonc",
+    "bun.lock": "jsonc",
   },
   "C_Cpp.files.exclude": {
     "**/.vscode": true,

AGENTS.md

@@ -0,0 +1,36 @@
+## bun tests
+
+**IMPORTANT**: use the `bun bd` command instead of the `bun` command. For example:
+
+✅ Good
+
+```sh
+bun bd test internal/ban-words.test.ts
+bun bd ./foo.ts
+```
+
+The `bun bd` command runs the DEBUG build. If you forget to run the debug build, your changes will not be reflected..
+
+### Run a file
+
+To run a file, you can use the `bun bd <file-path>` command.
+
+```sh
+bun bd ./foo.ts
+```
+
+### Run tests
+
+To run a single test, you need to use the `bun bd test <test-name>` command.
+
+```sh
+bun bd test internal/ban-words.test.ts
+```
+
+You must ALWAYS make sure to pass a file path to the `bun bd test <file-path>` command. DO NOT try to run ALL the tests at once unless you're in a specific subdirectory.
+
+### Run a Node.js test
+
+```sh
+bun bd --silent node:test test-fs-link
+```

CMakeLists.txt

@@ -12,6 +12,12 @@ list(APPEND CMAKE_MODULE_PATH
 include(Policies)
 include(Globals)
 
+if (CMAKE_HOST_WIN32)
+  # Workaround for TLS certificate verification issue on Windows when downloading from GitHub
+  # Remove this once we've bumped the CI machines build image
+  set(CMAKE_TLS_VERIFY 0)
+endif()
+
 # --- Compilers ---
 
 if(CMAKE_HOST_APPLE)

CONTRIBUTING.md

@@ -53,17 +53,17 @@ $ brew install bun
 
 ## Install LLVM
 
-Bun requires LLVM 18 (`clang` is part of LLVM). This version requirement is to match WebKit (precompiled), as mismatching versions will cause memory allocation failures at runtime. In most cases, you can install LLVM through your system package manager:
+Bun requires LLVM 19 (`clang` is part of LLVM). This version requirement is to match WebKit (precompiled), as mismatching versions will cause memory allocation failures at runtime. In most cases, you can install LLVM through your system package manager:
 
 {% codetabs group="os" %}
 
 ```bash#macOS (Homebrew)
-$ brew install llvm@18
+$ brew install llvm@19
 ```
 
 ```bash#Ubuntu/Debian
 $ # LLVM has an automatic installation script that is compatible with all versions of Ubuntu
-$ wget https://apt.llvm.org/llvm.sh -O - | sudo bash -s -- 18 all
+$ wget https://apt.llvm.org/llvm.sh -O - | sudo bash -s -- 19 all
 ```
 
 ```bash#Arch
@@ -71,21 +71,21 @@ $ sudo pacman -S llvm clang lld
 ```
 
 ```bash#Fedora
-$ sudo dnf install llvm18 clang18 lld18-devel
+$ sudo dnf install llvm clang lld-devel
 ```
 
 ```bash#openSUSE Tumbleweed
-$ sudo zypper install clang18 lld18 llvm18
+$ sudo zypper install clang19 lld19 llvm19
 ```
 
 {% /codetabs %}
 
-If none of the above solutions apply, you will have to install it [manually](https://github.com/llvm/llvm-project/releases/tag/llvmorg-18.1.8).
+If none of the above solutions apply, you will have to install it [manually](https://github.com/llvm/llvm-project/releases/tag/llvmorg-19.1.7).
 
-Make sure Clang/LLVM 18 is in your path:
+Make sure Clang/LLVM 19 is in your path:
 
 ```bash
-$ which clang-18
+$ which clang-19
 ```
 
 If not, run this to manually add it:
@@ -94,13 +94,13 @@ If not, run this to manually add it:
 
 ```bash#macOS (Homebrew)
 # use fish_add_path if you're using fish
-# use path+="$(brew --prefix llvm@18)/bin" if you are using zsh
-$ export PATH="$(brew --prefix llvm@18)/bin:$PATH"
+# use path+="$(brew --prefix llvm@19)/bin" if you are using zsh
+$ export PATH="$(brew --prefix llvm@19)/bin:$PATH"
 ```
 
 ```bash#Arch
 # use fish_add_path if you're using fish
-$ export PATH="$PATH:/usr/lib/llvm18/bin"
+$ export PATH="$PATH:/usr/lib/llvm19/bin"
 ```
 
 {% /codetabs %}
@@ -134,6 +134,16 @@ We recommend adding `./build/debug` to your `$PATH` so that you can run `bun-deb
 $ bun-debug
 ```
 
+## Running debug builds
+
+The `bd` package.json script compiles and runs a debug build of Bun, only printing the output of the build process if it fails.
+
+```sh
+$ bun bd <args>
+$ bun bd test foo.test.ts
+$ bun bd ./foo.ts
+```
+
 ## Code generation scripts
 
 Several code generation scripts are used during Bun's build process. These are run automatically when changes are made to certain files.
@@ -205,18 +215,33 @@ WebKit is not cloned by default (to save time and disk space). To clone and buil
 # Clone WebKit into ./vendor/WebKit
 $ git clone https://github.com/oven-sh/WebKit vendor/WebKit
 
+# Check out the commit hash specified in `set(WEBKIT_VERSION <commit_hash>)` in cmake/tools/SetupWebKit.cmake
+$ git -C vendor/WebKit checkout <commit_hash>
+
 # Make a debug build of JSC. This will output build artifacts in ./vendor/WebKit/WebKitBuild/Debug
 # Optionally, you can use `make jsc` for a release build
-$ make jsc-debug
+$ make jsc-debug && rm vendor/WebKit/WebKitBuild/Debug/JavaScriptCore/DerivedSources/inspector/InspectorProtocolObjects.h
+
+# After an initial run of `make jsc-debug`, you can rebuild JSC with:
+$ cmake --build vendor/WebKit/WebKitBuild/Debug --target jsc && rm vendor/WebKit/WebKitBuild/Debug/JavaScriptCore/DerivedSources/inspector/InspectorProtocolObjects.h
 
 # Build bun with the local JSC build
 $ bun run build:local
 ```
 
+Using `bun run build:local` will build Bun in the `./build/debug-local` directory (instead of `./build/debug`), you'll have to change a couple of places to use this new directory:
+
+- The first line in [`src/js/builtins.d.ts`](/src/js/builtins.d.ts)
+- The `CompilationDatabase` line in [`.clangd` config](/.clangd) should be `CompilationDatabase: build/debug-local`
+- In [`build.zig`](/build.zig), the `codegen_path` option should be `build/debug-local/codegen` (instead of `build/debug/codegen`)
+- In [`.vscode/launch.json`](/.vscode/launch.json), many configurations use `./build/debug/`, change them as you see fit
+
 Note that the WebKit folder, including build artifacts, is 8GB+ in size.
 
 If you are using a JSC debug build and using VScode, make sure to run the `C/C++: Select a Configuration` command to configure intellisense to find the debug headers.
 
+Note that if you change make changes to our [WebKit fork](https://github.com/oven-sh/WebKit), you will also have to change [`SetupWebKit.cmake`](/cmake/tools/SetupWebKit.cmake) to point to the commit hash.
+
 ## Troubleshooting
 
 ### 'span' file not found on Ubuntu
@@ -238,7 +263,7 @@ The issue may manifest when initially running `bun setup` as Clang being unable
 ```
 The C++ compiler
 
-  "/usr/bin/clang++-18"
+  "/usr/bin/clang++-19"
 
 is not able to compile a simple test program.
 ```

LATEST

@@ -1 +1 @@
-1.2.0
+1.2.15

Makefile

@@ -91,9 +91,9 @@ ZIG ?= $(shell which zig 2>/dev/null || echo -e "error: Missing zig. Please make
 # This is easier to happen than you'd expect.
 # Using realpath here causes issues because clang uses clang++ as a symlink
 # so if that's resolved, it won't build for C++
-REAL_CC = $(shell which clang-16 2>/dev/null || which clang 2>/dev/null)
-REAL_CXX = $(shell which clang++-16 2>/dev/null || which clang++ 2>/dev/null)
-CLANG_FORMAT = $(shell which clang-format-16 2>/dev/null || which clang-format 2>/dev/null)
+REAL_CC = $(shell which clang-19 2>/dev/null || which clang 2>/dev/null)
+REAL_CXX = $(shell which clang++-19 2>/dev/null || which clang++ 2>/dev/null)
+CLANG_FORMAT = $(shell which clang-format-19 2>/dev/null || which clang-format 2>/dev/null)
 
 CC = $(REAL_CC)
 CXX = $(REAL_CXX)
@@ -117,14 +117,14 @@ CC_WITH_CCACHE = $(CCACHE_PATH) $(CC)
 ifeq ($(OS_NAME),darwin)
 # Find LLVM
 	ifeq ($(wildcard $(LLVM_PREFIX)),)
-		LLVM_PREFIX = $(shell brew --prefix llvm@16)
+		LLVM_PREFIX = $(shell brew --prefix llvm@19)
 	endif
 	ifeq ($(wildcard $(LLVM_PREFIX)),)
 		LLVM_PREFIX = $(shell brew --prefix llvm)
 	endif
 	ifeq ($(wildcard $(LLVM_PREFIX)),)
 #   This is kinda ugly, but I can't find a better way to error :(
-		LLVM_PREFIX = $(shell echo -e "error: Unable to find llvm. Please run 'brew install llvm@16' or set LLVM_PREFIX=/path/to/llvm")
+		LLVM_PREFIX = $(shell echo -e "error: Unable to find llvm. Please run 'brew install llvm@19' or set LLVM_PREFIX=/path/to/llvm")
 	endif
 
 	LDFLAGS += -L$(LLVM_PREFIX)/lib
@@ -164,7 +164,7 @@ CMAKE_FLAGS_WITHOUT_RELEASE = -DCMAKE_C_COMPILER=$(CC) \
 	-DCMAKE_OSX_DEPLOYMENT_TARGET=$(MIN_MACOS_VERSION) \
 	$(CMAKE_CXX_COMPILER_LAUNCHER_FLAG) \
 	-DCMAKE_AR=$(AR) \
-	-DCMAKE_RANLIB=$(which llvm-16-ranlib 2>/dev/null || which llvm-ranlib 2>/dev/null) \
+	-DCMAKE_RANLIB=$(which llvm-19-ranlib 2>/dev/null || which llvm-ranlib 2>/dev/null) \
 	-DCMAKE_CXX_STANDARD=20 \
 	-DCMAKE_C_STANDARD=17 \
 	-DCMAKE_CXX_STANDARD_REQUIRED=ON \
@@ -191,7 +191,7 @@ endif
 
 ifeq ($(OS_NAME),linux)
 LIBICONV_PATH =
-AR = $(shell which llvm-ar-16 2>/dev/null || which llvm-ar 2>/dev/null || which ar 2>/dev/null)
+AR = $(shell which llvm-ar-19 2>/dev/null || which llvm-ar 2>/dev/null || which ar 2>/dev/null)
 endif
 
 OPTIMIZATION_LEVEL=-O3 $(MARCH_NATIVE)
@@ -255,7 +255,7 @@ DEFAULT_LINKER_FLAGS= -pthread -ldl
 endif
 ifeq ($(OS_NAME),darwin)
     _MIMALLOC_OBJECT_FILE = 0
-	JSC_BUILD_STEPS += jsc-build-mac jsc-copy-headers
+	JSC_BUILD_STEPS += jsc-build-mac
 	JSC_BUILD_STEPS_DEBUG += jsc-build-mac-debug
 	_MIMALLOC_FILE = libmimalloc.a
 	_MIMALLOC_INPUT_PATH = libmimalloc.a
@@ -286,7 +286,7 @@ STRIP=/usr/bin/strip
 endif
 
 ifeq ($(OS_NAME),linux)
-STRIP=$(shell which llvm-strip 2>/dev/null || which llvm-strip-16 2>/dev/null || which strip 2>/dev/null || echo "Missing strip")
+STRIP=$(shell which llvm-strip 2>/dev/null || which llvm-strip-19 2>/dev/null || which strip 2>/dev/null || echo "Missing strip")
 endif
 
 
@@ -482,7 +482,7 @@ STATIC_MUSL_FLAG ?=
 WRAP_SYMBOLS_ON_LINUX =
 
 ifeq ($(OS_NAME), linux)
-WRAP_SYMBOLS_ON_LINUX = -Wl,--wrap=fcntl -Wl,--wrap=fcntl64 -Wl,--wrap=stat64 -Wl,--wrap=pow -Wl,--wrap=exp -Wl,--wrap=log -Wl,--wrap=log2 \
+WRAP_SYMBOLS_ON_LINUX = -Wl,--wrap=fcntl -Wl,--wrap=fcntl64 -Wl,--wrap=stat64 -Wl,--wrap=pow -Wl,--wrap=exp -Wl,--wrap=exp2 -Wl,--wrap=log -Wl,--wrap=log2 \
 	-Wl,--wrap=lstat \
 	-Wl,--wrap=stat \
 	-Wl,--wrap=fstat \
@@ -674,7 +674,7 @@ endif
 .PHONY: assert-deps
 assert-deps:
 	@echo "Checking if the required utilities are available..."
-	@if [ $(CLANG_VERSION) -lt "15" ]; then echo -e "ERROR: clang version >=15 required, found: $(CLANG_VERSION). Install with:\n\n    $(POSIX_PKG_MANAGER) install llvm@16"; exit 1; fi
+	@if [ $(CLANG_VERSION) -lt "19" ]; then echo -e "ERROR: clang version >=19 required, found: $(CLANG_VERSION). Install with:\n\n    $(POSIX_PKG_MANAGER) install llvm@19"; exit 1; fi
 	@cmake --version >/dev/null 2>&1 || (echo -e "ERROR: cmake is required."; exit 1)
 	@$(PYTHON) --version >/dev/null 2>&1 || (echo -e "ERROR: python is required."; exit 1)
 	@$(ESBUILD) --version >/dev/null 2>&1 || (echo -e "ERROR: esbuild is required."; exit 1)
@@ -924,7 +924,7 @@ bun-codesign-release-local-debug:
 
 
 .PHONY: jsc
-jsc: jsc-build jsc-copy-headers jsc-bindings
+jsc: jsc-build
 .PHONY: jsc-debug
 jsc-debug: jsc-build-debug
 .PHONY: jsc-build
@@ -1154,7 +1154,7 @@ jsc-copy-headers:
 	cp $(WEBKIT_DIR)/Source/JavaScriptCore/bytecode/StubInfoSummary.h $(WEBKIT_RELEASE_DIR)/JavaScriptCore/PrivateHeaders/JavaScriptCore/StubInfoSummary.h
 	cp $(WEBKIT_DIR)/Source/JavaScriptCore/runtime/CommonSlowPaths.h $(WEBKIT_RELEASE_DIR)/JavaScriptCore/PrivateHeaders/JavaScriptCore/CommonSlowPaths.h
 	cp $(WEBKIT_DIR)/Source/JavaScriptCore/runtime/DirectArguments.h $(WEBKIT_RELEASE_DIR)/JavaScriptCore/PrivateHeaders/JavaScriptCore/DirectArguments.h
-	cp $(WEBKIT_DIR)/Source/JavaScriptCore/runtime/GenericArguments.h $(WEBKIT_RELEASE_DIR)/JavaScriptCore/PrivateHeaders/JavaScriptCore/GenericArguments.h
+	cp $(WEBKIT_DIR)/Source/JavaScriptCore/runtime/GenericArgumentsImpl.h $(WEBKIT_RELEASE_DIR)/JavaScriptCore/PrivateHeaders/JavaScriptCore/GenericArgumentsImpl.h
 	cp $(WEBKIT_DIR)/Source/JavaScriptCore/runtime/SamplingProfiler.h $(WEBKIT_RELEASE_DIR)/JavaScriptCore/PrivateHeaders/JavaScriptCore/SamplingProfiler.h
 	cp $(WEBKIT_DIR)/Source/JavaScriptCore/runtime/ScopedArguments.h $(WEBKIT_RELEASE_DIR)/JavaScriptCore/PrivateHeaders/JavaScriptCore/ScopedArguments.h
 	cp $(WEBKIT_DIR)/Source/JavaScriptCore/runtime/JSLexicalEnvironment.h $(WEBKIT_RELEASE_DIR)/JavaScriptCore/PrivateHeaders/JavaScriptCore/JSLexicalEnvironment.h
@@ -1183,6 +1183,8 @@ jsc-copy-headers:
 	cp $(WEBKIT_DIR)/Source/JavaScriptCore/runtime/SymbolObject.h $(WEBKIT_RELEASE_DIR)/JavaScriptCore/PrivateHeaders/JavaScriptCore/SymbolObject.h
 	cp $(WEBKIT_DIR)/Source/JavaScriptCore/runtime/JSGenerator.h $(WEBKIT_RELEASE_DIR)/JavaScriptCore/PrivateHeaders/JavaScriptCore/JSGenerator.h
 	cp $(WEBKIT_DIR)/Source/JavaScriptCore/bytecode/UnlinkedFunctionCodeBlock.h $(WEBKIT_RELEASE_DIR)/JavaScriptCore/PrivateHeaders/JavaScriptCore/UnlinkedFunctionCodeBlock.h
+	cp $(WEBKIT_DIR)/Source/JavaScriptCore/bytecode/GlobalCodeBlock.h $(WEBKIT_RELEASE_DIR)/JavaScriptCore/PrivateHeaders/JavaScriptCore/GlobalCodeBlock.h
+	cp $(WEBKIT_DIR)/Source/JavaScriptCore/bytecode/ProgramCodeBlock.h $(WEBKIT_RELEASE_DIR)/JavaScriptCore/PrivateHeaders/JavaScriptCore/ProgramCodeBlock.h
 	cp $(WEBKIT_DIR)/Source/JavaScriptCore/runtime/AggregateError.h $(WEBKIT_RELEASE_DIR)/JavaScriptCore/PrivateHeaders/JavaScriptCore/AggregateError.h
 	cp $(WEBKIT_DIR)/Source/JavaScriptCore/API/JSWeakValue.h  $(WEBKIT_RELEASE_DIR)/JavaScriptCore/PrivateHeaders/JavaScriptCore/JSWeakValue.h
 	find $(WEBKIT_RELEASE_DIR)/JavaScriptCore/Headers/JavaScriptCore/ -name "*.h" -exec cp {} $(WEBKIT_RELEASE_DIR)/JavaScriptCore/PrivateHeaders/JavaScriptCore/ \;
@@ -1205,7 +1207,7 @@ jsc-copy-headers-debug:
 	cp $(WEBKIT_DIR)/Source/JavaScriptCore/bytecode/StubInfoSummary.h $(WEBKIT_DEBUG_DIR)/JavaScriptCore/PrivateHeaders/JavaScriptCore/StubInfoSummary.h
 	cp $(WEBKIT_DIR)/Source/JavaScriptCore/runtime/CommonSlowPaths.h $(WEBKIT_DEBUG_DIR)/JavaScriptCore/PrivateHeaders/JavaScriptCore/CommonSlowPaths.h
 	cp $(WEBKIT_DIR)/Source/JavaScriptCore/runtime/DirectArguments.h $(WEBKIT_DEBUG_DIR)/JavaScriptCore/PrivateHeaders/JavaScriptCore/DirectArguments.h
-	cp $(WEBKIT_DIR)/Source/JavaScriptCore/runtime/GenericArguments.h $(WEBKIT_DEBUG_DIR)/JavaScriptCore/PrivateHeaders/JavaScriptCore/GenericArguments.h
+	cp $(WEBKIT_DIR)/Source/JavaScriptCore/runtime/GenericArgumentsImpl.h $(WEBKIT_DEBUG_DIR)/JavaScriptCore/PrivateHeaders/JavaScriptCore/GenericArgumentsImpl.h
 	cp $(WEBKIT_DIR)/Source/JavaScriptCore/runtime/SamplingProfiler.h $(WEBKIT_DEBUG_DIR)/JavaScriptCore/PrivateHeaders/JavaScriptCore/SamplingProfiler.h
 	cp $(WEBKIT_DIR)/Source/JavaScriptCore/runtime/ScopedArguments.h $(WEBKIT_DEBUG_DIR)/JavaScriptCore/PrivateHeaders/JavaScriptCore/ScopedArguments.h
 	cp $(WEBKIT_DIR)/Source/JavaScriptCore/runtime/JSLexicalEnvironment.h $(WEBKIT_DEBUG_DIR)/JavaScriptCore/PrivateHeaders/JavaScriptCore/JSLexicalEnvironment.h
@@ -1234,6 +1236,8 @@ jsc-copy-headers-debug:
 	cp $(WEBKIT_DIR)/Source/JavaScriptCore/runtime/SymbolObject.h $(WEBKIT_DEBUG_DIR)/JavaScriptCore/PrivateHeaders/JavaScriptCore/SymbolObject.h
 	cp $(WEBKIT_DIR)/Source/JavaScriptCore/runtime/JSGenerator.h $(WEBKIT_DEBUG_DIR)/JavaScriptCore/PrivateHeaders/JavaScriptCore/JSGenerator.h
 	cp $(WEBKIT_DIR)/Source/JavaScriptCore/bytecode/UnlinkedFunctionCodeBlock.h $(WEBKIT_DEBUG_DIR)/JavaScriptCore/PrivateHeaders/JavaScriptCore/UnlinkedFunctionCodeBlock.h
+	cp $(WEBKIT_DIR)/Source/JavaScriptCore/bytecode/GlobalCodeBlock.h $(WEBKIT_DEBUG_DIR)/JavaScriptCore/PrivateHeaders/JavaScriptCore/GlobalCodeBlock.h
+	cp $(WEBKIT_DIR)/Source/JavaScriptCore/bytecode/ProgramCodeBlock.h $(WEBKIT_DEBUG_DIR)/JavaScriptCore/PrivateHeaders/JavaScriptCore/ProgramCodeBlock.h
 	cp $(WEBKIT_DIR)/Source/JavaScriptCore/runtime/AggregateError.h $(WEBKIT_DEBUG_DIR)/JavaScriptCore/PrivateHeaders/JavaScriptCore/AggregateError.h
 	cp $(WEBKIT_DIR)/Source/JavaScriptCore/API/JSWeakValue.h  $(WEBKIT_DEBUG_DIR)/JavaScriptCore/PrivateHeaders/JavaScriptCore/JSWeakValue.h
 	find $(WEBKIT_DEBUG_DIR)/JavaScriptCore/Headers/JavaScriptCore/ -name "*.h" -exec cp {} $(WEBKIT_DEBUG_DIR)/JavaScriptCore/PrivateHeaders/JavaScriptCore/ \;
@@ -1261,6 +1265,7 @@ jsc-build-mac-compile:
 			-DBUN_FAST_TLS=ON \
 			-DENABLE_FTL_JIT=ON \
 			-DUSE_BUN_JSC_ADDITIONS=ON \
+			-DUSE_BUN_EVENT_LOOP=ON \
 			-G Ninja \
 			$(CMAKE_FLAGS_WITHOUT_RELEASE) \
 			-DPTHREAD_JIT_PERMISSIONS_API=1 \
@@ -1284,6 +1289,7 @@ jsc-build-mac-compile-lto:
 			-DUSE_THIN_ARCHIVES=OFF \
 			-DBUN_FAST_TLS=ON \
 			-DUSE_BUN_JSC_ADDITIONS=ON \
+			-DUSE_BUN_EVENT_LOOP=ON \
 			-DCMAKE_C_FLAGS="-flto=full" \
 			-DCMAKE_CXX_FLAGS="-flto=full" \
 			-DENABLE_FTL_JIT=ON \
@@ -1299,6 +1305,7 @@ jsc-build-mac-compile-lto:
 .PHONY: jsc-build-mac-compile-debug
 jsc-build-mac-compile-debug:
 	mkdir -p $(WEBKIT_DEBUG_DIR) $(WEBKIT_DIR);
+	# to disable asan, remove -DENABLE_SANITIZERS=address and add -DENABLE_MALLOC_HEAP_BREAKDOWN=ON
 	cd $(WEBKIT_DEBUG_DIR) && \
 		ICU_INCLUDE_DIRS="$(HOMEBREW_PREFIX)opt/icu4c/include" \
 		cmake \
@@ -1307,9 +1314,9 @@ jsc-build-mac-compile-debug:
 			-DCMAKE_BUILD_TYPE=Debug \
 			-DUSE_THIN_ARCHIVES=OFF \
 			-DENABLE_FTL_JIT=ON \
-			-DENABLE_MALLOC_HEAP_BREAKDOWN=ON \
 			-DCMAKE_EXPORT_COMPILE_COMMANDS=ON \
 			-DUSE_BUN_JSC_ADDITIONS=ON \
+			-DUSE_BUN_EVENT_LOOP=ON \
 			-DENABLE_BUN_SKIP_FAILING_ASSERTIONS=ON \
 			-DALLOW_LINE_AND_COLUMN_NUMBER_IN_BUILTINS=ON \
 			-G Ninja \
@@ -1318,6 +1325,7 @@ jsc-build-mac-compile-debug:
 			-DUSE_PTHREAD_JIT_PERMISSIONS_API=ON \
 			-DENABLE_REMOTE_INSPECTOR=ON \
 			-DUSE_VISIBILITY_ATTRIBUTE=1 \
+			-DENABLE_SANITIZERS=address \
 			$(WEBKIT_DIR) \
 			$(WEBKIT_DEBUG_DIR) && \
 	CFLAGS="$(CFLAGS) -ffat-lto-objects" CXXFLAGS="$(CXXFLAGS) -ffat-lto-objects" \
@@ -1334,6 +1342,7 @@ jsc-build-linux-compile-config:
 			-DENABLE_BUN_SKIP_FAILING_ASSERTIONS=ON \
 			-DUSE_THIN_ARCHIVES=OFF \
 			-DUSE_BUN_JSC_ADDITIONS=ON \
+			-DUSE_BUN_EVENT_LOOP=ON \
 			-DENABLE_FTL_JIT=ON \
 			-DENABLE_REMOTE_INSPECTOR=ON \
 			-DJSEXPORT_PRIVATE=WTF_EXPORT_DECLARATION \
@@ -1357,6 +1366,7 @@ jsc-build-linux-compile-config-debug:
 			-DENABLE_BUN_SKIP_FAILING_ASSERTIONS=ON \
 			-DUSE_THIN_ARCHIVES=OFF \
 			-DUSE_BUN_JSC_ADDITIONS=ON \
+			-DUSE_BUN_EVENT_LOOP=ON \
 			-DENABLE_FTL_JIT=ON \
 			-DENABLE_REMOTE_INSPECTOR=ON \
 			-DJSEXPORT_PRIVATE=WTF_EXPORT_DECLARATION \
@@ -1375,18 +1385,18 @@ jsc-build-linux-compile-config-debug:
 jsc-build-linux-compile-build:
 		mkdir -p $(WEBKIT_RELEASE_DIR)  && \
 		cd $(WEBKIT_RELEASE_DIR)  && \
-	CFLAGS="$(CFLAGS) -Wl,--whole-archive -ffat-lto-objects" CXXFLAGS="$(CXXFLAGS) -Wl,--whole-archive -ffat-lto-objects -DUSE_BUN_JSC_ADDITIONS=ON" \
+	CFLAGS="$(CFLAGS) -Wl,--whole-archive -ffat-lto-objects" CXXFLAGS="$(CXXFLAGS) -Wl,--whole-archive -ffat-lto-objects -DUSE_BUN_JSC_ADDITIONS=ON -DUSE_BUN_EVENT_LOOP=ON" \
 		cmake --build $(WEBKIT_RELEASE_DIR) --config relwithdebuginfo --target jsc
 
 .PHONY: jsc-build-linux-compile-build-debug
 jsc-build-linux-compile-build-debug:
 		mkdir -p $(WEBKIT_DEBUG_DIR)  && \
 		cd $(WEBKIT_DEBUG_DIR)  && \
-	CFLAGS="$(CFLAGS) -Wl,--whole-archive -ffat-lto-objects" CXXFLAGS="$(CXXFLAGS) -Wl,--whole-archive -ffat-lto-objects -DUSE_BUN_JSC_ADDITIONS=ON" \
+	CFLAGS="$(CFLAGS) -Wl,--whole-archive -ffat-lto-objects" CXXFLAGS="$(CXXFLAGS) -Wl,--whole-archive -ffat-lto-objects -DUSE_BUN_JSC_ADDITIONS=ON -DUSE_BUN_EVENT_LOOP=ON" \
 		cmake --build $(WEBKIT_DEBUG_DIR) --config Debug --target jsc
 
 
-jsc-build-mac: jsc-force-fastjit jsc-build-mac-compile jsc-build-copy
+jsc-build-mac: jsc-force-fastjit jsc-build-mac-compile
 jsc-build-mac-debug: jsc-force-fastjit jsc-build-mac-compile-debug
 
 jsc-build-linux: jsc-build-linux-compile-config jsc-build-linux-compile-build jsc-build-copy

README.md

@@ -96,10 +96,14 @@ bun upgrade --canary
   - [`bun init`](https://bun.sh/docs/cli/init)
   - [`bun create`](https://bun.sh/docs/cli/bun-create)
 
+- CLI
+
+  - [`bun upgrade`](https://bun.sh/docs/cli/bun-upgrade)
+
 - Runtime
 
   - [`bun run`](https://bun.sh/docs/cli/run)
-  - [File types](https://bun.sh/docs/runtime/loaders)
+  - [File types (Loaders)](https://bun.sh/docs/runtime/loaders)
   - [TypeScript](https://bun.sh/docs/runtime/typescript)
   - [JSX](https://bun.sh/docs/runtime/jsx)
   - [Environment variables](https://bun.sh/docs/runtime/env)
@@ -108,12 +112,12 @@ bun upgrade --canary
   - [Node.js compatibility](https://bun.sh/docs/runtime/nodejs-apis)
   - [Single-file executable](https://bun.sh/docs/bundler/executables)
   - [Plugins](https://bun.sh/docs/runtime/plugins)
-  - [Watch mode](https://bun.sh/docs/runtime/hot)
+  - [Watch mode / Hot Reloading](https://bun.sh/docs/runtime/hot)
   - [Module resolution](https://bun.sh/docs/runtime/modules)
   - [Auto-install](https://bun.sh/docs/runtime/autoimport)
   - [bunfig.toml](https://bun.sh/docs/runtime/bunfig)
   - [Debugger](https://bun.sh/docs/runtime/debugger)
-  - [Framework API](https://bun.sh/docs/runtime/framework)
+  - [$ Shell](https://bun.sh/docs/runtime/shell)
 
 - Package manager
 
@@ -122,7 +126,12 @@ bun upgrade --canary
   - [`bun remove`](https://bun.sh/docs/cli/remove)
   - [`bun update`](https://bun.sh/docs/cli/update)
   - [`bun link`](https://bun.sh/docs/cli/link)
+  - [`bun unlink`](https://bun.sh/docs/cli/unlink)
   - [`bun pm`](https://bun.sh/docs/cli/pm)
+  - [`bun outdated`](https://bun.sh/docs/cli/outdated)
+  - [`bun publish`](https://bun.sh/docs/cli/publish)
+  - [`bun patch`](https://bun.sh/docs/install/patch)
+  - [`bun patch-commit`](https://bun.sh/docs/cli/patch-commit)
   - [Global cache](https://bun.sh/docs/install/cache)
   - [Workspaces](https://bun.sh/docs/install/workspaces)
   - [Lifecycle scripts](https://bun.sh/docs/install/lifecycle)
@@ -130,6 +139,7 @@ bun upgrade --canary
   - [Lockfile](https://bun.sh/docs/install/lockfile)
   - [Scopes and registries](https://bun.sh/docs/install/registries)
   - [Overrides and resolutions](https://bun.sh/docs/install/overrides)
+  - [`.npmrc`](https://bun.sh/docs/install/npmrc)
 
 - Bundler
 
@@ -138,6 +148,11 @@ bun upgrade --canary
   - [Plugins](https://bun.sh/docs/bundler/plugins)
   - [Macros](https://bun.sh/docs/bundler/macros)
   - [vs esbuild](https://bun.sh/docs/bundler/vs-esbuild)
+  - [Single-file executable](https://bun.sh/docs/bundler/executables)
+  - [CSS](https://bun.sh/docs/bundler/css)
+  - [HTML](https://bun.sh/docs/bundler/html)
+  - [Hot Module Replacement (HMR)](https://bun.sh/docs/bundler/hmr)
+  - [Full-stack with HTML imports](https://bun.sh/docs/bundler/fullstack)
 
 - Test runner
 
@@ -150,6 +165,10 @@ bun upgrade --canary
   - [Dates and times](https://bun.sh/docs/test/time)
   - [DOM testing](https://bun.sh/docs/test/dom)
   - [Code coverage](https://bun.sh/docs/test/coverage)
+  - [Configuration](https://bun.sh/docs/test/configuration)
+  - [Discovery](https://bun.sh/docs/test/discovery)
+  - [Reporters](https://bun.sh/docs/test/reporters)
+  - [Runtime Behavior](https://bun.sh/docs/test/runtime-behavior)
 
 - Package runner
 
@@ -157,219 +176,235 @@ bun upgrade --canary
 
 - API
 
-  - [HTTP server](https://bun.sh/docs/api/http)
+  - [HTTP server (`Bun.serve`)](https://bun.sh/docs/api/http)
   - [WebSockets](https://bun.sh/docs/api/websockets)
   - [Workers](https://bun.sh/docs/api/workers)
   - [Binary data](https://bun.sh/docs/api/binary-data)
   - [Streams](https://bun.sh/docs/api/streams)
-  - [File I/O](https://bun.sh/docs/api/file-io)
+  - [File I/O (`Bun.file`)](https://bun.sh/docs/api/file-io)
   - [import.meta](https://bun.sh/docs/api/import-meta)
-  - [SQLite](https://bun.sh/docs/api/sqlite)
+  - [SQLite (`bun:sqlite`)](https://bun.sh/docs/api/sqlite)
+  - [PostgreSQL (`Bun.sql`)](https://bun.sh/docs/api/sql)
+  - [Redis (`Bun.redis`)](https://bun.sh/docs/api/redis)
+  - [S3 Client (`Bun.s3`)](https://bun.sh/docs/api/s3)
   - [FileSystemRouter](https://bun.sh/docs/api/file-system-router)
   - [TCP sockets](https://bun.sh/docs/api/tcp)
   - [UDP sockets](https://bun.sh/docs/api/udp)
   - [Globals](https://bun.sh/docs/api/globals)
   - [$ Shell](https://bun.sh/docs/runtime/shell)
-  - [Child processes](https://bun.sh/docs/api/spawn)
-  - [Transpiler](https://bun.sh/docs/api/transpiler)
+  - [Child processes (spawn)](https://bun.sh/docs/api/spawn)
+  - [Transpiler (`Bun.Transpiler`)](https://bun.sh/docs/api/transpiler)
   - [Hashing](https://bun.sh/docs/api/hashing)
+  - [Colors (`Bun.color`)](https://bun.sh/docs/api/color)
   - [Console](https://bun.sh/docs/api/console)
-  - [FFI](https://bun.sh/docs/api/ffi)
+  - [FFI (`bun:ffi`)](https://bun.sh/docs/api/ffi)
+  - [C Compiler (`bun:ffi` cc)](https://bun.sh/docs/api/cc)
   - [HTMLRewriter](https://bun.sh/docs/api/html-rewriter)
-  - [Testing](https://bun.sh/docs/api/test)
+  - [Testing (`bun:test`)](https://bun.sh/docs/api/test)
+  - [Cookies (`Bun.Cookie`)](https://bun.sh/docs/api/cookie)
   - [Utils](https://bun.sh/docs/api/utils)
   - [Node-API](https://bun.sh/docs/api/node-api)
-  - [Glob](https://bun.sh/docs/api/glob)
-  - [Semver](https://bun.sh/docs/api/semver)
-
-- Project
-  - [Roadmap](https://bun.sh/docs/project/roadmap)
-  - [Benchmarking](https://bun.sh/docs/project/benchmarking)
-  - [Contributing](https://bun.sh/docs/project/contributing)
-  - [Building Windows](https://bun.sh/docs/project/building-windows)
-  - [License](https://bun.sh/docs/project/licensing)
+  - [Glob (`Bun.Glob`)](https://bun.sh/docs/api/glob)
+  - [Semver (`Bun.semver`)](https://bun.sh/docs/api/semver)
+  - [DNS](https://bun.sh/docs/api/dns)
+  - [fetch API extensions](https://bun.sh/docs/api/fetch)
 
 ## Guides
 
 - Binary
 
-  - [Convert a Blob to a DataView](https://bun.sh/guides/binary/blob-to-dataview)
-  - [Convert a Blob to a ReadableStream](https://bun.sh/guides/binary/blob-to-stream)
   - [Convert a Blob to a string](https://bun.sh/guides/binary/blob-to-string)
-  - [Convert a Blob to a Uint8Array](https://bun.sh/guides/binary/blob-to-typedarray)
-  - [Convert a Blob to an ArrayBuffer](https://bun.sh/guides/binary/blob-to-arraybuffer)
   - [Convert a Buffer to a blob](https://bun.sh/guides/binary/buffer-to-blob)
-  - [Convert a Buffer to a ReadableStream](https://bun.sh/guides/binary/buffer-to-readablestream)
+  - [Convert a Blob to a DataView](https://bun.sh/guides/binary/blob-to-dataview)
   - [Convert a Buffer to a string](https://bun.sh/guides/binary/buffer-to-string)
-  - [Convert a Buffer to a Uint8Array](https://bun.sh/guides/binary/buffer-to-typedarray)
-  - [Convert a Buffer to an ArrayBuffer](https://bun.sh/guides/binary/buffer-to-arraybuffer)
+  - [Convert a Blob to a ReadableStream](https://bun.sh/guides/binary/blob-to-stream)
+  - [Convert a Blob to a Uint8Array](https://bun.sh/guides/binary/blob-to-typedarray)
   - [Convert a DataView to a string](https://bun.sh/guides/binary/dataview-to-string)
   - [Convert a Uint8Array to a Blob](https://bun.sh/guides/binary/typedarray-to-blob)
-  - [Convert a Uint8Array to a Buffer](https://bun.sh/guides/binary/typedarray-to-buffer)
-  - [Convert a Uint8Array to a DataView](https://bun.sh/guides/binary/typedarray-to-dataview)
-  - [Convert a Uint8Array to a ReadableStream](https://bun.sh/guides/binary/typedarray-to-readablestream)
-  - [Convert a Uint8Array to a string](https://bun.sh/guides/binary/typedarray-to-string)
-  - [Convert a Uint8Array to an ArrayBuffer](https://bun.sh/guides/binary/typedarray-to-arraybuffer)
+  - [Convert a Blob to an ArrayBuffer](https://bun.sh/guides/binary/blob-to-arraybuffer)
   - [Convert an ArrayBuffer to a Blob](https://bun.sh/guides/binary/arraybuffer-to-blob)
+  - [Convert a Buffer to a Uint8Array](https://bun.sh/guides/binary/buffer-to-typedarray)
+  - [Convert a Uint8Array to a Buffer](https://bun.sh/guides/binary/typedarray-to-buffer)
+  - [Convert a Uint8Array to a string](https://bun.sh/guides/binary/typedarray-to-string)
+  - [Convert a Buffer to an ArrayBuffer](https://bun.sh/guides/binary/buffer-to-arraybuffer)
   - [Convert an ArrayBuffer to a Buffer](https://bun.sh/guides/binary/arraybuffer-to-buffer)
   - [Convert an ArrayBuffer to a string](https://bun.sh/guides/binary/arraybuffer-to-string)
+  - [Convert a Uint8Array to a DataView](https://bun.sh/guides/binary/typedarray-to-dataview)
+  - [Convert a Buffer to a ReadableStream](https://bun.sh/guides/binary/buffer-to-readablestream)
+  - [Convert a Uint8Array to an ArrayBuffer](https://bun.sh/guides/binary/typedarray-to-arraybuffer)
   - [Convert an ArrayBuffer to a Uint8Array](https://bun.sh/guides/binary/arraybuffer-to-typedarray)
   - [Convert an ArrayBuffer to an array of numbers](https://bun.sh/guides/binary/arraybuffer-to-array)
+  - [Convert a Uint8Array to a ReadableStream](https://bun.sh/guides/binary/typedarray-to-readablestream)
 
 - Ecosystem
 
-  - [Build a frontend using Vite and Bun](https://bun.sh/guides/ecosystem/vite)
-  - [Build an app with Astro and Bun](https://bun.sh/guides/ecosystem/astro)
-  - [Build an app with Next.js and Bun](https://bun.sh/guides/ecosystem/nextjs)
+  - [Use React and JSX](https://bun.sh/guides/ecosystem/react)
+  - [Use EdgeDB with Bun](https://bun.sh/guides/ecosystem/edgedb)
+  - [Use Prisma with Bun](https://bun.sh/guides/ecosystem/prisma)
+  - [Add Sentry to a Bun app](https://bun.sh/guides/ecosystem/sentry)
+  - [Create a Discord bot](https://bun.sh/guides/ecosystem/discordjs)
+  - [Run Bun as a daemon with PM2](https://bun.sh/guides/ecosystem/pm2)
+  - [Use Drizzle ORM with Bun](https://bun.sh/guides/ecosystem/drizzle)
   - [Build an app with Nuxt and Bun](https://bun.sh/guides/ecosystem/nuxt)
   - [Build an app with Qwik and Bun](https://bun.sh/guides/ecosystem/qwik)
+  - [Build an app with Astro and Bun](https://bun.sh/guides/ecosystem/astro)
   - [Build an app with Remix and Bun](https://bun.sh/guides/ecosystem/remix)
-  - [Build an app with SolidStart and Bun](https://bun.sh/guides/ecosystem/solidstart)
-  - [Build an app with SvelteKit and Bun](https://bun.sh/guides/ecosystem/sveltekit)
-  - [Build an HTTP server using Elysia and Bun](https://bun.sh/guides/ecosystem/elysia)
-  - [Build an HTTP server using Express and Bun](https://bun.sh/guides/ecosystem/express)
+  - [Build a frontend using Vite and Bun](https://bun.sh/guides/ecosystem/vite)
+  - [Build an app with Next.js and Bun](https://bun.sh/guides/ecosystem/nextjs)
+  - [Run Bun as a daemon with systemd](https://bun.sh/guides/ecosystem/systemd)
+  - [Deploy a Bun application on Render](https://bun.sh/guides/ecosystem/render)
   - [Build an HTTP server using Hono and Bun](https://bun.sh/guides/ecosystem/hono)
+  - [Build an app with SvelteKit and Bun](https://bun.sh/guides/ecosystem/sveltekit)
+  - [Build an app with SolidStart and Bun](https://bun.sh/guides/ecosystem/solidstart)
+  - [Build an HTTP server using Elysia and Bun](https://bun.sh/guides/ecosystem/elysia)
   - [Build an HTTP server using StricJS and Bun](https://bun.sh/guides/ecosystem/stric)
   - [Containerize a Bun application with Docker](https://bun.sh/guides/ecosystem/docker)
-  - [Create a Discord bot](https://bun.sh/guides/ecosystem/discordjs)
-  - [Deploy a Bun application on Render](https://bun.sh/guides/ecosystem/render)
-  - [Read and write data to MongoDB using Mongoose and Bun](https://bun.sh/guides/ecosystem/mongoose)
-  - [Run Bun as a daemon with PM2](https://bun.sh/guides/ecosystem/pm2)
-  - [Run Bun as a daemon with systemd](https://bun.sh/guides/ecosystem/systemd)
+  - [Build an HTTP server using Express and Bun](https://bun.sh/guides/ecosystem/express)
+  - [Use Neon Postgres through Drizzle ORM](https://bun.sh/guides/ecosystem/neon-drizzle)
   - [Server-side render (SSR) a React component](https://bun.sh/guides/ecosystem/ssr-react)
-  - [Use Drizzle ORM with Bun](https://bun.sh/guides/ecosystem/drizzle)
-  - [Use EdgeDB with Bun](https://bun.sh/guides/ecosystem/edgedb)
+  - [Read and write data to MongoDB using Mongoose and Bun](https://bun.sh/guides/ecosystem/mongoose)
   - [Use Neon's Serverless Postgres with Bun](https://bun.sh/guides/ecosystem/neon-serverless-postgres)
-  - [Use Prisma with Bun](https://bun.sh/guides/ecosystem/prisma)
-  - [Use React and JSX](https://bun.sh/guides/ecosystem/react)
-  - [Add Sentry to a Bun app](https://bun.sh/guides/ecosystem/sentry)
+
+- HTMLRewriter
+
+  - [Extract links from a webpage using HTMLRewriter](https://bun.sh/guides/html-rewriter/extract-links)
+  - [Extract social share images and Open Graph tags](https://bun.sh/guides/html-rewriter/extract-social-meta)
 
 - HTTP
 
-  - [Common HTTP server usage](https://bun.sh/guides/http/server)
-  - [Configure TLS on an HTTP server](https://bun.sh/guides/http/tls)
-  - [fetch with unix domain sockets in Bun](https://bun.sh/guides/http/fetch-unix)
   - [Hot reload an HTTP server](https://bun.sh/guides/http/hot)
-  - [Proxy HTTP requests using fetch()](https://bun.sh/guides/http/proxy)
+  - [Common HTTP server usage](https://bun.sh/guides/http/server)
+  - [Write a simple HTTP server](https://bun.sh/guides/http/simple)
+  - [Configure TLS on an HTTP server](https://bun.sh/guides/http/tls)
   - [Send an HTTP request using fetch](https://bun.sh/guides/http/fetch)
+  - [Proxy HTTP requests using fetch()](https://bun.sh/guides/http/proxy)
   - [Start a cluster of HTTP servers](https://bun.sh/guides/http/cluster)
   - [Stream a file as an HTTP Response](https://bun.sh/guides/http/stream-file)
+  - [fetch with unix domain sockets in Bun](https://bun.sh/guides/http/fetch-unix)
+  - [Upload files via HTTP using FormData](https://bun.sh/guides/http/file-uploads)
   - [Streaming HTTP Server with Async Iterators](https://bun.sh/guides/http/stream-iterator)
   - [Streaming HTTP Server with Node.js Streams](https://bun.sh/guides/http/stream-node-streams-in-bun)
-  - [Upload files via HTTP using FormData](https://bun.sh/guides/http/file-uploads)
-  - [Write a simple HTTP server](https://bun.sh/guides/http/simple)
 
 - Install
 
   - [Add a dependency](https://bun.sh/guides/install/add)
-  - [Add a development dependency](https://bun.sh/guides/install/add-dev)
   - [Add a Git dependency](https://bun.sh/guides/install/add-git)
   - [Add a peer dependency](https://bun.sh/guides/install/add-peer)
-  - [Add a tarball dependency](https://bun.sh/guides/install/add-tarball)
   - [Add a trusted dependency](https://bun.sh/guides/install/trusted)
+  - [Add a development dependency](https://bun.sh/guides/install/add-dev)
+  - [Add a tarball dependency](https://bun.sh/guides/install/add-tarball)
   - [Add an optional dependency](https://bun.sh/guides/install/add-optional)
-  - [Configure a private registry for an organization scope with bun install](https://bun.sh/guides/install/registry-scope)
-  - [Configure git to diff Bun's lockb lockfile](https://bun.sh/guides/install/git-diff-bun-lockfile)
+  - [Generate a yarn-compatible lockfile](https://bun.sh/guides/install/yarnlock)
   - [Configuring a monorepo using workspaces](https://bun.sh/guides/install/workspaces)
-  - [Generate a human-readable lockfile](https://bun.sh/guides/install/yarnlock)
   - [Install a package under a different name](https://bun.sh/guides/install/npm-alias)
   - [Install dependencies with Bun in GitHub Actions](https://bun.sh/guides/install/cicd)
+  - [Using bun install with Artifactory](https://bun.sh/guides/install/jfrog-artifactory)
+  - [Configure git to diff Bun's lockb lockfile](https://bun.sh/guides/install/git-diff-bun-lockfile)
   - [Override the default npm registry for bun install](https://bun.sh/guides/install/custom-registry)
   - [Using bun install with an Azure Artifacts npm registry](https://bun.sh/guides/install/azure-artifacts)
-  - [Using bun install with Artifactory](https://bun.sh/guides/install/jfrog-artifactory)
+  - [Migrate from npm install to bun install](https://bun.sh/guides/install/from-npm-install-to-bun-install)
+  - [Configure a private registry for an organization scope with bun install](https://bun.sh/guides/install/registry-scope)
 
 - Process
 
-  - [Get the process uptime in nanoseconds](https://bun.sh/guides/process/nanoseconds)
+  - [Read from stdin](https://bun.sh/guides/process/stdin)
   - [Listen for CTRL+C](https://bun.sh/guides/process/ctrl-c)
+  - [Spawn a child process](https://bun.sh/guides/process/spawn)
   - [Listen to OS signals](https://bun.sh/guides/process/os-signals)
   - [Parse command-line arguments](https://bun.sh/guides/process/argv)
-  - [Read from stdin](https://bun.sh/guides/process/stdin)
   - [Read stderr from a child process](https://bun.sh/guides/process/spawn-stderr)
   - [Read stdout from a child process](https://bun.sh/guides/process/spawn-stdout)
-  - [Spawn a child process](https://bun.sh/guides/process/spawn)
+  - [Get the process uptime in nanoseconds](https://bun.sh/guides/process/nanoseconds)
   - [Spawn a child process and communicate using IPC](https://bun.sh/guides/process/ipc)
 
 - Read file
 
+  - [Read a JSON file](https://bun.sh/guides/read-file/json)
   - [Check if a file exists](https://bun.sh/guides/read-file/exists)
-  - [Get the MIME type of a file](https://bun.sh/guides/read-file/mime)
-  - [Read a file as a ReadableStream](https://bun.sh/guides/read-file/stream)
   - [Read a file as a string](https://bun.sh/guides/read-file/string)
   - [Read a file to a Buffer](https://bun.sh/guides/read-file/buffer)
+  - [Get the MIME type of a file](https://bun.sh/guides/read-file/mime)
+  - [Watch a directory for changes](https://bun.sh/guides/read-file/watch)
+  - [Read a file as a ReadableStream](https://bun.sh/guides/read-file/stream)
   - [Read a file to a Uint8Array](https://bun.sh/guides/read-file/uint8array)
   - [Read a file to an ArrayBuffer](https://bun.sh/guides/read-file/arraybuffer)
-  - [Read a JSON file](https://bun.sh/guides/read-file/json)
-  - [Watch a directory for changes](https://bun.sh/guides/read-file/watch)
 
 - Runtime
 
-  - [Debugging Bun with the VS Code extension](https://bun.sh/guides/runtime/vscode-debugger)
-  - [Debugging Bun with the web debugger](https://bun.sh/guides/runtime/web-debugger)
-  - [Define and replace static globals & constants](https://bun.sh/guides/runtime/define-constant)
+  - [Delete files](https://bun.sh/guides/runtime/delete-file)
+  - [Run a Shell Command](https://bun.sh/guides/runtime/shell)
   - [Import a JSON file](https://bun.sh/guides/runtime/import-json)
   - [Import a TOML file](https://bun.sh/guides/runtime/import-toml)
-  - [Import HTML file as text](https://bun.sh/guides/runtime/import-html)
-  - [Install and run Bun in GitHub Actions](https://bun.sh/guides/runtime/cicd)
-  - [Install TypeScript declarations for Bun](https://bun.sh/guides/runtime/typescript)
-  - [Re-map import paths](https://bun.sh/guides/runtime/tsconfig-paths)
-  - [Read environment variables](https://bun.sh/guides/runtime/read-env)
-  - [Run a Shell Command](https://bun.sh/guides/runtime/shell)
   - [Set a time zone in Bun](https://bun.sh/guides/runtime/timezone)
   - [Set environment variables](https://bun.sh/guides/runtime/set-env)
+  - [Re-map import paths](https://bun.sh/guides/runtime/tsconfig-paths)
+  - [Delete directories](https://bun.sh/guides/runtime/delete-directory)
+  - [Read environment variables](https://bun.sh/guides/runtime/read-env)
+  - [Import a HTML file as text](https://bun.sh/guides/runtime/import-html)
+  - [Install and run Bun in GitHub Actions](https://bun.sh/guides/runtime/cicd)
+  - [Debugging Bun with the web debugger](https://bun.sh/guides/runtime/web-debugger)
+  - [Install TypeScript declarations for Bun](https://bun.sh/guides/runtime/typescript)
+  - [Debugging Bun with the VS Code extension](https://bun.sh/guides/runtime/vscode-debugger)
+  - [Inspect memory usage using V8 heap snapshots](https://bun.sh/guides/runtime/heap-snapshot)
+  - [Define and replace static globals & constants](https://bun.sh/guides/runtime/define-constant)
+  - [Codesign a single-file JavaScript executable on macOS](https://bun.sh/guides/runtime/codesign-macos-executable)
 
 - Streams
 
-  - [Convert a Node.js Readable to a Blob](https://bun.sh/guides/streams/node-readable-to-blob)
-  - [Convert a Node.js Readable to a string](https://bun.sh/guides/streams/node-readable-to-string)
-  - [Convert a Node.js Readable to an ArrayBuffer](https://bun.sh/guides/streams/node-readable-to-arraybuffer)
-  - [Convert a Node.js Readable to JSON](https://bun.sh/guides/streams/node-readable-to-json)
+  - [Convert a ReadableStream to JSON](https://bun.sh/guides/streams/to-json)
   - [Convert a ReadableStream to a Blob](https://bun.sh/guides/streams/to-blob)
   - [Convert a ReadableStream to a Buffer](https://bun.sh/guides/streams/to-buffer)
   - [Convert a ReadableStream to a string](https://bun.sh/guides/streams/to-string)
   - [Convert a ReadableStream to a Uint8Array](https://bun.sh/guides/streams/to-typedarray)
   - [Convert a ReadableStream to an array of chunks](https://bun.sh/guides/streams/to-array)
+  - [Convert a Node.js Readable to JSON](https://bun.sh/guides/streams/node-readable-to-json)
   - [Convert a ReadableStream to an ArrayBuffer](https://bun.sh/guides/streams/to-arraybuffer)
-  - [Convert a ReadableStream to JSON](https://bun.sh/guides/streams/to-json)
+  - [Convert a Node.js Readable to a Blob](https://bun.sh/guides/streams/node-readable-to-blob)
+  - [Convert a Node.js Readable to a string](https://bun.sh/guides/streams/node-readable-to-string)
+  - [Convert a Node.js Readable to an Uint8Array](https://bun.sh/guides/streams/node-readable-to-uint8array)
+  - [Convert a Node.js Readable to an ArrayBuffer](https://bun.sh/guides/streams/node-readable-to-arraybuffer)
 
 - Test
 
-  - [Bail early with the Bun test runner](https://bun.sh/guides/test/bail)
-  - [Generate code coverage reports with the Bun test runner](https://bun.sh/guides/test/coverage)
-  - [Mark a test as a "todo" with the Bun test runner](https://bun.sh/guides/test/todo-tests)
-  - [Migrate from Jest to Bun's test runner](https://bun.sh/guides/test/migrate-from-jest)
-  - [Mock functions in `bun test`](https://bun.sh/guides/test/mock-functions)
-  - [Re-run tests multiple times with the Bun test runner](https://bun.sh/guides/test/rerun-each)
-  - [Run tests in watch mode with Bun](https://bun.sh/guides/test/watch-mode)
-  - [Run your tests with the Bun test runner](https://bun.sh/guides/test/run-tests)
-  - [Set a code coverage threshold with the Bun test runner](https://bun.sh/guides/test/coverage-threshold)
-  - [Set a per-test timeout with the Bun test runner](https://bun.sh/guides/test/timeout)
-  - [Set the system time in Bun's test runner](https://bun.sh/guides/test/mock-clock)
-  - [Skip tests with the Bun test runner](https://bun.sh/guides/test/skip-tests)
   - [Spy on methods in `bun test`](https://bun.sh/guides/test/spy-on)
-  - [Update snapshots in `bun test`](https://bun.sh/guides/test/update-snapshots)
+  - [Bail early with the Bun test runner](https://bun.sh/guides/test/bail)
+  - [Mock functions in `bun test`](https://bun.sh/guides/test/mock-functions)
+  - [Run tests in watch mode with Bun](https://bun.sh/guides/test/watch-mode)
   - [Use snapshot testing in `bun test`](https://bun.sh/guides/test/snapshot)
+  - [Skip tests with the Bun test runner](https://bun.sh/guides/test/skip-tests)
+  - [Using Testing Library with Bun](https://bun.sh/guides/test/testing-library)
+  - [Update snapshots in `bun test`](https://bun.sh/guides/test/update-snapshots)
+  - [Run your tests with the Bun test runner](https://bun.sh/guides/test/run-tests)
+  - [Set the system time in Bun's test runner](https://bun.sh/guides/test/mock-clock)
+  - [Set a per-test timeout with the Bun test runner](https://bun.sh/guides/test/timeout)
+  - [Migrate from Jest to Bun's test runner](https://bun.sh/guides/test/migrate-from-jest)
   - [Write browser DOM tests with Bun and happy-dom](https://bun.sh/guides/test/happy-dom)
+  - [Mark a test as a "todo" with the Bun test runner](https://bun.sh/guides/test/todo-tests)
+  - [Re-run tests multiple times with the Bun test runner](https://bun.sh/guides/test/rerun-each)
+  - [Generate code coverage reports with the Bun test runner](https://bun.sh/guides/test/coverage)
+  - [import, require, and test Svelte components with bun test](https://bun.sh/guides/test/svelte-test)
+  - [Set a code coverage threshold with the Bun test runner](https://bun.sh/guides/test/coverage-threshold)
 
 - Util
 
-  - [Check if the current file is the entrypoint](https://bun.sh/guides/util/entrypoint)
+  - [Generate a UUID](https://bun.sh/guides/util/javascript-uuid)
+  - [Hash a password](https://bun.sh/guides/util/hash-a-password)
+  - [Escape an HTML string](https://bun.sh/guides/util/escape-html)
+  - [Get the current Bun version](https://bun.sh/guides/util/version)
+  - [Encode and decode base64 strings](https://bun.sh/guides/util/base64)
+  - [Compress and decompress data with gzip](https://bun.sh/guides/util/gzip)
+  - [Sleep for a fixed number of milliseconds](https://bun.sh/guides/util/sleep)
+  - [Detect when code is executed with Bun](https://bun.sh/guides/util/detect-bun)
   - [Check if two objects are deeply equal](https://bun.sh/guides/util/deep-equals)
   - [Compress and decompress data with DEFLATE](https://bun.sh/guides/util/deflate)
-  - [Compress and decompress data with gzip](https://bun.sh/guides/util/gzip)
+  - [Get the absolute path to the current entrypoint](https://bun.sh/guides/util/main)
+  - [Get the directory of the current file](https://bun.sh/guides/util/import-meta-dir)
+  - [Check if the current file is the entrypoint](https://bun.sh/guides/util/entrypoint)
+  - [Get the file name of the current file](https://bun.sh/guides/util/import-meta-file)
   - [Convert a file URL to an absolute path](https://bun.sh/guides/util/file-url-to-path)
   - [Convert an absolute path to a file URL](https://bun.sh/guides/util/path-to-file-url)
-  - [Detect when code is executed with Bun](https://bun.sh/guides/util/detect-bun)
-  - [Encode and decode base64 strings](https://bun.sh/guides/util/base64)
-  - [Escape an HTML string](https://bun.sh/guides/util/escape-html)
   - [Get the absolute path of the current file](https://bun.sh/guides/util/import-meta-path)
-  - [Get the absolute path to the current entrypoint](https://bun.sh/guides/util/main)
-  - [Get the current Bun version](https://bun.sh/guides/util/version)
-  - [Get the directory of the current file](https://bun.sh/guides/util/import-meta-dir)
-  - [Get the file name of the current file](https://bun.sh/guides/util/import-meta-file)
   - [Get the path to an executable bin file](https://bun.sh/guides/util/which-path-to-executable-bin)
-  - [Hash a password](https://bun.sh/guides/util/hash-a-password)
-  - [Sleep for a fixed number of milliseconds](https://bun.sh/guides/util/sleep)
 
 - WebSocket
 
@@ -379,16 +414,17 @@ bun upgrade --canary
   - [Set per-socket contextual data on a WebSocket](https://bun.sh/guides/websocket/context)
 
 - Write file
-  - [Append content to a file](https://bun.sh/guides/write-file/append)
-  - [Copy a file to another location](https://bun.sh/guides/write-file/file-cp)
+
   - [Delete a file](https://bun.sh/guides/write-file/unlink)
-  - [Write a Blob to a file](https://bun.sh/guides/write-file/blob)
-  - [Write a file incrementally](https://bun.sh/guides/write-file/filesink)
-  - [Write a file to stdout](https://bun.sh/guides/write-file/cat)
-  - [Write a ReadableStream to a file](https://bun.sh/guides/write-file/stream)
-  - [Write a Response to a file](https://bun.sh/guides/write-file/response)
-  - [Write a string to a file](https://bun.sh/guides/write-file/basic)
   - [Write to stdout](https://bun.sh/guides/write-file/stdout)
+  - [Write a file to stdout](https://bun.sh/guides/write-file/cat)
+  - [Write a Blob to a file](https://bun.sh/guides/write-file/blob)
+  - [Write a string to a file](https://bun.sh/guides/write-file/basic)
+  - [Append content to a file](https://bun.sh/guides/write-file/append)
+  - [Write a file incrementally](https://bun.sh/guides/write-file/filesink)
+  - [Write a Response to a file](https://bun.sh/guides/write-file/response)
+  - [Copy a file to another location](https://bun.sh/guides/write-file/file-cp)
+  - [Write a ReadableStream to a file](https://bun.sh/guides/write-file/stream)
 
 ## Contributing
 

bench/bun.lock

@@ -1,5 +1,5 @@
 {
-  "lockfileVersion": 0,
+  "lockfileVersion": 1,
   "workspaces": {
     "": {
       "name": "bench",

bench/crypto/aes-gcm-throughput.mjs

@@ -0,0 +1,44 @@
+import { bench, run } from "../runner.mjs";
+import crypto from "node:crypto";
+import { Buffer } from "node:buffer";
+
+const keylen = { "aes-128-gcm": 16, "aes-192-gcm": 24, "aes-256-gcm": 32 };
+const sizes = [4 * 1024, 1024 * 1024];
+const ciphers = ["aes-128-gcm", "aes-192-gcm", "aes-256-gcm"];
+
+const messages = {};
+sizes.forEach(size => {
+  messages[size] = Buffer.alloc(size, "b");
+});
+
+const keys = {};
+ciphers.forEach(cipher => {
+  keys[cipher] = crypto.randomBytes(keylen[cipher]);
+});
+
+// Fixed IV and AAD
+const iv = crypto.randomBytes(12);
+const associate_data = Buffer.alloc(16, "z");
+
+for (const cipher of ciphers) {
+  for (const size of sizes) {
+    const message = messages[size];
+    const key = keys[cipher];
+
+    bench(`${cipher} ${size / 1024}KB`, () => {
+      const alice = crypto.createCipheriv(cipher, key, iv);
+      alice.setAAD(associate_data);
+      const enc = alice.update(message);
+      alice.final();
+      const tag = alice.getAuthTag();
+
+      const bob = crypto.createDecipheriv(cipher, key, iv);
+      bob.setAuthTag(tag);
+      bob.setAAD(associate_data);
+      bob.update(enc);
+      bob.final();
+    });
+  }
+}
+
+await run();

bench/crypto/diffie-hellman.mjs

@@ -0,0 +1,53 @@
+import crypto from "node:crypto";
+import { bench, run } from "../runner.mjs";
+
+// Pre-generate DH params to avoid including setup in benchmarks
+const dhSize = 1024; // Reduced from 2048 for faster testing
+const dh = crypto.createDiffieHellman(dhSize);
+const dhPrime = dh.getPrime();
+const dhGenerator = dh.getGenerator();
+
+// Classical Diffie-Hellman
+bench("DH - generateKeys", () => {
+  const alice = crypto.createDiffieHellman(dhPrime, dhGenerator);
+  return alice.generateKeys();
+});
+
+bench("DH - computeSecret", () => {
+  // Setup
+  const alice = crypto.createDiffieHellman(dhPrime, dhGenerator);
+  const aliceKey = alice.generateKeys();
+  const bob = crypto.createDiffieHellman(dhPrime, dhGenerator);
+  const bobKey = bob.generateKeys();
+
+  // Benchmark just the secret computation
+  return alice.computeSecret(bobKey);
+});
+
+// ECDH with prime256v1 (P-256)
+bench("ECDH-P256 - generateKeys", () => {
+  const ecdh = crypto.createECDH("prime256v1");
+  return ecdh.generateKeys();
+});
+
+bench("ECDH-P256 - computeSecret", () => {
+  // Setup
+  const alice = crypto.createECDH("prime256v1");
+  const aliceKey = alice.generateKeys();
+  const bob = crypto.createECDH("prime256v1");
+  const bobKey = bob.generateKeys();
+
+  // Benchmark just the secret computation
+  return alice.computeSecret(bobKey);
+});
+
+// ECDH with secp384r1 (P-384)
+bench("ECDH-P384 - computeSecret", () => {
+  const alice = crypto.createECDH("secp384r1");
+  const aliceKey = alice.generateKeys();
+  const bob = crypto.createECDH("secp384r1");
+  const bobKey = bob.generateKeys();
+  return alice.computeSecret(bobKey);
+});
+
+await run();

bench/crypto/ecdh-convert-key.mjs

@@ -0,0 +1,44 @@
+import crypto from "node:crypto";
+import { bench, run } from "../runner.mjs";
+
+function generateTestKeyPairs() {
+  const curves = crypto.getCurves();
+  const keys = {};
+
+  for (const curve of curves) {
+    const ecdh = crypto.createECDH(curve);
+    ecdh.generateKeys();
+
+    keys[curve] = {
+      compressed: ecdh.getPublicKey("hex", "compressed"),
+      uncompressed: ecdh.getPublicKey("hex", "uncompressed"),
+      instance: ecdh,
+    };
+  }
+
+  return keys;
+}
+
+const testKeys = generateTestKeyPairs();
+
+bench("ECDH key format - P256 compressed to uncompressed", () => {
+  const publicKey = testKeys["prime256v1"].compressed;
+  return crypto.ECDH.convertKey(publicKey, "prime256v1", "hex", "hex", "uncompressed");
+});
+
+bench("ECDH key format - P256 uncompressed to compressed", () => {
+  const publicKey = testKeys["prime256v1"].uncompressed;
+  return crypto.ECDH.convertKey(publicKey, "prime256v1", "hex", "hex", "compressed");
+});
+
+bench("ECDH key format - P384 compressed to uncompressed", () => {
+  const publicKey = testKeys["secp384r1"].compressed;
+  return crypto.ECDH.convertKey(publicKey, "secp384r1", "hex", "hex", "uncompressed");
+});
+
+bench("ECDH key format - P384 uncompressed to compressed", () => {
+  const publicKey = testKeys["secp384r1"].uncompressed;
+  return crypto.ECDH.convertKey(publicKey, "secp384r1", "hex", "hex", "compressed");
+});
+
+await run();

bench/crypto/hkdf.mjs

@@ -0,0 +1,50 @@
+import crypto from "node:crypto";
+import { bench, run } from "../runner.mjs";
+
+// Sample keys with different lengths
+const keys = {
+  short: "secret",
+  long: "this-is-a-much-longer-secret-aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+};
+
+// Test parameters
+const salts = ["", "salt"];
+const infos = ["", "info"];
+const hashes = ["sha256", "sha512"];
+const sizes = [10, 1024];
+
+// Benchmark sync HKDF
+for (const hash of hashes) {
+  for (const keyName of Object.keys(keys)) {
+    const key = keys[keyName];
+    for (const size of sizes) {
+      bench(`hkdfSync ${hash} ${keyName}-key ${size} bytes`, () => {
+        return crypto.hkdfSync(hash, key, "salt", "info", size);
+      });
+    }
+  }
+}
+
+// Benchmark different combinations of salt and info
+for (const salt of salts) {
+  for (const info of infos) {
+    bench(`hkdfSync sha256 with ${salt ? "salt" : "no-salt"} and ${info ? "info" : "no-info"}`, () => {
+      return crypto.hkdfSync("sha256", "secret", salt, info, 64);
+    });
+  }
+}
+
+// Benchmark async HKDF (using promises for cleaner benchmark)
+// Note: async benchmarks in Mitata require returning a Promise
+for (const hash of hashes) {
+  bench(`hkdf ${hash} async`, async () => {
+    return new Promise((resolve, reject) => {
+      crypto.hkdf(hash, "secret", "salt", "info", 64, (err, derivedKey) => {
+        if (err) reject(err);
+        else resolve(derivedKey);
+      });
+    });
+  });
+}
+
+await run();

bench/crypto/primes.mjs

@@ -0,0 +1,43 @@
+import { checkPrime, checkPrimeSync, generatePrime, generatePrimeSync } from "node:crypto";
+import { bench, run } from "../runner.mjs";
+
+const prime512 = generatePrimeSync(512);
+const prime2048 = generatePrimeSync(2048);
+
+bench("checkPrimeSync 512", () => {
+  return checkPrimeSync(prime512);
+});
+
+bench("checkPrimeSync 2048", () => {
+  return checkPrimeSync(prime2048);
+});
+
+bench("checkPrime 512", async () => {
+  const promises = Array.from({ length: 10 }, () => new Promise(resolve => checkPrime(prime512, resolve)));
+  await Promise.all(promises);
+});
+
+bench("checkPrime 2048", async () => {
+  const promises = Array.from({ length: 10 }, () => new Promise(resolve => checkPrime(prime2048, resolve)));
+  await Promise.all(promises);
+});
+
+bench("generatePrimeSync 512", () => {
+  return generatePrimeSync(512);
+});
+
+bench("generatePrimeSync 2048", () => {
+  return generatePrimeSync(2048);
+});
+
+bench("generatePrime 512", async () => {
+  const promises = Array.from({ length: 10 }, () => new Promise(resolve => generatePrime(512, resolve)));
+  await Promise.all(promises);
+});
+
+bench("generatePrime 2048", async () => {
+  const promises = Array.from({ length: 10 }, () => new Promise(resolve => generatePrime(2048, resolve)));
+  await Promise.all(promises);
+});
+
+await run();

bench/crypto/random.mjs

@@ -0,0 +1,50 @@
+import crypto from "crypto";
+import { bench, run } from "../runner.mjs";
+
+bench("randomInt - sync", () => {
+  crypto.randomInt(1000);
+});
+
+bench("randomInt - async", async () => {
+  const { promise, resolve } = Promise.withResolvers();
+  crypto.randomInt(1000, () => {
+    resolve();
+  });
+  await promise;
+});
+
+bench("randonBytes - 32", () => {
+  crypto.randomBytes(32);
+});
+
+bench("randomBytes - 256", () => {
+  crypto.randomBytes(256);
+});
+
+const buf = Buffer.alloc(256);
+
+bench("randomFill - 32", async () => {
+  const { promise, resolve } = Promise.withResolvers();
+  crypto.randomFill(buf, 0, 32, () => {
+    resolve();
+  });
+  await promise;
+});
+
+bench("randomFill - 256", async () => {
+  const { promise, resolve } = Promise.withResolvers();
+  crypto.randomFill(buf, 0, 256, () => {
+    resolve();
+  });
+  await promise;
+});
+
+bench("randomFillSync - 32", () => {
+  crypto.randomFillSync(buf, 0, 32);
+});
+
+bench("randomFillSync - 256", () => {
+  crypto.randomFillSync(buf, 0, 256);
+});
+
+await run();

bench/expect-to-equal/bun.lock

@@ -1,5 +1,5 @@
 {
-  "lockfileVersion": 0,
+  "lockfileVersion": 1,
   "workspaces": {
     "": {
       "name": "expect-to-equal",
@@ -136,7 +136,7 @@
 
     "@jest/console": ["@jest/console@29.4.3", "", { "dependencies": { "@jest/types": "^29.4.3", "@types/node": "*", "chalk": "^4.0.0", "jest-message-util": "^29.4.3", "jest-util": "^29.4.3", "slash": "^3.0.0" } }, "sha512-W/o/34+wQuXlgqlPYTansOSiBnuxrTv61dEVkA6HNmpcgHLUjfaUbdqt6oVvOzaawwo9IdW9QOtMgQ1ScSZC4A=="],
 
-    "@jest/core": ["@jest/core@29.4.3", "", { "dependencies": { "@jest/console": "^29.4.3", "@jest/reporters": "^29.4.3", "@jest/test-result": "^29.4.3", "@jest/transform": "^29.4.3", "@jest/types": "^29.4.3", "@types/node": "*", "ansi-escapes": "^4.2.1", "chalk": "^4.0.0", "ci-info": "^3.2.0", "exit": "^0.1.2", "graceful-fs": "^4.2.9", "jest-changed-files": "^29.4.3", "jest-config": "^29.4.3", "jest-haste-map": "^29.4.3", "jest-message-util": "^29.4.3", "jest-regex-util": "^29.4.3", "jest-resolve": "^29.4.3", "jest-resolve-dependencies": "^29.4.3", "jest-runner": "^29.4.3", "jest-runtime": "^29.4.3", "jest-snapshot": "^29.4.3", "jest-util": "^29.4.3", "jest-validate": "^29.4.3", "jest-watcher": "^29.4.3", "micromatch": "^4.0.4", "pretty-format": "^29.4.3", "slash": "^3.0.0", "strip-ansi": "^6.0.0" }, "peerDependencies": { "node-notifier": "^8.0.1 || ^9.0.0 || ^10.0.0" } }, "sha512-56QvBq60fS4SPZCuM7T+7scNrkGIe7Mr6PVIXUpu48ouvRaWOFqRPV91eifvFM0ay2HmfswXiGf97NGUN5KofQ=="],
+    "@jest/core": ["@jest/core@29.4.3", "", { "dependencies": { "@jest/console": "^29.4.3", "@jest/reporters": "^29.4.3", "@jest/test-result": "^29.4.3", "@jest/transform": "^29.4.3", "@jest/types": "^29.4.3", "@types/node": "*", "ansi-escapes": "^4.2.1", "chalk": "^4.0.0", "ci-info": "^3.2.0", "exit": "^0.1.2", "graceful-fs": "^4.2.9", "jest-changed-files": "^29.4.3", "jest-config": "^29.4.3", "jest-haste-map": "^29.4.3", "jest-message-util": "^29.4.3", "jest-regex-util": "^29.4.3", "jest-resolve": "^29.4.3", "jest-resolve-dependencies": "^29.4.3", "jest-runner": "^29.4.3", "jest-runtime": "^29.4.3", "jest-snapshot": "^29.4.3", "jest-util": "^29.4.3", "jest-validate": "^29.4.3", "jest-watcher": "^29.4.3", "micromatch": "^4.0.4", "pretty-format": "^29.4.3", "slash": "^3.0.0", "strip-ansi": "^6.0.0" }, "peerDependencies": { "node-notifier": "^8.0.1 || ^9.0.0 || ^10.0.0" }, "optionalPeers": ["node-notifier"] }, "sha512-56QvBq60fS4SPZCuM7T+7scNrkGIe7Mr6PVIXUpu48ouvRaWOFqRPV91eifvFM0ay2HmfswXiGf97NGUN5KofQ=="],
 
     "@jest/environment": ["@jest/environment@29.4.3", "", { "dependencies": { "@jest/fake-timers": "^29.4.3", "@jest/types": "^29.4.3", "@types/node": "*", "jest-mock": "^29.4.3" } }, "sha512-dq5S6408IxIa+lr54zeqce+QgI+CJT4nmmA+1yzFgtcsGK8c/EyiUb9XQOgz3BMKrRDfKseeOaxj2eO8LlD3lA=="],
 
@@ -148,7 +148,7 @@
 
     "@jest/globals": ["@jest/globals@29.4.3", "", { "dependencies": { "@jest/environment": "^29.4.3", "@jest/expect": "^29.4.3", "@jest/types": "^29.4.3", "jest-mock": "^29.4.3" } }, "sha512-8BQ/5EzfOLG7AaMcDh7yFCbfRLtsc+09E1RQmRBI4D6QQk4m6NSK/MXo+3bJrBN0yU8A2/VIcqhvsOLFmziioA=="],
 
-    "@jest/reporters": ["@jest/reporters@29.4.3", "", { "dependencies": { "@bcoe/v8-coverage": "^0.2.3", "@jest/console": "^29.4.3", "@jest/test-result": "^29.4.3", "@jest/transform": "^29.4.3", "@jest/types": "^29.4.3", "@jridgewell/trace-mapping": "^0.3.15", "@types/node": "*", "chalk": "^4.0.0", "collect-v8-coverage": "^1.0.0", "exit": "^0.1.2", "glob": "^7.1.3", "graceful-fs": "^4.2.9", "istanbul-lib-coverage": "^3.0.0", "istanbul-lib-instrument": "^5.1.0", "istanbul-lib-report": "^3.0.0", "istanbul-lib-source-maps": "^4.0.0", "istanbul-reports": "^3.1.3", "jest-message-util": "^29.4.3", "jest-util": "^29.4.3", "jest-worker": "^29.4.3", "slash": "^3.0.0", "string-length": "^4.0.1", "strip-ansi": "^6.0.0", "v8-to-istanbul": "^9.0.1" }, "peerDependencies": { "node-notifier": "^8.0.1 || ^9.0.0 || ^10.0.0" } }, "sha512-sr2I7BmOjJhyqj9ANC6CTLsL4emMoka7HkQpcoMRlhCbQJjz2zsRzw0BDPiPyEFDXAbxKgGFYuQZiSJ1Y6YoTg=="],
+    "@jest/reporters": ["@jest/reporters@29.4.3", "", { "dependencies": { "@bcoe/v8-coverage": "^0.2.3", "@jest/console": "^29.4.3", "@jest/test-result": "^29.4.3", "@jest/transform": "^29.4.3", "@jest/types": "^29.4.3", "@jridgewell/trace-mapping": "^0.3.15", "@types/node": "*", "chalk": "^4.0.0", "collect-v8-coverage": "^1.0.0", "exit": "^0.1.2", "glob": "^7.1.3", "graceful-fs": "^4.2.9", "istanbul-lib-coverage": "^3.0.0", "istanbul-lib-instrument": "^5.1.0", "istanbul-lib-report": "^3.0.0", "istanbul-lib-source-maps": "^4.0.0", "istanbul-reports": "^3.1.3", "jest-message-util": "^29.4.3", "jest-util": "^29.4.3", "jest-worker": "^29.4.3", "slash": "^3.0.0", "string-length": "^4.0.1", "strip-ansi": "^6.0.0", "v8-to-istanbul": "^9.0.1" }, "peerDependencies": { "node-notifier": "^8.0.1 || ^9.0.0 || ^10.0.0" }, "optionalPeers": ["node-notifier"] }, "sha512-sr2I7BmOjJhyqj9ANC6CTLsL4emMoka7HkQpcoMRlhCbQJjz2zsRzw0BDPiPyEFDXAbxKgGFYuQZiSJ1Y6YoTg=="],
 
     "@jest/schemas": ["@jest/schemas@29.4.3", "", { "dependencies": { "@sinclair/typebox": "^0.25.16" } }, "sha512-VLYKXQmtmuEz6IxJsrZwzG9NvtkQsWNnWMsKxqWNu3+CnfzJQhp0WDDKWLVV9hLKr0l3SLLFRqcYHjhtyuDVxg=="],
 
@@ -384,13 +384,13 @@
 
     "istanbul-reports": ["istanbul-reports@3.1.5", "", { "dependencies": { "html-escaper": "^2.0.0", "istanbul-lib-report": "^3.0.0" } }, "sha512-nUsEMa9pBt/NOHqbcbeJEgqIlY/K7rVWUX6Lql2orY5e9roQOthbR3vtY4zzf2orPELg80fnxxk9zUyPlgwD1w=="],
 
-    "jest": ["jest@29.4.3", "", { "dependencies": { "@jest/core": "^29.4.3", "@jest/types": "^29.4.3", "import-local": "^3.0.2", "jest-cli": "^29.4.3" }, "peerDependencies": { "node-notifier": "^8.0.1 || ^9.0.0 || ^10.0.0" }, "bin": { "jest": "bin/jest.js" } }, "sha512-XvK65feuEFGZT8OO0fB/QAQS+LGHvQpaadkH5p47/j3Ocqq3xf2pK9R+G0GzgfuhXVxEv76qCOOcMb5efLk6PA=="],
+    "jest": ["jest@29.4.3", "", { "dependencies": { "@jest/core": "^29.4.3", "@jest/types": "^29.4.3", "import-local": "^3.0.2", "jest-cli": "^29.4.3" }, "peerDependencies": { "node-notifier": "^8.0.1 || ^9.0.0 || ^10.0.0" }, "optionalPeers": ["node-notifier"], "bin": { "jest": "bin/jest.js" } }, "sha512-XvK65feuEFGZT8OO0fB/QAQS+LGHvQpaadkH5p47/j3Ocqq3xf2pK9R+G0GzgfuhXVxEv76qCOOcMb5efLk6PA=="],
 
     "jest-changed-files": ["jest-changed-files@29.4.3", "", { "dependencies": { "execa": "^5.0.0", "p-limit": "^3.1.0" } }, "sha512-Vn5cLuWuwmi2GNNbokPOEcvrXGSGrqVnPEZV7rC6P7ck07Dyw9RFnvWglnupSh+hGys0ajGtw/bc2ZgweljQoQ=="],
 
     "jest-circus": ["jest-circus@29.4.3", "", { "dependencies": { "@jest/environment": "^29.4.3", "@jest/expect": "^29.4.3", "@jest/test-result": "^29.4.3", "@jest/types": "^29.4.3", "@types/node": "*", "chalk": "^4.0.0", "co": "^4.6.0", "dedent": "^0.7.0", "is-generator-fn": "^2.0.0", "jest-each": "^29.4.3", "jest-matcher-utils": "^29.4.3", "jest-message-util": "^29.4.3", "jest-runtime": "^29.4.3", "jest-snapshot": "^29.4.3", "jest-util": "^29.4.3", "p-limit": "^3.1.0", "pretty-format": "^29.4.3", "slash": "^3.0.0", "stack-utils": "^2.0.3" } }, "sha512-Vw/bVvcexmdJ7MLmgdT3ZjkJ3LKu8IlpefYokxiqoZy6OCQ2VAm6Vk3t/qHiAGUXbdbJKJWnc8gH3ypTbB/OBw=="],
 
-    "jest-cli": ["jest-cli@29.4.3", "", { "dependencies": { "@jest/core": "^29.4.3", "@jest/test-result": "^29.4.3", "@jest/types": "^29.4.3", "chalk": "^4.0.0", "exit": "^0.1.2", "graceful-fs": "^4.2.9", "import-local": "^3.0.2", "jest-config": "^29.4.3", "jest-util": "^29.4.3", "jest-validate": "^29.4.3", "prompts": "^2.0.1", "yargs": "^17.3.1" }, "peerDependencies": { "node-notifier": "^8.0.1 || ^9.0.0 || ^10.0.0" }, "bin": { "jest": "bin/jest.js" } }, "sha512-PiiAPuFNfWWolCE6t3ZrDXQc6OsAuM3/tVW0u27UWc1KE+n/HSn5dSE6B2juqN7WP+PP0jAcnKtGmI4u8GMYCg=="],
+    "jest-cli": ["jest-cli@29.4.3", "", { "dependencies": { "@jest/core": "^29.4.3", "@jest/test-result": "^29.4.3", "@jest/types": "^29.4.3", "chalk": "^4.0.0", "exit": "^0.1.2", "graceful-fs": "^4.2.9", "import-local": "^3.0.2", "jest-config": "^29.4.3", "jest-util": "^29.4.3", "jest-validate": "^29.4.3", "prompts": "^2.0.1", "yargs": "^17.3.1" }, "peerDependencies": { "node-notifier": "^8.0.1 || ^9.0.0 || ^10.0.0" }, "optionalPeers": ["node-notifier"], "bin": { "jest": "bin/jest.js" } }, "sha512-PiiAPuFNfWWolCE6t3ZrDXQc6OsAuM3/tVW0u27UWc1KE+n/HSn5dSE6B2juqN7WP+PP0jAcnKtGmI4u8GMYCg=="],
 
     "jest-config": ["jest-config@29.4.3", "", { "dependencies": { "@babel/core": "^7.11.6", "@jest/test-sequencer": "^29.4.3", "@jest/types": "^29.4.3", "babel-jest": "^29.4.3", "chalk": "^4.0.0", "ci-info": "^3.2.0", "deepmerge": "^4.2.2", "glob": "^7.1.3", "graceful-fs": "^4.2.9", "jest-circus": "^29.4.3", "jest-environment-node": "^29.4.3", "jest-get-type": "^29.4.3", "jest-regex-util": "^29.4.3", "jest-resolve": "^29.4.3", "jest-runner": "^29.4.3", "jest-util": "^29.4.3", "jest-validate": "^29.4.3", "micromatch": "^4.0.4", "parse-json": "^5.2.0", "pretty-format": "^29.4.3", "slash": "^3.0.0", "strip-json-comments": "^3.1.1" }, "peerDependencies": { "@types/node": "*", "ts-node": ">=9.0.0" }, "optionalPeers": ["ts-node"] }, "sha512-eCIpqhGnIjdUCXGtLhz4gdDoxKSWXKjzNcc5r+0S1GKOp2fwOipx5mRcwa9GB/ArsxJ1jlj2lmlD9bZAsBxaWQ=="],
 
@@ -600,7 +600,7 @@
 
     "vite": ["vite@4.1.2", "", { "dependencies": { "esbuild": "^0.16.14", "fsevents": "~2.3.2", "postcss": "^8.4.21", "resolve": "^1.22.1", "rollup": "^3.10.0" }, "peerDependencies": { "@types/node": ">= 14", "less": "*", "sass": "*", "stylus": "*", "sugarss": "*", "terser": "^5.4.0" }, "optionalPeers": ["less", "sass", "stylus", "sugarss", "terser"], "bin": { "vite": "bin/vite.js" } }, "sha512-MWDb9Rfy3DI8omDQySbMK93nQqStwbsQWejXRY2EBzEWKmLAXWb1mkI9Yw2IJrc+oCvPCI1Os5xSSIBYY6DEAw=="],
 
-    "vitest": ["vitest@0.25.8", "", { "dependencies": { "@types/chai": "^4.3.4", "@types/chai-subset": "^1.3.3", "@types/node": "*", "acorn": "^8.8.1", "acorn-walk": "^8.2.0", "chai": "^4.3.7", "debug": "^4.3.4", "local-pkg": "^0.4.2", "source-map": "^0.6.1", "strip-literal": "^1.0.0", "tinybench": "^2.3.1", "tinypool": "^0.3.0", "tinyspy": "^1.0.2", "vite": "^3.0.0 || ^4.0.0" }, "peerDependencies": { "@edge-runtime/vm": "*", "@vitest/browser": "*", "@vitest/ui": "*", "happy-dom": "*", "jsdom": "*" }, "optionalPeers": ["@vitest/browser", "@vitest/ui", "happy-dom", "jsdom"], "bin": { "vitest": "vitest.mjs" } }, "sha512-X75TApG2wZTJn299E/TIYevr4E9/nBo1sUtZzn0Ci5oK8qnpZAZyhwg0qCeMSakGIWtc6oRwcQFyFfW14aOFWg=="],
+    "vitest": ["vitest@0.25.8", "", { "dependencies": { "@types/chai": "^4.3.4", "@types/chai-subset": "^1.3.3", "@types/node": "*", "acorn": "^8.8.1", "acorn-walk": "^8.2.0", "chai": "^4.3.7", "debug": "^4.3.4", "local-pkg": "^0.4.2", "source-map": "^0.6.1", "strip-literal": "^1.0.0", "tinybench": "^2.3.1", "tinypool": "^0.3.0", "tinyspy": "^1.0.2", "vite": "^3.0.0 || ^4.0.0" }, "peerDependencies": { "@edge-runtime/vm": "*", "@vitest/browser": "*", "@vitest/ui": "*", "happy-dom": "*", "jsdom": "*" }, "optionalPeers": ["@edge-runtime/vm", "@vitest/browser", "@vitest/ui", "happy-dom", "jsdom"], "bin": { "vitest": "vitest.mjs" } }, "sha512-X75TApG2wZTJn299E/TIYevr4E9/nBo1sUtZzn0Ci5oK8qnpZAZyhwg0qCeMSakGIWtc6oRwcQFyFfW14aOFWg=="],
 
     "walker": ["walker@1.0.8", "", { "dependencies": { "makeerror": "1.0.12" } }, "sha512-ts/8E8l5b7kY0vlWLewOkDXMmPdLcVV4GmOQLyxuSswIJsweeFZtAsMF7k1Nszz+TYBQrlYRmzOnr398y1JemQ=="],
 

bench/express/tsconfig.json

@@ -1,9 +1,9 @@
 {
   "compilerOptions": {
     // Enable latest features
-    "lib": ["ESNext", "DOM"],
+    "lib": ["ESNext"],
     "target": "ESNext",
-    "module": "ESNext",
+    "module": "Preserve",
     "moduleDetection": "force",
     "jsx": "react-jsx",
     "allowJs": true,

bench/ffi/src/bun.lock

@@ -1,5 +1,5 @@
 {
-  "lockfileVersion": 0,
+  "lockfileVersion": 1,
   "workspaces": {
     "": {
       "name": "bench",

bench/glob/match.mjs

@@ -1,19 +1,27 @@
-import micromatch from "micromatch";
+import { Glob } from "bun";
 import { bench, run } from "../runner.mjs";
 
-const Glob = typeof Bun !== "undefined" ? Bun.Glob : undefined;
-const doMatch = typeof Bun === "undefined" ? micromatch.isMatch : (a, b) => new Glob(b).match(a);
 
-bench((Glob ? "Bun.Glob - " : "micromatch - ") + "**/*.js", () => {
-  doMatch("foo/bar.js", "**/*.js");
-});
+function benchPattern(name, glob, pattern) {
+    bench(name, () => {
+        new Glob(glob).match(pattern);
+    })
+}
+
+benchPattern("max-depth" , "1{2,3{4,5{6,7{8,9{a,b{c,d{e,f{g,h{i,j{k,l}}}}}}}}}}m", "13579bdfhjlm");
+benchPattern("non-ascii", "😎/¢£.{ts,tsx,js,jsx}", "😎/¢£.jsx");
+benchPattern("utf8", "フォルダ/**/*", "フォルダ/aaa.js");
+benchPattern("non-ascii+max-depth" , "1{2,3{4,5{6,7{8,😎{a,b{c,d{e,f{g,h{i,j{k,l}}}}}}}}}}m", "1357😎bdfhjlm");
+benchPattern("pretty-average", "test/{foo/**,bar}/baz", "test/bar/baz");
+benchPattern("pretty-average-2", "a/**/c/*.md", "a/bb.bb/aa/b.b/aa/c/xyz.md");
+benchPattern("pretty-average-3", "a/b/**/c{d,e}/**/xyz.md", "a/b/cd/xyz.md");
+benchPattern("pretty-average-4", "foo/bar/**/one/**/*.*", "foo/bar/baz/one/two/three/image.png");
+benchPattern("long-pretty-average", "some/**/needle.{js,tsx,mdx,ts,jsx,txt}", "some/a/bigger/path/to/the/crazy/needle.txt");
+benchPattern("brackets-lots", "f[^eiu][^eiu][^eiu][^eiu][^eiu]r", "foo-bar");
 
-bench((Glob ? "Bun.Glob - " : "micromatch - ") + "*.js", () => {
-  doMatch("bar.js", "*.js");
-});
 
 await run({
-  avg: true,
-  min_max: true,
-  percentiles: true,
-});
+    min_max: true,
+    percentiles: true,
+    avg: true,
+})

bench/glob/micromatch.mjs

@@ -0,0 +1,19 @@
+import micromatch from "micromatch";
+import { bench, run } from "../runner.mjs";
+
+const Glob = typeof Bun !== "undefined" ? Bun.Glob : undefined;
+const doMatch = typeof Bun === "undefined" ? micromatch.isMatch : (a, b) => new Glob(b).match(a);
+
+bench((Glob ? "Bun.Glob - " : "micromatch - ") + "**/*.js", () => {
+  doMatch("foo/bar.js", "**/*.js");
+});
+
+bench((Glob ? "Bun.Glob - " : "micromatch - ") + "*.js", () => {
+  doMatch("bar.js", "*.js");
+});
+
+await run({
+  avg: true,
+  min_max: true,
+  percentiles: true,
+});

bench/gzip/bun.lock

@@ -1,5 +1,5 @@
 {
-  "lockfileVersion": 0,
+  "lockfileVersion": 1,
   "workspaces": {
     "": {
       "name": "bench",

bench/hot-module-reloading/css-stress-test/.gitignore

@@ -1,5 +0,0 @@
-bun
-next
-src/*.mov
-src/*.blob
-

bench/hot-module-reloading/css-stress-test/Makefile

@@ -1,77 +0,0 @@
-SLEEP_INTERVAL ?= 32
-SCREEN_WIDTH ?= $(shell system_profiler -json SPDisplaysDataType 2>/dev/null | jq -r '.. | objects | select(.spdisplays_main) | ._spdisplays_pixels | split(" ")[0]')
-SCREEN_HEIGHT ?= $(shell system_profiler -json SPDisplaysDataType 2>/dev/null | jq -r '.. | objects | select(.spdisplays_main) | ._spdisplays_pixels | split(" ")[2]')
-PROJECT ?= bun
-PACKAGE_NAME ?= bun-cli
-RUN_COUNT ?= 128
-ENDPOINT ?= /
-
-ifeq ($(PROJECT),bun)
-PACKAGE_NAME := bun-cli
-endif
-
-ifeq ($(PROJECT),next)
-PACKAGE_NAME := next
-endif
-
-generate:
-	@killall -9 bun next node || echo ""
-	PROJECT=$(PROJECT) SCREEN_WIDTH=$(SCREEN_WIDTH) SCREEN_HEIGHT=$(SCREEN_HEIGHT) ENDPOINT=$(ENDPOINT) node browser.js 
-
-generate-css-in-js:
-	@killall -9 bun next node || echo ""
-	PROJECT=$(PROJECT) SCREEN_WIDTH=$(SCREEN_WIDTH) SCREEN_HEIGHT=$(SCREEN_HEIGHT) ENDPOINT=/css-in-js node browser.js 
-loop:
-	cp src/colors.css.0 src/colors.css
-	sleep 3
-	osascript -e 'tell application "System Events" to tell process "Chromium"' \
-		-e 'set frontmost to true' \
-		-e 'if windows is not {} then perform action "AXRaise" of item 1 of windows' \
-		-e 'end tell'
-	sleep 0.5
-	cd src; zig run -Doptimize=ReleaseFast ../color-looper.zig -- ./colors.css:0 $(SLEEP_INTERVAL)
-	cp src/colors.css.blob $(PROJECT)/colors.css.blob
-
-loop-emotion:
-	cp src/css-in-js-styles.0 src/css-in-js-styles.tsx
-	sleep 3
-	osascript -e 'tell application "System Events" to tell process "Chromium"' \
-		-e 'set frontmost to true' \
-		-e 'if windows is not {} then perform action "AXRaise" of item 1 of windows' \
-		-e 'end tell'
-	sleep 0.5
-	cd src; zig run -Doptimize=ReleaseFast ../color-looper.emotion.zig -- ./css-in-js-styles.tsx:0 $(SLEEP_INTERVAL)
-	cp src/css-in-js-styles.tsx.blob $(PROJECT)/css-in-js-styles.blob
-
-process_video: 
-	rm -rf $(FRAMES_DIR); mkdir -p $(FRAMES_DIR); ffmpeg -i src/colors.css.mov -vf fps=120,format=gray $(FRAMES_DIR)/%d.tif
-
-FRAMES_DIR ?= $(shell mkdir -p ./$(PROJECT)/frames; realpath ./$(PROJECT)/frames)
-
-TIF_FILES := $(wildcard $(FRAMES_DIR)/*.tif)
-TXT_FILES := $(wildcard $(FRAMES_DIR)/*.txt)
-
-OBJ_FILES := $(patsubst $(SRC_DIR)/%.tif,$(OBJ_DIR)/%.txt,$(TIF_FILES))
-TRIM_FILES := $(patsubst $(SRC_DIR)/%.txt,$(OBJ_DIR)/%.trim,$(TXT_FILES))
-
-frames: $(OBJ_FILES)
-
-
-$(FRAMES_DIR)/%.txt: $(FRAMES_DIR)/%.tif
-	 tesseract -l eng $< $@ 
-
-trim: $(TRIM_FILES) cleanup print
-
-
-
-$(FRAMES_DIR)/%.trim: $(FRAMES_DIR)/%.txt
-	 (grep "Ran:" $< || echo "\n") >> $(PROJECT)/frames.all
-
-cleanup:
-	sed 's/^Ran: *//' $(PROJECT)/frames.all | tr -d ' ' | sort | uniq > $(PROJECT)/frames.all.clean
-
-print:
-	PACKAGE_NAME=$(PACKAGE_NAME) SLEEP_INTERVAL=$(SLEEP_INTERVAL) PROJECT=$(PROJECT) OUTFILE=timings/$(PACKAGE_NAME) node read-frames.js 
-
-print-emotion:
-	PACKAGE_NAME=$(PACKAGE_NAME) SLEEP_INTERVAL=$(SLEEP_INTERVAL) PROJECT=$(PROJECT) OUTFILE=timings/emotion_$(PACKAGE_NAME) node read-frames.js 

bench/hot-module-reloading/css-stress-test/README.md

@@ -1,62 +0,0 @@
-# CSS Stress Test
-
-This benchmarks bundler performance for CSS hot reloading.
-
-## Results
-
-bun is 14x faster than Next.js at hot reloading CSS.
-
-```
- bun v0.0.34
- Saving every 16ms
-
- Frame time:
- 50th percentile: 22.2ms
- 75th percentile: 23.9ms
- 90th percentile: 25.3ms
- 95th percentile: 43.6ms
- 99th percentile: 49.1ms
- Rendered frames: 922 / 1024 (90%)
-```
-
-```
- Next.js v11.1.2
- Saving every 16ms
-
- Frame time:
- 50th percentile: 312ms
- 75th percentile: 337.6ms
- 90th percentile: 387.7ms
- 95th percentile: 446.9ms
- 99th percentile: 591.7ms
- Rendered frames: 64 / 1024 (6%)
-```
-
-## How it works
-
-It times pixels instead of builds. `color-looper.zig` writes color updates and the timestamp to a css file, while simultaneously screen recording a non-headless Chromium instance. After it finishes, it OCRs the video frames and verifies the scanned timestamps against the actual data. This data measures (1) how long each update took from saving to disk up to the pixels visible on the screen and (2) what % of frames were rendered.
-
-The intent is to be as accurate as possible. Measuring times reported client-side is simpler, but lower accuracy since those times may not correspond to pixels on the screen and do not start from when the data was written to disk (at best, they measure when the filesystem watcher detected the update, but often not that either). `color-looper.zig` must run separately from `browser.js` or the results will be inaccurate.
-
-It works like this:
-
-1. `browser.js` loads either bun or Next.js and a Chromium instance opened to the correct webpage
-2. `color-looper.zig` updates [`./src/colors.css`](./src/colors.css) in a loop up to `1024` times (1024 is arbitrary), sleeping every `16`ms or `32`ms (a CLI arg you can pass it). The `var(--timestamp)` CSS variable contains the UTC timestamp with precision of milliseconds and one extra decimal point
-3. `color-looper.zig` automatically records the screen via `screencapture` (builtin on macOS) and saves it, along with a `BigUint64Array` containing all the expected timestamps. When it's done, it writes to a designated file on disk which `browser.js` picks up as the signal to close the browser.
-4. `ffmpeg` converts each frame into a black and white `.tif` file, which `tesseract` then OCRs
-5. Various cleanup scripts extract the timestamp from each of those OCR'd frames into a single file
-6. Using the OCR'd data, `./read-frames.js` calculates the 50th, 75th, 90th, 95th, and 99th percentile frame time, along with how many frames were skipped. Frame time is the metric here that matters here because that's how much time elapsed between each update. It includes the artificial sleep interval, so it will not be faster than the sleep interval.
-
-The script `run.sh` runs all the commands necessary to do this work unattended. It takes awhile though. The slow part is OCR'ing all the frames.
-
-To run this, you need:
-
-- `zig`
-- `bun-cli`
-- `node`
-- `tesseract`
-- `screencapture` (macOS builtin)
-- `ffmpeg`
-- `puppeteer` (from the package.json)
-
-You will need to run `bun bun --use next` first, with `next@11.1.2`. It will only run on macOS due to the dependencies on `screencapture`, how it detects screen resolution (so that Chromium is maximized), and how it auto-focuses Chromium (apple script)

bench/hot-module-reloading/css-stress-test/browser.js

@@ -1,114 +0,0 @@
-const puppeteer = require("puppeteer");
-const http = require("http");
-const path = require("path");
-const url = require("url");
-const fs = require("fs");
-const child_process = require("child_process");
-const serverURL = process.env.TEST_SERVER_URL || "http://localhost:8080";
-
-if (process.env.PROJECT === "bun") {
-  const bunFlags = [`--origin=${serverURL}`].filter(Boolean);
-  const bunExec = process.env.BUN_BIN || "bun";
-  const bunProcess = child_process.spawn(bunExec, bunFlags, {
-    cwd: process.cwd(),
-    stdio: "ignore",
-    env: {
-      ...process.env,
-      DISABLE_BUN_ANALYTICS: "1",
-    },
-
-    shell: false,
-  });
-  console.log("$", bunExec, bunFlags.join(" "));
-  const isDebug = bunExec.endsWith("-debug");
-
-  // bunProcess.stderr.pipe(process.stderr);
-  // bunProcess.stdout.pipe(process.stdout);
-  bunProcess.once("error", err => {
-    console.error("❌ bun error", err);
-    process.exit(1);
-  });
-  process.on("beforeExit", () => {
-    bunProcess?.kill(0);
-  });
-} else if (process.env.PROJECT === "next") {
-  const bunProcess = child_process.spawn("./node_modules/.bin/next", ["--port", "8080"], {
-    cwd: process.cwd(),
-    stdio: "ignore",
-    env: {
-      ...process.env,
-    },
-
-    shell: false,
-  });
-}
-
-const delay = new Promise((resolve, reject) => {
-  const watcher = fs.watch(path.resolve(process.cwd(), "src/colors.css.blob"));
-  watcher.once("change", () => {
-    setTimeout(() => {
-      resolve();
-    }, 1000);
-  });
-});
-
-async function main() {
-  const browser = await puppeteer.launch({
-    headless: false,
-    waitForInitialPage: true,
-    args: [
-      `--window-size=${parseInt(process.env.SCREEN_WIDTH || "1024", 10) / 2},${
-        parseInt(process.env.SCREEN_HEIGHT || "1024", 10) / 2
-      }`,
-    ],
-    defaultViewport: {
-      width: parseInt(process.env.SCREEN_WIDTH || "1024", 10) / 2,
-      height: parseInt(process.env.SCREEN_HEIGHT || "1024", 10) / 2,
-    },
-  });
-  const promises = [];
-  let allTestsPassed = true;
-
-  async function runPage(key) {
-    var page;
-
-    try {
-      console.log("Opening page");
-      page = await browser.newPage();
-
-      console.log(`Navigating to "http://localhost:8080/"`);
-
-      while (true) {
-        try {
-          await page.goto("http://localhost:8080/", { waitUntil: "load" });
-          break;
-        } catch (exception) {
-          if (!exception.toString().includes("ERR_CONNECTION_REFUSED")) break;
-        }
-      }
-
-      await page.bringToFront();
-
-      await delay;
-
-      //   runner.stdout.pipe(process.stdout);
-      //   runner.stderr.pipe(process.stderr);
-      var didResolve = false;
-
-      console.log(`Completed. Done.`);
-    } catch (error) {
-      console.error(error);
-    } finally {
-      await page.close();
-      await browser.close();
-    }
-  }
-
-  return runPage();
-}
-
-main().catch(error =>
-  setTimeout(() => {
-    throw error;
-  }),
-);

bench/hot-module-reloading/css-stress-test/bun.latest.16ms.txt

@@ -1,11 +0,0 @@
-SLEEP_INTERVAL=16 PROJECT=bun node read-frames.js
-bun
- --------------------------------------------------
- CSS HMR FRAME TIME
-
- 50th percentile: 22.2ms 
- 75th percentile: 23.9ms 
- 90th percentile: 25.3ms 
- 95th percentile: 43.6ms 
- 99th percentile: 49.1ms 
- Rendered frames: 922 / 1024 (90%)

bench/hot-module-reloading/css-stress-test/bun.latest.24ms.txt

@@ -1,11 +0,0 @@
-SLEEP_INTERVAL=24 PROJECT=bun node read-frames.js
-bun
- --------------------------------------------------
- CSS HMR FRAME TIME
-
- 50th percentile: 33.4ms 
- 75th percentile: 34.5ms 
- 90th percentile: 35.8ms 
- 95th percentile: 65.5ms 
- 99th percentile: 87.9ms 
- Rendered frames: 937 / 1024 (92%)

bench/hot-module-reloading/css-stress-test/bun.latest.32ms.txt

@@ -1,11 +0,0 @@
-SLEEP_INTERVAL=32 PROJECT=bun node read-frames.js
-bun
- --------------------------------------------------
- CSS HMR FRAME TIME
-
- 50th percentile: 40.7ms 
- 75th percentile: 42.3ms 
- 90th percentile: 43.5ms 
- 95th percentile: 76.4ms 
- 99th percentile: 118.8ms 
- Rendered frames: 958 / 1024 (94%)

bench/hot-module-reloading/css-stress-test/bun.latest.8ms.txt

@@ -1,11 +0,0 @@
-SLEEP_INTERVAL=8 PROJECT=bun node read-frames.js
-bun
- --------------------------------------------------
- CSS HMR FRAME TIME
-
- 50th percentile: 20ms 
- 75th percentile: 24.4ms 
- 90th percentile: 41ms 
- 95th percentile: 53.9ms 
- 99th percentile: 90.4ms 
- Rendered frames: 475 / 1024 (46%)

bench/hot-module-reloading/css-stress-test/color-looper.emotion.zig

@@ -1,218 +0,0 @@
-const std = @import("std");
-
-pub const Counter = extern struct {
-    timestamp: usize,
-    percent: f64,
-    rotate: u32,
-    color_values: [8 * 3]u32,
-};
-
-const RUN_COUNT = 1024;
-
-var counters: [RUN_COUNT]Counter = undefined;
-
-pub const Blob = extern struct {
-    run_count: u32,
-    interval: u64,
-};
-
-pub var all_timestamps: [RUN_COUNT + 1]usize = undefined;
-
-// usage:
-// ./file-path:0 10
-// 1           2 3
-
-// 1. file path
-// 2. Byte offset in file
-// 3. ms update interval
-var color_buf: [8192 + SIMULATE_LONG_FILE.len]u8 = undefined;
-
-pub fn main() anyerror!void {
-    var allocator = std.heap.c_allocator;
-    var timer = try std.time.Timer.start();
-
-    var args = std.mem.span(try std.process.argsAlloc(allocator));
-
-    var basepath_with_colon: []u8 = args[args.len - 2];
-    var basepath: []u8 = "";
-    var position_str: []u8 = "";
-    if (std.mem.lastIndexOfScalar(u8, basepath_with_colon, ':')) |colon| {
-        basepath = basepath_with_colon[0..colon];
-        position_str = basepath_with_colon[colon + 1 ..];
-    }
-    var position = try std.fmt.parseInt(u32, position_str, 10);
-    const filepath = try std.fs.path.resolve(allocator, &.{basepath});
-    var file = try std.fs.openFileAbsolute(filepath, .{ .write = true });
-    var ms = @as(u64, @truncate((try std.fmt.parseInt(u128, args[args.len - 1], 10)) * std.time.ns_per_ms));
-    std.debug.assert(ms > 0);
-    // std.debug.assert(std.math.isFinite(position));
-    var prng = std.rand.DefaultPrng.init(0);
-    var stdout = std.io.getStdOut();
-    var log = stdout.writer();
-    var colors = std.mem.zeroes([4][3]u32);
-    var progress_bar: f64 = 0.0;
-    var destination_count: f64 = 18.0;
-
-    // Randomize initial colors
-    colors[0][0] = prng.random.int(u32);
-    colors[0][1] = prng.random.int(u32);
-    colors[0][2] = prng.random.int(u32);
-
-    colors[1][0] = prng.random.int(u32);
-    colors[1][1] = prng.random.int(u32);
-    colors[1][2] = prng.random.int(u32);
-
-    colors[2][0] = prng.random.int(u32);
-    colors[2][1] = prng.random.int(u32);
-    colors[2][2] = prng.random.int(u32);
-
-    colors[3][0] = prng.random.int(u32);
-    colors[3][1] = prng.random.int(u32);
-    colors[3][2] = prng.random.int(u32);
-    var rotate: u32 = 0;
-    var counter: usize = 0;
-    const video = std.fmt.allocPrint(allocator, "{s}.mov", .{filepath}) catch unreachable;
-    std.fs.deleteFileAbsolute(video) catch {};
-    var screen_recorder_argv = [_][]const u8{ "screencapture", "-v", video };
-
-    var recorder = std.ChildProcess.init(&screen_recorder_argv, allocator);
-    recorder.stdin_behavior = .Pipe;
-    try recorder.spawn();
-    std.time.sleep(std.time.ns_per_s);
-    var wrote: []u8 = undefined;
-    while (counter < RUN_COUNT) {
-        colors[0][0] += 1;
-        colors[0][1] += 1;
-        colors[0][2] += 1;
-        colors[1][0] += 1;
-        colors[1][1] += 1;
-        colors[1][2] += 1;
-        colors[2][0] += 1;
-        colors[2][1] += 1;
-        colors[2][2] += 1;
-        colors[3][0] += 1;
-        colors[3][1] += 1;
-        colors[3][2] += 1;
-        rotate += 1;
-        const fmtd: []const u8 = comptime brk: {
-            break :brk (
-                \\
-                \\import {{ Global }} from "@emotion/react";
-                \\export function CSSInJSStyles() {{
-                \\  return (
-                \\    <Global
-                \\      styles={{`
-                \\:root {{
-                \\  --timestamp: "{d}";
-                \\  --interval: "{s}";
-                \\  --progress-bar: {d}%;
-                \\  --spinner-1-muted: rgb({d}, {d}, {d});
-                \\  --spinner-1-primary: rgb({d}, {d}, {d});
-                \\  --spinner-2-muted: rgb({d}, {d}, {d});
-                \\  --spinner-2-primary: rgb({d}, {d}, {d});
-                \\  --spinner-3-muted: rgb({d}, {d}, {d});
-                \\  --spinner-3-primary: rgb({d}, {d}, {d});
-                \\  --spinner-4-muted: rgb({d}, {d}, {d});
-                \\  --spinner-4-primary: rgb({d}, {d}, {d});
-                \\  --spinner-rotate: {d}deg;
-                \\}}
-            ++ SIMULATE_LONG_FILE ++
-                \\  `}}
-                \\    />
-                \\  );
-                \\}}
-                \\
-            );
-        };
-
-        counters[counter].timestamp = @as(u64, @truncate(@as(u128, @intCast(std.time.nanoTimestamp())) / (std.time.ns_per_ms / 10)));
-        counters[counter].rotate = rotate % 360;
-        counters[counter].percent = std.math.mod(f64, std.math.round(((progress_bar + 1.0) / destination_count) * 1000) / 1000, 100) catch 0;
-        counters[counter].color_values[0] = @as(u32, @intFromFloat(std.math.round(@as(f64, @floatFromInt(((colors[0][0] + 1) % 256))) * 0.8)));
-        counters[counter].color_values[1] = @as(u32, @intFromFloat(std.math.round(@as(f64, @floatFromInt(((colors[0][1] + 1) % 256))) * 0.8)));
-        counters[counter].color_values[2] = @as(u32, @intFromFloat(std.math.round(@as(f64, @floatFromInt(((colors[0][2] + 1) % 256))) * 0.8)));
-        counters[counter].color_values[3] = (colors[0][0] + 1) % 256;
-        counters[counter].color_values[4] = (colors[0][1] + 1) % 256;
-        counters[counter].color_values[5] = (colors[0][2] + 1) % 256;
-        counters[counter].color_values[6] = @as(u32, @intFromFloat(std.math.round(@as(f64, @floatFromInt(((colors[1][0] + 1) % 256))) * 0.8)));
-        counters[counter].color_values[7] = @as(u32, @intFromFloat(std.math.round(@as(f64, @floatFromInt(((colors[1][1] + 1) % 256))) * 0.8)));
-        counters[counter].color_values[8] = @as(u32, @intFromFloat(std.math.round(@as(f64, @floatFromInt(((colors[1][2] + 1) % 256))) * 0.8)));
-        counters[counter].color_values[9] = (colors[1][0] + 1) % 256;
-        counters[counter].color_values[10] = (colors[1][1] + 1) % 256;
-        counters[counter].color_values[11] = (colors[1][2] + 1) % 256;
-        counters[counter].color_values[12] = @as(u32, @intFromFloat(std.math.round(@as(f64, @floatFromInt(((colors[2][0] + 1) % 256))) * 0.8)));
-        counters[counter].color_values[13] = @as(u32, @intFromFloat(std.math.round(@as(f64, @floatFromInt(((colors[2][1] + 1) % 256))) * 0.8)));
-        counters[counter].color_values[14] = @as(u32, @intFromFloat(std.math.round(@as(f64, @floatFromInt(((colors[2][2] + 1) % 256))) * 0.8)));
-        counters[counter].color_values[15] = (colors[2][0] + 1) % 256;
-        counters[counter].color_values[16] = (colors[2][1] + 1) % 256;
-        counters[counter].color_values[17] = (colors[2][2] + 1) % 256;
-        counters[counter].color_values[18] = @as(u32, @intFromFloat(std.math.round(@as(f64, @floatFromInt(((colors[3][0] + 1) % 256))) * 0.8)));
-        counters[counter].color_values[19] = @as(u32, @intFromFloat(std.math.round(@as(f64, @floatFromInt(((colors[3][1] + 1) % 256))) * 0.8)));
-        counters[counter].color_values[20] = @as(u32, @intFromFloat(std.math.round(@as(f64, @floatFromInt(((colors[3][2] + 1) % 256))) * 0.8)));
-        counters[counter].color_values[21] = (colors[3][0] + 1) % 256;
-        counters[counter].color_values[22] = (colors[3][1] + 1) % 256;
-        counters[counter].color_values[23] = (colors[3][2] + 1) % 256;
-
-        file = try std.fs.createFileAbsolute(filepath, .{ .truncate = true });
-        wrote = try std.fmt.bufPrint(&color_buf, fmtd, .{
-            counters[counter].timestamp,
-            args[args.len - 1],
-            counters[counter].percent,
-            counters[counter].color_values[0],
-            counters[counter].color_values[1],
-            counters[counter].color_values[2],
-            counters[counter].color_values[3],
-            counters[counter].color_values[4],
-            counters[counter].color_values[5],
-            counters[counter].color_values[6],
-            counters[counter].color_values[7],
-            counters[counter].color_values[8],
-            counters[counter].color_values[9],
-            counters[counter].color_values[10],
-            counters[counter].color_values[11],
-            counters[counter].color_values[12],
-            counters[counter].color_values[13],
-            counters[counter].color_values[14],
-            counters[counter].color_values[15],
-            counters[counter].color_values[16],
-            counters[counter].color_values[17],
-            counters[counter].color_values[18],
-            counters[counter].color_values[19],
-            counters[counter].color_values[20],
-            counters[counter].color_values[21],
-            counters[counter].color_values[22],
-            counters[counter].color_values[23],
-            counters[counter].rotate,
-        });
-        progress_bar += 1.0;
-        _ = try file.writeAll(wrote);
-
-        try log.print("[{d}] \"{s}\":{d}\n", .{
-            std.time.nanoTimestamp(),
-            filepath,
-            position,
-        });
-        counter += 1;
-        // If we don't close the file, Parcel seems to never recognize it
-        file.close();
-        std.time.sleep(ms);
-    }
-
-    try recorder.stdin.?.writeAll(&[_]u8{ 3, ';' });
-
-    _ = try recorder.wait();
-
-    all_timestamps[0] = wrote.len;
-    for (counters, 0..) |count, i| {
-        all_timestamps[i + 1] = count.timestamp;
-    }
-
-    std.time.sleep(std.time.ns_per_s);
-    var blob_file = try std.fs.createFileAbsolute(std.fmt.allocPrint(std.heap.c_allocator, "{s}.blob", .{filepath}) catch unreachable, .{ .truncate = true });
-    try blob_file.writeAll(std.mem.asBytes(&all_timestamps));
-    blob_file.close();
-}
-
-const SIMULATE_LONG_FILE =
-    \\
-;

bench/hot-module-reloading/css-stress-test/index.html

@@ -1,15 +0,0 @@
-<!DOCTYPE html>
-<html>
-  <head>
-    <link
-      rel="stylesheet"
-      crossorigin="anonymous"
-      href="https://fonts.googleapis.com/css2?family=IBM+Plex+Sans:wght@400;700&family=Space+Mono:wght@400;700&display=swap"
-    />
-    <link rel="stylesheet" href="src/index.css" />
-    <script async src="src/index.tsx" type="module"></script>
-  </head>
-  <body>
-    <div id="reactroot"></div>
-  </body>
-</html>

bench/hot-module-reloading/css-stress-test/inject.js

@@ -1,2 +0,0 @@
-import React from "react";
-export { React };

bench/hot-module-reloading/css-stress-test/next-env.d.ts

@@ -1,6 +0,0 @@
-/// <reference types="next" />
-/// <reference types="next/types/global" />
-/// <reference types="next/image-types/global" />
-
-// NOTE: This file should not be edited
-// see https://nextjs.org/docs/basic-features/typescript for more information.

bench/hot-module-reloading/css-stress-test/next.config.js

@@ -1,5 +0,0 @@
-module.exports = {
-  experimental: {
-    swcLoader: true,
-  },
-};

bench/hot-module-reloading/css-stress-test/next.latest.16ms.txt

@@ -1,11 +0,0 @@
-SLEEP_INTERVAL=16 PROJECT=next node read-frames.js
-next
- --------------------------------------------------
- CSS HMR FRAME TIME
-
- 50th percentile: 312ms 
- 75th percentile: 337.6ms 
- 90th percentile: 387.7ms 
- 95th percentile: 446.9ms 
- 99th percentile: 591.7ms 
- Rendered frames: 64 / 1024 (6%)

bench/hot-module-reloading/css-stress-test/next.latest.24ms.txt

@@ -1,11 +0,0 @@
-SLEEP_INTERVAL=24 PROJECT=next node read-frames.js
-next
- --------------------------------------------------
- CSS HMR FRAME TIME
-
- 50th percentile: 310.1ms 
- 75th percentile: 360.3ms 
- 90th percentile: 461.6ms 
- 95th percentile: 660.4ms 
- 99th percentile: 1009.9ms 
- Rendered frames: 78 / 1024 (8%)

bench/hot-module-reloading/css-stress-test/next.latest.32ms.txt

@@ -1,11 +0,0 @@
-SLEEP_INTERVAL=32 PROJECT=next node read-frames.js
-next
- --------------------------------------------------
- CSS HMR FRAME TIME
-
- 50th percentile: 306.7ms 
- 75th percentile: 324.7ms 
- 90th percentile: 380ms 
- 95th percentile: 483.6ms 
- 99th percentile: 933.6ms 
- Rendered frames: 116 / 1024 (11%)

bench/hot-module-reloading/css-stress-test/next.latest.8ms.txt

@@ -1,11 +0,0 @@
-SLEEP_INTERVAL=8 PROJECT=next node read-frames.js
-next
- --------------------------------------------------
- CSS HMR FRAME TIME
-
- 50th percentile: 320.4ms 
- 75th percentile: 368.8ms 
- 90th percentile: 527.2ms 
- 95th percentile: 532.4ms 
- 99th percentile: 532.4ms 
- Rendered frames: 32 / 1024 (3%)

bench/hot-module-reloading/css-stress-test/package.json

@@ -1,43 +0,0 @@
-{
-  "name": "simple-react",
-  "version": "1.0.0",
-  "license": "MIT",
-  "dependencies": {
-    "@emotion/core": "latest",
-    "@emotion/css": "latest",
-    "@emotion/react": "latest",
-    "@vitejs/plugin-react-refresh": "^1.3.3",
-    "antd": "^4.16.1",
-    "bun-framework-next": "latest",
-    "left-pad": "^1.3.0",
-    "next": "^12",
-    "parcel": "2.0.0-beta.3",
-    "path-browserify": "^1.0.1",
-    "percentile": "^1.5.0",
-    "puppeteer": "^10.4.0",
-    "puppeteer-video-recorder": "^1.0.5",
-    "react": "^17.0.2",
-    "react-bootstrap": "^1.6.1",
-    "react-dom": "^17.0.2",
-    "react-form": "^4.0.1",
-    "react-hook-form": "^7.8.3",
-    "url": "^0.11.0",
-    "wipwipwipwip-next-donotuse": "4.0.0"
-  },
-  "parcel": "parceldist/index.js",
-  "targets": {
-    "parcel": {
-      "outputFormat": "esmodule",
-      "sourceMap": false,
-      "optimize": false,
-      "engines": {
-        "chrome": "last 1 version"
-      }
-    }
-  },
-  "devDependencies": {
-    "@microsoft/fetch-event-source": "^2.0.1",
-    "@snowpack/plugin-react-refresh": "^2.5.0",
-    "typescript": "^4.3.4"
-  }
-}

bench/hot-module-reloading/css-stress-test/pages/_app.tsx

@@ -1,13 +0,0 @@
-// @ts-nocheck
-import "../src/index.css";
-
-import App from "next/app";
-
-class MyApp extends App {
-  render() {
-    const { Component, pageProps } = this.props;
-    return <Component {...pageProps} />;
-  }
-}
-
-export default MyApp;

bench/hot-module-reloading/css-stress-test/pages/index.tsx

@@ -1,13 +0,0 @@
-import { Main } from "src/main";
-export function IndexPage() {
-  return (
-    <Main
-      productName={
-        // @ts-ignore
-        typeof location !== "undefined" ? location.search.substring(1) : ""
-      }
-    />
-  );
-}
-
-export default IndexPage;

bench/hot-module-reloading/css-stress-test/react-inject.js

@@ -1 +0,0 @@
-export { default as React } from "react";

bench/hot-module-reloading/css-stress-test/read-frames.js

@@ -1,99 +0,0 @@
-const fs = require("fs");
-
-const path = require("path");
-const PROJECT = process.env.PROJECT || "bun";
-const percentile = require("percentile");
-const PACKAGE_NAME = process.env.PACKAGE_NAME;
-const label = `${PACKAGE_NAME}@${require(PACKAGE_NAME + "/package.json").version}`;
-
-const BASEFOLDER = path.resolve(PROJECT);
-const OUTFILE = path.join(process.cwd(), process.env.OUTFILE);
-
-const buf = fs.readFileSync(BASEFOLDER + "/colors.css.blob");
-const VALID_TIMES = new BigUint64Array(buf.buffer).subarray(1);
-const cssFileSize = new BigUint64Array(buf.buffer)[0];
-
-const TOTAL_FRAMES = VALID_TIMES.length;
-
-const timings = fs
-  .readFileSync(BASEFOLDER + "/frames.all.clean", "utf8")
-  .split("\n")
-  .map(a => a.replace(/[Ran:'\.]?/gm, "").trim())
-  .filter(a => parseInt(a, 10))
-  .filter(a => a.length > 0 && VALID_TIMES.includes(BigInt(parseInt(a, 10))))
-  .map(num => BigInt(num));
-
-timings.sort();
-
-const frameTimesCount = timings.length;
-
-var frameTime = new Array(Math.floor(frameTimesCount / 2));
-
-for (let i = 0; i < frameTime.length; i++) {
-  const i1 = i * 2;
-  const i2 = i * 2 + 1;
-
-  frameTime[i] = Math.max(Number(timings[i2] - timings[i1]), 0);
-}
-
-const report = {
-  label,
-  cssFileSize: Number(cssFileSize),
-  at: new Date().toISOString(),
-  sleep: process.env.SLEEP_INTERVAL,
-  package: {
-    name: PACKAGE_NAME,
-    version: require(PACKAGE_NAME + "/package.json").version,
-  },
-  timestamps: timings.map(a => Number(a)),
-  frameTimes: frameTime,
-  percentileMs: {
-    50: percentile(50, frameTime) / 10,
-    75: percentile(75, frameTime) / 10,
-    90: percentile(90, frameTime) / 10,
-    95: percentile(95, frameTime) / 10,
-    99: percentile(99, frameTime) / 10,
-  },
-};
-
-fs.writeFileSync(
-  path.join(
-    path.dirname(OUTFILE),
-    path.basename(OUTFILE) +
-      "@" +
-      report.package.version +
-      "." +
-      process.env.SLEEP_INTERVAL +
-      "ms." +
-      `${process.platform}-${process.arch === "arm64" ? "aarch64" : process.arch}` +
-      ".json",
-  ),
-  JSON.stringify(report, null, 2),
-);
-
-console.log(
-  label + "\n",
-  "-".repeat(50) + "\n",
-  "CSS HMR FRAME TIME\n" + "\n",
-
-  "50th percentile:",
-  percentile(50, frameTime) / 10 + "ms",
-  "\n",
-  "75th percentile:",
-  percentile(75, frameTime) / 10 + "ms",
-  "\n",
-  "90th percentile:",
-  percentile(90, frameTime) / 10 + "ms",
-  "\n",
-  "95th percentile:",
-  percentile(95, frameTime) / 10 + "ms",
-  "\n",
-  "99th percentile:",
-  percentile(99, frameTime) / 10 + "ms",
-  "\n",
-  "Rendered frames:",
-  timings.length,
-  "/",
-  TOTAL_FRAMES,
-  "(" + Math.round(Math.max(Math.min(1.0, timings.length / TOTAL_FRAMES), 0) * 100) + "%)",
-);

bench/hot-module-reloading/css-stress-test/run.sh

@@ -1,83 +0,0 @@
-#!/usr/bin/env bash
-
-echo "Running next at 24ms"
-PROJECT=next SLEEP_INTERVAL=24 make generate &
-PROJECT=next SLEEP_INTERVAL=24 make loop
-killall Chromium || echo "";
-PROJECT=next SLEEP_INTERVAL=24 make process_video
-PROJECT=next SLEEP_INTERVAL=24 make frames -j$(nproc)
-PROJECT=next SLEEP_INTERVAL=24 make trim
-cp src/colors.css.blob next/colors.css.blob
-PROJECT=next SLEEP_INTERVAL=24 make print > "next.latest.24ms.txt"
-
-echo "Running bun at 24ms"
-PROJECT=bun SLEEP_INTERVAL=24 make generate &
-PROJECT=bun SLEEP_INTERVAL=24 make loop
-killall Chromium || echo "";
-PROJECT=bun SLEEP_INTERVAL=24 make process_video
-PROJECT=bun SLEEP_INTERVAL=24 make frames -j$(nproc)
-PROJECT=bun SLEEP_INTERVAL=24 make trim
-cp src/colors.css.blob bun/colors.css.blob
-PROJECT=bun SLEEP_INTERVAL=24 make print > "bun.latest.24ms.txt"
-
-echo "Running next at 16ms"
-PROJECT=next SLEEP_INTERVAL=16 make generate &
-PROJECT=next SLEEP_INTERVAL=16 make loop
-killall Chromium || echo "";
-PROJECT=next SLEEP_INTERVAL=16 make process_video
-PROJECT=next SLEEP_INTERVAL=16 make frames -j$(nproc)
-PROJECT=next SLEEP_INTERVAL=16 make trim
-cp src/colors.css.blob next/colors.css.blob
-PROJECT=next SLEEP_INTERVAL=16 make print > "next.latest.16ms.txt"
-
-echo "Running bun at 16ms"
-PROJECT=bun SLEEP_INTERVAL=16 make generate &
-PROJECT=bun SLEEP_INTERVAL=16 make loop
-killall Chromium || echo "";
-PROJECT=bun SLEEP_INTERVAL=16 make process_video
-PROJECT=bun SLEEP_INTERVAL=16 make frames -j$(nproc)
-PROJECT=bun SLEEP_INTERVAL=16 make trim
-cp src/colors.css.blob bun/colors.css.blob
-PROJECT=bun SLEEP_INTERVAL=16 make print > "bun.latest.16ms.txt"
-
-echo "Running bun at 8ms"
-PROJECT=bun SLEEP_INTERVAL=8 make generate &
-PROJECT=bun SLEEP_INTERVAL=8 make loop
-killall Chromium || echo "";
-PROJECT=bun SLEEP_INTERVAL=8 make process_video
-PROJECT=bun SLEEP_INTERVAL=8 make frames -j$(nproc)
-PROJECT=bun SLEEP_INTERVAL=8 make trim
-cp src/colors.css.blob bun/colors.css.blob
-PROJECT=bun SLEEP_INTERVAL=8 make print > "bun.latest.8ms.txt"
-
-
-echo "Running next at 8ms"
-PROJECT=next SLEEP_INTERVAL=8 make generate &
-PROJECT=next SLEEP_INTERVAL=8 make loop
-killall Chromium || echo "";
-PROJECT=next SLEEP_INTERVAL=8 make process_video
-PROJECT=next SLEEP_INTERVAL=8 make frames -j$(nproc)
-PROJECT=next SLEEP_INTERVAL=8 make trim
-cp src/colors.css.blob next/colors.css.blob
-PROJECT=next SLEEP_INTERVAL=8 make print > "next.latest.8ms.txt"
-
-echo "Running bun at 32ms"
-PROJECT=bun SLEEP_INTERVAL=32 make generate &
-PROJECT=bun SLEEP_INTERVAL=32 make loop
-killall Chromium || echo "";
-PROJECT=bun SLEEP_INTERVAL=32 make process_video
-PROJECT=bun SLEEP_INTERVAL=32 make frames -j$(nproc)
-PROJECT=bun SLEEP_INTERVAL=32 make trim
-cp src/colors.css.blob bun/colors.css.blob
-PROJECT=bun SLEEP_INTERVAL=32 make print > "bun.latest.32ms.txt"
-
-echo "Running next at 32ms"
-PROJECT=next SLEEP_INTERVAL=32 make generate &
-PROJECT=next SLEEP_INTERVAL=32 make loop
-killall Chromium || echo "";
-PROJECT=next SLEEP_INTERVAL=32 make process_video
-PROJECT=next SLEEP_INTERVAL=32 make frames -j$(nproc)
-PROJECT=next SLEEP_INTERVAL=32 make trim
-cp src/colors.css.blob next/colors.css.blob
-PROJECT=next SLEEP_INTERVAL=32 make print > "next.latest.32ms.txt"
-

bench/hot-module-reloading/css-stress-test/src/colors.css.0

@@ -1,14 +0,0 @@
-:root {
-  --timestamp: "0";
-  --interval: "8";
-  --progress-bar: 0%;
-  --spinner-1-muted: rgb(179, 6, 202);
-  --spinner-1-primary: rgb(224, 8, 253);
-  --spinner-2-muted: rgb(22, 188, 124);
-  --spinner-2-primary: rgb(27, 235, 155);
-  --spinner-3-muted: rgb(89, 72, 0);
-  --spinner-3-primary: rgb(111, 90, 0);
-  --spinner-4-muted: rgb(18, 84, 202);
-  --spinner-4-primary: rgb(23, 105, 253);
-  --spinner-rotate: 304deg;
-}

bench/hot-module-reloading/css-stress-test/src/css-in-js-styles.0

@@ -1,23 +0,0 @@
-import { Global } from "@emotion/react";
-export function CSSInJSStyles() {
-  return (
-    <Global
-      styles={`
-      :root {
-        --timestamp: "0";
-        --interval: "8";
-        --progress-bar: 11.83299999999997%;
-        --spinner-1-muted: rgb(142, 6, 182);
-        --spinner-1-primary: rgb(177, 8, 227);
-        --spinner-2-muted: rgb(110, 148, 190);
-        --spinner-2-primary: rgb(138, 185, 238);
-        --spinner-3-muted: rgb(75, 45, 64);
-        --spinner-3-primary: rgb(94, 56, 80);
-        --spinner-4-muted: rgb(155, 129, 108);
-        --spinner-4-primary: rgb(194, 161, 135);
-        --spinner-rotate: 213deg;
-      }
-  `}
-    />
-  );
-}

bench/hot-module-reloading/css-stress-test/src/css-in-js-styles.tsx

@@ -1,22 +0,0 @@
-import { Global } from "@emotion/react";
-export function CSSInJSStyles() {
-  return (
-    <Global
-      styles={`
-:root {
-  --timestamp: "16336621338281";
-  --interval: "16";
-  --progress-bar: 56.889%;
-  --spinner-1-muted: rgb(179, 6, 202);
-  --spinner-1-primary: rgb(224, 8, 253);
-  --spinner-2-muted: rgb(22, 188, 124);
-  --spinner-2-primary: rgb(27, 235, 155);
-  --spinner-3-muted: rgb(89, 72, 0);
-  --spinner-3-primary: rgb(111, 90, 0);
-  --spinner-4-muted: rgb(18, 84, 202);
-  --spinner-4-primary: rgb(23, 105, 253);
-  --spinner-rotate: 304deg;
-}  `}
-    />
-  );
-}

bench/hot-module-reloading/css-stress-test/src/index.css

@@ -1,248 +0,0 @@
-@import "./colors.css";
-
-:root {
-  --heading-font: "Space Mono", system-ui;
-  --body-font: "IBM Plex Sans", system-ui;
-
-  --color-brand: #02ff00;
-  --color-brand-muted: rgb(2, 150, 0);
-
-  --padding-horizontal: 90px;
-
-  --page-background: black;
-  --page-background-alpha: rgba(0, 0, 0, 0.8);
-
-  --result__background-color: black;
-  --result__primary-color: var(--color-brand);
-  --result__foreground-color: white;
-  --result__muted-color: rgb(165, 165, 165);
-
-  --card-width: 352px;
-
-  --page-width: 1152px;
-
-  --snippets_container-background-unfocused: #171717;
-  --snippets_container-background-focused: #0017e9;
-  --snippets_container-background: var(
-    --snippets_container-background-unfocused
-  );
-  --snippets_container-muted-color: rgb(153, 153, 153);
-}
-
-body {
-  color: white;
-  margin: 0;
-
-  padding: 0;
-  font-family: var(--body-font);
-  background-color: var(--page-background);
-  color: var(--result__muted-color);
-  display: flex;
-  flex-direction: column;
-  height: 100%;
-}
-
-.Subtitle {
-  text-align: center;
-  font-size: 4em;
-  margin: 0;
-  padding: 0;
-  margin-bottom: 0.25em;
-
-  align-items: center;
-  display: flex;
-  flex-direction: row;
-}
-
-#reactroot,
-#__next,
-body,
-html {
-  height: 100%;
-}
-
-.Title {
-  color: var(--color-brand);
-  font-family: var(--heading-font);
-  font-weight: 700;
-  margin-top: 48px;
-  font-size: 48px;
-  text-transform: capitalize;
-  text-align: center;
-}
-
-.Description {
-  text-align: center;
-}
-
-.main {
-  display: flex;
-  flex-direction: column;
-  height: 100%;
-}
-
-header,
-.main {
-  width: 650px;
-  margin: 0 auto;
-}
-
-section {
-  width: 650px;
-}
-
-header {
-  margin-bottom: 48px;
-}
-
-footer {
-  flex-shrink: 0;
-}
-
-#reactroot,
-#__next {
-  display: flex;
-  flex-direction: column;
-  justify-content: center;
-}
-
-section {
-  height: 300px;
-  display: flex;
-  flex-direction: column;
-}
-
-.ran,
-.timer {
-  white-space: nowrap;
-  font-weight: bold;
-  -webkit-text-stroke: white;
-  -webkit-text-stroke-width: 2px;
-  color: white;
-  font-size: 100px;
-}
-.ran {
-}
-
-.ProgressBar-container {
-  width: 100%;
-  display: block;
-  position: relative;
-  border-left: 10px solid red;
-  border-right: 10px solid pink;
-  border-top: 10px solid yellow;
-  border-bottom: 10px solid orange;
-  border-radius: 4px;
-
-  height: 92px;
-}
-
-.ProgressBar {
-  position: absolute;
-  top: 0;
-  bottom: 0;
-  right: 0;
-  left: 0;
-  width: 100%;
-  height: 100%;
-  display: block;
-  background-color: var(--color-brand);
-  transform-origin: top left;
-  border-radius: 4px;
-  transform: scaleX(var(--progress-bar, 0%));
-}
-
-.Bundler-container {
-  background-color: var(--snippets_container-background-focused);
-  font-size: 64px;
-  font-weight: bold;
-  color: white;
-  left: 0;
-  right: 0;
-  padding: 0.8em 0.8em;
-}
-
-.Bundler-updateRate {
-  font-size: 0.8em;
-  font-weight: normal;
-  display: flex;
-  color: var(--result__muted-color);
-}
-
-.interval:before {
-  content: var(--interval, "16");
-}
-
-.highlight {
-  margin-left: 0.5ch;
-  color: white;
-}
-
-.timer:after {
-  content: var(--timestamp);
-  font-variant-numeric: tabular-nums;
-  font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Oxygen,
-    Ubuntu, Cantarell, "Open Sans", "Helvetica Neue", sans-serif;
-  display: inline;
-  font-weight: 500;
-  color: white;
-  width: 100%;
-}
-
-.SectionLabel {
-  font-weight: 300;
-  font-family: var(--heading-font);
-  text-align: center;
-  width: 100%;
-  font-weight: 700;
-  margin-top: 24px;
-}
-
-.FooterLabel {
-  margin-top: 0;
-  margin-bottom: 12px;
-}
-
-.Spinner-container {
-  --spinner-muted: rgb(0, 255, 0);
-  --spinner-primary: rgb(0, 60, 255);
-
-  width: 96px;
-  height: 96px;
-  border-radius: 50%;
-  background-color: var(--page-background);
-  border-top: 1.1em solid var(--spinner-muted);
-  border-right: 1.1em solid var(--spinner-muted);
-  border-bottom: 1.1em solid var(--spinner-muted);
-  border-left: 1.1em solid var(--spinner-primary);
-
-  transform: rotate(var(--spinner-rotate, 12deg));
-}
-
-.Spinners {
-  display: grid;
-  grid-auto-flow: column;
-  justify-content: space-between;
-
-  width: 100%;
-}
-
-.Spinner-1.Spinner-container {
-  --spinner-muted: var(--spinner-1-muted);
-  --spinner-primary: var(--spinner-1-primary);
-}
-
-.Spinner-2.Spinner-container {
-  --spinner-muted: var(--spinner-2-muted);
-  --spinner-primary: var(--spinner-2-primary);
-}
-
-.Spinner-3.Spinner-container {
-  --spinner-muted: var(--spinner-3-muted);
-  --spinner-primary: var(--spinner-3-primary);
-}
-
-.Spinner-4.Spinner-container {
-  --spinner-muted: var(--spinner-4-muted);
-  --spinner-primary: var(--spinner-4-primary);
-}

bench/hot-module-reloading/css-stress-test/src/index.tsx

@@ -1,21 +0,0 @@
-import ReactDOM from "react-dom";
-import { Main } from "./main";
-
-const Base = () => {
-  const name = typeof location !== "undefined" ? decodeURIComponent(location.search.substring(1)) : null;
-  return <Main productName={name} />;
-};
-
-function startReact() {
-  ReactDOM.hydrate(<Base />, document.querySelector("#reactroot"));
-}
-
-if (typeof window !== "undefined") {
-  globalThis.addEventListener("DOMContentLoaded", () => {
-    startReact();
-  });
-
-  startReact();
-}
-
-export { Base };

bench/hot-module-reloading/css-stress-test/src/main.tsx

@@ -1,56 +0,0 @@
-export const Main = (props: { productName: string; cssInJS?: string }) => {
-  return (
-    <>
-      <header>
-        <div className="Title">CSS HMR Stress Test!</div>
-        <p className="Description">
-          This page visually tests how quickly a bundler can update {props.cssInJS ? "CSS-in-JS" : "CSS"} over Hot
-          Module Reloading.
-        </p>
-      </header>
-      <main className="main">
-        <section className="ProgressSection">
-          <p className="Subtitle">
-            <span className="Subtitle-part ran">
-              Ran: <span className="timer"></span>
-            </span>
-          </p>
-
-          <div className="ProgressBar-container">
-            <div className="ProgressBar"></div>
-          </div>
-          <div className="SectionLabel">The progress bar should move from left to right smoothly.</div>
-        </section>
-
-        <section>
-          <div className="Spinners">
-            <div className="Spinner-container Spinner-1">
-              <div className="Spinner"></div>
-            </div>
-
-            <div className="Spinner-container Spinner-2">
-              <div className="Spinner"></div>
-            </div>
-
-            <div className="Spinner-container Spinner-3">
-              <div className="Spinner"></div>
-            </div>
-
-            <div className="Spinner-container Spinner-4">
-              <div className="Spinner"></div>
-            </div>
-          </div>
-          <div className="SectionLabel">The spinners should rotate &amp; change color smoothly.</div>
-        </section>
-      </main>
-      <footer>
-        <div className="SectionLabel FooterLabel">There are no CSS animations on this page.</div>
-
-        <div className="Bundler-container">
-          <div className="Bundler">{props.productName}</div>
-          <div className="Bundler-updateRate">{props.cssInJS ? "CSS-in-JS framework: " + props.cssInJS : ""}</div>
-        </div>
-      </footer>
-    </>
-  );
-};

bench/hot-module-reloading/css-stress-test/timings/bun-cli@0.0.34.32ms.darwin-x64.json

@@ -1,178 +0,0 @@
-{
-  "label": "bun-cli@0.0.34",
-  "at": "2021-10-08T01:01:18.129Z",
-  "sleep": "32",
-  "package": {
-    "name": "bun-cli",
-    "version": "0.0.34"
-  },
-  "timestamps": [
-    16336202536562, 16336202536908, 16336202537294, 16336202537705, 16336202538114, 16336202538534, 16336202538941,
-    16336202539323, 16336202539742, 16336202540159, 16336202540877, 16336202541310, 16336202541749, 16336202542159,
-    16336202542565, 16336202542996, 16336202543333, 16336202543761, 16336202544159, 16336202544534, 16336202544944,
-    16336202545345, 16336202545744, 16336202546159, 16336202546573, 16336202546986, 16336202547399, 16336202547781,
-    16336202548202, 16336202548564, 16336202548949, 16336202549329, 16336202549762, 16336202550168, 16336202550534,
-    16336202550887, 16336202551305, 16336202551659, 16336202552060, 16336202552449, 16336202552854, 16336202553270,
-    16336202553609, 16336202554034, 16336202554437, 16336202554783, 16336202555191, 16336202555623, 16336202556034,
-    16336202556449, 16336202556890, 16336202557283, 16336202557669, 16336202558084, 16336202558496, 16336202558863,
-    16336202559271, 16336202559659, 16336202560051, 16336202560452, 16336202560873, 16336202561290, 16336202561659,
-    16336202562035, 16336202562440, 16336202562862, 16336202563284, 16336202563659, 16336202564034, 16336202564444,
-    16336202564853, 16336202565245, 16336202565659, 16336202566034, 16336202566455, 16336202566873, 16336202567284,
-    16336202567659, 16336202568034, 16336202568386, 16336202568790, 16336202569204, 16336202569620, 16336202570384,
-    16336202570768, 16336202571188, 16336202571551, 16336202572327, 16336202572717, 16336202573116, 16336202573541,
-    16336202573959, 16336202574319, 16336202574682, 16336202575040, 16336202575375, 16336202577001, 16336202577342,
-    16336202577680, 16336202578066, 16336202578451, 16336202579166, 16336202579534, 16336202579960, 16336202580370,
-    16336202580789, 16336202581159, 16336202581576, 16336202581949, 16336202582294, 16336202583087, 16336202583496,
-    16336202583858, 16336202584203, 16336202584606, 16336202585034, 16336202585386, 16336202585788, 16336202586211,
-    16336202586604, 16336202587034, 16336202587459, 16336202587869, 16336202588295, 16336202588668, 16336202589092,
-    16336202589452, 16336202589831, 16336202590197, 16336202590608, 16336202591034, 16336202591460, 16336202591880,
-    16336202592295, 16336202592727, 16336202593172, 16336202593567, 16336202593994, 16336202594397, 16336202594795,
-    16336202595224, 16336202595659, 16336202596058, 16336202596463, 16336202596890, 16336202597322, 16336202597732,
-    16336202598159, 16336202598534, 16336202598951, 16336202599365, 16336202599785, 16336202600159, 16336202600593,
-    16336202601005, 16336202601402, 16336202601807, 16336202602214, 16336202602556, 16336202602895, 16336202603307,
-    16336202603661, 16336202604075, 16336202604491, 16336202604853, 16336202605268, 16336202605670, 16336202606034,
-    16336202606393, 16336202606748, 16336202607170, 16336202607568, 16336202607982, 16336202608411, 16336202608836,
-    16336202609197, 16336202609596, 16336202609965, 16336202610333, 16336202610740, 16336202611159, 16336202611573,
-    16336202611975, 16336202612317, 16336202612691, 16336202613060, 16336202613474, 16336202613903, 16336202614341,
-    16336202614707, 16336202615094, 16336202615534, 16336202615883, 16336202616296, 16336202616671, 16336202617034,
-    16336202617391, 16336202617727, 16336202618159, 16336202618534, 16336202618937, 16336202619360, 16336202619770,
-    16336202620179, 16336202620716, 16336202621143, 16336202621534, 16336202622303, 16336202622659, 16336202623085,
-    16336202623498, 16336202623850, 16336202624220, 16336202624606, 16336202625034, 16336202625387, 16336202625805,
-    16336202626210, 16336202626599, 16336202627034, 16336202627386, 16336202627748, 16336202628159, 16336202628534,
-    16336202628954, 16336202629373, 16336202629809, 16336202630197, 16336202630535, 16336202630916, 16336202631290,
-    16336202631666, 16336202632034, 16336202632369, 16336202633152, 16336202633534, 16336202633883, 16336202634309,
-    16336202634717, 16336202635106, 16336202635871, 16336202636253, 16336202636671, 16336202637070, 16336202637434,
-    16336202637798, 16336202638184, 16336202638539, 16336202638938, 16336202639307, 16336202639666, 16336202640095,
-    16336202640534, 16336202640962, 16336202641307, 16336202641659, 16336202642087, 16336202642521, 16336202642886,
-    16336202643309, 16336202643662, 16336202644067, 16336202644491, 16336202644853, 16336202645226, 16336202645659,
-    16336202646074, 16336202646497, 16336202646890, 16336202647311, 16336202647749, 16336202648169, 16336202648976,
-    16336202649378, 16336202649810, 16336202650165, 16336202650534, 16336202650875, 16336202651250, 16336202651659,
-    16336202652093, 16336202652516, 16336202652921, 16336202653332, 16336202653722, 16336202654142, 16336202654534,
-    16336202654880, 16336202655221, 16336202655562, 16336202655997, 16336202656378, 16336202656811, 16336202657161,
-    16336202657588, 16336202657944, 16336202658360, 16336202658708, 16336202659089, 16336202659428, 16336202659849,
-    16336202660273, 16336202660685, 16336202661105, 16336202661534, 16336202661873, 16336202662228, 16336202662658,
-    16336202663438, 16336202663843, 16336202664219, 16336202664646, 16336202665050, 16336202665487, 16336202665838,
-    16336202666211, 16336202666573, 16336202666927, 16336202667334, 16336202667746, 16336202668158, 16336202668563,
-    16336202668980, 16336202669406, 16336202669753, 16336202670192, 16336202670554, 16336202670903, 16336202671324,
-    16336202671734, 16336202672159, 16336202672573, 16336202672982, 16336202673346, 16336202673680, 16336202674087,
-    16336202674499, 16336202674909, 16336202675260, 16336202676110, 16336202676535, 16336202676913, 16336202677312,
-    16336202677658, 16336202678044, 16336202678413, 16336202678793, 16336202679208, 16336202679604, 16336202680034,
-    16336202680385, 16336202680799, 16336202681213, 16336202681595, 16336202682004, 16336202682346, 16336202682726,
-    16336202683158, 16336202683586, 16336202683990, 16336202684323, 16336202684742, 16336202685175, 16336202685578,
-    16336202685979, 16336202686805, 16336202687206, 16336202687614, 16336202688038, 16336202688473, 16336202688848,
-    16336202689221, 16336202689559, 16336202689971, 16336202690368, 16336202690776, 16336202691159, 16336202691585,
-    16336202692010, 16336202692373, 16336202692780, 16336202693179, 16336202693580, 16336202693991, 16336202694324,
-    16336202694727, 16336202695159, 16336202695588, 16336202695991, 16336202696335, 16336202697160, 16336202697542,
-    16336202697929, 16336202698323, 16336202698674, 16336202699060, 16336202699492, 16336202699835, 16336202700238,
-    16336202700658, 16336202701059, 16336202701420, 16336202701815, 16336202702229, 16336202702659, 16336202703857,
-    16336202704256, 16336202704659, 16336202705497, 16336202706309, 16336202706660, 16336202707085, 16336202707511,
-    16336202707866, 16336202708210, 16336202708552, 16336202708925, 16336202709287, 16336202709670, 16336202710045,
-    16336202710402, 16336202710802, 16336202711167, 16336202711533, 16336202712249, 16336202712660, 16336202713088,
-    16336202713519, 16336202713936, 16336202714355, 16336202714740, 16336202715160, 16336202715533, 16336202715878,
-    16336202716290, 16336202716708, 16336202717102, 16336202718290, 16336202718699, 16336202719052, 16336202719388,
-    16336202719808, 16336202720225, 16336202720659, 16336202721052, 16336202721414, 16336202721828, 16336202722925,
-    16336202723664, 16336202724063, 16336202724405, 16336202726003, 16336202726736, 16336202727158, 16336202727543,
-    16336202727930, 16336202728336, 16336202728703, 16336202729061, 16336202729483, 16336202729832, 16336202730222,
-    16336202730659, 16336202731084, 16336202731500, 16336202731911, 16336202732326, 16336202733158, 16336202733585,
-    16336202734001, 16336202734691, 16336202735042, 16336202735442, 16336202735863, 16336202736255, 16336202736671,
-    16336202737043, 16336202737884, 16336202738671, 16336202739110, 16336202739533, 16336202739886, 16336202740283,
-    16336202740706, 16336202741143, 16336202741534, 16336202741942, 16336202742352, 16336202742697, 16336202743103,
-    16336202743940, 16336202745172, 16336202745542, 16336202745937, 16336202746339, 16336202746758, 16336202747531,
-    16336202747877, 16336202748232, 16336202748658, 16336202749055, 16336202749468, 16336202749859, 16336202750416,
-    16336202750839, 16336202751178, 16336202751572, 16336202752002, 16336202752419, 16336202753269, 16336202753678,
-    16336202754086, 16336202754432, 16336202754835, 16336202755260, 16336202755683, 16336202756059, 16336202756402,
-    16336202756837, 16336202758084, 16336202758507, 16336202758879, 16336202759270, 16336202759674, 16336202760044,
-    16336202760400, 16336202760801, 16336202761659, 16336202762053, 16336202762397, 16336202763199, 16336202763547,
-    16336202763948, 16336202764714, 16336202765113, 16336202765947, 16336202766329, 16336202766664, 16336202767085,
-    16336202768233, 16336202769056, 16336202769758, 16336202770178, 16336202770585, 16336202770929, 16336202771325,
-    16336202772158, 16336202772594, 16336202773033, 16336202773403, 16336202773801, 16336202774179, 16336202774555,
-    16336202774989, 16336202775393, 16336202775809, 16336202776209, 16336202776618, 16336202777033, 16336202777421,
-    16336202777845, 16336202778246, 16336202778658, 16336202779055, 16336202779411, 16336202779761, 16336202780175,
-    16336202780594, 16336202781002, 16336202781848, 16336202782658, 16336202783033, 16336202783857, 16336202784211,
-    16336202784557, 16336202784972, 16336202785377, 16336202785810, 16336202786172, 16336202786934, 16336202787343,
-    16336202787765, 16336202788201, 16336202788563, 16336202788970, 16336202789329, 16336202789672, 16336202790055,
-    16336202790456, 16336202790802, 16336202791580, 16336202791920, 16336202792326, 16336202793158, 16336202793953,
-    16336202794368, 16336202795187, 16336202795622, 16336202796033, 16336202796393, 16336202796777, 16336202797173,
-    16336202797540, 16336202797975, 16336202798317, 16336202798739, 16336202799158, 16336202799567, 16336202799966,
-    16336202800378, 16336202800803, 16336202801232, 16336202801658, 16336202802033, 16336202802374, 16336202802759,
-    16336202803158, 16336202803533, 16336202803947, 16336202804354, 16336202804729, 16336202805158, 16336202805534,
-    16336202805950, 16336202806390, 16336202806805, 16336202807219, 16336202807643, 16336202808033, 16336202808377,
-    16336202808790, 16336202809211, 16336202809560, 16336202809920, 16336202810355, 16336202810758, 16336202811187,
-    16336202811596, 16336202811943, 16336202812348, 16336202812710, 16336202813060, 16336202813398, 16336202813791,
-    16336202814158, 16336202814533, 16336202814878, 16336202815246, 16336202815658, 16336202816079, 16336202816851,
-    16336202817202, 16336202817540, 16336202817905, 16336202818244, 16336202818663, 16336202819068, 16336202819418,
-    16336202819777, 16336202820193, 16336202820599, 16336202821033, 16336202821395, 16336202821745, 16336202822158,
-    16336202822590, 16336202822996, 16336202823396, 16336202823804, 16336202824210, 16336202824581, 16336202824991,
-    16336202825406, 16336202825806, 16336202826210, 16336202826598, 16336202827033, 16336202827446, 16336202827839,
-    16336202828201, 16336202828577, 16336202828968, 16336202829362, 16336202829709, 16336202830096, 16336202830533,
-    16336202830917, 16336202831290, 16336202831699, 16336202832035, 16336202832406, 16336202832804, 16336202833200,
-    16336202833604, 16336202834033, 16336202834386, 16336202834759, 16336202835190, 16336202835621, 16336202836033,
-    16336202836405, 16336202837191, 16336202837613, 16336202838033, 16336202838374, 16336202838798, 16336202839200,
-    16336202839603, 16336202840034, 16336202840389, 16336202840783, 16336202841200, 16336202841617, 16336202842034,
-    16336202842390, 16336202842737, 16336202843158, 16336202843585, 16336202843923, 16336202844313, 16336202844724,
-    16336202845158, 16336202845576, 16336202845939, 16336202846368, 16336202846728, 16336202847158, 16336202847568,
-    16336202847911, 16336202848291, 16336202848695, 16336202849103, 16336202849533, 16336202849942, 16336202850368,
-    16336202850747, 16336202851158, 16336202851549, 16336202851978, 16336202852383, 16336202852725, 16336202853158,
-    16336202853554, 16336202853961, 16336202854308, 16336202854704, 16336202855060, 16336202855418, 16336202855776,
-    16336202856203, 16336202856617, 16336202857036, 16336202857455, 16336202857884, 16336202858262, 16336202858658,
-    16336202859071, 16336202859847, 16336202860237, 16336202860658, 16336202861037, 16336202861452, 16336202861869,
-    16336202862218, 16336202862590, 16336202863001, 16336202863422, 16336202863857, 16336202864219, 16336202864658,
-    16336202865047, 16336202865404, 16336202865789, 16336202866210, 16336202866624, 16336202867033, 16336202867380,
-    16336202867797, 16336202868227, 16336202868658, 16336202869083, 16336202869500, 16336202869906, 16336202870246,
-    16336202870658, 16336202871086, 16336202871441, 16336202871820, 16336202872204, 16336202872546, 16336202872943,
-    16336202873380, 16336202873811, 16336202874213, 16336202874566, 16336202874918, 16336202875261, 16336202875655,
-    16336202876047, 16336202876771, 16336202877202, 16336202877612, 16336202878033, 16336202878412, 16336202878846,
-    16336202879241, 16336202879658, 16336202880072, 16336202880508, 16336202880901, 16336202881308, 16336202881725,
-    16336202882158, 16336202882579, 16336202882945, 16336202883286, 16336202883657, 16336202884048, 16336202884404,
-    16336202884752, 16336202885158, 16336202885533, 16336202885938, 16336202886364, 16336202886759, 16336202887175,
-    16336202887585, 16336202887929, 16336202888345, 16336202888743, 16336202889157, 16336202889570, 16336202889970,
-    16336202890382, 16336202890761, 16336202891187, 16336202891600, 16336202892033, 16336202892454, 16336202892794,
-    16336202893178, 16336202893533, 16336202893903, 16336202894264, 16336202894668, 16336202895049, 16336202895400,
-    16336202895774, 16336202896157, 16336202896537, 16336202896883, 16336202897232, 16336202897658, 16336202898065,
-    16336202898493, 16336202898884, 16336202899251, 16336202899673, 16336202900047, 16336202900467, 16336202900883,
-    16336202901300, 16336202901676, 16336202902068, 16336202902479, 16336202902902, 16336202903260, 16336202903675,
-    16336202904094, 16336202904476, 16336202904824, 16336202905158, 16336202905533, 16336202905934, 16336202906289,
-    16336202906717, 16336202907158, 16336202907547, 16336202907904, 16336202908294, 16336202908717, 16336202909157,
-    16336202909582, 16336202910005, 16336202910399, 16336202910800, 16336202911220, 16336202911657, 16336202912064,
-    16336202912405, 16336202912779, 16336202913158, 16336202913553, 16336202913966, 16336202914376, 16336202914719,
-    16336202915091, 16336202915515, 16336202915887, 16336202916293, 16336202916649, 16336202917438, 16336202917869,
-    16336202918221, 16336202919053, 16336202919425, 16336202919833, 16336202920234, 16336202920658, 16336202921033,
-    16336202921433, 16336202921801, 16336202922161, 16336202922589, 16336202923017, 16336202923418, 16336202923804,
-    16336202924199, 16336202924593, 16336202925033, 16336202925449, 16336202925818, 16336202926223, 16336202926662,
-    16336202927431, 16336202927812, 16336202928227, 16336202928658, 16336202929061, 16336202929473, 16336202929891,
-    16336202930241, 16336202930657, 16336202931057, 16336202931396, 16336202931811, 16336202932225, 16336202932657,
-    16336202933058, 16336202933445, 16336202933790, 16336202934157, 16336202934562, 16336202934988, 16336202935391,
-    16336202935777, 16336202936160, 16336202936562, 16336202936986, 16336202937396, 16336202937751, 16336202938158,
-    16336202938578, 16336202938985, 16336202939396, 16336202939752, 16336202940157, 16336202940585
-  ],
-  "frameTimes": [
-    346, 411, 420, 382, 417, 433, 410, 431, 428, 375, 401, 415, 413, 382, 362, 380, 406, 353, 354, 389, 416, 425, 346,
-    432, 415, 393, 415, 367, 388, 401, 417, 376, 422, 375, 410, 392, 375, 418, 375, 352, 414, 764, 420, 776, 399, 418,
-    363, 335, 341, 386, 715, 426, 419, 417, 345, 409, 345, 428, 402, 393, 425, 426, 424, 379, 411, 426, 415, 445, 427,
-    398, 435, 405, 432, 427, 417, 420, 434, 397, 407, 339, 354, 416, 415, 364, 355, 398, 429, 361, 369, 407, 414, 342,
-    369, 429, 366, 440, 413, 363, 336, 375, 423, 409, 427, 769, 426, 352, 386, 353, 405, 435, 362, 375, 419, 388, 381,
-    376, 335, 382, 426, 389, 382, 399, 364, 355, 369, 429, 428, 352, 434, 423, 405, 362, 433, 423, 421, 420, 402, 355,
-    341, 409, 423, 411, 420, 346, 341, 381, 350, 356, 348, 339, 424, 420, 339, 430, 405, 427, 437, 373, 354, 412, 405,
-    426, 439, 349, 410, 414, 364, 407, 410, 850, 378, 346, 369, 415, 430, 414, 382, 342, 432, 404, 419, 403, 826, 408,
-    435, 373, 412, 408, 426, 363, 399, 411, 403, 429, 344, 382, 394, 386, 343, 420, 361, 414, 1198, 403, 812, 425, 355,
-    342, 362, 375, 400, 366, 411, 431, 419, 420, 345, 418, 1188, 353, 420, 434, 362, 1097, 399, 1598, 422, 387, 367,
-    422, 390, 425, 411, 832, 416, 351, 421, 416, 841, 439, 353, 423, 391, 410, 406, 1232, 395, 419, 346, 426, 413, 557,
-    339, 430, 850, 408, 403, 423, 343, 1247, 372, 404, 356, 858, 344, 348, 766, 834, 335, 1148, 702, 407, 396, 436, 370,
-    378, 434, 416, 409, 388, 401, 397, 350, 419, 846, 375, 354, 415, 433, 762, 422, 362, 359, 383, 346, 340, 832, 415,
-    435, 360, 396, 435, 422, 409, 412, 429, 375, 385, 375, 407, 429, 416, 415, 424, 344, 421, 360, 403, 409, 405, 350,
-    393, 375, 368, 421, 351, 365, 419, 350, 416, 434, 350, 432, 400, 406, 410, 400, 388, 413, 362, 391, 347, 437, 373,
-    336, 398, 404, 353, 431, 412, 786, 420, 424, 403, 355, 417, 417, 347, 427, 390, 434, 363, 360, 410, 380, 408, 409,
-    379, 391, 405, 433, 407, 396, 358, 427, 419, 429, 396, 776, 421, 415, 349, 411, 435, 439, 357, 421, 409, 417, 431,
-    417, 340, 428, 379, 342, 437, 402, 352, 394, 724, 410, 379, 395, 414, 393, 417, 421, 341, 391, 348, 375, 426, 416,
-    344, 398, 413, 412, 426, 433, 340, 355, 361, 381, 374, 380, 349, 407, 391, 422, 420, 417, 392, 423, 415, 382, 334,
-    401, 428, 389, 390, 440, 423, 401, 437, 341, 379, 413, 343, 424, 406, 789, 352, 372, 401, 375, 368, 428, 401, 395,
-    440, 369, 439, 381, 431, 412, 350, 400, 415, 432, 387, 367, 426, 386, 402, 410, 407, 407, 356, 428
-  ],
-  "percentileMs": {
-    "50": 40.7,
-    "75": 42.3,
-    "90": 43.5,
-    "95": 76.4,
-    "99": 118.8
-  }
-}

bench/hot-module-reloading/css-stress-test/tsconfig.json

@@ -1,8 +0,0 @@
-{
-  "extends": "../../../tsconfig.base.json",
-  "compilerOptions": {
-    "baseUrl": ".",
-    "jsx": "react-jsx",
-    "paths": {}
-  }
-}

bench/hot-module-reloading/css-stress-test/vite.config.js

@@ -1,5 +0,0 @@
-import reactRefresh from "@vitejs/plugin-react-refresh";
-
-export default {
-  plugins: [reactRefresh()],
-};

bench/hot-module-reloading/readme.md

@@ -1,15 +0,0 @@
-# Benchmarking hot module reloading
-
-## Methodology
-
-How do you benchmark hot module reloading? What do you call "done" and what do you call "start"?
-
-The answer for "done" is certainly not compilation time. Compilation time is one step.
-
-I think the answer should be different depending on the type of content loaded.
-
-For CSS, the answer should be "when the updated stylesheet was drawn on the screen"
-For JavaScript, the answer should be "when the rebuilt code completed execution such that any changes are applied"
-For images & assets, the answer should be "when the updated asset finished loading"
-
-The start time should be defined as "the timestamp the filesystem set as the write time". As in, the time the developer pressed save in their editor.

bench/install/README.md

@@ -23,7 +23,7 @@ $ hyperfine --prepare 'rm -rf node_modules' --runs 1 'bun install' 'pnpm install
 To run the benchmark with offline mode but without lockfiles:
 
 ```sh
-$ hyperfine --prepare 'rm -rf node_modules' --warmup 1 'rm bun.lockb && bun install' 'rm pnpm-lock.yaml && pnpm install --prefer-offline' 'rm yarn.lock && yarn --offline' 'rm package-lock.json && npm install --prefer-offline'
+$ hyperfine --prepare 'rm -rf node_modules' --warmup 1 'rm bun.lock && bun install' 'rm pnpm-lock.yaml && pnpm install --prefer-offline' 'rm yarn.lock && yarn --offline' 'rm package-lock.json && npm install --prefer-offline'
 ```
 
 ##