fix(transpiler): preserve unicode characters in string literals (#25169)

Unicode characters in BMP range (≤ U+FFFF) are now preserved in
transpiled output instead of being escaped to \uXXXX sequences. This
fixes Function.toString() returning escaped unicode, which broke tools
like unplugin-vue-router that rely on reading source code from function
bodies.

Changes:
- js_printer.zig: Use ascii_only=false for string character printing
- VirtualMachine.zig: Detect non-ASCII UTF-8 and use cloneUTF8 instead
  of treating bytes as Latin-1
- ModuleLoader.zig: Use cloneUTF8 for proper UTF-8 handling

Note: Supplementary characters (> U+FFFF like 🎉) are still escaped as
surrogate pairs due to JSC's UTF-16 string storage. This is a known
limitation.

Closes #25169

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

.buildkite/Dockerfile

@@ -26,7 +26,7 @@ RUN apt-get update && apt-get install -y --no-install-recommends \
    wget curl git python3 python3-pip ninja-build \
    software-properties-common apt-transport-https \
    ca-certificates gnupg lsb-release unzip \
-   libxml2-dev ruby ruby-dev bison gawk perl make golang ccache qemu-user-static \
+   libxml2-dev ruby ruby-dev bison gawk perl make golang \
    && add-apt-repository ppa:ubuntu-toolchain-r/test \
    && apt-get update \
    && apt-get install -y gcc-13 g++-13 libgcc-13-dev libstdc++-13-dev \
@@ -35,8 +35,7 @@ RUN apt-get update && apt-get install -y --no-install-recommends \
    && wget https://apt.llvm.org/llvm.sh \
    && chmod +x llvm.sh \
    && ./llvm.sh ${LLVM_VERSION} all \
-   && rm llvm.sh \
-   && rm -rf /var/lib/apt/lists/*
+   && rm llvm.sh
 
 
 RUN --mount=type=tmpfs,target=/tmp \
@@ -49,6 +48,14 @@ RUN --mount=type=tmpfs,target=/tmp \
     wget -O /tmp/cmake.sh "$cmake_url" && \
     sh /tmp/cmake.sh --skip-license --prefix=/usr
 
+RUN --mount=type=tmpfs,target=/tmp \
+    sccache_version="0.12.0" && \
+    arch=$(uname -m) && \
+    sccache_url="https://github.com/mozilla/sccache/releases/download/v${sccache_version}/sccache-v${sccache_version}-${arch}-unknown-linux-musl.tar.gz" && \
+    wget -O /tmp/sccache.tar.gz "$sccache_url" && \
+    tar -xzf /tmp/sccache.tar.gz -C /tmp && \
+    install -m755 /tmp/sccache-v${sccache_version}-${arch}-unknown-linux-musl/sccache /usr/local/bin
+
 RUN update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-13 130 \
    --slave /usr/bin/g++ g++ /usr/bin/g++-13 \
    --slave /usr/bin/gcc-ar gcc-ar /usr/bin/gcc-ar-13 \
@@ -127,7 +134,9 @@ RUN ARCH=$(if [ "$TARGETARCH" = "arm64" ]; then echo "arm64"; else echo "amd64";
 RUN mkdir -p /var/cache/buildkite-agent /var/log/buildkite-agent /var/run/buildkite-agent /etc/buildkite-agent /var/lib/buildkite-agent/cache/bun
 
 # The following is necessary to configure buildkite to use a stable
-# checkout directory for ccache to be effective.
+# checkout directory. sccache hashes absolute paths into its cache keys,
+# so if buildkite uses a different checkout path each time (which it does
+# by default), sccache will be useless.
 RUN mkdir -p -m 755 /var/lib/buildkite-agent/hooks && \
     cat <<'EOF' > /var/lib/buildkite-agent/hooks/environment
 #!/bin/sh

.buildkite/ci.mjs

@@ -31,7 +31,7 @@ import {
 } from "../scripts/utils.mjs";
 
 /**
- * @typedef {"linux" | "darwin" | "windows"} Os
+ * @typedef {"linux" | "darwin" | "windows" | "freebsd"} Os
  * @typedef {"aarch64" | "x64"} Arch
  * @typedef {"musl"} Abi
  * @typedef {"debian" | "ubuntu" | "alpine" | "amazonlinux"} Distro
@@ -114,8 +114,7 @@ const buildPlatforms = [
   { os: "linux", arch: "x64", abi: "musl", baseline: true, distro: "alpine", release: "3.22" },
   { os: "windows", arch: "x64", release: "2019" },
   { os: "windows", arch: "x64", baseline: true, release: "2019" },
-  // TODO: Enable when Windows ARM64 CI runners are ready
-  // { os: "windows", arch: "aarch64", release: "2019" },
+  { os: "freebsd", arch: "x64", release: "14.3" },
 ];
 
 /**
@@ -126,20 +125,21 @@ const testPlatforms = [
   { os: "darwin", arch: "aarch64", release: "13", tier: "previous" },
   { os: "darwin", arch: "x64", release: "14", tier: "latest" },
   { os: "darwin", arch: "x64", release: "13", tier: "previous" },
-  { os: "linux", arch: "aarch64", distro: "debian", release: "13", tier: "latest" },
-  { os: "linux", arch: "x64", distro: "debian", release: "13", tier: "latest" },
-  { os: "linux", arch: "x64", baseline: true, distro: "debian", release: "13", tier: "latest" },
-  { os: "linux", arch: "x64", profile: "asan", distro: "debian", release: "13", tier: "latest" },
+  { 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: "25.04", tier: "latest" },
+  { os: "linux", arch: "aarch64", distro: "ubuntu", release: "24.04", tier: "latest" },
   { os: "linux", arch: "x64", distro: "ubuntu", release: "25.04", tier: "latest" },
+  { os: "linux", arch: "x64", distro: "ubuntu", release: "24.04", tier: "latest" },
   { os: "linux", arch: "x64", baseline: true, distro: "ubuntu", release: "25.04", tier: "latest" },
+  { os: "linux", arch: "x64", baseline: true, distro: "ubuntu", release: "24.04", tier: "latest" },
   { os: "linux", arch: "aarch64", abi: "musl", distro: "alpine", release: "3.22", tier: "latest" },
   { os: "linux", arch: "x64", abi: "musl", distro: "alpine", release: "3.22", tier: "latest" },
   { os: "linux", arch: "x64", abi: "musl", baseline: true, distro: "alpine", release: "3.22", tier: "latest" },
   { os: "windows", arch: "x64", release: "2019", tier: "oldest" },
   { os: "windows", arch: "x64", release: "2019", baseline: true, tier: "oldest" },
-  // TODO: Enable when Windows ARM64 CI runners are ready
-  // { os: "windows", arch: "aarch64", release: "2019", tier: "oldest" },
 ];
 
 /**
@@ -537,109 +537,6 @@ function getLinkBunStep(platform, options) {
   };
 }
 
-/**
- * Returns the artifact triplet for a platform, e.g. "bun-linux-aarch64" or "bun-linux-x64-musl-baseline".
- * Matches the naming convention in cmake/targets/BuildBun.cmake.
- * @param {Platform} platform
- * @returns {string}
- */
-function getTargetTriplet(platform) {
-  const { os, arch, abi, baseline } = platform;
-  let triplet = `bun-${os}-${arch}`;
-  if (abi === "musl") {
-    triplet += "-musl";
-  }
-  if (baseline) {
-    triplet += "-baseline";
-  }
-  return triplet;
-}
-
-/**
- * Returns true if a platform needs QEMU-based baseline CPU verification.
- * x64 baseline builds verify no AVX/AVX2 instructions snuck in.
- * aarch64 builds verify no LSE/SVE instructions snuck in.
- * @param {Platform} platform
- * @returns {boolean}
- */
-function needsBaselineVerification(platform) {
-  const { os, arch, baseline } = platform;
-  if (os !== "linux") return false;
-  return (arch === "x64" && baseline) || arch === "aarch64";
-}
-
-/**
- * @param {Platform} platform
- * @param {PipelineOptions} options
- * @returns {Step}
- */
-function getVerifyBaselineStep(platform, options) {
-  const { arch } = platform;
-  const targetKey = getTargetKey(platform);
-  const archArg = arch === "x64" ? "x64" : "aarch64";
-
-  return {
-    key: `${targetKey}-verify-baseline`,
-    label: `${getTargetLabel(platform)} - verify-baseline`,
-    depends_on: [`${targetKey}-build-bun`],
-    agents: getLinkBunAgent(platform, options),
-    retry: getRetry(),
-    cancel_on_build_failing: isMergeQueue(),
-    timeout_in_minutes: 5,
-    command: [
-      `buildkite-agent artifact download '*.zip' . --step ${targetKey}-build-bun`,
-      `unzip -o '${getTargetTriplet(platform)}.zip'`,
-      `unzip -o '${getTargetTriplet(platform)}-profile.zip'`,
-      `chmod +x ${getTargetTriplet(platform)}/bun ${getTargetTriplet(platform)}-profile/bun-profile`,
-      `./scripts/verify-baseline-cpu.sh --arch ${archArg} --binary ${getTargetTriplet(platform)}/bun`,
-      `./scripts/verify-baseline-cpu.sh --arch ${archArg} --binary ${getTargetTriplet(platform)}-profile/bun-profile`,
-    ],
-  };
-}
-
-/**
- * Returns true if the PR modifies SetupWebKit.cmake (WebKit version changes).
- * JIT stress tests under QEMU should run when WebKit is updated to catch
- * JIT-generated code that uses unsupported CPU instructions.
- * @param {PipelineOptions} options
- * @returns {boolean}
- */
-function hasWebKitChanges(options) {
-  const { changedFiles = [] } = options;
-  return changedFiles.some(file => file.includes("SetupWebKit.cmake"));
-}
-
-/**
- * Returns a step that runs JSC JIT stress tests under QEMU.
- * This verifies that JIT-compiled code doesn't use CPU instructions
- * beyond the baseline target (no AVX on x64, no LSE on aarch64).
- * @param {Platform} platform
- * @param {PipelineOptions} options
- * @returns {Step}
- */
-function getJitStressTestStep(platform, options) {
-  const { arch } = platform;
-  const targetKey = getTargetKey(platform);
-  const archArg = arch === "x64" ? "x64" : "aarch64";
-
-  return {
-    key: `${targetKey}-jit-stress-qemu`,
-    label: `${getTargetLabel(platform)} - jit-stress-qemu`,
-    depends_on: [`${targetKey}-build-bun`],
-    agents: getLinkBunAgent(platform, options),
-    retry: getRetry(),
-    cancel_on_build_failing: isMergeQueue(),
-    // JIT stress tests are slow under QEMU emulation
-    timeout_in_minutes: 30,
-    command: [
-      `buildkite-agent artifact download '*.zip' . --step ${targetKey}-build-bun`,
-      `unzip -o '${getTargetTriplet(platform)}.zip'`,
-      `chmod +x ${getTargetTriplet(platform)}/bun`,
-      `./scripts/verify-jit-stress-qemu.sh --arch ${archArg} --binary ${getTargetTriplet(platform)}/bun`,
-    ],
-  };
-}
-
 /**
  * @param {Platform} platform
  * @param {PipelineOptions} options
@@ -678,7 +575,6 @@ function getTestBunStep(platform, options, testOptions = {}) {
   if (buildId) {
     args.push(`--build-id=${buildId}`);
   }
-
   if (testFiles) {
     args.push(...testFiles.map(testFile => `--include=${testFile}`));
   }
@@ -695,7 +591,7 @@ function getTestBunStep(platform, options, testOptions = {}) {
     agents: getTestAgent(platform, options),
     retry: getRetry(),
     cancel_on_build_failing: isMergeQueue(),
-    parallelism: os === "darwin" ? 2 : 20,
+    parallelism: os === "darwin" ? 2 : 10,
     timeout_in_minutes: profile === "asan" || os === "windows" ? 45 : 30,
     env: {
       ASAN_OPTIONS: "allow_user_segv_handler=1:disable_coredump=0:detect_leaks=0",
@@ -764,7 +660,7 @@ function getReleaseStep(buildPlatforms, options) {
     agents: {
       queue: "test-darwin",
     },
-    depends_on: buildPlatforms.map(platform => `${getTargetKey(platform)}-build-bun`),
+    depends_on: buildPlatforms.filter(p => p.os !== "freebsd").map(platform => `${getTargetKey(platform)}-build-bun`),
     env: {
       CANARY: revision,
     },
@@ -877,7 +773,6 @@ function getBenchmarkStep() {
  * @property {Platform[]} [buildPlatforms]
  * @property {Platform[]} [testPlatforms]
  * @property {string[]} [testFiles]
- * @property {string[]} [changedFiles]
  */
 
 /**
@@ -1216,6 +1111,9 @@ async function getPipeline(options = {}) {
       ? buildPlatforms
       : buildPlatforms.filter(({ profile }) => profile !== "asan");
 
+    // run build-image but no build-bun yet
+    relevantBuildPlatforms = relevantBuildPlatforms.filter(({ os }) => os !== "freebsd");
+
     steps.push(
       ...relevantBuildPlatforms.map(target => {
         const imageKey = getImageKey(target);
@@ -1230,14 +1128,6 @@ async function getPipeline(options = {}) {
         steps.push(getBuildZigStep(target, options));
         steps.push(getLinkBunStep(target, options));
 
-        if (needsBaselineVerification(target)) {
-          steps.push(getVerifyBaselineStep(target, options));
-          // Run JIT stress tests under QEMU when WebKit is updated
-          if (hasWebKitChanges(options)) {
-            steps.push(getJitStressTestStep(target, options));
-          }
-        }
-
         return getStepWithDependsOn(
           {
             key: getTargetKey(target),
@@ -1335,7 +1225,6 @@ async function main() {
       console.log(`- PR is only docs, skipping tests!`);
       return;
     }
-    options.changedFiles = allFiles;
   }
 
   startGroup("Generating pipeline...");

.buildkite/scripts/sign-windows.ps1

@@ -36,20 +36,16 @@ function Log-Debug {
     }
 }
 
-# Detect system architecture
-$script:IsARM64 = [System.Runtime.InteropServices.RuntimeInformation]::OSArchitecture -eq [System.Runtime.InteropServices.Architecture]::Arm64
-$script:VsArch = if ($script:IsARM64) { "arm64" } else { "amd64" }
-
 # Load Visual Studio environment if not already loaded
 function Ensure-VSEnvironment {
     if ($null -eq $env:VSINSTALLDIR) {
-        Log-Info "Loading Visual Studio environment for $script:VsArch..."
-
+        Log-Info "Loading Visual Studio environment..."
+        
         $vswhere = "C:\Program Files (x86)\Microsoft Visual Studio\Installer\vswhere.exe"
         if (!(Test-Path $vswhere)) {
             throw "Command not found: vswhere (did you install Visual Studio?)"
         }
-
+        
         $vsDir = & $vswhere -prerelease -latest -property installationPath
         if ($null -eq $vsDir) {
             $vsDir = Get-ChildItem -Path "C:\Program Files\Microsoft Visual Studio\2022" -Directory -ErrorAction SilentlyContinue
@@ -58,20 +54,20 @@ function Ensure-VSEnvironment {
             }
             $vsDir = $vsDir.FullName
         }
-
+        
         Push-Location $vsDir
         try {
             $vsShell = Join-Path -Path $vsDir -ChildPath "Common7\Tools\Launch-VsDevShell.ps1"
-            . $vsShell -Arch $script:VsArch -HostArch $script:VsArch
+            . $vsShell -Arch amd64 -HostArch amd64
         } finally {
             Pop-Location
         }
-
+        
         Log-Success "Visual Studio environment loaded"
     }
-
+    
     if ($env:VSCMD_ARG_TGT_ARCH -eq "x86") {
-        throw "Visual Studio environment is targeting 32 bit x86, but only 64-bit architectures (x64/arm64) are supported."
+        throw "Visual Studio environment is targeting 32 bit, but only 64 bit is supported."
     }
 }
 
@@ -190,10 +186,8 @@ function Install-KeyLocker {
     }
     
     # Download MSI installer
-    # Note: KeyLocker tools currently only available for x64, but works on ARM64 via emulation
-    $msiArch = "x64"
-    $msiUrl = "https://bun-ci-assets.bun.sh/Keylockertools-windows-${msiArch}.msi"
-    $msiPath = Join-Path $env:TEMP "Keylockertools-windows-${msiArch}.msi"
+    $msiUrl = "https://bun-ci-assets.bun.sh/Keylockertools-windows-x64.msi"
+    $msiPath = Join-Path $env:TEMP "Keylockertools-windows-x64.msi"
     
     Log-Info "Downloading MSI from: $msiUrl"
     Log-Info "Downloading to: $msiPath"

.buildkite/scripts/upload-release.sh

@@ -219,9 +219,6 @@ function create_release() {
     bun-windows-x64-profile.zip
     bun-windows-x64-baseline.zip
     bun-windows-x64-baseline-profile.zip
-    # TODO: Enable when Windows ARM64 CI runners are ready
-    # bun-windows-aarch64.zip
-    # bun-windows-aarch64-profile.zip
   )
 
   function upload_artifact() {

.claude/commands/upgrade-webkit.md

@@ -6,7 +6,8 @@ To do that:
 - git fetch upstream
 - git merge upstream main
 - Fix the merge conflicts
-- bun build.ts debug
+- cd ../../ (back to bun)
+- make jsc-build (this will take about 7 minutes)
 - While it compiles, in another task review the JSC commits between the last version of Webkit and the new version. Write up a summary of the webkit changes in a file called "webkit-changes.md"
 - bun run build:local (build a build of Bun with the new Webkit, make sure it compiles)
 - After making sure it compiles, run some code to make sure things work. something like ./build/debug-local/bun-debug --print '42' should be all you need
@@ -20,7 +21,3 @@ To do that:
 - commit + push (without adding the webkit-changes.md file)
 - create PR titled "Upgrade Webkit to the <commit-sha>", paste your webkit-changes.md into the PR description
 - delete the webkit-changes.md file
-
-Things to check for a successful upgrade:
-- Did JSType in vendor/WebKit/Source/JavaScriptCore have any recent changes? Does the enum values align with whats present in src/bun.js/bindings/JSType.zig?
-- Were there any changes to the webcore code generator? If there are C++ compilation errors, check for differences in some of the generated code in like vendor/WebKit/source/WebCore/bindings/scripts/test/JS/

.claude/skills/implementing-jsc-classes-cpp/SKILL.md

@@ -1,184 +0,0 @@
----
-name: implementing-jsc-classes-cpp
-description: Implements JavaScript classes in C++ using JavaScriptCore. Use when creating new JS classes with C++ bindings, prototypes, or constructors.
----
-
-# Implementing JavaScript Classes in C++
-
-## Class Structure
-
-For publicly accessible Constructor and Prototype, create 3 classes:
-
-1. **`class Foo : public JSC::DestructibleObject`** - if C++ fields exist; otherwise use `JSC::constructEmptyObject` with `putDirectOffset`
-2. **`class FooPrototype : public JSC::JSNonFinalObject`**
-3. **`class FooConstructor : public JSC::InternalFunction`**
-
-No public constructor? Only Prototype and class needed.
-
-## Iso Subspaces
-
-Classes with C++ fields need subspaces in:
-
-- `src/bun.js/bindings/webcore/DOMClientIsoSubspaces.h`
-- `src/bun.js/bindings/webcore/DOMIsoSubspaces.h`
-
-```cpp
-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_clientSubspaceForMyClassT.get(); },
-        [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForMyClassT = std::forward<decltype(space)>(space); },
-        [](auto& spaces) { return spaces.m_subspaceForMyClassT.get(); },
-        [](auto& spaces, auto&& space) { spaces.m_subspaceForMyClassT = std::forward<decltype(space)>(space); });
-}
-```
-
-## Property Definitions
-
-```cpp
-static JSC_DECLARE_HOST_FUNCTION(jsFooProtoFuncMethod);
-static JSC_DECLARE_CUSTOM_GETTER(jsFooGetter_property);
-
-static const HashTableValue JSFooPrototypeTableValues[] = {
-    { "property"_s, static_cast<unsigned>(PropertyAttribute::ReadOnly | PropertyAttribute::CustomAccessor), NoIntrinsic, { HashTableValue::GetterSetterType, jsFooGetter_property, 0 } },
-    { "method"_s, static_cast<unsigned>(PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, jsFooProtoFuncMethod, 1 } },
-};
-```
-
-## Prototype Class
-
-```cpp
-class JSFooPrototype final : public JSC::JSNonFinalObject {
-public:
-    using Base = JSC::JSNonFinalObject;
-    static constexpr unsigned StructureFlags = Base::StructureFlags;
-
-    static JSFooPrototype* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure) {
-        JSFooPrototype* prototype = new (NotNull, allocateCell<JSFooPrototype>(vm)) JSFooPrototype(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:
-    JSFooPrototype(JSC::VM& vm, JSC::Structure* structure) : Base(vm, structure) {}
-    void finishCreation(JSC::VM& vm);
-};
-
-void JSFooPrototype::finishCreation(VM& vm) {
-    Base::finishCreation(vm);
-    reifyStaticProperties(vm, JSFoo::info(), JSFooPrototypeTableValues, *this);
-    JSC_TO_STRING_TAG_WITHOUT_TRANSITION();
-}
-```
-
-## Getter/Setter/Function Definitions
-
-```cpp
-// Getter
-JSC_DEFINE_CUSTOM_GETTER(jsFooGetter_prop, (JSGlobalObject* globalObject, EncodedJSValue thisValue, PropertyName)) {
-    VM& vm = globalObject->vm();
-    auto scope = DECLARE_THROW_SCOPE(vm);
-    JSFoo* thisObject = jsDynamicCast<JSFoo*>(JSValue::decode(thisValue));
-    if (UNLIKELY(!thisObject)) {
-        Bun::throwThisTypeError(*globalObject, scope, "JSFoo"_s, "prop"_s);
-        return {};
-    }
-    return JSValue::encode(jsBoolean(thisObject->value()));
-}
-
-// Function
-JSC_DEFINE_HOST_FUNCTION(jsFooProtoFuncMethod, (JSGlobalObject* globalObject, CallFrame* callFrame)) {
-    VM& vm = globalObject->vm();
-    auto scope = DECLARE_THROW_SCOPE(vm);
-    auto* thisObject = jsDynamicCast<JSFoo*>(callFrame->thisValue());
-    if (UNLIKELY(!thisObject)) {
-        Bun::throwThisTypeError(*globalObject, scope, "Foo"_s, "method"_s);
-        return {};
-    }
-    return JSValue::encode(thisObject->doSomething(vm, globalObject));
-}
-```
-
-## Constructor Class
-
-```cpp
-class JSFooConstructor final : public JSC::InternalFunction {
-public:
-    using Base = JSC::InternalFunction;
-    static constexpr unsigned StructureFlags = Base::StructureFlags;
-
-    static JSFooConstructor* create(JSC::VM& vm, JSC::Structure* structure, JSC::JSObject* prototype) {
-        JSFooConstructor* constructor = new (NotNull, JSC::allocateCell<JSFooConstructor>(vm)) JSFooConstructor(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:
-    JSFooConstructor(JSC::VM& vm, JSC::Structure* structure) : Base(vm, structure, callFoo, constructFoo) {}
-
-    void finishCreation(JSC::VM& vm, JSC::JSObject* prototype) {
-        Base::finishCreation(vm, 0, "Foo"_s);
-        putDirectWithoutTransition(vm, vm.propertyNames->prototype, prototype, JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::DontDelete | JSC::PropertyAttribute::ReadOnly);
-    }
-};
-```
-
-## Structure Caching
-
-Add to `ZigGlobalObject.h`:
-
-```cpp
-JSC::LazyClassStructure m_JSFooClassStructure;
-```
-
-Initialize in `ZigGlobalObject.cpp`:
-
-```cpp
-m_JSFooClassStructure.initLater([](LazyClassStructure::Initializer& init) {
-    Bun::initJSFooClassStructure(init);
-});
-```
-
-Visit in `visitChildrenImpl`:
-
-```cpp
-m_JSFooClassStructure.visit(visitor);
-```
-
-## Expose to Zig
-
-```cpp
-extern "C" JSC::EncodedJSValue Bun__JSFooConstructor(Zig::GlobalObject* globalObject) {
-    return JSValue::encode(globalObject->m_JSFooClassStructure.constructor(globalObject));
-}
-
-extern "C" EncodedJSValue Bun__Foo__toJS(Zig::GlobalObject* globalObject, Foo* foo) {
-    auto* structure = globalObject->m_JSFooClassStructure.get(globalObject);
-    return JSValue::encode(JSFoo::create(globalObject->vm(), structure, globalObject, WTFMove(foo)));
-}
-```
-
-Include `#include "root.h"` at the top of C++ files.

.claude/skills/implementing-jsc-classes-zig/SKILL.md

@@ -1,206 +0,0 @@
----
-name: implementing-jsc-classes-zig
-description: Creates JavaScript classes using Bun's Zig bindings generator (.classes.ts). Use when implementing new JS APIs in Zig with JSC integration.
----
-
-# Bun's JavaScriptCore Class Bindings Generator
-
-Bridge JavaScript and Zig through `.classes.ts` definitions and Zig implementations.
-
-## Architecture
-
-1. **Zig Implementation** (.zig files)
-2. **JavaScript Interface Definition** (.classes.ts files)
-3. **Generated Code** (C++/Zig files connecting them)
-
-## Class Definition (.classes.ts)
-
-```typescript
-define({
-  name: "TextDecoder",
-  constructor: true,
-  JSType: "object",
-  finalize: true,
-  proto: {
-    decode: { args: 1 },
-    encoding: { getter: true, cache: true },
-    fatal: { getter: true },
-  },
-});
-```
-
-Options:
-
-- `name`: Class name
-- `constructor`: Has public constructor
-- `JSType`: "object", "function", etc.
-- `finalize`: Needs cleanup
-- `proto`: Properties/methods
-- `cache`: Cache property values via WriteBarrier
-
-## Zig Implementation
-
-```zig
-pub const TextDecoder = struct {
-    pub const js = JSC.Codegen.JSTextDecoder;
-    pub const toJS = js.toJS;
-    pub const fromJS = js.fromJS;
-    pub const fromJSDirect = js.fromJSDirect;
-
-    encoding: []const u8,
-    fatal: bool,
-
-    pub fn constructor(
-        globalObject: *JSGlobalObject,
-        callFrame: *JSC.CallFrame,
-    ) bun.JSError!*TextDecoder {
-        return bun.new(TextDecoder, .{ .encoding = "utf-8", .fatal = false });
-    }
-
-    pub fn decode(
-        this: *TextDecoder,
-        globalObject: *JSGlobalObject,
-        callFrame: *JSC.CallFrame,
-    ) bun.JSError!JSC.JSValue {
-        const args = callFrame.arguments();
-        if (args.len < 1 or args.ptr[0].isUndefinedOrNull()) {
-            return globalObject.throw("Input cannot be null", .{});
-        }
-        return JSC.JSValue.jsString(globalObject, "result");
-    }
-
-    pub fn getEncoding(this: *TextDecoder, globalObject: *JSGlobalObject) JSC.JSValue {
-        return JSC.JSValue.createStringFromUTF8(globalObject, this.encoding);
-    }
-
-    fn deinit(this: *TextDecoder) void {
-        // Release resources
-    }
-
-    pub fn finalize(this: *TextDecoder) void {
-        this.deinit();
-        bun.destroy(this);
-    }
-};
-```
-
-**Key patterns:**
-
-- Use `bun.JSError!JSValue` return type for error handling
-- Use `globalObject` not `ctx`
-- `deinit()` for cleanup, `finalize()` called by GC
-- Update `src/bun.js/bindings/generated_classes_list.zig`
-
-## CallFrame Access
-
-```zig
-const args = callFrame.arguments();
-const first_arg = args.ptr[0];  // Access as slice
-const argCount = args.len;
-const thisValue = callFrame.thisValue();
-```
-
-## Property Caching
-
-For `cache: true` properties, generated accessors:
-
-```zig
-// Get cached value
-pub fn encodingGetCached(thisValue: JSC.JSValue) ?JSC.JSValue {
-    const result = TextDecoderPrototype__encodingGetCachedValue(thisValue);
-    if (result == .zero) return null;
-    return result;
-}
-
-// Set cached value
-pub fn encodingSetCached(thisValue: JSC.JSValue, globalObject: *JSC.JSGlobalObject, value: JSC.JSValue) void {
-    TextDecoderPrototype__encodingSetCachedValue(thisValue, globalObject, value);
-}
-```
-
-## Error Handling
-
-```zig
-pub fn method(this: *MyClass, globalObject: *JSGlobalObject, callFrame: *JSC.CallFrame) bun.JSError!JSC.JSValue {
-    const args = callFrame.arguments();
-    if (args.len < 1) {
-        return globalObject.throw("Missing required argument", .{});
-    }
-    return JSC.JSValue.jsString(globalObject, "Success!");
-}
-```
-
-## Memory Management
-
-```zig
-pub fn deinit(this: *TextDecoder) void {
-    this._encoding.deref();
-    if (this.buffer) |buffer| {
-        bun.default_allocator.free(buffer);
-    }
-}
-
-pub fn finalize(this: *TextDecoder) void {
-    JSC.markBinding(@src());
-    this.deinit();
-    bun.default_allocator.destroy(this);
-}
-```
-
-## Creating a New Binding
-
-1. Define interface in `.classes.ts`:
-
-```typescript
-define({
-  name: "MyClass",
-  constructor: true,
-  finalize: true,
-  proto: {
-    myMethod: { args: 1 },
-    myProperty: { getter: true, cache: true },
-  },
-});
-```
-
-2. Implement in `.zig`:
-
-```zig
-pub const MyClass = struct {
-    pub const js = JSC.Codegen.JSMyClass;
-    pub const toJS = js.toJS;
-    pub const fromJS = js.fromJS;
-
-    value: []const u8,
-
-    pub const new = bun.TrivialNew(@This());
-
-    pub fn constructor(globalObject: *JSGlobalObject, callFrame: *JSC.CallFrame) bun.JSError!*MyClass {
-        return MyClass.new(.{ .value = "" });
-    }
-
-    pub fn myMethod(this: *MyClass, globalObject: *JSGlobalObject, callFrame: *JSC.CallFrame) bun.JSError!JSC.JSValue {
-        return JSC.JSValue.jsUndefined();
-    }
-
-    pub fn getMyProperty(this: *MyClass, globalObject: *JSGlobalObject) JSC.JSValue {
-        return JSC.JSValue.jsString(globalObject, this.value);
-    }
-
-    pub fn deinit(this: *MyClass) void {}
-
-    pub fn finalize(this: *MyClass) void {
-        this.deinit();
-        bun.destroy(this);
-    }
-};
-```
-
-3. Add to `src/bun.js/bindings/generated_classes_list.zig`
-
-## Generated Components
-
-- **C++ Classes**: `JSMyClass`, `JSMyClassPrototype`, `JSMyClassConstructor`
-- **Method Bindings**: `MyClassPrototype__myMethodCallback`
-- **Property Accessors**: `MyClassPrototype__myPropertyGetterWrap`
-- **Zig Bindings**: External function declarations, cached value accessors

.claude/skills/writing-bundler-tests/SKILL.md

@@ -1,222 +0,0 @@
----
-name: writing-bundler-tests
-description: Guides writing bundler tests using itBundled/expectBundled in test/bundler/. Use when creating or modifying bundler, transpiler, or code transformation tests.
----
-
-# Writing Bundler Tests
-
-Bundler tests use `itBundled()` from `test/bundler/expectBundled.ts` to test Bun's bundler.
-
-## Basic Usage
-
-```typescript
-import { describe } from "bun:test";
-import { itBundled, dedent } from "./expectBundled";
-
-describe("bundler", () => {
-  itBundled("category/TestName", {
-    files: {
-      "index.js": `console.log("hello");`,
-    },
-    run: {
-      stdout: "hello",
-    },
-  });
-});
-```
-
-Test ID format: `category/TestName` (e.g., `banner/CommentBanner`, `minify/Empty`)
-
-## File Setup
-
-```typescript
-{
-  files: {
-    "index.js": `console.log("test");`,
-    "lib.ts": `export const foo = 123;`,
-    "nested/file.js": `export default {};`,
-  },
-  entryPoints: ["index.js"],  // defaults to first file
-  runtimeFiles: {             // written AFTER bundling
-    "extra.js": `console.log("added later");`,
-  },
-}
-```
-
-## Bundler Options
-
-```typescript
-{
-  outfile: "/out.js",
-  outdir: "/out",
-  format: "esm" | "cjs" | "iife",
-  target: "bun" | "browser" | "node",
-
-  // Minification
-  minifyWhitespace: true,
-  minifyIdentifiers: true,
-  minifySyntax: true,
-
-  // Code manipulation
-  banner: "// copyright",
-  footer: "// end",
-  define: { "PROD": "true" },
-  external: ["lodash"],
-
-  // Advanced
-  sourceMap: "inline" | "external",
-  splitting: true,
-  treeShaking: true,
-  drop: ["console"],
-}
-```
-
-## Runtime Verification
-
-```typescript
-{
-  run: {
-    stdout: "expected output",      // exact match
-    stdout: /regex/,                // pattern match
-    partialStdout: "contains this", // substring
-    stderr: "error output",
-    exitCode: 1,
-    env: { NODE_ENV: "production" },
-    runtime: "bun" | "node",
-
-    // Runtime errors
-    error: "ReferenceError: x is not defined",
-  },
-}
-```
-
-## Bundle Errors/Warnings
-
-```typescript
-{
-  bundleErrors: {
-    "/file.js": ["error message 1", "error message 2"],
-  },
-  bundleWarnings: {
-    "/file.js": ["warning message"],
-  },
-}
-```
-
-## Dead Code Elimination (DCE)
-
-Add markers in source code:
-
-```javascript
-// KEEP - this should survive
-const used = 1;
-
-// REMOVE - this should be eliminated
-const unused = 2;
-```
-
-```typescript
-{
-  dce: true,
-  dceKeepMarkerCount: 5,  // expected KEEP markers
-}
-```
-
-## Capture Pattern
-
-Verify exact transpilation with `capture()`:
-
-```typescript
-itBundled("string/Folding", {
-  files: {
-    "index.ts": `capture(\`\${1 + 1}\`);`,
-  },
-  capture: ['"2"'], // expected captured value
-  minifySyntax: true,
-});
-```
-
-## Post-Bundle Assertions
-
-```typescript
-{
-  onAfterBundle(api) {
-    api.expectFile("out.js").toContain("console.log");
-    api.assertFileExists("out.js");
-
-    const content = api.readFile("out.js");
-    expect(content).toMatchSnapshot();
-
-    const values = api.captureFile("out.js");
-    expect(values).toEqual(["2"]);
-  },
-}
-```
-
-## Common Patterns
-
-**Simple output verification:**
-
-```typescript
-itBundled("banner/Comment", {
-  banner: "// copyright",
-  files: { "a.js": `console.log("Hello")` },
-  onAfterBundle(api) {
-    api.expectFile("out.js").toContain("// copyright");
-  },
-});
-```
-
-**Multi-file CJS/ESM interop:**
-
-```typescript
-itBundled("cjs/ImportSyntax", {
-  files: {
-    "entry.js": `import lib from './lib.cjs'; console.log(lib);`,
-    "lib.cjs": `exports.foo = 'bar';`,
-  },
-  run: { stdout: '{"foo":"bar"}' },
-});
-```
-
-**Error handling:**
-
-```typescript
-itBundled("edgecase/InvalidLoader", {
-  files: { "index.js": `...` },
-  bundleErrors: {
-    "index.js": ["Unsupported loader type"],
-  },
-});
-```
-
-## Test Organization
-
-```text
-test/bundler/
-├── bundler_banner.test.ts
-├── bundler_string.test.ts
-├── bundler_minify.test.ts
-├── bundler_cjs.test.ts
-├── bundler_edgecase.test.ts
-├── bundler_splitting.test.ts
-├── css/
-├── transpiler/
-└── expectBundled.ts
-```
-
-## Running Tests
-
-```bash
-bun bd test test/bundler/bundler_banner.test.ts
-BUN_BUNDLER_TEST_FILTER="banner/Comment" bun bd test bundler_banner.test.ts
-BUN_BUNDLER_TEST_DEBUG=1 bun bd test bundler_minify.test.ts
-```
-
-## Key Points
-
-- Use `dedent` for readable multi-line code
-- File paths are relative (e.g., `/index.js`)
-- Use `capture()` to verify exact transpilation results
-- Use `.toMatchSnapshot()` for complex outputs
-- Pass array to `run` for multiple test scenarios

.claude/skills/writing-dev-server-tests/SKILL.md

@@ -1,94 +0,0 @@
----
-name: writing-dev-server-tests
-description: Guides writing HMR/Dev Server tests in test/bake/. Use when creating or modifying dev server, hot reloading, or bundling tests.
----
-
-# Writing HMR/Dev Server Tests
-
-Dev server tests validate hot-reloading robustness and reliability.
-
-## File Structure
-
-- `test/bake/bake-harness.ts` - shared utilities: `devTest`, `prodTest`, `devAndProductionTest`, `Dev` class, `Client` class
-- `test/bake/client-fixture.mjs` - subprocess for `Client` (page loading, IPC queries)
-- `test/bake/dev/*.test.ts` - dev server and hot reload tests
-- `test/bake/dev-and-prod.ts` - tests running on both dev and production mode
-
-## Test Categories
-
-- `bundle.test.ts` - DevServer-specific bundling bugs
-- `css.test.ts` - CSS bundling issues
-- `plugins.test.ts` - development mode plugins
-- `ecosystem.test.ts` - library compatibility (prefer concrete bugs over full package tests)
-- `esm.test.ts` - ESM features in development
-- `html.test.ts` - HTML file handling
-- `react-spa.test.ts` - React, react-refresh transform, server components
-- `sourcemap.test.ts` - source map correctness
-
-## devTest Basics
-
-```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.patch("index.html", { find: "Hello", replace: "World" });
-    await dev.fetch("/").expect.toInclude("<h1>World</h1>");
-
-    await using c = await dev.client("/");
-    await c.expectMessage("hello");
-
-    await c.expectReload(async () => {
-      await dev.patch("index.html", { find: "World", replace: "Bar" });
-    });
-    await c.expectMessage("hello");
-  },
-});
-```
-
-## Key APIs
-
-- **`files`**: Initial filesystem state
-- **`dev.fetch()`**: HTTP requests
-- **`dev.client()`**: Opens browser instance
-- **`dev.write/patch/delete`**: Filesystem mutations (wait for hot-reload automatically)
-- **`c.expectMessage()`**: Assert console.log output
-- **`c.expectReload()`**: Wrap code that causes hard reload
-
-**Important**: Use `dev.write/patch/delete` instead of `node:fs` - they wait for hot-reload.
-
-## Testing Errors
-
-```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");
-  },
-});
-```
-
-Specify expected errors with the `errors` option:
-
-```ts
-await dev.delete("other.ts", {
-  errors: ['index.ts:1:16: error: Could not resolve: "./other"'],
-});
-```

.claude/skills/zig-system-calls/SKILL.md

@@ -1,268 +0,0 @@
----
-name: zig-system-calls
-description: Guides using bun.sys for system calls and file I/O in Zig. Use when implementing file operations instead of std.fs or std.posix.
----
-
-# System Calls & File I/O in Zig
-
-Use `bun.sys` instead of `std.fs` or `std.posix` for cross-platform syscalls with proper error handling.
-
-## bun.sys.File (Preferred)
-
-For most file operations, use the `bun.sys.File` wrapper:
-
-```zig
-const File = bun.sys.File;
-
-const file = switch (File.open(path, bun.O.RDWR, 0o644)) {
-    .result => |f| f,
-    .err => |err| return .{ .err = err },
-};
-defer file.close();
-
-// Read/write
-_ = try file.read(buffer).unwrap();
-_ = try file.writeAll(data).unwrap();
-
-// Get file info
-const stat = try file.stat().unwrap();
-const size = try file.getEndPos().unwrap();
-
-// std.io compatible
-const reader = file.reader();
-const writer = file.writer();
-```
-
-### Complete Example
-
-```zig
-const File = bun.sys.File;
-
-pub fn writeFile(path: [:0]const u8, data: []const u8) File.WriteError!void {
-    const file = switch (File.open(path, bun.O.WRONLY | bun.O.CREAT | bun.O.TRUNC, 0o664)) {
-        .result => |f| f,
-        .err => |err| return err.toError(),
-    };
-    defer file.close();
-
-    _ = switch (file.writeAll(data)) {
-        .result => {},
-        .err => |err| return err.toError(),
-    };
-}
-```
-
-## Why bun.sys?
-
-| Aspect      | bun.sys                          | std.fs/std.posix    |
-| ----------- | -------------------------------- | ------------------- |
-| Return Type | `Maybe(T)` with detailed Error   | Generic error union |
-| Windows     | Full support with libuv fallback | Limited/POSIX-only  |
-| Error Info  | errno, syscall tag, path, fd     | errno only          |
-| EINTR       | Automatic retry                  | Manual handling     |
-
-## Error Handling with Maybe(T)
-
-`bun.sys` functions return `Maybe(T)` - a tagged union:
-
-```zig
-const sys = bun.sys;
-
-// Pattern 1: Switch on result/error
-switch (sys.read(fd, buffer)) {
-    .result => |bytes_read| {
-        // use bytes_read
-    },
-    .err => |err| {
-        // err.errno, err.syscall, err.fd, err.path
-        if (err.getErrno() == .AGAIN) {
-            // handle EAGAIN
-        }
-    },
-}
-
-// Pattern 2: Unwrap with try (converts to Zig error)
-const bytes = try sys.read(fd, buffer).unwrap();
-
-// Pattern 3: Unwrap with default
-const value = sys.stat(path).unwrapOr(default_stat);
-```
-
-## Low-Level File Operations
-
-Only use these when `bun.sys.File` doesn't meet your needs.
-
-### Opening Files
-
-```zig
-const sys = bun.sys;
-
-// Use bun.O flags (cross-platform normalized)
-const fd = switch (sys.open(path, bun.O.RDONLY, 0)) {
-    .result => |fd| fd,
-    .err => |err| return .{ .err = err },
-};
-defer fd.close();
-
-// Common flags
-bun.O.RDONLY, bun.O.WRONLY, bun.O.RDWR
-bun.O.CREAT, bun.O.TRUNC, bun.O.APPEND
-bun.O.NONBLOCK, bun.O.DIRECTORY
-```
-
-### Reading & Writing
-
-```zig
-// Single read (may return less than buffer size)
-switch (sys.read(fd, buffer)) {
-    .result => |n| { /* n bytes read */ },
-    .err => |err| { /* handle error */ },
-}
-
-// Read until EOF or buffer full
-const total = try sys.readAll(fd, buffer).unwrap();
-
-// Position-based read/write
-sys.pread(fd, buffer, offset)
-sys.pwrite(fd, data, offset)
-
-// Vector I/O
-sys.readv(fd, iovecs)
-sys.writev(fd, iovecs)
-```
-
-### File Info
-
-```zig
-sys.stat(path)      // Follow symlinks
-sys.lstat(path)     // Don't follow symlinks
-sys.fstat(fd)       // From file descriptor
-sys.fstatat(fd, path)
-
-// Linux-only: faster selective stat
-sys.statx(path, &.{ .size, .mtime })
-```
-
-### Path Operations
-
-```zig
-sys.unlink(path)
-sys.unlinkat(dir_fd, path)
-sys.rename(from, to)
-sys.renameat(from_dir, from, to_dir, to)
-sys.readlink(path, buf)
-sys.readlinkat(fd, path, buf)
-sys.link(T, src, dest)
-sys.linkat(src_fd, src, dest_fd, dest)
-sys.symlink(target, dest)
-sys.symlinkat(target, dirfd, dest)
-sys.mkdir(path, mode)
-sys.mkdirat(dir_fd, path, mode)
-sys.rmdir(path)
-```
-
-### Permissions
-
-```zig
-sys.chmod(path, mode)
-sys.fchmod(fd, mode)
-sys.fchmodat(fd, path, mode, flags)
-sys.chown(path, uid, gid)
-sys.fchown(fd, uid, gid)
-```
-
-### Closing File Descriptors
-
-Close is on `bun.FD`:
-
-```zig
-fd.close();  // Asserts on error (use in defer)
-
-// Or if you need error info:
-if (fd.closeAllowingBadFileDescriptor(null)) |err| {
-    // handle error
-}
-```
-
-## Directory Operations
-
-```zig
-var buf: bun.PathBuffer = undefined;
-const cwd = try sys.getcwd(&buf).unwrap();
-const cwdZ = try sys.getcwdZ(&buf).unwrap();  // Zero-terminated
-sys.chdir(path, destination)
-```
-
-### Directory Iteration
-
-Use `bun.DirIterator` instead of `std.fs.Dir.Iterator`:
-
-```zig
-var iter = bun.iterateDir(dir_fd);
-while (true) {
-    switch (iter.next()) {
-        .result => |entry| {
-            if (entry) |e| {
-                const name = e.name.slice();
-                const kind = e.kind;  // .file, .directory, .sym_link, etc.
-            } else {
-                break;  // End of directory
-            }
-        },
-        .err => |err| return .{ .err = err },
-    }
-}
-```
-
-## Socket Operations
-
-**Important**: `bun.sys` has limited socket support. For network I/O:
-
-- **Non-blocking sockets**: Use `uws.Socket` (libuwebsockets) exclusively
-- **Pipes/blocking I/O**: Use `PipeReader.zig` and `PipeWriter.zig`
-
-Available in bun.sys:
-
-```zig
-sys.setsockopt(fd, level, optname, value)
-sys.socketpair(domain, socktype, protocol, nonblocking_status)
-```
-
-Do NOT use `bun.sys` for socket read/write - use `uws.Socket` instead.
-
-## Other Operations
-
-```zig
-sys.ftruncate(fd, size)
-sys.lseek(fd, offset, whence)
-sys.dup(fd)
-sys.dupWithFlags(fd, flags)
-sys.fcntl(fd, cmd, arg)
-sys.pipe()
-sys.mmap(...)
-sys.munmap(memory)
-sys.access(path, mode)
-sys.futimens(fd, atime, mtime)
-sys.utimens(path, atime, mtime)
-```
-
-## Error Type
-
-```zig
-const err: bun.sys.Error = ...;
-err.errno      // Raw errno value
-err.getErrno() // As std.posix.E enum
-err.syscall    // Which syscall failed (Tag enum)
-err.fd         // Optional: file descriptor
-err.path       // Optional: path string
-```
-
-## Key Points
-
-- Prefer `bun.sys.File` wrapper for most file operations
-- Use low-level `bun.sys` functions only when needed
-- Use `bun.O.*` flags instead of `std.os.O.*`
-- Handle `Maybe(T)` with switch or `.unwrap()`
-- Use `defer fd.close()` for cleanup
-- EINTR is handled automatically in most functions
-- For sockets, use `uws.Socket` not `bun.sys`

.coderabbit.yaml

@@ -1,9 +1,5 @@
 language: en-US
 
-issue_enrichment:
-  auto_enrich:
-    enabled: false
-
 reviews:
   profile: assertive
   request_changes_workflow: false

.cursor/rules/building-bun.mdc

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

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

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

.cursor/rules/javascriptcore-class.mdc

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

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

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

.cursor/rules/writing-tests.mdc

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

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

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

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

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

.github/workflows/update-cares.yml

@@ -88,7 +88,7 @@ jobs:
           commit-message: "deps: update c-ares to ${{ steps.check-version.outputs.tag }} (${{ steps.check-version.outputs.latest }})"
           title: "deps: update c-ares to ${{ steps.check-version.outputs.tag }}"
           delete-branch: true
-          branch: deps/update-cares
+          branch: deps/update-cares-${{ github.run_number }}
           body: |
             ## What does this PR do?
 

.github/workflows/update-hdrhistogram.yml

@@ -91,7 +91,7 @@ jobs:
           commit-message: "deps: update hdrhistogram to ${{ steps.check-version.outputs.tag }} (${{ steps.check-version.outputs.latest }})"
           title: "deps: update hdrhistogram to ${{ steps.check-version.outputs.tag }}"
           delete-branch: true
-          branch: deps/update-hdrhistogram
+          branch: deps/update-hdrhistogram-${{ github.run_number }}
           body: |
             ## What does this PR do?
 

.github/workflows/update-highway.yml

@@ -107,7 +107,7 @@ jobs:
           commit-message: "deps: update highway to ${{ steps.check-version.outputs.tag }} (${{ steps.check-version.outputs.latest }})"
           title: "deps: update highway to ${{ steps.check-version.outputs.tag }}"
           delete-branch: true
-          branch: deps/update-highway
+          branch: deps/update-highway-${{ github.run_number }}
           body: |
             ## What does this PR do?
 

.github/workflows/update-libarchive.yml

@@ -88,7 +88,7 @@ jobs:
           commit-message: "deps: update libarchive to ${{ steps.check-version.outputs.tag }} (${{ steps.check-version.outputs.latest }})"
           title: "deps: update libarchive to ${{ steps.check-version.outputs.tag }}"
           delete-branch: true
-          branch: deps/update-libarchive
+          branch: deps/update-libarchive-${{ github.run_number }}
           body: |
             ## What does this PR do?
 

.github/workflows/update-libdeflate.yml

@@ -88,7 +88,7 @@ jobs:
           commit-message: "deps: update libdeflate to ${{ steps.check-version.outputs.tag }} (${{ steps.check-version.outputs.latest }})"
           title: "deps: update libdeflate to ${{ steps.check-version.outputs.tag }}"
           delete-branch: true
-          branch: deps/update-libdeflate
+          branch: deps/update-libdeflate-${{ github.run_number }}
           body: |
             ## What does this PR do?
 

.github/workflows/update-lolhtml.yml

@@ -100,7 +100,7 @@ jobs:
           commit-message: "deps: update lolhtml to ${{ steps.check-version.outputs.tag }} (${{ steps.check-version.outputs.latest }})"
           title: "deps: update lolhtml to ${{ steps.check-version.outputs.tag }}"
           delete-branch: true
-          branch: deps/update-lolhtml
+          branch: deps/update-lolhtml-${{ github.run_number }}
           body: |
             ## What does this PR do?
 

.github/workflows/update-lshpack.yml

@@ -105,7 +105,7 @@ jobs:
           commit-message: "deps: update lshpack to ${{ steps.check-version.outputs.tag }} (${{ steps.check-version.outputs.latest }})"
           title: "deps: update lshpack to ${{ steps.check-version.outputs.tag }}"
           delete-branch: true
-          branch: deps/update-lshpack
+          branch: deps/update-lshpack-${{ github.run_number }}
           body: |
             ## What does this PR do?
 

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

@@ -74,7 +74,7 @@ jobs:
             ```
             ${{ env.changed_files }}
             ```
-          branch: certs/update-root-certs
+          branch: certs/update-root-certs-${{ github.run_number }}
           base: main
           delete-branch: true
           labels:

.github/workflows/update-sqlite3.yml

@@ -83,7 +83,7 @@ jobs:
           commit-message: "deps: update sqlite to ${{ steps.check-version.outputs.latest }}"
           title: "deps: update sqlite to ${{ steps.check-version.outputs.latest }}"
           delete-branch: true
-          branch: deps/update-sqlite
+          branch: deps/update-sqlite-${{ steps.check-version.outputs.latest }}
           body: |
             ## What does this PR do?
 

.github/workflows/update-vendor.yml

@@ -68,7 +68,7 @@ jobs:
           commit-message: "deps: update ${{ matrix.package }} to ${{ steps.check-version.outputs.latest }} (${{ steps.check-version.outputs.latest }})"
           title: "deps: update ${{ matrix.package }} to ${{ steps.check-version.outputs.latest }}"
           delete-branch: true
-          branch: deps/update-${{ matrix.package }}
+          branch: deps/update-${{ matrix.package }}-${{ github.run_number }}
           body: |
             ## What does this PR do?
 

.github/workflows/update-zstd.yml

@@ -88,7 +88,7 @@ jobs:
           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
+          branch: deps/update-zstd-${{ github.run_number }}
           body: |
             ## What does this PR do?
 

.gitignore

@@ -1,5 +1,4 @@
 .claude/settings.local.json
-.direnv
 .DS_Store
 .env
 .envrc
@@ -10,7 +9,6 @@
 .ninja_deps
 .ninja_log
 .npm
-.npmrc
 .npm.gz
 .parcel-cache
 .swcrc

CLAUDE.md

@@ -6,12 +6,10 @@ This is the Bun repository - an all-in-one JavaScript runtime & toolkit designed
 
 - **Build Bun**: `bun bd`
   - Creates a debug build at `./build/debug/bun-debug`
-  - **CRITICAL**: do not set a timeout when running `bun bd`
+  - **CRITICAL**: no need for a timeout, the build is really fast!
 - **Run tests with your debug build**: `bun bd test <test-file>`
   - **CRITICAL**: Never use `bun test` directly - it won't include your changes
 - **Run any command with debug build**: `bun bd <command>`
-- **Run with JavaScript exception scope verification**: `BUN_JSC_validateExceptionChecks=1
-BUN_JSC_dumpSimulatedThrows=1 bun bd <command>`
 
 Tip: Bun is already installed and in $PATH. The `bd` subcommand is a package.json script.
 
@@ -96,7 +94,7 @@ test("(multi-file test) my feature", async () => {
 
 - Always use `port: 0`. Do not hardcode ports. Do not use your own random port number function.
 - Use `normalizeBunSnapshot` to normalize snapshot output of the test.
-- NEVER write tests that check for no "panic" or "uncaught exception" or similar in the test output. These tests will never fail in CI.
+- NEVER write tests that check for no "panic" or "uncaught exception" or similar in the test output. That is NOT a valid test.
 - Use `tempDir` from `"harness"` to create a temporary directory. **Do not** use `tmpdirSync` or `fs.mkdtempSync` to create temporary directories.
 - When spawning processes, tests should expect(stdout).toBe(...) BEFORE expect(exitCode).toBe(0). This gives you a more useful error message on test failure.
 - **CRITICAL**: Do not write flaky tests. Do not use `setTimeout` in tests. Instead, `await` the condition to be met. You are not testing the TIME PASSING, you are testing the CONDITION.
@@ -211,24 +209,3 @@ Built-in JavaScript modules use special syntax and are organized as:
 12. **Branch names must start with `claude/`** - This is a requirement for the CI to work.
 
 **ONLY** push up changes after running `bun bd test <file>` and ensuring your tests pass.
-
-## Debugging CI Failures
-
-Use `scripts/buildkite-failures.ts` to fetch and analyze CI build failures:
-
-```bash
-# View failures for current branch
-bun run scripts/buildkite-failures.ts
-
-# View failures for a specific build number
-bun run scripts/buildkite-failures.ts 35051
-
-# View failures for a GitHub PR
-bun run scripts/buildkite-failures.ts #26173
-bun run scripts/buildkite-failures.ts https://github.com/oven-sh/bun/pull/26173
-
-# Wait for build to complete (polls every 10s until pass/fail)
-bun run scripts/buildkite-failures.ts --wait
-```
-
-The script fetches logs from BuildKite's public API and saves complete logs to `/tmp/bun-build-{number}-{platform}-{step}.log`. It displays a summary of errors and the file path for each failed job. Use `--wait` to poll continuously until the build completes or fails.

CMakeLists.txt

@@ -47,7 +47,15 @@ include(SetupEsbuild)
 include(SetupZig)
 include(SetupRust)
 
-include(SetupCcache)
+find_program(SCCACHE_PROGRAM sccache)
+if(SCCACHE_PROGRAM AND NOT DEFINED ENV{NO_SCCACHE})
+  include(SetupSccache)
+else()
+  find_program(CCACHE_PROGRAM ccache)
+  if(CCACHE_PROGRAM)
+    include(SetupCcache)
+  endif()
+endif()
 
 # Generate dependency versions header
 include(GenerateDependencyVersions)

CONTRIBUTING.md

@@ -23,7 +23,7 @@ Using your system's package manager, install Bun's dependencies:
 {% codetabs group="os" %}
 
 ```bash#macOS (Homebrew)
-$ brew install automake ccache cmake coreutils gnu-sed go icu4c libiconv libtool ninja pkg-config rust ruby
+$ brew install automake cmake coreutils gnu-sed go icu4c libiconv libtool ninja pkg-config rust ruby sccache
 ```
 
 ```bash#Ubuntu/Debian
@@ -65,28 +65,43 @@ $ brew install bun
 
 {% /codetabs %}
 
-### Optional: Install `ccache`
+### Optional: Install `sccache`
 
-ccache is used to cache compilation artifacts, significantly speeding up builds:
+sccache is used to cache compilation artifacts, significantly speeding up builds. It must be installed with S3 support:
 
 ```bash
 # For macOS
-$ brew install ccache
+$ brew install sccache
 
-# For Ubuntu/Debian
-$ sudo apt install ccache
-
-# For Arch
-$ sudo pacman -S ccache
-
-# For Fedora
-$ sudo dnf install ccache
-
-# For openSUSE
-$ sudo zypper install ccache
+# For Linux. Note that the version in your package manager may not have S3 support.
+$ cargo install sccache --features=s3
 ```
 
-Our build scripts will automatically detect and use `ccache` if available. You can check cache statistics with `ccache --show-stats`.
+This will install `sccache` with S3 support. Our build scripts will automatically detect and use `sccache` with our shared S3 cache. **Note**: Not all versions of `sccache` are compiled with S3 support, hence we recommend installing it via `cargo`.
+
+#### Registering AWS Credentials for `sccache` (Core Developers Only)
+
+Core developers have write access to the shared S3 cache. To enable write access, you must log in with AWS credentials. The easiest way to do this is to use the [`aws` CLI](https://aws.amazon.com/cli/) and invoke [`aws configure` to provide your AWS security info](https://docs.aws.amazon.com/cli/latest/reference/configure/).
+
+The `cmake` scripts should automatically detect your AWS credentials from the environment or the `~/.aws/credentials` file.
+
+<details>
+    <summary>Logging in to the `aws` CLI</summary>
+
+    1. Install the AWS CLI by following [the official guide](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html).
+    2. Log in to your AWS account console. A team member should provide you with your credentials.
+    3. Click your name in the top right > Security credentials.
+    4. Scroll to "Access keys" and create a new access key.
+    5. Run `aws configure` in your terminal and provide the access key ID and secret access key when prompted.
+</details>
+
+<details>
+    <summary>Common Issues You May Encounter</summary>
+
+    - To confirm that the cache is being used, you can use the `sccache --show-stats` command right after a build. This will expose very useful statistics, including cache hits/misses.
+    - If you have multiple AWS profiles configured, ensure that the correct profile is set in the `AWS_PROFILE` environment variable.
+    - `sccache` follows a server-client model. If you run into weird issues where `sccache` refuses to use S3, even though you have AWS credentials configured, try killing any running `sccache` servers with `sccache --stop-server` and then re-running the build.
+</details>
 
 ## Install LLVM
 
@@ -259,13 +274,18 @@ $ 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>
 
-# Build bun with the local JSC build — this automatically configures and builds JSC
+# Make a debug build of JSC. This will output build artifacts in ./vendor/WebKit/WebKitBuild/Debug
+# Optionally, you can use `bun run jsc:build` for a release build
+$ bun run jsc:build: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
 ```
 
-`bun run build:local` handles everything: configuring JSC, building JSC, and building Bun. On subsequent runs, JSC will incrementally rebuild if any WebKit sources changed. `ninja -Cbuild/debug-local` also works after the first build, and will build Bun+JSC.
-
-The build output goes to `./build/debug-local` (instead of `./build/debug`), so you'll need to update a couple of places:
+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`
@@ -276,7 +296,7 @@ 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 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.
+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
 

LATEST

@@ -1 +1 @@
-1.3.8
+1.3.3

LICENSE.md

@@ -36,7 +36,6 @@ Bun statically links these libraries:
 | [`libbase64`](https://github.com/aklomp/base64/blob/master/LICENSE) | BSD 2-Clause |
 | [`libuv`](https://github.com/libuv/libuv) (on Windows) | MIT |
 | [`libdeflate`](https://github.com/ebiggers/libdeflate) | MIT |
-| [`uucode`](https://github.com/jacobsandlund/uucode) | MIT |
 | A fork of [`uWebsockets`](https://github.com/jarred-sumner/uwebsockets) | Apache 2.0 licensed |
 | Parts of [Tigerbeetle's IO code](https://github.com/tigerbeetle/tigerbeetle/blob/532c8b70b9142c17e07737ab6d3da68d7500cbca/src/io/windows.zig#L1) | Apache 2.0 licensed |
 

bench/bun.lock

@@ -1,6 +1,5 @@
 {
   "lockfileVersion": 1,
-  "configVersion": 0,
   "workspaces": {
     "": {
       "name": "bench",
@@ -18,18 +17,12 @@
         "fast-glob": "3.3.1",
         "fastify": "^5.0.0",
         "fdir": "^6.1.0",
-        "marked": "^17.0.1",
-        "mitata": "1.0.20",
-        "react": "^19",
-        "react-dom": "^19",
-        "react-markdown": "^9.0.3",
-        "remark": "^15.0.1",
-        "remark-html": "^16.0.1",
+        "mitata": "^1.0.25",
+        "react": "^18.3.1",
+        "react-dom": "^18.3.1",
         "string-width": "7.1.0",
         "strip-ansi": "^7.1.0",
-        "tar": "^7.4.3",
         "tinycolor2": "^1.6.0",
-        "wrap-ansi": "^9.0.0",
         "zx": "^7.2.3",
       },
       "devDependencies": {
@@ -114,8 +107,6 @@
 
     "@fastify/proxy-addr": ["@fastify/proxy-addr@5.0.0", "", { "dependencies": { "@fastify/forwarded": "^3.0.0", "ipaddr.js": "^2.1.0" } }, "sha512-37qVVA1qZ5sgH7KpHkkC4z9SK6StIsIcOmpjvMPXNb3vx2GQxhZocogVYbr2PbbeLCQxYIPDok307xEvRZOzGA=="],
 
-    "@isaacs/fs-minipass": ["@isaacs/fs-minipass@4.0.1", "", { "dependencies": { "minipass": "^7.0.4" } }, "sha512-wgm9Ehl2jpeqP3zw/7mo3kRHFp5MEDhqAdwy1fTGkHAwnkGOVsgpvQhL8B5n1qlb01jV3n/bI0ZfZp5lWA1k4w=="],
-
     "@jridgewell/gen-mapping": ["@jridgewell/gen-mapping@0.1.1", "", { "dependencies": { "@jridgewell/set-array": "^1.0.0", "@jridgewell/sourcemap-codec": "^1.4.10" } }, "sha512-sQXCasFk+U8lWYEe66WxRDOE9PjVz4vSM51fTu3Hw+ClTpUSQb718772vH3pyS5pShp6lvQM7SxgIDXXXmOX7w=="],
 
     "@jridgewell/resolve-uri": ["@jridgewell/resolve-uri@3.1.0", "", {}, "sha512-F2msla3tad+Mfht5cJq7LSXcdudKTWCVYUgw6pLFOOHSTtZlj6SWNYAp+AhuqLmWdBO2X5hPrLcu8cVP8fy28w=="],
@@ -154,36 +145,18 @@
 
     "@swc/core-win32-x64-msvc": ["@swc/core-win32-x64-msvc@1.3.35", "", { "os": "win32", "cpu": "x64" }, "sha512-/RvphT4WfuGfIK84Ha0dovdPrKB1bW/mc+dtdmhv2E3EGkNc5FoueNwYmXWRimxnU7X0X7IkcRhyKB4G5DeAmg=="],
 
-    "@types/debug": ["@types/debug@4.1.12", "", { "dependencies": { "@types/ms": "*" } }, "sha512-vIChWdVG3LG1SMxEvI/AK+FWJthlrqlTu7fbrlywTkkaONwk/UAGaULXRlf8vkzFBLVm0zkMdCquhL5aOjhXPQ=="],
-
-    "@types/estree": ["@types/estree@1.0.8", "", {}, "sha512-dWHzHa2WqEXI/O1E9OjrocMTKJl2mSrEolh1Iomrv6U+JuNwaHXsXx9bLu5gG7BUWFIN0skIQJQ/L1rIex4X6w=="],
-
-    "@types/estree-jsx": ["@types/estree-jsx@1.0.5", "", { "dependencies": { "@types/estree": "*" } }, "sha512-52CcUVNFyfb1A2ALocQw/Dd1BQFNmSdkuC3BkZ6iqhdMfQz7JWOFRuJFloOzjk+6WijU56m9oKXFAXc7o3Towg=="],
-
     "@types/fs-extra": ["@types/fs-extra@11.0.4", "", { "dependencies": { "@types/jsonfile": "*", "@types/node": "*" } }, "sha512-yTbItCNreRooED33qjunPthRcSjERP1r4MqCZc7wv0u2sUkzTFp45tgUfS5+r7FrZPdmCCNflLhVSP/o+SemsQ=="],
 
-    "@types/hast": ["@types/hast@3.0.4", "", { "dependencies": { "@types/unist": "*" } }, "sha512-WPs+bbQw5aCj+x6laNGWLH3wviHtoCv/P3+otBhbOhJgG8qtpdAMlTCxLtsTWA7LH1Oh/bFCHsBn0TPS5m30EQ=="],
-
     "@types/jsonfile": ["@types/jsonfile@6.1.4", "", { "dependencies": { "@types/node": "*" } }, "sha512-D5qGUYwjvnNNextdU59/+fI+spnwtTFmyQP0h+PfIOSkNfpU6AOICUOkm4i0OnSk+NyjdPJrxCDro0sJsWlRpQ=="],
 
-    "@types/mdast": ["@types/mdast@4.0.4", "", { "dependencies": { "@types/unist": "*" } }, "sha512-kGaNbPh1k7AFzgpud/gMdvIm5xuECykRR+JnWKQno9TAXVa6WIVCGTPvYGekIDL4uwCZQSYbUxNBSb1aUo79oA=="],
-
     "@types/minimist": ["@types/minimist@1.2.5", "", {}, "sha512-hov8bUuiLiyFPGyFPE1lwWhmzYbirOXQNNo40+y3zow8aFVTeyn3VWL0VFFfdNddA8S4Vf0Tc062rzyNr7Paag=="],
 
-    "@types/ms": ["@types/ms@2.1.0", "", {}, "sha512-GsCCIZDE/p3i96vtEqx+7dBUGXrc7zeSK3wwPHIaRThS+9OhWIXRqzs4d6k1SVU8g91DrNRWxWUGhp5KXQb2VA=="],
-
     "@types/node": ["@types/node@18.19.8", "", { "dependencies": { "undici-types": "~5.26.4" } }, "sha512-g1pZtPhsvGVTwmeVoexWZLTQaOvXwoSq//pTL0DHeNzUDrFnir4fgETdhjhIxjVnN+hKOuh98+E1eMLnUXstFg=="],
 
     "@types/ps-tree": ["@types/ps-tree@1.1.6", "", {}, "sha512-PtrlVaOaI44/3pl3cvnlK+GxOM3re2526TJvPvh7W+keHIXdV4TE0ylpPBAcvFQCbGitaTXwL9u+RF7qtVeazQ=="],
 
-    "@types/react": ["@types/react@19.2.10", "", { "dependencies": { "csstype": "^3.2.2" } }, "sha512-WPigyYuGhgZ/cTPRXB2EwUw+XvsRA3GqHlsP4qteqrnnjDrApbS7MxcGr/hke5iUoeB7E/gQtrs9I37zAJ0Vjw=="],
-
-    "@types/unist": ["@types/unist@3.0.3", "", {}, "sha512-ko/gIFJRv177XgZsZcBwnqJN5x/Gien8qNOn0D5bQU/zAzVf9Zt3BlcUiLqhV9y4ARk0GbT3tnUiPNgnTXzc/Q=="],
-
     "@types/which": ["@types/which@3.0.3", "", {}, "sha512-2C1+XoY0huExTbs8MQv1DuS5FS86+SEjdM9F/+GS61gg5Hqbtj8ZiDSx8MfWcyei907fIPbfPGCOrNUTnVHY1g=="],
 
-    "@ungap/structured-clone": ["@ungap/structured-clone@1.3.0", "", {}, "sha512-WmoN8qaIAo7WTYWbAZuG8PYEhn5fkz7dZrqTBZ7dtt//lL2Gwms1IcnQ5yHqjDfX8Ft5j4YzDM23f87zBfDe9g=="],
-
     "abstract-logging": ["abstract-logging@2.0.1", "", {}, "sha512-2BjRTZxTPvheOvGbBslFSYOUkr+SjPtOnrLP33f+VIWLzezQpZcqVg7ja3L4dBXmzzgwT+a029jRx5PCi3JuiA=="],
 
     "ajv": ["ajv@8.17.1", "", { "dependencies": { "fast-deep-equal": "^3.1.3", "fast-uri": "^3.0.1", "json-schema-traverse": "^1.0.0", "require-from-string": "^2.0.2" } }, "sha512-B/gBuNg5SiMTrPkC+A2+cW0RszwxYmn6VYxB/inlBStS5nx6xHIt/ehKRhIMhqusl7a8LjQoZnjCs5vhwxOQ1g=="],
@@ -192,14 +165,12 @@
 
     "ansi-regex": ["ansi-regex@6.0.1", "", {}, "sha512-n5M855fKb2SsfMIiFFoVrABHJC8QtHwVx+mHWP3QcEqBHYienj5dHSgjbxtC0WEZXYt4wcD6zrQElDPhFuZgfA=="],
 
-    "ansi-styles": ["ansi-styles@6.2.3", "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/ansi-styles/-/ansi-styles-6.2.3.tgz", {}, "sha512-4Dj6M28JB+oAH8kFkTLUo+a2jwOFkuqb3yucU0CANcRRUbxS0cP0nZYCGjcc3BNXwRIsUVmDGgzawme7zvJHvg=="],
+    "ansi-styles": ["ansi-styles@3.2.1", "", { "dependencies": { "color-convert": "^1.9.0" } }, "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA=="],
 
     "atomic-sleep": ["atomic-sleep@1.0.0", "", {}, "sha512-kNOjDqAh7px0XWNI+4QbzoiR/nTkHAWNud2uvnJquD1/x5a7EQZMJT0AczqK0Qn67oY/TTQ1LbUKajZpp3I9tQ=="],
 
     "avvio": ["avvio@9.1.0", "", { "dependencies": { "@fastify/error": "^4.0.0", "fastq": "^1.17.1" } }, "sha512-fYASnYi600CsH/j9EQov7lECAniYiBFiiAtBNuZYLA2leLe9qOvZzqYHFjtIj6gD2VMoMLP14834LFWvr4IfDw=="],
 
-    "bail": ["bail@2.0.2", "", {}, "sha512-0xO6mYd7JB2YesxDKplafRpsiOzPt9V02ddPCLbY1xYGPOX24NTyN50qnUxgCPcSoYMhKpAuBTjQoRZCAkUDRw=="],
-
     "benchmark": ["benchmark@2.1.4", "", { "dependencies": { "lodash": "^4.17.4", "platform": "^1.3.3" } }, "sha512-l9MlfN4M1K/H2fbhfMy3B7vJd6AGKJVQn2h6Sg/Yx+KckoUA7ewS5Vv6TjSq18ooE1kS9hhAlQRH3AkXIh/aOQ=="],
 
     "braces": ["braces@3.0.2", "", { "dependencies": { "fill-range": "^7.0.1" } }, "sha512-b8um+L1RzM3WDSzvhm6gIz1yfTbBt6YTlcEKAvsmqCZZFw46z626lVj9j1yEPW33H5H+lBQpZMP1k8l+78Ha0A=="],
@@ -208,20 +179,8 @@
 
     "caniuse-lite": ["caniuse-lite@1.0.30001456", "", {}, "sha512-XFHJY5dUgmpMV25UqaD4kVq2LsiaU5rS8fb0f17pCoXQiQslzmFgnfOxfvo1bTpTqf7dwG/N/05CnLCnOEKmzA=="],
 
-    "ccount": ["ccount@2.0.1", "", {}, "sha512-eyrF0jiFpY+3drT6383f1qhkbGsLSifNAjA61IUjZjmLCWjItY6LB9ft9YhoDgwfmclB2zhu51Lc7+95b8NRAg=="],
-
     "chalk": ["chalk@5.3.0", "", {}, "sha512-dLitG79d+GV1Nb/VYcCDFivJeK1hiukt9QjRNVOsUtTy1rR1YJsmpGGTZ3qJos+uw7WmWF4wUwBd9jxjocFC2w=="],
 
-    "character-entities": ["character-entities@2.0.2", "", {}, "sha512-shx7oQ0Awen/BRIdkjkvz54PnEEI/EjwXDSIZp86/KKdbafHh1Df/RYGBhn4hbe2+uKC9FnT5UCEdyPz3ai9hQ=="],
-
-    "character-entities-html4": ["character-entities-html4@2.1.0", "", {}, "sha512-1v7fgQRj6hnSwFpq1Eu0ynr/CDEw0rXo2B61qXrLNdHZmPKgb7fqS1a2JwF0rISo9q77jDI8VMEHoApn8qDoZA=="],
-
-    "character-entities-legacy": ["character-entities-legacy@3.0.0", "", {}, "sha512-RpPp0asT/6ufRm//AJVwpViZbGM/MkjQFxJccQRHmISF/22NBtsHqAWmL+/pmkPWoIUJdWyeVleTl1wydHATVQ=="],
-
-    "character-reference-invalid": ["character-reference-invalid@2.0.1", "", {}, "sha512-iBZ4F4wRbyORVsu0jPV7gXkOsGYjGHPmAyv+HiHG8gi5PtC9KI2j1+v8/tlibRvjoWX027ypmG/n0HtO5t7unw=="],
-
-    "chownr": ["chownr@3.0.0", "", {}, "sha512-+IxzY9BZOQd/XuYPRmrvEVjF/nqj5kgT4kEq7VofrDoM1MxoRjEWkrCC3EtLi59TVawxTAn+orJwFQcrqEN1+g=="],
-
     "color": ["color@4.2.3", "", { "dependencies": { "color-convert": "^2.0.1", "color-string": "^1.9.0" } }, "sha512-1rXeuUUiGGrykh+CeBdu5Ie7OJwinCgQY0bc7GCRxy5xVHy+moaqkpL/jqQq0MtQOeYcrqEz4abc5f0KtU7W4A=="],
 
     "color-convert": ["color-convert@2.0.1", "", { "dependencies": { "color-name": "~1.1.4" } }, "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ=="],
@@ -230,26 +189,18 @@
 
     "color-string": ["color-string@1.9.1", "", { "dependencies": { "color-name": "^1.0.0", "simple-swizzle": "^0.2.2" } }, "sha512-shrVawQFojnZv6xM40anx4CkoDP+fZsw/ZerEMsW/pyzsRbElpsL/DBVW7q3ExxwusdNXI3lXpuhEZkzs8p5Eg=="],
 
-    "comma-separated-tokens": ["comma-separated-tokens@2.0.3", "", {}, "sha512-Fu4hJdvzeylCfQPp9SGWidpzrMs7tTrlu6Vb8XGaRGck8QSNZJJp538Wrb60Lax4fPwR64ViY468OIUTbRlGZg=="],
-
     "convert-source-map": ["convert-source-map@1.9.0", "", {}, "sha512-ASFBup0Mz1uyiIjANan1jzLQami9z1PoYSZCiiYW2FczPbenXc45FZdBZLzOT+r6+iciuEModtmCti+hjaAk0A=="],
 
     "cookie": ["cookie@1.0.2", "", {}, "sha512-9Kr/j4O16ISv8zBBhJoi4bXOYNTkFLOqSL3UDB0njXxCXNezjeyVrJyGOWtgfs/q2km1gwBcfH8q1yEGoMYunA=="],
 
     "cross-spawn": ["cross-spawn@7.0.3", "", { "dependencies": { "path-key": "^3.1.0", "shebang-command": "^2.0.0", "which": "^2.0.1" } }, "sha512-iRDPJKUPVEND7dHPO8rkbOnPpyDygcDFtWjpeWNCgy8WP2rXcxXL8TskReQl6OrB2G7+UJrags1q15Fudc7G6w=="],
 
-    "csstype": ["csstype@3.2.3", "", {}, "sha512-z1HGKcYy2xA8AGQfwrn0PAy+PB7X/GSj3UVJW9qKyn43xWa+gl5nXmU4qqLMRzWVLFC8KusUX8T/0kCiOYpAIQ=="],
-
     "data-uri-to-buffer": ["data-uri-to-buffer@4.0.1", "", {}, "sha512-0R9ikRb668HB7QDxT1vkpuUBtqc53YyAwMwGeUFKRojY/NWKvdZ+9UYtRfGmhqNbRkTSVpMbmyhXipFFv2cb/A=="],
 
     "debug": ["debug@4.3.4", "", { "dependencies": { "ms": "2.1.2" } }, "sha512-PRWFHuSU3eDtQJPvnNY7Jcket1j0t5OuOsFzPPzsekD52Zl8qUfFIPEiswXqIvHWGVHOgX+7G/vCNNhehwxfkQ=="],
 
-    "decode-named-character-reference": ["decode-named-character-reference@1.3.0", "", { "dependencies": { "character-entities": "^2.0.0" } }, "sha512-GtpQYB283KrPp6nRw50q3U9/VfOutZOe103qlN7BPP6Ad27xYnOIWv4lPzo8HCAL+mMZofJ9KEy30fq6MfaK6Q=="],
-
     "dequal": ["dequal@2.0.3", "", {}, "sha512-0je+qPKHEMohvfRTCEo3CrPG6cAzAYgmzKyxRiYSSDkS6eGJdyVJm7WaYA5ECaAD9wLB2T4EEeymA5aFVcYXCA=="],
 
-    "devlop": ["devlop@1.1.0", "", { "dependencies": { "dequal": "^2.0.0" } }, "sha512-RWmIqhcFf1lRYBvNmr7qTNuyCt/7/ns2jbpp1+PalgE/rDQcBT0fioSMUpJ93irlUhC5hrg4cYqe6U+0ImW0rA=="],
-
     "dir-glob": ["dir-glob@3.0.1", "", { "dependencies": { "path-type": "^4.0.0" } }, "sha512-WkrWp9GR4KXfKGYzOLmTuGVi1UWFfws377n9cc55/tb6DuqyF6pcQ5AbiHEshaDpY9v6oaSr2XCDidGmMwdzIA=="],
 
     "duplexer": ["duplexer@0.1.2", "", {}, "sha512-jtD6YG370ZCIi/9GTaJKQxWTZD045+4R4hTk/x1UyoqadyJ9x9CgSi1RlVDQF8U2sxLLSnFkCaMihqljHIWgMg=="],
@@ -304,16 +255,12 @@
 
     "escape-string-regexp": ["escape-string-regexp@1.0.5", "", {}, "sha512-vbRorB5FUQWvla16U8R/qgaFIya2qGzwDrNmCZuYKrbdSUMG6I1ZCGQRefkRVhuOkIGVne7BQ35DSfo1qvJqFg=="],
 
-    "estree-util-is-identifier-name": ["estree-util-is-identifier-name@3.0.0", "", {}, "sha512-hFtqIDZTIUZ9BXLb8y4pYGyk6+wekIivNVTcmvk8NoOh+VeRn5y6cEHzbURrWbfp1fIqdVipilzj+lfaadNZmg=="],
-
     "event-stream": ["event-stream@3.3.4", "", { "dependencies": { "duplexer": "~0.1.1", "from": "~0", "map-stream": "~0.1.0", "pause-stream": "0.0.11", "split": "0.3", "stream-combiner": "~0.0.4", "through": "~2.3.1" } }, "sha512-QHpkERcGsR0T7Qm3HNJSyXKEEj8AHNxkY3PK8TS2KJvQ7NiSHe3DDpwVKKtoYprL/AreyzFBeIkBIWChAqn60g=="],
 
     "eventemitter3": ["eventemitter3@5.0.0", "", {}, "sha512-riuVbElZZNXLeLEoprfNYoDSwTBRR44X3mnhdI1YcnENpWTCsTTVZ2zFuqQcpoyqPQIUXdiPEU0ECAq0KQRaHg=="],
 
     "execa": ["execa@8.0.1", "", { "dependencies": { "cross-spawn": "^7.0.3", "get-stream": "^8.0.1", "human-signals": "^5.0.0", "is-stream": "^3.0.0", "merge-stream": "^2.0.0", "npm-run-path": "^5.1.0", "onetime": "^6.0.0", "signal-exit": "^4.1.0", "strip-final-newline": "^3.0.0" } }, "sha512-VyhnebXciFV2DESc+p6B+y0LjSm0krU4OgJN44qFAhBY0TJ+1V61tYD2+wHusZ6F9n5K+vl8k0sTy7PEfV4qpg=="],
 
-    "extend": ["extend@3.0.2", "", {}, "sha512-fjquC59cD7CyW6urNXK0FBufkZcoiGG80wTuPujX590cB5Ttln20E2UB4S/WARVqhXffZl2LNgS+gQdPIIim/g=="],
-
     "fast-decode-uri-component": ["fast-decode-uri-component@1.0.1", "", {}, "sha512-WKgKWg5eUxvRZGwW8FvfbaH7AXSh2cL+3j5fMGzUMCxWBJ3dV3a7Wz8y2f/uQ0e3B6WmodD3oS54jTQ9HVTIIg=="],
 
     "fast-deep-equal": ["fast-deep-equal@3.1.3", "", {}, "sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q=="],
@@ -364,44 +311,20 @@
 
     "has-flag": ["has-flag@3.0.0", "", {}, "sha512-sKJf1+ceQBr4SMkvQnBDNDtf4TXpVhVGateu0t918bl30FnbE2m4vNLX+VWe/dpjlb+HugGYzW7uQXH98HPEYw=="],
 
-    "hast-util-sanitize": ["hast-util-sanitize@5.0.2", "", { "dependencies": { "@types/hast": "^3.0.0", "@ungap/structured-clone": "^1.0.0", "unist-util-position": "^5.0.0" } }, "sha512-3yTWghByc50aGS7JlGhk61SPenfE/p1oaFeNwkOOyrscaOkMGrcW9+Cy/QAIOBpZxP1yqDIzFMR0+Np0i0+usg=="],
-
-    "hast-util-to-html": ["hast-util-to-html@9.0.5", "", { "dependencies": { "@types/hast": "^3.0.0", "@types/unist": "^3.0.0", "ccount": "^2.0.0", "comma-separated-tokens": "^2.0.0", "hast-util-whitespace": "^3.0.0", "html-void-elements": "^3.0.0", "mdast-util-to-hast": "^13.0.0", "property-information": "^7.0.0", "space-separated-tokens": "^2.0.0", "stringify-entities": "^4.0.0", "zwitch": "^2.0.4" } }, "sha512-OguPdidb+fbHQSU4Q4ZiLKnzWo8Wwsf5bZfbvu7//a9oTYoqD/fWpe96NuHkoS9h0ccGOTe0C4NGXdtS0iObOw=="],
-
-    "hast-util-to-jsx-runtime": ["hast-util-to-jsx-runtime@2.3.6", "", { "dependencies": { "@types/estree": "^1.0.0", "@types/hast": "^3.0.0", "@types/unist": "^3.0.0", "comma-separated-tokens": "^2.0.0", "devlop": "^1.0.0", "estree-util-is-identifier-name": "^3.0.0", "hast-util-whitespace": "^3.0.0", "mdast-util-mdx-expression": "^2.0.0", "mdast-util-mdx-jsx": "^3.0.0", "mdast-util-mdxjs-esm": "^2.0.0", "property-information": "^7.0.0", "space-separated-tokens": "^2.0.0", "style-to-js": "^1.0.0", "unist-util-position": "^5.0.0", "vfile-message": "^4.0.0" } }, "sha512-zl6s8LwNyo1P9uw+XJGvZtdFF1GdAkOg8ujOw+4Pyb76874fLps4ueHXDhXWdk6YHQ6OgUtinliG7RsYvCbbBg=="],
-
-    "hast-util-whitespace": ["hast-util-whitespace@3.0.0", "", { "dependencies": { "@types/hast": "^3.0.0" } }, "sha512-88JUN06ipLwsnv+dVn+OIYOvAuvBMy/Qoi6O7mQHxdPXpjy+Cd6xRkWwux7DKO+4sYILtLBRIKgsdpS2gQc7qw=="],
-
-    "html-url-attributes": ["html-url-attributes@3.0.1", "", {}, "sha512-ol6UPyBWqsrO6EJySPz2O7ZSr856WDrEzM5zMqp+FJJLGMW35cLYmmZnl0vztAZxRUoNZJFTCohfjuIJ8I4QBQ=="],
-
-    "html-void-elements": ["html-void-elements@3.0.0", "", {}, "sha512-bEqo66MRXsUGxWHV5IP0PUiAWwoEjba4VCzg0LjFJBpchPaTfyfCKTG6bc5F8ucKec3q5y6qOdGyYTSBEvhCrg=="],
-
     "human-signals": ["human-signals@5.0.0", "", {}, "sha512-AXcZb6vzzrFAUE61HnN4mpLqd/cSIwNQjtNWR0euPm6y0iqx3G4gOXaIDdtdDwZmhwe82LA6+zinmW4UBWVePQ=="],
 
     "ignore": ["ignore@5.3.0", "", {}, "sha512-g7dmpshy+gD7mh88OC9NwSGTKoc3kyLAZQRU1mt53Aw/vnvfXnbC+F/7F7QoYVKbV+KNvJx8wArewKy1vXMtlg=="],
 
-    "inline-style-parser": ["inline-style-parser@0.2.7", "", {}, "sha512-Nb2ctOyNR8DqQoR0OwRG95uNWIC0C1lCgf5Naz5H6Ji72KZ8OcFZLz2P5sNgwlyoJ8Yif11oMuYs5pBQa86csA=="],
-
     "ipaddr.js": ["ipaddr.js@2.2.0", "", {}, "sha512-Ag3wB2o37wslZS19hZqorUnrnzSkpOVy+IiiDEiTqNubEYpYuHWIf6K4psgN2ZWKExS4xhVCrRVfb/wfW8fWJA=="],
 
-    "is-alphabetical": ["is-alphabetical@2.0.1", "", {}, "sha512-FWyyY60MeTNyeSRpkM2Iry0G9hpr7/9kD40mD/cGQEuilcZYS4okz8SN2Q6rLCJ8gbCt6fN+rC+6tMGS99LaxQ=="],
-
-    "is-alphanumerical": ["is-alphanumerical@2.0.1", "", { "dependencies": { "is-alphabetical": "^2.0.0", "is-decimal": "^2.0.0" } }, "sha512-hmbYhX/9MUMF5uh7tOXyK/n0ZvWpad5caBA17GsC6vyuCqaWliRG5K1qS9inmUhEMaOBIW7/whAnSwveW/LtZw=="],
-
     "is-arrayish": ["is-arrayish@0.3.2", "", {}, "sha512-eVRqCvVlZbuw3GrM63ovNSNAeA1K16kaR/LRY/92w0zxQ5/1YzwblUX652i4Xs9RwAGjW9d9y6X88t8OaAJfWQ=="],
 
-    "is-decimal": ["is-decimal@2.0.1", "", {}, "sha512-AAB9hiomQs5DXWcRB1rqsxGUstbRroFOPPVAomNk/3XHR5JyEZChOyTWe2oayKnsSsr/kcGqF+z6yuH6HHpN0A=="],
-
     "is-extglob": ["is-extglob@2.1.1", "", {}, "sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ=="],
 
     "is-glob": ["is-glob@4.0.3", "", { "dependencies": { "is-extglob": "^2.1.1" } }, "sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg=="],
 
-    "is-hexadecimal": ["is-hexadecimal@2.0.1", "", {}, "sha512-DgZQp241c8oO6cA1SbTEWiXeoxV42vlcJxgH+B3hi1AiqqKruZR3ZGF8In3fj4+/y/7rHvlOZLZtgJ/4ttYGZg=="],
-
     "is-number": ["is-number@7.0.0", "", {}, "sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng=="],
 
-    "is-plain-obj": ["is-plain-obj@4.1.0", "", {}, "sha512-+Pgi+vMuUNkJyExiMBt5IlFoMyKnr5zhJ4Uspz58WOhBF5QoIZkFyNHIbBAtHwzVAgk5RtndVNsDRN61/mmDqg=="],
-
     "is-stream": ["is-stream@3.0.0", "", {}, "sha512-LnQR4bZ9IADDRSkvpqMGvt/tEJWclzklNgSw48V5EAaAeDd6qGvN8ei6k5p0tvxSR171VmGyHuTiAOfxAbr8kA=="],
 
     "isexe": ["isexe@2.0.0", "", {}, "sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw=="],
@@ -422,87 +345,23 @@
 
     "lodash": ["lodash@4.17.21", "", {}, "sha512-v2kDEe57lecTulaDIuNTPy3Ry4gLGJ6Z1O3vE1krgXZNrsQ+LFTGHVxVjcXPs17LhbZVGedAJv8XZ1tvj5FvSg=="],
 
-    "longest-streak": ["longest-streak@3.1.0", "", {}, "sha512-9Ri+o0JYgehTaVBBDoMqIl8GXtbWg711O3srftcHhZ0dqnETqLaoIK0x17fUw9rFSlK/0NlsKe0Ahhyl5pXE2g=="],
+    "loose-envify": ["loose-envify@1.4.0", "", { "dependencies": { "js-tokens": "^3.0.0 || ^4.0.0" }, "bin": { "loose-envify": "cli.js" } }, "sha512-lyuxPGr/Wfhrlem2CL/UcnUc1zcqKAImBDzukY7Y5F/yQiNdko6+fRLevlw1HgMySw7f611UIY408EtxRSoK3Q=="],
 
     "lru-cache": ["lru-cache@5.1.1", "", { "dependencies": { "yallist": "^3.0.2" } }, "sha512-KpNARQA3Iwv+jTA0utUVVbrh+Jlrr1Fv0e56GGzAFOXN7dk/FviaDW8LHmK52DlcH4WP2n6gI8vN1aesBFgo9w=="],
 
     "map-stream": ["map-stream@0.1.0", "", {}, "sha512-CkYQrPYZfWnu/DAmVCpTSX/xHpKZ80eKh2lAkyA6AJTef6bW+6JpbQZN5rofum7da+SyN1bi5ctTm+lTfcCW3g=="],
 
-    "marked": ["marked@17.0.1", "", { "bin": { "marked": "bin/marked.js" } }, "sha512-boeBdiS0ghpWcSwoNm/jJBwdpFaMnZWRzjA6SkUMYb40SVaN1x7mmfGKp0jvexGcx+7y2La5zRZsYFZI6Qpypg=="],
-
-    "mdast-util-from-markdown": ["mdast-util-from-markdown@2.0.2", "", { "dependencies": { "@types/mdast": "^4.0.0", "@types/unist": "^3.0.0", "decode-named-character-reference": "^1.0.0", "devlop": "^1.0.0", "mdast-util-to-string": "^4.0.0", "micromark": "^4.0.0", "micromark-util-decode-numeric-character-reference": "^2.0.0", "micromark-util-decode-string": "^2.0.0", "micromark-util-normalize-identifier": "^2.0.0", "micromark-util-symbol": "^2.0.0", "micromark-util-types": "^2.0.0", "unist-util-stringify-position": "^4.0.0" } }, "sha512-uZhTV/8NBuw0WHkPTrCqDOl0zVe1BIng5ZtHoDk49ME1qqcjYmmLmOf0gELgcRMxN4w2iuIeVso5/6QymSrgmA=="],
-
-    "mdast-util-mdx-expression": ["mdast-util-mdx-expression@2.0.1", "", { "dependencies": { "@types/estree-jsx": "^1.0.0", "@types/hast": "^3.0.0", "@types/mdast": "^4.0.0", "devlop": "^1.0.0", "mdast-util-from-markdown": "^2.0.0", "mdast-util-to-markdown": "^2.0.0" } }, "sha512-J6f+9hUp+ldTZqKRSg7Vw5V6MqjATc+3E4gf3CFNcuZNWD8XdyI6zQ8GqH7f8169MM6P7hMBRDVGnn7oHB9kXQ=="],
-
-    "mdast-util-mdx-jsx": ["mdast-util-mdx-jsx@3.2.0", "", { "dependencies": { "@types/estree-jsx": "^1.0.0", "@types/hast": "^3.0.0", "@types/mdast": "^4.0.0", "@types/unist": "^3.0.0", "ccount": "^2.0.0", "devlop": "^1.1.0", "mdast-util-from-markdown": "^2.0.0", "mdast-util-to-markdown": "^2.0.0", "parse-entities": "^4.0.0", "stringify-entities": "^4.0.0", "unist-util-stringify-position": "^4.0.0", "vfile-message": "^4.0.0" } }, "sha512-lj/z8v0r6ZtsN/cGNNtemmmfoLAFZnjMbNyLzBafjzikOM+glrjNHPlf6lQDOTccj9n5b0PPihEBbhneMyGs1Q=="],
-
-    "mdast-util-mdxjs-esm": ["mdast-util-mdxjs-esm@2.0.1", "", { "dependencies": { "@types/estree-jsx": "^1.0.0", "@types/hast": "^3.0.0", "@types/mdast": "^4.0.0", "devlop": "^1.0.0", "mdast-util-from-markdown": "^2.0.0", "mdast-util-to-markdown": "^2.0.0" } }, "sha512-EcmOpxsZ96CvlP03NghtH1EsLtr0n9Tm4lPUJUBccV9RwUOneqSycg19n5HGzCf+10LozMRSObtVr3ee1WoHtg=="],
-
-    "mdast-util-phrasing": ["mdast-util-phrasing@4.1.0", "", { "dependencies": { "@types/mdast": "^4.0.0", "unist-util-is": "^6.0.0" } }, "sha512-TqICwyvJJpBwvGAMZjj4J2n0X8QWp21b9l0o7eXyVJ25YNWYbJDVIyD1bZXE6WtV6RmKJVYmQAKWa0zWOABz2w=="],
-
-    "mdast-util-to-hast": ["mdast-util-to-hast@13.2.1", "", { "dependencies": { "@types/hast": "^3.0.0", "@types/mdast": "^4.0.0", "@ungap/structured-clone": "^1.0.0", "devlop": "^1.0.0", "micromark-util-sanitize-uri": "^2.0.0", "trim-lines": "^3.0.0", "unist-util-position": "^5.0.0", "unist-util-visit": "^5.0.0", "vfile": "^6.0.0" } }, "sha512-cctsq2wp5vTsLIcaymblUriiTcZd0CwWtCbLvrOzYCDZoWyMNV8sZ7krj09FSnsiJi3WVsHLM4k6Dq/yaPyCXA=="],
-
-    "mdast-util-to-markdown": ["mdast-util-to-markdown@2.1.2", "", { "dependencies": { "@types/mdast": "^4.0.0", "@types/unist": "^3.0.0", "longest-streak": "^3.0.0", "mdast-util-phrasing": "^4.0.0", "mdast-util-to-string": "^4.0.0", "micromark-util-classify-character": "^2.0.0", "micromark-util-decode-string": "^2.0.0", "unist-util-visit": "^5.0.0", "zwitch": "^2.0.0" } }, "sha512-xj68wMTvGXVOKonmog6LwyJKrYXZPvlwabaryTjLh9LuvovB/KAH+kvi8Gjj+7rJjsFi23nkUxRQv1KqSroMqA=="],
-
-    "mdast-util-to-string": ["mdast-util-to-string@4.0.0", "", { "dependencies": { "@types/mdast": "^4.0.0" } }, "sha512-0H44vDimn51F0YwvxSJSm0eCDOJTRlmN0R1yBh4HLj9wiV1Dn0QoXGbvFAWj2hSItVTlCmBF1hqKlIyUBVFLPg=="],
-
     "merge-stream": ["merge-stream@2.0.0", "", {}, "sha512-abv/qOcuPfk3URPfDzmZU1LKmuw8kT+0nIHvKrKgFrwifol/doWcdA4ZqsWQ8ENrFKkd67Mfpo/LovbIUsbt3w=="],
 
     "merge2": ["merge2@1.4.1", "", {}, "sha512-8q7VEgMJW4J8tcfVPy8g09NcQwZdbwFEqhe/WZkoIzjn/3TGDwtOCYtXGxA3O8tPzpczCCDgv+P2P5y00ZJOOg=="],
 
-    "micromark": ["micromark@4.0.2", "", { "dependencies": { "@types/debug": "^4.0.0", "debug": "^4.0.0", "decode-named-character-reference": "^1.0.0", "devlop": "^1.0.0", "micromark-core-commonmark": "^2.0.0", "micromark-factory-space": "^2.0.0", "micromark-util-character": "^2.0.0", "micromark-util-chunked": "^2.0.0", "micromark-util-combine-extensions": "^2.0.0", "micromark-util-decode-numeric-character-reference": "^2.0.0", "micromark-util-encode": "^2.0.0", "micromark-util-normalize-identifier": "^2.0.0", "micromark-util-resolve-all": "^2.0.0", "micromark-util-sanitize-uri": "^2.0.0", "micromark-util-subtokenize": "^2.0.0", "micromark-util-symbol": "^2.0.0", "micromark-util-types": "^2.0.0" } }, "sha512-zpe98Q6kvavpCr1NPVSCMebCKfD7CA2NqZ+rykeNhONIJBpc1tFKt9hucLGwha3jNTNI8lHpctWJWoimVF4PfA=="],
-
-    "micromark-core-commonmark": ["micromark-core-commonmark@2.0.3", "", { "dependencies": { "decode-named-character-reference": "^1.0.0", "devlop": "^1.0.0", "micromark-factory-destination": "^2.0.0", "micromark-factory-label": "^2.0.0", "micromark-factory-space": "^2.0.0", "micromark-factory-title": "^2.0.0", "micromark-factory-whitespace": "^2.0.0", "micromark-util-character": "^2.0.0", "micromark-util-chunked": "^2.0.0", "micromark-util-classify-character": "^2.0.0", "micromark-util-html-tag-name": "^2.0.0", "micromark-util-normalize-identifier": "^2.0.0", "micromark-util-resolve-all": "^2.0.0", "micromark-util-subtokenize": "^2.0.0", "micromark-util-symbol": "^2.0.0", "micromark-util-types": "^2.0.0" } }, "sha512-RDBrHEMSxVFLg6xvnXmb1Ayr2WzLAWjeSATAoxwKYJV94TeNavgoIdA0a9ytzDSVzBy2YKFK+emCPOEibLeCrg=="],
-
-    "micromark-factory-destination": ["micromark-factory-destination@2.0.1", "", { "dependencies": { "micromark-util-character": "^2.0.0", "micromark-util-symbol": "^2.0.0", "micromark-util-types": "^2.0.0" } }, "sha512-Xe6rDdJlkmbFRExpTOmRj9N3MaWmbAgdpSrBQvCFqhezUn4AHqJHbaEnfbVYYiexVSs//tqOdY/DxhjdCiJnIA=="],
-
-    "micromark-factory-label": ["micromark-factory-label@2.0.1", "", { "dependencies": { "devlop": "^1.0.0", "micromark-util-character": "^2.0.0", "micromark-util-symbol": "^2.0.0", "micromark-util-types": "^2.0.0" } }, "sha512-VFMekyQExqIW7xIChcXn4ok29YE3rnuyveW3wZQWWqF4Nv9Wk5rgJ99KzPvHjkmPXF93FXIbBp6YdW3t71/7Vg=="],
-
-    "micromark-factory-space": ["micromark-factory-space@2.0.1", "", { "dependencies": { "micromark-util-character": "^2.0.0", "micromark-util-types": "^2.0.0" } }, "sha512-zRkxjtBxxLd2Sc0d+fbnEunsTj46SWXgXciZmHq0kDYGnck/ZSGj9/wULTV95uoeYiK5hRXP2mJ98Uo4cq/LQg=="],
-
-    "micromark-factory-title": ["micromark-factory-title@2.0.1", "", { "dependencies": { "micromark-factory-space": "^2.0.0", "micromark-util-character": "^2.0.0", "micromark-util-symbol": "^2.0.0", "micromark-util-types": "^2.0.0" } }, "sha512-5bZ+3CjhAd9eChYTHsjy6TGxpOFSKgKKJPJxr293jTbfry2KDoWkhBb6TcPVB4NmzaPhMs1Frm9AZH7OD4Cjzw=="],
-
-    "micromark-factory-whitespace": ["micromark-factory-whitespace@2.0.1", "", { "dependencies": { "micromark-factory-space": "^2.0.0", "micromark-util-character": "^2.0.0", "micromark-util-symbol": "^2.0.0", "micromark-util-types": "^2.0.0" } }, "sha512-Ob0nuZ3PKt/n0hORHyvoD9uZhr+Za8sFoP+OnMcnWK5lngSzALgQYKMr9RJVOWLqQYuyn6ulqGWSXdwf6F80lQ=="],
-
-    "micromark-util-character": ["micromark-util-character@2.1.1", "", { "dependencies": { "micromark-util-symbol": "^2.0.0", "micromark-util-types": "^2.0.0" } }, "sha512-wv8tdUTJ3thSFFFJKtpYKOYiGP2+v96Hvk4Tu8KpCAsTMs6yi+nVmGh1syvSCsaxz45J6Jbw+9DD6g97+NV67Q=="],
-
-    "micromark-util-chunked": ["micromark-util-chunked@2.0.1", "", { "dependencies": { "micromark-util-symbol": "^2.0.0" } }, "sha512-QUNFEOPELfmvv+4xiNg2sRYeS/P84pTW0TCgP5zc9FpXetHY0ab7SxKyAQCNCc1eK0459uoLI1y5oO5Vc1dbhA=="],
-
-    "micromark-util-classify-character": ["micromark-util-classify-character@2.0.1", "", { "dependencies": { "micromark-util-character": "^2.0.0", "micromark-util-symbol": "^2.0.0", "micromark-util-types": "^2.0.0" } }, "sha512-K0kHzM6afW/MbeWYWLjoHQv1sgg2Q9EccHEDzSkxiP/EaagNzCm7T/WMKZ3rjMbvIpvBiZgwR3dKMygtA4mG1Q=="],
-
-    "micromark-util-combine-extensions": ["micromark-util-combine-extensions@2.0.1", "", { "dependencies": { "micromark-util-chunked": "^2.0.0", "micromark-util-types": "^2.0.0" } }, "sha512-OnAnH8Ujmy59JcyZw8JSbK9cGpdVY44NKgSM7E9Eh7DiLS2E9RNQf0dONaGDzEG9yjEl5hcqeIsj4hfRkLH/Bg=="],
-
-    "micromark-util-decode-numeric-character-reference": ["micromark-util-decode-numeric-character-reference@2.0.2", "", { "dependencies": { "micromark-util-symbol": "^2.0.0" } }, "sha512-ccUbYk6CwVdkmCQMyr64dXz42EfHGkPQlBj5p7YVGzq8I7CtjXZJrubAYezf7Rp+bjPseiROqe7G6foFd+lEuw=="],
-
-    "micromark-util-decode-string": ["micromark-util-decode-string@2.0.1", "", { "dependencies": { "decode-named-character-reference": "^1.0.0", "micromark-util-character": "^2.0.0", "micromark-util-decode-numeric-character-reference": "^2.0.0", "micromark-util-symbol": "^2.0.0" } }, "sha512-nDV/77Fj6eH1ynwscYTOsbK7rR//Uj0bZXBwJZRfaLEJ1iGBR6kIfNmlNqaqJf649EP0F3NWNdeJi03elllNUQ=="],
-
-    "micromark-util-encode": ["micromark-util-encode@2.0.1", "", {}, "sha512-c3cVx2y4KqUnwopcO9b/SCdo2O67LwJJ/UyqGfbigahfegL9myoEFoDYZgkT7f36T0bLrM9hZTAaAyH+PCAXjw=="],
-
-    "micromark-util-html-tag-name": ["micromark-util-html-tag-name@2.0.1", "", {}, "sha512-2cNEiYDhCWKI+Gs9T0Tiysk136SnR13hhO8yW6BGNyhOC4qYFnwF1nKfD3HFAIXA5c45RrIG1ub11GiXeYd1xA=="],
-
-    "micromark-util-normalize-identifier": ["micromark-util-normalize-identifier@2.0.1", "", { "dependencies": { "micromark-util-symbol": "^2.0.0" } }, "sha512-sxPqmo70LyARJs0w2UclACPUUEqltCkJ6PhKdMIDuJ3gSf/Q+/GIe3WKl0Ijb/GyH9lOpUkRAO2wp0GVkLvS9Q=="],
-
-    "micromark-util-resolve-all": ["micromark-util-resolve-all@2.0.1", "", { "dependencies": { "micromark-util-types": "^2.0.0" } }, "sha512-VdQyxFWFT2/FGJgwQnJYbe1jjQoNTS4RjglmSjTUlpUMa95Htx9NHeYW4rGDJzbjvCsl9eLjMQwGeElsqmzcHg=="],
-
-    "micromark-util-sanitize-uri": ["micromark-util-sanitize-uri@2.0.1", "", { "dependencies": { "micromark-util-character": "^2.0.0", "micromark-util-encode": "^2.0.0", "micromark-util-symbol": "^2.0.0" } }, "sha512-9N9IomZ/YuGGZZmQec1MbgxtlgougxTodVwDzzEouPKo3qFWvymFHWcnDi2vzV1ff6kas9ucW+o3yzJK9YB1AQ=="],
-
-    "micromark-util-subtokenize": ["micromark-util-subtokenize@2.1.0", "", { "dependencies": { "devlop": "^1.0.0", "micromark-util-chunked": "^2.0.0", "micromark-util-symbol": "^2.0.0", "micromark-util-types": "^2.0.0" } }, "sha512-XQLu552iSctvnEcgXw6+Sx75GflAPNED1qx7eBJ+wydBb2KCbRZe+NwvIEEMM83uml1+2WSXpBAcp9IUCgCYWA=="],
-
-    "micromark-util-symbol": ["micromark-util-symbol@2.0.1", "", {}, "sha512-vs5t8Apaud9N28kgCrRUdEed4UJ+wWNvicHLPxCa9ENlYuAY31M0ETy5y1vA33YoNPDFTghEbnh6efaE8h4x0Q=="],
-
-    "micromark-util-types": ["micromark-util-types@2.0.2", "", {}, "sha512-Yw0ECSpJoViF1qTU4DC6NwtC4aWGt1EkzaQB8KPPyCRR8z9TWeV0HbEFGTO+ZY1wB22zmxnJqhPyTpOVCpeHTA=="],
-
     "micromatch": ["micromatch@4.0.5", "", { "dependencies": { "braces": "^3.0.2", "picomatch": "^2.3.1" } }, "sha512-DMy+ERcEW2q8Z2Po+WNXuw3c5YaUSFjAO5GsJqfEl7UjvtIuFKO6ZrKvcItdy98dwFI2N1tg3zNIdKaQT+aNdA=="],
 
     "mimic-fn": ["mimic-fn@4.0.0", "", {}, "sha512-vqiC06CuhBTUdZH+RYl8sFrL096vA45Ok5ISO6sE/Mr1jRbGH4Csnhi8f3wKVl7x8mO4Au7Ir9D3Oyv1VYMFJw=="],
 
     "minimist": ["minimist@1.2.8", "", {}, "sha512-2yyAR8qBkN3YuheJanUpWC5U3bb5osDywNB8RzDVlDwDHbocAJveqqj1u8+SVD7jkWT4yvsHCpWqqWqAxb0zCA=="],
 
-    "minipass": ["minipass@7.1.2", "", {}, "sha512-qOOzS1cBTWYF4BH8fVePDBOO9iptMnGUEZwNc/cMWnTV2nVLZ7VoNWEPHkYczZA0pdoA7dl6e7FL659nX9S2aw=="],
-
-    "minizlib": ["minizlib@3.1.0", "", { "dependencies": { "minipass": "^7.1.2" } }, "sha512-KZxYo1BUkWD2TVFLr0MQoM8vUUigWD3LlD83a/75BqC+4qE0Hb1Vo5v1FgcfaNXvfXzr+5EhQ6ing/CaBijTlw=="],
-
-    "mitata": ["mitata@1.0.20", "", {}, "sha512-oHWYGX5bi4wGT/1zrhiZAEzqTV14Vq6/PUTW8WK0b3YHBBQcZz2QFm+InHhjnD0I7B6CMtwdGt2K0938r7YTdQ=="],
+    "mitata": ["mitata@1.0.25", "", {}, "sha512-0v5qZtVW5vwj9FDvYfraR31BMDcRLkhSFWPTLaxx/Z3/EvScfVtAAWtMI2ArIbBcwh7P86dXh0lQWKiXQPlwYA=="],
 
     "ms": ["ms@2.1.2", "", {}, "sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w=="],
 
@@ -518,8 +377,6 @@
 
     "onetime": ["onetime@6.0.0", "", { "dependencies": { "mimic-fn": "^4.0.0" } }, "sha512-1FlR+gjXK7X+AsAHso35MnyN5KqGwJRi/31ft6x0M194ht7S+rWAvd7PHss9xSKMzE0asv1pyIHaJYq+BbacAQ=="],
 
-    "parse-entities": ["parse-entities@4.0.2", "", { "dependencies": { "@types/unist": "^2.0.0", "character-entities-legacy": "^3.0.0", "character-reference-invalid": "^2.0.0", "decode-named-character-reference": "^1.0.0", "is-alphanumerical": "^2.0.0", "is-decimal": "^2.0.0", "is-hexadecimal": "^2.0.0" } }, "sha512-GG2AQYWoLgL877gQIKeRPGO1xF9+eG1ujIb5soS5gPvLQ1y2o8FL90w2QWNdf9I361Mpp7726c+lj3U0qK1uGw=="],
-
     "path-key": ["path-key@3.1.1", "", {}, "sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q=="],
 
     "path-type": ["path-type@4.0.0", "", {}, "sha512-gDKb8aZMDeD/tZWs9P6+q0J9Mwkdl6xMV8TjnGP3qJVJ06bdMgkbBlLU8IdfOsIsFz2BW1rNVT3XuNEl8zPAvw=="],
@@ -540,32 +397,18 @@
 
     "process-warning": ["process-warning@5.0.0", "", {}, "sha512-a39t9ApHNx2L4+HBnQKqxxHNs1r7KF+Intd8Q/g1bUh6q0WIp9voPXJ/x0j+ZL45KF1pJd9+q2jLIRMfvEshkA=="],
 
-    "property-information": ["property-information@7.1.0", "", {}, "sha512-TwEZ+X+yCJmYfL7TPUOcvBZ4QfoT5YenQiJuX//0th53DE6w0xxLEtfK3iyryQFddXuvkIk51EEgrJQ0WJkOmQ=="],
-
     "ps-tree": ["ps-tree@1.2.0", "", { "dependencies": { "event-stream": "=3.3.4" }, "bin": { "ps-tree": "./bin/ps-tree.js" } }, "sha512-0VnamPPYHl4uaU/nSFeZZpR21QAWRz+sRv4iW9+v/GS/J5U5iZB5BNN6J0RMoOvdx2gWM2+ZFMIm58q24e4UYA=="],
 
     "queue-microtask": ["queue-microtask@1.2.3", "", {}, "sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A=="],
 
     "quick-format-unescaped": ["quick-format-unescaped@4.0.4", "", {}, "sha512-tYC1Q1hgyRuHgloV/YXs2w15unPVh8qfu/qCTfhTYamaw7fyhumKa2yGpdSo87vY32rIclj+4fWYQXUMs9EHvg=="],
 
-    "react": ["react@19.2.4", "", {}, "sha512-9nfp2hYpCwOjAN+8TZFGhtWEwgvWHXqESH8qT89AT/lWklpLON22Lc8pEtnpsZz7VmawabSU0gCjnj8aC0euHQ=="],
+    "react": ["react@18.3.1", "", { "dependencies": { "loose-envify": "^1.1.0" } }, "sha512-wS+hAgJShR0KhEvPJArfuPVN1+Hz1t0Y6n5jLrGQbkb4urgPE/0Rve+1kMB1v/oWgHgm4WIcV+i7F2pTVj+2iQ=="],
 
-    "react-dom": ["react-dom@19.2.4", "", { "dependencies": { "scheduler": "^0.27.0" }, "peerDependencies": { "react": "^19.2.4" } }, "sha512-AXJdLo8kgMbimY95O2aKQqsz2iWi9jMgKJhRBAxECE4IFxfcazB2LmzloIoibJI3C12IlY20+KFaLv+71bUJeQ=="],
-
-    "react-markdown": ["react-markdown@9.1.0", "", { "dependencies": { "@types/hast": "^3.0.0", "@types/mdast": "^4.0.0", "devlop": "^1.0.0", "hast-util-to-jsx-runtime": "^2.0.0", "html-url-attributes": "^3.0.0", "mdast-util-to-hast": "^13.0.0", "remark-parse": "^11.0.0", "remark-rehype": "^11.0.0", "unified": "^11.0.0", "unist-util-visit": "^5.0.0", "vfile": "^6.0.0" }, "peerDependencies": { "@types/react": ">=18", "react": ">=18" } }, "sha512-xaijuJB0kzGiUdG7nc2MOMDUDBWPyGAjZtUrow9XxUeua8IqeP+VlIfAZ3bphpcLTnSZXz6z9jcVC/TCwbfgdw=="],
+    "react-dom": ["react-dom@18.3.1", "", { "dependencies": { "loose-envify": "^1.1.0", "scheduler": "^0.23.2" }, "peerDependencies": { "react": "^18.3.1" } }, "sha512-5m4nQKp+rZRb09LNH59GM4BxTh9251/ylbKIbpe7TpGxfJ+9kv6BLkLBXIjjspbgbnIBNqlI23tRnTWT0snUIw=="],
 
     "real-require": ["real-require@0.2.0", "", {}, "sha512-57frrGM/OCTLqLOAh0mhVA9VBMHd+9U7Zb2THMGdBUoZVOtGbJzjxsYGDJ3A9AYYCP4hn6y1TVbaOfzWtm5GFg=="],
 
-    "remark": ["remark@15.0.1", "", { "dependencies": { "@types/mdast": "^4.0.0", "remark-parse": "^11.0.0", "remark-stringify": "^11.0.0", "unified": "^11.0.0" } }, "sha512-Eht5w30ruCXgFmxVUSlNWQ9iiimq07URKeFS3hNc8cUWy1llX4KDWfyEDZRycMc+znsN9Ux5/tJ/BFdgdOwA3A=="],
-
-    "remark-html": ["remark-html@16.0.1", "", { "dependencies": { "@types/mdast": "^4.0.0", "hast-util-sanitize": "^5.0.0", "hast-util-to-html": "^9.0.0", "mdast-util-to-hast": "^13.0.0", "unified": "^11.0.0" } }, "sha512-B9JqA5i0qZe0Nsf49q3OXyGvyXuZFDzAP2iOFLEumymuYJITVpiH1IgsTEwTpdptDmZlMDMWeDmSawdaJIGCXQ=="],
-
-    "remark-parse": ["remark-parse@11.0.0", "", { "dependencies": { "@types/mdast": "^4.0.0", "mdast-util-from-markdown": "^2.0.0", "micromark-util-types": "^2.0.0", "unified": "^11.0.0" } }, "sha512-FCxlKLNGknS5ba/1lmpYijMUzX2esxW5xQqjWxw2eHFfS2MSdaHVINFmhjo+qN1WhZhNimq0dZATN9pH0IDrpA=="],
-
-    "remark-rehype": ["remark-rehype@11.1.2", "", { "dependencies": { "@types/hast": "^3.0.0", "@types/mdast": "^4.0.0", "mdast-util-to-hast": "^13.0.0", "unified": "^11.0.0", "vfile": "^6.0.0" } }, "sha512-Dh7l57ianaEoIpzbp0PC9UKAdCSVklD8E5Rpw7ETfbTl3FqcOOgq5q2LVDhgGCkaBv7p24JXikPdvhhmHvKMsw=="],
-
-    "remark-stringify": ["remark-stringify@11.0.0", "", { "dependencies": { "@types/mdast": "^4.0.0", "mdast-util-to-markdown": "^2.0.0", "unified": "^11.0.0" } }, "sha512-1OSmLd3awB/t8qdoEOMazZkNsfVTeY4fTsgzcQFdXNq8ToTN4ZGwrMnlda4K6smTFKD+GRV6O48i6Z4iKgPPpw=="],
-
     "require-from-string": ["require-from-string@2.0.2", "", {}, "sha512-Xf0nWe6RseziFMu+Ap9biiUbmplq6S9/p+7w7YXP/JBHhrUDDUhwa+vANyubuqfZWTveU//DYVGsDG7RKL/vEw=="],
 
     "ret": ["ret@0.5.0", "", {}, "sha512-I1XxrZSQ+oErkRR4jYbAyEEu2I0avBvvMM5JN+6EBprOGRCs63ENqZ3vjavq8fBw2+62G5LF5XelKwuJpcvcxw=="],
@@ -580,7 +423,7 @@
 
     "safe-stable-stringify": ["safe-stable-stringify@2.5.0", "", {}, "sha512-b3rppTKm9T+PsVCBEOUR46GWI7fdOs00VKZ1+9c1EWDaDMvjQc6tUwuFyIprgGgTcWoVHSKrU8H31ZHA2e0RHA=="],
 
-    "scheduler": ["scheduler@0.27.0", "", {}, "sha512-eNv+WrVbKu1f3vbYJT/xtiF5syA5HPIMtf9IgY/nKg0sWqzAUEvqY/xm7OcZc/qafLx/iO9FgOmeSAp4v5ti/Q=="],
+    "scheduler": ["scheduler@0.23.2", "", { "dependencies": { "loose-envify": "^1.1.0" } }, "sha512-UOShsPwz7NrMUqhR6t0hWjFduvOzbtv7toDH1/hIrfRNIDBnnBWd0CwJTGvTpngVlmwGCdP9/Zl/tVrDqcuYzQ=="],
 
     "secure-json-parse": ["secure-json-parse@4.0.0", "", {}, "sha512-dxtLJO6sc35jWidmLxo7ij+Eg48PM/kleBsxpC8QJE0qJICe+KawkDQmvCMZUr9u7WKVHgMW6vy3fQ7zMiFZMA=="],
 
@@ -600,8 +443,6 @@
 
     "sonic-boom": ["sonic-boom@4.2.0", "", { "dependencies": { "atomic-sleep": "^1.0.0" } }, "sha512-INb7TM37/mAcsGmc9hyyI6+QR3rR1zVRu36B0NeGXKnOOLiZOfER5SA+N7X7k3yUYRzLWafduTDvJAfDswwEww=="],
 
-    "space-separated-tokens": ["space-separated-tokens@2.0.2", "", {}, "sha512-PEGlAwrG8yXGXRjW32fGbg66JAlOAwbObuqVoJpv/mRgoWDQfgH1wDPvtzWyUSNAXBGSk8h755YDbbcEy3SH2Q=="],
-
     "split": ["split@0.3.3", "", { "dependencies": { "through": "2" } }, "sha512-wD2AeVmxXRBoX44wAycgjVpMhvbwdI2aZjCkvfNcH1YqHQvJVa1duWc73OyVGJUc05fhFaTZeQ/PYsrmyH0JVA=="],
 
     "split2": ["split2@4.2.0", "", {}, "sha512-UcjcJOWknrNkF6PLX83qcHM6KHgVKNkV62Y8a5uYDVv9ydGQVwAHMKqHdJje1VTWpljG0WYpCDhrCdAOYH4TWg=="],
@@ -610,20 +451,12 @@
 
     "string-width": ["string-width@7.1.0", "", { "dependencies": { "emoji-regex": "^10.3.0", "get-east-asian-width": "^1.0.0", "strip-ansi": "^7.1.0" } }, "sha512-SEIJCWiX7Kg4c129n48aDRwLbFb2LJmXXFrWBG4NGaRtMQ3myKPKbwrD1BKqQn74oCoNMBVrfDEr5M9YxCsrkw=="],
 
-    "stringify-entities": ["stringify-entities@4.0.4", "", { "dependencies": { "character-entities-html4": "^2.0.0", "character-entities-legacy": "^3.0.0" } }, "sha512-IwfBptatlO+QCJUo19AqvrPNqlVMpW9YEL2LIVY+Rpv2qsjCGxaDLNRgeGsQWJhfItebuJhsGSLjaBbNSQ+ieg=="],
-
     "strip-ansi": ["strip-ansi@7.1.0", "", { "dependencies": { "ansi-regex": "^6.0.1" } }, "sha512-iq6eVVI64nQQTRYq2KtEg2d2uU7LElhTJwsH4YzIHZshxlgZms/wIc4VoDQTlG/IvVIrBKG06CrZnp0qv7hkcQ=="],
 
     "strip-final-newline": ["strip-final-newline@3.0.0", "", {}, "sha512-dOESqjYr96iWYylGObzd39EuNTa5VJxyvVAEm5Jnh7KGo75V43Hk1odPQkNDyXNmUR6k+gEiDVXnjB8HJ3crXw=="],
 
-    "style-to-js": ["style-to-js@1.1.21", "", { "dependencies": { "style-to-object": "1.0.14" } }, "sha512-RjQetxJrrUJLQPHbLku6U/ocGtzyjbJMP9lCNK7Ag0CNh690nSH8woqWH9u16nMjYBAok+i7JO1NP2pOy8IsPQ=="],
-
-    "style-to-object": ["style-to-object@1.0.14", "", { "dependencies": { "inline-style-parser": "0.2.7" } }, "sha512-LIN7rULI0jBscWQYaSswptyderlarFkjQ+t79nzty8tcIAceVomEVlLzH5VP4Cmsv6MtKhs7qaAiwlcp+Mgaxw=="],
-
     "supports-color": ["supports-color@5.5.0", "", { "dependencies": { "has-flag": "^3.0.0" } }, "sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow=="],
 
-    "tar": ["tar@7.5.2", "", { "dependencies": { "@isaacs/fs-minipass": "^4.0.0", "chownr": "^3.0.0", "minipass": "^7.1.2", "minizlib": "^3.1.0", "yallist": "^5.0.0" } }, "sha512-7NyxrTE4Anh8km8iEy7o0QYPs+0JKBTj5ZaqHg6B39erLg0qYXN3BijtShwbsNSvQ+LN75+KV+C4QR/f6Gwnpg=="],
-
     "thread-stream": ["thread-stream@3.1.0", "", { "dependencies": { "real-require": "^0.2.0" } }, "sha512-OqyPZ9u96VohAyMfJykzmivOrY2wfMSf3C5TtFJVgN+Hm6aj+voFhlK+kZEIv2FBh1X6Xp3DlnCOfEQ3B2J86A=="],
 
     "through": ["through@2.3.8", "", {}, "sha512-w89qg7PI8wAdvX60bMDP+bFoD5Dvhm9oLheFp5O4a2QF0cSBGsBX4qZmadPMvVqlLJBBci+WqGGOAPvcDeNSVg=="],
@@ -636,52 +469,30 @@
 
     "toad-cache": ["toad-cache@3.7.0", "", {}, "sha512-/m8M+2BJUpoJdgAHoG+baCwBT+tf2VraSfkBgl0Y00qIWt41DJ8R5B8nsEw0I58YwF5IZH6z24/2TobDKnqSWw=="],
 
-    "trim-lines": ["trim-lines@3.0.1", "", {}, "sha512-kRj8B+YHZCc9kQYdWfJB2/oUl9rA99qbowYYBtr4ui4mZyAQ2JpvVBd/6U2YloATfqBhBTSMhTpgBHtU0Mf3Rg=="],
-
-    "trough": ["trough@2.2.0", "", {}, "sha512-tmMpK00BjZiUyVyvrBK7knerNgmgvcV/KLVyuma/SC+TQN167GrMRciANTz09+k3zW8L8t60jWO1GpfkZdjTaw=="],
-
     "undici-types": ["undici-types@5.26.5", "", {}, "sha512-JlCMO+ehdEIKqlFxk6IfVoAUVmgz7cU7zD/h9XZ0qzeosSHmUJVOzSQvvYSYWXkFXC+IfLKSIffhv0sVZup6pA=="],
 
-    "unified": ["unified@11.0.5", "", { "dependencies": { "@types/unist": "^3.0.0", "bail": "^2.0.0", "devlop": "^1.0.0", "extend": "^3.0.0", "is-plain-obj": "^4.0.0", "trough": "^2.0.0", "vfile": "^6.0.0" } }, "sha512-xKvGhPWw3k84Qjh8bI3ZeJjqnyadK+GEFtazSfZv/rKeTkTjOJho6mFqh2SM96iIcZokxiOpg78GazTSg8+KHA=="],
-
-    "unist-util-is": ["unist-util-is@6.0.1", "", { "dependencies": { "@types/unist": "^3.0.0" } }, "sha512-LsiILbtBETkDz8I9p1dQ0uyRUWuaQzd/cuEeS1hoRSyW5E5XGmTzlwY1OrNzzakGowI9Dr/I8HVaw4hTtnxy8g=="],
-
-    "unist-util-position": ["unist-util-position@5.0.0", "", { "dependencies": { "@types/unist": "^3.0.0" } }, "sha512-fucsC7HjXvkB5R3kTCO7kUjRdrS0BJt3M/FPxmHMBOm8JQi2BsHAHFsy27E0EolP8rp0NzXsJ+jNPyDWvOJZPA=="],
-
-    "unist-util-stringify-position": ["unist-util-stringify-position@4.0.0", "", { "dependencies": { "@types/unist": "^3.0.0" } }, "sha512-0ASV06AAoKCDkS2+xw5RXJywruurpbC4JZSm7nr7MOt1ojAzvyyaO+UxZf18j8FCF6kmzCZKcAgN/yu2gm2XgQ=="],
-
-    "unist-util-visit": ["unist-util-visit@5.1.0", "", { "dependencies": { "@types/unist": "^3.0.0", "unist-util-is": "^6.0.0", "unist-util-visit-parents": "^6.0.0" } }, "sha512-m+vIdyeCOpdr/QeQCu2EzxX/ohgS8KbnPDgFni4dQsfSCtpz8UqDyY5GjRru8PDKuYn7Fq19j1CQ+nJSsGKOzg=="],
-
-    "unist-util-visit-parents": ["unist-util-visit-parents@6.0.2", "", { "dependencies": { "@types/unist": "^3.0.0", "unist-util-is": "^6.0.0" } }, "sha512-goh1s1TBrqSqukSc8wrjwWhL0hiJxgA8m4kFxGlQ+8FYQ3C/m11FcTs4YYem7V664AhHVvgoQLk890Ssdsr2IQ=="],
-
     "universalify": ["universalify@2.0.1", "", {}, "sha512-gptHNQghINnc/vTGIk0SOFGFNXw7JVrlRUtConJRlvaw6DuX0wO5Jeko9sWrMBhh+PsYAZ7oXAiOnf/UKogyiw=="],
 
     "update-browserslist-db": ["update-browserslist-db@1.0.10", "", { "dependencies": { "escalade": "^3.1.1", "picocolors": "^1.0.0" }, "peerDependencies": { "browserslist": ">= 4.21.0" }, "bin": { "browserslist-lint": "cli.js" } }, "sha512-OztqDenkfFkbSG+tRxBeAnCVPckDBcvibKd35yDONx6OU8N7sqgwc7rCbkJ/WcYtVRZ4ba68d6byhC21GFh7sQ=="],
 
-    "vfile": ["vfile@6.0.3", "", { "dependencies": { "@types/unist": "^3.0.0", "vfile-message": "^4.0.0" } }, "sha512-KzIbH/9tXat2u30jf+smMwFCsno4wHVdNmzFyL+T/L3UGqqk6JKfVqOFOZEpZSHADH1k40ab6NUIXZq422ov3Q=="],
-
-    "vfile-message": ["vfile-message@4.0.3", "", { "dependencies": { "@types/unist": "^3.0.0", "unist-util-stringify-position": "^4.0.0" } }, "sha512-QTHzsGd1EhbZs4AsQ20JX1rC3cOlt/IWJruk893DfLRr57lcnOeMaWG4K0JrRta4mIJZKth2Au3mM3u03/JWKw=="],
-
     "web-streams-polyfill": ["web-streams-polyfill@3.3.2", "", {}, "sha512-3pRGuxRF5gpuZc0W+EpwQRmCD7gRqcDOMt688KmdlDAgAyaB1XlN0zq2njfDNm44XVdIouE7pZ6GzbdyH47uIQ=="],
 
     "webpod": ["webpod@0.0.2", "", { "bin": { "webpod": "dist/index.js" } }, "sha512-cSwwQIeg8v4i3p4ajHhwgR7N6VyxAf+KYSSsY6Pd3aETE+xEU4vbitz7qQkB0I321xnhDdgtxuiSfk5r/FVtjg=="],
 
     "which": ["which@3.0.1", "", { "dependencies": { "isexe": "^2.0.0" }, "bin": { "node-which": "bin/which.js" } }, "sha512-XA1b62dzQzLfaEOSQFTCOd5KFf/1VSzZo7/7TUjnya6u0vGGKzU96UQBZTAThCb2j4/xjBAyii1OhRLJEivHvg=="],
 
-    "wrap-ansi": ["wrap-ansi@9.0.2", "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/wrap-ansi/-/wrap-ansi-9.0.2.tgz", { "dependencies": { "ansi-styles": "^6.2.1", "string-width": "^7.0.0", "strip-ansi": "^7.1.0" } }, "sha512-42AtmgqjV+X1VpdOfyTGOYRi0/zsoLqtXQckTmqTeybT+BDIbM/Guxo7x3pE2vtpr1ok6xRqM9OpBe+Jyoqyww=="],
-
-    "yallist": ["yallist@5.0.0", "", {}, "sha512-YgvUTfwqyc7UXVMrB+SImsVYSmTS8X/tSrtdNZMImM+n7+QTriRXyXim0mBrTXNeqzVF0KWGgHPeiyViFFrNDw=="],
+    "yallist": ["yallist@3.1.1", "", {}, "sha512-a4UGQaWPH59mOXUYnAG2ewncQS4i4F43Tv3JoAM+s2VDAmS9NsK8GpDMLrCHPksFT7h3K6TOoUNn2pb7RoXx4g=="],
 
     "yaml": ["yaml@2.3.4", "", {}, "sha512-8aAvwVUSHpfEqTQ4w/KMlf3HcRdt50E5ODIQJBw1fQ5RL34xabzxtUlzTXVqc4rkZsPbvrXKWnABCD7kWSmocA=="],
 
-    "zwitch": ["zwitch@2.0.4", "", {}, "sha512-bXE4cR/kVZhKZX/RjPEflHaKVhUVl85noU3v6b8apfQEc1x4A+zBxjZ4lN8LqGd6WZ3dl98pY4o717VFmoPp+A=="],
-
     "zx": ["zx@7.2.3", "", { "dependencies": { "@types/fs-extra": "^11.0.1", "@types/minimist": "^1.2.2", "@types/node": "^18.16.3", "@types/ps-tree": "^1.1.2", "@types/which": "^3.0.0", "chalk": "^5.2.0", "fs-extra": "^11.1.1", "fx": "*", "globby": "^13.1.4", "minimist": "^1.2.8", "node-fetch": "3.3.1", "ps-tree": "^1.2.0", "webpod": "^0", "which": "^3.0.0", "yaml": "^2.2.2" }, "bin": { "zx": "build/cli.js" } }, "sha512-QODu38nLlYXg/B/Gw7ZKiZrvPkEsjPN3LQ5JFXM7h0JvwhEdPNNl+4Ao1y4+o3CLNiDUNcwzQYZ4/Ko7kKzCMA=="],
 
     "@babel/generator/@jridgewell/gen-mapping": ["@jridgewell/gen-mapping@0.3.2", "", { "dependencies": { "@jridgewell/set-array": "^1.0.1", "@jridgewell/sourcemap-codec": "^1.4.10", "@jridgewell/trace-mapping": "^0.3.9" } }, "sha512-mh65xKQAzI6iBcFzwv28KVWSmCkdRBWoOh+bYQGW3+6OZvbbN3TqMGo5hqYxQniRcH9F2VZIoJCm4pa3BPDK/A=="],
 
     "@babel/highlight/chalk": ["chalk@2.4.2", "", { "dependencies": { "ansi-styles": "^3.2.1", "escape-string-regexp": "^1.0.5", "supports-color": "^5.3.0" } }, "sha512-Mti+f9lpJNcwF4tWV8/OrTTtF1gZi+f8FqlyAdouralcFWFQWF2+NgCHShjkCb+IFBLq9buZwE1xckQU4peSuQ=="],
 
+    "ansi-styles/color-convert": ["color-convert@1.9.3", "", { "dependencies": { "color-name": "1.1.3" } }, "sha512-QfAUtd+vFdAtFQcC8CCyYt1fYWxSqAiK2cSD6zDB8N3cpsEBAvRxp9zOGg6G/SHHJYAT88/az/IuDGALsNVbGg=="],
+
     "avvio/fastq": ["fastq@1.19.1", "", { "dependencies": { "reusify": "^1.0.4" } }, "sha512-GwLTyxkCXjXbxqIhTsMI2Nui8huMPtnxg7krajPJAjnEG/iiOS7i+zCtWGZR9G0NBKbXKh6X9m9UIsYX/N6vvQ=="],
 
     "cross-spawn/which": ["which@2.0.2", "", { "dependencies": { "isexe": "^2.0.0" }, "bin": { "node-which": "./bin/node-which" } }, "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA=="],
@@ -690,16 +501,8 @@
 
     "light-my-request/process-warning": ["process-warning@4.0.1", "", {}, "sha512-3c2LzQ3rY9d0hc1emcsHhfT9Jwz0cChib/QN89oME2R451w5fy3f0afAhERFZAwrbDU43wk12d0ORBpDVME50Q=="],
 
-    "lru-cache/yallist": ["yallist@3.1.1", "", {}, "sha512-a4UGQaWPH59mOXUYnAG2ewncQS4i4F43Tv3JoAM+s2VDAmS9NsK8GpDMLrCHPksFT7h3K6TOoUNn2pb7RoXx4g=="],
-
     "npm-run-path/path-key": ["path-key@4.0.0", "", {}, "sha512-haREypq7xkM7ErfgIyA0z+Bj4AGKlMSdlQE2jvJo6huWD1EdkKYV+G/T4nq0YEF2vgTT8kqMFKo1uHn950r4SQ=="],
 
-    "parse-entities/@types/unist": ["@types/unist@2.0.11", "", {}, "sha512-CmBKiL6NNo/OqgmMn95Fk9Whlp2mtvIv+KNpQKN2F4SjvrEesubTRWGYSg+BnWZOnlCaSTU1sMpsBOzgbYhnsA=="],
-
-    "@babel/highlight/chalk/ansi-styles": ["ansi-styles@3.2.1", "", { "dependencies": { "color-convert": "^1.9.0" } }, "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA=="],
-
-    "@babel/highlight/chalk/ansi-styles/color-convert": ["color-convert@1.9.3", "", { "dependencies": { "color-name": "1.1.3" } }, "sha512-QfAUtd+vFdAtFQcC8CCyYt1fYWxSqAiK2cSD6zDB8N3cpsEBAvRxp9zOGg6G/SHHJYAT88/az/IuDGALsNVbGg=="],
-
-    "@babel/highlight/chalk/ansi-styles/color-convert/color-name": ["color-name@1.1.3", "", {}, "sha512-72fSenhMw2HZMTVHeCA9KCmpEIbzWiQsjN+BHcBbS9vr1mtt+vJjPdksIBNUmKAW8TFUDPJK5SUU3QhE9NEXDw=="],
+    "ansi-styles/color-convert/color-name": ["color-name@1.1.3", "", {}, "sha512-72fSenhMw2HZMTVHeCA9KCmpEIbzWiQsjN+BHcBbS9vr1mtt+vJjPdksIBNUmKAW8TFUDPJK5SUU3QhE9NEXDw=="],
   }
 }

bench/install/bun.lock

@@ -1,6 +1,5 @@
 {
   "lockfileVersion": 1,
-  "configVersion": 0,
   "workspaces": {
     "": {
       "name": "installbench",
@@ -13,7 +12,7 @@
         "@trpc/server": "^11.0.0",
         "drizzle-orm": "^0.41.0",
         "esbuild": "^0.25.11",
-        "next": "15.5.7",
+        "next": "^15.2.3",
         "next-auth": "5.0.0-beta.25",
         "postgres": "^3.4.4",
         "react": "^19.0.0",
@@ -176,23 +175,23 @@
 
     "@jridgewell/trace-mapping": ["@jridgewell/trace-mapping@0.3.31", "", { "dependencies": { "@jridgewell/resolve-uri": "3.1.2", "@jridgewell/sourcemap-codec": "1.5.5" } }, "sha512-zzNR+SdQSDJzc8joaeP8QQoCQr8NuYx2dIIytl1QeBEZHJ9uW6hebsrYgbz8hJwUQao3TWCMtmfV8Nu1twOLAw=="],
 
-    "@next/env": ["@next/env@15.5.7", "", {}, "sha512-4h6Y2NyEkIEN7Z8YxkA27pq6zTkS09bUSYC0xjd0NpwFxjnIKeZEeH591o5WECSmjpUhLn3H2QLJcDye3Uzcvg=="],
+    "@next/env": ["@next/env@15.5.6", "", {}, "sha512-3qBGRW+sCGzgbpc5TS1a0p7eNxnOarGVQhZxfvTdnV0gFI61lX7QNtQ4V1TSREctXzYn5NetbUsLvyqwLFJM6Q=="],
 
-    "@next/swc-darwin-arm64": ["@next/swc-darwin-arm64@15.5.7", "", { "os": "darwin", "cpu": "arm64" }, "sha512-IZwtxCEpI91HVU/rAUOOobWSZv4P2DeTtNaCdHqLcTJU4wdNXgAySvKa/qJCgR5m6KI8UsKDXtO2B31jcaw1Yw=="],
+    "@next/swc-darwin-arm64": ["@next/swc-darwin-arm64@15.5.6", "", { "os": "darwin", "cpu": "arm64" }, "sha512-ES3nRz7N+L5Umz4KoGfZ4XX6gwHplwPhioVRc25+QNsDa7RtUF/z8wJcbuQ2Tffm5RZwuN2A063eapoJ1u4nPg=="],
 
-    "@next/swc-darwin-x64": ["@next/swc-darwin-x64@15.5.7", "", { "os": "darwin", "cpu": "x64" }, "sha512-UP6CaDBcqaCBuiq/gfCEJw7sPEoX1aIjZHnBWN9v9qYHQdMKvCKcAVs4OX1vIjeE+tC5EIuwDTVIoXpUes29lg=="],
+    "@next/swc-darwin-x64": ["@next/swc-darwin-x64@15.5.6", "", { "os": "darwin", "cpu": "x64" }, "sha512-JIGcytAyk9LQp2/nuVZPAtj8uaJ/zZhsKOASTjxDug0SPU9LAM3wy6nPU735M1OqacR4U20LHVF5v5Wnl9ptTA=="],
 
-    "@next/swc-linux-arm64-gnu": ["@next/swc-linux-arm64-gnu@15.5.7", "", { "os": "linux", "cpu": "arm64" }, "sha512-NCslw3GrNIw7OgmRBxHtdWFQYhexoUCq+0oS2ccjyYLtcn1SzGzeM54jpTFonIMUjNbHmpKpziXnpxhSWLcmBA=="],
+    "@next/swc-linux-arm64-gnu": ["@next/swc-linux-arm64-gnu@15.5.6", "", { "os": "linux", "cpu": "arm64" }, "sha512-qvz4SVKQ0P3/Im9zcS2RmfFL/UCQnsJKJwQSkissbngnB/12c6bZTCB0gHTexz1s6d/mD0+egPKXAIRFVS7hQg=="],
 
-    "@next/swc-linux-arm64-musl": ["@next/swc-linux-arm64-musl@15.5.7", "", { "os": "linux", "cpu": "arm64" }, "sha512-nfymt+SE5cvtTrG9u1wdoxBr9bVB7mtKTcj0ltRn6gkP/2Nu1zM5ei8rwP9qKQP0Y//umK+TtkKgNtfboBxRrw=="],
+    "@next/swc-linux-arm64-musl": ["@next/swc-linux-arm64-musl@15.5.6", "", { "os": "linux", "cpu": "arm64" }, "sha512-FsbGVw3SJz1hZlvnWD+T6GFgV9/NYDeLTNQB2MXoPN5u9VA9OEDy6fJEfePfsUKAhJufFbZLgp0cPxMuV6SV0w=="],
 
-    "@next/swc-linux-x64-gnu": ["@next/swc-linux-x64-gnu@15.5.7", "", { "os": "linux", "cpu": "x64" }, "sha512-hvXcZvCaaEbCZcVzcY7E1uXN9xWZfFvkNHwbe/n4OkRhFWrs1J1QV+4U1BN06tXLdaS4DazEGXwgqnu/VMcmqw=="],
+    "@next/swc-linux-x64-gnu": ["@next/swc-linux-x64-gnu@15.5.6", "", { "os": "linux", "cpu": "x64" }, "sha512-3QnHGFWlnvAgyxFxt2Ny8PTpXtQD7kVEeaFat5oPAHHI192WKYB+VIKZijtHLGdBBvc16tiAkPTDmQNOQ0dyrA=="],
 
-    "@next/swc-linux-x64-musl": ["@next/swc-linux-x64-musl@15.5.7", "", { "os": "linux", "cpu": "x64" }, "sha512-4IUO539b8FmF0odY6/SqANJdgwn1xs1GkPO5doZugwZ3ETF6JUdckk7RGmsfSf7ws8Qb2YB5It33mvNL/0acqA=="],
+    "@next/swc-linux-x64-musl": ["@next/swc-linux-x64-musl@15.5.6", "", { "os": "linux", "cpu": "x64" }, "sha512-OsGX148sL+TqMK9YFaPFPoIaJKbFJJxFzkXZljIgA9hjMjdruKht6xDCEv1HLtlLNfkx3c5w2GLKhj7veBQizQ=="],
 
-    "@next/swc-win32-arm64-msvc": ["@next/swc-win32-arm64-msvc@15.5.7", "", { "os": "win32", "cpu": "arm64" }, "sha512-CpJVTkYI3ZajQkC5vajM7/ApKJUOlm6uP4BknM3XKvJ7VXAvCqSjSLmM0LKdYzn6nBJVSjdclx8nYJSa3xlTgQ=="],
+    "@next/swc-win32-arm64-msvc": ["@next/swc-win32-arm64-msvc@15.5.6", "", { "os": "win32", "cpu": "arm64" }, "sha512-ONOMrqWxdzXDJNh2n60H6gGyKed42Ieu6UTVPZteXpuKbLZTH4G4eBMsr5qWgOBA+s7F+uB4OJbZnrkEDnZ5Fg=="],
 
-    "@next/swc-win32-x64-msvc": ["@next/swc-win32-x64-msvc@15.5.7", "", { "os": "win32", "cpu": "x64" }, "sha512-gMzgBX164I6DN+9/PGA+9dQiwmTkE4TloBNx8Kv9UiGARsr9Nba7IpcBRA1iTV9vwlYnrE3Uy6I7Aj6qLjQuqw=="],
+    "@next/swc-win32-x64-msvc": ["@next/swc-win32-x64-msvc@15.5.6", "", { "os": "win32", "cpu": "x64" }, "sha512-pxK4VIjFRx1MY92UycLOOw7dTdvccWsNETQ0kDHkBlcFH1GrTLUjSiHU1ohrznnux6TqRHgv5oflhfIWZwVROQ=="],
 
     "@panva/hkdf": ["@panva/hkdf@1.2.1", "", {}, "sha512-6oclG6Y3PiDFcoyk8srjLfVKyMfVCKJ27JwNPViuXziFpmdz+MZnZN/aKY0JGXgYuO/VghU0jcOAZgWXZ1Dmrw=="],
 
@@ -324,7 +323,7 @@
 
     "nanoid": ["nanoid@3.3.11", "", { "bin": { "nanoid": "bin/nanoid.cjs" } }, "sha512-N8SpfPUnUp1bK+PMYW8qSWdl9U+wwNWI4QKxOYDy9JAro3WMX7p2OeVRF9v+347pnakNevPmiHhNmZ2HbFA76w=="],
 
-    "next": ["next@15.5.7", "", { "dependencies": { "@next/env": "15.5.7", "@swc/helpers": "0.5.15", "caniuse-lite": "^1.0.30001579", "postcss": "8.4.31", "styled-jsx": "5.1.6" }, "optionalDependencies": { "@next/swc-darwin-arm64": "15.5.7", "@next/swc-darwin-x64": "15.5.7", "@next/swc-linux-arm64-gnu": "15.5.7", "@next/swc-linux-arm64-musl": "15.5.7", "@next/swc-linux-x64-gnu": "15.5.7", "@next/swc-linux-x64-musl": "15.5.7", "@next/swc-win32-arm64-msvc": "15.5.7", "@next/swc-win32-x64-msvc": "15.5.7", "sharp": "^0.34.3" }, "peerDependencies": { "@opentelemetry/api": "^1.1.0", "@playwright/test": "^1.51.1", "babel-plugin-react-compiler": "*", "react": "^18.2.0 || 19.0.0-rc-de68d2f4-20241204 || ^19.0.0", "react-dom": "^18.2.0 || 19.0.0-rc-de68d2f4-20241204 || ^19.0.0", "sass": "^1.3.0" }, "optionalPeers": ["@opentelemetry/api", "@playwright/test", "babel-plugin-react-compiler", "sass"], "bin": { "next": "dist/bin/next" } }, "sha512-+t2/0jIJ48kUpGKkdlhgkv+zPTEOoXyr60qXe68eB/pl3CMJaLeIGjzp5D6Oqt25hCBiBTt8wEeeAzfJvUKnPQ=="],
+    "next": ["next@15.5.6", "", { "dependencies": { "@next/env": "15.5.6", "@swc/helpers": "0.5.15", "caniuse-lite": "1.0.30001752", "postcss": "8.4.31", "styled-jsx": "5.1.6" }, "optionalDependencies": { "@next/swc-darwin-arm64": "15.5.6", "@next/swc-darwin-x64": "15.5.6", "@next/swc-linux-arm64-gnu": "15.5.6", "@next/swc-linux-arm64-musl": "15.5.6", "@next/swc-linux-x64-gnu": "15.5.6", "@next/swc-linux-x64-musl": "15.5.6", "@next/swc-win32-arm64-msvc": "15.5.6", "@next/swc-win32-x64-msvc": "15.5.6", "sharp": "0.34.4" }, "peerDependencies": { "react": "19.2.0", "react-dom": "19.2.0" }, "bin": { "next": "dist/bin/next" } }, "sha512-zTxsnI3LQo3c9HSdSf91O1jMNsEzIXDShXd4wVdg9y5shwLqBXi4ZtUUJyB86KGVSJLZx0PFONvO54aheGX8QQ=="],
 
     "next-auth": ["next-auth@5.0.0-beta.25", "", { "dependencies": { "@auth/core": "0.37.2" }, "peerDependencies": { "next": "15.5.6", "react": "19.2.0" } }, "sha512-2dJJw1sHQl2qxCrRk+KTQbeH+izFbGFPuJj5eGgBZFYyiYYtvlrBeUw1E/OJJxTRjuxbSYGnCTkUIRsIIW0bog=="],
 

bench/install/package.json

@@ -26,7 +26,7 @@
     "@trpc/server": "^11.0.0",
     "drizzle-orm": "^0.41.0",
     "esbuild": "^0.25.11",
-    "next": "15.5.7",
+    "next": "^15.2.3",
     "next-auth": "5.0.0-beta.25",
     "postgres": "^3.4.4",
     "react": "^19.0.0",

bench/json5/bun.lock

@@ -1,15 +0,0 @@
-{
-  "lockfileVersion": 1,
-  "configVersion": 1,
-  "workspaces": {
-    "": {
-      "name": "json5-benchmark",
-      "dependencies": {
-        "json5": "^2.2.3",
-      },
-    },
-  },
-  "packages": {
-    "json5": ["json5@2.2.3", "", { "bin": { "json5": "lib/cli.js" } }, "sha512-XmOWe7eyHYH14cLdVPoyg+GOH3rYX++KpzrylJwSW98t3Nk+U8XOl8FWKOgwtzdb8lXGf6zYwDUzeHMWfxasyg=="],
-  }
-}

bench/json5/json5.mjs

@@ -1,88 +0,0 @@
-import JSON5 from "json5";
-import { bench, group, run } from "../runner.mjs";
-
-const isBun = typeof Bun !== "undefined" && Bun.JSON5;
-
-function sizeLabel(n) {
-  if (n >= 1024 * 1024) return `${(n / 1024 / 1024).toFixed(1)}MB`;
-  if (n >= 1024) return `${(n / 1024).toFixed(0)}KB`;
-  return `${n}B`;
-}
-
-// -- parse inputs --
-
-const smallJson5 = `{
-  // User profile
-  name: "John Doe",
-  age: 30,
-  email: 'john@example.com',
-  active: true,
-}`;
-
-function generateLargeJson5(count) {
-  const lines = ["{\n  // Auto-generated dataset\n  items: [\n"];
-  for (let i = 0; i < count; i++) {
-    lines.push(`    {
-      id: ${i},
-      name: 'item_${i}',
-      value: ${(Math.random() * 1000).toFixed(2)},
-      hex: 0x${i.toString(16).toUpperCase()},
-      active: ${i % 2 === 0},
-      tags: ['tag_${i % 10}', 'category_${i % 5}',],
-      // entry ${i}
-    },\n`);
-  }
-  lines.push("  ],\n  total: " + count + ",\n  status: 'complete',\n}\n");
-  return lines.join("");
-}
-
-const largeJson5 = generateLargeJson5(6500);
-
-// -- stringify inputs --
-
-const smallObject = {
-  name: "John Doe",
-  age: 30,
-  email: "john@example.com",
-  active: true,
-};
-
-const largeObject = {
-  items: Array.from({ length: 10000 }, (_, i) => ({
-    id: i,
-    name: `item_${i}`,
-    value: +(Math.random() * 1000).toFixed(2),
-    active: i % 2 === 0,
-    tags: [`tag_${i % 10}`, `category_${i % 5}`],
-  })),
-  total: 10000,
-  status: "complete",
-};
-
-const stringify = isBun ? Bun.JSON5.stringify : JSON5.stringify;
-
-// -- parse benchmarks --
-
-group(`parse small (${sizeLabel(smallJson5.length)})`, () => {
-  if (isBun) bench("Bun.JSON5.parse", () => Bun.JSON5.parse(smallJson5));
-  bench("json5.parse", () => JSON5.parse(smallJson5));
-});
-
-group(`parse large (${sizeLabel(largeJson5.length)})`, () => {
-  if (isBun) bench("Bun.JSON5.parse", () => Bun.JSON5.parse(largeJson5));
-  bench("json5.parse", () => JSON5.parse(largeJson5));
-});
-
-// -- stringify benchmarks --
-
-group(`stringify small (${sizeLabel(stringify(smallObject).length)})`, () => {
-  if (isBun) bench("Bun.JSON5.stringify", () => Bun.JSON5.stringify(smallObject));
-  bench("json5.stringify", () => JSON5.stringify(smallObject));
-});
-
-group(`stringify large (${sizeLabel(stringify(largeObject).length)})`, () => {
-  if (isBun) bench("Bun.JSON5.stringify", () => Bun.JSON5.stringify(largeObject));
-  bench("json5.stringify", () => JSON5.stringify(largeObject));
-});
-
-await run();

bench/json5/package.json

@@ -1,7 +0,0 @@
-{
-  "name": "json5-benchmark",
-  "version": "1.0.0",
-  "dependencies": {
-    "json5": "^2.2.3"
-  }
-}

bench/package.json

@@ -14,18 +14,12 @@
     "fast-glob": "3.3.1",
     "fastify": "^5.0.0",
     "fdir": "^6.1.0",
-    "marked": "^17.0.1",
-    "mitata": "1.0.20",
-    "react": "^19",
-    "react-dom": "^19",
-    "react-markdown": "^9.0.3",
-    "remark": "^15.0.1",
-    "remark-html": "^16.0.1",
+    "mitata": "^1.0.25",
+    "react": "^18.3.1",
+    "react-dom": "^18.3.1",
     "string-width": "7.1.0",
     "strip-ansi": "^7.1.0",
-    "tar": "^7.4.3",
     "tinycolor2": "^1.6.0",
-    "wrap-ansi": "^9.0.0",
     "zx": "^7.2.3"
   },
   "scripts": {

bench/runner.mjs

@@ -14,4 +14,3 @@ export function run(opts = {}) {
 
 export const bench = Mitata.bench;
 export const group = Mitata.group;
-export const summary = Mitata.summary;

bench/snippets/archive.mjs

@@ -1,477 +0,0 @@
-import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { Pack, Unpack } from "tar";
-import { bench, group, run } from "../runner.mjs";
-
-// Check if Bun.Archive is available
-const hasBunArchive = typeof Bun !== "undefined" && typeof Bun.Archive !== "undefined";
-
-// Test data sizes
-const smallContent = "Hello, World!";
-const mediumContent = Buffer.alloc(10 * 1024, "x").toString(); // 10KB
-const largeContent = Buffer.alloc(100 * 1024, "x").toString(); // 100KB
-
-// Create test files for node-tar (it reads from filesystem)
-const setupDir = mkdtempSync(join(tmpdir(), "archive-bench-setup-"));
-
-function setupNodeTarFiles(prefix, files) {
-  const dir = join(setupDir, prefix);
-  mkdirSync(dir, { recursive: true });
-  for (const [name, content] of Object.entries(files)) {
-    const filePath = join(dir, name);
-    const fileDir = join(filePath, "..");
-    mkdirSync(fileDir, { recursive: true });
-    writeFileSync(filePath, content);
-  }
-  return dir;
-}
-
-// Setup directories for different test cases
-const smallFilesDir = setupNodeTarFiles("small", {
-  "file1.txt": smallContent,
-  "file2.txt": smallContent,
-  "file3.txt": smallContent,
-});
-
-const mediumFilesDir = setupNodeTarFiles("medium", {
-  "file1.txt": mediumContent,
-  "file2.txt": mediumContent,
-  "file3.txt": mediumContent,
-});
-
-const largeFilesDir = setupNodeTarFiles("large", {
-  "file1.txt": largeContent,
-  "file2.txt": largeContent,
-  "file3.txt": largeContent,
-});
-
-const manyFilesEntries = {};
-for (let i = 0; i < 100; i++) {
-  manyFilesEntries[`file${i}.txt`] = smallContent;
-}
-const manyFilesDir = setupNodeTarFiles("many", manyFilesEntries);
-
-// Pre-create archives for extraction benchmarks
-let smallTarGzBuffer, mediumTarGzBuffer, largeTarGzBuffer, manyFilesTarGzBuffer;
-let smallTarBuffer, mediumTarBuffer, largeTarBuffer, manyFilesTarBuffer;
-let smallBunArchiveGz, mediumBunArchiveGz, largeBunArchiveGz, manyFilesBunArchiveGz;
-let smallBunArchive, mediumBunArchive, largeBunArchive, manyFilesBunArchive;
-
-// Create tar buffer using node-tar (with optional gzip)
-async function createNodeTarBuffer(cwd, files, gzip = false) {
-  return new Promise(resolve => {
-    const pack = new Pack({ cwd, gzip });
-    const bufs = [];
-    pack.on("data", chunk => bufs.push(chunk));
-    pack.on("end", () => resolve(Buffer.concat(bufs)));
-    for (const file of files) {
-      pack.add(file);
-    }
-    pack.end();
-  });
-}
-
-// Extract tar buffer using node-tar
-async function extractNodeTarBuffer(buffer, cwd) {
-  return new Promise((resolve, reject) => {
-    const unpack = new Unpack({ cwd });
-    unpack.on("end", resolve);
-    unpack.on("error", reject);
-    unpack.end(buffer);
-  });
-}
-
-// Initialize gzipped archives
-smallTarGzBuffer = await createNodeTarBuffer(smallFilesDir, ["file1.txt", "file2.txt", "file3.txt"], true);
-mediumTarGzBuffer = await createNodeTarBuffer(mediumFilesDir, ["file1.txt", "file2.txt", "file3.txt"], true);
-largeTarGzBuffer = await createNodeTarBuffer(largeFilesDir, ["file1.txt", "file2.txt", "file3.txt"], true);
-manyFilesTarGzBuffer = await createNodeTarBuffer(manyFilesDir, Object.keys(manyFilesEntries), true);
-
-// Initialize uncompressed archives
-smallTarBuffer = await createNodeTarBuffer(smallFilesDir, ["file1.txt", "file2.txt", "file3.txt"], false);
-mediumTarBuffer = await createNodeTarBuffer(mediumFilesDir, ["file1.txt", "file2.txt", "file3.txt"], false);
-largeTarBuffer = await createNodeTarBuffer(largeFilesDir, ["file1.txt", "file2.txt", "file3.txt"], false);
-manyFilesTarBuffer = await createNodeTarBuffer(manyFilesDir, Object.keys(manyFilesEntries), false);
-
-const smallFiles = { "file1.txt": smallContent, "file2.txt": smallContent, "file3.txt": smallContent };
-const mediumFiles = { "file1.txt": mediumContent, "file2.txt": mediumContent, "file3.txt": mediumContent };
-const largeFiles = { "file1.txt": largeContent, "file2.txt": largeContent, "file3.txt": largeContent };
-
-if (hasBunArchive) {
-  smallBunArchiveGz = await Bun.Archive.from(smallFiles).bytes("gzip");
-  mediumBunArchiveGz = await Bun.Archive.from(mediumFiles).bytes("gzip");
-  largeBunArchiveGz = await Bun.Archive.from(largeFiles).bytes("gzip");
-  manyFilesBunArchiveGz = await Bun.Archive.from(manyFilesEntries).bytes("gzip");
-
-  smallBunArchive = await Bun.Archive.from(smallFiles).bytes();
-  mediumBunArchive = await Bun.Archive.from(mediumFiles).bytes();
-  largeBunArchive = await Bun.Archive.from(largeFiles).bytes();
-  manyFilesBunArchive = await Bun.Archive.from(manyFilesEntries).bytes();
-}
-
-// Create reusable extraction directories (overwriting is fine)
-const extractDirNodeTar = mkdtempSync(join(tmpdir(), "archive-bench-extract-node-"));
-const extractDirBun = mkdtempSync(join(tmpdir(), "archive-bench-extract-bun-"));
-const writeDirNodeTar = mkdtempSync(join(tmpdir(), "archive-bench-write-node-"));
-const writeDirBun = mkdtempSync(join(tmpdir(), "archive-bench-write-bun-"));
-
-// ============================================================================
-// Create .tar (uncompressed) benchmarks
-// ============================================================================
-
-group("create .tar (3 small files)", () => {
-  bench("node-tar", async () => {
-    await createNodeTarBuffer(smallFilesDir, ["file1.txt", "file2.txt", "file3.txt"], false);
-  });
-
-  if (hasBunArchive) {
-    bench("Bun.Archive", async () => {
-      await Bun.Archive.from(smallFiles).bytes();
-    });
-  }
-});
-
-group("create .tar (3 x 100KB files)", () => {
-  bench("node-tar", async () => {
-    await createNodeTarBuffer(largeFilesDir, ["file1.txt", "file2.txt", "file3.txt"], false);
-  });
-
-  if (hasBunArchive) {
-    bench("Bun.Archive", async () => {
-      await Bun.Archive.from(largeFiles).bytes();
-    });
-  }
-});
-
-group("create .tar (100 small files)", () => {
-  bench("node-tar", async () => {
-    await createNodeTarBuffer(manyFilesDir, Object.keys(manyFilesEntries), false);
-  });
-
-  if (hasBunArchive) {
-    bench("Bun.Archive", async () => {
-      await Bun.Archive.from(manyFilesEntries).bytes();
-    });
-  }
-});
-
-// ============================================================================
-// Create .tar.gz (compressed) benchmarks
-// ============================================================================
-
-group("create .tar.gz (3 small files)", () => {
-  bench("node-tar", async () => {
-    await createNodeTarBuffer(smallFilesDir, ["file1.txt", "file2.txt", "file3.txt"], true);
-  });
-
-  if (hasBunArchive) {
-    bench("Bun.Archive", async () => {
-      await Bun.Archive.from(smallFiles).bytes("gzip");
-    });
-  }
-});
-
-group("create .tar.gz (3 x 100KB files)", () => {
-  bench("node-tar", async () => {
-    await createNodeTarBuffer(largeFilesDir, ["file1.txt", "file2.txt", "file3.txt"], true);
-  });
-
-  if (hasBunArchive) {
-    bench("Bun.Archive", async () => {
-      await Bun.Archive.from(largeFiles).bytes("gzip");
-    });
-  }
-});
-
-group("create .tar.gz (100 small files)", () => {
-  bench("node-tar", async () => {
-    await createNodeTarBuffer(manyFilesDir, Object.keys(manyFilesEntries), true);
-  });
-
-  if (hasBunArchive) {
-    bench("Bun.Archive", async () => {
-      await Bun.Archive.from(manyFilesEntries).bytes("gzip");
-    });
-  }
-});
-
-// ============================================================================
-// Extract .tar (uncompressed) benchmarks
-// ============================================================================
-
-group("extract .tar (3 small files)", () => {
-  bench("node-tar", async () => {
-    await extractNodeTarBuffer(smallTarBuffer, extractDirNodeTar);
-  });
-
-  if (hasBunArchive) {
-    bench("Bun.Archive", async () => {
-      await Bun.Archive.from(smallBunArchive).extract(extractDirBun);
-    });
-  }
-});
-
-group("extract .tar (3 x 100KB files)", () => {
-  bench("node-tar", async () => {
-    await extractNodeTarBuffer(largeTarBuffer, extractDirNodeTar);
-  });
-
-  if (hasBunArchive) {
-    bench("Bun.Archive", async () => {
-      await Bun.Archive.from(largeBunArchive).extract(extractDirBun);
-    });
-  }
-});
-
-group("extract .tar (100 small files)", () => {
-  bench("node-tar", async () => {
-    await extractNodeTarBuffer(manyFilesTarBuffer, extractDirNodeTar);
-  });
-
-  if (hasBunArchive) {
-    bench("Bun.Archive", async () => {
-      await Bun.Archive.from(manyFilesBunArchive).extract(extractDirBun);
-    });
-  }
-});
-
-// ============================================================================
-// Extract .tar.gz (compressed) benchmarks
-// ============================================================================
-
-group("extract .tar.gz (3 small files)", () => {
-  bench("node-tar", async () => {
-    await extractNodeTarBuffer(smallTarGzBuffer, extractDirNodeTar);
-  });
-
-  if (hasBunArchive) {
-    bench("Bun.Archive", async () => {
-      await Bun.Archive.from(smallBunArchiveGz).extract(extractDirBun);
-    });
-  }
-});
-
-group("extract .tar.gz (3 x 100KB files)", () => {
-  bench("node-tar", async () => {
-    await extractNodeTarBuffer(largeTarGzBuffer, extractDirNodeTar);
-  });
-
-  if (hasBunArchive) {
-    bench("Bun.Archive", async () => {
-      await Bun.Archive.from(largeBunArchiveGz).extract(extractDirBun);
-    });
-  }
-});
-
-group("extract .tar.gz (100 small files)", () => {
-  bench("node-tar", async () => {
-    await extractNodeTarBuffer(manyFilesTarGzBuffer, extractDirNodeTar);
-  });
-
-  if (hasBunArchive) {
-    bench("Bun.Archive", async () => {
-      await Bun.Archive.from(manyFilesBunArchiveGz).extract(extractDirBun);
-    });
-  }
-});
-
-// ============================================================================
-// Write .tar to disk benchmarks
-// ============================================================================
-
-let writeCounter = 0;
-
-group("write .tar to disk (3 small files)", () => {
-  bench("node-tar + writeFileSync", async () => {
-    const buffer = await createNodeTarBuffer(smallFilesDir, ["file1.txt", "file2.txt", "file3.txt"], false);
-    writeFileSync(join(writeDirNodeTar, `archive-${writeCounter++}.tar`), buffer);
-  });
-
-  if (hasBunArchive) {
-    bench("Bun.Archive.write", async () => {
-      await Bun.Archive.write(join(writeDirBun, `archive-${writeCounter++}.tar`), smallFiles);
-    });
-  }
-});
-
-group("write .tar to disk (3 x 100KB files)", () => {
-  bench("node-tar + writeFileSync", async () => {
-    const buffer = await createNodeTarBuffer(largeFilesDir, ["file1.txt", "file2.txt", "file3.txt"], false);
-    writeFileSync(join(writeDirNodeTar, `archive-${writeCounter++}.tar`), buffer);
-  });
-
-  if (hasBunArchive) {
-    bench("Bun.Archive.write", async () => {
-      await Bun.Archive.write(join(writeDirBun, `archive-${writeCounter++}.tar`), largeFiles);
-    });
-  }
-});
-
-group("write .tar to disk (100 small files)", () => {
-  bench("node-tar + writeFileSync", async () => {
-    const buffer = await createNodeTarBuffer(manyFilesDir, Object.keys(manyFilesEntries), false);
-    writeFileSync(join(writeDirNodeTar, `archive-${writeCounter++}.tar`), buffer);
-  });
-
-  if (hasBunArchive) {
-    bench("Bun.Archive.write", async () => {
-      await Bun.Archive.write(join(writeDirBun, `archive-${writeCounter++}.tar`), manyFilesEntries);
-    });
-  }
-});
-
-// ============================================================================
-// Write .tar.gz to disk benchmarks
-// ============================================================================
-
-group("write .tar.gz to disk (3 small files)", () => {
-  bench("node-tar + writeFileSync", async () => {
-    const buffer = await createNodeTarBuffer(smallFilesDir, ["file1.txt", "file2.txt", "file3.txt"], true);
-    writeFileSync(join(writeDirNodeTar, `archive-${writeCounter++}.tar.gz`), buffer);
-  });
-
-  if (hasBunArchive) {
-    bench("Bun.Archive.write", async () => {
-      await Bun.Archive.write(join(writeDirBun, `archive-${writeCounter++}.tar.gz`), smallFiles, "gzip");
-    });
-  }
-});
-
-group("write .tar.gz to disk (3 x 100KB files)", () => {
-  bench("node-tar + writeFileSync", async () => {
-    const buffer = await createNodeTarBuffer(largeFilesDir, ["file1.txt", "file2.txt", "file3.txt"], true);
-    writeFileSync(join(writeDirNodeTar, `archive-${writeCounter++}.tar.gz`), buffer);
-  });
-
-  if (hasBunArchive) {
-    bench("Bun.Archive.write", async () => {
-      await Bun.Archive.write(join(writeDirBun, `archive-${writeCounter++}.tar.gz`), largeFiles, "gzip");
-    });
-  }
-});
-
-group("write .tar.gz to disk (100 small files)", () => {
-  bench("node-tar + writeFileSync", async () => {
-    const buffer = await createNodeTarBuffer(manyFilesDir, Object.keys(manyFilesEntries), true);
-    writeFileSync(join(writeDirNodeTar, `archive-${writeCounter++}.tar.gz`), buffer);
-  });
-
-  if (hasBunArchive) {
-    bench("Bun.Archive.write", async () => {
-      await Bun.Archive.write(join(writeDirBun, `archive-${writeCounter++}.tar.gz`), manyFilesEntries, "gzip");
-    });
-  }
-});
-
-// ============================================================================
-// Get files array from archive (files() method) benchmarks
-// ============================================================================
-
-// Helper to get files array from node-tar (reads all entries into memory)
-async function getFilesArrayNodeTar(buffer) {
-  return new Promise((resolve, reject) => {
-    const files = new Map();
-    let pending = 0;
-    let closed = false;
-
-    const maybeResolve = () => {
-      if (closed && pending === 0) {
-        resolve(files);
-      }
-    };
-
-    const unpack = new Unpack({
-      onReadEntry: entry => {
-        if (entry.type === "File") {
-          pending++;
-          const chunks = [];
-          entry.on("data", chunk => chunks.push(chunk));
-          entry.on("end", () => {
-            const content = Buffer.concat(chunks);
-            // Create a File-like object similar to Bun.Archive.files()
-            files.set(entry.path, new Blob([content]));
-            pending--;
-            maybeResolve();
-          });
-        }
-        entry.resume(); // Drain the entry
-      },
-    });
-    unpack.on("close", () => {
-      closed = true;
-      maybeResolve();
-    });
-    unpack.on("error", reject);
-    unpack.end(buffer);
-  });
-}
-
-group("files() - get all files as Map (3 small files)", () => {
-  bench("node-tar", async () => {
-    await getFilesArrayNodeTar(smallTarBuffer);
-  });
-
-  if (hasBunArchive) {
-    bench("Bun.Archive.files()", async () => {
-      await Bun.Archive.from(smallBunArchive).files();
-    });
-  }
-});
-
-group("files() - get all files as Map (3 x 100KB files)", () => {
-  bench("node-tar", async () => {
-    await getFilesArrayNodeTar(largeTarBuffer);
-  });
-
-  if (hasBunArchive) {
-    bench("Bun.Archive.files()", async () => {
-      await Bun.Archive.from(largeBunArchive).files();
-    });
-  }
-});
-
-group("files() - get all files as Map (100 small files)", () => {
-  bench("node-tar", async () => {
-    await getFilesArrayNodeTar(manyFilesTarBuffer);
-  });
-
-  if (hasBunArchive) {
-    bench("Bun.Archive.files()", async () => {
-      await Bun.Archive.from(manyFilesBunArchive).files();
-    });
-  }
-});
-
-group("files() - get all files as Map from .tar.gz (3 small files)", () => {
-  bench("node-tar", async () => {
-    await getFilesArrayNodeTar(smallTarGzBuffer);
-  });
-
-  if (hasBunArchive) {
-    bench("Bun.Archive.files()", async () => {
-      await Bun.Archive.from(smallBunArchiveGz).files();
-    });
-  }
-});
-
-group("files() - get all files as Map from .tar.gz (100 small files)", () => {
-  bench("node-tar", async () => {
-    await getFilesArrayNodeTar(manyFilesTarGzBuffer);
-  });
-
-  if (hasBunArchive) {
-    bench("Bun.Archive.files()", async () => {
-      await Bun.Archive.from(manyFilesBunArchiveGz).files();
-    });
-  }
-});
-
-await run();
-
-// Cleanup
-rmSync(setupDir, { recursive: true, force: true });
-rmSync(extractDirNodeTar, { recursive: true, force: true });
-rmSync(extractDirBun, { recursive: true, force: true });
-rmSync(writeDirNodeTar, { recursive: true, force: true });
-rmSync(writeDirBun, { recursive: true, force: true });

bench/snippets/array-of.js

@@ -1,335 +0,0 @@
-import { bench, run } from "../runner.mjs";
-
-let sink;
-
-// Integers
-bench("int: Array.of(1,2,3,4,5)", () => {
-  sink = Array.of(1, 2, 3, 4, 5);
-});
-
-bench("int: Array.of(100 elements)", () => {
-  sink = Array.of(
-    0,
-    1,
-    2,
-    3,
-    4,
-    5,
-    6,
-    7,
-    8,
-    9,
-    10,
-    11,
-    12,
-    13,
-    14,
-    15,
-    16,
-    17,
-    18,
-    19,
-    20,
-    21,
-    22,
-    23,
-    24,
-    25,
-    26,
-    27,
-    28,
-    29,
-    30,
-    31,
-    32,
-    33,
-    34,
-    35,
-    36,
-    37,
-    38,
-    39,
-    40,
-    41,
-    42,
-    43,
-    44,
-    45,
-    46,
-    47,
-    48,
-    49,
-    50,
-    51,
-    52,
-    53,
-    54,
-    55,
-    56,
-    57,
-    58,
-    59,
-    60,
-    61,
-    62,
-    63,
-    64,
-    65,
-    66,
-    67,
-    68,
-    69,
-    70,
-    71,
-    72,
-    73,
-    74,
-    75,
-    76,
-    77,
-    78,
-    79,
-    80,
-    81,
-    82,
-    83,
-    84,
-    85,
-    86,
-    87,
-    88,
-    89,
-    90,
-    91,
-    92,
-    93,
-    94,
-    95,
-    96,
-    97,
-    98,
-    99,
-  );
-});
-
-// Doubles
-bench("double: Array.of(1.1,2.2,3.3,4.4,5.5)", () => {
-  sink = Array.of(1.1, 2.2, 3.3, 4.4, 5.5);
-});
-
-bench("double: Array.of(100 elements)", () => {
-  sink = Array.of(
-    0.1,
-    1.1,
-    2.1,
-    3.1,
-    4.1,
-    5.1,
-    6.1,
-    7.1,
-    8.1,
-    9.1,
-    10.1,
-    11.1,
-    12.1,
-    13.1,
-    14.1,
-    15.1,
-    16.1,
-    17.1,
-    18.1,
-    19.1,
-    20.1,
-    21.1,
-    22.1,
-    23.1,
-    24.1,
-    25.1,
-    26.1,
-    27.1,
-    28.1,
-    29.1,
-    30.1,
-    31.1,
-    32.1,
-    33.1,
-    34.1,
-    35.1,
-    36.1,
-    37.1,
-    38.1,
-    39.1,
-    40.1,
-    41.1,
-    42.1,
-    43.1,
-    44.1,
-    45.1,
-    46.1,
-    47.1,
-    48.1,
-    49.1,
-    50.1,
-    51.1,
-    52.1,
-    53.1,
-    54.1,
-    55.1,
-    56.1,
-    57.1,
-    58.1,
-    59.1,
-    60.1,
-    61.1,
-    62.1,
-    63.1,
-    64.1,
-    65.1,
-    66.1,
-    67.1,
-    68.1,
-    69.1,
-    70.1,
-    71.1,
-    72.1,
-    73.1,
-    74.1,
-    75.1,
-    76.1,
-    77.1,
-    78.1,
-    79.1,
-    80.1,
-    81.1,
-    82.1,
-    83.1,
-    84.1,
-    85.1,
-    86.1,
-    87.1,
-    88.1,
-    89.1,
-    90.1,
-    91.1,
-    92.1,
-    93.1,
-    94.1,
-    95.1,
-    96.1,
-    97.1,
-    98.1,
-    99.1,
-  );
-});
-
-// Objects
-bench("object: Array.of(obj x5)", () => {
-  sink = Array.of({ a: 1 }, { a: 2 }, { a: 3 }, { a: 4 }, { a: 5 });
-});
-
-bench("object: Array.of(100 elements)", () => {
-  sink = Array.of(
-    { a: 0 },
-    { a: 1 },
-    { a: 2 },
-    { a: 3 },
-    { a: 4 },
-    { a: 5 },
-    { a: 6 },
-    { a: 7 },
-    { a: 8 },
-    { a: 9 },
-    { a: 10 },
-    { a: 11 },
-    { a: 12 },
-    { a: 13 },
-    { a: 14 },
-    { a: 15 },
-    { a: 16 },
-    { a: 17 },
-    { a: 18 },
-    { a: 19 },
-    { a: 20 },
-    { a: 21 },
-    { a: 22 },
-    { a: 23 },
-    { a: 24 },
-    { a: 25 },
-    { a: 26 },
-    { a: 27 },
-    { a: 28 },
-    { a: 29 },
-    { a: 30 },
-    { a: 31 },
-    { a: 32 },
-    { a: 33 },
-    { a: 34 },
-    { a: 35 },
-    { a: 36 },
-    { a: 37 },
-    { a: 38 },
-    { a: 39 },
-    { a: 40 },
-    { a: 41 },
-    { a: 42 },
-    { a: 43 },
-    { a: 44 },
-    { a: 45 },
-    { a: 46 },
-    { a: 47 },
-    { a: 48 },
-    { a: 49 },
-    { a: 50 },
-    { a: 51 },
-    { a: 52 },
-    { a: 53 },
-    { a: 54 },
-    { a: 55 },
-    { a: 56 },
-    { a: 57 },
-    { a: 58 },
-    { a: 59 },
-    { a: 60 },
-    { a: 61 },
-    { a: 62 },
-    { a: 63 },
-    { a: 64 },
-    { a: 65 },
-    { a: 66 },
-    { a: 67 },
-    { a: 68 },
-    { a: 69 },
-    { a: 70 },
-    { a: 71 },
-    { a: 72 },
-    { a: 73 },
-    { a: 74 },
-    { a: 75 },
-    { a: 76 },
-    { a: 77 },
-    { a: 78 },
-    { a: 79 },
-    { a: 80 },
-    { a: 81 },
-    { a: 82 },
-    { a: 83 },
-    { a: 84 },
-    { a: 85 },
-    { a: 86 },
-    { a: 87 },
-    { a: 88 },
-    { a: 89 },
-    { a: 90 },
-    { a: 91 },
-    { a: 92 },
-    { a: 93 },
-    { a: 94 },
-    { a: 95 },
-    { a: 96 },
-    { a: 97 },
-    { a: 98 },
-    { a: 99 },
-  );
-});
-
-await run();

bench/snippets/buffer-from-array.mjs

@@ -1,38 +0,0 @@
-// @runtime bun,node
-import { Buffer } from "node:buffer";
-import { bench, group, run } from "../runner.mjs";
-
-// Small arrays (common case)
-const int32Array8 = [1, 2, 3, 4, 5, 6, 7, 8];
-const doubleArray8 = [1.5, 2.5, 3.5, 4.5, 5.5, 6.5, 7.5, 8.5];
-
-// Medium arrays
-const int32Array64 = Array.from({ length: 64 }, (_, i) => i % 256);
-const doubleArray64 = Array.from({ length: 64 }, (_, i) => i + 0.5);
-
-// Large arrays
-const int32Array1024 = Array.from({ length: 1024 }, (_, i) => i % 256);
-
-// Array-like objects (fallback path)
-const arrayLike8 = { 0: 1, 1: 2, 2: 3, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, length: 8 };
-
-// Empty array
-const emptyArray = [];
-
-group("Buffer.from(array) - Int32 arrays", () => {
-  bench("Buffer.from(int32[8])", () => Buffer.from(int32Array8));
-  bench("Buffer.from(int32[64])", () => Buffer.from(int32Array64));
-  bench("Buffer.from(int32[1024])", () => Buffer.from(int32Array1024));
-});
-
-group("Buffer.from(array) - Double arrays", () => {
-  bench("Buffer.from(double[8])", () => Buffer.from(doubleArray8));
-  bench("Buffer.from(double[64])", () => Buffer.from(doubleArray64));
-});
-
-group("Buffer.from(array) - Edge cases", () => {
-  bench("Buffer.from([])", () => Buffer.from(emptyArray));
-  bench("Buffer.from(arrayLike[8])", () => Buffer.from(arrayLike8));
-});
-
-await run();

bench/snippets/ipc-json-child.mjs

@@ -1,4 +0,0 @@
-// Child process for IPC benchmarks - echoes messages back to parent
-process.on("message", message => {
-  process.send(message);
-});

bench/snippets/ipc-json.mjs

@@ -1,45 +0,0 @@
-import { fork } from "node:child_process";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-import { bench, run } from "../runner.mjs";
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const childPath = path.join(__dirname, "ipc-json-child.mjs");
-
-const smallMessage = { type: "ping", id: 1 };
-const largeString = Buffer.alloc(10 * 1024 * 1024, "A").toString();
-const largeMessage = { type: "ping", id: 1, data: largeString };
-
-async function runBenchmark(message, count) {
-  let received = 0;
-  const { promise, resolve } = Promise.withResolvers();
-
-  const child = fork(childPath, [], {
-    stdio: ["ignore", "ignore", "ignore", "ipc"],
-    serialization: "json",
-  });
-
-  child.on("message", () => {
-    received++;
-    if (received >= count) {
-      resolve();
-    }
-  });
-
-  for (let i = 0; i < count; i++) {
-    child.send(message);
-  }
-
-  await promise;
-  child.kill();
-}
-
-bench("ipc json - small messages (1000 roundtrips)", async () => {
-  await runBenchmark(smallMessage, 1000);
-});
-
-bench("ipc json - 10MB messages (10 roundtrips)", async () => {
-  await runBenchmark(largeMessage, 10);
-});
-
-await run();

bench/snippets/markdown-react.mjs

@@ -1,92 +0,0 @@
-import React from "react";
-import { renderToString } from "react-dom/server";
-import ReactMarkdown from "react-markdown";
-
-const markdown = `# Project README
-
-## Introduction
-
-This is a medium-sized markdown document that includes **bold text**, *italic text*,
-and \`inline code\`. It also has [links](https://example.com) and various formatting.
-
-## Features
-
-- Feature one with **bold**
-- Feature two with *emphasis*
-- Feature three with \`code\`
-- Feature four with [a link](https://example.com)
-
-## Code Example
-
-\`\`\`javascript
-function hello() {
-  console.log("Hello, world!");
-  return 42;
-}
-
-const result = hello();
-\`\`\`
-
-## Table
-
-| Name | Value | Description |
-|------|-------|-------------|
-| foo  | 1     | First item  |
-| bar  | 2     | Second item |
-| baz  | 3     | Third item  |
-
-## Blockquote
-
-> This is a blockquote with **bold** and *italic* text.
-> It spans multiple lines and contains a [link](https://example.com).
-
----
-
-### Nested Lists
-
-1. First ordered item
-   - Nested unordered
-   - Another nested
-2. Second ordered item
-   1. Nested ordered
-   2. Another nested
-3. Third ordered item
-
-Some final paragraph with ~~strikethrough~~ text and more **formatting**.
-`;
-
-// Verify outputs are roughly the same
-const bunHtml = renderToString(Bun.markdown.react(markdown));
-const reactMarkdownHtml = renderToString(React.createElement(ReactMarkdown, { children: markdown }));
-
-console.log("=== Bun.markdown.react output ===");
-console.log(bunHtml.slice(0, 500));
-console.log(`... (${bunHtml.length} chars total)\n`);
-
-console.log("=== react-markdown output ===");
-console.log(reactMarkdownHtml.slice(0, 500));
-console.log(`... (${reactMarkdownHtml.length} chars total)\n`);
-
-const server = Bun.serve({
-  port: 0,
-  routes: {
-    "/bun-markdown": () => {
-      return new Response(renderToString(Bun.markdown.react(markdown)), {
-        headers: { "Content-Type": "text/html" },
-      });
-    },
-    "/react-markdown": () => {
-      return new Response(renderToString(React.createElement(ReactMarkdown, { children: markdown })), {
-        headers: { "Content-Type": "text/html" },
-      });
-    },
-  },
-});
-
-console.log(`Server listening on ${server.url}`);
-console.log(`  ${server.url}bun-markdown`);
-console.log(`  ${server.url}react-markdown`);
-console.log();
-console.log("Run:");
-console.log(`  oha -c 20 -z 5s ${server.url}bun-markdown`);
-console.log(`  oha -c 20 -z 5s ${server.url}react-markdown`);

bench/snippets/markdown.mjs

@@ -1,159 +0,0 @@
-import { marked } from "marked";
-import { remark } from "remark";
-import remarkHtml from "remark-html";
-import { bench, run, summary } from "../runner.mjs";
-
-const remarkProcessor = remark().use(remarkHtml);
-
-const small = `# Hello World
-
-This is a **bold** and *italic* paragraph with a [link](https://example.com).
-
-- Item 1
-- Item 2
-- Item 3
-`;
-
-const medium = `# Project README
-
-## Introduction
-
-This is a medium-sized markdown document that includes **bold text**, *italic text*,
-and \`inline code\`. It also has [links](https://example.com) and various formatting.
-
-## Features
-
-- Feature one with **bold**
-- Feature two with *emphasis*
-- Feature three with \`code\`
-- Feature four with [a link](https://example.com)
-
-## Code Example
-
-\`\`\`javascript
-function hello() {
-  console.log("Hello, world!");
-  return 42;
-}
-
-const result = hello();
-\`\`\`
-
-## Table
-
-| Name | Value | Description |
-|------|-------|-------------|
-| foo  | 1     | First item  |
-| bar  | 2     | Second item |
-| baz  | 3     | Third item  |
-
-## Blockquote
-
-> This is a blockquote with **bold** and *italic* text.
-> It spans multiple lines and contains a [link](https://example.com).
-
----
-
-### Nested Lists
-
-1. First ordered item
-   - Nested unordered
-   - Another nested
-2. Second ordered item
-   1. Nested ordered
-   2. Another nested
-3. Third ordered item
-
-Some final paragraph with ~~strikethrough~~ text and more **formatting**.
-`;
-
-const large = medium.repeat(20);
-
-const renderCallbacks = {
-  heading: (children, { level }) => `<h${level}>${children}</h${level}>`,
-  paragraph: children => `<p>${children}</p>`,
-  strong: children => `<strong>${children}</strong>`,
-  emphasis: children => `<em>${children}</em>`,
-  codespan: children => `<code>${children}</code>`,
-  code: (children, { language }) =>
-    language
-      ? `<pre><code class="language-${language}">${children}</code></pre>`
-      : `<pre><code>${children}</code></pre>`,
-  link: (children, { href, title }) =>
-    title ? `<a href="${href}" title="${title}">${children}</a>` : `<a href="${href}">${children}</a>`,
-  image: (children, { src, title }) =>
-    title ? `<img src="${src}" alt="${children}" title="${title}" />` : `<img src="${src}" alt="${children}" />`,
-  list: (children, { ordered, start }) => (ordered ? `<ol start="${start}">${children}</ol>` : `<ul>${children}</ul>`),
-  listItem: children => `<li>${children}</li>`,
-  blockquote: children => `<blockquote>${children}</blockquote>`,
-  hr: () => `<hr />`,
-  strikethrough: children => `<del>${children}</del>`,
-  table: children => `<table>${children}</table>`,
-  thead: children => `<thead>${children}</thead>`,
-  tbody: children => `<tbody>${children}</tbody>`,
-  tr: children => `<tr>${children}</tr>`,
-  th: children => `<th>${children}</th>`,
-  td: children => `<td>${children}</td>`,
-};
-
-summary(() => {
-  if (typeof Bun !== "undefined" && Bun.markdown) {
-    bench(`small (${small.length} chars) - Bun.markdown.html`, () => {
-      return Bun.markdown.html(small);
-    });
-
-    bench(`small (${small.length} chars) - Bun.markdown.render`, () => {
-      return Bun.markdown.render(small, renderCallbacks);
-    });
-  }
-
-  bench(`small (${small.length} chars) - marked`, () => {
-    return marked(small);
-  });
-
-  bench(`small (${small.length} chars) - remark`, () => {
-    return remarkProcessor.processSync(small).toString();
-  });
-});
-
-summary(() => {
-  if (typeof Bun !== "undefined" && Bun.markdown) {
-    bench(`medium (${medium.length} chars) - Bun.markdown.html`, () => {
-      return Bun.markdown.html(medium);
-    });
-
-    bench(`medium (${medium.length} chars) - Bun.markdown.render`, () => {
-      return Bun.markdown.render(medium, renderCallbacks);
-    });
-  }
-
-  bench(`medium (${medium.length} chars) - marked`, () => {
-    return marked(medium);
-  });
-
-  bench(`medium (${medium.length} chars) - remark`, () => {
-    return remarkProcessor.processSync(medium).toString();
-  });
-});
-
-summary(() => {
-  if (typeof Bun !== "undefined" && Bun.markdown) {
-    bench(`large (${large.length} chars) - Bun.markdown.html`, () => {
-      return Bun.markdown.html(large);
-    });
-
-    bench(`large (${large.length} chars) - Bun.markdown.render`, () => {
-      return Bun.markdown.render(large, renderCallbacks);
-    });
-  }
-
-  bench(`large (${large.length} chars) - marked`, () => {
-    return marked(large);
-  });
-
-  bench(`large (${large.length} chars) - remark`, () => {
-    return remarkProcessor.processSync(large).toString();
-  });
-});
-
-await run();

bench/snippets/object-hasown.mjs

@@ -1,57 +0,0 @@
-import { bench, run } from "../runner.mjs";
-
-const obj = { a: 1, b: 2, c: 3 };
-const objDeep = { a: 1, b: 2, c: 3, d: 4, e: 5, f: 6, g: 7, h: 8 };
-const sym = Symbol("test");
-const objWithSymbol = { [sym]: 1, a: 2 };
-
-const objs = [
-  { f: 50 },
-  { f: 50, g: 70 },
-  { g: 50, f: 70 },
-  { h: 50, f: 70 },
-  { z: 50, f: 70 },
-  { k: 50, f: 70 },
-];
-
-bench("Object.hasOwn - hit", () => {
-  return Object.hasOwn(obj, "a");
-});
-
-bench("Object.hasOwn - miss", () => {
-  return Object.hasOwn(obj, "z");
-});
-
-bench("Object.hasOwn - symbol hit", () => {
-  return Object.hasOwn(objWithSymbol, sym);
-});
-
-bench("Object.hasOwn - symbol miss", () => {
-  return Object.hasOwn(objWithSymbol, Symbol("other"));
-});
-
-bench("Object.hasOwn - multiple shapes", () => {
-  let result = true;
-  for (let i = 0; i < objs.length; i++) {
-    result = Object.hasOwn(objs[i], "f") && result;
-  }
-  return result;
-});
-
-bench("Object.prototype.hasOwnProperty - hit", () => {
-  return obj.hasOwnProperty("a");
-});
-
-bench("Object.prototype.hasOwnProperty - miss", () => {
-  return obj.hasOwnProperty("z");
-});
-
-bench("in operator - hit", () => {
-  return "a" in obj;
-});
-
-bench("in operator - miss", () => {
-  return "z" in obj;
-});
-
-await run();

bench/snippets/promise-race.mjs

@@ -1,7 +0,0 @@
-import { bench, run } from "../runner.mjs";
-
-bench("Promise.race([p1, p2])", async function () {
-  return await Promise.race([Promise.resolve(1), Promise.resolve(2)]);
-});
-
-await run();

bench/snippets/response-json.mjs

@@ -112,40 +112,12 @@ const obj = {
   },
 };
 
-const smallObj = { id: 1, name: "test" };
-
-const arrayObj = {
-  items: Array.from({ length: 100 }, (_, i) => ({ id: i, value: `item-${i}` })),
-};
-
-bench("Response.json(obj)", () => {
+bench("Response.json(obj)", async () => {
   return Response.json(obj);
 });
 
-bench("new Response(JSON.stringify(obj))", () => {
-  return new Response(JSON.stringify(obj), {
-    headers: { "Content-Type": "application/json" },
-  });
-});
-
-bench("Response.json(smallObj)", () => {
-  return Response.json(smallObj);
-});
-
-bench("new Response(JSON.stringify(smallObj))", () => {
-  return new Response(JSON.stringify(smallObj), {
-    headers: { "Content-Type": "application/json" },
-  });
-});
-
-bench("Response.json(arrayObj)", () => {
-  return Response.json(arrayObj);
-});
-
-bench("new Response(JSON.stringify(arrayObj))", () => {
-  return new Response(JSON.stringify(arrayObj), {
-    headers: { "Content-Type": "application/json" },
-  });
+bench("Response.json(obj).json()", async () => {
+  return await Response.json(obj).json();
 });
 
 await run();

bench/snippets/spread-set.mjs

@@ -1,20 +0,0 @@
-// Benchmark for [...set] optimization (WebKit#56539)
-// https://github.com/WebKit/WebKit/pull/56539
-import { bench, run } from "../runner.mjs";
-
-const intSet10 = new Set([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
-const intSet100 = new Set(Array.from({ length: 100 }, (_, i) => i));
-const strSet10 = new Set(Array.from({ length: 10 }, (_, i) => `key-${i}`));
-const strSet100 = new Set(Array.from({ length: 100 }, (_, i) => `key-${i}`));
-
-const objSet10 = new Set(Array.from({ length: 10 }, (_, i) => ({ id: i })));
-const objSet100 = new Set(Array.from({ length: 100 }, (_, i) => ({ id: i })));
-
-bench("[...set] - integers (10)", () => [...intSet10]);
-bench("[...set] - integers (100)", () => [...intSet100]);
-bench("[...set] - strings (10)", () => [...strSet10]);
-bench("[...set] - strings (100)", () => [...strSet100]);
-bench("[...set] - objects (10)", () => [...objSet10]);
-bench("[...set] - objects (100)", () => [...objSet100]);
-
-await run();

bench/snippets/string-includes.mjs

@@ -1,34 +0,0 @@
-import { bench, run } from "../runner.mjs";
-
-const shortStr = "The quick brown fox jumps over the lazy dog";
-const longStr = shortStr.repeat(100);
-
-bench("String.includes - short, hit (middle)", () => {
-  return shortStr.includes("jumps");
-});
-
-bench("String.includes - short, hit (start)", () => {
-  return shortStr.includes("The");
-});
-
-bench("String.includes - short, hit (end)", () => {
-  return shortStr.includes("dog");
-});
-
-bench("String.includes - short, miss", () => {
-  return shortStr.includes("cat");
-});
-
-bench("String.includes - long, hit (middle)", () => {
-  return longStr.includes("jumps");
-});
-
-bench("String.includes - long, miss", () => {
-  return longStr.includes("cat");
-});
-
-bench("String.includes - with position", () => {
-  return shortStr.includes("fox", 10);
-});
-
-await run();

bench/snippets/urlpattern.js

@@ -1,48 +0,0 @@
-import { bench, group, run } from "../runner.mjs";
-
-const patterns = [
-  { name: "string pattern", input: "https://(sub.)?example(.com/)foo" },
-  { name: "hostname IDN", input: { hostname: "xn--caf-dma.com" } },
-  {
-    name: "pathname + search + hash + baseURL",
-    input: {
-      pathname: "/foo",
-      search: "bar",
-      hash: "baz",
-      baseURL: "https://example.com:8080",
-    },
-  },
-  { name: "pathname with regex", input: { pathname: "/([[a-z]--a])" } },
-  { name: "named groups", input: { pathname: "/users/:id/posts/:postId" } },
-  { name: "wildcard", input: { pathname: "/files/*" } },
-];
-
-const testURL = "https://sub.example.com/foo";
-
-group("URLPattern parse (constructor)", () => {
-  for (const { name, input } of patterns) {
-    bench(name, () => {
-      return new URLPattern(input);
-    });
-  }
-});
-
-group("URLPattern.test()", () => {
-  for (const { name, input } of patterns) {
-    const pattern = new URLPattern(input);
-    bench(name, () => {
-      return pattern.test(testURL);
-    });
-  }
-});
-
-group("URLPattern.exec()", () => {
-  for (const { name, input } of patterns) {
-    const pattern = new URLPattern(input);
-    bench(name, () => {
-      return pattern.exec(testURL);
-    });
-  }
-});
-
-await run();

bench/snippets/wrap-ansi.js

@@ -1,103 +0,0 @@
-import wrapAnsi from "wrap-ansi";
-import { bench, run, summary } from "../runner.mjs";
-
-// Test fixtures
-const shortText = "The quick brown fox jumped over the lazy dog.";
-const mediumText = "The quick brown fox jumped over the lazy dog and then ran away with the unicorn. ".repeat(10);
-const longText = "The quick brown fox jumped over the lazy dog and then ran away with the unicorn. ".repeat(100);
-
-// ANSI colored text
-const red = s => `\u001B[31m${s}\u001B[39m`;
-const green = s => `\u001B[32m${s}\u001B[39m`;
-const blue = s => `\u001B[34m${s}\u001B[39m`;
-
-const coloredShort = `The quick ${red("brown fox")} jumped over the ${green("lazy dog")}.`;
-const coloredMedium =
-  `The quick ${red("brown fox jumped over")} the ${green("lazy dog and then ran away")} with the ${blue("unicorn")}. `.repeat(
-    10,
-  );
-const coloredLong =
-  `The quick ${red("brown fox jumped over")} the ${green("lazy dog and then ran away")} with the ${blue("unicorn")}. `.repeat(
-    100,
-  );
-
-// Full-width characters (Japanese)
-const japaneseText = "日本語のテキストを折り返すテストです。全角文字は幅2としてカウントされます。".repeat(5);
-
-// Emoji text
-const emojiText = "Hello 👋 World 🌍! Let's test 🧪 some emoji 😀 wrapping 📦!".repeat(5);
-
-// Hyperlink text
-const hyperlinkText = "Check out \u001B]8;;https://bun.sh\u0007Bun\u001B]8;;\u0007, it's fast! ".repeat(10);
-
-// Options
-const hardOpts = { hard: true };
-const noTrimOpts = { trim: false };
-
-// Basic text benchmarks
-summary(() => {
-  bench("Short text (45 chars) - npm", () => wrapAnsi(shortText, 20));
-  bench("Short text (45 chars) - Bun", () => Bun.wrapAnsi(shortText, 20));
-});
-
-summary(() => {
-  bench("Medium text (810 chars) - npm", () => wrapAnsi(mediumText, 40));
-  bench("Medium text (810 chars) - Bun", () => Bun.wrapAnsi(mediumText, 40));
-});
-
-summary(() => {
-  bench("Long text (8100 chars) - npm", () => wrapAnsi(longText, 80));
-  bench("Long text (8100 chars) - Bun", () => Bun.wrapAnsi(longText, 80));
-});
-
-// ANSI colored text benchmarks
-summary(() => {
-  bench("Colored short - npm", () => wrapAnsi(coloredShort, 20));
-  bench("Colored short - Bun", () => Bun.wrapAnsi(coloredShort, 20));
-});
-
-summary(() => {
-  bench("Colored medium - npm", () => wrapAnsi(coloredMedium, 40));
-  bench("Colored medium - Bun", () => Bun.wrapAnsi(coloredMedium, 40));
-});
-
-summary(() => {
-  bench("Colored long - npm", () => wrapAnsi(coloredLong, 80));
-  bench("Colored long - Bun", () => Bun.wrapAnsi(coloredLong, 80));
-});
-
-// Hard wrap benchmarks
-summary(() => {
-  bench("Hard wrap long - npm", () => wrapAnsi(longText, 80, hardOpts));
-  bench("Hard wrap long - Bun", () => Bun.wrapAnsi(longText, 80, hardOpts));
-});
-
-summary(() => {
-  bench("Hard wrap colored - npm", () => wrapAnsi(coloredLong, 80, hardOpts));
-  bench("Hard wrap colored - Bun", () => Bun.wrapAnsi(coloredLong, 80, hardOpts));
-});
-
-// Unicode benchmarks
-summary(() => {
-  bench("Japanese (full-width) - npm", () => wrapAnsi(japaneseText, 40));
-  bench("Japanese (full-width) - Bun", () => Bun.wrapAnsi(japaneseText, 40));
-});
-
-summary(() => {
-  bench("Emoji text - npm", () => wrapAnsi(emojiText, 30));
-  bench("Emoji text - Bun", () => Bun.wrapAnsi(emojiText, 30));
-});
-
-// Hyperlink benchmarks
-summary(() => {
-  bench("Hyperlink (OSC 8) - npm", () => wrapAnsi(hyperlinkText, 40));
-  bench("Hyperlink (OSC 8) - Bun", () => Bun.wrapAnsi(hyperlinkText, 40));
-});
-
-// No trim option
-summary(() => {
-  bench("No trim long - npm", () => wrapAnsi(longText, 80, noTrimOpts));
-  bench("No trim long - Bun", () => Bun.wrapAnsi(longText, 80, noTrimOpts));
-});
-
-await run();

build.zig

@@ -34,7 +34,6 @@ const BunBuildOptions = struct {
     enable_asan: bool,
     enable_fuzzilli: bool,
     enable_valgrind: bool,
-    enable_tinycc: bool,
     use_mimalloc: bool,
     tracy_callstack_depth: u16,
     reported_nodejs_version: Version,
@@ -85,7 +84,6 @@ const BunBuildOptions = struct {
         opts.addOption(bool, "enable_asan", this.enable_asan);
         opts.addOption(bool, "enable_fuzzilli", this.enable_fuzzilli);
         opts.addOption(bool, "enable_valgrind", this.enable_valgrind);
-        opts.addOption(bool, "enable_tinycc", this.enable_tinycc);
         opts.addOption(bool, "use_mimalloc", this.use_mimalloc);
         opts.addOption([]const u8, "reported_nodejs_version", b.fmt("{f}", .{this.reported_nodejs_version}));
         opts.addOption(bool, "zig_self_hosted_backend", this.no_llvm);
@@ -261,7 +259,6 @@ pub fn build(b: *Build) !void {
         .enable_asan = b.option(bool, "enable_asan", "Enable asan") orelse false,
         .enable_fuzzilli = b.option(bool, "enable_fuzzilli", "Enable fuzzilli instrumentation") orelse false,
         .enable_valgrind = b.option(bool, "enable_valgrind", "Enable valgrind") orelse false,
-        .enable_tinycc = b.option(bool, "enable_tinycc", "Enable TinyCC for FFI JIT compilation") orelse true,
         .use_mimalloc = b.option(bool, "use_mimalloc", "Use mimalloc as default allocator") orelse false,
         .llvm_codegen_threads = b.option(u32, "llvm_codegen_threads", "Number of threads to use for LLVM codegen") orelse 1,
     };
@@ -345,7 +342,6 @@ pub fn build(b: *Build) !void {
         const step = b.step("check-debug", "Check for semantic analysis errors on some platforms");
         addMultiCheck(b, step, build_options, &.{
             .{ .os = .windows, .arch = .x86_64 },
-            .{ .os = .windows, .arch = .aarch64 },
             .{ .os = .mac, .arch = .aarch64 },
             .{ .os = .linux, .arch = .x86_64 },
         }, &.{.Debug});
@@ -356,7 +352,6 @@ pub fn build(b: *Build) !void {
         const step = b.step("check-all", "Check for semantic analysis errors on all supported platforms");
         addMultiCheck(b, step, build_options, &.{
             .{ .os = .windows, .arch = .x86_64 },
-            .{ .os = .windows, .arch = .aarch64 },
             .{ .os = .mac, .arch = .x86_64 },
             .{ .os = .mac, .arch = .aarch64 },
             .{ .os = .linux, .arch = .x86_64 },
@@ -371,7 +366,6 @@ pub fn build(b: *Build) !void {
         const step = b.step("check-all-debug", "Check for semantic analysis errors on all supported platforms in debug mode");
         addMultiCheck(b, step, build_options, &.{
             .{ .os = .windows, .arch = .x86_64 },
-            .{ .os = .windows, .arch = .aarch64 },
             .{ .os = .mac, .arch = .x86_64 },
             .{ .os = .mac, .arch = .aarch64 },
             .{ .os = .linux, .arch = .x86_64 },
@@ -386,14 +380,12 @@ pub fn build(b: *Build) !void {
         const step = b.step("check-windows", "Check for semantic analysis errors on Windows");
         addMultiCheck(b, step, build_options, &.{
             .{ .os = .windows, .arch = .x86_64 },
-            .{ .os = .windows, .arch = .aarch64 },
         }, &.{ .Debug, .ReleaseFast });
     }
     {
         const step = b.step("check-windows-debug", "Check for semantic analysis errors on Windows");
         addMultiCheck(b, step, build_options, &.{
             .{ .os = .windows, .arch = .x86_64 },
-            .{ .os = .windows, .arch = .aarch64 },
         }, &.{.Debug});
     }
     {
@@ -430,7 +422,6 @@ pub fn build(b: *Build) !void {
         const step = b.step("translate-c", "Copy generated translated-c-headers.zig to zig-out");
         for ([_]TargetDescription{
             .{ .os = .windows, .arch = .x86_64 },
-            .{ .os = .windows, .arch = .aarch64 },
             .{ .os = .mac, .arch = .x86_64 },
             .{ .os = .mac, .arch = .aarch64 },
             .{ .os = .linux, .arch = .x86_64 },
@@ -459,146 +450,6 @@ pub fn build(b: *Build) !void {
         // const run = b.addRunArtifact(exe);
         // step.dependOn(&run.step);
     }
-
-    // zig build generate-grapheme-tables
-    // Regenerates src/string/immutable/grapheme_tables.zig from the vendored uucode.
-    // Run this when updating src/deps/uucode. Normal builds use the committed file.
-    {
-        const step = b.step("generate-grapheme-tables", "Regenerate grapheme property tables from vendored uucode");
-
-        // --- Phase 1: Build uucode tables (separate module graph, no tables dependency) ---
-        const bt_config_mod = b.createModule(.{
-            .root_source_file = b.path("src/deps/uucode/src/config.zig"),
-            .target = b.graph.host,
-        });
-        const bt_types_mod = b.createModule(.{
-            .root_source_file = b.path("src/deps/uucode/src/types.zig"),
-            .target = b.graph.host,
-        });
-        bt_types_mod.addImport("config.zig", bt_config_mod);
-        bt_config_mod.addImport("types.zig", bt_types_mod);
-
-        const bt_config_x_mod = b.createModule(.{
-            .root_source_file = b.path("src/deps/uucode/src/x/config.x.zig"),
-            .target = b.graph.host,
-        });
-        const bt_types_x_mod = b.createModule(.{
-            .root_source_file = b.path("src/deps/uucode/src/x/types.x.zig"),
-            .target = b.graph.host,
-        });
-        bt_types_x_mod.addImport("config.x.zig", bt_config_x_mod);
-        bt_config_x_mod.addImport("types.x.zig", bt_types_x_mod);
-        bt_config_x_mod.addImport("types.zig", bt_types_mod);
-        bt_config_x_mod.addImport("config.zig", bt_config_mod);
-
-        const bt_build_config_mod = b.createModule(.{
-            .root_source_file = b.path("src/unicode/uucode/uucode_config.zig"),
-            .target = b.graph.host,
-        });
-        bt_build_config_mod.addImport("types.zig", bt_types_mod);
-        bt_build_config_mod.addImport("config.zig", bt_config_mod);
-        bt_build_config_mod.addImport("types.x.zig", bt_types_x_mod);
-        bt_build_config_mod.addImport("config.x.zig", bt_config_x_mod);
-
-        const build_tables_mod = b.createModule(.{
-            .root_source_file = b.path("src/deps/uucode/src/build/tables.zig"),
-            .target = b.graph.host,
-            .optimize = .Debug,
-        });
-        build_tables_mod.addImport("config.zig", bt_config_mod);
-        build_tables_mod.addImport("build_config", bt_build_config_mod);
-        build_tables_mod.addImport("types.zig", bt_types_mod);
-
-        const build_tables_exe = b.addExecutable(.{
-            .name = "uucode_build_tables",
-            .root_module = build_tables_mod,
-            .use_llvm = true,
-        });
-        const run_build_tables = b.addRunArtifact(build_tables_exe);
-        run_build_tables.setCwd(b.path("src/deps/uucode"));
-        const tables_path = run_build_tables.addOutputFileArg("tables.zig");
-
-        // --- Phase 2: Build grapheme-gen with full uucode (separate module graph) ---
-        const rt_config_mod = b.createModule(.{
-            .root_source_file = b.path("src/deps/uucode/src/config.zig"),
-            .target = b.graph.host,
-        });
-        const rt_types_mod = b.createModule(.{
-            .root_source_file = b.path("src/deps/uucode/src/types.zig"),
-            .target = b.graph.host,
-        });
-        rt_types_mod.addImport("config.zig", rt_config_mod);
-        rt_config_mod.addImport("types.zig", rt_types_mod);
-
-        const rt_config_x_mod = b.createModule(.{
-            .root_source_file = b.path("src/deps/uucode/src/x/config.x.zig"),
-            .target = b.graph.host,
-        });
-        const rt_types_x_mod = b.createModule(.{
-            .root_source_file = b.path("src/deps/uucode/src/x/types.x.zig"),
-            .target = b.graph.host,
-        });
-        rt_types_x_mod.addImport("config.x.zig", rt_config_x_mod);
-        rt_config_x_mod.addImport("types.x.zig", rt_types_x_mod);
-        rt_config_x_mod.addImport("types.zig", rt_types_mod);
-        rt_config_x_mod.addImport("config.zig", rt_config_mod);
-
-        const rt_build_config_mod = b.createModule(.{
-            .root_source_file = b.path("src/unicode/uucode/uucode_config.zig"),
-            .target = b.graph.host,
-        });
-        rt_build_config_mod.addImport("types.zig", rt_types_mod);
-        rt_build_config_mod.addImport("config.zig", rt_config_mod);
-        rt_build_config_mod.addImport("types.x.zig", rt_types_x_mod);
-        rt_build_config_mod.addImport("config.x.zig", rt_config_x_mod);
-
-        const rt_tables_mod = b.createModule(.{
-            .root_source_file = tables_path,
-            .target = b.graph.host,
-        });
-        rt_tables_mod.addImport("types.zig", rt_types_mod);
-        rt_tables_mod.addImport("types.x.zig", rt_types_x_mod);
-        rt_tables_mod.addImport("config.zig", rt_config_mod);
-        rt_tables_mod.addImport("build_config", rt_build_config_mod);
-
-        const rt_get_mod = b.createModule(.{
-            .root_source_file = b.path("src/deps/uucode/src/get.zig"),
-            .target = b.graph.host,
-        });
-        rt_get_mod.addImport("types.zig", rt_types_mod);
-        rt_get_mod.addImport("tables", rt_tables_mod);
-        rt_types_mod.addImport("get.zig", rt_get_mod);
-
-        const uucode_mod = b.createModule(.{
-            .root_source_file = b.path("src/deps/uucode/src/root.zig"),
-            .target = b.graph.host,
-        });
-        uucode_mod.addImport("types.zig", rt_types_mod);
-        uucode_mod.addImport("config.zig", rt_config_mod);
-        uucode_mod.addImport("types.x.zig", rt_types_x_mod);
-        uucode_mod.addImport("tables", rt_tables_mod);
-        uucode_mod.addImport("get.zig", rt_get_mod);
-
-        // grapheme_gen executable
-        const gen_exe = b.addExecutable(.{
-            .name = "grapheme-gen",
-            .root_module = b.createModule(.{
-                .root_source_file = b.path("src/unicode/uucode/grapheme_gen.zig"),
-                .target = b.graph.host,
-                .optimize = .Debug,
-                .imports = &.{
-                    .{ .name = "uucode", .module = uucode_mod },
-                },
-            }),
-            .use_llvm = true,
-        });
-
-        const run_gen = b.addRunArtifact(gen_exe);
-        const gen_output = run_gen.captureStdOut();
-
-        const install = b.addInstallFile(gen_output, "../src/string/immutable/grapheme_tables.zig");
-        step.dependOn(&install.step);
-    }
 }
 
 const TargetDescription = struct {
@@ -642,7 +493,6 @@ fn addMultiCheck(
                 .no_llvm = root_build_options.no_llvm,
                 .enable_asan = root_build_options.enable_asan,
                 .enable_valgrind = root_build_options.enable_valgrind,
-                .enable_tinycc = root_build_options.enable_tinycc,
                 .enable_fuzzilli = root_build_options.enable_fuzzilli,
                 .use_mimalloc = root_build_options.use_mimalloc,
                 .override_no_export_cpp_apis = root_build_options.override_no_export_cpp_apis,
@@ -757,7 +607,7 @@ fn configureObj(b: *Build, opts: *BunBuildOptions, obj: *Compile) void {
             obj.llvm_codegen_threads = opts.llvm_codegen_threads orelse 0;
     }
 
-    obj.no_link_obj = opts.os != .windows and !opts.no_llvm;
+    obj.no_link_obj = opts.os != .windows;
 
 
     if (opts.enable_asan and !enableFastBuild(b)) {

bun.lock

@@ -36,7 +36,6 @@
   },
   "overrides": {
     "@types/bun": "workspace:packages/@types/bun",
-    "@types/node": "25.0.0",
     "bun-types": "workspace:packages/bun-types",
   },
   "packages": {
@@ -156,7 +155,7 @@
 
     "@types/ms": ["@types/ms@2.1.0", "", {}, "sha512-GsCCIZDE/p3i96vtEqx+7dBUGXrc7zeSK3wwPHIaRThS+9OhWIXRqzs4d6k1SVU8g91DrNRWxWUGhp5KXQb2VA=="],
 
-    "@types/node": ["@types/node@25.0.0", "", { "dependencies": { "undici-types": "~7.16.0" } }, "sha512-rl78HwuZlaDIUSeUKkmogkhebA+8K1Hy7tddZuJ3D0xV8pZSfsYGTsliGUol1JPzu9EKnTxPC4L1fiWouStRew=="],
+    "@types/node": ["@types/node@24.10.1", "", { "dependencies": { "undici-types": "~7.16.0" } }, "sha512-GNWcUTRBgIRJD5zj+Tq0fKOJ5XZajIiBroOF0yvj2bSU1WvNdYS/dn9UxwsujGW4JX06dnHyjV2y9rRaybH0iQ=="],
 
     "aggregate-error": ["aggregate-error@3.1.0", "", { "dependencies": { "clean-stack": "^2.0.0", "indent-string": "^4.0.0" } }, "sha512-4I7Td01quW/RpocfNayFdFVk1qSuoh0E7JrbRJ16nH01HhKFQ88INq9Sd+nd72zqRySlr9BmDA8xlEJ6vJMrYA=="],
 

cmake/CompilerFlags.cmake

@@ -21,10 +21,6 @@ endforeach()
 if(CMAKE_SYSTEM_PROCESSOR MATCHES "arm|ARM|arm64|ARM64|aarch64|AARCH64")
   if(APPLE)
     register_compiler_flags(-mcpu=apple-m1)
-  elseif(WIN32)
-    # Windows ARM64: use /clang: prefix for clang-cl, skip for MSVC cl.exe subprojects
-    # These flags are only understood by clang-cl, not MSVC cl.exe
-    register_compiler_flags(/clang:-march=armv8-a+crc /clang:-mtune=ampere1)
   else()
     register_compiler_flags(-march=armv8-a+crc -mtune=ampere1)
   endif()
@@ -246,17 +242,10 @@ if(UNIX)
   )
 endif()
 
-if(WIN32)
-  register_compiler_flags(
-    DESCRIPTION "Set C/C++ error limit"
-    /clang:-ferror-limit=${ERROR_LIMIT}
-  )
-else()
-  register_compiler_flags(
-    DESCRIPTION "Set C/C++ error limit"
-    -ferror-limit=${ERROR_LIMIT}
-  )
-endif()
+register_compiler_flags(
+  DESCRIPTION "Set C/C++ error limit"
+  -ferror-limit=${ERROR_LIMIT}
+)
 
 # --- LTO ---
 if(ENABLE_LTO)

cmake/Globals.cmake

@@ -106,9 +106,9 @@ else()
 endif()
 
 if(CMAKE_HOST_SYSTEM_PROCESSOR MATCHES "arm64|ARM64|aarch64|AARCH64")
-  set(HOST_ARCH "aarch64")
+  set(HOST_OS "aarch64")
 elseif(CMAKE_HOST_SYSTEM_PROCESSOR MATCHES "x86_64|X86_64|x64|X64|amd64|AMD64")
-  set(HOST_ARCH "x64")
+  set(HOST_OS "x64")
 else()
   unsupported(CMAKE_HOST_SYSTEM_PROCESSOR)
 endif()
@@ -433,33 +433,6 @@ function(register_command)
     list(APPEND CMD_EFFECTIVE_DEPENDS ${CMD_EXECUTABLE})
   endif()
 
-  # SKIP_CODEGEN: Skip commands that use BUN_EXECUTABLE if all outputs exist
-  # This is used for Windows ARM64 builds where x64 bun crashes under emulation
-  if(SKIP_CODEGEN AND CMD_EXECUTABLE STREQUAL "${BUN_EXECUTABLE}")
-    set(ALL_OUTPUTS_EXIST TRUE)
-    foreach(output ${CMD_OUTPUTS})
-      if(NOT EXISTS ${output})
-        set(ALL_OUTPUTS_EXIST FALSE)
-        break()
-      endif()
-    endforeach()
-    if(ALL_OUTPUTS_EXIST AND CMD_OUTPUTS)
-      message(STATUS "SKIP_CODEGEN: Skipping ${CMD_TARGET} (outputs exist)")
-      if(CMD_TARGET)
-        add_custom_target(${CMD_TARGET})
-      endif()
-      return()
-    elseif(NOT CMD_OUTPUTS)
-      message(STATUS "SKIP_CODEGEN: Skipping ${CMD_TARGET} (no outputs)")
-      if(CMD_TARGET)
-        add_custom_target(${CMD_TARGET})
-      endif()
-      return()
-    else()
-      message(FATAL_ERROR "SKIP_CODEGEN: Cannot skip ${CMD_TARGET} - missing outputs. Run codegen on x64 first.")
-    endif()
-  endif()
-
   foreach(target ${CMD_TARGETS})
     if(target MATCHES "/|\\\\")
       message(FATAL_ERROR "register_command: TARGETS contains \"${target}\", if it's a path add it to SOURCES instead")
@@ -677,7 +650,6 @@ function(register_bun_install)
       ${NPM_CWD}
     COMMAND
       ${BUN_EXECUTABLE}
-        ${BUN_FLAGS}
         install
         --frozen-lockfile
     SOURCES
@@ -785,7 +757,7 @@ function(register_cmake_command)
   set(MAKE_EFFECTIVE_ARGS -B${MAKE_BUILD_PATH} ${CMAKE_ARGS})
 
   set(setFlags GENERATOR BUILD_TYPE)
-  set(appendFlags C_FLAGS CXX_FLAGS LINKER_FLAGS STATIC_LINKER_FLAGS EXE_LINKER_FLAGS SHARED_LINKER_FLAGS MODULE_LINKER_FLAGS)
+  set(appendFlags C_FLAGS CXX_FLAGS LINKER_FLAGS)
   set(specialFlags POSITION_INDEPENDENT_CODE)
   set(flags ${setFlags} ${appendFlags} ${specialFlags})
 
@@ -831,14 +803,6 @@ function(register_cmake_command)
     list(APPEND MAKE_EFFECTIVE_ARGS "-DCMAKE_${flag}=${MAKE_${flag}}")
   endforeach()
 
-  # Workaround for CMake 4.1.0 bug: Force correct machine type for Windows ARM64
-  # Use toolchain file and set CMP0197 policy to prevent duplicate /machine: flags
-  if(WIN32 AND CMAKE_SYSTEM_PROCESSOR MATCHES "ARM64|aarch64|AARCH64")
-    list(APPEND MAKE_EFFECTIVE_ARGS "-DCMAKE_TOOLCHAIN_FILE=${CWD}/cmake/toolchains/windows-aarch64.cmake")
-    list(APPEND MAKE_EFFECTIVE_ARGS "-DCMAKE_POLICY_DEFAULT_CMP0197=NEW")
-    list(APPEND MAKE_EFFECTIVE_ARGS "-DCMAKE_PROJECT_INCLUDE=${CWD}/cmake/arm64-static-lib-fix.cmake")
-  endif()
-
   if(DEFINED FRESH)
     list(APPEND MAKE_EFFECTIVE_ARGS --fresh)
   endif()

cmake/Options.cmake

@@ -4,7 +4,6 @@ endif()
 
 optionx(BUN_LINK_ONLY BOOL "If only the linking step should be built" DEFAULT OFF)
 optionx(BUN_CPP_ONLY BOOL "If only the C++ part of Bun should be built" DEFAULT OFF)
-optionx(SKIP_CODEGEN BOOL "Skip JavaScript codegen (for Windows ARM64 debug)" DEFAULT OFF)
 
 optionx(BUILDKITE BOOL "If Buildkite is enabled" DEFAULT OFF)
 optionx(GITHUB_ACTIONS BOOL "If GitHub Actions is enabled" DEFAULT OFF)
@@ -50,7 +49,7 @@ else()
   message(FATAL_ERROR "Unsupported operating system: ${CMAKE_SYSTEM_NAME}")
 endif()
 
-if(CMAKE_SYSTEM_PROCESSOR MATCHES "aarch64|arm64|ARM64")
+if(CMAKE_SYSTEM_PROCESSOR MATCHES "aarch64|arm64|arm")
   setx(ARCH "aarch64")
 elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "amd64|x86_64|x64|AMD64")
   setx(ARCH "x64")
@@ -58,18 +57,6 @@ else()
   message(FATAL_ERROR "Unsupported architecture: ${CMAKE_SYSTEM_PROCESSOR}")
 endif()
 
-# CMake 4.0+ policy CMP0197 controls how MSVC machine type flags are handled
-# Setting to NEW prevents duplicate /machine: flags being added to linker commands
-if(WIN32 AND ARCH STREQUAL "aarch64")
-  set(CMAKE_POLICY_DEFAULT_CMP0197 NEW)
-  set(CMAKE_MSVC_CMP0197 NEW)
-  # Set linker flags for exe/shared linking
-  set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /machine:ARM64")
-  set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} /machine:ARM64")
-  set(CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} /machine:ARM64")
-  set(CMAKE_STATIC_LINKER_FLAGS "${CMAKE_STATIC_LINKER_FLAGS} /machine:ARM64")
-endif()
-
 # Windows Code Signing Option
 if(WIN32)
   optionx(ENABLE_WINDOWS_CODESIGNING BOOL "Enable Windows code signing with DigiCert KeyLocker" DEFAULT OFF)
@@ -212,16 +199,6 @@ optionx(USE_WEBKIT_ICU BOOL "Use the ICU libraries from WebKit" DEFAULT ${DEFAUL
 
 optionx(ERROR_LIMIT STRING "Maximum number of errors to show when compiling C++ code" DEFAULT "100")
 
-# TinyCC is used for FFI JIT compilation
-# Disable on Windows ARM64 where it's not yet supported
-if(WIN32 AND ARCH STREQUAL "aarch64")
-  set(DEFAULT_ENABLE_TINYCC OFF)
-else()
-  set(DEFAULT_ENABLE_TINYCC ON)
-endif()
-
-optionx(ENABLE_TINYCC BOOL "Enable TinyCC for FFI JIT compilation" DEFAULT ${DEFAULT_ENABLE_TINYCC})
-
 # This is not an `option` because setting this variable to OFF is experimental
 # and unsupported. This replaces the `use_mimalloc` variable previously in
 # bun.zig, and enables C++ code to also be aware of the option.

cmake/Sources.json

@@ -13,7 +13,10 @@
   },
   {
     "output": "JavaScriptSources.txt",
-    "paths": ["src/js/**/*.{js,ts}", "src/install/PackageManager/scanner-entry.ts"]
+    "paths": [
+      "src/js/**/*.{js,ts}",
+      "src/install/PackageManager/scanner-entry.ts"
+    ]
   },
   {
     "output": "JavaScriptCodegenSources.txt",

cmake/arm64-static-lib-fix.cmake

@@ -1,8 +0,0 @@
-# This file is included after project() via CMAKE_PROJECT_INCLUDE
-# It fixes the static library creation command to use ARM64 machine type
-
-if(WIN32 AND CMAKE_SYSTEM_PROCESSOR STREQUAL \"aarch64\")
-  # Override the static library creation commands to avoid spurious /machine:x64 flags
-  set(CMAKE_C_CREATE_STATIC_LIBRARY \"<CMAKE_AR> /nologo /machine:ARM64 /out:<TARGET> <OBJECTS>\" CACHE STRING \"\" FORCE)
-  set(CMAKE_CXX_CREATE_STATIC_LIBRARY \"<CMAKE_AR> /nologo /machine:ARM64 /out:<TARGET> <OBJECTS>\" CACHE STRING \"\" FORCE)
-endif()

cmake/scripts/DownloadZig.cmake

@@ -21,12 +21,7 @@ if(NOT DEFINED CMAKE_HOST_SYSTEM_PROCESSOR)
 endif()
 
 if(CMAKE_HOST_SYSTEM_PROCESSOR MATCHES "arm64|ARM64|aarch64|AARCH64")
-  # Windows ARM64 can run x86_64 via emulation, and no native ARM64 Zig build exists yet
-  if(CMAKE_HOST_WIN32)
-    set(ZIG_ARCH "x86_64")
-  else()
-    set(ZIG_ARCH "aarch64")
-  endif()
+  set(ZIG_ARCH "aarch64")
 elseif(CMAKE_HOST_SYSTEM_PROCESSOR MATCHES "amd64|AMD64|x86_64|X86_64|x64|X64")
   set(ZIG_ARCH "x86_64")
 else()

cmake/scripts/llvm-lib-arm64.bat

@@ -1,34 +0,0 @@
-@echo off
-setlocal enabledelayedexpansion
-
-REM Wrapper for llvm-lib that strips conflicting /machine:x64 flag for ARM64 builds
-REM This is a workaround for CMake 4.1.0 bug
-
-REM Find llvm-lib.exe - check LLVM_LIB env var, then PATH, then known locations
-if defined LLVM_LIB (
-    set "LLVM_LIB_EXE=!LLVM_LIB!"
-) else (
-    where llvm-lib.exe >nul 2>&1
-    if !ERRORLEVEL! equ 0 (
-        for /f "delims=" %%i in ('where llvm-lib.exe') do set "LLVM_LIB_EXE=%%i"
-    ) else if exist "C:\Program Files\LLVM\bin\llvm-lib.exe" (
-        set "LLVM_LIB_EXE=C:\Program Files\LLVM\bin\llvm-lib.exe"
-    ) else (
-        echo Error: Cannot find llvm-lib.exe. Set LLVM_LIB environment variable or add LLVM to PATH.
-        exit /b 1
-    )
-)
-
-set "ARGS="
-
-for %%a in (%*) do (
-    set "ARG=%%a"
-    if /i "!ARG!"=="/machine:x64" (
-        REM Skip this argument
-    ) else (
-        set "ARGS=!ARGS! %%a"
-    )
-)
-
-"!LLVM_LIB_EXE!" %ARGS%
-exit /b %ERRORLEVEL%

cmake/scripts/llvm-lib-arm64.ps1

@@ -1,18 +0,0 @@
-# Wrapper for llvm-lib that strips conflicting /machine:x64 flag for ARM64 builds
-# This is a workaround for CMake 4.1.0 bug where both /machine:ARM64 and /machine:x64 are added
-
-# Find llvm-lib.exe - check LLVM_LIB env var, then PATH, then known locations
-if ($env:LLVM_LIB) {
-    $llvmLib = $env:LLVM_LIB
-} elseif (Get-Command llvm-lib.exe -ErrorAction SilentlyContinue) {
-    $llvmLib = (Get-Command llvm-lib.exe).Source
-} elseif (Test-Path "C:\Program Files\LLVM\bin\llvm-lib.exe") {
-    $llvmLib = "C:\Program Files\LLVM\bin\llvm-lib.exe"
-} else {
-    Write-Error "Cannot find llvm-lib.exe. Set LLVM_LIB environment variable or add LLVM to PATH."
-    exit 1
-}
-
-$filteredArgs = $args | Where-Object { $_ -ne "/machine:x64" }
-& $llvmLib @filteredArgs
-exit $LASTEXITCODE

cmake/scripts/llvm-lib-wrapper.bat

@@ -1,34 +0,0 @@
-@echo off
-setlocal enabledelayedexpansion
-
-REM Wrapper for llvm-lib that strips conflicting /machine:x64 flag for ARM64 builds
-REM This is a workaround for CMake 4.1.0 bug
-
-REM Find llvm-lib.exe - check LLVM_LIB env var, then PATH, then known locations
-if defined LLVM_LIB (
-    set "LLVM_LIB_EXE=!LLVM_LIB!"
-) else (
-    where llvm-lib.exe >nul 2>&1
-    if !ERRORLEVEL! equ 0 (
-        for /f "delims=" %%i in ('where llvm-lib.exe') do set "LLVM_LIB_EXE=%%i"
-    ) else if exist "C:\Program Files\LLVM\bin\llvm-lib.exe" (
-        set "LLVM_LIB_EXE=C:\Program Files\LLVM\bin\llvm-lib.exe"
-    ) else (
-        echo Error: Cannot find llvm-lib.exe. Set LLVM_LIB environment variable or add LLVM to PATH.
-        exit /b 1
-    )
-)
-
-set NEWARGS=
-
-for %%a in (%*) do (
-    set "ARG=%%a"
-    if /i "!ARG!"=="/machine:x64" (
-        REM Skip /machine:x64 argument
-    ) else (
-        set "NEWARGS=!NEWARGS! %%a"
-    )
-)
-
-"!LLVM_LIB_EXE!" %NEWARGS%
-exit /b %ERRORLEVEL%

cmake/targets/BuildBoringSSL.cmake

@@ -4,7 +4,7 @@ register_repository(
   REPOSITORY
     oven-sh/boringssl
   COMMIT
-    4f4f5ef8ebc6e23cbf393428f0ab1b526773f7ac
+    f1ffd9e83d4f5c28a9c70d73f9a4e6fcf310062f
 )
 
 register_cmake_command(

cmake/targets/BuildBun.cmake

@@ -57,17 +57,13 @@ set(BUN_DEPENDENCIES
   LolHtml
   Lshpack
   Mimalloc
+  TinyCC
   Zlib
   LibArchive # must be loaded after zlib
   HdrHistogram # must be loaded after zlib
   Zstd
 )
 
-# TinyCC is optional - disabled on Windows ARM64 where it's not supported
-if(ENABLE_TINYCC)
-  list(APPEND BUN_DEPENDENCIES TinyCC)
-endif()
-
 include(CloneZstd)
 
 # --- Codegen ---
@@ -189,7 +185,7 @@ register_command(
   CWD
     ${BUN_NODE_FALLBACKS_SOURCE}
   COMMAND
-    ${BUN_EXECUTABLE} ${BUN_FLAGS} run build-fallbacks
+    ${BUN_EXECUTABLE} run build-fallbacks
       ${BUN_NODE_FALLBACKS_OUTPUT}
       ${BUN_NODE_FALLBACKS_SOURCES}
   SOURCES
@@ -210,7 +206,7 @@ register_command(
   CWD
     ${BUN_NODE_FALLBACKS_SOURCE}
   COMMAND
-    ${BUN_EXECUTABLE} ${BUN_FLAGS} build
+    ${BUN_EXECUTABLE} build
       ${BUN_NODE_FALLBACKS_SOURCE}/node_modules/react-refresh/cjs/react-refresh-runtime.development.js
       --outfile=${BUN_REACT_REFRESH_OUTPUT}
       --target=browser
@@ -247,7 +243,6 @@ register_command(
     "Generating ErrorCode.{zig,h}"
   COMMAND
     ${BUN_EXECUTABLE}
-      ${BUN_FLAGS}
       run
       ${BUN_ERROR_CODE_SCRIPT}
       ${CODEGEN_PATH}
@@ -283,7 +278,6 @@ register_command(
     "Generating ZigGeneratedClasses.{zig,cpp,h}"
   COMMAND
     ${BUN_EXECUTABLE}
-      ${BUN_FLAGS}
       run
       ${BUN_ZIG_GENERATED_CLASSES_SCRIPT}
       ${BUN_ZIG_GENERATED_CLASSES_SOURCES}
@@ -334,7 +328,6 @@ register_command(
     "Generating C++ --> Zig bindings"
   COMMAND
     ${BUN_EXECUTABLE}
-      ${BUN_FLAGS}
       ${CWD}/src/codegen/cppbind.ts
       ${CWD}/src
       ${CODEGEN_PATH}
@@ -352,7 +345,6 @@ register_command(
     "Generating CI info"
   COMMAND
     ${BUN_EXECUTABLE}
-      ${BUN_FLAGS}
       ${CWD}/src/codegen/ci_info.ts
       ${CODEGEN_PATH}/ci_info.zig
   SOURCES
@@ -361,35 +353,24 @@ register_command(
     ${BUN_CI_INFO_OUTPUTS}
 )
 
-if(SKIP_CODEGEN)
-  # Skip JavaScript codegen - useful for Windows ARM64 debug builds where bun crashes
-  message(STATUS "SKIP_CODEGEN is ON - skipping bun-js-modules codegen")
-  foreach(output ${BUN_JAVASCRIPT_OUTPUTS})
-    if(NOT EXISTS ${output})
-      message(FATAL_ERROR "SKIP_CODEGEN is ON but ${output} does not exist. Run codegen manually first.")
-    endif()
-  endforeach()
-else()
-  register_command(
-    TARGET
-      bun-js-modules
-    COMMENT
-      "Generating JavaScript modules"
-    COMMAND
-      ${BUN_EXECUTABLE}
-        ${BUN_FLAGS}
-        run
-        ${BUN_JAVASCRIPT_CODEGEN_SCRIPT}
-          --debug=${DEBUG}
-          ${BUILD_PATH}
-    SOURCES
-      ${BUN_JAVASCRIPT_SOURCES}
-      ${BUN_JAVASCRIPT_CODEGEN_SOURCES}
+register_command(
+  TARGET
+    bun-js-modules
+  COMMENT
+    "Generating JavaScript modules"
+  COMMAND
+    ${BUN_EXECUTABLE}
+      run
       ${BUN_JAVASCRIPT_CODEGEN_SCRIPT}
-    OUTPUTS
-      ${BUN_JAVASCRIPT_OUTPUTS}
-  )
-endif()
+        --debug=${DEBUG}
+        ${BUILD_PATH}
+  SOURCES
+    ${BUN_JAVASCRIPT_SOURCES}
+    ${BUN_JAVASCRIPT_CODEGEN_SOURCES}
+    ${BUN_JAVASCRIPT_CODEGEN_SCRIPT}
+  OUTPUTS
+    ${BUN_JAVASCRIPT_OUTPUTS}
+)
 
 set(BUN_BAKE_RUNTIME_CODEGEN_SCRIPT ${CWD}/src/codegen/bake-codegen.ts)
 
@@ -411,7 +392,6 @@ register_command(
     "Bundling Bake Runtime"
   COMMAND
     ${BUN_EXECUTABLE}
-      ${BUN_FLAGS}
       run
       ${BUN_BAKE_RUNTIME_CODEGEN_SCRIPT}
         --debug=${DEBUG}
@@ -435,13 +415,16 @@ string(REPLACE ";" "," BUN_BINDGENV2_SOURCES_COMMA_SEPARATED
   "${BUN_BINDGENV2_SOURCES}")
 
 execute_process(
-  COMMAND ${BUN_EXECUTABLE} ${BUN_FLAGS} run ${BUN_BINDGENV2_SCRIPT}
+  COMMAND ${BUN_EXECUTABLE} run ${BUN_BINDGENV2_SCRIPT}
     --command=list-outputs
     --sources=${BUN_BINDGENV2_SOURCES_COMMA_SEPARATED}
     --codegen-path=${CODEGEN_PATH}
+  RESULT_VARIABLE bindgen_result
   OUTPUT_VARIABLE bindgen_outputs
-  COMMAND_ERROR_IS_FATAL ANY
 )
+if(${bindgen_result})
+  message(FATAL_ERROR "bindgenv2/script.ts exited with non-zero status")
+endif()
 foreach(output IN LISTS bindgen_outputs)
   if(output MATCHES "\.cpp$")
     list(APPEND BUN_BINDGENV2_CPP_OUTPUTS ${output})
@@ -458,7 +441,7 @@ register_command(
   COMMENT
     "Generating bindings (v2)"
   COMMAND
-    ${BUN_EXECUTABLE} ${BUN_FLAGS} run ${BUN_BINDGENV2_SCRIPT}
+    ${BUN_EXECUTABLE} run ${BUN_BINDGENV2_SCRIPT}
       --command=generate
       --codegen-path=${CODEGEN_PATH}
       --sources=${BUN_BINDGENV2_SOURCES_COMMA_SEPARATED}
@@ -489,7 +472,6 @@ register_command(
     "Processing \".bind.ts\" files"
   COMMAND
     ${BUN_EXECUTABLE}
-      ${BUN_FLAGS}
       run
       ${BUN_BINDGEN_SCRIPT}
         --debug=${DEBUG}
@@ -522,7 +504,6 @@ register_command(
     "Generating JSSink.{cpp,h}"
   COMMAND
     ${BUN_EXECUTABLE}
-      ${BUN_FLAGS}
       run
       ${BUN_JS_SINK_SCRIPT}
       ${CODEGEN_PATH}
@@ -595,7 +576,6 @@ foreach(i RANGE 0 ${BUN_OBJECT_LUT_SOURCES_MAX_INDEX})
       ${BUN_OBJECT_LUT_SOURCE}
     COMMAND
       ${BUN_EXECUTABLE}
-        ${BUN_FLAGS}
         run
         ${BUN_OBJECT_LUT_SCRIPT}
         ${BUN_OBJECT_LUT_SOURCE}
@@ -679,10 +659,6 @@ endif()
 if(CMAKE_SYSTEM_PROCESSOR MATCHES "arm|ARM|arm64|ARM64|aarch64|AARCH64")
   if(APPLE)
     set(ZIG_CPU "apple_m1")
-  elseif(WIN32)
-    # Windows ARM64: use a specific CPU with NEON support
-    # Zig running under x64 emulation would detect wrong CPU with "native"
-    set(ZIG_CPU "cortex_a76")
   else()
     set(ZIG_CPU "native")
   endif()
@@ -721,7 +697,6 @@ register_command(
       -Denable_asan=$<IF:$<BOOL:${ENABLE_ZIG_ASAN}>,true,false>
       -Denable_fuzzilli=$<IF:$<BOOL:${ENABLE_FUZZILLI}>,true,false>
       -Denable_valgrind=$<IF:$<BOOL:${ENABLE_VALGRIND}>,true,false>
-      -Denable_tinycc=$<IF:$<BOOL:${ENABLE_TINYCC}>,true,false>
       -Duse_mimalloc=$<IF:$<BOOL:${USE_MIMALLOC_AS_DEFAULT_ALLOCATOR}>,true,false>
       -Dllvm_codegen_threads=${LLVM_ZIG_CODEGEN_THREADS}
       -Dversion=${VERSION}
@@ -897,24 +872,10 @@ target_include_directories(${bun} PRIVATE
   ${CODEGEN_PATH}
   ${VENDOR_PATH}
   ${VENDOR_PATH}/picohttpparser
-  ${VENDOR_PATH}/zlib
   ${NODEJS_HEADERS_PATH}/include
   ${NODEJS_HEADERS_PATH}/include/node
 )
 
-# --- Python ---
-set(PYTHON_ROOT /Users/dylan/code/bun/vendor/cpython/install)
-set(PYTHON_VERSION_MAJOR 3)
-set(PYTHON_VERSION_MINOR 13)
-set(PYTHON_VERSION "${PYTHON_VERSION_MAJOR}.${PYTHON_VERSION_MINOR}")
-target_include_directories(${bun} PRIVATE
-  ${PYTHON_ROOT}/include/python${PYTHON_VERSION}
-)
-# Pass PYTHON_ROOT to C++ so BunPython.cpp can use it for runtime paths
-target_compile_definitions(${bun} PRIVATE
-  PYTHON_ROOT="${PYTHON_ROOT}"
-)
-
 if(NOT WIN32)
   target_include_directories(${bun} PRIVATE ${CWD}/src/bun.js/bindings/libuv)
 endif()
@@ -952,7 +913,7 @@ if(WIN32)
 endif()
 
 if(USE_MIMALLOC_AS_DEFAULT_ALLOCATOR)
-  target_compile_definitions(${bun} PRIVATE USE_BUN_MIMALLOC=1)
+  target_compile_definitions(${bun} PRIVATE USE_MIMALLOC=1)
 endif()
 
 target_compile_definitions(${bun} PRIVATE
@@ -1238,35 +1199,11 @@ set_target_properties(${bun} PROPERTIES LINK_DEPENDS ${BUN_SYMBOLS_PATH})
 
 include(SetupWebKit)
 
-if(BUN_LINK_ONLY)
-  register_command(
-    TARGET
-      ${bun}
-    TARGET_PHASE
-      POST_BUILD
-    COMMENT
-      "Uploading link metadata"
-    COMMAND
-      ${CMAKE_COMMAND} -E env
-        BUN_VERSION=${VERSION}
-        WEBKIT_DOWNLOAD_URL=${WEBKIT_DOWNLOAD_URL}
-        WEBKIT_VERSION=${WEBKIT_VERSION}
-        ZIG_COMMIT=${ZIG_COMMIT}
-        ${BUN_EXECUTABLE} ${BUN_FLAGS} ${CWD}/scripts/create-link-metadata.mjs ${BUILD_PATH} ${bun}
-    SOURCES
-      ${BUN_ZIG_OUTPUT}
-      ${BUN_CPP_OUTPUT}
-    ARTIFACTS
-      ${BUILD_PATH}/link-metadata.json
-  )
-endif()
-
 if(WIN32)
   if(DEBUG)
     target_link_libraries(${bun} PRIVATE
       ${WEBKIT_LIB_PATH}/WTF.lib
       ${WEBKIT_LIB_PATH}/JavaScriptCore.lib
-      ${WEBKIT_LIB_PATH}/bmalloc.lib
       ${WEBKIT_LIB_PATH}/sicudtd.lib
       ${WEBKIT_LIB_PATH}/sicuind.lib
       ${WEBKIT_LIB_PATH}/sicuucd.lib
@@ -1275,7 +1212,6 @@ if(WIN32)
     target_link_libraries(${bun} PRIVATE
       ${WEBKIT_LIB_PATH}/WTF.lib
       ${WEBKIT_LIB_PATH}/JavaScriptCore.lib
-      ${WEBKIT_LIB_PATH}/bmalloc.lib
       ${WEBKIT_LIB_PATH}/sicudt.lib
       ${WEBKIT_LIB_PATH}/sicuin.lib
       ${WEBKIT_LIB_PATH}/sicuuc.lib
@@ -1286,18 +1222,13 @@ else()
     ${WEBKIT_LIB_PATH}/libWTF.a
     ${WEBKIT_LIB_PATH}/libJavaScriptCore.a
   )
-  if(WEBKIT_LOCAL OR NOT APPLE OR EXISTS ${WEBKIT_LIB_PATH}/libbmalloc.a)
+  if(NOT APPLE OR EXISTS ${WEBKIT_LIB_PATH}/libbmalloc.a)
     target_link_libraries(${bun} PRIVATE ${WEBKIT_LIB_PATH}/libbmalloc.a)
   endif()
 endif()
 
 include_directories(${WEBKIT_INCLUDE_PATH})
 
-# When building with a local WebKit, ensure JSC is built before compiling Bun's C++ sources.
-if(WEBKIT_LOCAL AND TARGET jsc)
-  add_dependencies(${bun} jsc)
-endif()
-
 # Include the generated dependency versions header
 include_directories(${CMAKE_BINARY_DIR})
 
@@ -1327,19 +1258,6 @@ if(APPLE)
   target_compile_definitions(${bun} PRIVATE U_DISABLE_RENAMING=1)
 endif()
 
-# --- Python ---
-# Link against shared Python library so extension modules can find symbols
-if(APPLE)
-  target_link_libraries(${bun} PRIVATE
-    "${PYTHON_ROOT}/lib/libpython${PYTHON_VERSION}.dylib"
-    "-framework CoreFoundation"
-  )
-else()
-  target_link_libraries(${bun} PRIVATE
-    "${PYTHON_ROOT}/lib/libpython${PYTHON_VERSION}.so"
-  )
-endif()
-
 if(USE_STATIC_SQLITE)
   target_compile_definitions(${bun} PRIVATE LAZY_LOAD_SQLITE=0)
 else()
@@ -1355,14 +1273,9 @@ if(LINUX)
     target_link_libraries(${bun} PUBLIC libatomic.so)
   endif()
 
-  if(WEBKIT_LOCAL)
-    find_package(ICU REQUIRED COMPONENTS data i18n uc)
-    target_link_libraries(${bun} PRIVATE ICU::data ICU::i18n ICU::uc)
-  else()
-    target_link_libraries(${bun} PRIVATE ${WEBKIT_LIB_PATH}/libicudata.a)
-    target_link_libraries(${bun} PRIVATE ${WEBKIT_LIB_PATH}/libicui18n.a)
-    target_link_libraries(${bun} PRIVATE ${WEBKIT_LIB_PATH}/libicuuc.a)
-  endif()
+  target_link_libraries(${bun} PRIVATE ${WEBKIT_LIB_PATH}/libicudata.a)
+  target_link_libraries(${bun} PRIVATE ${WEBKIT_LIB_PATH}/libicui18n.a)
+  target_link_libraries(${bun} PRIVATE ${WEBKIT_LIB_PATH}/libicuuc.a)
 endif()
 
 if(WIN32)
@@ -1376,9 +1289,6 @@ if(WIN32)
     wsock32 # ws2_32 required by TransmitFile aka sendfile on windows
     delayimp.lib
   )
-  # Required for static ICU linkage - without this, ICU headers expect DLL linkage
-  # which causes ABI mismatch and crashes (STATUS_STACK_BUFFER_OVERRUN)
-  target_compile_definitions(${bun} PRIVATE U_STATIC_IMPLEMENTATION)
 endif()
 
 # --- Packaging ---

cmake/targets/BuildCares.cmake

@@ -4,7 +4,7 @@ register_repository(
   REPOSITORY
     c-ares/c-ares
   COMMIT
-    3ac47ee46edd8ea40370222f91613fc16c434853
+    d3a507e920e7af18a5efb7f9f1d8044ed4750013
 )
 
 register_cmake_command(

cmake/targets/BuildHighway.cmake

@@ -20,15 +20,6 @@ set(HIGHWAY_CMAKE_ARGS
   -DHWY_ENABLE_INSTALL=OFF
 )
 
-# On Windows ARM64 with clang-cl, the __ARM_NEON macro isn't defined by default
-# but NEON intrinsics are supported. Define it so Highway can detect NEON support.
-if(WIN32 AND CMAKE_SYSTEM_PROCESSOR MATCHES "ARM64|aarch64|AARCH64")
-  list(APPEND HIGHWAY_CMAKE_ARGS
-    -DCMAKE_C_FLAGS=-D__ARM_NEON=1
-    -DCMAKE_CXX_FLAGS=-D__ARM_NEON=1
-  )
-endif()
-
 register_cmake_command(
   TARGET
     highway

cmake/targets/BuildLolHtml.cmake

@@ -4,7 +4,7 @@ register_repository(
   REPOSITORY
     cloudflare/lol-html
   COMMIT
-    e9e16dca48dd4a8ffbc77642bc4be60407585f11
+    d64457d9ff0143deef025d5df7e8586092b9afb7
 )
 
 set(LOLHTML_CWD ${VENDOR_PATH}/lolhtml/c-api)
@@ -33,37 +33,6 @@ if (NOT WIN32)
   set(RUSTFLAGS "-Cpanic=abort-Cdebuginfo=0-Cforce-unwind-tables=no-Copt-level=s")
 endif()
 
-# On Windows, ensure MSVC link.exe is used instead of Git's link.exe
-set(LOLHTML_ENV
-  CARGO_TERM_COLOR=always
-  CARGO_TERM_VERBOSE=true
-  CARGO_TERM_DIAGNOSTIC=true
-  CARGO_ENCODED_RUSTFLAGS=${RUSTFLAGS}
-  CARGO_HOME=${CARGO_HOME}
-  RUSTUP_HOME=${RUSTUP_HOME}
-)
-
-if(WIN32)
-  # On Windows, tell Rust to use MSVC link.exe directly via the target-specific linker env var.
-  # This avoids Git's /usr/bin/link being found first in PATH.
-  # Find the MSVC link.exe from Visual Studio installation
-  file(GLOB MSVC_VERSIONS "C:/Program Files/Microsoft Visual Studio/2022/*/VC/Tools/MSVC/*")
-  if(MSVC_VERSIONS)
-    list(GET MSVC_VERSIONS -1 MSVC_LATEST)  # Get the latest version
-    if(CMAKE_SYSTEM_PROCESSOR MATCHES "ARM64|aarch64")
-      set(MSVC_LINK_PATH "${MSVC_LATEST}/bin/HostARM64/arm64/link.exe")
-      set(CARGO_LINKER_VAR "CARGO_TARGET_AARCH64_PC_WINDOWS_MSVC_LINKER")
-    else()
-      set(MSVC_LINK_PATH "${MSVC_LATEST}/bin/Hostx64/x64/link.exe")
-      set(CARGO_LINKER_VAR "CARGO_TARGET_X86_64_PC_WINDOWS_MSVC_LINKER")
-    endif()
-    if(EXISTS "${MSVC_LINK_PATH}")
-      list(APPEND LOLHTML_ENV "${CARGO_LINKER_VAR}=${MSVC_LINK_PATH}")
-      message(STATUS "lolhtml: Using MSVC link.exe: ${MSVC_LINK_PATH}")
-    endif()
-  endif()
-endif()
-
 register_command(
   TARGET
     lolhtml
@@ -76,7 +45,12 @@ register_command(
   ARTIFACTS
     ${LOLHTML_LIBRARY}
   ENVIRONMENT
-    ${LOLHTML_ENV}
+    CARGO_TERM_COLOR=always
+    CARGO_TERM_VERBOSE=true
+    CARGO_TERM_DIAGNOSTIC=true
+    CARGO_ENCODED_RUSTFLAGS=${RUSTFLAGS}
+    CARGO_HOME=${CARGO_HOME}
+    RUSTUP_HOME=${RUSTUP_HOME}
 )
 
 target_link_libraries(${bun} PRIVATE ${LOLHTML_LIBRARY})

cmake/targets/BuildMimalloc.cmake

@@ -4,7 +4,7 @@ register_repository(
   REPOSITORY
     oven-sh/mimalloc
   COMMIT
-    ffa38ab8ac914f9eb7af75c1f8ad457643dc14f2
+    1beadf9651a7bfdec6b5367c380ecc3fe1c40d1a
 )
 
 set(MIMALLOC_CMAKE_ARGS
@@ -14,7 +14,7 @@ set(MIMALLOC_CMAKE_ARGS
   -DMI_BUILD_TESTS=OFF
   -DMI_USE_CXX=ON
   -DMI_SKIP_COLLECT_ON_EXIT=ON
-
+  
   # ```
   # ❯ mimalloc_allow_large_os_pages=0 BUN_PORT=3004 mem bun http-hello.js
   # Started development server: http://localhost:3004
@@ -51,7 +51,7 @@ if(ENABLE_ASAN)
   list(APPEND MIMALLOC_CMAKE_ARGS -DMI_DEBUG_UBSAN=ON)
 elseif(APPLE OR LINUX)
   if(APPLE)
-    list(APPEND MIMALLOC_CMAKE_ARGS -DMI_OVERRIDE=OFF)
+    list(APPEND MIMALLOC_CMAKE_ARGS -DMI_OVERRIDE=OFF)  
     list(APPEND MIMALLOC_CMAKE_ARGS -DMI_OSX_ZONE=OFF)
     list(APPEND MIMALLOC_CMAKE_ARGS -DMI_OSX_INTERPOSE=OFF)
   else()
@@ -69,27 +69,17 @@ if(ENABLE_VALGRIND)
   list(APPEND MIMALLOC_CMAKE_ARGS -DMI_VALGRIND=ON)
 endif()
 
-# Enable architecture-specific optimizations when not building for baseline.
-# On Linux aarch64, upstream mimalloc force-enables MI_OPT_ARCH which adds
-# -march=armv8.1-a (LSE atomics). This crashes on ARMv8.0 CPUs
-# (Cortex-A53, Raspberry Pi 4, AWS a1 instances). Use MI_NO_OPT_ARCH
-# to prevent that, but keep SIMD enabled. -moutline-atomics for runtime
-# dispatch to LSE/LL-SC. macOS arm64 always has LSE (Apple Silicon) so
-# MI_OPT_ARCH is safe there.
-if(CMAKE_SYSTEM_PROCESSOR MATCHES "aarch64|arm64|ARM64|AARCH64" AND NOT APPLE)
-  list(APPEND MIMALLOC_CMAKE_ARGS -DMI_NO_OPT_ARCH=ON)
-  list(APPEND MIMALLOC_CMAKE_ARGS -DMI_OPT_SIMD=ON)
-  list(APPEND MIMALLOC_CMAKE_ARGS "-DCMAKE_C_FLAGS=-moutline-atomics")
-elseif(NOT ENABLE_BASELINE)
+# Enable SIMD optimizations when not building for baseline (older CPUs)
+if(NOT ENABLE_BASELINE)
   list(APPEND MIMALLOC_CMAKE_ARGS -DMI_OPT_ARCH=ON)
   list(APPEND MIMALLOC_CMAKE_ARGS -DMI_OPT_SIMD=ON)
 endif()
 
 if(WIN32)
   if(DEBUG)
-    set(MIMALLOC_LIBRARY mimalloc-debug)
+    set(MIMALLOC_LIBRARY mimalloc-static-debug)
   else()
-    set(MIMALLOC_LIBRARY mimalloc)
+    set(MIMALLOC_LIBRARY mimalloc-static)
   endif()
 elseif(DEBUG)
   if (ENABLE_ASAN)

cmake/targets/BuildTinyCC.cmake

@@ -4,7 +4,7 @@ register_repository(
   REPOSITORY
     oven-sh/tinycc
   COMMIT
-    12882eee073cfe5c7621bcfadf679e1372d4537b
+    29985a3b59898861442fa3b43f663fc1af2591d7
 )
 
 register_cmake_command(

cmake/toolchains/windows-aarch64.cmake

@@ -1,20 +0,0 @@
-set(CMAKE_SYSTEM_NAME Windows)
-set(CMAKE_SYSTEM_PROCESSOR aarch64)
-
-set(CMAKE_C_COMPILER_WORKS ON)
-set(CMAKE_CXX_COMPILER_WORKS ON)
-
-# Force ARM64 architecture ID - this is what CMake uses to determine /machine: flag
-set(MSVC_C_ARCHITECTURE_ID ARM64 CACHE INTERNAL "")
-set(MSVC_CXX_ARCHITECTURE_ID ARM64 CACHE INTERNAL "")
-
-# CMake 4.0+ policy CMP0197 controls how MSVC machine type flags are handled
-set(CMAKE_POLICY_DEFAULT_CMP0197 NEW CACHE INTERNAL "")
-
-# Clear any inherited static linker flags that might have wrong machine types
-set(CMAKE_STATIC_LINKER_FLAGS "" CACHE STRING "" FORCE)
-
-# Use wrapper script for llvm-lib that strips /machine:x64 flags
-# This works around CMake 4.1.0 bug where both ARM64 and x64 machine flags are added
-get_filename_component(_TOOLCHAIN_DIR "${CMAKE_CURRENT_LIST_DIR}" DIRECTORY)
-set(CMAKE_AR "${_TOOLCHAIN_DIR}/scripts/llvm-lib-wrapper.bat" CACHE FILEPATH "" FORCE)

cmake/tools/SetupBuildkite.cmake

@@ -6,8 +6,7 @@ endif()
 
 optionx(BUILDKITE_ORGANIZATION_SLUG STRING "The organization slug to use on Buildkite" DEFAULT "bun")
 optionx(BUILDKITE_PIPELINE_SLUG STRING "The pipeline slug to use on Buildkite" DEFAULT "bun")
-optionx(BUILDKITE_BUILD_ID STRING "The build ID (UUID) to use on Buildkite")
-optionx(BUILDKITE_BUILD_NUMBER STRING "The build number to use on Buildkite")
+optionx(BUILDKITE_BUILD_ID STRING "The build ID to use on Buildkite")
 optionx(BUILDKITE_GROUP_ID STRING "The group ID to use on Buildkite")
 
 if(ENABLE_BASELINE)
@@ -33,13 +32,7 @@ if(NOT BUILDKITE_BUILD_ID)
   return()
 endif()
 
-# Use BUILDKITE_BUILD_NUMBER for the URL if available, as the UUID format causes a 302 redirect
-# that CMake's file(DOWNLOAD) doesn't follow, resulting in empty response.
-if(BUILDKITE_BUILD_NUMBER)
-  setx(BUILDKITE_BUILD_URL https://buildkite.com/${BUILDKITE_ORGANIZATION_SLUG}/${BUILDKITE_PIPELINE_SLUG}/builds/${BUILDKITE_BUILD_NUMBER})
-else()
-  setx(BUILDKITE_BUILD_URL https://buildkite.com/${BUILDKITE_ORGANIZATION_SLUG}/${BUILDKITE_PIPELINE_SLUG}/builds/${BUILDKITE_BUILD_ID})
-endif()
+setx(BUILDKITE_BUILD_URL https://buildkite.com/${BUILDKITE_ORGANIZATION_SLUG}/${BUILDKITE_PIPELINE_SLUG}/builds/${BUILDKITE_BUILD_ID})
 setx(BUILDKITE_BUILD_PATH ${BUILDKITE_BUILDS_PATH}/builds/${BUILDKITE_BUILD_ID})
 
 file(
@@ -55,17 +48,6 @@ if(NOT BUILDKITE_BUILD_STATUS EQUAL 0)
 endif()
 
 file(READ ${BUILDKITE_BUILD_PATH}/build.json BUILDKITE_BUILD)
-# CMake's string(JSON ...) interprets escape sequences like \n, \r, \t.
-# We need to escape these specific sequences while preserving valid JSON escapes like \" and \\.
-# Strategy: Use a unique placeholder to protect \\ sequences, escape \n/\r/\t, then restore \\.
-# This prevents \\n (literal backslash + n) from being corrupted to \\\n.
-set(BKSLASH_PLACEHOLDER "___BKSLASH_PLACEHOLDER_7f3a9b2c___")
-string(REPLACE "\\\\" "${BKSLASH_PLACEHOLDER}" BUILDKITE_BUILD "${BUILDKITE_BUILD}")
-string(REPLACE "\\n" "\\\\n" BUILDKITE_BUILD "${BUILDKITE_BUILD}")
-string(REPLACE "\\r" "\\\\r" BUILDKITE_BUILD "${BUILDKITE_BUILD}")
-string(REPLACE "\\t" "\\\\t" BUILDKITE_BUILD "${BUILDKITE_BUILD}")
-string(REPLACE "${BKSLASH_PLACEHOLDER}" "\\\\" BUILDKITE_BUILD "${BUILDKITE_BUILD}")
-
 string(JSON BUILDKITE_BUILD_UUID GET ${BUILDKITE_BUILD} id)
 string(JSON BUILDKITE_JOBS GET ${BUILDKITE_BUILD} jobs)
 string(JSON BUILDKITE_JOBS_COUNT LENGTH ${BUILDKITE_JOBS})

cmake/tools/SetupBun.cmake

@@ -17,14 +17,6 @@ if (NOT CI)
   set(BUN_EXECUTABLE ${BUN_EXECUTABLE} CACHE FILEPATH "Bun executable" FORCE)
 endif()
 
-# On Windows ARM64, we need to add --smol flag to avoid crashes when running
-# x64 bun under WoW64 emulation
-if(WIN32 AND ARCH STREQUAL "aarch64")
-  set(BUN_FLAGS "--smol" CACHE STRING "Extra flags for bun executable")
-else()
-  set(BUN_FLAGS "" CACHE STRING "Extra flags for bun executable")
-endif()
-
 # If this is not set, some advanced features are not checked.
 # https://github.com/oven-sh/bun/blob/cd7f6a1589db7f1e39dc4e3f4a17234afbe7826c/src/bun.js/javascript.zig#L1069-L1072
 setenv(BUN_GARBAGE_COLLECTOR_LEVEL 1)

cmake/tools/SetupCcache.cmake

@@ -5,12 +5,18 @@ if(NOT ENABLE_CCACHE OR CACHE_STRATEGY STREQUAL "none")
   return()
 endif()
 
+if (CI AND NOT APPLE)
+  setenv(CCACHE_DISABLE 1)
+  return()
+endif()
 
 find_command(
   VARIABLE
     CCACHE_PROGRAM
   COMMAND
     ccache
+  REQUIRED
+    ${CI}
 )
 
 if(NOT CCACHE_PROGRAM)

cmake/tools/SetupLLVM.cmake

@@ -12,13 +12,7 @@ if(NOT ENABLE_LLVM)
   return()
 endif()
 
-# LLVM 21 is required for Windows ARM64 (first version with ARM64 Windows builds)
-# Other platforms use LLVM 19.1.7
-if(WIN32 AND CMAKE_SYSTEM_PROCESSOR MATCHES "ARM64|aarch64|AARCH64")
-  set(DEFAULT_LLVM_VERSION "21.1.8")
-else()
-  set(DEFAULT_LLVM_VERSION "19.1.7")
-endif()
+set(DEFAULT_LLVM_VERSION "19.1.7")
 
 optionx(LLVM_VERSION STRING "The version of LLVM to use" DEFAULT ${DEFAULT_LLVM_VERSION})
 

cmake/tools/SetupMacSDK.cmake

@@ -31,6 +31,13 @@ execute_process(
   ERROR_QUIET
 )
 
+if(MACOS_VERSION VERSION_LESS ${CMAKE_OSX_DEPLOYMENT_TARGET})
+  message(FATAL_ERROR "Your computer is running macOS ${MACOS_VERSION}, which is older than the target macOS SDK ${CMAKE_OSX_DEPLOYMENT_TARGET}. To fix this, either:\n"
+    " - Upgrade your computer to macOS ${CMAKE_OSX_DEPLOYMENT_TARGET} or newer\n"
+    " - Download a newer version of the macOS SDK from Apple: https://developer.apple.com/download/all/?q=xcode\n"
+    " - Set -DCMAKE_OSX_DEPLOYMENT_TARGET=${MACOS_VERSION}\n")
+endif()
+
 execute_process(
   COMMAND xcrun --sdk macosx --show-sdk-path
   OUTPUT_VARIABLE DEFAULT_CMAKE_OSX_SYSROOT

cmake/tools/SetupSccache.cmake

@@ -0,0 +1,123 @@
+# Setup sccache as the C and C++ compiler launcher to speed up builds by caching
+if(CACHE_STRATEGY STREQUAL "none")
+  return()
+endif()
+
+set(SCCACHE_SHARED_CACHE_REGION "us-west-1")
+set(SCCACHE_SHARED_CACHE_BUCKET "bun-build-sccache-store")
+
+# Function to check if the system AWS credentials have access to the sccache S3 bucket.
+function(check_aws_credentials OUT_VAR)
+  # Install dependencies first
+  execute_process(
+    COMMAND ${BUN_EXECUTABLE} install --frozen-lockfile
+    WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}/scripts/build-cache
+    RESULT_VARIABLE INSTALL_EXIT_CODE
+    OUTPUT_VARIABLE INSTALL_OUTPUT
+    ERROR_VARIABLE INSTALL_ERROR
+  )
+
+  if(NOT INSTALL_EXIT_CODE EQUAL 0)
+    message(FATAL_ERROR "Failed to install dependencies in scripts/build-cache\n"
+      "Exit code: ${INSTALL_EXIT_CODE}\n"
+      "Output: ${INSTALL_OUTPUT}\n"
+      "Error: ${INSTALL_ERROR}")
+  endif()
+
+  # Check AWS credentials
+  execute_process(
+    COMMAND
+      ${BUN_EXECUTABLE}
+      run
+      have-access.ts
+      --bucket ${SCCACHE_SHARED_CACHE_BUCKET}
+      --region ${SCCACHE_SHARED_CACHE_REGION}
+    WORKING_DIRECTORY
+      ${CMAKE_SOURCE_DIR}/scripts/build-cache
+    RESULT_VARIABLE HAVE_ACCESS_EXIT_CODE
+  )
+
+  if(HAVE_ACCESS_EXIT_CODE EQUAL 0)
+    set(HAS_CREDENTIALS TRUE)
+  else()
+    set(HAS_CREDENTIALS FALSE)
+  endif()
+
+  set(${OUT_VAR} ${HAS_CREDENTIALS} PARENT_SCOPE)
+endfunction()
+
+# Configure sccache to use the local cache only.
+function(sccache_configure_local_filesystem)
+  unsetenv(SCCACHE_BUCKET)
+  unsetenv(SCCACHE_REGION)
+  setenv(SCCACHE_DIR "${CACHE_PATH}/sccache")
+endfunction()
+
+# Configure sccache to use the distributed cache (S3 + local).
+function(sccache_configure_distributed)
+  setenv(SCCACHE_BUCKET "${SCCACHE_SHARED_CACHE_BUCKET}")
+  setenv(SCCACHE_REGION "${SCCACHE_SHARED_CACHE_REGION}")
+  setenv(SCCACHE_DIR "${CACHE_PATH}/sccache")
+endfunction()
+
+function(sccache_configure_environment_ci)
+  if(CACHE_STRATEGY STREQUAL "auto" OR CACHE_STRATEGY STREQUAL "distributed")
+    check_aws_credentials(HAS_AWS_CREDENTIALS)
+    if(HAS_AWS_CREDENTIALS)
+      sccache_configure_distributed()
+      message(NOTICE "sccache: Using distributed cache strategy.")
+    else()
+      message(FATAL_ERROR "CI CACHE_STRATEGY is set to '${CACHE_STRATEGY}', but no valid AWS "
+        "credentials were found. Note that 'auto' requires AWS credentials to access the shared "
+        "cache in CI.")
+    endif()
+  elseif(CACHE_STRATEGY STREQUAL "local")
+    # We disallow this because we want our CI runs to always used the shared cache to accelerate
+    # builds.
+    # none, distributed and auto are all okay.
+    #
+    # If local is configured, it's as good as "none", so this is probably user error.
+    message(FATAL_ERROR "CI CACHE_STRATEGY is set to 'local', which is not allowed.")
+  endif()
+endfunction()
+
+function(sccache_configure_environment_developer)
+  # Local environments can use any strategy they like. S3 is set up in such a way so as to clean
+  # itself from old entries automatically.
+  if (CACHE_STRATEGY STREQUAL "auto" OR CACHE_STRATEGY STREQUAL "local")
+    # In the local environment, we prioritize using the local cache. This is because sccache takes
+    # into consideration the whole absolute path of the files being compiled, and it's very
+    # unlikely users will have the same absolute paths on their local machines.
+    sccache_configure_local_filesystem()
+    message(NOTICE "sccache: Using local cache strategy.")
+  elseif(CACHE_STRATEGY STREQUAL "distributed")
+    check_aws_credentials(HAS_AWS_CREDENTIALS)
+    if(HAS_AWS_CREDENTIALS)
+      sccache_configure_distributed()
+      message(NOTICE "sccache: Using distributed cache strategy.")
+    else()
+      message(FATAL_ERROR "CACHE_STRATEGY is set to 'distributed', but no valid AWS credentials "
+        "were found.")
+    endif()
+  endif()
+endfunction()
+
+find_command(VARIABLE SCCACHE_PROGRAM COMMAND sccache REQUIRED ${CI})
+if(NOT SCCACHE_PROGRAM)
+  message(WARNING "sccache not found. Your builds will be slower.")
+  return()
+endif()
+
+set(SCCACHE_ARGS CMAKE_C_COMPILER_LAUNCHER CMAKE_CXX_COMPILER_LAUNCHER)
+foreach(arg ${SCCACHE_ARGS})
+  setx(${arg} ${SCCACHE_PROGRAM})
+  list(APPEND CMAKE_ARGS -D${arg}=${${arg}})
+endforeach()
+
+setenv(SCCACHE_LOG "info")
+
+if (CI)
+  sccache_configure_environment_ci()
+else()
+  sccache_configure_environment_developer()
+endif()

cmake/tools/SetupWebKit.cmake

@@ -1,25 +1,14 @@
-# NOTE: Changes to this file trigger QEMU JIT stress tests in CI.
-# See scripts/verify-jit-stress-qemu.sh for details.
-
 option(WEBKIT_VERSION "The version of WebKit to use")
 option(WEBKIT_LOCAL "If a local version of WebKit should be used instead of downloading")
-option(WEBKIT_BUILD_TYPE "The build type for local WebKit (defaults to CMAKE_BUILD_TYPE)")
 
 if(NOT WEBKIT_VERSION)
-  set(WEBKIT_VERSION 515344bc5d65aa2d4f9ff277b5fb944f0e051dcd)
+  set(WEBKIT_VERSION 6d0f3aac0b817cc01a846b3754b21271adedac12)
 endif()
 
-# Use preview build URL for Windows ARM64 until the fix is merged to main
-set(WEBKIT_PREVIEW_PR 140)
-
 string(SUBSTRING ${WEBKIT_VERSION} 0 16 WEBKIT_VERSION_PREFIX)
-string(SUBSTRING ${WEBKIT_VERSION} 0 8 WEBKIT_VERSION_SHORT)
 
 if(WEBKIT_LOCAL)
-  if(NOT WEBKIT_BUILD_TYPE)
-    set(WEBKIT_BUILD_TYPE ${CMAKE_BUILD_TYPE})
-  endif()
-  set(DEFAULT_WEBKIT_PATH ${VENDOR_PATH}/WebKit/WebKitBuild/${WEBKIT_BUILD_TYPE})
+  set(DEFAULT_WEBKIT_PATH ${VENDOR_PATH}/WebKit/WebKitBuild/${CMAKE_BUILD_TYPE})
 else()
   set(DEFAULT_WEBKIT_PATH ${CACHE_PATH}/webkit-${WEBKIT_VERSION_PREFIX})
 endif()
@@ -34,153 +23,18 @@ set(WEBKIT_INCLUDE_PATH ${WEBKIT_PATH}/include)
 set(WEBKIT_LIB_PATH ${WEBKIT_PATH}/lib)
 
 if(WEBKIT_LOCAL)
-  set(WEBKIT_SOURCE_DIR ${VENDOR_PATH}/WebKit)
-
-  if(WIN32)
-    # --- Build ICU from source (Windows only) ---
-    # On macOS, ICU is found automatically (Homebrew icu4c for headers, system for libs).
-    # On Linux, ICU is found automatically from system packages (e.g. libicu-dev).
-    # On Windows, there is no system ICU, so we build it from source.
-    set(ICU_LOCAL_ROOT ${VENDOR_PATH}/WebKit/WebKitBuild/icu)
-    if(NOT EXISTS ${ICU_LOCAL_ROOT}/lib/sicudt.lib)
-      message(STATUS "Building ICU from source...")
-      if(CMAKE_SYSTEM_PROCESSOR MATCHES "arm64|ARM64|aarch64|AARCH64")
-        set(ICU_PLATFORM "ARM64")
-      else()
-        set(ICU_PLATFORM "x64")
-      endif()
-      execute_process(
-        COMMAND powershell -ExecutionPolicy Bypass -File
-          ${WEBKIT_SOURCE_DIR}/build-icu.ps1
-          -Platform ${ICU_PLATFORM}
-          -BuildType ${WEBKIT_BUILD_TYPE}
-          -OutputDir ${ICU_LOCAL_ROOT}
-        RESULT_VARIABLE ICU_BUILD_RESULT
-      )
-      if(NOT ICU_BUILD_RESULT EQUAL 0)
-        message(FATAL_ERROR "Failed to build ICU (exit code: ${ICU_BUILD_RESULT}).")
-      endif()
-    endif()
-
-    # Copy ICU libs to WEBKIT_LIB_PATH with the names BuildBun.cmake expects.
-    # Prebuilt WebKit uses 's' prefix (static) and 'd' suffix (debug).
-    file(MAKE_DIRECTORY ${WEBKIT_LIB_PATH})
-    if(WEBKIT_BUILD_TYPE STREQUAL "Debug")
-      set(ICU_SUFFIX "d")
-    else()
-      set(ICU_SUFFIX "")
-    endif()
-    file(COPY_FILE ${ICU_LOCAL_ROOT}/lib/sicudt.lib ${WEBKIT_LIB_PATH}/sicudt${ICU_SUFFIX}.lib ONLY_IF_DIFFERENT)
-    file(COPY_FILE ${ICU_LOCAL_ROOT}/lib/icuin.lib ${WEBKIT_LIB_PATH}/sicuin${ICU_SUFFIX}.lib ONLY_IF_DIFFERENT)
-    file(COPY_FILE ${ICU_LOCAL_ROOT}/lib/icuuc.lib ${WEBKIT_LIB_PATH}/sicuuc${ICU_SUFFIX}.lib ONLY_IF_DIFFERENT)
-  endif()
-
-  # --- Configure JSC ---
-  message(STATUS "Configuring JSC from local WebKit source at ${WEBKIT_SOURCE_DIR}...")
-
-  set(JSC_CMAKE_ARGS
-    -S ${WEBKIT_SOURCE_DIR}
-    -B ${WEBKIT_PATH}
-    -G ${CMAKE_GENERATOR}
-    -DPORT=JSCOnly
-    -DENABLE_STATIC_JSC=ON
-    -DUSE_THIN_ARCHIVES=OFF
-    -DENABLE_FTL_JIT=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
-    -DCMAKE_BUILD_TYPE=${WEBKIT_BUILD_TYPE}
-    -DCMAKE_C_COMPILER=${CMAKE_C_COMPILER}
-    -DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}
-    -DENABLE_REMOTE_INSPECTOR=ON
-  )
-
-  if(WIN32)
-    # ICU paths and Windows-specific compiler/linker settings
-    list(APPEND JSC_CMAKE_ARGS
-      -DICU_ROOT=${ICU_LOCAL_ROOT}
-      -DICU_LIBRARY=${ICU_LOCAL_ROOT}/lib
-      -DICU_INCLUDE_DIR=${ICU_LOCAL_ROOT}/include
-      -DCMAKE_LINKER=lld-link
+  if(EXISTS ${WEBKIT_PATH}/cmakeconfig.h)
+    # You may need to run:
+    # make jsc-compile-debug jsc-copy-headers
+    include_directories(
+      ${WEBKIT_PATH}
+      ${WEBKIT_PATH}/JavaScriptCore/Headers/JavaScriptCore
+      ${WEBKIT_PATH}/JavaScriptCore/PrivateHeaders
+      ${WEBKIT_PATH}/bmalloc/Headers
+      ${WEBKIT_PATH}/WTF/Headers
+      ${WEBKIT_PATH}/JavaScriptCore/DerivedSources/inspector
+      ${WEBKIT_PATH}/JavaScriptCore/PrivateHeaders/JavaScriptCore
     )
-    # Static CRT and U_STATIC_IMPLEMENTATION
-    if(WEBKIT_BUILD_TYPE STREQUAL "Debug")
-      set(JSC_MSVC_RUNTIME "MultiThreadedDebug")
-    else()
-      set(JSC_MSVC_RUNTIME "MultiThreaded")
-    endif()
-    list(APPEND JSC_CMAKE_ARGS
-      -DCMAKE_MSVC_RUNTIME_LIBRARY=${JSC_MSVC_RUNTIME}
-      "-DCMAKE_C_FLAGS=/DU_STATIC_IMPLEMENTATION"
-      "-DCMAKE_CXX_FLAGS=/DU_STATIC_IMPLEMENTATION /clang:-fno-c++-static-destructors"
-    )
-  endif()
-
-  if(ENABLE_ASAN)
-    list(APPEND JSC_CMAKE_ARGS -DENABLE_SANITIZERS=address)
-  endif()
-
-  # Pass through ccache if available
-  if(CMAKE_C_COMPILER_LAUNCHER)
-    list(APPEND JSC_CMAKE_ARGS -DCMAKE_C_COMPILER_LAUNCHER=${CMAKE_C_COMPILER_LAUNCHER})
-  endif()
-  if(CMAKE_CXX_COMPILER_LAUNCHER)
-    list(APPEND JSC_CMAKE_ARGS -DCMAKE_CXX_COMPILER_LAUNCHER=${CMAKE_CXX_COMPILER_LAUNCHER})
-  endif()
-
-  execute_process(
-    COMMAND ${CMAKE_COMMAND} ${JSC_CMAKE_ARGS}
-    RESULT_VARIABLE JSC_CONFIGURE_RESULT
-  )
-  if(NOT JSC_CONFIGURE_RESULT EQUAL 0)
-    message(FATAL_ERROR "Failed to configure JSC (exit code: ${JSC_CONFIGURE_RESULT}). "
-      "Check the output above for errors.")
-  endif()
-
-  if(WIN32)
-    set(JSC_BYPRODUCTS
-      ${WEBKIT_LIB_PATH}/JavaScriptCore.lib
-      ${WEBKIT_LIB_PATH}/WTF.lib
-      ${WEBKIT_LIB_PATH}/bmalloc.lib
-    )
-  else()
-    set(JSC_BYPRODUCTS
-      ${WEBKIT_LIB_PATH}/libJavaScriptCore.a
-      ${WEBKIT_LIB_PATH}/libWTF.a
-      ${WEBKIT_LIB_PATH}/libbmalloc.a
-    )
-  endif()
-
-  if(WIN32)
-    add_custom_target(jsc ALL
-      COMMAND ${CMAKE_COMMAND} --build ${WEBKIT_PATH} --config ${WEBKIT_BUILD_TYPE} --target jsc
-      BYPRODUCTS ${JSC_BYPRODUCTS}
-      COMMENT "Building JSC (${WEBKIT_PATH})"
-    )
-  else()
-    add_custom_target(jsc ALL
-      COMMAND ${CMAKE_COMMAND} --build ${WEBKIT_PATH} --config ${WEBKIT_BUILD_TYPE} --target jsc
-      BYPRODUCTS ${JSC_BYPRODUCTS}
-      COMMENT "Building JSC (${WEBKIT_PATH})"
-      USES_TERMINAL
-    )
-  endif()
-
-  include_directories(
-    ${WEBKIT_PATH}
-    ${WEBKIT_PATH}/JavaScriptCore/Headers
-    ${WEBKIT_PATH}/JavaScriptCore/Headers/JavaScriptCore
-    ${WEBKIT_PATH}/JavaScriptCore/PrivateHeaders
-    ${WEBKIT_PATH}/bmalloc/Headers
-    ${WEBKIT_PATH}/WTF/Headers
-    ${WEBKIT_PATH}/JavaScriptCore/PrivateHeaders/JavaScriptCore
-  )
-
-  # On Windows, add ICU headers from the local ICU build
-  if(WIN32)
-    include_directories(${ICU_LOCAL_ROOT}/include)
   endif()
 
   # After this point, only prebuilt WebKit is supported
@@ -197,7 +51,7 @@ else()
   message(FATAL_ERROR "Unsupported operating system: ${CMAKE_SYSTEM_NAME}")
 endif()
 
-if(CMAKE_SYSTEM_PROCESSOR MATCHES "arm64|ARM64|aarch64|AARCH64")
+if(CMAKE_SYSTEM_PROCESSOR MATCHES "arm64|aarch64")
   set(WEBKIT_ARCH "arm64")
 elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "amd64|x86_64|x64|AMD64")
   set(WEBKIT_ARCH "amd64")
@@ -226,14 +80,7 @@ endif()
 
 setx(WEBKIT_NAME bun-webkit-${WEBKIT_OS}-${WEBKIT_ARCH}${WEBKIT_SUFFIX})
 set(WEBKIT_FILENAME ${WEBKIT_NAME}.tar.gz)
-
-if(WEBKIT_VERSION MATCHES "^autobuild-")
-  set(WEBKIT_TAG ${WEBKIT_VERSION})
-else()
-  set(WEBKIT_TAG autobuild-${WEBKIT_VERSION})
-endif()
-
-setx(WEBKIT_DOWNLOAD_URL https://github.com/oven-sh/WebKit/releases/download/${WEBKIT_TAG}/${WEBKIT_FILENAME})
+setx(WEBKIT_DOWNLOAD_URL https://github.com/oven-sh/WebKit/releases/download/autobuild-${WEBKIT_VERSION}/${WEBKIT_FILENAME})
 
 if(EXISTS ${WEBKIT_PATH}/package.json)
   file(READ ${WEBKIT_PATH}/package.json WEBKIT_PACKAGE_JSON)
@@ -243,14 +90,7 @@ if(EXISTS ${WEBKIT_PATH}/package.json)
   endif()
 endif()
 
-file(
-  DOWNLOAD ${WEBKIT_DOWNLOAD_URL} ${CACHE_PATH}/${WEBKIT_FILENAME} SHOW_PROGRESS
-  STATUS WEBKIT_DOWNLOAD_STATUS
-)
-if(NOT "${WEBKIT_DOWNLOAD_STATUS}" MATCHES "^0;")
-  message(FATAL_ERROR "Failed to download WebKit: ${WEBKIT_DOWNLOAD_STATUS}")
-endif()
-
+file(DOWNLOAD ${WEBKIT_DOWNLOAD_URL} ${CACHE_PATH}/${WEBKIT_FILENAME} SHOW_PROGRESS)
 file(ARCHIVE_EXTRACT INPUT ${CACHE_PATH}/${WEBKIT_FILENAME} DESTINATION ${CACHE_PATH} TOUCH)
 file(REMOVE ${CACHE_PATH}/${WEBKIT_FILENAME})
 file(REMOVE_RECURSE ${WEBKIT_PATH})

cmake/tools/SetupZig.cmake

@@ -1,4 +1,4 @@
-if(CMAKE_SYSTEM_PROCESSOR MATCHES "arm64|ARM64|aarch64|AARCH64")
+if(CMAKE_SYSTEM_PROCESSOR MATCHES "arm64|aarch64")
   set(DEFAULT_ZIG_ARCH "aarch64")
 elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "amd64|x86_64|x64|AMD64")
   set(DEFAULT_ZIG_ARCH "x86_64")

completions/bun.fish

@@ -35,8 +35,8 @@ end
 set -l bun_install_boolean_flags yarn production optional development no-save dry-run force no-cache silent verbose global
 set -l bun_install_boolean_flags_descriptions "Write a yarn.lock file (yarn v1)" "Don't install devDependencies" "Add dependency to optionalDependencies" "Add dependency to devDependencies" "Don't update package.json or save a lockfile" "Don't install anything" "Always request the latest versions from the registry & reinstall all dependencies" "Ignore manifest cache entirely" "Don't output anything" "Excessively verbose logging" "Use global folder"
 
-set -l bun_builtin_cmds_without_run dev create help bun upgrade discord install remove add update init pm x
-set -l bun_builtin_cmds_accepting_flags create help bun upgrade discord run init link unlink pm x update
+set -l bun_builtin_cmds_without_run dev create help bun upgrade discord install remove add init pm x
+set -l bun_builtin_cmds_accepting_flags create help bun upgrade discord run init link unlink pm x
 
 function __bun_complete_bins_scripts --inherit-variable bun_builtin_cmds_without_run -d "Emit bun completions for bins and scripts"
     # Do nothing if we already have a builtin subcommand,
@@ -148,14 +148,14 @@ complete -c bun \
 
 for i in (seq (count $bun_install_boolean_flags))
 	complete -c bun \
-		-n "__fish_seen_subcommand_from install add remove update" -l "$bun_install_boolean_flags[$i]" -d "$bun_install_boolean_flags_descriptions[$i]"
+		-n "__fish_seen_subcommand_from install add remove" -l "$bun_install_boolean_flags[$i]" -d "$bun_install_boolean_flags_descriptions[$i]"
 end
 
 complete -c bun \
-	-n "__fish_seen_subcommand_from install add remove update" -l 'cwd' -d 'Change working directory'
+	-n "__fish_seen_subcommand_from install add remove" -l 'cwd' -d 'Change working directory'
 
 complete -c bun \
-	-n "__fish_seen_subcommand_from install add remove update" -l 'cache-dir' -d 'Choose a cache directory (default: $HOME/.bun/install/cache)'
+	-n "__fish_seen_subcommand_from install add remove" -l 'cache-dir' -d 'Choose a cache directory (default: $HOME/.bun/install/cache)'
 
 complete -c bun \
 	-n "__fish_seen_subcommand_from add" -d 'Popular' -a '(__fish__get_bun_packages)'
@@ -183,5 +183,4 @@ complete -c bun -n "__fish_use_subcommand" -a "unlink" -d "Unregister a local np
 complete -c bun -n "__fish_use_subcommand" -a "pm" -d "Additional package management utilities" -f
 complete -c bun -n "__fish_use_subcommand" -a "x" -d "Execute a package binary, installing if needed" -f
 complete -c bun -n "__fish_use_subcommand" -a "outdated" -d "Display the latest versions of outdated dependencies" -f
-complete -c bun -n "__fish_use_subcommand" -a "update" -d "Update dependencies to their latest versions" -f
 complete -c bun -n "__fish_use_subcommand" -a "publish" -d "Publish your package from local to npm" -f

dockerhub/debian-slim/Dockerfile

@@ -1,4 +1,4 @@
-FROM debian:trixie-slim AS build
+FROM debian:bookworm-slim AS build
 
 # https://github.com/oven-sh/bun/releases
 ARG BUN_VERSION=latest
@@ -55,7 +55,7 @@ RUN apt-get update -qq \
     && which bun \
     && bun --version
 
-FROM debian:trixie-slim
+FROM debian:bookworm-slim
 
 # Disable the runtime transpiler cache by default inside Docker containers.
 # On ephemeral containers, the cache is not useful

dockerhub/debian/Dockerfile

@@ -1,4 +1,4 @@
-FROM debian:trixie-slim AS build
+FROM debian:bookworm-slim AS build
 
 # https://github.com/oven-sh/bun/releases
 ARG BUN_VERSION=latest
@@ -56,7 +56,7 @@ RUN apt-get update -qq \
     && rm -f "bun-linux-$build.zip" SHASUMS256.txt.asc SHASUMS256.txt \
     && chmod +x /usr/local/bin/bun
 
-FROM debian:trixie
+FROM debian:bookworm
 
 COPY docker-entrypoint.sh /usr/local/bin
 COPY --from=build /usr/local/bin/bun /usr/local/bin/bun

dockerhub/distroless/Dockerfile

@@ -1,4 +1,4 @@
-FROM debian:trixie-slim AS build
+FROM debian:bookworm-slim AS build
 
 # https://github.com/oven-sh/bun/releases
 ARG BUN_VERSION=latest
@@ -55,7 +55,7 @@ RUN apt-get update -qq \
     && which bun \
     && bun --version
 
-FROM gcr.io/distroless/base-nossl-debian13
+FROM gcr.io/distroless/base-nossl-debian11
 
 # Disable the runtime transpiler cache by default inside Docker containers.
 # On ephemeral containers, the cache is not useful
@@ -71,7 +71,6 @@ ENV PATH "${PATH}:/usr/local/bun-node-fallback-bin"
 
 # Temporarily use the `build`-stage image binaries to create a symlink:
 RUN --mount=type=bind,from=build,source=/usr/bin,target=/usr/bin \
-    --mount=type=bind,from=build,source=/etc/alternatives/which,target=/etc/alternatives/which \
     --mount=type=bind,from=build,source=/bin,target=/bin \
     --mount=type=bind,from=build,source=/usr/lib,target=/usr/lib \
     --mount=type=bind,from=build,source=/lib,target=/lib \

docs/bundler/bytecode.mdx

@@ -7,9 +7,9 @@ Bytecode caching is a build-time optimization that dramatically improves applica
 
 ## Usage
 
-### Basic usage (CommonJS)
+### Basic usage
 
-Enable bytecode caching with the `--bytecode` flag. Without `--format`, this defaults to CommonJS:
+Enable bytecode caching with the `--bytecode` flag:
 
 ```bash terminal icon="terminal"
 bun build ./index.ts --target=bun --bytecode --outdir=./dist
@@ -17,7 +17,7 @@ bun build ./index.ts --target=bun --bytecode --outdir=./dist
 
 This generates two files:
 
-- `dist/index.js` - Your bundled JavaScript (CommonJS)
+- `dist/index.js` - Your bundled JavaScript
 - `dist/index.jsc` - The bytecode cache file
 
 At runtime, Bun automatically detects and uses the `.jsc` file:
@@ -28,24 +28,14 @@ bun ./dist/index.js  # Automatically uses index.jsc
 
 ### With standalone executables
 
-When creating executables with `--compile`, bytecode is embedded into the binary. Both ESM and CommonJS formats are supported:
+When creating executables with `--compile`, bytecode is embedded into the binary:
 
 ```bash terminal icon="terminal"
-# ESM (requires --compile)
-bun build ./cli.ts --compile --bytecode --format=esm --outfile=mycli
-
-# CommonJS (works with or without --compile)
 bun build ./cli.ts --compile --bytecode --outfile=mycli
 ```
 
 The resulting executable contains both the code and bytecode, giving you maximum performance in a single file.
 
-### ESM bytecode
-
-ESM bytecode requires `--compile` because Bun embeds module metadata (import/export information) in the compiled binary. This metadata allows the JavaScript engine to skip parsing entirely at runtime.
-
-Without `--compile`, ESM bytecode would still require parsing the source to analyze module dependencies—defeating the purpose of bytecode caching.
-
 ### Combining with other optimizations
 
 Bytecode works great with minification and source maps:
@@ -100,9 +90,35 @@ Larger applications benefit more because they have more code to parse.
 - ❌ **Code that runs once**
 - ❌ **Development builds**
 - ❌ **Size-constrained environments**
+- ❌ **Code with top-level await** (not supported)
 
 ## Limitations
 
+### CommonJS only
+
+Bytecode caching currently works with CommonJS output format. Bun's bundler automatically converts most ESM code to CommonJS, but **top-level await** is the exception:
+
+```js
+// This prevents bytecode caching
+const data = await fetch("https://api.example.com");
+export default data;
+```
+
+**Why**: Top-level await requires async module evaluation, which can't be represented in CommonJS. The module graph becomes asynchronous, and the CommonJS wrapper function model breaks down.
+
+**Workaround**: Move async initialization into a function:
+
+```js
+async function init() {
+  const data = await fetch("https://api.example.com");
+  return data;
+}
+
+export default init;
+```
+
+Now the module exports a function that the consumer can await when needed.
+
 ### Version compatibility
 
 Bytecode is **not portable across Bun versions**. The bytecode format is tied to JavaScriptCore's internal representation, which changes between versions.
@@ -220,6 +236,8 @@ It's normal for it it to log a cache miss multiple times since Bun doesn't curre
 - Compressing `.jsc` files for network transfer (gzip/brotli)
 - Evaluating if the startup performance gain is worth the size increase
 
+**Top-level await**: Not supported. Refactor to use async initialization functions.
+
 ## What is bytecode?
 
 When you run JavaScript, the JavaScript engine doesn't execute your source code directly. Instead, it goes through several steps:

docs/bundler/esbuild.mdx

@@ -65,7 +65,6 @@ In Bun's CLI, simple boolean flags like `--minify` do not accept an argument. Ot
 | `--chunk-names`        | `--chunk-naming`           | Renamed for consistency with naming in JS API                                                                                                                                                                                                                                                                                                                       |
 | `--color`              | n/a                        | Always enabled                                                                                                                                                                                                                                                                                                                                                      |
 | `--drop`               | `--drop`                   |                                                                                                                                                                                                                                                                                                                                                                     |
-| n/a                    | `--feature`                | Bun-specific. Enable feature flags for compile-time dead-code elimination via `import { feature } from "bun:bundle"`                                                                                                                                                                                                                                                |
 | `--entry-names`        | `--entry-naming`           | Renamed for consistency with naming in JS API                                                                                                                                                                                                                                                                                                                       |
 | `--global-name`        | n/a                        | Not applicable, Bun does not support `iife` output at this time                                                                                                                                                                                                                                                                                                     |
 | `--ignore-annotations` | `--ignore-dce-annotations` |                                                                                                                                                                                                                                                                                                                                                                     |

docs/bundler/fullstack.mdx

@@ -427,8 +427,8 @@ This will allow you to use TailwindCSS utility classes in your HTML and CSS file
 <!doctype html>
 <html>
   <head>
-    <!-- [!code ++] -->
     <link rel="stylesheet" href="tailwindcss" />
+    <!-- [!code ++] -->
   </head>
   <!-- the rest of your HTML... -->
 </html>
@@ -448,8 +448,8 @@ Alternatively, you can import TailwindCSS in your CSS file:
 <!doctype html>
 <html>
   <head>
-    <!-- [!code ++] -->
     <link rel="stylesheet" href="./style.css" />
+    <!-- [!code ++] -->
   </head>
   <!-- the rest of your HTML... -->
 </html>

docs/bundler/index.mdx

@@ -220,78 +220,6 @@ An array of paths corresponding to the entrypoints of our application. One bundl
   </Tab>
 </Tabs>
 
-### files
-
-A map of file paths to their contents for in-memory bundling. This allows you to bundle virtual files that don't exist on disk, or override the contents of files that do exist. This option is only available in the JavaScript API.
-
-File contents can be provided as a `string`, `Blob`, `TypedArray`, or `ArrayBuffer`.
-
-#### Bundle entirely from memory
-
-You can bundle code without any files on disk by providing all sources via `files`:
-
-```ts title="build.ts" icon="/icons/typescript.svg"
-const result = await Bun.build({
-  entrypoints: ["/app/index.ts"],
-  files: {
-    "/app/index.ts": `
-      import { greet } from "./greet.ts";
-      console.log(greet("World"));
-    `,
-    "/app/greet.ts": `
-      export function greet(name: string) {
-        return "Hello, " + name + "!";
-      }
-    `,
-  },
-});
-
-const output = await result.outputs[0].text();
-console.log(output);
-```
-
-When all entrypoints are in the `files` map, the current working directory is used as the root.
-
-#### Override files on disk
-
-In-memory files take priority over files on disk. This lets you override specific files while keeping the rest of your codebase unchanged:
-
-```ts title="build.ts" icon="/icons/typescript.svg"
-// Assume ./src/config.ts exists on disk with development settings
-await Bun.build({
-  entrypoints: ["./src/index.ts"],
-  files: {
-    // Override config.ts with production values
-    "./src/config.ts": `
-      export const API_URL = "https://api.production.com";
-      export const DEBUG = false;
-    `,
-  },
-  outdir: "./dist",
-});
-```
-
-#### Mix disk and virtual files
-
-Real files on disk can import virtual files, and virtual files can import real files:
-
-```ts title="build.ts" icon="/icons/typescript.svg"
-// ./src/index.ts exists on disk and imports "./generated.ts"
-await Bun.build({
-  entrypoints: ["./src/index.ts"],
-  files: {
-    // Provide a virtual file that index.ts imports
-    "./src/generated.ts": `
-      export const BUILD_ID = "${crypto.randomUUID()}";
-      export const BUILD_TIME = ${Date.now()};
-    `,
-  },
-  outdir: "./dist",
-});
-```
-
-This is useful for code generation, injecting build-time constants, or testing with mock modules.
-
 ### outdir
 
 The directory where output files will be written.
@@ -1213,201 +1141,6 @@ Remove function calls from a bundle. For example, `--drop=console` will remove a
   </Tab>
 </Tabs>
 
-### features
-
-Enable compile-time feature flags for dead-code elimination. This provides a way to conditionally include or exclude code paths at bundle time using `import { feature } from "bun:bundle"`.
-
-```ts title="app.ts" icon="/icons/typescript.svg"
-import { feature } from "bun:bundle";
-
-if (feature("PREMIUM")) {
-  // Only included when PREMIUM flag is enabled
-  initPremiumFeatures();
-}
-
-if (feature("DEBUG")) {
-  // Only included when DEBUG flag is enabled
-  console.log("Debug mode");
-}
-```
-
-<Tabs>
-  <Tab title="JavaScript">
-    ```ts title="build.ts" icon="/icons/typescript.svg"
-    await Bun.build({
-      entrypoints: ['./app.ts'],
-      outdir: './out',
-      features: ["PREMIUM"],  // PREMIUM=true, DEBUG=false
-    })
-    ```
-  </Tab>
-  <Tab title="CLI">
-    ```bash terminal icon="terminal"
-    bun build ./app.ts --outdir ./out --feature PREMIUM
-    ```
-  </Tab>
-</Tabs>
-
-The `feature()` function is replaced with `true` or `false` at bundle time. Combined with minification, unreachable code is eliminated:
-
-```ts title="Input" icon="/icons/typescript.svg"
-import { feature } from "bun:bundle";
-const mode = feature("PREMIUM") ? "premium" : "free";
-```
-
-```js title="Output (with --feature PREMIUM --minify)" icon="/icons/javascript.svg"
-var mode = "premium";
-```
-
-```js title="Output (without --feature PREMIUM, with --minify)" icon="/icons/javascript.svg"
-var mode = "free";
-```
-
-**Key behaviors:**
-
-- `feature()` requires a string literal argument — dynamic values are not supported
-- The `bun:bundle` import is completely removed from the output
-- Works with `bun build`, `bun run`, and `bun test`
-- Multiple flags can be enabled: `--feature FLAG_A --feature FLAG_B`
-- For type safety, augment the `Registry` interface to restrict `feature()` to known flags (see below)
-
-**Use cases:**
-
-- Platform-specific code (`feature("SERVER")` vs `feature("CLIENT")`)
-- Environment-based features (`feature("DEVELOPMENT")`)
-- Gradual feature rollouts
-- A/B testing variants
-- Paid tier features
-
-**Type safety:** By default, `feature()` accepts any string. To get autocomplete and catch typos at compile time, create an `env.d.ts` file (or add to an existing `.d.ts`) and augment the `Registry` interface:
-
-```ts title="env.d.ts" icon="/icons/typescript.svg"
-declare module "bun:bundle" {
-  interface Registry {
-    features: "DEBUG" | "PREMIUM" | "BETA_FEATURES";
-  }
-}
-```
-
-Ensure the file is included in your `tsconfig.json` (e.g., `"include": ["src", "env.d.ts"]`). Now `feature()` only accepts those flags, and invalid strings like `feature("TYPO")` become type errors.
-
-### metafile
-
-Generate metadata about the build in a structured format. The metafile contains information about all input files, output files, their sizes, imports, and exports. This is useful for:
-
-- **Bundle analysis**: Understand what's contributing to bundle size
-- **Visualization**: Feed into tools like [esbuild's bundle analyzer](https://esbuild.github.io/analyze/) or other visualization tools
-- **Dependency tracking**: See the full import graph of your application
-- **CI integration**: Track bundle size changes over time
-
-<Tabs>
-  <Tab title="JavaScript">
-    ```ts title="build.ts" icon="/icons/typescript.svg"
-    const result = await Bun.build({
-      entrypoints: ['./src/index.ts'],
-      outdir: './dist',
-      metafile: true,
-    });
-
-    if (result.metafile) {
-      // Analyze inputs
-      for (const [path, meta] of Object.entries(result.metafile.inputs)) {
-        console.log(`${path}: ${meta.bytes} bytes`);
-      }
-
-      // Analyze outputs
-      for (const [path, meta] of Object.entries(result.metafile.outputs)) {
-        console.log(`${path}: ${meta.bytes} bytes`);
-      }
-
-      // Save for external analysis tools
-      await Bun.write('./dist/meta.json', JSON.stringify(result.metafile));
-    }
-    ```
-
-  </Tab>
-  <Tab title="CLI">
-    ```bash terminal icon="terminal"
-    bun build ./src/index.ts --outdir ./dist --metafile ./dist/meta.json
-    ```
-  </Tab>
-</Tabs>
-
-#### Markdown metafile
-
-Use `--metafile-md` to generate a markdown metafile, which is LLM-friendly and easy to read in the terminal:
-
-```bash terminal icon="terminal"
-bun build ./src/index.ts --outdir ./dist --metafile-md ./dist/meta.md
-```
-
-Both `--metafile` and `--metafile-md` can be used together:
-
-```bash terminal icon="terminal"
-bun build ./src/index.ts --outdir ./dist --metafile ./dist/meta.json --metafile-md ./dist/meta.md
-```
-
-#### `metafile` option formats
-
-In the JavaScript API, `metafile` accepts several forms:
-
-```ts title="build.ts" icon="/icons/typescript.svg"
-// Boolean — include metafile in the result object
-await Bun.build({
-  entrypoints: ["./src/index.ts"],
-  outdir: "./dist",
-  metafile: true,
-});
-
-// String — write JSON metafile to a specific path
-await Bun.build({
-  entrypoints: ["./src/index.ts"],
-  outdir: "./dist",
-  metafile: "./dist/meta.json",
-});
-
-// Object — specify separate paths for JSON and markdown output
-await Bun.build({
-  entrypoints: ["./src/index.ts"],
-  outdir: "./dist",
-  metafile: {
-    json: "./dist/meta.json",
-    markdown: "./dist/meta.md",
-  },
-});
-```
-
-The metafile structure contains:
-
-```ts
-interface BuildMetafile {
-  inputs: {
-    [path: string]: {
-      bytes: number;
-      imports: Array<{
-        path: string;
-        kind: ImportKind;
-        original?: string; // Original specifier before resolution
-        external?: boolean;
-      }>;
-      format?: "esm" | "cjs" | "json" | "css";
-    };
-  };
-  outputs: {
-    [path: string]: {
-      bytes: number;
-      inputs: {
-        [path: string]: { bytesInOutput: number };
-      };
-      imports: Array<{ path: string; kind: ImportKind }>;
-      exports: string[];
-      entryPoint?: string;
-      cssBundle?: string; // Associated CSS file for JS entry points
-    };
-  };
-}
-```
-
 ## Outputs
 
 The `Bun.build` function returns a `Promise<BuildOutput>`, defined as:
@@ -1417,7 +1150,6 @@ interface BuildOutput {
   outputs: BuildArtifact[];
   success: boolean;
   logs: Array<object>; // see docs for details
-  metafile?: BuildMetafile; // only when metafile: true
 }
 
 interface BuildArtifact extends Blob {
@@ -1508,43 +1240,22 @@ BuildArtifact (entry-point) {
 
 ## Bytecode
 
-The `bytecode: boolean` option can be used to generate bytecode for any JavaScript/TypeScript entrypoints. This can greatly improve startup times for large applications. Requires `"target": "bun"` and is dependent on a matching version of Bun.
-
-- **CommonJS**: Works with or without `compile: true`. Generates a `.jsc` file alongside each entrypoint.
-- **ESM**: Requires `compile: true`. Bytecode and module metadata are embedded in the standalone executable.
-
-Without an explicit `format`, bytecode defaults to CommonJS.
+The `bytecode: boolean` option can be used to generate bytecode for any JavaScript/TypeScript entrypoints. This can greatly improve startup times for large applications. Only supported for `"cjs"` format, only supports `"target": "bun"` and dependent on a matching version of Bun. This adds a corresponding `.jsc` file for each entrypoint.
 
 <Tabs>
   <Tab title="JavaScript">
     ```ts title="build.ts" icon="/icons/typescript.svg"
-    // CommonJS bytecode (generates .jsc files)
     await Bun.build({
       entrypoints: ["./index.tsx"],
       outdir: "./out",
       bytecode: true,
     })
-
-    // ESM bytecode (requires compile)
-    await Bun.build({
-      entrypoints: ["./index.tsx"],
-      outfile: "./mycli",
-      bytecode: true,
-      format: "esm",
-      compile: true,
-    })
     ```
-
   </Tab>
   <Tab title="CLI">
     ```bash terminal icon="terminal"
-    # CommonJS bytecode
     bun build ./index.tsx --outdir ./out --bytecode
-
-    # ESM bytecode (requires --compile)
-    bun build ./index.tsx --outfile ./mycli --bytecode --format=esm --compile
     ```
-
   </Tab>
 </Tabs>
 
@@ -1711,10 +1422,7 @@ interface BuildConfig {
    * start times, but will make the final output larger and slightly increase
    * memory usage.
    *
-   * - CommonJS: works with or without `compile: true`
-   * - ESM: requires `compile: true`
-   *
-   * Without an explicit `format`, defaults to CommonJS.
+   * Bytecode is currently only supported for CommonJS (`format: "cjs"`).
    *
    * Must be `target: "bun"`
    * @default false

docs/docs.json

@@ -121,7 +121,6 @@
               "/runtime/file-io",
               "/runtime/streams",
               "/runtime/binary-data",
-              "/runtime/archive",
               "/runtime/sql",
               "/runtime/sqlite",
               "/runtime/s3",
@@ -150,9 +149,6 @@
               "/runtime/secrets",
               "/runtime/console",
               "/runtime/yaml",
-              "/runtime/markdown",
-              "/runtime/json5",
-              "/runtime/jsonl",
               "/runtime/html-rewriter",
               "/runtime/hashing",
               "/runtime/glob",
@@ -330,7 +326,6 @@
             "group": "Utilities",
             "icon": "wrench",
             "pages": [
-              "/guides/util/upgrade",
               "/guides/util/detect-bun",
               "/guides/util/version",
               "/guides/util/hash-a-password",
@@ -500,7 +495,6 @@
               "/guides/runtime/import-json",
               "/guides/runtime/import-toml",
               "/guides/runtime/import-yaml",
-              "/guides/runtime/import-json5",
               "/guides/runtime/import-html",
               "/guides/util/import-meta-dir",
               "/guides/util/import-meta-file",

docs/guides/ecosystem/nuxt.mdx

@@ -74,12 +74,6 @@ export default defineNuxtConfig({
 });
 ```
 
-Alternatively, you can set the preset via environment variable:
-
-```sh terminal icon="terminal"
-NITRO_PRESET=bun bun run build
-```
-
 <Note>
   Some packages provide Bun-specific exports that Nitro will not bundle correctly using the default preset. In this
   case, you need to use Bun preset so that the packages will work correctly in production builds.

docs/guides/ecosystem/pm2.mdx

@@ -33,7 +33,7 @@ Alternatively, you can create a PM2 configuration file. Create a file named `pm2
 
 ```js pm2.config.js icon="file-code"
 module.exports = {
-  name: "app", // Name of your application
+  title: "app", // Name of your application
   script: "index.ts", // Entry point of your application
   interpreter: "bun", // Bun interpreter
   env: {

docs/guides/ecosystem/solidstart.mdx

@@ -4,59 +4,63 @@ sidebarTitle: "SolidStart with Bun"
 mode: center
 ---
 
-Initialize a SolidStart app with `create-solid`. You can specify the `--solidstart` flag to create a SolidStart project, and `--ts` for TypeScript support. When prompted for a template, select `basic` for a minimal starter app.
+<Warning>
+  SolidStart currently relies on Node.js APIs that Bun does not yet implement. The guide below uses Bun to initialize a
+  project and install dependencies, but it uses Node.js to run the dev server.
+</Warning>
+
+---
+
+Initialize a SolidStart app with `create-solid`.
 
 ```sh terminal icon="terminal"
-bun create solid my-app --solidstart --ts
+bun create solid my-app
 ```
 
 ```txt
-┌
- Create-Solid v0.6.11
-│
-◇  Project Name
-│  my-app
-│
-◇  Which template would you like to use?
-│  basic
-│
-◇  Project created 🎉
-│
-◇  To get started, run: ─╮
-│                        │
-│  cd my-app             │
-│  bun install           │
-│  bun dev               │
-│                        │
-├────────────────────────╯
+create-solid version 0.2.31
+
+Welcome to the SolidStart setup wizard!
+
+There are definitely bugs and some feature might not work yet.
+If you encounter an issue, have a look at
+https://github.com/solidjs/solid-start/issues and open a new one,
+if it is not already tracked.
+
+✔ Which template do you want to use? › todomvc
+✔ Server Side Rendering? … yes
+✔ Use TypeScript? … yes
+cloned solidjs/solid-start#main to /path/to/my-app/.solid-start
+✔ Copied project files
 ```
 
 ---
 
-As instructed by the `create-solid` CLI, install the dependencies.
+As instructed by the `create-solid` CLI, let's install our dependencies.
 
 ```sh terminal icon="terminal"
 cd my-app
 bun install
 ```
 
-Then run the development server with `bun dev`.
+---
+
+Then run the development server.
 
 ```sh terminal icon="terminal"
-bun dev
+bun run dev
+# or, equivalently
+bunx solid-start dev
 ```
 
-```txt
-$ vinxi dev
-vinxi v0.5.8
-vinxi starting dev server
-
-  ➜ Local:    http://localhost:3000/
-  ➜ Network:  use --host to expose
-```
-
-Open [localhost:3000](http://localhost:3000). Any changes you make to `src/routes/index.tsx` will be hot-reloaded automatically.
-
 ---
 
-Refer to the [SolidStart website](https://docs.solidjs.com/solid-start) for complete framework documentation.
+Open [localhost:3000](http://localhost:3000). Any changes you make to `src/routes/index.tsx` will be hot-reloaded automatically.
+
+<Frame>
+  ![SolidStart demo app](https://github.com/oven-sh/bun/assets/3084745/1e8043c4-49d1-498c-9add-c1eaab6c7167)
+</Frame>
+
+---
+
+Refer to the [SolidStart website](https://start.solidjs.com/getting-started/what-is-solidstart) for complete framework documentation.

docs/guides/install/trusted.mdx

@@ -8,9 +8,7 @@ Unlike other npm clients, Bun does not execute arbitrary lifecycle scripts for i
 
 <Note>
   Bun includes a default allowlist of popular packages containing `postinstall` scripts that are known to be safe. You
-  can see this list [here](https://github.com/oven-sh/bun/blob/main/src/install/default-trusted-dependencies.txt). This
-  default list only applies to packages installed from npm. For packages from other sources (such as `file:`, `link:`,
-  `git:`, or `github:` dependencies), you must explicitly add them to `trustedDependencies`.
+  can see this list [here](https://github.com/oven-sh/bun/blob/main/src/install/default-trusted-dependencies.txt).
 </Note>
 
 ---

docs/guides/process/os-signals.mdx

@@ -14,6 +14,16 @@ process.on("SIGINT", () => {
 
 ---
 
+If you don't know which signal to listen for, you listen to the umbrella `"exit"` event.
+
+```ts
+process.on("exit", code => {
+  console.log(`Process exited with code ${code}`);
+});
+```
+
+---
+
 If you don't know which signal to listen for, you listen to the [`"beforeExit"`](https://nodejs.org/api/process.html#event-beforeexit) and [`"exit"`](https://nodejs.org/api/process.html#event-exit) events.
 
 ```ts

docs/guides/runtime/import-json5.mdx

@@ -1,74 +0,0 @@
----
-title: Import a JSON5 file
-sidebarTitle: Import JSON5
-mode: center
----
-
-Bun natively supports `.json5` imports.
-
-```json5 config.json5 icon="file-code"
-{
-  // Comments are allowed
-  database: {
-    host: "localhost",
-    port: 5432,
-    name: "myapp",
-  },
-
-  server: {
-    port: 3000,
-    timeout: 30,
-  },
-
-  features: {
-    auth: true,
-    rateLimit: true,
-  },
-}
-```
-
----
-
-Import the file like any other source file.
-
-```ts config.ts icon="/icons/typescript.svg"
-import config from "./config.json5";
-
-config.database.host; // => "localhost"
-config.server.port; // => 3000
-config.features.auth; // => true
-```
-
----
-
-You can also use named imports to destructure top-level properties:
-
-```ts config.ts icon="/icons/typescript.svg"
-import { database, server, features } from "./config.json5";
-
-console.log(database.name); // => "myapp"
-console.log(server.timeout); // => 30
-console.log(features.rateLimit); // => true
-```
-
----
-
-For parsing JSON5 strings at runtime, use `Bun.JSON5.parse()`:
-
-```ts config.ts icon="/icons/typescript.svg"
-const data = JSON5.parse(`{
-  name: 'John Doe',
-  age: 30,
-  hobbies: [
-    'reading',
-    'coding',
-  ],
-}`);
-
-console.log(data.name); // => "John Doe"
-console.log(data.hobbies); // => ["reading", "coding"]
-```
-
----
-
-See [Docs > API > JSON5](/runtime/json5) for complete documentation on JSON5 support in Bun.