Add SessionStart hook for Claude Code Remote

Configure the Bun repository for Claude Code Remote sessions:

- Add session-start.sh hook that runs on session startup
- Fix /tmp permissions if needed (must be 1777)
- Fix Python alternatives for apt_pkg compatibility
- Run bootstrap.sh to install build dependencies (LLVM 19, Node.js, etc.)
- Set up clang-19 as default compiler with proper symlinks
- Persist environment variables (PATH, CC, CXX) for the session
- Install npm dependencies for main and test directories
- Build bun-debug binary

The hook only runs in Claude Code Remote environments (checks
CLAUDE_CODE_REMOTE env var).

.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 \
+   libxml2-dev ruby ruby-dev bison gawk perl make golang ccache \
    && 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,7 +35,8 @@ 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 llvm.sh \
+   && rm -rf /var/lib/apt/lists/*
 
 
 RUN --mount=type=tmpfs,target=/tmp \
@@ -48,14 +49,6 @@ 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 \
@@ -134,9 +127,7 @@ 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. 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.
+# checkout directory for ccache to be effective.
 RUN mkdir -p -m 755 /var/lib/buildkite-agent/hooks && \
     cat <<'EOF' > /var/lib/buildkite-agent/hooks/environment
 #!/bin/sh

.buildkite/ci.mjs

@@ -124,16 +124,13 @@ 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: "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: "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: "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" },
@@ -574,6 +571,7 @@ function getTestBunStep(platform, options, testOptions = {}) {
   if (buildId) {
     args.push(`--build-id=${buildId}`);
   }
+
   if (testFiles) {
     args.push(...testFiles.map(testFile => `--include=${testFile}`));
   }
@@ -590,7 +588,7 @@ function getTestBunStep(platform, options, testOptions = {}) {
     agents: getTestAgent(platform, options),
     retry: getRetry(),
     cancel_on_build_failing: isMergeQueue(),
-    parallelism: os === "darwin" ? 2 : 10,
+    parallelism: os === "darwin" ? 2 : 20,
     timeout_in_minutes: profile === "asan" || os === "windows" ? 45 : 30,
     env: {
       ASAN_OPTIONS: "allow_user_segv_handler=1:disable_coredump=0:detect_leaks=0",
@@ -1072,7 +1070,7 @@ async function getPipeline(options = {}) {
   const imagePlatforms = new Map(
     buildImages || publishImages
       ? [...buildPlatforms, ...testPlatforms]
-          .filter(({ os }) => os === "linux" || os === "windows")
+          .filter(({ os }) => os !== "darwin")
           .map(platform => [getImageKey(platform), platform])
       : [],
   );
@@ -1106,7 +1104,7 @@ async function getPipeline(options = {}) {
   const includeASAN = !isMainBranch();
 
   if (!buildId) {
-    const relevantBuildPlatforms = includeASAN
+    let relevantBuildPlatforms = includeASAN
       ? buildPlatforms
       : buildPlatforms.filter(({ profile }) => profile !== "asan");
 

.claude/hooks/session-start.sh

@@ -0,0 +1,61 @@
+#!/bin/bash
+set -euo pipefail
+
+# Only run in Claude Code Remote environment
+if [ "${CLAUDE_CODE_REMOTE:-}" != "true" ]; then
+  exit 0
+fi
+
+cd "$CLAUDE_PROJECT_DIR"
+
+# Fix /tmp permissions if needed (must be world-writable with sticky bit)
+if [ "$(stat -c %a /tmp 2>/dev/null)" != "1777" ]; then
+  echo "Fixing /tmp permissions..."
+  chmod 1777 /tmp 2>/dev/null || true
+fi
+
+# Ensure /usr/local/bin takes precedence for bootstrap-installed tools
+export PATH="/usr/local/bin:$PATH"
+
+# Fix Python alternatives if apt_pkg module is missing
+if ! /usr/bin/python3 -c "import apt_pkg" 2>/dev/null; then
+  echo "Fixing Python alternatives for apt_pkg..."
+  if [ -f /usr/bin/python3.12 ]; then
+    update-alternatives --install /usr/bin/python3 python3 /usr/bin/python3.12 1 2>/dev/null || true
+    update-alternatives --set python3 /usr/bin/python3.12 2>/dev/null || true
+  fi
+fi
+
+echo "Running bootstrap to set up build dependencies..."
+./scripts/bootstrap.sh || echo "Bootstrap had some errors, continuing..."
+
+# Set up clang as default compiler if not already done
+if [ -f /usr/bin/clang-19 ] && [ ! -L /usr/bin/cc ] || [ "$(readlink /usr/bin/cc 2>/dev/null)" != "/usr/bin/clang" ]; then
+  echo "Setting up clang-19 as default compiler..."
+  ln -sf /usr/bin/clang-19 /usr/bin/clang 2>/dev/null || true
+  ln -sf /usr/bin/clang++-19 /usr/bin/clang++ 2>/dev/null || true
+  ln -sf /usr/bin/clang /usr/bin/cc 2>/dev/null || true
+  ln -sf /usr/bin/clang++ /usr/bin/c++ 2>/dev/null || true
+  ln -sf /usr/bin/lld-19 /usr/bin/lld 2>/dev/null || true
+  ln -sf /usr/bin/ld.lld-19 /usr/bin/ld.lld 2>/dev/null || true
+  ln -sf /usr/bin/llvm-ar-19 /usr/bin/llvm-ar 2>/dev/null || true
+  ln -sf /usr/bin/llvm-symbolizer-19 /usr/bin/llvm-symbolizer 2>/dev/null || true
+fi
+
+# Persist environment variables for the session
+if [ -n "${CLAUDE_ENV_FILE:-}" ]; then
+  echo 'export PATH="/usr/local/bin:$PATH"' >> "$CLAUDE_ENV_FILE"
+  echo 'export CC=/usr/bin/clang' >> "$CLAUDE_ENV_FILE"
+  echo 'export CXX=/usr/bin/clang++' >> "$CLAUDE_ENV_FILE"
+fi
+
+echo "Installing main dependencies..."
+bun install
+
+echo "Installing test dependencies..."
+bun install --cwd test --ignore-scripts
+
+echo "Building bun-debug..."
+bun run build
+
+echo "Session start hook completed successfully."

.claude/settings.json

@@ -1,5 +1,15 @@
 {
   "hooks": {
+    "SessionStart": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "$CLAUDE_PROJECT_DIR/.claude/hooks/session-start.sh"
+          }
+        ]
+      }
+    ],
     "PreToolUse": [
       {
         "matcher": "Bash",

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

@@ -0,0 +1,184 @@
+---
+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

@@ -0,0 +1,206 @@
+---
+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

@@ -0,0 +1,222 @@
+---
+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

@@ -0,0 +1,94 @@
+---
+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

@@ -0,0 +1,268 @@
+---
+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,5 +1,9 @@
 language: en-US
 
+issue_enrichment:
+  auto_enrich:
+    enabled: false
+
 reviews:
   profile: assertive
   request_changes_workflow: false

.cursor/rules/building-bun.mdc

@@ -1,41 +0,0 @@
----
-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

@@ -1,139 +0,0 @@
----
-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

@@ -1,413 +0,0 @@
----
-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

@@ -1,203 +0,0 @@
-# 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

@@ -1,91 +0,0 @@
----
-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

@@ -1,509 +0,0 @@
----
-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/claude.yml

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

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

@@ -1,58 +0,0 @@
-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"

.gitignore

@@ -9,6 +9,7 @@
 .ninja_deps
 .ninja_log
 .npm
+.npmrc
 .npm.gz
 .parcel-cache
 .swcrc

.vscode/settings.json

@@ -27,18 +27,22 @@
   "git.ignoreLimitWarning": true,
 
   // Zig
-  "zig.initialSetupDone": true,
-  "zig.buildOption": "build",
+  // "zig.initialSetupDone": true,
+  // "zig.buildOption": "build",
   "zig.zls.zigLibPath": "${workspaceFolder}/vendor/zig/lib",
-  "zig.buildArgs": ["-Dgenerated-code=./build/debug/codegen", "--watch", "-fincremental"],
-  "zig.zls.buildOnSaveStep": "check",
+  "zig.buildOnSaveArgs": [
+    "-Dgenerated-code=./build/debug/codegen",
+    "--watch",
+    "-fincremental"
+  ],
+  // "zig.zls.buildOnSaveStep": "check",
   // "zig.zls.enableBuildOnSave": true,
   // "zig.buildOnSave": true,
-  "zig.buildFilePath": "${workspaceFolder}/build.zig",
+  // "zig.buildFilePath": "${workspaceFolder}/build.zig",
   "zig.path": "${workspaceFolder}/vendor/zig/zig.exe",
   "zig.zls.path": "${workspaceFolder}/vendor/zig/zls.exe",
   "zig.formattingProvider": "zls",
-  "zig.zls.enableInlayHints": false,
+  // "zig.zls.enableInlayHints": false,
   "[zig]": {
     "editor.tabSize": 4,
     "editor.useTabStops": false,

CLAUDE.md

@@ -6,7 +6,7 @@ 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**: no need for a timeout, the build is really fast!
+  - **CRITICAL**: do not set a timeout when running `bun bd`
 - **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>`
@@ -94,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. That is NOT a valid 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.
 - 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.

CMakeLists.txt

@@ -47,15 +47,7 @@ include(SetupEsbuild)
 include(SetupZig)
 include(SetupRust)
 
-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()
+include(SetupCcache)
 
 # 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 cmake coreutils gnu-sed go icu4c libiconv libtool ninja pkg-config rust ruby sccache
+$ brew install automake ccache cmake coreutils gnu-sed go icu4c libiconv libtool ninja pkg-config rust ruby
 ```
 
 ```bash#Ubuntu/Debian
@@ -65,43 +65,28 @@ $ brew install bun
 
 {% /codetabs %}
 
-### Optional: Install `sccache`
+### Optional: Install `ccache`
 
-sccache is used to cache compilation artifacts, significantly speeding up builds. It must be installed with S3 support:
+ccache is used to cache compilation artifacts, significantly speeding up builds:
 
 ```bash
 # For macOS
-$ brew install sccache
+$ brew install ccache
 
-# For Linux. Note that the version in your package manager may not have S3 support.
-$ cargo install sccache --features=s3
+# 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
 ```
 
-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>
+Our build scripts will automatically detect and use `ccache` if available. You can check cache statistics with `ccache --show-stats`.
 
 ## Install LLVM
 

LATEST

@@ -1 +1 @@
-1.3.2
+1.3.5

README.md

@@ -54,7 +54,7 @@ Bun supports Linux (x64 & arm64), macOS (x64 & Apple Silicon) and Windows (x64).
 curl -fsSL https://bun.com/install | bash
 
 # on windows
-powershell -c "irm bun.com/install.ps1 | iex"
+powershell -c "irm bun.sh/install.ps1 | iex"
 
 # with npm
 npm install -g bun
@@ -104,13 +104,13 @@ bun upgrade --canary
   - [File types (Loaders)](https://bun.com/docs/runtime/loaders)
   - [TypeScript](https://bun.com/docs/runtime/typescript)
   - [JSX](https://bun.com/docs/runtime/jsx)
-  - [Environment variables](https://bun.com/docs/runtime/env)
+  - [Environment variables](https://bun.com/docs/runtime/environment-variables)
   - [Bun APIs](https://bun.com/docs/runtime/bun-apis)
   - [Web APIs](https://bun.com/docs/runtime/web-apis)
-  - [Node.js compatibility](https://bun.com/docs/runtime/nodejs-apis)
+  - [Node.js compatibility](https://bun.com/docs/runtime/nodejs-compat)
   - [Single-file executable](https://bun.com/docs/bundler/executables)
   - [Plugins](https://bun.com/docs/runtime/plugins)
-  - [Watch mode / Hot Reloading](https://bun.com/docs/runtime/hot)
+  - [Watch mode / Hot Reloading](https://bun.com/docs/runtime/watch-mode)
   - [Module resolution](https://bun.com/docs/runtime/modules)
   - [Auto-install](https://bun.com/docs/runtime/autoimport)
   - [bunfig.toml](https://bun.com/docs/runtime/bunfig)

bench/bun.lock

@@ -1,5 +1,6 @@
 {
   "lockfileVersion": 1,
+  "configVersion": 0,
   "workspaces": {
     "": {
       "name": "bench",
@@ -22,6 +23,7 @@
         "react-dom": "^18.3.1",
         "string-width": "7.1.0",
         "strip-ansi": "^7.1.0",
+        "tar": "^7.4.3",
         "tinycolor2": "^1.6.0",
         "zx": "^7.2.3",
       },
@@ -107,6 +109,8 @@
 
     "@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=="],
@@ -181,6 +185,8 @@
 
     "chalk": ["chalk@5.3.0", "", {}, "sha512-dLitG79d+GV1Nb/VYcCDFivJeK1hiukt9QjRNVOsUtTy1rR1YJsmpGGTZ3qJos+uw7WmWF4wUwBd9jxjocFC2w=="],
 
+    "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=="],
@@ -361,6 +367,10 @@
 
     "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.25", "", {}, "sha512-0v5qZtVW5vwj9FDvYfraR31BMDcRLkhSFWPTLaxx/Z3/EvScfVtAAWtMI2ArIbBcwh7P86dXh0lQWKiXQPlwYA=="],
 
     "ms": ["ms@2.1.2", "", {}, "sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w=="],
@@ -457,6 +467,8 @@
 
     "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=="],
@@ -481,7 +493,7 @@
 
     "which": ["which@3.0.1", "", { "dependencies": { "isexe": "^2.0.0" }, "bin": { "node-which": "bin/which.js" } }, "sha512-XA1b62dzQzLfaEOSQFTCOd5KFf/1VSzZo7/7TUjnya6u0vGGKzU96UQBZTAThCb2j4/xjBAyii1OhRLJEivHvg=="],
 
-    "yallist": ["yallist@3.1.1", "", {}, "sha512-a4UGQaWPH59mOXUYnAG2ewncQS4i4F43Tv3JoAM+s2VDAmS9NsK8GpDMLrCHPksFT7h3K6TOoUNn2pb7RoXx4g=="],
+    "yallist": ["yallist@5.0.0", "", {}, "sha512-YgvUTfwqyc7UXVMrB+SImsVYSmTS8X/tSrtdNZMImM+n7+QTriRXyXim0mBrTXNeqzVF0KWGgHPeiyViFFrNDw=="],
 
     "yaml": ["yaml@2.3.4", "", {}, "sha512-8aAvwVUSHpfEqTQ4w/KMlf3HcRdt50E5ODIQJBw1fQ5RL34xabzxtUlzTXVqc4rkZsPbvrXKWnABCD7kWSmocA=="],
 
@@ -501,6 +513,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=="],
 
     "ansi-styles/color-convert/color-name": ["color-name@1.1.3", "", {}, "sha512-72fSenhMw2HZMTVHeCA9KCmpEIbzWiQsjN+BHcBbS9vr1mtt+vJjPdksIBNUmKAW8TFUDPJK5SUU3QhE9NEXDw=="],

bench/install/bun.lock

@@ -1,5 +1,6 @@
 {
   "lockfileVersion": 1,
+  "configVersion": 0,
   "workspaces": {
     "": {
       "name": "installbench",
@@ -12,7 +13,7 @@
         "@trpc/server": "^11.0.0",
         "drizzle-orm": "^0.41.0",
         "esbuild": "^0.25.11",
-        "next": "^15.2.3",
+        "next": "15.5.7",
         "next-auth": "5.0.0-beta.25",
         "postgres": "^3.4.4",
         "react": "^19.0.0",
@@ -175,23 +176,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.6", "", {}, "sha512-3qBGRW+sCGzgbpc5TS1a0p7eNxnOarGVQhZxfvTdnV0gFI61lX7QNtQ4V1TSREctXzYn5NetbUsLvyqwLFJM6Q=="],
+    "@next/env": ["@next/env@15.5.7", "", {}, "sha512-4h6Y2NyEkIEN7Z8YxkA27pq6zTkS09bUSYC0xjd0NpwFxjnIKeZEeH591o5WECSmjpUhLn3H2QLJcDye3Uzcvg=="],
 
-    "@next/swc-darwin-arm64": ["@next/swc-darwin-arm64@15.5.6", "", { "os": "darwin", "cpu": "arm64" }, "sha512-ES3nRz7N+L5Umz4KoGfZ4XX6gwHplwPhioVRc25+QNsDa7RtUF/z8wJcbuQ2Tffm5RZwuN2A063eapoJ1u4nPg=="],
+    "@next/swc-darwin-arm64": ["@next/swc-darwin-arm64@15.5.7", "", { "os": "darwin", "cpu": "arm64" }, "sha512-IZwtxCEpI91HVU/rAUOOobWSZv4P2DeTtNaCdHqLcTJU4wdNXgAySvKa/qJCgR5m6KI8UsKDXtO2B31jcaw1Yw=="],
 
-    "@next/swc-darwin-x64": ["@next/swc-darwin-x64@15.5.6", "", { "os": "darwin", "cpu": "x64" }, "sha512-JIGcytAyk9LQp2/nuVZPAtj8uaJ/zZhsKOASTjxDug0SPU9LAM3wy6nPU735M1OqacR4U20LHVF5v5Wnl9ptTA=="],
+    "@next/swc-darwin-x64": ["@next/swc-darwin-x64@15.5.7", "", { "os": "darwin", "cpu": "x64" }, "sha512-UP6CaDBcqaCBuiq/gfCEJw7sPEoX1aIjZHnBWN9v9qYHQdMKvCKcAVs4OX1vIjeE+tC5EIuwDTVIoXpUes29lg=="],
 
-    "@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-gnu": ["@next/swc-linux-arm64-gnu@15.5.7", "", { "os": "linux", "cpu": "arm64" }, "sha512-NCslw3GrNIw7OgmRBxHtdWFQYhexoUCq+0oS2ccjyYLtcn1SzGzeM54jpTFonIMUjNbHmpKpziXnpxhSWLcmBA=="],
 
-    "@next/swc-linux-arm64-musl": ["@next/swc-linux-arm64-musl@15.5.6", "", { "os": "linux", "cpu": "arm64" }, "sha512-FsbGVw3SJz1hZlvnWD+T6GFgV9/NYDeLTNQB2MXoPN5u9VA9OEDy6fJEfePfsUKAhJufFbZLgp0cPxMuV6SV0w=="],
+    "@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-x64-gnu": ["@next/swc-linux-x64-gnu@15.5.6", "", { "os": "linux", "cpu": "x64" }, "sha512-3QnHGFWlnvAgyxFxt2Ny8PTpXtQD7kVEeaFat5oPAHHI192WKYB+VIKZijtHLGdBBvc16tiAkPTDmQNOQ0dyrA=="],
+    "@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-musl": ["@next/swc-linux-x64-musl@15.5.6", "", { "os": "linux", "cpu": "x64" }, "sha512-OsGX148sL+TqMK9YFaPFPoIaJKbFJJxFzkXZljIgA9hjMjdruKht6xDCEv1HLtlLNfkx3c5w2GLKhj7veBQizQ=="],
+    "@next/swc-linux-x64-musl": ["@next/swc-linux-x64-musl@15.5.7", "", { "os": "linux", "cpu": "x64" }, "sha512-4IUO539b8FmF0odY6/SqANJdgwn1xs1GkPO5doZugwZ3ETF6JUdckk7RGmsfSf7ws8Qb2YB5It33mvNL/0acqA=="],
 
-    "@next/swc-win32-arm64-msvc": ["@next/swc-win32-arm64-msvc@15.5.6", "", { "os": "win32", "cpu": "arm64" }, "sha512-ONOMrqWxdzXDJNh2n60H6gGyKed42Ieu6UTVPZteXpuKbLZTH4G4eBMsr5qWgOBA+s7F+uB4OJbZnrkEDnZ5Fg=="],
+    "@next/swc-win32-arm64-msvc": ["@next/swc-win32-arm64-msvc@15.5.7", "", { "os": "win32", "cpu": "arm64" }, "sha512-CpJVTkYI3ZajQkC5vajM7/ApKJUOlm6uP4BknM3XKvJ7VXAvCqSjSLmM0LKdYzn6nBJVSjdclx8nYJSa3xlTgQ=="],
 
-    "@next/swc-win32-x64-msvc": ["@next/swc-win32-x64-msvc@15.5.6", "", { "os": "win32", "cpu": "x64" }, "sha512-pxK4VIjFRx1MY92UycLOOw7dTdvccWsNETQ0kDHkBlcFH1GrTLUjSiHU1ohrznnux6TqRHgv5oflhfIWZwVROQ=="],
+    "@next/swc-win32-x64-msvc": ["@next/swc-win32-x64-msvc@15.5.7", "", { "os": "win32", "cpu": "x64" }, "sha512-gMzgBX164I6DN+9/PGA+9dQiwmTkE4TloBNx8Kv9UiGARsr9Nba7IpcBRA1iTV9vwlYnrE3Uy6I7Aj6qLjQuqw=="],
 
     "@panva/hkdf": ["@panva/hkdf@1.2.1", "", {}, "sha512-6oclG6Y3PiDFcoyk8srjLfVKyMfVCKJ27JwNPViuXziFpmdz+MZnZN/aKY0JGXgYuO/VghU0jcOAZgWXZ1Dmrw=="],
 
@@ -323,7 +324,7 @@
 
     "nanoid": ["nanoid@3.3.11", "", { "bin": { "nanoid": "bin/nanoid.cjs" } }, "sha512-N8SpfPUnUp1bK+PMYW8qSWdl9U+wwNWI4QKxOYDy9JAro3WMX7p2OeVRF9v+347pnakNevPmiHhNmZ2HbFA76w=="],
 
-    "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": ["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-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.2.3",
+    "next": "15.5.7",
     "next-auth": "5.0.0-beta.25",
     "postgres": "^3.4.4",
     "react": "^19.0.0",

bench/package.json

@@ -19,6 +19,7 @@
     "react-dom": "^18.3.1",
     "string-width": "7.1.0",
     "strip-ansi": "^7.1.0",
+    "tar": "^7.4.3",
     "tinycolor2": "^1.6.0",
     "zx": "^7.2.3"
   },

bench/snippets/archive.mjs

@@ -0,0 +1,477 @@
+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

@@ -0,0 +1,335 @@
+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/ipc-json-child.mjs

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

bench/snippets/ipc-json.mjs

@@ -0,0 +1,45 @@
+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/object-hasown.mjs

@@ -0,0 +1,57 @@
+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

@@ -0,0 +1,7 @@
+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,12 +112,40 @@ const obj = {
   },
 };
 
-bench("Response.json(obj)", async () => {
+const smallObj = { id: 1, name: "test" };
+
+const arrayObj = {
+  items: Array.from({ length: 100 }, (_, i) => ({ id: i, value: `item-${i}` })),
+};
+
+bench("Response.json(obj)", () => {
   return Response.json(obj);
 });
 
-bench("Response.json(obj).json()", async () => {
-  return await Response.json(obj).json();
+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" },
+  });
 });
 
 await run();

bench/snippets/string-includes.mjs

@@ -0,0 +1,34 @@
+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

@@ -0,0 +1,48 @@
+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();

build.zig

@@ -607,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;
+    obj.no_link_obj = opts.os != .windows and !opts.no_llvm;
 
 
     if (opts.enable_asan and !enableFastBuild(b)) {

bun.lock

@@ -1,6 +1,6 @@
 {
   "lockfileVersion": 1,
-  "configVersion": 0,
+  "configVersion": 1,
   "workspaces": {
     "": {
       "name": "bun",
@@ -36,6 +36,7 @@
   },
   "overrides": {
     "@types/bun": "workspace:packages/@types/bun",
+    "@types/node": "25.0.0",
     "bun-types": "workspace:packages/bun-types",
   },
   "packages": {
@@ -85,13 +86,13 @@
 
     "@esbuild/win32-x64": ["@esbuild/win32-x64@0.21.5", "", { "os": "win32", "cpu": "x64" }, "sha512-tQd/1efJuzPC6rCFwEvLtci/xNFcTZknmXs98FYDfGE4wP9ClFV98nyKrzJKVPMhdDnjzLhdUyMX4PsQAPjwIw=="],
 
-    "@lezer/common": ["@lezer/common@1.2.3", "", {}, "sha512-w7ojc8ejBqr2REPsWxJjrMFsA/ysDCFICn8zEOR9mrqzOu2amhITYuLD8ag6XZf0CFXDrhKqw7+tW8cX66NaDA=="],
+    "@lezer/common": ["@lezer/common@1.3.0", "", {}, "sha512-L9X8uHCYU310o99L3/MpJKYxPzXPOS7S0NmBaM7UO/x2Kb2WbmMLSkfvdr1KxRIFYOpbY0Jhn7CfLSUDzL8arQ=="],
 
     "@lezer/cpp": ["@lezer/cpp@1.1.3", "", { "dependencies": { "@lezer/common": "^1.2.0", "@lezer/highlight": "^1.0.0", "@lezer/lr": "^1.0.0" } }, "sha512-ykYvuFQKGsRi6IcE+/hCSGUhb/I4WPjd3ELhEblm2wS2cOznDFzO+ubK2c+ioysOnlZ3EduV+MVQFCPzAIoY3w=="],
 
-    "@lezer/highlight": ["@lezer/highlight@1.2.1", "", { "dependencies": { "@lezer/common": "^1.0.0" } }, "sha512-Z5duk4RN/3zuVO7Jq0pGLJ3qynpxUVsh7IbUbGj88+uV2ApSAn6kWg2au3iJb+0Zi7kKtqffIESgNcRXWZWmSA=="],
+    "@lezer/highlight": ["@lezer/highlight@1.2.3", "", { "dependencies": { "@lezer/common": "^1.3.0" } }, "sha512-qXdH7UqTvGfdVBINrgKhDsVTJTxactNNxLk7+UMwZhU13lMHaOBlJe9Vqp907ya56Y3+ed2tlqzys7jDkTmW0g=="],
 
-    "@lezer/lr": ["@lezer/lr@1.4.2", "", { "dependencies": { "@lezer/common": "^1.0.0" } }, "sha512-pu0K1jCIdnQ12aWNaAVU5bzi7Bd1w54J3ECgANPmYLtQKP0HBj2cE/5coBD66MT10xbtIuUr7tg0Shbsvk0mDA=="],
+    "@lezer/lr": ["@lezer/lr@1.4.3", "", { "dependencies": { "@lezer/common": "^1.0.0" } }, "sha512-yenN5SqAxAPv/qMnpWW0AT7l+SxVrgG+u0tNsRQWqbrz66HIl8DnEbBObvy21J5K7+I1v7gsAnlE2VQ5yYVSeA=="],
 
     "@octokit/app": ["@octokit/app@14.1.0", "", { "dependencies": { "@octokit/auth-app": "^6.0.0", "@octokit/auth-unauthenticated": "^5.0.0", "@octokit/core": "^5.0.0", "@octokit/oauth-app": "^6.0.0", "@octokit/plugin-paginate-rest": "^9.0.0", "@octokit/types": "^12.0.0", "@octokit/webhooks": "^12.0.4" } }, "sha512-g3uEsGOQCBl1+W1rgfwoRFUIR6PtvB2T1E4RpygeUU5LrLvlOqcxrt5lfykIeRpUPpupreGJUYl70fqMDXdTpw=="],
 
@@ -145,7 +146,7 @@
 
     "@sentry/types": ["@sentry/types@7.120.4", "", {}, "sha512-cUq2hSSe6/qrU6oZsEP4InMI5VVdD86aypE+ENrQ6eZEVLTCYm1w6XhW1NvIu3UuWh7gZec4a9J7AFpYxki88Q=="],
 
-    "@types/aws-lambda": ["@types/aws-lambda@8.10.152", "", {}, "sha512-soT/c2gYBnT5ygwiHPmd9a1bftj462NWVk2tKCc1PYHSIacB2UwbTS2zYG4jzag1mRDuzg/OjtxQjQ2NKRB6Rw=="],
+    "@types/aws-lambda": ["@types/aws-lambda@8.10.159", "", {}, "sha512-SAP22WSGNN12OQ8PlCzGzRCZ7QDCwI85dQZbmpz7+mAk+L7j+wI7qnvmdKh+o7A5LaOp6QnOZ2NJphAZQTTHQg=="],
 
     "@types/btoa-lite": ["@types/btoa-lite@1.0.2", "", {}, "sha512-ZYbcE2x7yrvNFJiU7xJGrpF/ihpkM7zKgw8bha3LNJSesvTtUNxbpzaT7WXBIryf6jovisrxTBvymxMeLLj1Mg=="],
 
@@ -155,7 +156,7 @@
 
     "@types/ms": ["@types/ms@2.1.0", "", {}, "sha512-GsCCIZDE/p3i96vtEqx+7dBUGXrc7zeSK3wwPHIaRThS+9OhWIXRqzs4d6k1SVU8g91DrNRWxWUGhp5KXQb2VA=="],
 
-    "@types/node": ["@types/node@24.2.1", "", { "dependencies": { "undici-types": "~7.10.0" } }, "sha512-DRh5K+ka5eJic8CjH7td8QpYEV6Zo10gfRkjHCO3weqZHWDtAaSTFtl4+VMqOJ4N5jcuhZ9/l+yy8rVgw7BQeQ=="],
+    "@types/node": ["@types/node@25.0.0", "", { "dependencies": { "undici-types": "~7.16.0" } }, "sha512-rl78HwuZlaDIUSeUKkmogkhebA+8K1Hy7tddZuJ3D0xV8pZSfsYGTsliGUol1JPzu9EKnTxPC4L1fiWouStRew=="],
 
     "aggregate-error": ["aggregate-error@3.1.0", "", { "dependencies": { "clean-stack": "^2.0.0", "indent-string": "^4.0.0" } }, "sha512-4I7Td01quW/RpocfNayFdFVk1qSuoh0E7JrbRJ16nH01HhKFQ88INq9Sd+nd72zqRySlr9BmDA8xlEJ6vJMrYA=="],
 
@@ -187,7 +188,7 @@
 
     "deprecation": ["deprecation@2.3.1", "", {}, "sha512-xmHIy4F3scKVwMsQ4WnVaS8bHOx0DmVwRywosKhaILI0ywMDWPtBSku2HNxRvF7jtwDRsoEwYQSfbxj8b7RlJQ=="],
 
-    "detect-libc": ["detect-libc@2.0.4", "", {}, "sha512-3UDv+G9CsCKO1WKMGw9fwq/SWJYbI0c5Y7LU1AXYoDdbhE2AHQ6N6Nb34sG8Fj7T5APy8qXDCKuuIHd1BR0tVA=="],
+    "detect-libc": ["detect-libc@2.1.2", "", {}, "sha512-Btj2BOOO83o3WyH59e8MgXsxEQVcarkUOpEYrubB0urwnN10yQ364rsiByU11nZlqWYZm05i/of7io4mzihBtQ=="],
 
     "dot-case": ["dot-case@3.0.4", "", { "dependencies": { "no-case": "^3.0.4", "tslib": "^2.0.3" } }, "sha512-Kv5nKlh6yRrdrGvxeJ2e5y2eRUpkUosIW4A2AS38zwSz27zu7ufDwQPi5Jhs3XAlGNetl3bmnGhQsMtkKJnj3w=="],
 
@@ -211,27 +212,29 @@
 
     "jws": ["jws@3.2.2", "", { "dependencies": { "jwa": "^1.4.1", "safe-buffer": "^5.0.1" } }, "sha512-YHlZCB6lMTllWDtSPHz/ZXTsi8S00usEV6v1tjq8tOUZzw7DpSDWVXjXDre6ed1w/pd495ODpHZYSdkRTsa0HA=="],
 
-    "lightningcss": ["lightningcss@1.30.1", "", { "dependencies": { "detect-libc": "^2.0.3" }, "optionalDependencies": { "lightningcss-darwin-arm64": "1.30.1", "lightningcss-darwin-x64": "1.30.1", "lightningcss-freebsd-x64": "1.30.1", "lightningcss-linux-arm-gnueabihf": "1.30.1", "lightningcss-linux-arm64-gnu": "1.30.1", "lightningcss-linux-arm64-musl": "1.30.1", "lightningcss-linux-x64-gnu": "1.30.1", "lightningcss-linux-x64-musl": "1.30.1", "lightningcss-win32-arm64-msvc": "1.30.1", "lightningcss-win32-x64-msvc": "1.30.1" } }, "sha512-xi6IyHML+c9+Q3W0S4fCQJOym42pyurFiJUHEcEyHS0CeKzia4yZDEsLlqOFykxOdHpNy0NmvVO31vcSqAxJCg=="],
+    "lightningcss": ["lightningcss@1.30.2", "", { "dependencies": { "detect-libc": "^2.0.3" }, "optionalDependencies": { "lightningcss-android-arm64": "1.30.2", "lightningcss-darwin-arm64": "1.30.2", "lightningcss-darwin-x64": "1.30.2", "lightningcss-freebsd-x64": "1.30.2", "lightningcss-linux-arm-gnueabihf": "1.30.2", "lightningcss-linux-arm64-gnu": "1.30.2", "lightningcss-linux-arm64-musl": "1.30.2", "lightningcss-linux-x64-gnu": "1.30.2", "lightningcss-linux-x64-musl": "1.30.2", "lightningcss-win32-arm64-msvc": "1.30.2", "lightningcss-win32-x64-msvc": "1.30.2" } }, "sha512-utfs7Pr5uJyyvDETitgsaqSyjCb2qNRAtuqUeWIAKztsOYdcACf2KtARYXg2pSvhkt+9NfoaNY7fxjl6nuMjIQ=="],
 
-    "lightningcss-darwin-arm64": ["lightningcss-darwin-arm64@1.30.1", "", { "os": "darwin", "cpu": "arm64" }, "sha512-c8JK7hyE65X1MHMN+Viq9n11RRC7hgin3HhYKhrMyaXflk5GVplZ60IxyoVtzILeKr+xAJwg6zK6sjTBJ0FKYQ=="],
+    "lightningcss-android-arm64": ["lightningcss-android-arm64@1.30.2", "", { "os": "android", "cpu": "arm64" }, "sha512-BH9sEdOCahSgmkVhBLeU7Hc9DWeZ1Eb6wNS6Da8igvUwAe0sqROHddIlvU06q3WyXVEOYDZ6ykBZQnjTbmo4+A=="],
 
-    "lightningcss-darwin-x64": ["lightningcss-darwin-x64@1.30.1", "", { "os": "darwin", "cpu": "x64" }, "sha512-k1EvjakfumAQoTfcXUcHQZhSpLlkAuEkdMBsI/ivWw9hL+7FtilQc0Cy3hrx0AAQrVtQAbMI7YjCgYgvn37PzA=="],
+    "lightningcss-darwin-arm64": ["lightningcss-darwin-arm64@1.30.2", "", { "os": "darwin", "cpu": "arm64" }, "sha512-ylTcDJBN3Hp21TdhRT5zBOIi73P6/W0qwvlFEk22fkdXchtNTOU4Qc37SkzV+EKYxLouZ6M4LG9NfZ1qkhhBWA=="],
 
-    "lightningcss-freebsd-x64": ["lightningcss-freebsd-x64@1.30.1", "", { "os": "freebsd", "cpu": "x64" }, "sha512-kmW6UGCGg2PcyUE59K5r0kWfKPAVy4SltVeut+umLCFoJ53RdCUWxcRDzO1eTaxf/7Q2H7LTquFHPL5R+Gjyig=="],
+    "lightningcss-darwin-x64": ["lightningcss-darwin-x64@1.30.2", "", { "os": "darwin", "cpu": "x64" }, "sha512-oBZgKchomuDYxr7ilwLcyms6BCyLn0z8J0+ZZmfpjwg9fRVZIR5/GMXd7r9RH94iDhld3UmSjBM6nXWM2TfZTQ=="],
 
-    "lightningcss-linux-arm-gnueabihf": ["lightningcss-linux-arm-gnueabihf@1.30.1", "", { "os": "linux", "cpu": "arm" }, "sha512-MjxUShl1v8pit+6D/zSPq9S9dQ2NPFSQwGvxBCYaBYLPlCWuPh9/t1MRS8iUaR8i+a6w7aps+B4N0S1TYP/R+Q=="],
+    "lightningcss-freebsd-x64": ["lightningcss-freebsd-x64@1.30.2", "", { "os": "freebsd", "cpu": "x64" }, "sha512-c2bH6xTrf4BDpK8MoGG4Bd6zAMZDAXS569UxCAGcA7IKbHNMlhGQ89eRmvpIUGfKWNVdbhSbkQaWhEoMGmGslA=="],
 
-    "lightningcss-linux-arm64-gnu": ["lightningcss-linux-arm64-gnu@1.30.1", "", { "os": "linux", "cpu": "arm64" }, "sha512-gB72maP8rmrKsnKYy8XUuXi/4OctJiuQjcuqWNlJQ6jZiWqtPvqFziskH3hnajfvKB27ynbVCucKSm2rkQp4Bw=="],
+    "lightningcss-linux-arm-gnueabihf": ["lightningcss-linux-arm-gnueabihf@1.30.2", "", { "os": "linux", "cpu": "arm" }, "sha512-eVdpxh4wYcm0PofJIZVuYuLiqBIakQ9uFZmipf6LF/HRj5Bgm0eb3qL/mr1smyXIS1twwOxNWndd8z0E374hiA=="],
 
-    "lightningcss-linux-arm64-musl": ["lightningcss-linux-arm64-musl@1.30.1", "", { "os": "linux", "cpu": "arm64" }, "sha512-jmUQVx4331m6LIX+0wUhBbmMX7TCfjF5FoOH6SD1CttzuYlGNVpA7QnrmLxrsub43ClTINfGSYyHe2HWeLl5CQ=="],
+    "lightningcss-linux-arm64-gnu": ["lightningcss-linux-arm64-gnu@1.30.2", "", { "os": "linux", "cpu": "arm64" }, "sha512-UK65WJAbwIJbiBFXpxrbTNArtfuznvxAJw4Q2ZGlU8kPeDIWEX1dg3rn2veBVUylA2Ezg89ktszWbaQnxD/e3A=="],
 
-    "lightningcss-linux-x64-gnu": ["lightningcss-linux-x64-gnu@1.30.1", "", { "os": "linux", "cpu": "x64" }, "sha512-piWx3z4wN8J8z3+O5kO74+yr6ze/dKmPnI7vLqfSqI8bccaTGY5xiSGVIJBDd5K5BHlvVLpUB3S2YCfelyJ1bw=="],
+    "lightningcss-linux-arm64-musl": ["lightningcss-linux-arm64-musl@1.30.2", "", { "os": "linux", "cpu": "arm64" }, "sha512-5Vh9dGeblpTxWHpOx8iauV02popZDsCYMPIgiuw97OJ5uaDsL86cnqSFs5LZkG3ghHoX5isLgWzMs+eD1YzrnA=="],
 
-    "lightningcss-linux-x64-musl": ["lightningcss-linux-x64-musl@1.30.1", "", { "os": "linux", "cpu": "x64" }, "sha512-rRomAK7eIkL+tHY0YPxbc5Dra2gXlI63HL+v1Pdi1a3sC+tJTcFrHX+E86sulgAXeI7rSzDYhPSeHHjqFhqfeQ=="],
+    "lightningcss-linux-x64-gnu": ["lightningcss-linux-x64-gnu@1.30.2", "", { "os": "linux", "cpu": "x64" }, "sha512-Cfd46gdmj1vQ+lR6VRTTadNHu6ALuw2pKR9lYq4FnhvgBc4zWY1EtZcAc6EffShbb1MFrIPfLDXD6Xprbnni4w=="],
 
-    "lightningcss-win32-arm64-msvc": ["lightningcss-win32-arm64-msvc@1.30.1", "", { "os": "win32", "cpu": "arm64" }, "sha512-mSL4rqPi4iXq5YVqzSsJgMVFENoa4nGTT/GjO2c0Yl9OuQfPsIfncvLrEW6RbbB24WtZ3xP/2CCmI3tNkNV4oA=="],
+    "lightningcss-linux-x64-musl": ["lightningcss-linux-x64-musl@1.30.2", "", { "os": "linux", "cpu": "x64" }, "sha512-XJaLUUFXb6/QG2lGIW6aIk6jKdtjtcffUT0NKvIqhSBY3hh9Ch+1LCeH80dR9q9LBjG3ewbDjnumefsLsP6aiA=="],
 
-    "lightningcss-win32-x64-msvc": ["lightningcss-win32-x64-msvc@1.30.1", "", { "os": "win32", "cpu": "x64" }, "sha512-PVqXh48wh4T53F/1CCu8PIPCxLzWyCnn/9T5W1Jpmdy5h9Cwd+0YQS6/LwhHXSafuc61/xg9Lv5OrCby6a++jg=="],
+    "lightningcss-win32-arm64-msvc": ["lightningcss-win32-arm64-msvc@1.30.2", "", { "os": "win32", "cpu": "arm64" }, "sha512-FZn+vaj7zLv//D/192WFFVA0RgHawIcHqLX9xuWiQt7P0PtdFEVaxgF9rjM/IRYHQXNnk61/H/gb2Ei+kUQ4xQ=="],
+
+    "lightningcss-win32-x64-msvc": ["lightningcss-win32-x64-msvc@1.30.2", "", { "os": "win32", "cpu": "x64" }, "sha512-5g1yc73p+iAkid5phb4oVFMB45417DkRevRbt/El/gKXJk4jid+vPFF/AXbxn05Aky8PapwzZrdJShv5C0avjw=="],
 
     "lodash.includes": ["lodash.includes@4.3.0", "", {}, "sha512-W3Bx6mdkRTGtlJISOvVD/lbqjTlPPUDTMnlXZFnVwi9NKJ6tiAk6LVdlhZMm17VZisqhKcgzpO5Wz91PCt5b0w=="],
 
@@ -287,7 +290,7 @@
 
     "scheduler": ["scheduler@0.23.2", "", { "dependencies": { "loose-envify": "^1.1.0" } }, "sha512-UOShsPwz7NrMUqhR6t0hWjFduvOzbtv7toDH1/hIrfRNIDBnnBWd0CwJTGvTpngVlmwGCdP9/Zl/tVrDqcuYzQ=="],
 
-    "semver": ["semver@7.7.2", "", { "bin": { "semver": "bin/semver.js" } }, "sha512-RF0Fw+rO5AMf9MAyaRXI4AV0Ulj5lMHqVxxdSgiVbixSCXoEmmX/jk0CuJw4+3SqroYO9VoUh+HcuJivvtJemA=="],
+    "semver": ["semver@7.7.3", "", { "bin": { "semver": "bin/semver.js" } }, "sha512-SdsKMrI9TdgjdweUSR9MweHA4EJ8YxHn8DFaDisvhVlUOe4BF1tLD7GAj0lIqWVl+dPb/rExr0Btby5loQm20Q=="],
 
     "sentence-case": ["sentence-case@3.0.4", "", { "dependencies": { "no-case": "^3.0.4", "tslib": "^2.0.3", "upper-case-first": "^2.0.2" } }, "sha512-8LS0JInaQMCRoQ7YUytAo/xUu5W2XnQxV2HI/6uM6U7CITS1RqPElr30V6uIqyMKM9lJGRVFy5/4CuzcixNYSg=="],
 
@@ -303,7 +306,7 @@
 
     "uglify-js": ["uglify-js@3.19.3", "", { "bin": { "uglifyjs": "bin/uglifyjs" } }, "sha512-v3Xu+yuwBXisp6QYTcH4UbH+xYJXqnq2m/LtQVWKWzYc1iehYnLixoQDN9FH6/j9/oybfd6W9Ghwkl8+UMKTKQ=="],
 
-    "undici-types": ["undici-types@7.10.0", "", {}, "sha512-t5Fy/nfn+14LuOc2KNYg75vZqClpAiqscVvMygNnlsHBFpSXdJaYtXMcdNLpl/Qvc3P2cB3s6lOV51nqsFq4ag=="],
+    "undici-types": ["undici-types@7.16.0", "", {}, "sha512-Zz+aZWSj8LE6zoxD+xrjh4VfkIG8Ya6LvYkZqtUQGJPZjYl53ypCaUwWqo7eI0x66KBGeRo+mlBEkMSeSZ38Nw=="],
 
     "universal-github-app-jwt": ["universal-github-app-jwt@1.2.0", "", { "dependencies": { "@types/jsonwebtoken": "^9.0.0", "jsonwebtoken": "^9.0.2" } }, "sha512-dncpMpnsKBk0eetwfN8D8OUHGfiDhhJ+mtsbMl+7PfW7mYjiH8LIcqRmYMtzYLgSh47HjfdBtrBwIQ/gizKR3g=="],
 

bunfig.toml

@@ -10,4 +10,4 @@ preload = "./test/preload.ts"
 
 [install]
 linker = "isolated"
-minimumReleaseAge = 1
+minimumReleaseAge = 259200 # three days

cmake/targets/BuildBun.cmake

@@ -419,12 +419,9 @@ execute_process(
     --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})
@@ -872,6 +869,7 @@ target_include_directories(${bun} PRIVATE
   ${CODEGEN_PATH}
   ${VENDOR_PATH}
   ${VENDOR_PATH}/picohttpparser
+  ${VENDOR_PATH}/zlib
   ${NODEJS_HEADERS_PATH}/include
   ${NODEJS_HEADERS_PATH}/include/node
 )
@@ -1199,6 +1197,29 @@ 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} ${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

cmake/targets/BuildCares.cmake

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

cmake/tools/SetupBuildkite.cmake

@@ -48,6 +48,9 @@ if(NOT BUILDKITE_BUILD_STATUS EQUAL 0)
 endif()
 
 file(READ ${BUILDKITE_BUILD_PATH}/build.json BUILDKITE_BUILD)
+# Escape backslashes so CMake doesn't interpret JSON escape sequences (e.g., \n in commit messages)
+string(REPLACE "\\" "\\\\" 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/SetupCcache.cmake

@@ -5,18 +5,12 @@ 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/SetupSccache.cmake

@@ -1,123 +0,0 @@
-# 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

@@ -2,7 +2,7 @@ option(WEBKIT_VERSION "The version of WebKit to use")
 option(WEBKIT_LOCAL "If a local version of WebKit should be used instead of downloading")
 
 if(NOT WEBKIT_VERSION)
-  set(WEBKIT_VERSION 6d0f3aac0b817cc01a846b3754b21271adedac12)
+  set(WEBKIT_VERSION 1d0216219a3c52cb85195f48f19ba7d5db747ff7)
 endif()
 
 string(SUBSTRING ${WEBKIT_VERSION} 0 16 WEBKIT_VERSION_PREFIX)
@@ -28,6 +28,7 @@ if(WEBKIT_LOCAL)
     # make jsc-compile-debug jsc-copy-headers
     include_directories(
       ${WEBKIT_PATH}
+      ${WEBKIT_PATH}/JavaScriptCore/Headers
       ${WEBKIT_PATH}/JavaScriptCore/Headers/JavaScriptCore
       ${WEBKIT_PATH}/JavaScriptCore/PrivateHeaders
       ${WEBKIT_PATH}/bmalloc/Headers
@@ -90,7 +91,14 @@ if(EXISTS ${WEBKIT_PATH}/package.json)
   endif()
 endif()
 
-file(DOWNLOAD ${WEBKIT_DOWNLOAD_URL} ${CACHE_PATH}/${WEBKIT_FILENAME} SHOW_PROGRESS)
+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(ARCHIVE_EXTRACT INPUT ${CACHE_PATH}/${WEBKIT_FILENAME} DESTINATION ${CACHE_PATH} TOUCH)
 file(REMOVE ${CACHE_PATH}/${WEBKIT_FILENAME})
 file(REMOVE_RECURSE ${WEBKIT_PATH})

dockerhub/debian-slim/Dockerfile

@@ -1,4 +1,4 @@
-FROM debian:bookworm-slim AS build
+FROM debian:trixie-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:bookworm-slim
+FROM debian:trixie-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:bookworm-slim AS build
+FROM debian:trixie-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:bookworm
+FROM debian:trixie
 
 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:bookworm-slim AS build
+FROM debian:trixie-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-debian11
+FROM gcr.io/distroless/base-nossl-debian13
 
 # Disable the runtime transpiler cache by default inside Docker containers.
 # On ephemeral containers, the cache is not useful
@@ -71,6 +71,7 @@ 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/css.mdx

@@ -72,7 +72,7 @@ Bun's CSS bundler automatically converts this nested syntax into traditional fla
 
 You can also nest media queries and other at-rules inside selectors, eliminating the need to repeat selector patterns:
 
-```css title="styles.css" icon="file-code"
+```scss title="styles.css" icon="file-code"
 .responsive-element {
   display: block;
 

docs/bundler/esbuild.mdx

@@ -65,6 +65,7 @@ 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>
-    <link rel="stylesheet" href="tailwindcss" />
     <!-- [!code ++] -->
+    <link rel="stylesheet" href="tailwindcss" />
   </head>
   <!-- the rest of your HTML... -->
 </html>
@@ -448,8 +448,8 @@ Alternatively, you can import TailwindCSS in your CSS file:
 <!doctype html>
 <html>
   <head>
-    <link rel="stylesheet" href="./style.css" />
     <!-- [!code ++] -->
+    <link rel="stylesheet" href="./style.css" />
   </head>
   <!-- the rest of your HTML... -->
 </html>
@@ -492,6 +492,28 @@ Bun will lazily resolve and load each plugin and use them to bundle your routes.
   the CLI.
 </Note>
 
+## Inline Environment Variables
+
+Bun can replace `process.env.*` references in your frontend JavaScript and TypeScript with their actual values at build time. Configure the `env` option in your `bunfig.toml`:
+
+```toml title="bunfig.toml" icon="settings"
+[serve.static]
+env = "PUBLIC_*"  # only inline env vars starting with PUBLIC_ (recommended)
+# env = "inline"  # inline all environment variables
+# env = "disable" # disable env var replacement (default)
+```
+
+<Note>
+  This only works with literal `process.env.FOO` references, not `import.meta.env` or indirect access like `const env =
+  process.env; env.FOO`.
+
+If an environment variable is not set, you may see runtime errors like `ReferenceError: process
+  is not defined` in the browser.
+
+</Note>
+
+See the [HTML & static sites documentation](/bundler/html-static#inline-environment-variables) for more details on build-time configuration and examples.
+
 ## How It Works
 
 Bun uses `HTMLRewriter` to scan for `<script>` and `<link>` tags in HTML files, uses them as entrypoints for Bun's bundler, generates an optimized bundle for the JavaScript/TypeScript/TSX/JSX and CSS files, and serves the result.
@@ -632,7 +654,7 @@ const server = serve({
 console.log(`🚀 Server running on ${server.url}`);
 ```
 
-```html title="public/index.html"
+```html title="public/index.html" icon="file-code"
 <!DOCTYPE html>
 <html>
   <head>
@@ -757,7 +779,7 @@ export function App() {
 }
 ```
 
-```css title="src/styles.css"
+```css title="src/styles.css" icon="file-code"
 * {
   margin: 0;
   padding: 0;
@@ -999,7 +1021,7 @@ CMD ["bun", "index.js"]
 
 ### Environment Variables
 
-```bash title=".env.production" icon="file-code"
+```ini title=".env.production" icon="file-code"
 NODE_ENV=production
 PORT=3000
 DATABASE_URL=postgresql://user:pass@localhost:5432/myapp

docs/bundler/hot-reloading.mdx

@@ -9,7 +9,7 @@ Hot Module Replacement (HMR) allows you to update modules in a running applicati
 
 ## `import.meta.hot` API Reference
 
-Bun implements a client-side HMR API modeled after [Vite's `import.meta.hot` API](https://vitejs.dev/guide/api-hmr.html). It can be checked for with `if (import.meta.hot)`, tree-shaking it in production.
+Bun implements a client-side HMR API modeled after [Vite's `import.meta.hot` API](https://vite.dev/guide/api-hmr). It can be checked for with `if (import.meta.hot)`, tree-shaking it in production.
 
 ```ts title="index.ts" icon="/icons/typescript.svg"
 if (import.meta.hot) {
@@ -144,7 +144,7 @@ Indicates that multiple dependencies' modules can be accepted. This variant acce
 
 `import.meta.hot.data` maintains state between module instances during hot replacement, enabling data transfer from previous to new versions. When `import.meta.hot.data` is written into, Bun will also mark this module as capable of self-accepting (equivalent of calling `import.meta.hot.accept()`).
 
-```jsx title="index.ts" icon="/icons/typescript.svg"
+```tsx title="index.tsx" icon="/icons/typescript.svg"
 import { createRoot } from "react-dom/client";
 import { App } from "./app";
 

docs/bundler/html-static.mdx

@@ -25,7 +25,7 @@ bun ./index.html
 ```
 
 ```
-Bun v1.3.2
+Bun v1.3.3
 ready in 6.62ms
 → http://localhost:3000/
 Press h + Enter to show shortcuts
@@ -51,7 +51,7 @@ bun index.html
 ```
 
 ```
-Bun v1.3.2
+Bun v1.3.3
 ready in 6.62ms
 → http://localhost:3000/
 Press h + Enter to show shortcuts
@@ -81,7 +81,7 @@ bun ./index.html ./about.html
 ```
 
 ```txt
-Bun v1.3.2
+Bun v1.3.3
 ready in 6.62ms
 → http://localhost:3000/
 Routes:
@@ -104,7 +104,7 @@ bun ./**/*.html
 ```
 
 ```
-Bun v1.3.2
+Bun v1.3.3
 ready in 6.62ms
 → http://localhost:3000/
 Routes:
@@ -122,7 +122,7 @@ bun ./index.html ./about/index.html ./about/foo/index.html
 ```
 
 ```
-Bun v1.3.2
+Bun v1.3.3
 ready in 6.62ms
 → http://localhost:3000/
 Routes:
@@ -164,7 +164,7 @@ For example:
 }
 ```
 
-```css abc.css
+```css abc.css icon="file-code"
 body {
   background-color: red;
 }
@@ -174,7 +174,7 @@ body {
 
 This outputs:
 
-```css
+```css styles.css icon="file-code"
 body {
   background-color: red;
 }
@@ -262,6 +262,93 @@ Then, reference TailwindCSS in your HTML via `<link>` tag, `@import` in CSS, or
 
 <Info>Only one of those are necessary, not all three.</Info>
 
+## Inline environment variables
+
+Bun can replace `process.env.*` references in your JavaScript and TypeScript with their actual values at build time. This is useful for injecting configuration like API URLs or feature flags into your frontend code.
+
+### Dev server (runtime)
+
+To inline environment variables when using `bun ./index.html`, configure the `env` option in your `bunfig.toml`:
+
+```toml title="bunfig.toml" icon="settings"
+[serve.static]
+env = "PUBLIC_*"  # only inline env vars starting with PUBLIC_ (recommended)
+# env = "inline"  # inline all environment variables
+# env = "disable" # disable env var replacement (default)
+```
+
+<Note>
+  This only works with literal `process.env.FOO` references, not `import.meta.env` or indirect access like `const env =
+  process.env; env.FOO`.
+
+If an environment variable is not set, you may see runtime errors like `ReferenceError: process
+  is not defined` in the browser.
+
+</Note>
+
+Then run the dev server:
+
+```bash terminal icon="terminal"
+PUBLIC_API_URL=https://api.example.com bun ./index.html
+```
+
+### Build for production
+
+When building static HTML for production, use the `env` option to inline environment variables:
+
+<Tabs>
+  <Tab title="CLI">
+    ```bash terminal icon="terminal"
+    # Inline all environment variables
+    bun build ./index.html --outdir=dist --env=inline
+
+    # Only inline env vars with a specific prefix (recommended)
+    bun build ./index.html --outdir=dist --env=PUBLIC_*
+    ```
+
+  </Tab>
+  <Tab title="API">
+    ```ts title="build.ts" icon="/icons/typescript.svg"
+    // Inline all environment variables
+    await Bun.build({
+      entrypoints: ["./index.html"],
+      outdir: "./dist",
+      env: "inline", // [!code highlight]
+    });
+
+    // Only inline env vars with a specific prefix (recommended)
+    await Bun.build({
+      entrypoints: ["./index.html"],
+      outdir: "./dist",
+      env: "PUBLIC_*", // [!code highlight]
+    });
+    ```
+
+  </Tab>
+</Tabs>
+
+### Example
+
+Given this source file:
+
+```ts title="app.ts" icon="/icons/typescript.svg"
+const apiUrl = process.env.PUBLIC_API_URL;
+console.log(`API URL: ${apiUrl}`);
+```
+
+And running with `PUBLIC_API_URL=https://api.example.com`:
+
+```bash terminal icon="terminal"
+PUBLIC_API_URL=https://api.example.com bun build ./index.html --outdir=dist --env=PUBLIC_*
+```
+
+The bundled output will contain:
+
+```js title="dist/app.js" icon="/icons/javascript.svg"
+const apiUrl = "https://api.example.com";
+console.log(`API URL: ${apiUrl}`);
+```
+
 ## Echo console logs from browser to terminal
 
 Bun's dev server supports streaming console logs from the browser to the terminal.
@@ -273,7 +360,7 @@ bun ./index.html --console
 ```
 
 ```
-Bun v1.3.2
+Bun v1.3.3
 ready in 6.62ms
 → http://localhost:3000/
 Press h + Enter to show shortcuts
@@ -385,7 +472,8 @@ All paths are resolved relative to your HTML file, making it easy to organize yo
 - Need more configuration options for things like asset handling
 - Need a way to configure CORS, headers, etc.
 
-If you want to submit a PR, most of the code is [here](https://github.com/oven-sh/bun/blob/main/src/bun.js/api/bun/html-rewriter.ts). You could even copy paste that file into your project and use it as a starting point.
+{/* todo: find the correct link to link to as this 404's and there isn't any similar files */}
+{/* If you want to submit a PR, most of the code is [here](https://github.com/oven-sh/bun/blob/main/src/bun.js/api/bun/html-rewriter.ts). You could even copy paste that file into your project and use it as a starting point. */}
 
 </Warning>
 

docs/bundler/index.mdx

@@ -106,7 +106,7 @@ For each file specified in `entrypoints`, Bun will generate a new bundle. This b
 
 The contents of `out/index.js` will look something like this:
 
-```ts title="out/index.js" icon="/icons/javascript.svg"
+```js title="out/index.js" icon="/icons/javascript.svg"
 // out/index.js
 // ...
 // ~20k lines of code
@@ -220,6 +220,78 @@ 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.
@@ -527,7 +599,7 @@ Injects environment variables into the bundled output by converting `process.env
 
 For the input below:
 
-```ts title="input.js" icon="/icons/javascript.svg"
+```js title="input.js" icon="/icons/javascript.svg"
 // input.js
 console.log(process.env.FOO);
 console.log(process.env.BAZ);
@@ -535,7 +607,7 @@ console.log(process.env.BAZ);
 
 The generated bundle will contain the following code:
 
-```ts title="output.js" icon="/icons/javascript.svg"
+```js title="output.js" icon="/icons/javascript.svg"
 // output.js
 console.log("bar");
 console.log("123");
@@ -580,7 +652,7 @@ console.log(process.env.BAZ);
 
 The generated bundle will contain the following code:
 
-```ts title="output.js" icon="/icons/javascript.svg"
+```js title="output.js" icon="/icons/javascript.svg"
 console.log(process.env.FOO);
 console.log("https://acme.com");
 console.log(process.env.BAZ);
@@ -722,7 +794,7 @@ Normally, bundling `index.tsx` would generate a bundle containing the entire sou
 
 The generated bundle will look something like this:
 
-```ts title="out/index.js" icon="/icons/javascript.svg"
+```js title="out/index.js" icon="/icons/javascript.svg"
 import { z } from "zod";
 
 // ...
@@ -1026,7 +1098,7 @@ Setting `publicPath` will prefix all file paths with the specified value.
 
 The output file would now look something like this.
 
-```ts title="out/index.js" icon="/icons/javascript.svg"
+```js title="out/index.js" icon="/icons/javascript.svg"
 var logo = "https://cdn.example.com/logo-a7305bdef.svg";
 ```
 
@@ -1141,6 +1213,157 @@ 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>
+
+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:
@@ -1150,6 +1373,7 @@ interface BuildOutput {
   outputs: BuildArtifact[];
   success: boolean;
   logs: Array<object>; // see docs for details
+  metafile?: BuildMetafile; // only when metafile: true
 }
 
 interface BuildArtifact extends Blob {
@@ -1356,10 +1580,12 @@ interface BuildConfig {
    * JSX configuration object for controlling JSX transform behavior
    */
   jsx?: {
+    runtime?: "automatic" | "classic";
+    importSource?: string;
     factory?: string;
     fragment?: string;
-    importSource?: string;
-    runtime?: "automatic" | "classic";
+    sideEffects?: boolean;
+    development?: boolean;
   };
   naming?:
     | string
@@ -1443,13 +1669,20 @@ interface BuildConfig {
   drop?: string[];
 
   /**
-   * When set to `true`, the returned promise rejects with an AggregateError when a build failure happens.
-   * When set to `false`, the `success` property of the returned object will be `false` when a build failure happens.
+   * - When set to `true`, the returned promise rejects with an AggregateError when a build failure happens.
+   * - When set to `false`, returns a {@link BuildOutput} with `{success: false}`
    *
-   * This defaults to `false` in Bun 1.1 and will change to `true` in Bun 1.2
-   * as most usage of `Bun.build` forgets to check for errors.
+   * @default true
    */
   throw?: boolean;
+
+  /**
+   * Custom tsconfig.json file path to use for path resolution.
+   * Equivalent to `--tsconfig-override` in the CLI.
+   */
+  tsconfig?: string;
+
+  outdir?: string;
 }
 
 interface BuildOutput {

docs/bundler/loaders.mdx

@@ -312,7 +312,7 @@ The `html` loader processes HTML files and bundles any referenced assets. It wil
 
 For example, given this HTML file:
 
-```html title="src/index.html"
+```html title="src/index.html" icon="file-code"
 <!DOCTYPE html>
 <html>
   <body>
@@ -325,7 +325,7 @@ For example, given this HTML file:
 
 It will output a new HTML file with the bundled assets:
 
-```html title="dist/index.html"
+```html title="dist/index.html" icon="file-code"
 <!DOCTYPE html>
 <html>
   <body>

docs/bundler/macros.mdx

@@ -87,7 +87,7 @@ macro();
 
 When shipping a library containing a macro to npm or another package registry, use the `"macro"` export condition to provide a special version of your package exclusively for the macro environment.
 
-```json title="package.json" icon="file-code"
+```json title="package.json" icon="file-json"
 {
   "name": "my-package",
   "exports": {

docs/docs.json

@@ -121,6 +121,7 @@
               "/runtime/file-io",
               "/runtime/streams",
               "/runtime/binary-data",
+              "/runtime/archive",
               "/runtime/sql",
               "/runtime/sqlite",
               "/runtime/s3",
@@ -326,6 +327,7 @@
             "group": "Utilities",
             "icon": "wrench",
             "pages": [
+              "/guides/util/upgrade",
               "/guides/util/detect-bun",
               "/guides/util/version",
               "/guides/util/hash-a-password",
@@ -456,7 +458,6 @@
             "pages": [
               "/guides/test/run-tests",
               "/guides/test/watch-mode",
-              "/guides/test/concurrent-test-glob",
               "/guides/test/migrate-from-jest",
               "/guides/test/mock-functions",
               "/guides/test/spy-on",
@@ -465,6 +466,7 @@
               "/guides/test/update-snapshots",
               "/guides/test/coverage",
               "/guides/test/coverage-threshold",
+              "/guides/test/concurrent-test-glob",
               "/guides/test/skip-tests",
               "/guides/test/todo-tests",
               "/guides/test/timeout",

docs/feedback.mdx

@@ -4,13 +4,9 @@ description: Share feedback, bug reports, and feature requests
 mode: center
 ---
 
-import Feedback from "/snippets/cli/feedback.mdx";
-
 Whether you've found a bug, have a performance issue, or just want to suggest an improvement, here's how you can open a helpful issue:
 
-<Callout icon="discord">
-  For general questions, please join our [Discord](https://discord.com/invite/CXdq2DP29u).
-</Callout>
+<Callout icon="discord">For general questions, please join our [Discord](https://bun.com/discord).</Callout>
 
 ## Reporting Issues
 
@@ -56,9 +52,7 @@ Whether you've found a bug, have a performance issue, or just want to suggest an
     		<Note>
     			- For MacOS and Linux: copy the output of `uname -mprs`
     		  - For Windows: copy the output of this command in the powershell console:
-    				```powershell
-    					"$([Environment]::OSVersion | ForEach-Object VersionString) $(if ([Environment]::Is64BitOperatingSystem) { "x64" } else { "x86" })"
-    				```
+    				`"$([Environment]::OSVersion | ForEach-Object VersionString) $(if ([Environment]::Is64BitOperatingSystem) { "x64" } else { "x86" })"`
     		</Note>
     </Step>
 
@@ -79,7 +73,3 @@ echo "please document X" | bun feedback --email you@example.com
 ```
 
 You can provide feedback as text arguments, file paths, or piped input.
-
----
-
-<Feedback />

docs/guides/binary/arraybuffer-to-array.mdx

@@ -26,4 +26,4 @@ const regularArr = Array.from(uintArr);
 
 ---
 
-See [Docs > API > Binary Data](https://bun.com/docs/api/binary-data#conversion) for complete documentation on manipulating binary data with Bun.
+See [Docs > API > Binary Data](/runtime/binary-data#conversion) for complete documentation on manipulating binary data with Bun.

docs/guides/binary/arraybuffer-to-blob.mdx

@@ -23,4 +23,4 @@ blob.type; // => "application/octet-stream"
 
 ---
 
-See [Docs > API > Binary Data](https://bun.com/docs/api/binary-data#conversion) for complete documentation on manipulating binary data with Bun.
+See [Docs > API > Binary Data](/runtime/binary-data#conversion) for complete documentation on manipulating binary data with Bun.

docs/guides/binary/arraybuffer-to-buffer.mdx

@@ -24,4 +24,4 @@ const nodeBuffer = Buffer.from(arrBuffer, 0, 16); // view first 16 bytes
 
 ---
 
-See [Docs > API > Binary Data](https://bun.com/docs/api/binary-data#conversion) for complete documentation on manipulating binary data with Bun.
+See [Docs > API > Binary Data](/runtime/binary-data#conversion) for complete documentation on manipulating binary data with Bun.

docs/guides/binary/arraybuffer-to-string.mdx

@@ -14,4 +14,4 @@ const str = decoder.decode(buf);
 
 ---
 
-See [Docs > API > Binary Data](https://bun.com/docs/api/binary-data#conversion) for complete documentation on manipulating binary data with Bun.
+See [Docs > API > Binary Data](/runtime/binary-data#conversion) for complete documentation on manipulating binary data with Bun.

docs/guides/binary/arraybuffer-to-typedarray.mdx

@@ -38,4 +38,4 @@ const arr = new Uint8Array(buffer, 0, 16); // view first 16 bytes
 
 ---
 
-See [Docs > API > Utils](https://bun.com/docs/api/utils) for more useful utilities.
+See [Docs > API > Utils](/runtime/utils) for more useful utilities.

docs/guides/binary/blob-to-arraybuffer.mdx

@@ -13,4 +13,4 @@ const buf = await blob.arrayBuffer();
 
 ---
 
-See [Docs > API > Binary Data](https://bun.com/docs/api/binary-data#conversion) for complete documentation on manipulating binary data with Bun.
+See [Docs > API > Binary Data](/runtime/binary-data#conversion) for complete documentation on manipulating binary data with Bun.

docs/guides/binary/blob-to-dataview.mdx

@@ -13,4 +13,4 @@ const arr = new DataView(await blob.arrayBuffer());
 
 ---
 
-See [Docs > API > Binary Data](https://bun.com/docs/api/binary-data#conversion) for complete documentation on manipulating binary data with Bun.
+See [Docs > API > Binary Data](/runtime/binary-data#conversion) for complete documentation on manipulating binary data with Bun.

docs/guides/binary/blob-to-stream.mdx

@@ -13,4 +13,4 @@ const stream = await blob.stream();
 
 ---
 
-See [Docs > API > Binary Data](https://bun.com/docs/api/binary-data#conversion) for complete documentation on manipulating binary data with Bun.
+See [Docs > API > Binary Data](/runtime/binary-data#conversion) for complete documentation on manipulating binary data with Bun.

docs/guides/binary/blob-to-string.mdx

@@ -14,4 +14,4 @@ const str = await blob.text();
 
 ---
 
-See [Docs > API > Binary Data](https://bun.com/docs/api/binary-data#conversion) for complete documentation on manipulating binary data with Bun.
+See [Docs > API > Binary Data](/runtime/binary-data#conversion) for complete documentation on manipulating binary data with Bun.

docs/guides/binary/blob-to-typedarray.mdx

@@ -13,4 +13,4 @@ const arr = new Uint8Array(await blob.arrayBuffer());
 
 ---
 
-See [Docs > API > Binary Data](https://bun.com/docs/api/binary-data#conversion) for complete documentation on manipulating binary data with Bun.
+See [Docs > API > Binary Data](/runtime/binary-data#conversion) for complete documentation on manipulating binary data with Bun.

docs/guides/binary/buffer-to-arraybuffer.mdx

@@ -13,4 +13,4 @@ const arrBuf = nodeBuf.buffer;
 
 ---
 
-See [Docs > API > Binary Data](https://bun.com/docs/api/binary-data#conversion) for complete documentation on manipulating binary data with Bun.
+See [Docs > API > Binary Data](/runtime/binary-data#conversion) for complete documentation on manipulating binary data with Bun.

docs/guides/binary/buffer-to-blob.mdx

@@ -13,4 +13,4 @@ const blob = new Blob([buf]);
 
 ---
 
-See [Docs > API > Binary Data](https://bun.com/docs/api/binary-data#conversion) for complete documentation on manipulating binary data with Bun.
+See [Docs > API > Binary Data](/runtime/binary-data#conversion) for complete documentation on manipulating binary data with Bun.

docs/guides/binary/buffer-to-readablestream.mdx

@@ -40,4 +40,4 @@ const stream = blob.stream(1024);
 
 ---
 
-See [Docs > API > Binary Data](https://bun.com/docs/api/binary-data#conversion) for complete documentation on manipulating binary data with Bun.
+See [Docs > API > Binary Data](/runtime/binary-data#conversion) for complete documentation on manipulating binary data with Bun.

docs/guides/binary/buffer-to-string.mdx

@@ -24,4 +24,4 @@ const str = buf.toString("utf8", 0, 5);
 
 ---
 
-See [Docs > API > Binary Data](https://bun.com/docs/api/binary-data#conversion) for complete documentation on manipulating binary data with Bun.
+See [Docs > API > Binary Data](/runtime/binary-data#conversion) for complete documentation on manipulating binary data with Bun.

docs/guides/binary/buffer-to-typedarray.mdx

@@ -13,4 +13,4 @@ buf instanceof Uint8Array; // => true
 
 ---
 
-See [Docs > API > Binary Data](https://bun.com/docs/api/binary-data#conversion) for complete documentation on manipulating binary data with Bun.
+See [Docs > API > Binary Data](/runtime/binary-data#conversion) for complete documentation on manipulating binary data with Bun.

docs/guides/binary/dataview-to-string.mdx

@@ -14,4 +14,4 @@ const str = decoder.decode(dv);
 
 ---
 
-See [Docs > API > Binary Data](https://bun.com/docs/api/binary-data#conversion) for complete documentation on manipulating binary data with Bun.
+See [Docs > API > Binary Data](/runtime/binary-data#conversion) for complete documentation on manipulating binary data with Bun.

docs/guides/binary/typedarray-to-arraybuffer.mdx

@@ -24,4 +24,4 @@ arr.byteLength; // => 32
 
 ---
 
-See [Docs > API > Binary Data](https://bun.com/docs/api/binary-data#conversion) for complete documentation on manipulating binary data with Bun.
+See [Docs > API > Binary Data](/runtime/binary-data#conversion) for complete documentation on manipulating binary data with Bun.

docs/guides/binary/typedarray-to-blob.mdx

@@ -15,4 +15,4 @@ console.log(await blob.text());
 
 ---
 
-See [Docs > API > Binary Data](https://bun.com/docs/api/binary-data#conversion) for complete documentation on manipulating binary data with Bun.
+See [Docs > API > Binary Data](/runtime/binary-data#conversion) for complete documentation on manipulating binary data with Bun.

docs/guides/binary/typedarray-to-buffer.mdx

@@ -13,4 +13,4 @@ const buf = Buffer.from(arr);
 
 ---
 
-See [Docs > API > Binary Data](https://bun.com/docs/api/binary-data#conversion) for complete documentation on manipulating binary data with Bun.
+See [Docs > API > Binary Data](/runtime/binary-data#conversion) for complete documentation on manipulating binary data with Bun.

docs/guides/binary/typedarray-to-dataview.mdx

@@ -13,4 +13,4 @@ const dv = new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
 
 ---
 
-See [Docs > API > Binary Data](https://bun.com/docs/api/binary-data#conversion) for complete documentation on manipulating binary data with Bun.
+See [Docs > API > Binary Data](/runtime/binary-data#conversion) for complete documentation on manipulating binary data with Bun.

docs/guides/binary/typedarray-to-readablestream.mdx

@@ -40,4 +40,4 @@ const stream = blob.stream(1024);
 
 ---
 
-See [Docs > API > Binary Data](https://bun.com/docs/api/binary-data#conversion) for complete documentation on manipulating binary data with Bun.
+See [Docs > API > Binary Data](/runtime/binary-data#conversion) for complete documentation on manipulating binary data with Bun.

docs/guides/binary/typedarray-to-string.mdx

@@ -15,4 +15,4 @@ const str = decoder.decode(arr);
 
 ---
 
-See [Docs > API > Binary Data](https://bun.com/docs/api/binary-data#conversion) for complete documentation on manipulating binary data with Bun.
+See [Docs > API > Binary Data](/runtime/binary-data#conversion) for complete documentation on manipulating binary data with Bun.

docs/guides/deployment/vercel.mdx

@@ -4,8 +4,6 @@ sidebarTitle: Deploy on Vercel
 mode: center
 ---
 
-import { ProductCard } from "/snippets/product-card.mdx";
-
 [Vercel](https://vercel.com/) is a cloud platform that lets you build, deploy, and scale your apps.
 
 <Warning>
@@ -81,7 +79,7 @@ import { ProductCard } from "/snippets/product-card.mdx";
     	console.log("runtime", process.versions.bun);
     	```
     	```txt
-    	runtime 1.3.2
+    	runtime 1.3.3
     	```
 
     	[See the Vercel Bun Runtime documentation for feature support →](https://vercel.com/docs/functions/runtimes/bun#feature-support)

docs/guides/ecosystem/discordjs.mdx

@@ -22,7 +22,7 @@ bun add discord.js
 
 ---
 
-Before we go further, we need to go to the [Discord developer portal](https://discord.com/developers/applications), login/signup, create a new _Application_, then create a new _Bot_ within that application. Follow the [official guide](https://discordjs.guide/preparations/setting-up-a-bot-application.html#creating-your-bot) for step-by-step instructions.
+Before we go further, we need to go to the [Discord developer portal](https://discord.com/developers/applications), login/signup, create a new _Application_, then create a new _Bot_ within that application. Follow the [official guide](https://discordjs.guide/legacy/preparations/app-setup#creating-your-bot) for step-by-step instructions.
 
 ---
 
@@ -30,7 +30,7 @@ Once complete, you'll be presented with your bot's _private key_. Let's add this
 
 <Note>This is an example token that has already been invalidated.</Note>
 
-```txt .env.local icon="settings"
+```ini .env.local icon="settings"
 DISCORD_TOKEN=NzkyNzE1NDU0MTk2MDg4ODQy.X-hvzA.Ovy4MCQywSkoMRRclStW4xAYK7I
 ```
 

docs/guides/ecosystem/express.mdx

@@ -7,8 +7,8 @@ mode: center
 Express and other major Node.js HTTP libraries should work out of the box. Bun implements the [`node:http`](https://nodejs.org/api/http.html) and [`node:https`](https://nodejs.org/api/https.html) modules that these libraries rely on.
 
 <Note>
-  Refer to the [Runtime > Node.js APIs](https://bun.com/docs/runtime/nodejs-apis#node-http) page for more detailed
-  compatibility information.
+  Refer to the [Runtime > Node.js APIs](/runtime/nodejs-compat#node-http) page for more detailed compatibility
+  information.
 </Note>
 
 ```sh terminal icon="terminal"

docs/guides/ecosystem/mongoose.mdx

@@ -89,4 +89,4 @@ Moo!
 
 ---
 
-This is a simple introduction to using Mongoose with TypeScript and Bun. As you build your application, refer to the official [MongoDB](https://docs.mongodb.com/) and [Mongoose](https://mongoosejs.com/docs/) sites for complete documentation.
+This is a simple introduction to using Mongoose with TypeScript and Bun. As you build your application, refer to the official [MongoDB](https://www.mongodb.com/docs) and [Mongoose](https://mongoosejs.com/docs/) sites for complete documentation.

docs/guides/ecosystem/neon-drizzle.mdx

@@ -20,7 +20,7 @@ bun add -D drizzle-kit
 
 Create a `.env.local` file and add your [Neon Postgres connection string](https://neon.tech/docs/connect/connect-from-any-app) to it.
 
-```txt .env.local icon="settings"
+```ini .env.local icon="settings"
 DATABASE_URL=postgresql://usertitle:password@ep-adj-noun-guid.us-east-1.aws.neon.tech/neondb?sslmode=require
 ```
 
@@ -33,7 +33,7 @@ import { neon } from "@neondatabase/serverless";
 import { drizzle } from "drizzle-orm/neon-http";
 
 // Bun automatically loads the DATABASE_URL from .env.local
-// Refer to: https://bun.com/docs/runtime/env for more information
+// Refer to: https://bun.com/docs/runtime/environment-variables for more information
 const sql = neon(process.env.DATABASE_URL!);
 
 export const db = drizzle(sql);

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

@@ -21,7 +21,7 @@ bun add @neondatabase/serverless
 
 Create a `.env.local` file and add your [Neon Postgres connection string](https://neon.tech/docs/connect/connect-from-any-app) to it.
 
-```sh .env.local icon="settings"
+```ini .env.local icon="settings"
 DATABASE_URL=postgresql://usertitle:password@ep-adj-noun-guid.us-east-1.aws.neon.tech/neondb?sslmode=require
 ```
 
@@ -33,7 +33,7 @@ Paste the following code into your project's `index.ts` file.
 import { neon } from "@neondatabase/serverless";
 
 // Bun automatically loads the DATABASE_URL from .env.local
-// Refer to: https://bun.com/docs/runtime/env for more information
+// Refer to: https://bun.com/docs/runtime/environment-variables for more information
 const sql = neon(process.env.DATABASE_URL);
 
 const rows = await sql`SELECT version()`;

docs/guides/ecosystem/nuxt.mdx

@@ -14,7 +14,7 @@ bunx nuxi init my-nuxt-app
 ✔ Which package manager would you like to use?
 bun
 ◐ Installing dependencies...
-bun install v1.3.2 (16b4bf34)
+bun install v1.3.3 (16b4bf34)
  + @nuxt/devtools@0.8.2
  + nuxt@3.7.0
  785 packages installed [2.67s]
@@ -74,6 +74,12 @@ 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 = {
-  title: "app", // Name of your application
+  name: "app", // Name of your application
   script: "index.ts", // Entry point of your application
   interpreter: "bun", // Bun interpreter
   env: {

docs/guides/ecosystem/prisma-postgres.mdx

@@ -62,7 +62,7 @@ mode: center
     <Step title="Configure database connection">
     	Set up your Postgres database URL in the `.env` file.
 
-    	```env .env icon="settings"
+    	```ini .env icon="settings"
     	DATABASE_URL="postgresql://username:password@localhost:5432/mydb?schema=public"
     	```
     </Step>

docs/guides/ecosystem/prisma.mdx

@@ -161,4 +161,4 @@ mode: center
 
 ---
 
-That's it! Now that you've set up Prisma using Bun, we recommend referring to the [official Prisma docs](https://www.prisma.io/docs/concepts/components/prisma-client) as you continue to develop your application.
+That's it! Now that you've set up Prisma using Bun, we recommend referring to the [official Prisma docs](https://www.prisma.io/docs/orm/prisma-client) as you continue to develop your application.

docs/guides/ecosystem/qwik.mdx

@@ -65,14 +65,14 @@ bun create qwik
 │  bun qwik add                                        │
 │                                                      │
 │  Relevant docs:                                      │
-│  https://qwik.builder.io/docs/getting-started/       │
+│  https://qwik.dev/docs/getting-started/              │
 │                                                      │
 │  Questions? Start the conversation at:               │
-│  https://qwik.builder.io/chat                        │
+│  https://qwik.dev/chat                               │
 │  https://twitter.com/QwikDev                         │
 │                                                      │
 │  Presentations, Podcasts and Videos:                 │
-│  https://qwik.builder.io/media/                      │
+│  https://qwik.dev/media/                             │
 │                                                      │
 │  Next steps:                                         │
 │  cd my-app                                           │
@@ -111,4 +111,4 @@ Open [http://localhost:5173](http://localhost:5173) with your browser to see the
 
 ---
 
-Refer to the [Qwik docs](https://qwik.builder.io/docs/getting-started/) for complete documentation.
+Refer to the [Qwik docs](https://qwik.dev/docs/getting-started/) for complete documentation.

docs/guides/ecosystem/sentry.mdx

@@ -20,7 +20,7 @@ bun add @sentry/bun
 
 Then, initialize the Sentry SDK with your Sentry DSN in your app's entry file. You can find your DSN in your Sentry project settings.
 
-```js sentry.ts icon="/icons/typescript.svg"
+```ts sentry.ts icon="/icons/typescript.svg"
 import * as Sentry from "@sentry/bun";
 
 // Ensure to call this before importing any other modules!
@@ -37,7 +37,7 @@ Sentry.init({
 
 You can verify that Sentry is working by capturing a test error:
 
-```js sentry.ts icon="/icons/typescript.svg"
+```ts sentry.ts icon="/icons/typescript.svg"
 setTimeout(() => {
   try {
     foo();

docs/guides/ecosystem/solidstart.mdx

@@ -4,63 +4,59 @@ sidebarTitle: "SolidStart with Bun"
 mode: center
 ---
 
-<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`.
+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.
 
 ```sh terminal icon="terminal"
-bun create solid my-app
+bun create solid my-app --solidstart --ts
 ```
 
 ```txt
-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
+┌
+ 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               │
+│                        │
+├────────────────────────╯
 ```
 
 ---
 
-As instructed by the `create-solid` CLI, let's install our dependencies.
+As instructed by the `create-solid` CLI, install the dependencies.
 
 ```sh terminal icon="terminal"
 cd my-app
 bun install
 ```
 
----
-
-Then run the development server.
+Then run the development server with `bun dev`.
 
 ```sh terminal icon="terminal"
-bun run dev
-# or, equivalently
-bunx solid-start dev
+bun 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.
 
-<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.
+Refer to the [SolidStart website](https://docs.solidjs.com/solid-start) for complete framework documentation.

docs/guides/ecosystem/sveltekit.mdx

@@ -88,7 +88,7 @@ To build for production, you'll need to add the right SvelteKit adapter. Current
 
 Now, make the following changes to your `svelte.config.js`.
 
-```ts svelte.config.js icon="file-code"
+```js svelte.config.js icon="file-code"
 import adapter from "@sveltejs/adapter-auto"; // [!code --]
 import adapter from "svelte-adapter-bun"; // [!code ++]
 import { vitePreprocess } from "@sveltejs/vite-plugin-svelte";

docs/guides/ecosystem/tanstack-start.mdx

@@ -98,7 +98,6 @@ To host your TanStack Start app, you can use [Nitro](https://nitro.build/) or a
           }
         ```
 
-
         <Note>
           You do **not** need the custom `start` script when deploying to Vercel.
         </Note>