deps: update libarchive to v3.8.4 (d114ceee6de08a7a60ff1209492ba38bf9436f79)

.buildkite/Dockerfile

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

.buildkite/ci.mjs

@@ -31,7 +31,7 @@ import {
 } from "../scripts/utils.mjs";
 
 /**
- * @typedef {"linux" | "darwin" | "windows"} Os
+ * @typedef {"linux" | "darwin" | "windows" | "freebsd"} Os
  * @typedef {"aarch64" | "x64"} Arch
  * @typedef {"musl"} Abi
  * @typedef {"debian" | "ubuntu" | "alpine" | "amazonlinux"} Distro
@@ -114,6 +114,7 @@ const buildPlatforms = [
   { os: "linux", arch: "x64", abi: "musl", baseline: true, distro: "alpine", release: "3.22" },
   { os: "windows", arch: "x64", release: "2019" },
   { os: "windows", arch: "x64", baseline: true, release: "2019" },
+  { os: "freebsd", arch: "x64", release: "14.3" },
 ];
 
 /**
@@ -571,7 +572,6 @@ function getTestBunStep(platform, options, testOptions = {}) {
   if (buildId) {
     args.push(`--build-id=${buildId}`);
   }
-
   if (testFiles) {
     args.push(...testFiles.map(testFile => `--include=${testFile}`));
   }
@@ -657,7 +657,7 @@ function getReleaseStep(buildPlatforms, options) {
     agents: {
       queue: "test-darwin",
     },
-    depends_on: buildPlatforms.map(platform => `${getTargetKey(platform)}-build-bun`),
+    depends_on: buildPlatforms.filter(p => p.os !== "freebsd").map(platform => `${getTargetKey(platform)}-build-bun`),
     env: {
       CANARY: revision,
     },
@@ -1108,6 +1108,9 @@ async function getPipeline(options = {}) {
       ? buildPlatforms
       : buildPlatforms.filter(({ profile }) => profile !== "asan");
 
+    // run build-image but no build-bun yet
+    relevantBuildPlatforms = relevantBuildPlatforms.filter(({ os }) => os !== "freebsd");
+
     steps.push(
       ...relevantBuildPlatforms.map(target => {
         const imageKey = getImageKey(target);

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

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

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

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

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

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

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

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

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

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

.coderabbit.yaml

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

.cursor/rules/building-bun.mdc

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

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

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

.cursor/rules/javascriptcore-class.mdc

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

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

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

.cursor/rules/writing-tests.mdc

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

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

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

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

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

.gitignore

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

CLAUDE.md

@@ -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. These tests will never fail in CI.
+- NEVER write tests that check for no "panic" or "uncaught exception" or similar in the test output. That is NOT a valid test.
 - Use `tempDir` from `"harness"` to create a temporary directory. **Do not** use `tmpdirSync` or `fs.mkdtempSync` to create temporary directories.
 - When spawning processes, tests should expect(stdout).toBe(...) BEFORE expect(exitCode).toBe(0). This gives you a more useful error message on test failure.
 - **CRITICAL**: Do not write flaky tests. Do not use `setTimeout` in tests. Instead, `await` the condition to be met. You are not testing the TIME PASSING, you are testing the CONDITION.

CMakeLists.txt

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

CONTRIBUTING.md

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

LATEST

@@ -1 +1 @@
-1.3.5
+1.3.3

TODO.md

@@ -0,0 +1,51 @@
+- [ ] issue-207.test.ts: update webkit to allow overridenDateNow to be negative. we will have to pick some other value to be none, eg NaN.
+
+- [ ] process.hrtime (same as performance.now, resets to [0, 0] when fake timers are enabled)
+- [ ] decimal ticks should be supported: https://github.com/sinonjs/fake-timers/blob/main/test/issue-207-test.js
+- [ ] what happens when you add negative time?
+
+- [ ] test abortsignal
+- [ ] test spawnSync
+- [ ] support performance.now
+- [ ] support Date.now()
+- [ ] support useFakeTimers in combination with setSystemTime
+- [ ] support functions:
+  - [x] advanceTimersByTime
+  - [ ] advanceTimersByTimeAsync\*
+  - [x] advanceTimersToNextTimer
+  - [ ] advanceTimersToNextTimerAsync\*
+  - [ ] advanceTimersToNextFrame
+  - [x] getTimerCount
+  - [x] clearAllTimers
+  - [ ] getMockedSystemTime
+  - [ ] getRealSystemTime
+  - [ ] runAllTicks
+  - [x] runAllTimers
+  - [ ] runAllTimersAsync\*
+  - [x] runOnlyPendingTimers
+    - [x] make sure `[10, [20]], [30, [40]]` runs 10, 20, and 30
+  - [ ] runOnlyPendingTimersAsync
+  - [ ] setSystemTime
+  - [x] useFakeTimers
+  - [x] isFakeTimers
+  - [x] useRealTimers
+- [ ] the result of 'arm' ('.disarm'/'.rearm') seems to be ignored? both disarm and rearm? we should change it to return void if it's actually ignored
+  - [ ] we can make this change seperately in main
+- [ ] see how fake timers works with setSystemTime
+- [ ] handle the config argument for useFakeTimers
+  - vitest has the toFake parameter for enabling nextTick and queueMicrotask
+  - jets has a timerLimit parameter
+- [ ] make sure there is no memory leak if you create a setTimeout/setInterval and clear or stop the fake timers before it fires repeatedly.
+- [ ] audit the allowFakeTimers list (do we want subprocess timeouts to count? and others)
+  - we will also need some timespec.now() calls to exclude mocked time, ie `timespec.nowUnmocked()`
+  - since test timeouts must be unmocked, we need BunTest timeouts to use unmocked time
+  - [ ] audit all timespec.now() calls to replace some with timespec.nowUnmocked()
+- [ ] add a test that fake timers do not break test duration calculations
+- [ ] test the order of '0' timeouts, decide if we will match or not
+  - [ ] consider supporting edge-case where `timeout0(A, timeout0(B)), timeout0(C)` prints `A=0, C=0, B=1` (date.now())
+- [ ] \* support async functions (maybe defer these for later? the first PR does not need to have everything. we can stub the unimplemented functions.)
+- [ ] add types for all functions
+- [ ] add docs for all functions (at minimum: documentatino comments in the types)
+- [ ] determine which tags should have timer-faking enabled (eg should subprocess timeout? probably not but maybe)
+- [ ] find real projects using fake timers, see if they work
+- [ ] make sure we match jest fake timers also

bench/bun.lock

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

bench/snippets/array-of.js

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

bench/snippets/object-hasown.mjs

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

bench/snippets/promise-race.mjs

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

bench/snippets/response-json.mjs

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

bench/snippets/string-includes.mjs

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

bun.lock

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

cmake/targets/BuildBun.cmake

@@ -872,7 +872,6 @@ target_include_directories(${bun} PRIVATE
   ${CODEGEN_PATH}
   ${VENDOR_PATH}
   ${VENDOR_PATH}/picohttpparser
-  ${VENDOR_PATH}/zlib
   ${NODEJS_HEADERS_PATH}/include
   ${NODEJS_HEADERS_PATH}/include/node
 )
@@ -1200,29 +1199,6 @@ 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
-    3ac47ee46edd8ea40370222f91613fc16c434853
+    d3a507e920e7af18a5efb7f9f1d8044ed4750013
 )
 
 register_cmake_command(

cmake/targets/BuildLibArchive.cmake

@@ -4,7 +4,7 @@ register_repository(
   REPOSITORY
     libarchive/libarchive
   COMMIT
-    9525f90ca4bd14c7b335e2f8c84a4607b0af6bdf
+    d114ceee6de08a7a60ff1209492ba38bf9436f79
 )
 
 register_cmake_command(

cmake/tools/SetupCcache.cmake

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

cmake/tools/SetupSccache.cmake

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

cmake/tools/SetupWebKit.cmake

@@ -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 preview-pr-122-786e646a)
+  set(WEBKIT_VERSION 6d0f3aac0b817cc01a846b3754b21271adedac12)
 endif()
 
 string(SUBSTRING ${WEBKIT_VERSION} 0 16 WEBKIT_VERSION_PREFIX)

docs/bundler/esbuild.mdx

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

docs/bundler/fullstack.mdx

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

docs/bundler/index.mdx

@@ -1141,84 +1141,6 @@ Remove function calls from a bundle. For example, `--drop=console` will remove a
   </Tab>
 </Tabs>
 
-### features
-
-Enable compile-time feature flags for dead-code elimination. This provides a way to conditionally include or exclude code paths at bundle time using `import { feature } from "bun:bundle"`.
-
-```ts title="app.ts" icon="/icons/typescript.svg"
-import { feature } from "bun:bundle";
-
-if (feature("PREMIUM")) {
-  // Only included when PREMIUM flag is enabled
-  initPremiumFeatures();
-}
-
-if (feature("DEBUG")) {
-  // Only included when DEBUG flag is enabled
-  console.log("Debug mode");
-}
-```
-
-<Tabs>
-  <Tab title="JavaScript">
-    ```ts title="build.ts" icon="/icons/typescript.svg"
-    await Bun.build({
-      entrypoints: ['./app.ts'],
-      outdir: './out',
-      features: ["PREMIUM"],  // PREMIUM=true, DEBUG=false
-    })
-    ```
-  </Tab>
-  <Tab title="CLI">
-    ```bash terminal icon="terminal"
-    bun build ./app.ts --outdir ./out --feature PREMIUM
-    ```
-  </Tab>
-</Tabs>
-
-The `feature()` function is replaced with `true` or `false` at bundle time. Combined with minification, unreachable code is eliminated:
-
-```ts title="Input" icon="/icons/typescript.svg"
-import { feature } from "bun:bundle";
-const mode = feature("PREMIUM") ? "premium" : "free";
-```
-
-```js title="Output (with --feature PREMIUM --minify)" icon="/icons/javascript.svg"
-var mode = "premium";
-```
-
-```js title="Output (without --feature PREMIUM, with --minify)" icon="/icons/javascript.svg"
-var mode = "free";
-```
-
-**Key behaviors:**
-
-- `feature()` requires a string literal argument — dynamic values are not supported
-- The `bun:bundle` import is completely removed from the output
-- Works with `bun build`, `bun run`, and `bun test`
-- Multiple flags can be enabled: `--feature FLAG_A --feature FLAG_B`
-- For type safety, augment the `Registry` interface to restrict `feature()` to known flags (see below)
-
-**Use cases:**
-
-- Platform-specific code (`feature("SERVER")` vs `feature("CLIENT")`)
-- Environment-based features (`feature("DEVELOPMENT")`)
-- Gradual feature rollouts
-- A/B testing variants
-- Paid tier features
-
-**Type safety:** By default, `feature()` accepts any string. To get autocomplete and catch typos at compile time, create an `env.d.ts` file (or add to an existing `.d.ts`) and augment the `Registry` interface:
-
-```ts title="env.d.ts" icon="/icons/typescript.svg"
-declare module "bun:bundle" {
-  interface Registry {
-    features: "DEBUG" | "PREMIUM" | "BETA_FEATURES";
-  }
-}
-```
-
-Ensure the file is included in your `tsconfig.json` (e.g., `"include": ["src", "env.d.ts"]`). Now `feature()` only accepts those flags, and invalid strings like `feature("TYPO")` become type errors.
-
 ## Outputs
 
 The `Bun.build` function returns a `Promise<BuildOutput>`, defined as:

docs/guides/install/trusted.mdx

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

docs/guides/process/os-signals.mdx

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

docs/guides/test/mock-functions.mdx

@@ -60,7 +60,7 @@ test("random", async () => {
 
   expect(random).toHaveBeenCalled();
   expect(random).toHaveBeenCalledTimes(3);
-  expect(random.mock.calls).toEqual([[1], [2], [3]]);
+  expect(random.mock.args).toEqual([[1], [2], [3]]);
   expect(random.mock.results[0]).toEqual({ type: "return", value: a });
 });
 ```

docs/pm/lifecycle.mdx

@@ -46,13 +46,6 @@ Once added to `trustedDependencies`, install/re-install the package. Bun will re
 
 The top 500 npm packages with lifecycle scripts are allowed by default. You can see the full list [here](https://github.com/oven-sh/bun/blob/main/src/install/default-trusted-dependencies.txt).
 
-<Note>
-  The default trusted dependencies list only applies to packages installed from npm. For packages from other sources
-  (such as `file:`, `link:`, `git:`, or `github:` dependencies), you must explicitly add them to `trustedDependencies`
-  to run their lifecycle scripts, even if the package name matches an entry in the default list. This prevents malicious
-  packages from spoofing trusted package names through local file paths or git repositories.
-</Note>
-
 ---
 
 ## `--ignore-scripts`

docs/project/building-windows.mdx

@@ -49,7 +49,7 @@ After Visual Studio, you need the following:
 
 ```ps1 Scoop
 > irm https://get.scoop.sh | iex
-> scoop install nodejs-lts go rust nasm ruby perl ccache
+> scoop install nodejs-lts go rust nasm ruby perl sccache
 # scoop seems to be buggy if you install llvm and the rest at the same time
 > scoop install llvm@19.1.7
 ```

docs/project/contributing.mdx

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

docs/runtime/bunfig.mdx

@@ -115,26 +115,6 @@ Currently we do not collect telemetry and this setting is only used for enabling
 telemetry = false
 ```
 
-### `env`
-
-Configure automatic `.env` file loading. By default, Bun automatically loads `.env` files. To disable this behavior:
-
-```toml title="bunfig.toml" icon="settings"
-# Disable automatic .env file loading
-env = false
-```
-
-You can also use object syntax with the `file` property:
-
-```toml title="bunfig.toml" icon="settings"
-[env]
-file = false
-```
-
-This is useful in production environments or CI/CD pipelines where you want to rely solely on system environment variables.
-
-Note: Explicitly provided environment files via `--env-file` will still be loaded even when default loading is disabled.
-
 ### `console`
 
 Configure console output behavior.

docs/runtime/child-process.mdx

@@ -315,109 +315,6 @@ if (typeof Bun !== "undefined") {
 
 ---
 
-## Terminal (PTY) support
-
-For interactive terminal applications, you can spawn a subprocess with a pseudo-terminal (PTY) attached using the `terminal` option. This makes the subprocess think it's running in a real terminal, enabling features like colored output, cursor movement, and interactive prompts.
-
-```ts
-const proc = Bun.spawn(["bash"], {
-  terminal: {
-    cols: 80,
-    rows: 24,
-    data(terminal, data) {
-      // Called when data is received from the terminal
-      process.stdout.write(data);
-    },
-  },
-});
-
-// Write to the terminal
-proc.terminal.write("echo hello\n");
-
-// Wait for the process to exit
-await proc.exited;
-
-// Close the terminal
-proc.terminal.close();
-```
-
-When the `terminal` option is provided:
-
-- The subprocess sees `process.stdout.isTTY` as `true`
-- `stdin`, `stdout`, and `stderr` are all connected to the terminal
-- `proc.stdin`, `proc.stdout`, and `proc.stderr` return `null` — use the terminal instead
-- Access the terminal via `proc.terminal`
-
-### Terminal options
-
-| Option  | Description                                                                                                                                                        | Default            |
-| ------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------ |
-| `cols`  | Number of columns                                                                                                                                                  | `80`               |
-| `rows`  | Number of rows                                                                                                                                                     | `24`               |
-| `name`  | Terminal type for PTY configuration (set `TERM` env var separately via `env` option)                                                                               | `"xterm-256color"` |
-| `data`  | Callback when data is received `(terminal, data) => void`                                                                                                          | —                  |
-| `exit`  | Callback when PTY stream closes (EOF or error). `exitCode` is PTY lifecycle status (0=EOF, 1=error), not subprocess exit code. Use `proc.exited` for process exit. | —                  |
-| `drain` | Callback when ready for more data `(terminal) => void`                                                                                                             | —                  |
-
-### Terminal methods
-
-The `Terminal` object returned by `proc.terminal` has the following methods:
-
-```ts
-// Write data to the terminal
-proc.terminal.write("echo hello\n");
-
-// Resize the terminal
-proc.terminal.resize(120, 40);
-
-// Set raw mode (disable line buffering and echo)
-proc.terminal.setRawMode(true);
-
-// Keep event loop alive while terminal is open
-proc.terminal.ref();
-proc.terminal.unref();
-
-// Close the terminal
-proc.terminal.close();
-```
-
-### Reusable Terminal
-
-You can create a terminal independently and reuse it across multiple subprocesses:
-
-```ts
-await using terminal = new Bun.Terminal({
-  cols: 80,
-  rows: 24,
-  data(term, data) {
-    process.stdout.write(data);
-  },
-});
-
-// Spawn first process
-const proc1 = Bun.spawn(["echo", "first"], { terminal });
-await proc1.exited;
-
-// Reuse terminal for another process
-const proc2 = Bun.spawn(["echo", "second"], { terminal });
-await proc2.exited;
-
-// Terminal is closed automatically by `await using`
-```
-
-When passing an existing `Terminal` object:
-
-- The terminal can be reused across multiple spawns
-- You control when to close the terminal
-- The `exit` callback fires when you call `terminal.close()`, not when each subprocess exits
-- Use `proc.exited` to detect individual subprocess exits
-
-This is useful for running multiple commands in sequence through the same terminal session.
-
-<Note>Terminal support is only available on POSIX systems (Linux, macOS). It is not available on Windows.</Note>
-
----
-
 ## Blocking API (`Bun.spawnSync()`)
 
 Bun provides a synchronous equivalent of `Bun.spawn` called `Bun.spawnSync`. This is a blocking API that supports the same inputs and parameters as `Bun.spawn`. It returns a `SyncSubprocess` object, which differs from `Subprocess` in a few ways.
@@ -510,7 +407,6 @@ namespace SpawnOptions {
     timeout?: number;
     killSignal?: string | number;
     maxBuffer?: number;
-    terminal?: TerminalOptions; // PTY support (POSIX only)
   }
 
   type Readable =
@@ -539,11 +435,10 @@ namespace SpawnOptions {
 }
 
 interface Subprocess extends AsyncDisposable {
-  readonly stdin: FileSink | number | undefined | null;
-  readonly stdout: ReadableStream<Uint8Array<ArrayBuffer>> | number | undefined | null;
-  readonly stderr: ReadableStream<Uint8Array<ArrayBuffer>> | number | undefined | null;
-  readonly readable: ReadableStream<Uint8Array<ArrayBuffer>> | number | undefined | null;
-  readonly terminal: Terminal | undefined;
+  readonly stdin: FileSink | number | undefined;
+  readonly stdout: ReadableStream<Uint8Array> | number | undefined;
+  readonly stderr: ReadableStream<Uint8Array> | number | undefined;
+  readonly readable: ReadableStream<Uint8Array> | number | undefined;
   readonly pid: number;
   readonly exited: Promise<number>;
   readonly exitCode: number | null;
@@ -570,28 +465,6 @@ interface SyncSubprocess {
   pid: number;
 }
 
-interface TerminalOptions {
-  cols?: number;
-  rows?: number;
-  name?: string;
-  data?: (terminal: Terminal, data: Uint8Array<ArrayBuffer>) => void;
-  /** Called when PTY stream closes (EOF or error). exitCode is PTY lifecycle status (0=EOF, 1=error), not subprocess exit code. */
-  exit?: (terminal: Terminal, exitCode: number, signal: string | null) => void;
-  drain?: (terminal: Terminal) => void;
-}
-
-interface Terminal extends AsyncDisposable {
-  readonly stdin: number;
-  readonly stdout: number;
-  readonly closed: boolean;
-  write(data: string | BufferSource): number;
-  resize(cols: number, rows: number): void;
-  setRawMode(enabled: boolean): void;
-  ref(): void;
-  unref(): void;
-  close(): void;
-}
-
 interface ResourceUsage {
   contextSwitches: {
     voluntary: number;

docs/runtime/http/server.mdx

@@ -193,17 +193,15 @@ This is the maximum amount of time a connection is allowed to be idle before the
 Thus far, the examples on this page have used the explicit `Bun.serve` API. Bun also supports an alternate syntax.
 
 ```ts server.ts
-import type { Serve } from "bun";
+import { type Serve } from "bun";
 
 export default {
   fetch(req) {
     return new Response("Bun!");
   },
-} satisfies Serve.Options<undefined>;
+} satisfies Serve;
 ```
 
-The type parameter `<undefined>` represents WebSocket data — if you add a `websocket` handler with custom data attached via `server.upgrade(req, { data: ... })`, replace `undefined` with your data type.
-
 Instead of passing the server options into `Bun.serve`, `export default` it. This file can be executed as-is; when Bun sees a file with a `default` export containing a `fetch` handler, it passes it into `Bun.serve` under the hood.
 
 ---

docs/runtime/sqlite.mdx

@@ -303,7 +303,7 @@ Internally, this calls [`sqlite3_reset`](https://www.sqlite.org/capi3ref.html#sq
 
 ### `.run()`
 
-Use `.run()` to run a query and get back an object with execution metadata. This is useful for schema-modifying queries (e.g. `CREATE TABLE`) or bulk write operations.
+Use `.run()` to run a query and get back `undefined`. This is useful for schema-modifying queries (e.g. `CREATE TABLE`) or bulk write operations.
 
 ```ts db.ts icon="/icons/typescript.svg" highlight={2}
 const query = db.query(`create table foo;`);

docs/test/configuration.mdx

@@ -376,18 +376,16 @@ timeout = 10000
 
 ## Environment Variables
 
-Environment variables for tests should be set using `.env` files. Bun automatically loads `.env` files from your project root. For test-specific variables, create a `.env.test` file:
+You can also set environment variables in your configuration that affect test behavior:
 
-```ini title=".env.test" icon="settings"
-NODE_ENV=test
-DATABASE_URL=postgresql://localhost:5432/test_db
-LOG_LEVEL=error
-```
+```toml title="bunfig.toml" icon="settings"
+[env]
+NODE_ENV = "test"
+DATABASE_URL = "postgresql://localhost:5432/test_db"
+LOG_LEVEL = "error"
 
-Then load it with `--env-file`:
-
-```bash terminal icon="terminal"
-bun test --env-file=.env.test
+[test]
+coverage = true
 ```
 
 ## Complete Configuration Example
@@ -400,6 +398,13 @@ Here's a comprehensive example showing all available test configuration options:
 registry = "https://registry.npmjs.org/"
 exact = true
 
+[env]
+# Environment variables for tests
+NODE_ENV = "test"
+DATABASE_URL = "postgresql://localhost:5432/test_db"
+API_URL = "http://localhost:3001"
+LOG_LEVEL = "error"
+
 [test]
 # Test discovery
 root = "src"

docs/test/mocks.mdx

@@ -428,26 +428,26 @@ test("foo, bar, baz", () => {
   const barSpy = spyOn(barModule, "bar");
   const bazSpy = spyOn(bazModule, "baz");
 
-  // Original implementations still work
-  expect(fooModule.foo()).toBe("foo");
-  expect(barModule.bar()).toBe("bar");
-  expect(bazModule.baz()).toBe("baz");
+  // Original values
+  expect(fooSpy).toBe("foo");
+  expect(barSpy).toBe("bar");
+  expect(bazSpy).toBe("baz");
 
   // Mock implementations
   fooSpy.mockImplementation(() => 42);
   barSpy.mockImplementation(() => 43);
   bazSpy.mockImplementation(() => 44);
 
-  expect(fooModule.foo()).toBe(42);
-  expect(barModule.bar()).toBe(43);
-  expect(bazModule.baz()).toBe(44);
+  expect(fooSpy()).toBe(42);
+  expect(barSpy()).toBe(43);
+  expect(bazSpy()).toBe(44);
 
   // Restore all
   mock.restore();
 
-  expect(fooModule.foo()).toBe("foo");
-  expect(barModule.bar()).toBe("bar");
-  expect(bazModule.baz()).toBe("baz");
+  expect(fooSpy()).toBe("foo");
+  expect(barSpy()).toBe("bar");
+  expect(bazSpy()).toBe("baz");
 });
 ```
 
@@ -455,10 +455,10 @@ Using `mock.restore()` can reduce the amount of code in your tests by adding it
 
 ## Vitest Compatibility
 
-For added compatibility with tests written for Vitest, Bun provides the `vi` object as an alias for parts of the Jest mocking API:
+For added compatibility with tests written for Vitest, Bun provides the `vi` global object as an alias for parts of the Jest mocking API:
 
 ```ts title="test.ts" icon="/icons/typescript.svg"
-import { test, expect, vi } from "bun:test";
+import { test, expect } from "bun:test";
 
 // Using the 'vi' alias similar to Vitest
 test("vitest compatibility", () => {

flake.nix

@@ -40,7 +40,7 @@
           pkgs.cmake # Expected: 3.30+ on nixos-unstable as of 2025-10
           pkgs.ninja
           pkgs.pkg-config
-          pkgs.ccache
+          pkgs.sccache
 
           # Compilers and toolchain - version pinned to LLVM 19
           clang

package.json

@@ -1,7 +1,7 @@
 {
   "private": true,
   "name": "bun",
-  "version": "1.3.6",
+  "version": "1.3.4",
   "workspaces": [
     "./packages/bun-types",
     "./packages/@types/bun"
@@ -23,8 +23,7 @@
   },
   "resolutions": {
     "bun-types": "workspace:packages/bun-types",
-    "@types/bun": "workspace:packages/@types/bun",
-    "@types/node": "25.0.0"
+    "@types/bun": "workspace:packages/@types/bun"
   },
   "scripts": {
     "build": "bun --silent run build:debug",

packages/bun-types/bun.d.ts

@@ -1740,9 +1740,9 @@ declare module "bun" {
      * @default "esm"
      */
     format?: /**
-     * ECMAScript Module format
-     */
-    | "esm"
+       * ECMAScript Module format
+       */
+      | "esm"
       /**
        * CommonJS format
        * **Experimental**
@@ -1891,24 +1891,6 @@ declare module "bun" {
      */
     drop?: string[];
 
-    /**
-     * Enable feature flags for dead-code elimination via `import { feature } from "bun:bundle"`.
-     *
-     * When `feature("FLAG_NAME")` is called, it returns `true` if FLAG_NAME is in this array,
-     * or `false` otherwise. This enables static dead-code elimination at bundle time.
-     *
-     * Equivalent to the CLI `--feature` flag.
-     *
-     * @example
-     * ```ts
-     * await Bun.build({
-     *   entrypoints: ['./src/index.ts'],
-     *   features: ['FEATURE_A', 'FEATURE_B'],
-     * });
-     * ```
-     */
-    features?: string[];
-
     /**
      * - 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}`
@@ -1970,26 +1952,6 @@ declare module "bun" {
      * @default true
      */
     autoloadBunfig?: boolean;
-    /**
-     * Whether to autoload tsconfig.json when the standalone executable runs
-     *
-     * Standalone-only: applies only when building/running the standalone executable.
-     *
-     * Equivalent CLI flags: `--compile-autoload-tsconfig`, `--no-compile-autoload-tsconfig`
-     *
-     * @default false
-     */
-    autoloadTsconfig?: boolean;
-    /**
-     * Whether to autoload package.json when the standalone executable runs
-     *
-     * Standalone-only: applies only when building/running the standalone executable.
-     *
-     * Equivalent CLI flags: `--compile-autoload-package-json`, `--no-compile-autoload-package-json`
-     *
-     * @default false
-     */
-    autoloadPackageJson?: boolean;
     windows?: {
       hideConsole?: boolean;
       icon?: string;
@@ -3354,10 +3316,10 @@ declare module "bun" {
   function color(
     input: ColorInput,
     outputFormat?: /**
-     * True color ANSI color string, for use in terminals
-     * @example \x1b[38;2;100;200;200m
-     */
-    | "ansi"
+       * True color ANSI color string, for use in terminals
+       * @example \x1b[38;2;100;200;200m
+       */
+      | "ansi"
       | "ansi-16"
       | "ansi-16m"
       /**
@@ -3925,9 +3887,6 @@ declare module "bun" {
     static readonly byteLength: 32;
   }
 
-  /** Extends the standard web formats with `brotli` and `zstd` support. */
-  type CompressionFormat = "gzip" | "deflate" | "deflate-raw" | "brotli" | "zstd";
-
   /** Compression options for `Bun.deflateSync` and `Bun.gzipSync` */
   interface ZlibCompressionOptions {
     /**
@@ -5691,11 +5650,17 @@ declare module "bun" {
       maxBuffer?: number;
     }
 
-    interface SpawnSyncOptions<In extends Writable, Out extends Readable, Err extends Readable>
-      extends BaseOptions<In, Out, Err> {}
+    interface SpawnSyncOptions<In extends Writable, Out extends Readable, Err extends Readable> extends BaseOptions<
+      In,
+      Out,
+      Err
+    > {}
 
-    interface SpawnOptions<In extends Writable, Out extends Readable, Err extends Readable>
-      extends BaseOptions<In, Out, Err> {
+    interface SpawnOptions<In extends Writable, Out extends Readable, Err extends Readable> extends BaseOptions<
+      In,
+      Out,
+      Err
+    > {
       /**
        * If true, stdout and stderr pipes will not automatically start reading
        * data. Reading will only begin when you access the `stdout` or `stderr`
@@ -5717,44 +5682,6 @@ declare module "bun" {
        * ```
        */
       lazy?: boolean;
-
-      /**
-       * Spawn the subprocess with a pseudo-terminal (PTY) attached.
-       *
-       * When this option is provided:
-       * - `stdin`, `stdout`, and `stderr` are all connected to the terminal
-       * - The subprocess sees itself running in a real terminal (`isTTY = true`)
-       * - Access the terminal via `subprocess.terminal`
-       * - `subprocess.stdin`, `subprocess.stdout`, `subprocess.stderr` return `null`
-       *
-       * Only available on POSIX systems (Linux, macOS).
-       *
-       * @example
-       * ```ts
-       * const proc = Bun.spawn(["bash"], {
-       *   terminal: {
-       *     cols: 80,
-       *     rows: 24,
-       *     data: (term, data) => console.log(data.toString()),
-       *   },
-       * });
-       *
-       * proc.terminal.write("echo hello\n");
-       * await proc.exited;
-       * proc.terminal.close();
-       * ```
-       *
-       * You can also pass an existing `Terminal` object for reuse across multiple spawns:
-       * ```ts
-       * const terminal = new Bun.Terminal({ ... });
-       * const proc1 = Bun.spawn(["echo", "first"], { terminal });
-       * await proc1.exited;
-       * const proc2 = Bun.spawn(["echo", "second"], { terminal });
-       * await proc2.exited;
-       * terminal.close();
-       * ```
-       */
-      terminal?: TerminalOptions | Terminal;
     }
 
     type ReadableToIO<X extends Readable> = X extends "pipe" | undefined
@@ -5869,24 +5796,6 @@ declare module "bun" {
     readonly stdout: SpawnOptions.ReadableToIO<Out>;
     readonly stderr: SpawnOptions.ReadableToIO<Err>;
 
-    /**
-     * The terminal attached to this subprocess, if spawned with the `terminal` option.
-     * Returns `undefined` if no terminal was attached.
-     *
-     * When a terminal is attached, `stdin`, `stdout`, and `stderr` return `null`.
-     * Use `terminal.write()` and the `data` callback instead.
-     *
-     * @example
-     * ```ts
-     * const proc = Bun.spawn(["bash"], {
-     *   terminal: { data: (term, data) => console.log(data.toString()) },
-     * });
-     *
-     * proc.terminal?.write("echo hello\n");
-     * ```
-     */
-    readonly terminal: Terminal | undefined;
-
     /**
      * Access extra file descriptors passed to the `stdio` option in the options object.
      */
@@ -6178,154 +6087,6 @@ declare module "bun" {
     "ignore" | "inherit" | null | undefined
   >;
 
-  /**
-   * Options for creating a pseudo-terminal (PTY).
-   */
-  interface TerminalOptions {
-    /**
-     * Number of columns for the terminal.
-     * @default 80
-     */
-    cols?: number;
-    /**
-     * Number of rows for the terminal.
-     * @default 24
-     */
-    rows?: number;
-    /**
-     * Terminal name (e.g., "xterm-256color").
-     * @default "xterm-256color"
-     */
-    name?: string;
-    /**
-     * Callback invoked when data is received from the terminal.
-     * @param terminal The terminal instance
-     * @param data The data received as a Uint8Array
-     */
-    data?: (terminal: Terminal, data: Uint8Array<ArrayBuffer>) => void;
-    /**
-     * Callback invoked when the PTY stream closes (EOF or read error).
-     * Note: exitCode is a PTY lifecycle status (0=clean EOF, 1=error), NOT the subprocess exit code.
-     * Use Subprocess.exited or onExit callback for actual process exit information.
-     * @param terminal The terminal instance
-     * @param exitCode PTY lifecycle status (0 for EOF, 1 for error)
-     * @param signal Reserved for future signal reporting, currently null
-     */
-    exit?: (terminal: Terminal, exitCode: number, signal: string | null) => void;
-    /**
-     * Callback invoked when the terminal is ready to receive more data.
-     * @param terminal The terminal instance
-     */
-    drain?: (terminal: Terminal) => void;
-  }
-
-  /**
-   * A pseudo-terminal (PTY) that can be used to spawn interactive terminal programs.
-   *
-   * @example
-   * ```ts
-   * await using terminal = new Bun.Terminal({
-   *   cols: 80,
-   *   rows: 24,
-   *   data(term, data) {
-   *     console.log("Received:", new TextDecoder().decode(data));
-   *   },
-   * });
-   *
-   * // Spawn a shell connected to the PTY
-   * const proc = Bun.spawn(["bash"], { terminal });
-   *
-   * // Write to the terminal
-   * terminal.write("echo hello\n");
-   *
-   * // Wait for process to exit
-   * await proc.exited;
-   *
-   * // Terminal is closed automatically by `await using`
-   * ```
-   */
-  class Terminal implements AsyncDisposable {
-    constructor(options: TerminalOptions);
-
-    /**
-     * Whether the terminal is closed.
-     */
-    readonly closed: boolean;
-
-    /**
-     * Write data to the terminal.
-     * @param data The data to write (string or BufferSource)
-     * @returns The number of bytes written
-     */
-    write(data: string | BufferSource): number;
-
-    /**
-     * Resize the terminal.
-     * @param cols New number of columns
-     * @param rows New number of rows
-     */
-    resize(cols: number, rows: number): void;
-
-    /**
-     * Set raw mode on the terminal.
-     * In raw mode, input is passed directly without processing.
-     * @param enabled Whether to enable raw mode
-     */
-    setRawMode(enabled: boolean): void;
-
-    /**
-     * Reference the terminal to keep the event loop alive.
-     */
-    ref(): void;
-
-    /**
-     * Unreference the terminal to allow the event loop to exit.
-     */
-    unref(): void;
-
-    /**
-     * Close the terminal.
-     */
-    close(): void;
-
-    /**
-     * Async dispose for use with `await using`.
-     */
-    [Symbol.asyncDispose](): Promise<void>;
-
-    /**
-     * Terminal input flags (c_iflag from termios).
-     * Controls input processing behavior like ICRNL, IXON, etc.
-     * Returns 0 if terminal is closed.
-     * Setting returns true on success, false on failure.
-     */
-    inputFlags: number;
-
-    /**
-     * Terminal output flags (c_oflag from termios).
-     * Controls output processing behavior like OPOST, ONLCR, etc.
-     * Returns 0 if terminal is closed.
-     * Setting returns true on success, false on failure.
-     */
-    outputFlags: number;
-
-    /**
-     * Terminal local flags (c_lflag from termios).
-     * Controls local processing like ICANON, ECHO, ISIG, etc.
-     * Returns 0 if terminal is closed.
-     * Setting returns true on success, false on failure.
-     */
-    localFlags: number;
-
-    /**
-     * Terminal control flags (c_cflag from termios).
-     * Controls hardware characteristics like CSIZE, PARENB, etc.
-     * Returns 0 if terminal is closed.
-     * Setting returns true on success, false on failure.
-     */
-    controlFlags: number;
-  }
-
   // Blocked on https://github.com/oven-sh/bun/issues/8329
   // /**
   //  *

packages/bun-types/bundle.d.ts

@@ -1,74 +0,0 @@
-/**
- * The `bun:bundle` module provides compile-time utilities for dead-code elimination.
- *
- * @example
- * ```ts
- * import { feature } from "bun:bundle";
- *
- * if (feature("SUPER_SECRET")) {
- *   console.log("Secret feature enabled!");
- * } else {
- *   console.log("Normal mode");
- * }
- * ```
- *
- * Enable feature flags via CLI:
- * ```bash
- * # During build
- * bun build --feature=SUPER_SECRET index.ts
- *
- * # At runtime
- * bun run --feature=SUPER_SECRET index.ts
- *
- * # In tests
- * bun test --feature=SUPER_SECRET
- * ```
- *
- * @module bun:bundle
- */
-declare module "bun:bundle" {
-  /**
-   * Registry for type-safe feature flags.
-   *
-   * Augment this interface to get autocomplete and type checking for your feature flags:
-   *
-   * @example
-   * ```ts
-   * // env.d.ts
-   * declare module "bun:bundle" {
-   *   interface Registry {
-   *     features: "DEBUG" | "PREMIUM" | "BETA";
-   *   }
-   * }
-   * ```
-   *
-   * Now `feature()` only accepts `"DEBUG"`, `"PREMIUM"`, or `"BETA"`:
-   * ```ts
-   * feature("DEBUG");    // OK
-   * feature("TYPO");     // Type error
-   * ```
-   */
-  interface Registry {}
-
-  /**
-   * Check if a feature flag is enabled at compile time.
-   *
-   * This function is replaced with a boolean literal (`true` or `false`) at bundle time,
-   * enabling dead-code elimination. The bundler will remove unreachable branches.
-   *
-   * @param flag - The name of the feature flag to check
-   * @returns `true` if the flag was passed via `--feature=FLAG`, `false` otherwise
-   *
-   * @example
-   * ```ts
-   * import { feature } from "bun:bundle";
-   *
-   * // With --feature=DEBUG, this becomes: if (true) { ... }
-   * // Without --feature=DEBUG, this becomes: if (false) { ... }
-   * if (feature("DEBUG")) {
-   *   console.log("Debug mode enabled");
-   * }
-   * ```
-   */
-  function feature(flag: Registry extends { features: infer Features extends string } ? Features : string): boolean;
-}

packages/bun-types/globals.d.ts

@@ -1,12 +1,9 @@
 declare module "bun" {
   namespace __internal {
+    type NodeCryptoWebcryptoSubtleCrypto = import("crypto").webcrypto.SubtleCrypto;
     type NodeCryptoWebcryptoCryptoKey = import("crypto").webcrypto.CryptoKey;
     type NodeCryptoWebcryptoCryptoKeyPair = import("crypto").webcrypto.CryptoKeyPair;
 
-    type LibEmptyOrNodeCryptoWebcryptoSubtleCrypto = LibDomIsLoaded extends true
-      ? {}
-      : import("crypto").webcrypto.SubtleCrypto;
-
     type LibWorkerOrBunWorker = LibDomIsLoaded extends true ? {} : Bun.Worker;
     type LibEmptyOrBunWebSocket = LibDomIsLoaded extends true ? {} : Bun.WebSocket;
 
@@ -17,9 +14,7 @@ declare module "bun" {
       ? {}
       : import("node:stream/web").DecompressionStream;
 
-    type LibPerformanceOrNodePerfHooksPerformance = LibDomIsLoaded extends true
-      ? {}
-      : import("node:perf_hooks").Performance;
+    type LibPerformanceOrNodePerfHooksPerformance = LibDomIsLoaded extends true ? {} : import("perf_hooks").Performance;
     type LibEmptyOrPerformanceEntry = LibDomIsLoaded extends true ? {} : import("node:perf_hooks").PerformanceEntry;
     type LibEmptyOrPerformanceMark = LibDomIsLoaded extends true ? {} : import("node:perf_hooks").PerformanceMark;
     type LibEmptyOrPerformanceMeasure = LibDomIsLoaded extends true ? {} : import("node:perf_hooks").PerformanceMeasure;
@@ -88,24 +83,6 @@ declare var WritableStream: Bun.__internal.UseLibDomIfAvailable<
   }
 >;
 
-interface CompressionStream extends Bun.__internal.LibEmptyOrNodeStreamWebCompressionStream {}
-declare var CompressionStream: Bun.__internal.UseLibDomIfAvailable<
-  "CompressionStream",
-  {
-    prototype: CompressionStream;
-    new (format: Bun.CompressionFormat): CompressionStream;
-  }
->;
-
-interface DecompressionStream extends Bun.__internal.LibEmptyOrNodeStreamWebDecompressionStream {}
-declare var DecompressionStream: Bun.__internal.UseLibDomIfAvailable<
-  "DecompressionStream",
-  {
-    prototype: DecompressionStream;
-    new (format: Bun.CompressionFormat): DecompressionStream;
-  }
->;
-
 interface Worker extends Bun.__internal.LibWorkerOrBunWorker {}
 declare var Worker: Bun.__internal.UseLibDomIfAvailable<
   "Worker",
@@ -229,7 +206,7 @@ interface TextEncoder extends Bun.__internal.LibEmptyOrNodeUtilTextEncoder {
    * @param src The text to encode.
    * @param dest The array to hold the encode result.
    */
-  encodeInto(src?: string, dest?: Bun.BufferSource): import("node:util").TextEncoderEncodeIntoResult;
+  encodeInto(src?: string, dest?: Bun.BufferSource): import("util").EncodeIntoResult;
 }
 declare var TextEncoder: Bun.__internal.UseLibDomIfAvailable<
   "TextEncoder",
@@ -301,6 +278,30 @@ declare var Event: {
   new (type: string, eventInitDict?: Bun.EventInit): Event;
 };
 
+/**
+ * Unimplemented in Bun
+ */
+interface CompressionStream extends Bun.__internal.LibEmptyOrNodeStreamWebCompressionStream {}
+/**
+ * Unimplemented in Bun
+ */
+declare var CompressionStream: Bun.__internal.UseLibDomIfAvailable<
+  "CompressionStream",
+  typeof import("node:stream/web").CompressionStream
+>;
+
+/**
+ * Unimplemented in Bun
+ */
+interface DecompressionStream extends Bun.__internal.LibEmptyOrNodeStreamWebCompressionStream {}
+/**
+ * Unimplemented in Bun
+ */
+declare var DecompressionStream: Bun.__internal.UseLibDomIfAvailable<
+  "DecompressionStream",
+  typeof import("node:stream/web").DecompressionStream
+>;
+
 interface EventTarget {
   /**
    * Adds a new handler for the `type` event. Any given `listener` is added only once per `type` and per `capture` option value.
@@ -957,7 +958,7 @@ declare function alert(message?: string): void;
 declare function confirm(message?: string): boolean;
 declare function prompt(message?: string, _default?: string): string | null;
 
-interface SubtleCrypto extends Bun.__internal.LibEmptyOrNodeCryptoWebcryptoSubtleCrypto {}
+interface SubtleCrypto extends Bun.__internal.NodeCryptoWebcryptoSubtleCrypto {}
 declare var SubtleCrypto: {
   prototype: SubtleCrypto;
   new (): SubtleCrypto;
@@ -1693,10 +1694,6 @@ declare var EventSource: Bun.__internal.UseLibDomIfAvailable<
 
 interface Performance extends Bun.__internal.LibPerformanceOrNodePerfHooksPerformance {}
 declare var performance: Bun.__internal.UseLibDomIfAvailable<"performance", Performance>;
-declare var Performance: Bun.__internal.UseLibDomIfAvailable<
-  "Performance",
-  { new (): Performance; prototype: Performance }
->;
 
 interface PerformanceEntry extends Bun.__internal.LibEmptyOrPerformanceEntry {}
 declare var PerformanceEntry: Bun.__internal.UseLibDomIfAvailable<

packages/bun-types/index.d.ts

@@ -23,7 +23,6 @@
 /// <reference path="./serve.d.ts" />
 /// <reference path="./sql.d.ts" />
 /// <reference path="./security.d.ts" />
-/// <reference path="./bundle.d.ts" />
 
 /// <reference path="./bun.ns.d.ts" />
 

packages/bun-types/overrides.d.ts

@@ -86,7 +86,7 @@ declare global {
       reallyExit(code?: number): never;
       dlopen(module: { exports: any }, filename: string, flags?: number): void;
       _exiting: boolean;
-      noDeprecation?: boolean | undefined;
+      noDeprecation: boolean;
 
       binding(m: "constants"): {
         os: typeof import("node:os").constants;
@@ -308,11 +308,11 @@ declare global {
   }
 }
 
-declare module "node:fs/promises" {
+declare module "fs/promises" {
   function exists(path: Bun.PathLike): Promise<boolean>;
 }
 
-declare module "node:tls" {
+declare module "tls" {
   interface BunConnectionOptions extends Omit<ConnectionOptions, "key" | "ca" | "tls" | "cert"> {
     /**
      * Optionally override the trusted CA certificates. Default is to trust
@@ -359,18 +359,3 @@ declare module "node:tls" {
 
   function connect(options: BunConnectionOptions, secureConnectListener?: () => void): TLSSocket;
 }
-
-declare module "console" {
-  interface Console {
-    /**
-     * Asynchronously read lines from standard input (fd 0)
-     *
-     * ```ts
-     * for await (const line of console) {
-     *   console.log(line);
-     * }
-     * ```
-     */
-    [Symbol.asyncIterator](): AsyncIterableIterator<string>;
-  }
-}

packages/bun-types/s3.d.ts

@@ -281,24 +281,6 @@ declare module "bun" {
      */
     type?: string;
 
-    /**
-     * The Content-Disposition header value.
-     * Controls how the file is presented when downloaded.
-     *
-     * @example
-     *    // Setting attachment disposition with filename
-     *     const file = s3.file("report.pdf", {
-     *       contentDisposition: "attachment; filename=\"quarterly-report.pdf\""
-     *     });
-     *
-     * @example
-     *    // Setting inline disposition
-     *     await s3.write("image.png", imageData, {
-     *       contentDisposition: "inline"
-     *     });
-     */
-    contentDisposition?: string | undefined;
-
     /**
      * By default, Amazon S3 uses the STANDARD Storage Class to store newly created objects.
      *

packages/bun-types/sqlite.d.ts

@@ -154,6 +154,12 @@ declare module "bun:sqlite" {
      * | `bigint`        | `INTEGER`              |
      * | `null`          | `NULL`                 |
      *
+     * @example
+     * ```ts
+     * db.run("CREATE TABLE foo (bar TEXT)");
+     * db.run("INSERT INTO foo VALUES (?)", ["baz"]);
+     * ```
+     *
      * Useful for queries like:
      * - `CREATE TABLE`
      * - `INSERT INTO`
@@ -174,14 +180,8 @@ declare module "bun:sqlite" {
      *
      * @param sql The SQL query to run
      * @param bindings Optional bindings for the query
-     * @returns A `Changes` object with `changes` and `lastInsertRowid` properties
      *
-     * @example
-     * ```ts
-     * db.run("CREATE TABLE foo (bar TEXT)");
-     * db.run("INSERT INTO foo VALUES (?)", ["baz"]);
-     * // => { changes: 1, lastInsertRowid: 1 }
-     * ```
+     * @returns `Database` instance
      */
     run<ParamsType extends SQLQueryBindings[]>(sql: string, ...bindings: ParamsType[]): Changes;
 
@@ -670,19 +670,18 @@ declare module "bun:sqlite" {
      * Execute the prepared statement.
      *
      * @param params optional values to bind to the statement. If omitted, the statement is run with the last bound values or no parameters if there are none.
-     * @returns A `Changes` object with `changes` and `lastInsertRowid` properties
      *
      * @example
      * ```ts
-     * const insert = db.prepare("INSERT INTO users (name) VALUES (?)");
-     * insert.run("Alice");
-     * // => { changes: 1, lastInsertRowid: 1 }
-     * insert.run("Bob");
-     * // => { changes: 1, lastInsertRowid: 2 }
+     * const stmt = db.prepare("UPDATE foo SET bar = ?");
+     * stmt.run("baz");
+     * // => undefined
      *
-     * const update = db.prepare("UPDATE users SET name = ? WHERE id = ?");
-     * update.run("Charlie", 1);
-     * // => { changes: 1, lastInsertRowid: 2 }
+     * stmt.run();
+     * // => undefined
+     *
+     * stmt.run("foo");
+     * // => undefined
      * ```
      *
      * The following types can be used when binding parameters:

packages/bun-types/test.d.ts

@@ -428,8 +428,6 @@ declare module "bun:test" {
   }
 
   namespace __internal {
-    type IfNeverThenElse<T, Else> = [T] extends [never] ? Else : T;
-
     type IsTuple<T> = T extends readonly unknown[]
       ? number extends T["length"]
         ? false // It's an array with unknown length, not a tuple
@@ -1099,8 +1097,8 @@ declare module "bun:test" {
      *
      * @param expected the expected value
      */
-    toContainKey(expected: __internal.IfNeverThenElse<keyof T, PropertyKey>): void;
-    toContainKey<X = T>(expected: __internal.IfNeverThenElse<NoInfer<keyof X>, PropertyKey>): void;
+    toContainKey(expected: keyof T): void;
+    toContainKey<X = T>(expected: NoInfer<keyof X>): void;
 
     /**
      * Asserts that an `object` contains all the provided keys.
@@ -1116,8 +1114,8 @@ declare module "bun:test" {
      *
      * @param expected the expected value
      */
-    toContainAllKeys(expected: Array<__internal.IfNeverThenElse<keyof T, PropertyKey>>): void;
-    toContainAllKeys<X = T>(expected: Array<__internal.IfNeverThenElse<NoInfer<keyof X>, PropertyKey>>): void;
+    toContainAllKeys(expected: Array<keyof T>): void;
+    toContainAllKeys<X = T>(expected: NoInfer<Array<keyof X>>): void;
 
     /**
      * Asserts that an `object` contains at least one of the provided keys.
@@ -1133,8 +1131,8 @@ declare module "bun:test" {
      *
      * @param expected the expected value
      */
-    toContainAnyKeys(expected: Array<__internal.IfNeverThenElse<keyof T, PropertyKey>>): void;
-    toContainAnyKeys<X = T>(expected: Array<__internal.IfNeverThenElse<NoInfer<keyof X>, PropertyKey>>): void;
+    toContainAnyKeys(expected: Array<keyof T>): void;
+    toContainAnyKeys<X = T>(expected: NoInfer<Array<keyof X>>): void;
 
     /**
      * Asserts that an `object` contain the provided value.
@@ -1226,8 +1224,8 @@ declare module "bun:test" {
      *
      * @param expected the expected value
      */
-    toContainKeys(expected: Array<__internal.IfNeverThenElse<keyof T, PropertyKey>>): void;
-    toContainKeys<X = T>(expected: Array<__internal.IfNeverThenElse<NoInfer<keyof X>, PropertyKey>>): void;
+    toContainKeys(expected: Array<keyof T>): void;
+    toContainKeys<X = T>(expected: NoInfer<Array<keyof X>>): void;
 
     /**
      * Asserts that a value contains and equals what is expected.

packages/bun-usockets/src/context.c

@@ -54,8 +54,8 @@ void us_listen_socket_close(int ssl, struct us_listen_socket_t *ls) {
         s->next = loop->data.closed_head;
         loop->data.closed_head = s;
 
-        /* Mark the socket as closed */
-        s->flags.is_closed = 1;
+        /* Any socket with prev = context is marked as closed */
+        s->prev = (struct us_socket_t *) context;
     }
 
     /* We cannot immediately free a listen socket as we can be inside an accept loop */
@@ -154,9 +154,7 @@ void us_internal_socket_context_unlink_connecting_socket(int ssl, struct us_sock
 
 /* We always add in the top, so we don't modify any s.next */
 void us_internal_socket_context_link_listen_socket(int ssl, struct us_socket_context_t *context, struct us_listen_socket_t *ls) {
-
     struct us_socket_t* s = &ls->s;
-    if(us_socket_is_closed(ssl, s)) return;
     s->context = context;
     s->next = (struct us_socket_t *) context->head_listen_sockets;
     s->prev = 0;
@@ -168,8 +166,6 @@ void us_internal_socket_context_link_listen_socket(int ssl, struct us_socket_con
 }
 
 void us_internal_socket_context_link_connecting_socket(int ssl, struct us_socket_context_t *context, struct us_connecting_socket_t *c) {
-    if(c->closed) return;
-
     c->context = context;
     c->next_pending = context->head_connecting_sockets;
     c->prev_pending = 0;
@@ -184,8 +180,6 @@ void us_internal_socket_context_link_connecting_socket(int ssl, struct us_socket
 
 /* We always add in the top, so we don't modify any s.next */
 void us_internal_socket_context_link_socket(int ssl, struct us_socket_context_t *context, struct us_socket_t *s) {
-    if(us_socket_is_closed(ssl,s)) return;
-    
     s->context = context;
     s->next = context->head_sockets;
     s->prev = 0;
@@ -392,9 +386,6 @@ struct us_listen_socket_t *us_socket_context_listen(int ssl, struct us_socket_co
     s->flags.low_prio_state = 0;
     s->flags.is_paused = 0;
     s->flags.is_ipc = 0;
-    s->flags.is_closed = 0;
-    s->flags.adopted = 0;
-    s->flags.is_tls = ssl;
     s->next = 0;
     s->flags.allow_half_open = (options & LIBUS_SOCKET_ALLOW_HALF_OPEN);
     us_internal_socket_context_link_listen_socket(ssl, context, ls);
@@ -431,9 +422,6 @@ struct us_listen_socket_t *us_socket_context_listen_unix(int ssl, struct us_sock
     s->flags.allow_half_open = (options & LIBUS_SOCKET_ALLOW_HALF_OPEN);
     s->flags.is_paused = 0;
     s->flags.is_ipc = 0;
-    s->flags.is_closed = 0;
-    s->flags.adopted = 0;
-    s->flags.is_tls = ssl;
     s->next = 0;
     us_internal_socket_context_link_listen_socket(ssl, context, ls);
 
@@ -442,7 +430,7 @@ struct us_listen_socket_t *us_socket_context_listen_unix(int ssl, struct us_sock
     return ls;
 }
 
-struct us_socket_t* us_socket_context_connect_resolved_dns(int ssl, struct us_socket_context_t *context, struct sockaddr_storage* addr, int options, int socket_ext_size) {
+struct us_socket_t* us_socket_context_connect_resolved_dns(struct us_socket_context_t *context, struct sockaddr_storage* addr, int options, int socket_ext_size) {
     LIBUS_SOCKET_DESCRIPTOR connect_socket_fd = bsd_create_connect_socket(addr, options);
     if (connect_socket_fd == LIBUS_SOCKET_ERROR) {
         return NULL;
@@ -465,9 +453,6 @@ struct us_socket_t* us_socket_context_connect_resolved_dns(int ssl, struct us_so
     socket->flags.allow_half_open = (options & LIBUS_SOCKET_ALLOW_HALF_OPEN);
     socket->flags.is_paused = 0;
     socket->flags.is_ipc = 0;
-    socket->flags.is_closed = 0;
-    socket->flags.adopted = 0;
-    socket->flags.is_tls = ssl;
     socket->connect_state = NULL;
     socket->connect_next = NULL;
 
@@ -529,7 +514,7 @@ void *us_socket_context_connect(int ssl, struct us_socket_context_t *context, co
     struct sockaddr_storage addr;
     if (try_parse_ip(host, port, &addr)) {
         *has_dns_resolved = 1;
-        return us_socket_context_connect_resolved_dns(ssl, context, &addr, options, socket_ext_size);
+        return us_socket_context_connect_resolved_dns(context, &addr, options, socket_ext_size);
     }
 
     struct addrinfo_request* ai_req;
@@ -549,7 +534,7 @@ void *us_socket_context_connect(int ssl, struct us_socket_context_t *context, co
             struct sockaddr_storage addr;
             init_addr_with_port(&entries->info, port, &addr);
             *has_dns_resolved = 1;
-            struct us_socket_t *s = us_socket_context_connect_resolved_dns(ssl, context, &addr, options, socket_ext_size);
+            struct us_socket_t *s = us_socket_context_connect_resolved_dns(context, &addr, options, socket_ext_size);
             Bun__addrinfo_freeRequest(ai_req, s == NULL);
             return s;
         }
@@ -598,9 +583,6 @@ int start_connections(struct us_connecting_socket_t *c, int count) {
         flags->allow_half_open = (c->options & LIBUS_SOCKET_ALLOW_HALF_OPEN);
         flags->is_paused = 0;
         flags->is_ipc = 0;
-        flags->is_closed = 0;
-        flags->adopted = 0;
-        flags->is_tls = c->ssl;
         /* Link it into context so that timeout fires properly */
         us_internal_socket_context_link_socket(0, context, s);
 
@@ -778,9 +760,6 @@ struct us_socket_t *us_socket_context_connect_unix(int ssl, struct us_socket_con
     connect_socket->flags.allow_half_open = (options & LIBUS_SOCKET_ALLOW_HALF_OPEN);
     connect_socket->flags.is_paused = 0;
     connect_socket->flags.is_ipc = 0;
-    connect_socket->flags.is_closed = 0;
-    connect_socket->flags.adopted = 0;
-    connect_socket->flags.is_tls = ssl;
     connect_socket->connect_state = NULL;
     connect_socket->connect_next = NULL;
     us_internal_socket_context_link_socket(ssl, context, connect_socket);
@@ -801,10 +780,10 @@ struct us_socket_context_t *us_create_child_socket_context(int ssl, struct us_so
 }
 
 /* Note: This will set timeout to 0 */
-struct us_socket_t *us_socket_context_adopt_socket(int ssl, struct us_socket_context_t *context, struct us_socket_t *s, int old_ext_size, int ext_size) {
+struct us_socket_t *us_socket_context_adopt_socket(int ssl, struct us_socket_context_t *context, struct us_socket_t *s, int ext_size) {
 #ifndef LIBUS_NO_SSL
     if (ssl) {
-        return (struct us_socket_t *) us_internal_ssl_socket_context_adopt_socket((struct us_internal_ssl_socket_context_t *) context, (struct us_internal_ssl_socket_t *) s, old_ext_size, ext_size);
+        return (struct us_socket_t *) us_internal_ssl_socket_context_adopt_socket((struct us_internal_ssl_socket_context_t *) context, (struct us_internal_ssl_socket_t *) s, ext_size);
     }
 #endif
 
@@ -828,18 +807,7 @@ struct us_socket_t *us_socket_context_adopt_socket(int ssl, struct us_socket_con
     struct us_socket_t *new_s = s;
     if (ext_size != -1) {
         struct us_poll_t *pool_ref = &s->p;
-        new_s = (struct us_socket_t *) us_poll_resize(pool_ref, loop, sizeof(struct us_socket_t) + old_ext_size, sizeof(struct us_socket_t) + ext_size);
-        if(new_s != s) {
-            /* Mark the old socket as closed */
-            s->flags.is_closed = 1;
-            /* Link this socket to the close-list and let it be deleted after this iteration */
-            s->next = s->context->loop->data.closed_head;
-            s->context->loop->data.closed_head = s;
-            /* Mark the old socket as adopted (reallocated) */
-            s->flags.adopted = 1;
-            /* Tell the event loop what is the new socket so we can process to send info to the right place and callbacks like more data and EOF*/
-            s->prev = new_s;
-        }
+        new_s = (struct us_socket_t *) us_poll_resize(pool_ref, loop, sizeof(struct us_socket_t) + ext_size);
         if (c) {
             c->connecting_head = new_s;
             c->context = context;

packages/bun-usockets/src/crypto/openssl.c

@@ -396,7 +396,7 @@ void us_internal_update_handshake(struct us_internal_ssl_socket_t *s) {
   }
 
   int result = SSL_do_handshake(s->ssl);
-  
+
   if (SSL_get_shutdown(s->ssl) & SSL_RECEIVED_SHUTDOWN) {
     us_internal_ssl_socket_close(s, 0, NULL);
     return;
@@ -417,7 +417,7 @@ void us_internal_update_handshake(struct us_internal_ssl_socket_t *s) {
     }
     s->handshake_state = HANDSHAKE_PENDING;
     s->ssl_write_wants_read = 1;
-    s->s.flags.last_write_failed = 1;
+
     return;
   }
   // success
@@ -434,7 +434,6 @@ ssl_on_close(struct us_internal_ssl_socket_t *s, int code, void *reason) {
   struct us_internal_ssl_socket_t * ret = context->on_close(s, code, reason);
   SSL_free(s->ssl); // free SSL after on_close
   s->ssl = NULL; // set to NULL
-
   return ret;
 }
 
@@ -1856,16 +1855,15 @@ void us_internal_ssl_socket_shutdown(struct us_internal_ssl_socket_t *s) {
 
 struct us_internal_ssl_socket_t *us_internal_ssl_socket_context_adopt_socket(
     struct us_internal_ssl_socket_context_t *context,
-    struct us_internal_ssl_socket_t *s, int old_ext_size, int ext_size) {
+    struct us_internal_ssl_socket_t *s, int ext_size) {
   // todo: this is completely untested
-  int new_old_ext_size = sizeof(struct us_internal_ssl_socket_t) - sizeof(struct us_socket_t) + old_ext_size;
   int new_ext_size = ext_size;
   if (ext_size != -1) {
     new_ext_size = sizeof(struct us_internal_ssl_socket_t) - sizeof(struct us_socket_t) + ext_size;
   }
   return (struct us_internal_ssl_socket_t *)us_socket_context_adopt_socket(
       0, &context->sc, &s->s,
-      new_old_ext_size, new_ext_size);
+      new_ext_size);
 }
 
 struct us_internal_ssl_socket_t *
@@ -1922,11 +1920,10 @@ ssl_wrapped_context_on_data(struct us_internal_ssl_socket_t *s, char *data,
   struct us_wrapped_socket_context_t *wrapped_context =
       (struct us_wrapped_socket_context_t *)us_internal_ssl_socket_context_ext(
           context);
-          // raw data if needed
+  // raw data if needed
   if (wrapped_context->old_events.on_data) {
     wrapped_context->old_events.on_data((struct us_socket_t *)s, data, length);
   }
-  
   // ssl wrapped data
   return ssl_on_data(s, data, length);
 }
@@ -2031,7 +2028,7 @@ us_internal_ssl_socket_open(struct us_internal_ssl_socket_t *s, int is_client,
   // already opened
   if (s->ssl)
     return s;
-  
+
   // start SSL open
   return ssl_on_open(s, is_client, ip, ip_length, NULL);
 }
@@ -2043,7 +2040,6 @@ struct us_socket_t *us_socket_upgrade_to_tls(us_socket_r s, us_socket_context_r
   struct us_internal_ssl_socket_t *socket =
       (struct us_internal_ssl_socket_t *)us_socket_context_adopt_socket(
           0, new_context, s,
-          sizeof(void*),
           (sizeof(struct us_internal_ssl_socket_t) - sizeof(struct us_socket_t)) + sizeof(void*));
   socket->ssl = NULL;
   socket->ssl_write_wants_read = 0;
@@ -2062,7 +2058,7 @@ struct us_socket_t *us_socket_upgrade_to_tls(us_socket_r s, us_socket_context_r
 
 struct us_internal_ssl_socket_t *us_internal_ssl_socket_wrap_with_tls(
     struct us_socket_t *s, struct us_bun_socket_context_options_t options,
-    struct us_socket_events_t events, int old_socket_ext_size, int socket_ext_size) {
+    struct us_socket_events_t events, int socket_ext_size) {
   /* Cannot wrap a closed socket */
   if (us_socket_is_closed(0, s)) {
     return NULL;
@@ -2167,7 +2163,6 @@ us_socket_context_on_socket_connect_error(
   struct us_internal_ssl_socket_t *socket =
       (struct us_internal_ssl_socket_t *)us_socket_context_adopt_socket(
           0, context, s,
-          old_socket_ext_size,
           sizeof(struct us_internal_ssl_socket_t) - sizeof(struct us_socket_t) +
               socket_ext_size);
   socket->ssl = NULL;

packages/bun-usockets/src/eventing/epoll_kqueue.c

@@ -228,8 +228,8 @@ void us_loop_run(struct us_loop_t *loop) {
                 // > Instead, the filter will aggregate the events into a single kevent struct
                 // Note: EV_ERROR only sets the error in data as part of changelist. Not in this call!
                 int events = 0
-                    | ((filter == EVFILT_READ) ? LIBUS_SOCKET_READABLE : 0)
-                    | ((filter == EVFILT_WRITE) ? LIBUS_SOCKET_WRITABLE : 0);
+                    | ((filter & EVFILT_READ) ? LIBUS_SOCKET_READABLE : 0)
+                    | ((filter & EVFILT_WRITE) ? LIBUS_SOCKET_WRITABLE : 0);
                 const int error = (flags & (EV_ERROR)) ? ((int)fflags || 1) : 0;
                 const int eof = (flags & (EV_EOF));
 #endif
@@ -325,7 +325,7 @@ void us_internal_loop_update_pending_ready_polls(struct us_loop_t *loop, struct
     int num_entries_possibly_remaining = 1;
 #else
     /* Ready polls may contain same poll twice under kqueue, as one poll may hold two filters */
-    int num_entries_possibly_remaining = 2;
+    int num_entries_possibly_remaining = 2;//((old_events & LIBUS_SOCKET_READABLE) ? 1 : 0) + ((old_events & LIBUS_SOCKET_WRITABLE) ? 1 : 0);
 #endif
 
     /* Todo: for kqueue if we track things in us_change_poll it is possible to have a fast path with no seeking in cases of:
@@ -360,11 +360,11 @@ int kqueue_change(int kqfd, int fd, int old_events, int new_events, void *user_d
     if(!is_readable && !is_writable) {
         if(!(old_events & LIBUS_SOCKET_WRITABLE)) {
             // if we are not reading or writing, we need to add writable to receive FIN
-            EV_SET64(&change_list[change_length++], fd, EVFILT_WRITE, EV_ADD | EV_ONESHOT, 0, 0, (uint64_t)(void*)user_data, 0, 0);
+            EV_SET64(&change_list[change_length++], fd, EVFILT_WRITE, EV_ADD, 0, 0, (uint64_t)(void*)user_data, 0, 0);
         }
     } else if ((new_events & LIBUS_SOCKET_WRITABLE) != (old_events & LIBUS_SOCKET_WRITABLE)) {
         /* Do they differ in writable? */
-        EV_SET64(&change_list[change_length++], fd, EVFILT_WRITE, (new_events & LIBUS_SOCKET_WRITABLE) ? EV_ADD | EV_ONESHOT : EV_DELETE, 0, 0, (uint64_t)(void*)user_data, 0, 0);
+        EV_SET64(&change_list[change_length++], fd, EVFILT_WRITE, (new_events & LIBUS_SOCKET_WRITABLE) ? EV_ADD : EV_DELETE, 0, 0, (uint64_t)(void*)user_data, 0, 0);
     }
     int ret;
     do {
@@ -377,30 +377,22 @@ int kqueue_change(int kqfd, int fd, int old_events, int new_events, void *user_d
 }
 #endif
 
-struct us_poll_t *us_poll_resize(struct us_poll_t *p, struct us_loop_t *loop, unsigned int old_ext_size, unsigned int ext_size) {
-
-    unsigned int old_size = sizeof(struct us_poll_t) + old_ext_size;
-    unsigned int new_size = sizeof(struct us_poll_t) + ext_size;
-    if(new_size <= old_size) return p;
-
-    struct us_poll_t *new_p = us_calloc(1, new_size);
-    memcpy(new_p, p, old_size);
-
-    /* Increment poll count for the new poll - the old poll will be freed separately
-     * which decrements the count, keeping the total correct */
-    loop->num_polls++;
-    
+struct us_poll_t *us_poll_resize(struct us_poll_t *p, struct us_loop_t *loop, unsigned int ext_size) {
     int events = us_poll_events(p);
+    
+
+    struct us_poll_t *new_p = us_realloc(p, sizeof(struct us_poll_t) + ext_size);
+    if (p != new_p) {
 #ifdef LIBUS_USE_EPOLL
-    /* Hack: forcefully update poll by stripping away already set events */
-    new_p->state.poll_type = us_internal_poll_type(new_p);
-    us_poll_change(new_p, loop, events);
+        /* Hack: forcefully update poll by stripping away already set events */
+        new_p->state.poll_type = us_internal_poll_type(new_p);
+        us_poll_change(new_p, loop, events);
 #else
-    /* Forcefully update poll by resetting them with new_p as user data */
-    kqueue_change(loop->fd, new_p->state.fd, 0, LIBUS_SOCKET_WRITABLE | LIBUS_SOCKET_READABLE, new_p);
-#endif
-    /* This is needed for epoll also (us_change_poll doesn't update the old poll) */
-    us_internal_loop_update_pending_ready_polls(loop, p, new_p, events, events);
+        /* Forcefully update poll by resetting them with new_p as user data */
+        kqueue_change(loop->fd, new_p->state.fd, 0, LIBUS_SOCKET_WRITABLE | LIBUS_SOCKET_READABLE, new_p);
+#endif      /* This is needed for epoll also (us_change_poll doesn't update the old poll) */
+        us_internal_loop_update_pending_ready_polls(loop, p, new_p, events, events);
+    }
 
     return new_p;
 }
@@ -452,7 +444,7 @@ void us_poll_change(struct us_poll_t *p, struct us_loop_t *loop, int events) {
         kqueue_change(loop->fd, p->state.fd, old_events, events, p);
 #endif
         /* Set all removed events to null-polls in pending ready poll list */
-        us_internal_loop_update_pending_ready_polls(loop, p, p, old_events, events);
+        // us_internal_loop_update_pending_ready_polls(loop, p, p, old_events, events);
     }
 }
 

packages/bun-usockets/src/eventing/libuv.c

@@ -71,11 +71,6 @@ void us_poll_init(struct us_poll_t *p, LIBUS_SOCKET_DESCRIPTOR fd,
 }
 
 void us_poll_free(struct us_poll_t *p, struct us_loop_t *loop) {
-  // poll was resized and dont own uv_poll_t anymore
-  if(!p->uv_p) {
-    free(p);
-    return;
-  }
   /* The idea here is like so; in us_poll_stop we call uv_close after setting
    * data of uv-poll to 0. This means that in close_cb_free we call free on 0
    * with does nothing, since us_poll_stop should not really free the poll.
@@ -91,7 +86,6 @@ void us_poll_free(struct us_poll_t *p, struct us_loop_t *loop) {
 }
 
 void us_poll_start(struct us_poll_t *p, struct us_loop_t *loop, int events) {
-  if(!p->uv_p) return;
   p->poll_type = us_internal_poll_type(p) |
                  ((events & LIBUS_SOCKET_READABLE) ? POLL_TYPE_POLLING_IN : 0) |
                  ((events & LIBUS_SOCKET_WRITABLE) ? POLL_TYPE_POLLING_OUT : 0);
@@ -105,7 +99,6 @@ void us_poll_start(struct us_poll_t *p, struct us_loop_t *loop, int events) {
 }
 
 void us_poll_change(struct us_poll_t *p, struct us_loop_t *loop, int events) {
-  if(!p->uv_p) return;
   if (us_poll_events(p) != events) {
     p->poll_type =
         us_internal_poll_type(p) |
@@ -116,7 +109,6 @@ void us_poll_change(struct us_poll_t *p, struct us_loop_t *loop, int events) {
 }
 
 void us_poll_stop(struct us_poll_t *p, struct us_loop_t *loop) {
-  if(!p->uv_p) return;
   uv_poll_stop(p->uv_p);
 
   /* We normally only want to close the poll here, not free it. But if we stop
@@ -225,20 +217,10 @@ struct us_poll_t *us_create_poll(struct us_loop_t *loop, int fallthrough,
 /* If we update our block position we have to update the uv_poll data to point
  * to us */
 struct us_poll_t *us_poll_resize(struct us_poll_t *p, struct us_loop_t *loop,
-                                 unsigned int old_ext_size, unsigned int ext_size) {
-
-  // cannot resize if we dont own uv_poll_t
-  if(!p->uv_p) return p;
-
-  unsigned int old_size = sizeof(struct us_poll_t) + old_ext_size;
-  unsigned int new_size = sizeof(struct us_poll_t) + ext_size;
-  if(new_size <= old_size) return p;
-
-  struct us_poll_t *new_p = calloc(1, new_size);
-  memcpy(new_p, p, old_size);
+                                 unsigned int ext_size) {
 
+  struct us_poll_t *new_p = realloc(p, sizeof(struct us_poll_t) + ext_size);
   new_p->uv_p->data = new_p;
-  p->uv_p = NULL;
 
   return new_p;
 }

packages/bun-usockets/src/internal/internal.h

@@ -170,14 +170,6 @@ struct us_socket_flags {
     unsigned char low_prio_state: 2;
     /* If true, the socket should be read using readmsg to support receiving file descriptors */
     bool is_ipc: 1;
-    /* If true, the socket has been closed */
-    bool is_closed: 1;
-    /* If true, the socket was reallocated during adoption */
-    bool adopted: 1;
-    /* If true, the socket is a TLS socket */
-    bool is_tls: 1;
-    /* If true, the last write to this socket failed (would block) */
-    bool last_write_failed: 1;
 
 } __attribute__((packed));
 
@@ -443,11 +435,11 @@ void us_internal_ssl_socket_shutdown(us_internal_ssl_socket_r s);
 
 struct us_internal_ssl_socket_t *us_internal_ssl_socket_context_adopt_socket(
     us_internal_ssl_socket_context_r context,
-    us_internal_ssl_socket_r s, int old_ext_size, int ext_size);
+    us_internal_ssl_socket_r s, int ext_size);
 
 struct us_internal_ssl_socket_t *us_internal_ssl_socket_wrap_with_tls(
     us_socket_r s, struct us_bun_socket_context_options_t options,
-    struct us_socket_events_t events, int old_socket_ext_size, int socket_ext_size);
+    struct us_socket_events_t events, int socket_ext_size);
 struct us_internal_ssl_socket_context_t *
 us_internal_create_child_ssl_socket_context(
     us_internal_ssl_socket_context_r context, int context_ext_size);

packages/bun-usockets/src/internal/loop_data.h

@@ -37,6 +37,7 @@ struct us_internal_loop_data_t {
     struct us_timer_t *sweep_timer;
     int sweep_timer_count;
     struct us_internal_async *wakeup_async;
+    int last_write_failed;
     struct us_socket_context_t *head;
     struct us_socket_context_t *iterator;
     struct us_socket_context_t *closed_context_head;

packages/bun-usockets/src/libusockets.h

@@ -349,7 +349,7 @@ struct us_loop_t *us_socket_context_loop(int ssl, us_socket_context_r context) n
 
 /* Invalidates passed socket, returning a new resized socket which belongs to a different socket context.
  * Used mainly for "socket upgrades" such as when transitioning from HTTP to WebSocket. */
-struct us_socket_t *us_socket_context_adopt_socket(int ssl, us_socket_context_r context, us_socket_r s, int old_ext_size, int ext_size);
+struct us_socket_t *us_socket_context_adopt_socket(int ssl, us_socket_context_r context, us_socket_r s, int ext_size);
 
 struct us_socket_t *us_socket_upgrade_to_tls(us_socket_r s, us_socket_context_r new_context, const char *sni);
 
@@ -411,7 +411,7 @@ void *us_poll_ext(us_poll_r p) nonnull_fn_decl;
 LIBUS_SOCKET_DESCRIPTOR us_poll_fd(us_poll_r p) nonnull_fn_decl;
 
 /* Resize an active poll */
-struct us_poll_t *us_poll_resize(us_poll_r p, us_loop_r loop, unsigned int old_ext_size, unsigned int ext_size) nonnull_fn_decl;
+struct us_poll_t *us_poll_resize(us_poll_r p, us_loop_r loop, unsigned int ext_size) nonnull_fn_decl;
 
 /* Public interfaces for sockets */
 
@@ -470,7 +470,7 @@ void us_socket_local_address(int ssl, us_socket_r s, char *nonnull_arg buf, int
 /* Bun extras */
 struct us_socket_t *us_socket_pair(struct us_socket_context_t *ctx, int socket_ext_size, LIBUS_SOCKET_DESCRIPTOR* fds);
 struct us_socket_t *us_socket_from_fd(struct us_socket_context_t *ctx, int socket_ext_size, LIBUS_SOCKET_DESCRIPTOR fd, int ipc);
-struct us_socket_t *us_socket_wrap_with_tls(int ssl, us_socket_r s, struct us_bun_socket_context_options_t options, struct us_socket_events_t events, int old_socket_ext_size, int socket_ext_size);
+struct us_socket_t *us_socket_wrap_with_tls(int ssl, us_socket_r s, struct us_bun_socket_context_options_t options, struct us_socket_events_t events, int socket_ext_size);
 int us_socket_raw_write(int ssl, us_socket_r s, const char *data, int length);
 struct us_socket_t* us_socket_open(int ssl, struct us_socket_t * s, int is_client, char* ip, int ip_length);
 int us_raw_root_certs(struct us_cert_string_t**out);

packages/bun-usockets/src/loop.c

@@ -193,17 +193,9 @@ void us_internal_handle_low_priority_sockets(struct us_loop_t *loop) {
         loop_data->low_prio_head = s->next;
         if (s->next) s->next->prev = 0;
         s->next = 0;
-        int ssl = s->flags.is_tls;
-        
-        if(us_socket_is_closed(ssl, s)) {
-            s->flags.low_prio_state = 2;    
-            us_socket_context_unref(ssl, s->context);
-            continue;
-        }
 
-        us_internal_socket_context_link_socket(ssl, s->context, s);
-        us_socket_context_unref(ssl, s->context);
-        us_poll_change(&s->p, us_socket_context(ssl, s)->loop, us_poll_events(&s->p) | LIBUS_SOCKET_READABLE);
+        us_internal_socket_context_link_socket(0, s->context, s);
+        us_poll_change(&s->p, us_socket_context(0, s)->loop, us_poll_events(&s->p) | LIBUS_SOCKET_READABLE);
 
         s->flags.low_prio_state = 2;
     }
@@ -251,7 +243,6 @@ void us_internal_free_closed_sockets(struct us_loop_t *loop) {
     /* Free all closed sockets (maybe it is better to reverse order?) */
     for (struct us_socket_t *s = loop->data.closed_head; s; ) {
         struct us_socket_t *next = s->next;
-        s->prev = s->next = 0;
         us_poll_free((struct us_poll_t *) s, loop);
         s = next;
     }
@@ -356,9 +347,6 @@ void us_internal_dispatch_ready_poll(struct us_poll_t *p, int error, int eof, in
                         s->flags.allow_half_open = listen_socket->s.flags.allow_half_open;
                         s->flags.is_paused = 0;
                         s->flags.is_ipc = 0;
-                        s->flags.is_closed = 0;
-                        s->flags.adopted = 0;
-                        s->flags.is_tls = listen_socket->s.flags.is_tls;
 
                         /* We always use nodelay */
                         bsd_socket_nodelay(client_fd, 1);
@@ -366,10 +354,7 @@ void us_internal_dispatch_ready_poll(struct us_poll_t *p, int error, int eof, in
                         us_internal_socket_context_link_socket(0, listen_socket->s.context, s);
 
                         listen_socket->s.context->on_open(s, 0, bsd_addr_get_ip(&addr), bsd_addr_get_ip_length(&addr));
-                        /* After socket adoption, track the new socket; the old one becomes invalid */
-                        if(s && s->flags.adopted && s->prev) {
-                            s = s->prev;
-                        }
+
                         /* Exit accept loop if listen socket was closed in on_open handler */
                         if (us_socket_is_closed(0, &listen_socket->s)) {
                             break;
@@ -384,37 +369,22 @@ void us_internal_dispatch_ready_poll(struct us_poll_t *p, int error, int eof, in
     case POLL_TYPE_SOCKET: {
             /* We should only use s, no p after this point */
             struct us_socket_t *s = (struct us_socket_t *) p;
-            /* After socket adoption, track the new socket; the old one becomes invalid */
-            if(s && s->flags.adopted && s->prev) {
-                s = s->prev;
-            }
             /* The context can change after calling a callback but the loop is always the same */
             struct us_loop_t* loop = s->context->loop;
             if (events & LIBUS_SOCKET_WRITABLE && !error) {
-                s->flags.last_write_failed = 0;
-                #ifdef LIBUS_USE_KQUEUE
-                /* Kqueue is one-shot so is not writable anymore */
-                p->state.poll_type = us_internal_poll_type(p) | ((events & LIBUS_SOCKET_READABLE) ? POLL_TYPE_POLLING_IN : 0);
-                #endif
+                /* Note: if we failed a write as a socket of one loop then adopted
+                 * to another loop, this will be wrong. Absurd case though */
+                loop->data.last_write_failed = 0;
 
                 s = s->context->on_writable(s);
-                /* After socket adoption, track the new socket; the old one becomes invalid */
-                if(s && s->flags.adopted && s->prev) {
-                    s = s->prev;
-                }
 
                 if (!s || us_socket_is_closed(0, s)) {
                     return;
                 }
 
                 /* If we have no failed write or if we shut down, then stop polling for more writable */
-                if (!s->flags.last_write_failed || us_socket_is_shut_down(0, s)) {
+                if (!loop->data.last_write_failed || us_socket_is_shut_down(0, s)) {
                     us_poll_change(&s->p, loop, us_poll_events(&s->p) & LIBUS_SOCKET_READABLE);
-                } else {
-                    #ifdef LIBUS_USE_KQUEUE
-                    /* Kqueue one-shot writable needs to be re-enabled */
-                    us_poll_change(&s->p, loop, us_poll_events(&s->p) | LIBUS_SOCKET_WRITABLE);
-                    #endif
                 }
             }
 
@@ -498,10 +468,6 @@ void us_internal_dispatch_ready_poll(struct us_poll_t *p, int error, int eof, in
 
                     if (length > 0) {
                         s = s->context->on_data(s, loop->data.recv_buf + LIBUS_RECV_BUFFER_PADDING, length);
-                        /* After socket adoption, track the new socket; the old one becomes invalid */
-                        if(s && s->flags.adopted && s->prev) {
-                            s = s->prev;
-                        }
                         // loop->num_ready_polls isn't accessible on Windows.
                         #ifndef WIN32
                         // rare case: we're reading a lot of data, there's more to be read, and either:

packages/bun-usockets/src/socket.c

@@ -125,7 +125,7 @@ int us_socket_is_closed(int ssl, struct us_socket_t *s) {
     if(ssl) {
         return us_internal_ssl_socket_is_closed((struct us_internal_ssl_socket_t *) s);
     }
-    return s->flags.is_closed;
+    return s->prev == (struct us_socket_t *) s->context;
 }
 
 int us_connecting_socket_is_closed(int ssl, struct us_connecting_socket_t *c) {
@@ -159,8 +159,8 @@ void us_connecting_socket_close(int ssl, struct us_connecting_socket_t *c) {
         s->next = s->context->loop->data.closed_head;
         s->context->loop->data.closed_head = s;
 
-        /* Mark the socket as closed */
-        s->flags.is_closed = 1;
+        /* Any socket with prev = context is marked as closed */
+        s->prev = (struct us_socket_t *) s->context;
     }
     if(!c->error) {
         // if we have no error, we have to set that we were aborted aka we called close
@@ -218,10 +218,11 @@ struct us_socket_t *us_socket_close(int ssl, struct us_socket_t *s, int code, vo
 
         bsd_close_socket(us_poll_fd((struct us_poll_t *) s));
 
-        /* Mark the socket as closed */
-        s->flags.is_closed = 1;
 
-        /* call the callback */
+        /* Any socket with prev = context is marked as closed */
+        s->prev = (struct us_socket_t *) s->context;
+
+        /* mark it as closed and call the callback */
         struct us_socket_t *res = s;
         if (!(us_internal_poll_type(&s->p) & POLL_TYPE_SEMI_SOCKET)) {
             res = s->context->on_close(s, code, reason);
@@ -267,8 +268,8 @@ struct us_socket_t *us_socket_detach(int ssl, struct us_socket_t *s) {
         s->next = s->context->loop->data.closed_head;
         s->context->loop->data.closed_head = s;
 
-        /* Mark the socket as closed */
-        s->flags.is_closed = 1;
+        /* Any socket with prev = context is marked as closed */
+        s->prev = (struct us_socket_t *) s->context;
 
         return s;
     }
@@ -320,10 +321,8 @@ struct us_socket_t *us_socket_from_fd(struct us_socket_context_t *ctx, int socke
     s->flags.low_prio_state = 0;
     s->flags.allow_half_open = 0;
     s->flags.is_paused = 0;
+    s->flags.is_ipc = 0;
     s->flags.is_ipc = ipc;
-    s->flags.is_closed = 0;
-    s->flags.adopted = 0;
-    s->flags.is_tls = 0;
     s->connect_state = NULL;
 
     /* We always use nodelay */
@@ -370,7 +369,7 @@ int us_socket_write(int ssl, struct us_socket_t *s, const char *data, int length
 
     int written = bsd_send(us_poll_fd(&s->p), data, length);
     if (written != length) {
-        s->flags.last_write_failed = 1;
+        s->context->loop->data.last_write_failed = 1;
         us_poll_change(&s->p, s->context->loop, LIBUS_SOCKET_READABLE | LIBUS_SOCKET_WRITABLE);
     }
 
@@ -407,7 +406,7 @@ int us_socket_ipc_write_fd(struct us_socket_t *s, const char* data, int length,
     int sent = bsd_sendmsg(us_poll_fd(&s->p), &msg, 0);
 
     if (sent != length) {
-        s->flags.last_write_failed = 1;
+        s->context->loop->data.last_write_failed = 1;
         us_poll_change(&s->p, s->context->loop, LIBUS_SOCKET_READABLE | LIBUS_SOCKET_WRITABLE);
     }
 
@@ -477,13 +476,13 @@ int us_connecting_socket_get_error(int ssl, struct us_connecting_socket_t *c) {
     Note: this assumes that the socket is non-TLS and will be adopted and wrapped with a new TLS context
           context ext will not be copied to the new context, new context will contain us_wrapped_socket_context_t on ext
 */
-struct us_socket_t *us_socket_wrap_with_tls(int ssl, struct us_socket_t *s, struct us_bun_socket_context_options_t options, struct us_socket_events_t events, int old_socket_ext_size, int socket_ext_size) {
+struct us_socket_t *us_socket_wrap_with_tls(int ssl, struct us_socket_t *s, struct us_bun_socket_context_options_t options, struct us_socket_events_t events, int socket_ext_size) {
     // only accepts non-TLS sockets
     if (ssl) {
         return NULL;
     }
 
-    return(struct us_socket_t *) us_internal_ssl_socket_wrap_with_tls(s, options, events, old_socket_ext_size, socket_ext_size);
+    return(struct us_socket_t *) us_internal_ssl_socket_wrap_with_tls(s, options, events, socket_ext_size);
 }
 
 // if a TLS socket calls this, it will start SSL call open event and TLS handshake if required

packages/bun-uws/src/AsyncSocketData.h

@@ -84,7 +84,6 @@ struct AsyncSocketData {
     /* Or empty */
     AsyncSocketData() = default;
     bool isIdle = false;
-    bool isAuthorized = false; // per-socket TLS authorization status
 };
 
 }

packages/bun-uws/src/HttpContext.h

@@ -124,16 +124,15 @@ private:
                 // if we are closing or already closed, we don't need to do anything
                 if (!us_socket_is_closed(SSL, s)) {
                     HttpContextData<SSL> *httpContextData = getSocketContextDataS(s);
-                    // Set per-socket authorization status
-                    auto *httpResponseData = reinterpret_cast<HttpResponseData<SSL> *>(us_socket_ext(SSL, s));
+                    httpContextData->flags.isAuthorized = success;
                     if(httpContextData->flags.rejectUnauthorized) {
                         if(!success || verify_error.error != 0) {
                             // we failed to handshake, close the socket
                             us_socket_close(SSL, s, 0, nullptr);
                             return;
                         }
+                        httpContextData->flags.isAuthorized = true;
                     }
-                    httpResponseData->isAuthorized = success;
 
                     /* Any connected socket should timeout until it has a request */
                     ((HttpResponse<SSL> *) s)->resetTimeout();

packages/bun-uws/src/HttpResponse.h

@@ -331,7 +331,7 @@ public:
         
 
         /* Adopting a socket invalidates it, do not rely on it directly to carry any data */
-        us_socket_t *usSocket = us_socket_context_adopt_socket(SSL, (us_socket_context_t *) webSocketContext, (us_socket_t *) this, sizeof(HttpResponseData<SSL>), sizeof(WebSocketData) + sizeof(UserData));
+        us_socket_t *usSocket = us_socket_context_adopt_socket(SSL, (us_socket_context_t *) webSocketContext, (us_socket_t *) this, sizeof(WebSocketData) + sizeof(UserData));
         WebSocket<SSL, true, UserData> *webSocket = (WebSocket<SSL, true, UserData> *) usSocket;
 
         /* For whatever reason we were corked, update cork to the new socket */

rust-toolchain.toml

@@ -1,2 +0,0 @@
-[toolchain]
-channel = "nightly-2025-12-10"

scripts/bootstrap.ps1

@@ -313,7 +313,7 @@ function Install-Build-Essentials {
     strawberryperl `
     mingw
   Install-Rust
-  Install-Ccache
+  Install-Sccache
   # Needed to remap stack traces
   Install-PdbAddr2line
   Install-Llvm
@@ -376,8 +376,8 @@ function Install-Rust {
   Add-To-Path "$rustPath\cargo\bin"
 }
 
-function Install-Ccache {
-  Install-Package ccache
+function Install-Sccache {
+  Install-Package sccache -Version "0.12.0"
 }
 
 function Install-PdbAddr2line {

scripts/bootstrap.sh

@@ -1,5 +1,5 @@
 #!/bin/sh
-# Version: 26
+# Version: 21
 
 # A script that installs the dependencies needed to build and test Bun.
 # This should work on macOS and Linux with a POSIX shell.
@@ -281,6 +281,9 @@ check_operating_system() {
 	Darwin)
 		os="darwin"
 		;;
+	FreeBSD)
+		os="freebsd"
+		;;
 	*)
 		error "Unsupported operating system: $os"
 		;;
@@ -343,6 +346,11 @@ check_operating_system() {
 			;;
 		esac
 		;;
+	freebsd)
+		. /etc/os-release
+		distro="$ID"
+		release="$VERSION_ID"
+		;;
 	esac
 
 	if [ -n "$distro" ]; then
@@ -426,6 +434,9 @@ check_package_manager() {
 			error "No package manager found. (apt, dnf, yum, apk)"
 		fi
 		;;
+	freebsd)
+		pm="pkg"
+		;;
 	esac
 	print "Package manager: $pm"
 
@@ -438,6 +449,13 @@ check_package_manager() {
 	apk)
 		package_manager update
 		;;
+	pkg)
+		# may need to switch betwen 'latest' and 'quarterly' depending on which repo www/chromium is in. check https://www.freshports.org/www/chromium/.
+		# mkdir -p /usr/local/etc/pkg/repos
+		# echo 'FreeBSD: { url: "pkg+http://pkg.FreeBSD.org/${ABI}/quarterly" }' > /usr/local/etc/pkg/repos/FreeBSD.conf
+		export ASSUME_ALWAYS_YES=yes
+		package_manager update -f
+		;;
 	esac
 }
 
@@ -798,6 +816,9 @@ install_nodejs() {
 	linux)
 		nodejs_platform="linux"
 		;;
+	freebsd)
+		nodejs_platform="freebsd"
+		;;
 	*)
 		error "Unsupported OS for Node.js download: $os"
 		;;
@@ -816,6 +837,12 @@ install_nodejs() {
 		;;
 	esac
 
+	if [ "$os" = "freebsd" ]; then
+		# TODO: use nodejs_version_exact
+		install_packages "www/node$(nodejs_version)" "www/npm-node$(nodejs_version)"
+		return
+	fi
+
 	case "$abi" in
 	musl)
 		nodejs_mirror="https://bun-nodejs-release.s3.us-west-1.amazonaws.com"
@@ -905,6 +932,10 @@ install_nodejs() {
 }
 
 install_nodejs_headers() {
+	if [ "$os" = "freebsd" ]; then
+		return
+	fi
+
 	nodejs_version="$(nodejs_version_exact)"
 	nodejs_headers_tar="$(download_file "https://nodejs.org/download/release/v$nodejs_version/node-v$nodejs_version-headers.tar.gz")"
 	nodejs_headers_dir="$(dirname "$nodejs_headers_tar")"
@@ -919,6 +950,10 @@ install_nodejs_headers() {
 }
 
 setup_node_gyp_cache() {
+	if [ "$os" = "freebsd" ]; then
+		return
+	fi
+
 	nodejs_version="$1"
 	headers_source="$2"
 
@@ -957,6 +992,11 @@ bun_version_exact() {
 }
 
 install_bun() {
+	if [ "$os" = "freebsd" ]; then
+		# TODO: need to complete bun bootstrap for for this work
+		return
+	fi
+
 	install_packages unzip
 
 	case "$pm" in
@@ -1008,6 +1048,9 @@ install_cmake() {
 			--skip-license \
 			--prefix=/usr
 		;;
+	freebsd-pkg)
+		install_packages devel/cmake
+		;;
 	esac
 }
 
@@ -1079,6 +1122,17 @@ install_build_essentials() {
 				ruby \
 				perl \
 			;;
+		freebsd)
+			install_packages \
+				devel/ninja \
+				devel/pkgconf \
+				lang/go \
+				devel/gmake \
+				lang/python3 \
+				devel/libtool \
+				lang/ruby33 \
+				perl5 \
+			;;
 	esac
 
 	install_cmake
@@ -1086,7 +1140,7 @@ install_build_essentials() {
 	install_osxcross
 	install_gcc
 	install_rust
-	install_ccache
+	install_sccache
 	install_docker
 }
 
@@ -1101,23 +1155,12 @@ llvm_version() {
 install_llvm() {
 	case "$pm" in
 	apt)
-		# Debian 13 (Trixie) has LLVM 19 natively, and apt.llvm.org doesn't have a trixie repo
-		if [ "$distro" = "debian" ]; then
-			install_packages \
-				"llvm-$(llvm_version)" \
-				"clang-$(llvm_version)" \
-				"lld-$(llvm_version)" \
-				"llvm-$(llvm_version)-dev" \
-				"llvm-$(llvm_version)-tools" \
-				"libclang-rt-$(llvm_version)-dev"
-		else
-			bash="$(require bash)"
-			llvm_script="$(download_file "https://apt.llvm.org/llvm.sh")"
-			execute_sudo "$bash" "$llvm_script" "$(llvm_version)" all
+		bash="$(require bash)"
+		llvm_script="$(download_file "https://apt.llvm.org/llvm.sh")"
+		execute_sudo "$bash" "$llvm_script" "$(llvm_version)" all
 
-			# Install llvm-symbolizer explicitly to ensure it's available for ASAN
-			install_packages "llvm-$(llvm_version)-tools"
-		fi
+		# Install llvm-symbolizer explicitly to ensure it's available for ASAN
+		install_packages "llvm-$(llvm_version)-tools"
 		;;
 	brew)
 		install_packages "llvm@$(llvm_version)"
@@ -1131,6 +1174,13 @@ install_llvm() {
 			"llvm$(llvm_version)-dev" # Ensures llvm-symbolizer is installed
 		;;
 	esac
+
+	case "$os" in
+		freebsd)
+			# TODO: use llvm_version_exact
+			install_packages "devel/llvm$(llvm_version)"
+		;;
+	esac
 }
 
 install_gcc() {
@@ -1206,39 +1256,69 @@ install_gcc() {
 	execute_sudo ln -sf $(which llvm-symbolizer-$llvm_v) /usr/bin/llvm-symbolizer
 }
 
-install_ccache() {
-	case "$pm" in
-	apt)
-		install_packages ccache
-		;;
-	brew)
-		install_packages ccache
-		;;
-	apk)
-		install_packages ccache
-		;;
-	dnf|yum)
-		install_packages ccache
-		;;
-	zypper)
-		install_packages ccache
-		;;
+install_sccache() {
+	case "$os" in
+		linux)
+			;;
+		freebsd)
+			cargo install sccache --locked --version 0.12.0
+			return
+			;;
+		*)
+			error "Unsupported platform: $os"
+			;;
 	esac
+
+	# Alright, look, this function is cobbled together but it's only as cobbled
+	# together as this whole script is.
+	#
+	# For some reason, move_to_bin doesn't work here due to permissions so I'm
+	# avoiding that function. It's also wrong with permissions and so on.
+	#
+	# Unfortunately, we cannot use install_packages since many package managers
+	# don't compile `sccache` with S3 support.
+	local opts=$-
+	set -ef
+
+	local sccache_http
+	sccache_http="https://github.com/mozilla/sccache/releases/download/v0.12.0/sccache-v0.12.0-$(uname -m)-unknown-linux-musl.tar.gz"
+
+	local file
+	file=$(download_file "$sccache_http")
+
+	local tmpdir
+	tmpdir=$(mktemp -d)
+
+	execute tar -xzf "$file" -C "$tmpdir"
+	execute_sudo install -m755 "$tmpdir/sccache-v0.12.0-$(uname -m)-unknown-linux-musl/sccache" "/usr/local/bin"
+
+	set +ef -"$opts"
 }
 
 install_rust() {
-	rust_home="/opt/rust"
-	create_directory "$rust_home"
-	append_to_profile "export RUSTUP_HOME=$rust_home"
-	append_to_profile "export CARGO_HOME=$rust_home"
+	case "$distro" in
+	alpine)
+		install_packages \
+			rust \
+			cargo
+		;;
+	freebsd)
+		install_packages lang/rust
+		create_directory "$HOME/.cargo/bin"
+		append_to_path "$HOME/.cargo/bin"
+		;;
+	*)
+		rust_home="/opt/rust"
+		create_directory "$rust_home"
+		append_to_profile "export RUSTUP_HOME=$rust_home"
+		append_to_profile "export CARGO_HOME=$rust_home"
 
-	sh="$(require sh)"
-	rustup_script=$(download_file "https://sh.rustup.rs")
-	execute "$sh" -lc "$rustup_script -y --no-modify-path"
-	append_to_path "$rust_home/bin"
-
-	# Ensure all rustup files are accessible (for CI builds where different users run builds)
-	grant_to_user "$rust_home"
+		sh="$(require sh)"
+		rustup_script=$(download_file "https://sh.rustup.rs")
+		execute "$sh" -lc "$rustup_script -y --no-modify-path"
+		append_to_path "$rust_home/bin"
+		;;
+	esac
 
 	case "$osxcross" in
 	1)
@@ -1355,6 +1435,9 @@ install_tailscale() {
 		execute_as_user go install tailscale.com/cmd/tailscale{,d}@latest
 		append_to_path "$home/go/bin"
 		;;
+	freebsd)
+		install_packages security/tailscale
+		;;
 	esac
 }
 
@@ -1421,6 +1504,14 @@ create_buildkite_user() {
 				--home "$home" \
 				--disabled-password
 			;;
+		freebsd)
+			execute_sudo pw group add -n "$group"
+			execute_sudo pw user add \
+				-n "$user" \
+				-g "$group" \
+				-s "$(require sh)" \
+				-d "$home" \
+			;;
 		*)
 			execute_sudo useradd "$user" \
 				--system \
@@ -1446,7 +1537,9 @@ create_buildkite_user() {
 	done
 
 	# The following is necessary to configure buildkite to use a stable
-	# checkout directory for ccache to be effective.
+	# checkout directory. sccache hashes absolute paths into its cache keys,
+	# so if buildkite uses a different checkout path each time (which it does
+	# by default), sccache will be useless.
 	local opts=$-
 	set -ef
 
@@ -1601,6 +1694,17 @@ install_age() {
 			;;
 		esac
 		;;
+	freebsd)
+		case "$arch" in
+		x64)
+			age_arch="amd64"
+			age_hash="943a7510a9973a1e589b913a70228aa1361a63cde39e3ed581435a4d4802df29"
+			;;
+		*)
+			error "Unsupported platform: $os-$arch"
+			;;
+		esac
+		;;
 	*)
 		error "Unsupported platform: $os-$arch"
 		;;

scripts/build-cache/bun.lock

@@ -0,0 +1,249 @@
+{
+  "lockfileVersion": 1,
+  "configVersion": 1,
+  "workspaces": {
+    "": {
+      "dependencies": {
+        "@aws-sdk/client-s3": "^3.928.0",
+        "@aws-sdk/property-provider": "^3.374.0",
+      },
+    },
+  },
+  "packages": {
+    "@aws-crypto/crc32": ["@aws-crypto/crc32@5.2.0", "", { "dependencies": { "@aws-crypto/util": "^5.2.0", "@aws-sdk/types": "^3.222.0", "tslib": "^2.6.2" } }, "sha512-nLbCWqQNgUiwwtFsen1AdzAtvuLRsQS8rYgMuxCrdKf9kOssamGLuPwyTY9wyYblNr9+1XM8v6zoDTPPSIeANg=="],
+
+    "@aws-crypto/crc32c": ["@aws-crypto/crc32c@5.2.0", "", { "dependencies": { "@aws-crypto/util": "^5.2.0", "@aws-sdk/types": "^3.222.0", "tslib": "^2.6.2" } }, "sha512-+iWb8qaHLYKrNvGRbiYRHSdKRWhto5XlZUEBwDjYNf+ly5SVYG6zEoYIdxvf5R3zyeP16w4PLBn3rH1xc74Rag=="],
+
+    "@aws-crypto/sha1-browser": ["@aws-crypto/sha1-browser@5.2.0", "", { "dependencies": { "@aws-crypto/supports-web-crypto": "^5.2.0", "@aws-crypto/util": "^5.2.0", "@aws-sdk/types": "^3.222.0", "@aws-sdk/util-locate-window": "^3.0.0", "@smithy/util-utf8": "^2.0.0", "tslib": "^2.6.2" } }, "sha512-OH6lveCFfcDjX4dbAvCFSYUjJZjDr/3XJ3xHtjn3Oj5b9RjojQo8npoLeA/bNwkOkrSQ0wgrHzXk4tDRxGKJeg=="],
+
+    "@aws-crypto/sha256-browser": ["@aws-crypto/sha256-browser@5.2.0", "", { "dependencies": { "@aws-crypto/sha256-js": "^5.2.0", "@aws-crypto/supports-web-crypto": "^5.2.0", "@aws-crypto/util": "^5.2.0", "@aws-sdk/types": "^3.222.0", "@aws-sdk/util-locate-window": "^3.0.0", "@smithy/util-utf8": "^2.0.0", "tslib": "^2.6.2" } }, "sha512-AXfN/lGotSQwu6HNcEsIASo7kWXZ5HYWvfOmSNKDsEqC4OashTp8alTmaz+F7TC2L083SFv5RdB+qU3Vs1kZqw=="],
+
+    "@aws-crypto/sha256-js": ["@aws-crypto/sha256-js@5.2.0", "", { "dependencies": { "@aws-crypto/util": "^5.2.0", "@aws-sdk/types": "^3.222.0", "tslib": "^2.6.2" } }, "sha512-FFQQyu7edu4ufvIZ+OadFpHHOt+eSTBaYaki44c+akjg7qZg9oOQeLlk77F6tSYqjDAFClrHJk9tMf0HdVyOvA=="],
+
+    "@aws-crypto/supports-web-crypto": ["@aws-crypto/supports-web-crypto@5.2.0", "", { "dependencies": { "tslib": "^2.6.2" } }, "sha512-iAvUotm021kM33eCdNfwIN//F77/IADDSs58i+MDaOqFrVjZo9bAal0NK7HurRuWLLpF1iLX7gbWrjHjeo+YFg=="],
+
+    "@aws-crypto/util": ["@aws-crypto/util@5.2.0", "", { "dependencies": { "@aws-sdk/types": "^3.222.0", "@smithy/util-utf8": "^2.0.0", "tslib": "^2.6.2" } }, "sha512-4RkU9EsI6ZpBve5fseQlGNUWKMa1RLPQ1dnjnQoe07ldfIzcsGb5hC5W0Dm7u423KWzawlrpbjXBrXCEv9zazQ=="],
+
+    "@aws-sdk/client-s3": ["@aws-sdk/client-s3@3.928.0", "", { "dependencies": { "@aws-crypto/sha1-browser": "5.2.0", "@aws-crypto/sha256-browser": "5.2.0", "@aws-crypto/sha256-js": "5.2.0", "@aws-sdk/core": "3.928.0", "@aws-sdk/credential-provider-node": "3.928.0", "@aws-sdk/middleware-bucket-endpoint": "3.922.0", "@aws-sdk/middleware-expect-continue": "3.922.0", "@aws-sdk/middleware-flexible-checksums": "3.928.0", "@aws-sdk/middleware-host-header": "3.922.0", "@aws-sdk/middleware-location-constraint": "3.922.0", "@aws-sdk/middleware-logger": "3.922.0", "@aws-sdk/middleware-recursion-detection": "3.922.0", "@aws-sdk/middleware-sdk-s3": "3.928.0", "@aws-sdk/middleware-ssec": "3.922.0", "@aws-sdk/middleware-user-agent": "3.928.0", "@aws-sdk/region-config-resolver": "3.925.0", "@aws-sdk/signature-v4-multi-region": "3.928.0", "@aws-sdk/types": "3.922.0", "@aws-sdk/util-endpoints": "3.922.0", "@aws-sdk/util-user-agent-browser": "3.922.0", "@aws-sdk/util-user-agent-node": "3.928.0", "@aws-sdk/xml-builder": "3.921.0", "@smithy/config-resolver": "^4.4.2", "@smithy/core": "^3.17.2", "@smithy/eventstream-serde-browser": "^4.2.4", "@smithy/eventstream-serde-config-resolver": "^4.3.4", "@smithy/eventstream-serde-node": "^4.2.4", "@smithy/fetch-http-handler": "^5.3.5", "@smithy/hash-blob-browser": "^4.2.5", "@smithy/hash-node": "^4.2.4", "@smithy/hash-stream-node": "^4.2.4", "@smithy/invalid-dependency": "^4.2.4", "@smithy/md5-js": "^4.2.4", "@smithy/middleware-content-length": "^4.2.4", "@smithy/middleware-endpoint": "^4.3.6", "@smithy/middleware-retry": "^4.4.6", "@smithy/middleware-serde": "^4.2.4", "@smithy/middleware-stack": "^4.2.4", "@smithy/node-config-provider": "^4.3.4", "@smithy/node-http-handler": "^4.4.4", "@smithy/protocol-http": "^5.3.4", "@smithy/smithy-client": "^4.9.2", "@smithy/types": "^4.8.1", "@smithy/url-parser": "^4.2.4", "@smithy/util-base64": "^4.3.0", "@smithy/util-body-length-browser": "^4.2.0", "@smithy/util-body-length-node": "^4.2.1", "@smithy/util-defaults-mode-browser": "^4.3.5", "@smithy/util-defaults-mode-node": "^4.2.8", "@smithy/util-endpoints": "^3.2.4", "@smithy/util-middleware": "^4.2.4", "@smithy/util-retry": "^4.2.4", "@smithy/util-stream": "^4.5.5", "@smithy/util-utf8": "^4.2.0", "@smithy/util-waiter": "^4.2.4", "@smithy/uuid": "^1.1.0", "tslib": "^2.6.2" } }, "sha512-lXhhmcBjYa+ea0kRs00aq3WUwiXggwJkLwcMzOOsbW3CVYQaNpT7hztkfn2S6Qna7ETzd8M5+XZP+BmQRVE0Sg=="],
+
+    "@aws-sdk/client-sso": ["@aws-sdk/client-sso@3.928.0", "", { "dependencies": { "@aws-crypto/sha256-browser": "5.2.0", "@aws-crypto/sha256-js": "5.2.0", "@aws-sdk/core": "3.928.0", "@aws-sdk/middleware-host-header": "3.922.0", "@aws-sdk/middleware-logger": "3.922.0", "@aws-sdk/middleware-recursion-detection": "3.922.0", "@aws-sdk/middleware-user-agent": "3.928.0", "@aws-sdk/region-config-resolver": "3.925.0", "@aws-sdk/types": "3.922.0", "@aws-sdk/util-endpoints": "3.922.0", "@aws-sdk/util-user-agent-browser": "3.922.0", "@aws-sdk/util-user-agent-node": "3.928.0", "@smithy/config-resolver": "^4.4.2", "@smithy/core": "^3.17.2", "@smithy/fetch-http-handler": "^5.3.5", "@smithy/hash-node": "^4.2.4", "@smithy/invalid-dependency": "^4.2.4", "@smithy/middleware-content-length": "^4.2.4", "@smithy/middleware-endpoint": "^4.3.6", "@smithy/middleware-retry": "^4.4.6", "@smithy/middleware-serde": "^4.2.4", "@smithy/middleware-stack": "^4.2.4", "@smithy/node-config-provider": "^4.3.4", "@smithy/node-http-handler": "^4.4.4", "@smithy/protocol-http": "^5.3.4", "@smithy/smithy-client": "^4.9.2", "@smithy/types": "^4.8.1", "@smithy/url-parser": "^4.2.4", "@smithy/util-base64": "^4.3.0", "@smithy/util-body-length-browser": "^4.2.0", "@smithy/util-body-length-node": "^4.2.1", "@smithy/util-defaults-mode-browser": "^4.3.5", "@smithy/util-defaults-mode-node": "^4.2.8", "@smithy/util-endpoints": "^3.2.4", "@smithy/util-middleware": "^4.2.4", "@smithy/util-retry": "^4.2.4", "@smithy/util-utf8": "^4.2.0", "tslib": "^2.6.2" } }, "sha512-Efenb8zV2fJJDXmp2NE4xj8Ymhp4gVJCkQ6ixhdrpfQXgd2PODO7a20C2+BhFM6aGmN3m6XWYJ64ZyhXF4pAyQ=="],
+
+    "@aws-sdk/core": ["@aws-sdk/core@3.928.0", "", { "dependencies": { "@aws-sdk/types": "3.922.0", "@aws-sdk/xml-builder": "3.921.0", "@smithy/core": "^3.17.2", "@smithy/node-config-provider": "^4.3.4", "@smithy/property-provider": "^4.2.4", "@smithy/protocol-http": "^5.3.4", "@smithy/signature-v4": "^5.3.4", "@smithy/smithy-client": "^4.9.2", "@smithy/types": "^4.8.1", "@smithy/util-base64": "^4.3.0", "@smithy/util-middleware": "^4.2.4", "@smithy/util-utf8": "^4.2.0", "tslib": "^2.6.2" } }, "sha512-e28J2uKjy2uub4u41dNnmzAu0AN3FGB+LRcLN2Qnwl9Oq3kIcByl5sM8ZD+vWpNG+SFUrUasBCq8cMnHxwXZ4w=="],
+
+    "@aws-sdk/credential-provider-env": ["@aws-sdk/credential-provider-env@3.928.0", "", { "dependencies": { "@aws-sdk/core": "3.928.0", "@aws-sdk/types": "3.922.0", "@smithy/property-provider": "^4.2.4", "@smithy/types": "^4.8.1", "tslib": "^2.6.2" } }, "sha512-tB8F9Ti0/NFyFVQX8UQtgRik88evtHpyT6WfXOB4bAY6lEnEHA0ubJZmk9y+aUeoE+OsGLx70dC3JUsiiCPJkQ=="],
+
+    "@aws-sdk/credential-provider-http": ["@aws-sdk/credential-provider-http@3.928.0", "", { "dependencies": { "@aws-sdk/core": "3.928.0", "@aws-sdk/types": "3.922.0", "@smithy/fetch-http-handler": "^5.3.5", "@smithy/node-http-handler": "^4.4.4", "@smithy/property-provider": "^4.2.4", "@smithy/protocol-http": "^5.3.4", "@smithy/smithy-client": "^4.9.2", "@smithy/types": "^4.8.1", "@smithy/util-stream": "^4.5.5", "tslib": "^2.6.2" } }, "sha512-67ynC/8UW9Y8Gn1ZZtC3OgcQDGWrJelHmkbgpmmxYUrzVhp+NINtz3wiTzrrBFhPH/8Uy6BxvhMfXhn0ptcMEQ=="],
+
+    "@aws-sdk/credential-provider-ini": ["@aws-sdk/credential-provider-ini@3.928.0", "", { "dependencies": { "@aws-sdk/core": "3.928.0", "@aws-sdk/credential-provider-env": "3.928.0", "@aws-sdk/credential-provider-http": "3.928.0", "@aws-sdk/credential-provider-process": "3.928.0", "@aws-sdk/credential-provider-sso": "3.928.0", "@aws-sdk/credential-provider-web-identity": "3.928.0", "@aws-sdk/nested-clients": "3.928.0", "@aws-sdk/types": "3.922.0", "@smithy/credential-provider-imds": "^4.2.4", "@smithy/property-provider": "^4.2.4", "@smithy/shared-ini-file-loader": "^4.3.4", "@smithy/types": "^4.8.1", "tslib": "^2.6.2" } }, "sha512-WVWYyj+jox6mhKYp11mu8x1B6Xa2sLbXFHAv5K3Jg8CHvXYpePgTcYlCljq3d4XHC4Jl4nCcsdMtBahSpU9bAA=="],
+
+    "@aws-sdk/credential-provider-node": ["@aws-sdk/credential-provider-node@3.928.0", "", { "dependencies": { "@aws-sdk/credential-provider-env": "3.928.0", "@aws-sdk/credential-provider-http": "3.928.0", "@aws-sdk/credential-provider-ini": "3.928.0", "@aws-sdk/credential-provider-process": "3.928.0", "@aws-sdk/credential-provider-sso": "3.928.0", "@aws-sdk/credential-provider-web-identity": "3.928.0", "@aws-sdk/types": "3.922.0", "@smithy/credential-provider-imds": "^4.2.4", "@smithy/property-provider": "^4.2.4", "@smithy/shared-ini-file-loader": "^4.3.4", "@smithy/types": "^4.8.1", "tslib": "^2.6.2" } }, "sha512-SdXVjxZOIXefIR/NJx+lyXOrn4m0ScTAU2JXpLsFCkW2Cafo6vTqHUghyO8vak/XQ8PpPqpLXVpGbAYFuIPW6Q=="],
+
+    "@aws-sdk/credential-provider-process": ["@aws-sdk/credential-provider-process@3.928.0", "", { "dependencies": { "@aws-sdk/core": "3.928.0", "@aws-sdk/types": "3.922.0", "@smithy/property-provider": "^4.2.4", "@smithy/shared-ini-file-loader": "^4.3.4", "@smithy/types": "^4.8.1", "tslib": "^2.6.2" } }, "sha512-XL0juran8yhqwn0mreV+NJeHJOkcRBaExsvVn9fXWW37A4gLh4esSJxM2KbSNh0t+/Bk3ehBI5sL9xad+yRDuw=="],
+
+    "@aws-sdk/credential-provider-sso": ["@aws-sdk/credential-provider-sso@3.928.0", "", { "dependencies": { "@aws-sdk/client-sso": "3.928.0", "@aws-sdk/core": "3.928.0", "@aws-sdk/token-providers": "3.928.0", "@aws-sdk/types": "3.922.0", "@smithy/property-provider": "^4.2.4", "@smithy/shared-ini-file-loader": "^4.3.4", "@smithy/types": "^4.8.1", "tslib": "^2.6.2" } }, "sha512-md/y+ePDsO1zqPJrsOyPs4ciKmdpqLL7B0dln1NhqZPnKIS5IBfTqZJ5tJ9eTezqc7Tn4Dbg6HiuemcGvZTeFA=="],
+
+    "@aws-sdk/credential-provider-web-identity": ["@aws-sdk/credential-provider-web-identity@3.928.0", "", { "dependencies": { "@aws-sdk/core": "3.928.0", "@aws-sdk/nested-clients": "3.928.0", "@aws-sdk/types": "3.922.0", "@smithy/property-provider": "^4.2.4", "@smithy/shared-ini-file-loader": "^4.3.4", "@smithy/types": "^4.8.1", "tslib": "^2.6.2" } }, "sha512-rd97nLY5e/nGOr73ZfsXD+H44iZ9wyGZTKt/2QkiBN3hot/idhgT9+XHsWhRi+o/dThQbpL8RkpAnpF+0ZGthw=="],
+
+    "@aws-sdk/middleware-bucket-endpoint": ["@aws-sdk/middleware-bucket-endpoint@3.922.0", "", { "dependencies": { "@aws-sdk/types": "3.922.0", "@aws-sdk/util-arn-parser": "3.893.0", "@smithy/node-config-provider": "^4.3.4", "@smithy/protocol-http": "^5.3.4", "@smithy/types": "^4.8.1", "@smithy/util-config-provider": "^4.2.0", "tslib": "^2.6.2" } }, "sha512-Dpr2YeOaLFqt3q1hocwBesynE3x8/dXZqXZRuzSX/9/VQcwYBFChHAm4mTAl4zuvArtDbLrwzWSxmOWYZGtq5w=="],
+
+    "@aws-sdk/middleware-expect-continue": ["@aws-sdk/middleware-expect-continue@3.922.0", "", { "dependencies": { "@aws-sdk/types": "3.922.0", "@smithy/protocol-http": "^5.3.4", "@smithy/types": "^4.8.1", "tslib": "^2.6.2" } }, "sha512-xmnLWMtmHJHJBupSWMUEW1gyxuRIeQ1Ov2xa8Tqq77fPr4Ft2AluEwiDMaZIMHoAvpxWKEEt9Si59Li7GIA+bQ=="],
+
+    "@aws-sdk/middleware-flexible-checksums": ["@aws-sdk/middleware-flexible-checksums@3.928.0", "", { "dependencies": { "@aws-crypto/crc32": "5.2.0", "@aws-crypto/crc32c": "5.2.0", "@aws-crypto/util": "5.2.0", "@aws-sdk/core": "3.928.0", "@aws-sdk/types": "3.922.0", "@smithy/is-array-buffer": "^4.2.0", "@smithy/node-config-provider": "^4.3.4", "@smithy/protocol-http": "^5.3.4", "@smithy/types": "^4.8.1", "@smithy/util-middleware": "^4.2.4", "@smithy/util-stream": "^4.5.5", "@smithy/util-utf8": "^4.2.0", "tslib": "^2.6.2" } }, "sha512-9+aCRt7teItSIMbnGvOY+FhtJnW2ZBUbfD+ug29a/ZbobDfTwmtrmtgEIWdXryFaRbT03HHfaJ3a++lTw4osuw=="],
+
+    "@aws-sdk/middleware-host-header": ["@aws-sdk/middleware-host-header@3.922.0", "", { "dependencies": { "@aws-sdk/types": "3.922.0", "@smithy/protocol-http": "^5.3.4", "@smithy/types": "^4.8.1", "tslib": "^2.6.2" } }, "sha512-HPquFgBnq/KqKRVkiuCt97PmWbKtxQ5iUNLEc6FIviqOoZTmaYG3EDsIbuFBz9C4RHJU4FKLmHL2bL3FEId6AA=="],
+
+    "@aws-sdk/middleware-location-constraint": ["@aws-sdk/middleware-location-constraint@3.922.0", "", { "dependencies": { "@aws-sdk/types": "3.922.0", "@smithy/types": "^4.8.1", "tslib": "^2.6.2" } }, "sha512-T4iqd7WQ2DDjCH/0s50mnhdoX+IJns83ZE+3zj9IDlpU0N2aq8R91IG890qTfYkUEdP9yRm0xir/CNed+v6Dew=="],
+
+    "@aws-sdk/middleware-logger": ["@aws-sdk/middleware-logger@3.922.0", "", { "dependencies": { "@aws-sdk/types": "3.922.0", "@smithy/types": "^4.8.1", "tslib": "^2.6.2" } }, "sha512-AkvYO6b80FBm5/kk2E636zNNcNgjztNNUxpqVx+huyGn9ZqGTzS4kLqW2hO6CBe5APzVtPCtiQsXL24nzuOlAg=="],
+
+    "@aws-sdk/middleware-recursion-detection": ["@aws-sdk/middleware-recursion-detection@3.922.0", "", { "dependencies": { "@aws-sdk/types": "3.922.0", "@aws/lambda-invoke-store": "^0.1.1", "@smithy/protocol-http": "^5.3.4", "@smithy/types": "^4.8.1", "tslib": "^2.6.2" } }, "sha512-TtSCEDonV/9R0VhVlCpxZbp/9sxQvTTRKzIf8LxW3uXpby6Wl8IxEciBJlxmSkoqxh542WRcko7NYODlvL/gDA=="],
+
+    "@aws-sdk/middleware-sdk-s3": ["@aws-sdk/middleware-sdk-s3@3.928.0", "", { "dependencies": { "@aws-sdk/core": "3.928.0", "@aws-sdk/types": "3.922.0", "@aws-sdk/util-arn-parser": "3.893.0", "@smithy/core": "^3.17.2", "@smithy/node-config-provider": "^4.3.4", "@smithy/protocol-http": "^5.3.4", "@smithy/signature-v4": "^5.3.4", "@smithy/smithy-client": "^4.9.2", "@smithy/types": "^4.8.1", "@smithy/util-config-provider": "^4.2.0", "@smithy/util-middleware": "^4.2.4", "@smithy/util-stream": "^4.5.5", "@smithy/util-utf8": "^4.2.0", "tslib": "^2.6.2" } }, "sha512-LTkjS6cpJ2PEtsottTKq7JxZV0oH+QJ12P/dGNPZL4URayjEMBVR/dp4zh835X/FPXzijga3sdotlIKzuFy9FA=="],
+
+    "@aws-sdk/middleware-ssec": ["@aws-sdk/middleware-ssec@3.922.0", "", { "dependencies": { "@aws-sdk/types": "3.922.0", "@smithy/types": "^4.8.1", "tslib": "^2.6.2" } }, "sha512-eHvSJZTSRJO+/tjjGD6ocnPc8q9o3m26+qbwQTu/4V6yOJQ1q+xkDZNqwJQphL+CodYaQ7uljp8g1Ji/AN3D9w=="],
+
+    "@aws-sdk/middleware-user-agent": ["@aws-sdk/middleware-user-agent@3.928.0", "", { "dependencies": { "@aws-sdk/core": "3.928.0", "@aws-sdk/types": "3.922.0", "@aws-sdk/util-endpoints": "3.922.0", "@smithy/core": "^3.17.2", "@smithy/protocol-http": "^5.3.4", "@smithy/types": "^4.8.1", "tslib": "^2.6.2" } }, "sha512-ESvcfLx5PtpdUM3ptCwb80toBTd3y5I4w5jaeOPHihiZr7jkRLE/nsaCKzlqscPs6UQ8xI0maav04JUiTskcHw=="],
+
+    "@aws-sdk/nested-clients": ["@aws-sdk/nested-clients@3.928.0", "", { "dependencies": { "@aws-crypto/sha256-browser": "5.2.0", "@aws-crypto/sha256-js": "5.2.0", "@aws-sdk/core": "3.928.0", "@aws-sdk/middleware-host-header": "3.922.0", "@aws-sdk/middleware-logger": "3.922.0", "@aws-sdk/middleware-recursion-detection": "3.922.0", "@aws-sdk/middleware-user-agent": "3.928.0", "@aws-sdk/region-config-resolver": "3.925.0", "@aws-sdk/types": "3.922.0", "@aws-sdk/util-endpoints": "3.922.0", "@aws-sdk/util-user-agent-browser": "3.922.0", "@aws-sdk/util-user-agent-node": "3.928.0", "@smithy/config-resolver": "^4.4.2", "@smithy/core": "^3.17.2", "@smithy/fetch-http-handler": "^5.3.5", "@smithy/hash-node": "^4.2.4", "@smithy/invalid-dependency": "^4.2.4", "@smithy/middleware-content-length": "^4.2.4", "@smithy/middleware-endpoint": "^4.3.6", "@smithy/middleware-retry": "^4.4.6", "@smithy/middleware-serde": "^4.2.4", "@smithy/middleware-stack": "^4.2.4", "@smithy/node-config-provider": "^4.3.4", "@smithy/node-http-handler": "^4.4.4", "@smithy/protocol-http": "^5.3.4", "@smithy/smithy-client": "^4.9.2", "@smithy/types": "^4.8.1", "@smithy/url-parser": "^4.2.4", "@smithy/util-base64": "^4.3.0", "@smithy/util-body-length-browser": "^4.2.0", "@smithy/util-body-length-node": "^4.2.1", "@smithy/util-defaults-mode-browser": "^4.3.5", "@smithy/util-defaults-mode-node": "^4.2.8", "@smithy/util-endpoints": "^3.2.4", "@smithy/util-middleware": "^4.2.4", "@smithy/util-retry": "^4.2.4", "@smithy/util-utf8": "^4.2.0", "tslib": "^2.6.2" } }, "sha512-kXzfJkq2cD65KAHDe4hZCsnxcGGEWD5pjHqcZplwG4VFMa/iVn/mWrUY9QdadD2GBpXFNQbgOiKG3U2NkKu+4Q=="],
+
+    "@aws-sdk/property-provider": ["@aws-sdk/property-provider@3.374.0", "", { "dependencies": { "@smithy/property-provider": "^1.0.1", "tslib": "^2.5.0" } }, "sha512-UvsRnRtLD3g0tPMuiILJiGT9PIg4tgU3coRO4s+bAuT29mUiuViDAQB8DYPgaOtqA4qNFiWose+AMCpdxlOhRA=="],
+
+    "@aws-sdk/region-config-resolver": ["@aws-sdk/region-config-resolver@3.925.0", "", { "dependencies": { "@aws-sdk/types": "3.922.0", "@smithy/config-resolver": "^4.4.2", "@smithy/node-config-provider": "^4.3.4", "@smithy/types": "^4.8.1", "tslib": "^2.6.2" } }, "sha512-FOthcdF9oDb1pfQBRCfWPZhJZT5wqpvdAS5aJzB1WDZ+6EuaAhLzLH/fW1slDunIqq1PSQGG3uSnVglVVOvPHQ=="],
+
+    "@aws-sdk/signature-v4-multi-region": ["@aws-sdk/signature-v4-multi-region@3.928.0", "", { "dependencies": { "@aws-sdk/middleware-sdk-s3": "3.928.0", "@aws-sdk/types": "3.922.0", "@smithy/protocol-http": "^5.3.4", "@smithy/signature-v4": "^5.3.4", "@smithy/types": "^4.8.1", "tslib": "^2.6.2" } }, "sha512-1+Ic8+MyqQy+OE6QDoQKVCIcSZO+ETmLLLpVS5yu0fihBU85B5HHU7iaKX1qX7lEaGPMpSN/mbHW0VpyQ0Xqaw=="],
+
+    "@aws-sdk/token-providers": ["@aws-sdk/token-providers@3.928.0", "", { "dependencies": { "@aws-sdk/core": "3.928.0", "@aws-sdk/nested-clients": "3.928.0", "@aws-sdk/types": "3.922.0", "@smithy/property-provider": "^4.2.4", "@smithy/shared-ini-file-loader": "^4.3.4", "@smithy/types": "^4.8.1", "tslib": "^2.6.2" } }, "sha512-533NpTdUJNDi98zBwRp4ZpZoqULrAVfc0YgIy+8AZHzk0v7N+v59O0d2Du3YO6zN4VU8HU8766DgKiyEag6Dzg=="],
+
+    "@aws-sdk/types": ["@aws-sdk/types@3.922.0", "", { "dependencies": { "@smithy/types": "^4.8.1", "tslib": "^2.6.2" } }, "sha512-eLA6XjVobAUAMivvM7DBL79mnHyrm+32TkXNWZua5mnxF+6kQCfblKKJvxMZLGosO53/Ex46ogim8IY5Nbqv2w=="],
+
+    "@aws-sdk/util-arn-parser": ["@aws-sdk/util-arn-parser@3.893.0", "", { "dependencies": { "tslib": "^2.6.2" } }, "sha512-u8H4f2Zsi19DGnwj5FSZzDMhytYF/bCh37vAtBsn3cNDL3YG578X5oc+wSX54pM3tOxS+NY7tvOAo52SW7koUA=="],
+
+    "@aws-sdk/util-endpoints": ["@aws-sdk/util-endpoints@3.922.0", "", { "dependencies": { "@aws-sdk/types": "3.922.0", "@smithy/types": "^4.8.1", "@smithy/url-parser": "^4.2.4", "@smithy/util-endpoints": "^3.2.4", "tslib": "^2.6.2" } }, "sha512-4ZdQCSuNMY8HMlR1YN4MRDdXuKd+uQTeKIr5/pIM+g3TjInZoj8imvXudjcrFGA63UF3t92YVTkBq88mg58RXQ=="],
+
+    "@aws-sdk/util-locate-window": ["@aws-sdk/util-locate-window@3.893.0", "", { "dependencies": { "tslib": "^2.6.2" } }, "sha512-T89pFfgat6c8nMmpI8eKjBcDcgJq36+m9oiXbcUzeU55MP9ZuGgBomGjGnHaEyF36jenW9gmg3NfZDm0AO2XPg=="],
+
+    "@aws-sdk/util-user-agent-browser": ["@aws-sdk/util-user-agent-browser@3.922.0", "", { "dependencies": { "@aws-sdk/types": "3.922.0", "@smithy/types": "^4.8.1", "bowser": "^2.11.0", "tslib": "^2.6.2" } }, "sha512-qOJAERZ3Plj1st7M4Q5henl5FRpE30uLm6L9edZqZXGR6c7ry9jzexWamWVpQ4H4xVAVmiO9dIEBAfbq4mduOA=="],
+
+    "@aws-sdk/util-user-agent-node": ["@aws-sdk/util-user-agent-node@3.928.0", "", { "dependencies": { "@aws-sdk/middleware-user-agent": "3.928.0", "@aws-sdk/types": "3.922.0", "@smithy/node-config-provider": "^4.3.4", "@smithy/types": "^4.8.1", "tslib": "^2.6.2" }, "peerDependencies": { "aws-crt": ">=1.0.0" }, "optionalPeers": ["aws-crt"] }, "sha512-s0jP67nQLLWVWfBtqTkZUkSWK5e6OI+rs+wFya2h9VLyWBFir17XSDI891s8HZKIVCEl8eBrup+hhywm4nsIAA=="],
+
+    "@aws-sdk/xml-builder": ["@aws-sdk/xml-builder@3.921.0", "", { "dependencies": { "@smithy/types": "^4.8.1", "fast-xml-parser": "5.2.5", "tslib": "^2.6.2" } }, "sha512-LVHg0jgjyicKKvpNIEMXIMr1EBViESxcPkqfOlT+X1FkmUMTNZEEVF18tOJg4m4hV5vxtkWcqtr4IEeWa1C41Q=="],
+
+    "@aws/lambda-invoke-store": ["@aws/lambda-invoke-store@0.1.1", "", {}, "sha512-RcLam17LdlbSOSp9VxmUu1eI6Mwxp+OwhD2QhiSNmNCzoDb0EeUXTD2n/WbcnrAYMGlmf05th6QYq23VqvJqpA=="],
+
+    "@smithy/abort-controller": ["@smithy/abort-controller@4.2.5", "", { "dependencies": { "@smithy/types": "^4.9.0", "tslib": "^2.6.2" } }, "sha512-j7HwVkBw68YW8UmFRcjZOmssE77Rvk0GWAIN1oFBhsaovQmZWYCIcGa9/pwRB0ExI8Sk9MWNALTjftjHZea7VA=="],
+
+    "@smithy/chunked-blob-reader": ["@smithy/chunked-blob-reader@5.2.0", "", { "dependencies": { "tslib": "^2.6.2" } }, "sha512-WmU0TnhEAJLWvfSeMxBNe5xtbselEO8+4wG0NtZeL8oR21WgH1xiO37El+/Y+H/Ie4SCwBy3MxYWmOYaGgZueA=="],
+
+    "@smithy/chunked-blob-reader-native": ["@smithy/chunked-blob-reader-native@4.2.1", "", { "dependencies": { "@smithy/util-base64": "^4.3.0", "tslib": "^2.6.2" } }, "sha512-lX9Ay+6LisTfpLid2zZtIhSEjHMZoAR5hHCR4H7tBz/Zkfr5ea8RcQ7Tk4mi0P76p4cN+Btz16Ffno7YHpKXnQ=="],
+
+    "@smithy/config-resolver": ["@smithy/config-resolver@4.4.3", "", { "dependencies": { "@smithy/node-config-provider": "^4.3.5", "@smithy/types": "^4.9.0", "@smithy/util-config-provider": "^4.2.0", "@smithy/util-endpoints": "^3.2.5", "@smithy/util-middleware": "^4.2.5", "tslib": "^2.6.2" } }, "sha512-ezHLe1tKLUxDJo2LHtDuEDyWXolw8WGOR92qb4bQdWq/zKenO5BvctZGrVJBK08zjezSk7bmbKFOXIVyChvDLw=="],
+
+    "@smithy/core": ["@smithy/core@3.18.0", "", { "dependencies": { "@smithy/middleware-serde": "^4.2.5", "@smithy/protocol-http": "^5.3.5", "@smithy/types": "^4.9.0", "@smithy/util-base64": "^4.3.0", "@smithy/util-body-length-browser": "^4.2.0", "@smithy/util-middleware": "^4.2.5", "@smithy/util-stream": "^4.5.6", "@smithy/util-utf8": "^4.2.0", "@smithy/uuid": "^1.1.0", "tslib": "^2.6.2" } }, "sha512-vGSDXOJFZgOPTatSI1ly7Gwyy/d/R9zh2TO3y0JZ0uut5qQ88p9IaWaZYIWSSqtdekNM4CGok/JppxbAff4KcQ=="],
+
+    "@smithy/credential-provider-imds": ["@smithy/credential-provider-imds@4.2.5", "", { "dependencies": { "@smithy/node-config-provider": "^4.3.5", "@smithy/property-provider": "^4.2.5", "@smithy/types": "^4.9.0", "@smithy/url-parser": "^4.2.5", "tslib": "^2.6.2" } }, "sha512-BZwotjoZWn9+36nimwm/OLIcVe+KYRwzMjfhd4QT7QxPm9WY0HiOV8t/Wlh+HVUif0SBVV7ksq8//hPaBC/okQ=="],
+
+    "@smithy/eventstream-codec": ["@smithy/eventstream-codec@4.2.5", "", { "dependencies": { "@aws-crypto/crc32": "5.2.0", "@smithy/types": "^4.9.0", "@smithy/util-hex-encoding": "^4.2.0", "tslib": "^2.6.2" } }, "sha512-Ogt4Zi9hEbIP17oQMd68qYOHUzmH47UkK7q7Gl55iIm9oKt27MUGrC5JfpMroeHjdkOliOA4Qt3NQ1xMq/nrlA=="],
+
+    "@smithy/eventstream-serde-browser": ["@smithy/eventstream-serde-browser@4.2.5", "", { "dependencies": { "@smithy/eventstream-serde-universal": "^4.2.5", "@smithy/types": "^4.9.0", "tslib": "^2.6.2" } }, "sha512-HohfmCQZjppVnKX2PnXlf47CW3j92Ki6T/vkAT2DhBR47e89pen3s4fIa7otGTtrVxmj7q+IhH0RnC5kpR8wtw=="],
+
+    "@smithy/eventstream-serde-config-resolver": ["@smithy/eventstream-serde-config-resolver@4.3.5", "", { "dependencies": { "@smithy/types": "^4.9.0", "tslib": "^2.6.2" } }, "sha512-ibjQjM7wEXtECiT6my1xfiMH9IcEczMOS6xiCQXoUIYSj5b1CpBbJ3VYbdwDy8Vcg5JHN7eFpOCGk8nyZAltNQ=="],
+
+    "@smithy/eventstream-serde-node": ["@smithy/eventstream-serde-node@4.2.5", "", { "dependencies": { "@smithy/eventstream-serde-universal": "^4.2.5", "@smithy/types": "^4.9.0", "tslib": "^2.6.2" } }, "sha512-+elOuaYx6F2H6x1/5BQP5ugv12nfJl66GhxON8+dWVUEDJ9jah/A0tayVdkLRP0AeSac0inYkDz5qBFKfVp2Gg=="],
+
+    "@smithy/eventstream-serde-universal": ["@smithy/eventstream-serde-universal@4.2.5", "", { "dependencies": { "@smithy/eventstream-codec": "^4.2.5", "@smithy/types": "^4.9.0", "tslib": "^2.6.2" } }, "sha512-G9WSqbST45bmIFaeNuP/EnC19Rhp54CcVdX9PDL1zyEB514WsDVXhlyihKlGXnRycmHNmVv88Bvvt4EYxWef/Q=="],
+
+    "@smithy/fetch-http-handler": ["@smithy/fetch-http-handler@5.3.6", "", { "dependencies": { "@smithy/protocol-http": "^5.3.5", "@smithy/querystring-builder": "^4.2.5", "@smithy/types": "^4.9.0", "@smithy/util-base64": "^4.3.0", "tslib": "^2.6.2" } }, "sha512-3+RG3EA6BBJ/ofZUeTFJA7mHfSYrZtQIrDP9dI8Lf7X6Jbos2jptuLrAAteDiFVrmbEmLSuRG/bUKzfAXk7dhg=="],
+
+    "@smithy/hash-blob-browser": ["@smithy/hash-blob-browser@4.2.6", "", { "dependencies": { "@smithy/chunked-blob-reader": "^5.2.0", "@smithy/chunked-blob-reader-native": "^4.2.1", "@smithy/types": "^4.9.0", "tslib": "^2.6.2" } }, "sha512-8P//tA8DVPk+3XURk2rwcKgYwFvwGwmJH/wJqQiSKwXZtf/LiZK+hbUZmPj/9KzM+OVSwe4o85KTp5x9DUZTjw=="],
+
+    "@smithy/hash-node": ["@smithy/hash-node@4.2.5", "", { "dependencies": { "@smithy/types": "^4.9.0", "@smithy/util-buffer-from": "^4.2.0", "@smithy/util-utf8": "^4.2.0", "tslib": "^2.6.2" } }, "sha512-DpYX914YOfA3UDT9CN1BM787PcHfWRBB43fFGCYrZFUH0Jv+5t8yYl+Pd5PW4+QzoGEDvn5d5QIO4j2HyYZQSA=="],
+
+    "@smithy/hash-stream-node": ["@smithy/hash-stream-node@4.2.5", "", { "dependencies": { "@smithy/types": "^4.9.0", "@smithy/util-utf8": "^4.2.0", "tslib": "^2.6.2" } }, "sha512-6+do24VnEyvWcGdHXomlpd0m8bfZePpUKBy7m311n+JuRwug8J4dCanJdTymx//8mi0nlkflZBvJe+dEO/O12Q=="],
+
+    "@smithy/invalid-dependency": ["@smithy/invalid-dependency@4.2.5", "", { "dependencies": { "@smithy/types": "^4.9.0", "tslib": "^2.6.2" } }, "sha512-2L2erASEro1WC5nV+plwIMxrTXpvpfzl4e+Nre6vBVRR2HKeGGcvpJyyL3/PpiSg+cJG2KpTmZmq934Olb6e5A=="],
+
+    "@smithy/is-array-buffer": ["@smithy/is-array-buffer@4.2.0", "", { "dependencies": { "tslib": "^2.6.2" } }, "sha512-DZZZBvC7sjcYh4MazJSGiWMI2L7E0oCiRHREDzIxi/M2LY79/21iXt6aPLHge82wi5LsuRF5A06Ds3+0mlh6CQ=="],
+
+    "@smithy/md5-js": ["@smithy/md5-js@4.2.5", "", { "dependencies": { "@smithy/types": "^4.9.0", "@smithy/util-utf8": "^4.2.0", "tslib": "^2.6.2" } }, "sha512-Bt6jpSTMWfjCtC0s79gZ/WZ1w90grfmopVOWqkI2ovhjpD5Q2XRXuecIPB9689L2+cCySMbaXDhBPU56FKNDNg=="],
+
+    "@smithy/middleware-content-length": ["@smithy/middleware-content-length@4.2.5", "", { "dependencies": { "@smithy/protocol-http": "^5.3.5", "@smithy/types": "^4.9.0", "tslib": "^2.6.2" } }, "sha512-Y/RabVa5vbl5FuHYV2vUCwvh/dqzrEY/K2yWPSqvhFUwIY0atLqO4TienjBXakoy4zrKAMCZwg+YEqmH7jaN7A=="],
+
+    "@smithy/middleware-endpoint": ["@smithy/middleware-endpoint@4.3.7", "", { "dependencies": { "@smithy/core": "^3.18.0", "@smithy/middleware-serde": "^4.2.5", "@smithy/node-config-provider": "^4.3.5", "@smithy/shared-ini-file-loader": "^4.4.0", "@smithy/types": "^4.9.0", "@smithy/url-parser": "^4.2.5", "@smithy/util-middleware": "^4.2.5", "tslib": "^2.6.2" } }, "sha512-i8Mi8OuY6Yi82Foe3iu7/yhBj1HBRoOQwBSsUNYglJTNSFaWYTNM2NauBBs/7pq2sqkLRqeUXA3Ogi2utzpUlQ=="],
+
+    "@smithy/middleware-retry": ["@smithy/middleware-retry@4.4.7", "", { "dependencies": { "@smithy/node-config-provider": "^4.3.5", "@smithy/protocol-http": "^5.3.5", "@smithy/service-error-classification": "^4.2.5", "@smithy/smithy-client": "^4.9.3", "@smithy/types": "^4.9.0", "@smithy/util-middleware": "^4.2.5", "@smithy/util-retry": "^4.2.5", "@smithy/uuid": "^1.1.0", "tslib": "^2.6.2" } }, "sha512-E7Vc6WHCHlzDRTx1W0jZ6J1L6ziEV0PIWcUdmfL4y+c8r7WYr6I+LkQudaD8Nfb7C5c4P3SQ972OmXHtv6m/OA=="],
+
+    "@smithy/middleware-serde": ["@smithy/middleware-serde@4.2.5", "", { "dependencies": { "@smithy/protocol-http": "^5.3.5", "@smithy/types": "^4.9.0", "tslib": "^2.6.2" } }, "sha512-La1ldWTJTZ5NqQyPqnCNeH9B+zjFhrNoQIL1jTh4zuqXRlmXhxYHhMtI1/92OlnoAtp6JoN7kzuwhWoXrBwPqg=="],
+
+    "@smithy/middleware-stack": ["@smithy/middleware-stack@4.2.5", "", { "dependencies": { "@smithy/types": "^4.9.0", "tslib": "^2.6.2" } }, "sha512-bYrutc+neOyWxtZdbB2USbQttZN0mXaOyYLIsaTbJhFsfpXyGWUxJpEuO1rJ8IIJm2qH4+xJT0mxUSsEDTYwdQ=="],
+
+    "@smithy/node-config-provider": ["@smithy/node-config-provider@4.3.5", "", { "dependencies": { "@smithy/property-provider": "^4.2.5", "@smithy/shared-ini-file-loader": "^4.4.0", "@smithy/types": "^4.9.0", "tslib": "^2.6.2" } }, "sha512-UTurh1C4qkVCtqggI36DGbLB2Kv8UlcFdMXDcWMbqVY2uRg0XmT9Pb4Vj6oSQ34eizO1fvR0RnFV4Axw4IrrAg=="],
+
+    "@smithy/node-http-handler": ["@smithy/node-http-handler@4.4.5", "", { "dependencies": { "@smithy/abort-controller": "^4.2.5", "@smithy/protocol-http": "^5.3.5", "@smithy/querystring-builder": "^4.2.5", "@smithy/types": "^4.9.0", "tslib": "^2.6.2" } }, "sha512-CMnzM9R2WqlqXQGtIlsHMEZfXKJVTIrqCNoSd/QpAyp+Dw0a1Vps13l6ma1fH8g7zSPNsA59B/kWgeylFuA/lw=="],
+
+    "@smithy/property-provider": ["@smithy/property-provider@1.2.0", "", { "dependencies": { "@smithy/types": "^1.2.0", "tslib": "^2.5.0" } }, "sha512-qlJd9gT751i4T0t/hJAyNGfESfi08Fek8QiLcysoKPgR05qHhG0OYhlaCJHhpXy4ECW0lHyjvFM1smrCLIXVfw=="],
+
+    "@smithy/protocol-http": ["@smithy/protocol-http@5.3.5", "", { "dependencies": { "@smithy/types": "^4.9.0", "tslib": "^2.6.2" } }, "sha512-RlaL+sA0LNMp03bf7XPbFmT5gN+w3besXSWMkA8rcmxLSVfiEXElQi4O2IWwPfxzcHkxqrwBFMbngB8yx/RvaQ=="],
+
+    "@smithy/querystring-builder": ["@smithy/querystring-builder@4.2.5", "", { "dependencies": { "@smithy/types": "^4.9.0", "@smithy/util-uri-escape": "^4.2.0", "tslib": "^2.6.2" } }, "sha512-y98otMI1saoajeik2kLfGyRp11e5U/iJYH/wLCh3aTV/XutbGT9nziKGkgCaMD1ghK7p6htHMm6b6scl9JRUWg=="],
+
+    "@smithy/querystring-parser": ["@smithy/querystring-parser@4.2.5", "", { "dependencies": { "@smithy/types": "^4.9.0", "tslib": "^2.6.2" } }, "sha512-031WCTdPYgiQRYNPXznHXof2YM0GwL6SeaSyTH/P72M1Vz73TvCNH2Nq8Iu2IEPq9QP2yx0/nrw5YmSeAi/AjQ=="],
+
+    "@smithy/service-error-classification": ["@smithy/service-error-classification@4.2.5", "", { "dependencies": { "@smithy/types": "^4.9.0" } }, "sha512-8fEvK+WPE3wUAcDvqDQG1Vk3ANLR8Px979te96m84CbKAjBVf25rPYSzb4xU4hlTyho7VhOGnh5i62D/JVF0JQ=="],
+
+    "@smithy/shared-ini-file-loader": ["@smithy/shared-ini-file-loader@4.4.0", "", { "dependencies": { "@smithy/types": "^4.9.0", "tslib": "^2.6.2" } }, "sha512-5WmZ5+kJgJDjwXXIzr1vDTG+RhF9wzSODQBfkrQ2VVkYALKGvZX1lgVSxEkgicSAFnFhPj5rudJV0zoinqS0bA=="],
+
+    "@smithy/signature-v4": ["@smithy/signature-v4@5.3.5", "", { "dependencies": { "@smithy/is-array-buffer": "^4.2.0", "@smithy/protocol-http": "^5.3.5", "@smithy/types": "^4.9.0", "@smithy/util-hex-encoding": "^4.2.0", "@smithy/util-middleware": "^4.2.5", "@smithy/util-uri-escape": "^4.2.0", "@smithy/util-utf8": "^4.2.0", "tslib": "^2.6.2" } }, "sha512-xSUfMu1FT7ccfSXkoLl/QRQBi2rOvi3tiBZU2Tdy3I6cgvZ6SEi9QNey+lqps/sJRnogIS+lq+B1gxxbra2a/w=="],
+
+    "@smithy/smithy-client": ["@smithy/smithy-client@4.9.3", "", { "dependencies": { "@smithy/core": "^3.18.0", "@smithy/middleware-endpoint": "^4.3.7", "@smithy/middleware-stack": "^4.2.5", "@smithy/protocol-http": "^5.3.5", "@smithy/types": "^4.9.0", "@smithy/util-stream": "^4.5.6", "tslib": "^2.6.2" } }, "sha512-8tlueuTgV5n7inQCkhyptrB3jo2AO80uGrps/XTYZivv5MFQKKBj3CIWIGMI2fRY5LEduIiazOhAWdFknY1O9w=="],
+
+    "@smithy/types": ["@smithy/types@4.9.0", "", { "dependencies": { "tslib": "^2.6.2" } }, "sha512-MvUbdnXDTwykR8cB1WZvNNwqoWVaTRA0RLlLmf/cIFNMM2cKWz01X4Ly6SMC4Kks30r8tT3Cty0jmeWfiuyHTA=="],
+
+    "@smithy/url-parser": ["@smithy/url-parser@4.2.5", "", { "dependencies": { "@smithy/querystring-parser": "^4.2.5", "@smithy/types": "^4.9.0", "tslib": "^2.6.2" } }, "sha512-VaxMGsilqFnK1CeBX+LXnSuaMx4sTL/6znSZh2829txWieazdVxr54HmiyTsIbpOTLcf5nYpq9lpzmwRdxj6rQ=="],
+
+    "@smithy/util-base64": ["@smithy/util-base64@4.3.0", "", { "dependencies": { "@smithy/util-buffer-from": "^4.2.0", "@smithy/util-utf8": "^4.2.0", "tslib": "^2.6.2" } }, "sha512-GkXZ59JfyxsIwNTWFnjmFEI8kZpRNIBfxKjv09+nkAWPt/4aGaEWMM04m4sxgNVWkbt2MdSvE3KF/PfX4nFedQ=="],
+
+    "@smithy/util-body-length-browser": ["@smithy/util-body-length-browser@4.2.0", "", { "dependencies": { "tslib": "^2.6.2" } }, "sha512-Fkoh/I76szMKJnBXWPdFkQJl2r9SjPt3cMzLdOB6eJ4Pnpas8hVoWPYemX/peO0yrrvldgCUVJqOAjUrOLjbxg=="],
+
+    "@smithy/util-body-length-node": ["@smithy/util-body-length-node@4.2.1", "", { "dependencies": { "tslib": "^2.6.2" } }, "sha512-h53dz/pISVrVrfxV1iqXlx5pRg3V2YWFcSQyPyXZRrZoZj4R4DeWRDo1a7dd3CPTcFi3kE+98tuNyD2axyZReA=="],
+
+    "@smithy/util-buffer-from": ["@smithy/util-buffer-from@4.2.0", "", { "dependencies": { "@smithy/is-array-buffer": "^4.2.0", "tslib": "^2.6.2" } }, "sha512-kAY9hTKulTNevM2nlRtxAG2FQ3B2OR6QIrPY3zE5LqJy1oxzmgBGsHLWTcNhWXKchgA0WHW+mZkQrng/pgcCew=="],
+
+    "@smithy/util-config-provider": ["@smithy/util-config-provider@4.2.0", "", { "dependencies": { "tslib": "^2.6.2" } }, "sha512-YEjpl6XJ36FTKmD+kRJJWYvrHeUvm5ykaUS5xK+6oXffQPHeEM4/nXlZPe+Wu0lsgRUcNZiliYNh/y7q9c2y6Q=="],
+
+    "@smithy/util-defaults-mode-browser": ["@smithy/util-defaults-mode-browser@4.3.6", "", { "dependencies": { "@smithy/property-provider": "^4.2.5", "@smithy/smithy-client": "^4.9.3", "@smithy/types": "^4.9.0", "tslib": "^2.6.2" } }, "sha512-kbpuXbEf2YQ9zEE6eeVnUCQWO0e1BjMnKrXL8rfXgiWA0m8/E0leU4oSNzxP04WfCmW8vjEqaDeXWxwE4tpOjQ=="],
+
+    "@smithy/util-defaults-mode-node": ["@smithy/util-defaults-mode-node@4.2.9", "", { "dependencies": { "@smithy/config-resolver": "^4.4.3", "@smithy/credential-provider-imds": "^4.2.5", "@smithy/node-config-provider": "^4.3.5", "@smithy/property-provider": "^4.2.5", "@smithy/smithy-client": "^4.9.3", "@smithy/types": "^4.9.0", "tslib": "^2.6.2" } }, "sha512-dgyribrVWN5qE5usYJ0m5M93mVM3L3TyBPZWe1Xl6uZlH2gzfQx3dz+ZCdW93lWqdedJRkOecnvbnoEEXRZ5VQ=="],
+
+    "@smithy/util-endpoints": ["@smithy/util-endpoints@3.2.5", "", { "dependencies": { "@smithy/node-config-provider": "^4.3.5", "@smithy/types": "^4.9.0", "tslib": "^2.6.2" } }, "sha512-3O63AAWu2cSNQZp+ayl9I3NapW1p1rR5mlVHcF6hAB1dPZUQFfRPYtplWX/3xrzWthPGj5FqB12taJJCfH6s8A=="],
+
+    "@smithy/util-hex-encoding": ["@smithy/util-hex-encoding@4.2.0", "", { "dependencies": { "tslib": "^2.6.2" } }, "sha512-CCQBwJIvXMLKxVbO88IukazJD9a4kQ9ZN7/UMGBjBcJYvatpWk+9g870El4cB8/EJxfe+k+y0GmR9CAzkF+Nbw=="],
+
+    "@smithy/util-middleware": ["@smithy/util-middleware@4.2.5", "", { "dependencies": { "@smithy/types": "^4.9.0", "tslib": "^2.6.2" } }, "sha512-6Y3+rvBF7+PZOc40ybeZMcGln6xJGVeY60E7jy9Mv5iKpMJpHgRE6dKy9ScsVxvfAYuEX4Q9a65DQX90KaQ3bA=="],
+
+    "@smithy/util-retry": ["@smithy/util-retry@4.2.5", "", { "dependencies": { "@smithy/service-error-classification": "^4.2.5", "@smithy/types": "^4.9.0", "tslib": "^2.6.2" } }, "sha512-GBj3+EZBbN4NAqJ/7pAhsXdfzdlznOh8PydUijy6FpNIMnHPSMO2/rP4HKu+UFeikJxShERk528oy7GT79YiJg=="],
+
+    "@smithy/util-stream": ["@smithy/util-stream@4.5.6", "", { "dependencies": { "@smithy/fetch-http-handler": "^5.3.6", "@smithy/node-http-handler": "^4.4.5", "@smithy/types": "^4.9.0", "@smithy/util-base64": "^4.3.0", "@smithy/util-buffer-from": "^4.2.0", "@smithy/util-hex-encoding": "^4.2.0", "@smithy/util-utf8": "^4.2.0", "tslib": "^2.6.2" } }, "sha512-qWw/UM59TiaFrPevefOZ8CNBKbYEP6wBAIlLqxn3VAIo9rgnTNc4ASbVrqDmhuwI87usnjhdQrxodzAGFFzbRQ=="],
+
+    "@smithy/util-uri-escape": ["@smithy/util-uri-escape@4.2.0", "", { "dependencies": { "tslib": "^2.6.2" } }, "sha512-igZpCKV9+E/Mzrpq6YacdTQ0qTiLm85gD6N/IrmyDvQFA4UnU3d5g3m8tMT/6zG/vVkWSU+VxeUyGonL62DuxA=="],
+
+    "@smithy/util-utf8": ["@smithy/util-utf8@4.2.0", "", { "dependencies": { "@smithy/util-buffer-from": "^4.2.0", "tslib": "^2.6.2" } }, "sha512-zBPfuzoI8xyBtR2P6WQj63Rz8i3AmfAaJLuNG8dWsfvPe8lO4aCPYLn879mEgHndZH1zQ2oXmG8O1GGzzaoZiw=="],
+
+    "@smithy/util-waiter": ["@smithy/util-waiter@4.2.5", "", { "dependencies": { "@smithy/abort-controller": "^4.2.5", "@smithy/types": "^4.9.0", "tslib": "^2.6.2" } }, "sha512-Dbun99A3InifQdIrsXZ+QLcC0PGBPAdrl4cj1mTgJvyc9N2zf7QSxg8TBkzsCmGJdE3TLbO9ycwpY0EkWahQ/g=="],
+
+    "@smithy/uuid": ["@smithy/uuid@1.1.0", "", { "dependencies": { "tslib": "^2.6.2" } }, "sha512-4aUIteuyxtBUhVdiQqcDhKFitwfd9hqoSDYY2KRXiWtgoWJ9Bmise+KfEPDiVHWeJepvF8xJO9/9+WDIciMFFw=="],
+
+    "bowser": ["bowser@2.12.1", "", {}, "sha512-z4rE2Gxh7tvshQ4hluIT7XcFrgLIQaw9X3A+kTTRdovCz5PMukm/0QC/BKSYPj3omF5Qfypn9O/c5kgpmvYUCw=="],
+
+    "fast-xml-parser": ["fast-xml-parser@5.2.5", "", { "dependencies": { "strnum": "^2.1.0" }, "bin": { "fxparser": "src/cli/cli.js" } }, "sha512-pfX9uG9Ki0yekDHx2SiuRIyFdyAr1kMIMitPvb0YBo8SUfKvia7w7FIyd/l6av85pFYRhZscS75MwMnbvY+hcQ=="],
+
+    "strnum": ["strnum@2.1.1", "", {}, "sha512-7ZvoFTiCnGxBtDqJ//Cu6fWtZtc7Y3x+QOirG15wztbdngGSkht27o2pyGWrVy0b4WAy3jbKmnoK6g5VlVNUUw=="],
+
+    "tslib": ["tslib@2.8.1", "", {}, "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w=="],
+
+    "@aws-crypto/sha1-browser/@smithy/util-utf8": ["@smithy/util-utf8@2.3.0", "", { "dependencies": { "@smithy/util-buffer-from": "^2.2.0", "tslib": "^2.6.2" } }, "sha512-R8Rdn8Hy72KKcebgLiv8jQcQkXoLMOGGv5uI1/k0l+snqkOzQ1R0ChUBCxWMlBsFMekWjq0wRudIweFs7sKT5A=="],
+
+    "@aws-crypto/sha256-browser/@smithy/util-utf8": ["@smithy/util-utf8@2.3.0", "", { "dependencies": { "@smithy/util-buffer-from": "^2.2.0", "tslib": "^2.6.2" } }, "sha512-R8Rdn8Hy72KKcebgLiv8jQcQkXoLMOGGv5uI1/k0l+snqkOzQ1R0ChUBCxWMlBsFMekWjq0wRudIweFs7sKT5A=="],
+
+    "@aws-crypto/util/@smithy/util-utf8": ["@smithy/util-utf8@2.3.0", "", { "dependencies": { "@smithy/util-buffer-from": "^2.2.0", "tslib": "^2.6.2" } }, "sha512-R8Rdn8Hy72KKcebgLiv8jQcQkXoLMOGGv5uI1/k0l+snqkOzQ1R0ChUBCxWMlBsFMekWjq0wRudIweFs7sKT5A=="],
+
+    "@aws-sdk/core/@smithy/property-provider": ["@smithy/property-provider@4.2.5", "", { "dependencies": { "@smithy/types": "^4.9.0", "tslib": "^2.6.2" } }, "sha512-8iLN1XSE1rl4MuxvQ+5OSk/Zb5El7NJZ1td6Tn+8dQQHIjp59Lwl6bd0+nzw6SKm2wSSriH2v/I9LPzUic7EOg=="],
+
+    "@aws-sdk/credential-provider-env/@smithy/property-provider": ["@smithy/property-provider@4.2.5", "", { "dependencies": { "@smithy/types": "^4.9.0", "tslib": "^2.6.2" } }, "sha512-8iLN1XSE1rl4MuxvQ+5OSk/Zb5El7NJZ1td6Tn+8dQQHIjp59Lwl6bd0+nzw6SKm2wSSriH2v/I9LPzUic7EOg=="],
+
+    "@aws-sdk/credential-provider-http/@smithy/property-provider": ["@smithy/property-provider@4.2.5", "", { "dependencies": { "@smithy/types": "^4.9.0", "tslib": "^2.6.2" } }, "sha512-8iLN1XSE1rl4MuxvQ+5OSk/Zb5El7NJZ1td6Tn+8dQQHIjp59Lwl6bd0+nzw6SKm2wSSriH2v/I9LPzUic7EOg=="],
+
+    "@aws-sdk/credential-provider-ini/@smithy/property-provider": ["@smithy/property-provider@4.2.5", "", { "dependencies": { "@smithy/types": "^4.9.0", "tslib": "^2.6.2" } }, "sha512-8iLN1XSE1rl4MuxvQ+5OSk/Zb5El7NJZ1td6Tn+8dQQHIjp59Lwl6bd0+nzw6SKm2wSSriH2v/I9LPzUic7EOg=="],
+
+    "@aws-sdk/credential-provider-node/@smithy/property-provider": ["@smithy/property-provider@4.2.5", "", { "dependencies": { "@smithy/types": "^4.9.0", "tslib": "^2.6.2" } }, "sha512-8iLN1XSE1rl4MuxvQ+5OSk/Zb5El7NJZ1td6Tn+8dQQHIjp59Lwl6bd0+nzw6SKm2wSSriH2v/I9LPzUic7EOg=="],
+
+    "@aws-sdk/credential-provider-process/@smithy/property-provider": ["@smithy/property-provider@4.2.5", "", { "dependencies": { "@smithy/types": "^4.9.0", "tslib": "^2.6.2" } }, "sha512-8iLN1XSE1rl4MuxvQ+5OSk/Zb5El7NJZ1td6Tn+8dQQHIjp59Lwl6bd0+nzw6SKm2wSSriH2v/I9LPzUic7EOg=="],
+
+    "@aws-sdk/credential-provider-sso/@smithy/property-provider": ["@smithy/property-provider@4.2.5", "", { "dependencies": { "@smithy/types": "^4.9.0", "tslib": "^2.6.2" } }, "sha512-8iLN1XSE1rl4MuxvQ+5OSk/Zb5El7NJZ1td6Tn+8dQQHIjp59Lwl6bd0+nzw6SKm2wSSriH2v/I9LPzUic7EOg=="],
+
+    "@aws-sdk/credential-provider-web-identity/@smithy/property-provider": ["@smithy/property-provider@4.2.5", "", { "dependencies": { "@smithy/types": "^4.9.0", "tslib": "^2.6.2" } }, "sha512-8iLN1XSE1rl4MuxvQ+5OSk/Zb5El7NJZ1td6Tn+8dQQHIjp59Lwl6bd0+nzw6SKm2wSSriH2v/I9LPzUic7EOg=="],
+
+    "@aws-sdk/token-providers/@smithy/property-provider": ["@smithy/property-provider@4.2.5", "", { "dependencies": { "@smithy/types": "^4.9.0", "tslib": "^2.6.2" } }, "sha512-8iLN1XSE1rl4MuxvQ+5OSk/Zb5El7NJZ1td6Tn+8dQQHIjp59Lwl6bd0+nzw6SKm2wSSriH2v/I9LPzUic7EOg=="],
+
+    "@smithy/credential-provider-imds/@smithy/property-provider": ["@smithy/property-provider@4.2.5", "", { "dependencies": { "@smithy/types": "^4.9.0", "tslib": "^2.6.2" } }, "sha512-8iLN1XSE1rl4MuxvQ+5OSk/Zb5El7NJZ1td6Tn+8dQQHIjp59Lwl6bd0+nzw6SKm2wSSriH2v/I9LPzUic7EOg=="],
+
+    "@smithy/node-config-provider/@smithy/property-provider": ["@smithy/property-provider@4.2.5", "", { "dependencies": { "@smithy/types": "^4.9.0", "tslib": "^2.6.2" } }, "sha512-8iLN1XSE1rl4MuxvQ+5OSk/Zb5El7NJZ1td6Tn+8dQQHIjp59Lwl6bd0+nzw6SKm2wSSriH2v/I9LPzUic7EOg=="],
+
+    "@smithy/property-provider/@smithy/types": ["@smithy/types@1.2.0", "", { "dependencies": { "tslib": "^2.5.0" } }, "sha512-z1r00TvBqF3dh4aHhya7nz1HhvCg4TRmw51fjMrh5do3h+ngSstt/yKlNbHeb9QxJmFbmN8KEVSWgb1bRvfEoA=="],
+
+    "@smithy/util-defaults-mode-browser/@smithy/property-provider": ["@smithy/property-provider@4.2.5", "", { "dependencies": { "@smithy/types": "^4.9.0", "tslib": "^2.6.2" } }, "sha512-8iLN1XSE1rl4MuxvQ+5OSk/Zb5El7NJZ1td6Tn+8dQQHIjp59Lwl6bd0+nzw6SKm2wSSriH2v/I9LPzUic7EOg=="],
+
+    "@smithy/util-defaults-mode-node/@smithy/property-provider": ["@smithy/property-provider@4.2.5", "", { "dependencies": { "@smithy/types": "^4.9.0", "tslib": "^2.6.2" } }, "sha512-8iLN1XSE1rl4MuxvQ+5OSk/Zb5El7NJZ1td6Tn+8dQQHIjp59Lwl6bd0+nzw6SKm2wSSriH2v/I9LPzUic7EOg=="],
+
+    "@aws-crypto/sha1-browser/@smithy/util-utf8/@smithy/util-buffer-from": ["@smithy/util-buffer-from@2.2.0", "", { "dependencies": { "@smithy/is-array-buffer": "^2.2.0", "tslib": "^2.6.2" } }, "sha512-IJdWBbTcMQ6DA0gdNhh/BwrLkDR+ADW5Kr1aZmd4k3DIF6ezMV4R2NIAmT08wQJ3yUK82thHWmC/TnK/wpMMIA=="],
+
+    "@aws-crypto/sha256-browser/@smithy/util-utf8/@smithy/util-buffer-from": ["@smithy/util-buffer-from@2.2.0", "", { "dependencies": { "@smithy/is-array-buffer": "^2.2.0", "tslib": "^2.6.2" } }, "sha512-IJdWBbTcMQ6DA0gdNhh/BwrLkDR+ADW5Kr1aZmd4k3DIF6ezMV4R2NIAmT08wQJ3yUK82thHWmC/TnK/wpMMIA=="],
+
+    "@aws-crypto/util/@smithy/util-utf8/@smithy/util-buffer-from": ["@smithy/util-buffer-from@2.2.0", "", { "dependencies": { "@smithy/is-array-buffer": "^2.2.0", "tslib": "^2.6.2" } }, "sha512-IJdWBbTcMQ6DA0gdNhh/BwrLkDR+ADW5Kr1aZmd4k3DIF6ezMV4R2NIAmT08wQJ3yUK82thHWmC/TnK/wpMMIA=="],
+
+    "@aws-crypto/sha1-browser/@smithy/util-utf8/@smithy/util-buffer-from/@smithy/is-array-buffer": ["@smithy/is-array-buffer@2.2.0", "", { "dependencies": { "tslib": "^2.6.2" } }, "sha512-GGP3O9QFD24uGeAXYUjwSTXARoqpZykHadOmA8G5vfJPK0/DC67qa//0qvqrJzL1xc8WQWX7/yc7fwudjPHPhA=="],
+
+    "@aws-crypto/sha256-browser/@smithy/util-utf8/@smithy/util-buffer-from/@smithy/is-array-buffer": ["@smithy/is-array-buffer@2.2.0", "", { "dependencies": { "tslib": "^2.6.2" } }, "sha512-GGP3O9QFD24uGeAXYUjwSTXARoqpZykHadOmA8G5vfJPK0/DC67qa//0qvqrJzL1xc8WQWX7/yc7fwudjPHPhA=="],
+
+    "@aws-crypto/util/@smithy/util-utf8/@smithy/util-buffer-from/@smithy/is-array-buffer": ["@smithy/is-array-buffer@2.2.0", "", { "dependencies": { "tslib": "^2.6.2" } }, "sha512-GGP3O9QFD24uGeAXYUjwSTXARoqpZykHadOmA8G5vfJPK0/DC67qa//0qvqrJzL1xc8WQWX7/yc7fwudjPHPhA=="],
+  }
+}

scripts/build-cache/have-access.ts

@@ -0,0 +1,82 @@
+/**
+ * Test whether the current user has access to the Bun build-cache.
+ *
+ * Exits with code 0 if access is available, or 1 otherwise.
+ */
+import { HeadBucketCommand, S3Client } from "@aws-sdk/client-s3";
+import { CredentialsProviderError } from "@aws-sdk/property-provider";
+
+class CacheConfig {
+  #bucket: string;
+  #region: string;
+
+  get bucket(): string {
+    return this.#bucket;
+  }
+
+  get region(): string {
+    return this.#region;
+  }
+
+  static fromArgv(): CacheConfig {
+    const cacheConfig = new CacheConfig();
+
+    const exitWithHelp = (reason: string) => {
+      console.error(`Error: ${reason}\n`);
+      console.error("Usage: have-access --bucket <bucket-name> --region <region>");
+      process.exit(1);
+    };
+
+    for (let i = 2; i < process.argv.length; i++) {
+      switch (process.argv[i]) {
+        case "-b":
+        case "--bucket":
+          cacheConfig.#bucket = process.argv[++i];
+          break;
+        case "-r":
+        case "--region":
+          cacheConfig.#region = process.argv[++i];
+          break;
+        default:
+          exitWithHelp(`Unknown argument: ${process.argv[i]}`);
+      }
+    }
+
+    if (!cacheConfig.#bucket) {
+      exitWithHelp("Missing required argument: --bucket");
+    }
+
+    if (!cacheConfig.#region) {
+      exitWithHelp("Missing required argument: --region");
+    }
+
+    return cacheConfig;
+  }
+}
+
+/**
+ * Test whether the current user has access to the Bun build-cache.
+ */
+async function currentUserHasAccess(cacheConfig: CacheConfig): Promise<boolean> {
+  const s3Client = new S3Client({ region: cacheConfig.region });
+
+  try {
+    await s3Client.send(new HeadBucketCommand({ Bucket: cacheConfig.bucket }));
+    return true;
+  } catch (error) {
+    if (
+      error.name === "NotFound" ||
+      error.$metadata?.httpStatusCode === 404 ||
+      error.name === "Forbidden" ||
+      error.$metadata?.httpStatusCode === 403 ||
+      error instanceof CredentialsProviderError
+    ) {
+      return false;
+    }
+
+    throw error;
+  }
+}
+
+const ok = await currentUserHasAccess(CacheConfig.fromArgv());
+process.exit(ok ? 0 : 1);

scripts/build-cache/package.json

@@ -0,0 +1,6 @@
+{
+  "dependencies": {
+    "@aws-sdk/client-s3": "^3.928.0",
+    "@aws-sdk/property-provider": "^3.374.0"
+  }
+}

scripts/build.mjs

@@ -108,8 +108,8 @@ async function build(args) {
   await startGroup("CMake Build", () => spawn("cmake", buildArgs, { env }));
 
   if (ciCppBuild) {
-    await startGroup("ccache stats", () => {
-      spawn("ccache", ["--show-stats"], { env });
+    await startGroup("sccache stats", () => {
+      spawn("sccache", ["--show-stats"], { env });
     });
   }
 

scripts/create-link-metadata.mjs

@@ -1,50 +0,0 @@
-#!/usr/bin/env bun
-/**
- * Creates link-metadata.json with link command and build metadata
- *
- * Usage: bun scripts/create-link-metadata.mjs <build-path> <bun-target>
- */
-
-import { $ } from "bun";
-import { dirname, join } from "path";
-
-const [buildPath, bunTarget] = process.argv.slice(2);
-
-if (!buildPath || !bunTarget) {
-  console.error("Usage: bun scripts/create-link-metadata.mjs <build-path> <bun-target>");
-  process.exit(1);
-}
-
-// Get the repo root (parent of scripts directory)
-const repoRoot = dirname(import.meta.dir);
-
-// Extract link command using ninja
-console.log("Extracting link command...");
-const linkCommandResult = await $`ninja -C ${buildPath} -t commands ${bunTarget}`.quiet();
-const linkCommand = linkCommandResult.stdout.toString().trim();
-
-// Read linker-related files from src/
-console.log("Reading linker files...");
-const linkerLds = await Bun.file(join(repoRoot, "src", "linker.lds")).text();
-const symbolsDyn = await Bun.file(join(repoRoot, "src", "symbols.dyn")).text();
-const symbolsTxt = await Bun.file(join(repoRoot, "src", "symbols.txt")).text();
-
-// Create metadata JSON with link command included
-const metadata = {
-  bun_version: process.env.BUN_VERSION || "",
-  webkit_url: process.env.WEBKIT_DOWNLOAD_URL || "",
-  webkit_version: process.env.WEBKIT_VERSION || "",
-  zig_commit: process.env.ZIG_COMMIT || "",
-  target: bunTarget,
-  timestamp: new Date().toISOString(),
-  link_command: linkCommand,
-  linker_lds: linkerLds,
-  symbols_dyn: symbolsDyn,
-  symbols_txt: symbolsTxt,
-};
-
-const metadataPath = join(buildPath, "link-metadata.json");
-await Bun.write(metadataPath, JSON.stringify(metadata, null, 2));
-console.log(`Written to ${metadataPath}`);
-
-console.log("Done");

scripts/machine.mjs

@@ -387,6 +387,9 @@ const aws = {
         owner = "amazon";
         name = `Windows_Server-${release || "*"}-English-Full-Base-*`;
       }
+    } else if (os === "freebsd") {
+      owner = "782442783595"; // upstream member of FreeBSD team, likely Colin Percival
+      name = `FreeBSD ${release}-STABLE-${{ "aarch64": "arm64", "x64": "amd64" }[arch] ?? "amd64"}-* UEFI-PREFERRED cloud-init UFS`;
     }
 
     if (!name) {
@@ -673,6 +676,10 @@ function getCloudInit(cloudInit) {
     case "windows":
       // handled above
       break;
+    case "freebsd":
+      sftpPath = "/usr/libexec/openssh/sftp-server";
+      shell = "/bin/csh";
+      break;
     default:
       throw new Error(`Unsupported os: ${cloudInit["os"]}`);
   }
@@ -1064,7 +1071,7 @@ function getCloud(name) {
 }
 
 /**
- * @typedef {"linux" | "darwin" | "windows"} Os
+ * @typedef {"linux" | "darwin" | "windows" | "freebsd"} Os
  * @typedef {"aarch64" | "x64"} Arch
  * @typedef {"macos" | "windowsserver" | "debian" | "ubuntu" | "alpine" | "amazonlinux"} Distro
  */

scripts/utils.mjs

@@ -1538,7 +1538,7 @@ export function parseNumber(value) {
 
 /**
  * @param {string} string
- * @returns {"darwin" | "linux" | "windows"}
+ * @returns {"darwin" | "linux" | "windows" | "freebsd"}
  */
 export function parseOs(string) {
   if (/darwin|apple|mac/i.test(string)) {
@@ -1550,6 +1550,9 @@ export function parseOs(string) {
   if (/win/i.test(string)) {
     return "windows";
   }
+  if (/freebsd/i.test(string)) {
+    return "freebsd";
+  }
   throw new Error(`Unsupported operating system: ${string}`);
 }
 
@@ -1912,6 +1915,10 @@ export function getUsernameForDistro(distro) {
   if (/amazon|amzn|al\d+|rhel/i.test(distro)) {
     return "ec2-user";
   }
+  if (/freebsd/i.test(distro)) {
+    return "root";
+  }
+
   throw new Error(`Unsupported distro: ${distro}`);
 }
 
@@ -2979,6 +2986,7 @@ const emojiMap = {
   gear: ["⚙️", "gear"],
   clipboard: ["📋", "clipboard"],
   rocket: ["🚀", "rocket"],
+  freebsd: ["😈", "freebsd"],
   openbsd: ["🐡", "openbsd"],
   netbsd: ["🚩", "netbsd"],
 };

shell.nix

@@ -17,7 +17,7 @@ pkgs.mkShell rec {
     cargo
     go
     python3
-    ccache
+    sccache
     pkg-config
     gnumake
     libtool

src/allocators/LinuxMemFdAllocator.zig

@@ -132,7 +132,7 @@ pub fn create(bytes: []const u8) bun.sys.Maybe(bun.webcore.Blob.Store.Bytes) {
     const label = std.fmt.bufPrintZ(&label_buf, "memfd-num-{d}", .{memfd_counter.fetchAdd(1, .monotonic)}) catch "";
 
     // Using huge pages was slower.
-    const fd = switch (bun.sys.memfd_create(label, .non_executable)) {
+    const fd = switch (bun.sys.memfd_create(label, std.os.linux.MFD.CLOEXEC)) {
         .err => |err| return .{ .err = bun.sys.Error.fromCode(err.getErrno(), .open) },
         .result => |fd| fd,
     };

src/api/schema.zig

@@ -1655,9 +1655,6 @@ pub const api = struct {
 
         drop: []const []const u8 = &.{},
 
-        /// feature_flags for dead-code elimination via `import { feature } from "bun:bundle"`
-        feature_flags: []const []const u8 = &.{},
-
         /// preserve_symlinks
         preserve_symlinks: ?bool = null,
 

src/ast/ConvertESMExportsForHmr.zig

@@ -296,7 +296,7 @@ fn deduplicatedImport(
         // Disable this one since an older record is getting used.  It isn't
         // practical to delete this import record entry since an import or
         // require expression can exist.
-        ir.flags.is_unused = true;
+        ir.is_unused = true;
 
         const stmt = ctx.stmts.items[gop.value_ptr.stmt_index].data.s_import;
         if (items.len > 0) {

src/ast/Expr.zig

@@ -312,9 +312,8 @@ pub fn getObject(expr: *const Expr, name: string) ?Expr {
 
 pub fn getBoolean(expr: *const Expr, name: string) ?bool {
     if (expr.asProperty(name)) |query| {
-        switch (query.expr.data) {
-            .e_boolean, .e_branch_boolean => |b| return b.value,
-            else => {},
+        if (query.expr.data == .e_boolean) {
+            return query.expr.data.e_boolean.value;
         }
     }
     return null;
@@ -511,10 +510,9 @@ pub inline fn asStringZ(expr: *const Expr, allocator: std.mem.Allocator) OOM!?st
 pub fn asBool(
     expr: *const Expr,
 ) ?bool {
-    return switch (expr.data) {
-        .e_boolean, .e_branch_boolean => |b| b.value,
-        else => null,
-    };
+    if (expr.data != .e_boolean) return null;
+
+    return expr.data.e_boolean.value;
 }
 
 pub fn asNumber(expr: *const Expr) ?f64 {
@@ -617,7 +615,7 @@ pub fn joinAllWithCommaCallback(all: []Expr, comptime Context: type, ctx: Contex
             return callback(ctx, all[0]);
         },
         2 => {
-            const result = Expr.joinWithComma(
+            return Expr.joinWithComma(
                 callback(ctx, all[0]) orelse Expr{
                     .data = .{ .e_missing = .{} },
                     .loc = all[0].loc,
@@ -628,10 +626,6 @@ pub fn joinAllWithCommaCallback(all: []Expr, comptime Context: type, ctx: Contex
                 },
                 allocator,
             );
-            if (result.isMissing()) {
-                return null;
-            }
-            return result;
         },
         else => {
             var i: usize = 1;
@@ -647,9 +641,6 @@ pub fn joinAllWithCommaCallback(all: []Expr, comptime Context: type, ctx: Contex
                 }, allocator);
             }
 
-            if (expr.isMissing()) {
-                return null;
-            }
             return expr;
         },
     }
@@ -1499,11 +1490,6 @@ pub const Tag = enum {
     e_private_identifier,
     e_commonjs_export_identifier,
     e_boolean,
-    /// Like e_boolean, but produced by `feature()` from `bun:bundle`.
-    /// This tag ensures feature() can only be used directly in conditional
-    /// contexts (if statements, ternaries). Invalid usage is caught during
-    /// the visit phase when this expression appears outside a branch condition.
-    e_branch_boolean,
     e_number,
     e_big_int,
     e_string,
@@ -1527,7 +1513,7 @@ pub const Tag = enum {
     // object, regex and array may have had side effects
     pub fn isPrimitiveLiteral(tag: Tag) bool {
         return switch (tag) {
-            .e_null, .e_undefined, .e_string, .e_boolean, .e_branch_boolean, .e_number, .e_big_int => true,
+            .e_null, .e_undefined, .e_string, .e_boolean, .e_number, .e_big_int => true,
             else => false,
         };
     }
@@ -1536,7 +1522,7 @@ pub const Tag = enum {
         return switch (tag) {
             .e_array, .e_object, .e_null, .e_reg_exp => "object",
             .e_undefined => "undefined",
-            .e_boolean, .e_branch_boolean => "boolean",
+            .e_boolean => "boolean",
             .e_number => "number",
             .e_big_int => "bigint",
             .e_string => "string",
@@ -1551,7 +1537,7 @@ pub const Tag = enum {
             .e_array => writer.writeAll("array"),
             .e_unary => writer.writeAll("unary"),
             .e_binary => writer.writeAll("binary"),
-            .e_boolean, .e_branch_boolean => writer.writeAll("boolean"),
+            .e_boolean => writer.writeAll("boolean"),
             .e_super => writer.writeAll("super"),
             .e_null => writer.writeAll("null"),
             .e_undefined => writer.writeAll("undefined"),
@@ -1641,7 +1627,14 @@ pub const Tag = enum {
         }
     }
     pub fn isBoolean(self: Tag) bool {
-        return self == .e_boolean or self == .e_branch_boolean;
+        switch (self) {
+            .e_boolean => {
+                return true;
+            },
+            else => {
+                return false;
+            },
+        }
     }
     pub fn isSuper(self: Tag) bool {
         switch (self) {
@@ -1928,7 +1921,7 @@ pub const Tag = enum {
 
 pub fn isBoolean(a: *const Expr) bool {
     return switch (a.data) {
-        .e_boolean, .e_branch_boolean => true,
+        .e_boolean => true,
         .e_if => |ex| ex.yes.isBoolean() and ex.no.isBoolean(),
         .e_unary => |ex| ex.op == .un_not or ex.op == .un_delete,
         .e_binary => |ex| switch (ex.op) {
@@ -1985,8 +1978,8 @@ pub fn maybeSimplifyNot(expr: *const Expr, allocator: std.mem.Allocator) ?Expr {
         .e_null, .e_undefined => {
             return expr.at(E.Boolean, E.Boolean{ .value = true }, allocator);
         },
-        .e_boolean, .e_branch_boolean => |b| {
-            return expr.at(E.Boolean, E.Boolean{ .value = !b.value }, allocator);
+        .e_boolean => |b| {
+            return expr.at(E.Boolean, E.Boolean{ .value = b.value }, allocator);
         },
         .e_number => |n| {
             return expr.at(E.Boolean, E.Boolean{ .value = (n.value == 0 or std.math.isNan(n.value)) }, allocator);
@@ -2056,7 +2049,7 @@ pub fn toStringExprWithoutSideEffects(expr: *const Expr, allocator: std.mem.Allo
         .e_null => "null",
         .e_string => return expr.*,
         .e_undefined => "undefined",
-        .e_boolean, .e_branch_boolean => |data| if (data.value) "true" else "false",
+        .e_boolean => |data| if (data.value) "true" else "false",
         .e_big_int => |bigint| bigint.value,
         .e_number => |num| if (num.toString(allocator)) |str|
             str
@@ -2158,7 +2151,6 @@ pub const Data = union(Tag) {
     e_commonjs_export_identifier: E.CommonJSExportIdentifier,
 
     e_boolean: E.Boolean,
-    e_branch_boolean: E.Boolean,
     e_number: E.Number,
     e_big_int: *E.BigInt,
     e_string: *E.String,
@@ -2597,7 +2589,7 @@ pub const Data = union(Tag) {
                 const symbol = e.ref.getSymbol(symbol_table);
                 hasher.update(symbol.original_name);
             },
-            inline .e_boolean, .e_branch_boolean, .e_number => |e| {
+            inline .e_boolean, .e_number => |e| {
                 writeAnyToHasher(hasher, e.value);
             },
             inline .e_big_int, .e_reg_exp => |e| {
@@ -2651,7 +2643,6 @@ pub const Data = union(Tag) {
         return switch (this) {
             .e_number,
             .e_boolean,
-            .e_branch_boolean,
             .e_null,
             .e_undefined,
             .e_inlined_enum,
@@ -2680,7 +2671,6 @@ pub const Data = union(Tag) {
 
             .e_number,
             .e_boolean,
-            .e_branch_boolean,
             .e_null,
             .e_undefined,
             // .e_reg_exp,
@@ -2706,7 +2696,7 @@ pub const Data = union(Tag) {
             // rope strings can throw when toString is called.
             .e_string => |str| str.next == null,
 
-            .e_number, .e_boolean, .e_branch_boolean, .e_undefined, .e_null => true,
+            .e_number, .e_boolean, .e_undefined, .e_null => true,
             // BigInt is deliberately excluded as a large enough BigInt could throw an out of memory error.
             //
 
@@ -2717,7 +2707,7 @@ pub const Data = union(Tag) {
     pub fn knownPrimitive(data: Expr.Data) PrimitiveType {
         return switch (data) {
             .e_big_int => .bigint,
-            .e_boolean, .e_branch_boolean => .boolean,
+            .e_boolean => .boolean,
             .e_null => .null,
             .e_number => .number,
             .e_string => .string,
@@ -2853,7 +2843,7 @@ pub const Data = union(Tag) {
                 // +'1' => 1
                 return stringToEquivalentNumberValue(str.slice8());
             },
-            .e_boolean, .e_branch_boolean => |b| @as(f64, if (b.value) 1.0 else 0.0),
+            .e_boolean => @as(f64, if (data.e_boolean.value) 1.0 else 0.0),
             .e_number => data.e_number.value,
             .e_inlined_enum => |inlined| switch (inlined.value.data) {
                 .e_number => |num| num.value,
@@ -2872,7 +2862,7 @@ pub const Data = union(Tag) {
 
     pub fn toFiniteNumber(data: Expr.Data) ?f64 {
         return switch (data) {
-            .e_boolean, .e_branch_boolean => |b| @as(f64, if (b.value) 1.0 else 0.0),
+            .e_boolean => @as(f64, if (data.e_boolean.value) 1.0 else 0.0),
             .e_number => if (std.math.isFinite(data.e_number.value))
                 data.e_number.value
             else
@@ -2963,12 +2953,12 @@ pub const Data = union(Tag) {
                     .ok = ok,
                 };
             },
-            .e_boolean, .e_branch_boolean => |l| {
+            .e_boolean => |l| {
                 switch (right) {
-                    .e_boolean, .e_branch_boolean => |r| {
+                    .e_boolean => {
                         return .{
                             .ok = true,
-                            .equal = l.value == r.value,
+                            .equal = l.value == right.e_boolean.value,
                         };
                     },
                     .e_number => |num| {
@@ -3006,7 +2996,7 @@ pub const Data = union(Tag) {
                             .equal = l.value == r.value.data.e_number.value,
                         };
                     },
-                    .e_boolean, .e_branch_boolean => |r| {
+                    .e_boolean => |r| {
                         if (comptime kind == .loose) {
                             return .{
                                 .ok = true,
@@ -3121,7 +3111,7 @@ pub const Data = union(Tag) {
             .e_string => |e| e.toJS(allocator, globalObject),
             .e_null => jsc.JSValue.null,
             .e_undefined => .js_undefined,
-            .e_boolean, .e_branch_boolean => |boolean| if (boolean.value)
+            .e_boolean => |boolean| if (boolean.value)
                 .true
             else
                 .false,

src/ast/ImportScanner.zig

@@ -25,7 +25,7 @@ pub fn scan(
                 const record: *ImportRecord = &p.import_records.items[st.import_record_index];
 
                 if (record.path.isMacro()) {
-                    record.flags.is_unused = true;
+                    record.is_unused = true;
                     record.path.is_disabled = true;
                     continue;
                 }
@@ -190,8 +190,8 @@ pub fn scan(
                     {
                         // internal imports are presumed to be always used
                         // require statements cannot be stripped
-                        if (!record.flags.is_internal and !record.flags.was_originally_require) {
-                            record.flags.is_unused = true;
+                        if (!record.is_internal and !record.was_originally_require) {
+                            record.is_unused = true;
                             continue;
                         }
                     }
@@ -204,7 +204,7 @@ pub fn scan(
                     st.star_name_loc = null;
                 }
 
-                record.flags.contains_default_alias = record.flags.contains_default_alias or st.default_name != null;
+                record.contains_default_alias = record.contains_default_alias or st.default_name != null;
 
                 const existing_items: ImportItemForNamespaceMap = p.import_items_for_namespace.get(namespace_ref) orelse
                     ImportItemForNamespaceMap.init(allocator);
@@ -265,7 +265,7 @@ pub fn scan(
                     ) catch |err| bun.handleOom(err);
 
                     if (st.star_name_loc) |loc| {
-                        record.flags.contains_import_star = true;
+                        record.contains_import_star = true;
                         p.named_imports.putAssumeCapacity(
                             namespace_ref,
                             js_ast.NamedImport{
@@ -279,7 +279,7 @@ pub fn scan(
                     }
 
                     if (st.default_name) |default| {
-                        record.flags.contains_default_alias = true;
+                        record.contains_default_alias = true;
                         p.named_imports.putAssumeCapacity(
                             default.ref.?,
                             .{
@@ -313,7 +313,7 @@ pub fn scan(
                     // We do not know at this stage whether or not the import statement is bundled
                     // This keeps track of the `namespace_alias` incase, at printing time, we determine that we should print it with the namespace
                     for (st.items) |item| {
-                        record.flags.contains_default_alias = record.flags.contains_default_alias or strings.eqlComptime(item.alias, "default");
+                        record.contains_default_alias = record.contains_default_alias or strings.eqlComptime(item.alias, "default");
 
                         const name: LocRef = item.name;
                         const name_ref = name.ref.?;
@@ -327,7 +327,7 @@ pub fn scan(
 
                         // Make sure the printer prints this as a property access
                         var symbol: *Symbol = &p.symbols.items[name_ref.innerIndex()];
-                        if (record.flags.contains_import_star or st.star_name_loc != null)
+                        if (record.contains_import_star or st.star_name_loc != null)
                             symbol.namespace_alias = G.NamespaceAlias{
                                 .namespace_ref = namespace_ref,
                                 .alias = item.alias,
@@ -336,7 +336,7 @@ pub fn scan(
                             };
                     }
 
-                    if (record.flags.was_originally_require) {
+                    if (record.was_originally_require) {
                         var symbol = &p.symbols.items[namespace_ref.innerIndex()];
                         symbol.namespace_alias = G.NamespaceAlias{
                             .namespace_ref = namespace_ref,
@@ -349,12 +349,12 @@ pub fn scan(
 
                 try p.import_records_for_current_part.append(allocator, st.import_record_index);
 
-                record.flags.contains_import_star = record.flags.contains_import_star or st.star_name_loc != null;
-                record.flags.contains_default_alias = record.flags.contains_default_alias or st.default_name != null;
+                record.contains_import_star = record.contains_import_star or st.star_name_loc != null;
+                record.contains_default_alias = record.contains_default_alias or st.default_name != null;
 
                 for (st.items) |*item| {
-                    record.flags.contains_default_alias = record.flags.contains_default_alias or strings.eqlComptime(item.alias, "default");
-                    record.flags.contains_es_module_alias = record.flags.contains_es_module_alias or strings.eqlComptime(item.alias, "__esModule");
+                    record.contains_default_alias = record.contains_default_alias or strings.eqlComptime(item.alias, "default");
+                    record.contains_es_module_alias = record.contains_es_module_alias or strings.eqlComptime(item.alias, "__esModule");
                 }
             },
 
@@ -456,7 +456,7 @@ pub fn scan(
                     });
                     try p.recordExport(alias.loc, alias.original_name, st.namespace_ref);
                     var record = &p.import_records.items[st.import_record_index];
-                    record.flags.contains_import_star = true;
+                    record.contains_import_star = true;
                 } else {
                     // "export * from 'path'"
                     try p.export_star_import_records.append(allocator, st.import_record_index);
@@ -482,9 +482,9 @@ pub fn scan(
 
                     var record = &p.import_records.items[st.import_record_index];
                     if (strings.eqlComptime(item.original_name, "default")) {
-                        record.flags.contains_default_alias = true;
+                        record.contains_default_alias = true;
                     } else if (strings.eqlComptime(item.original_name, "__esModule")) {
-                        record.flags.contains_es_module_alias = true;
+                        record.contains_es_module_alias = true;
                     }
                 }
             },

src/ast/Macro.zig

@@ -480,7 +480,7 @@ pub const Runner = struct {
                     this.macro.vm.waitForPromise(promise);
 
                     const promise_result = promise.result(this.macro.vm.jsc_vm);
-                    const rejected = promise.status() == .rejected;
+                    const rejected = promise.status(this.macro.vm.jsc_vm) == .rejected;
 
                     if (promise_result.isUndefined() and this.is_top_level) {
                         this.is_top_level = false;

src/ast/P.zig

@@ -185,13 +185,6 @@ pub fn NewParser_(
         /// it to the symbol so the code generated `e_import_identifier`'s
         bun_app_namespace_ref: Ref = Ref.None,
 
-        /// Used to track the `feature` function from `import { feature } from "bun:bundle"`.
-        /// When visiting e_call, if the target ref matches this, we replace the call with
-        /// a boolean based on whether the feature flag is enabled.
-        bundler_feature_flag_ref: Ref = Ref.None,
-        /// Set to true when visiting an if/ternary condition. feature() calls are only valid in this context.
-        in_branch_condition: bool = false,
-
         scopes_in_order_visitor_index: usize = 0,
         has_classic_runtime_warned: bool = false,
         macro_call_count: MacroCallCountType = 0,
@@ -518,7 +511,7 @@ pub fn NewParser_(
                     p.import_records.items[import_record_index].tag = tag;
                 }
 
-                p.import_records.items[import_record_index].flags.handles_import_errors = (state.is_await_target and p.fn_or_arrow_data_visit.try_body_count != 0) or state.is_then_catch_target;
+                p.import_records.items[import_record_index].handles_import_errors = (state.is_await_target and p.fn_or_arrow_data_visit.try_body_count != 0) or state.is_then_catch_target;
                 p.import_records_for_current_part.append(p.allocator, import_record_index) catch unreachable;
 
                 return p.newExpr(E.Import{
@@ -573,7 +566,7 @@ pub fn NewParser_(
             }
 
             const import_record_index = p.addImportRecord(.require_resolve, arg.loc, arg.data.e_string.string(p.allocator) catch unreachable);
-            p.import_records.items[import_record_index].flags.handles_import_errors = p.fn_or_arrow_data_visit.try_body_count != 0;
+            p.import_records.items[import_record_index].handles_import_errors = p.fn_or_arrow_data_visit.try_body_count != 0;
             p.import_records_for_current_part.append(p.allocator, import_record_index) catch unreachable;
 
             return p.newExpr(
@@ -625,7 +618,7 @@ pub fn NewParser_(
 
                     if (should_unwrap_require) {
                         const import_record_index = p.addImportRecordByRangeAndPath(.stmt, p.source.rangeOfString(arg.loc), path);
-                        p.import_records.items[import_record_index].flags.handles_import_errors = handles_import_errors;
+                        p.import_records.items[import_record_index].handles_import_errors = handles_import_errors;
 
                         // Note that this symbol may be completely removed later.
                         var path_name = fs.PathName.init(path.text);
@@ -658,7 +651,7 @@ pub fn NewParser_(
                     }
 
                     const import_record_index = p.addImportRecordByRangeAndPath(.require, p.source.rangeOfString(arg.loc), path);
-                    p.import_records.items[import_record_index].flags.handles_import_errors = handles_import_errors;
+                    p.import_records.items[import_record_index].handles_import_errors = handles_import_errors;
                     p.import_records_for_current_part.append(p.allocator, import_record_index) catch unreachable;
 
                     return p.newExpr(E.RequireString{ .import_record_index = import_record_index }, arg.loc);
@@ -1332,7 +1325,7 @@ pub fn NewParser_(
             var import_record: *ImportRecord = &p.import_records.items[import_record_i];
             if (comptime is_internal)
                 import_record.path.namespace = "runtime";
-            import_record.flags.is_internal = is_internal;
+            import_record.is_internal = is_internal;
             const import_path_identifier = try import_record.path.name.nonUniqueNameString(allocator);
             var namespace_identifier = try allocator.alloc(u8, import_path_identifier.len + prefix.len);
             const clause_items = try allocator.alloc(js_ast.ClauseItem, imports.len);
@@ -2628,7 +2621,7 @@ pub fn NewParser_(
             if (is_macro) {
                 const id = p.addImportRecord(.stmt, path.loc, path.text);
                 p.import_records.items[id].path.namespace = js_ast.Macro.namespace;
-                p.import_records.items[id].flags.is_unused = true;
+                p.import_records.items[id].is_unused = true;
 
                 if (stmt.default_name) |name_loc| {
                     const name = p.loadNameFromRef(name_loc.ref.?);
@@ -2660,41 +2653,13 @@ pub fn NewParser_(
                 return p.s(S.Empty{}, loc);
             }
 
-            // Handle `import { feature } from "bun:bundle"` - this is a special import
-            // that provides static feature flag checking at bundle time.
-            // We handle it here at parse time (similar to macros) rather than at visit time.
-            if (strings.eqlComptime(path.text, "bun:bundle")) {
-                // Look for the "feature" import and validate specifiers
-                for (stmt.items) |*item| {
-                    // In ClauseItem from parseImportClause:
-                    // - alias is the name from the source module ("feature")
-                    // - original_name is the local binding name
-                    // - name.ref is the ref for the local binding
-                    if (strings.eqlComptime(item.alias, "feature")) {
-                        // Check for duplicate imports of feature
-                        if (p.bundler_feature_flag_ref.isValid()) {
-                            try p.log.addError(p.source, item.alias_loc, "`feature` from \"bun:bundle\" may only be imported once");
-                            continue;
-                        }
-                        // Declare the symbol and store the ref
-                        const name = p.loadNameFromRef(item.name.ref.?);
-                        const ref = try p.declareSymbol(.other, item.name.loc, name);
-                        p.bundler_feature_flag_ref = ref;
-                    } else {
-                        try p.log.addErrorFmt(p.source, item.alias_loc, p.allocator, "\"bun:bundle\" has no export named \"{s}\"", .{item.alias});
-                    }
-                }
-                // Return empty statement - the import is completely removed
-                return p.s(S.Empty{}, loc);
-            }
-
             const macro_remap = if (comptime allow_macros)
                 p.options.macro_context.getRemap(path.text)
             else
                 null;
 
             stmt.import_record_index = p.addImportRecord(.stmt, path.loc, path.text);
-            p.import_records.items[stmt.import_record_index].flags.was_originally_bare_import = was_originally_bare_import;
+            p.import_records.items[stmt.import_record_index].was_originally_bare_import = was_originally_bare_import;
 
             if (stmt.star_name_loc) |star| {
                 const name = p.loadNameFromRef(stmt.namespace_ref);
@@ -2755,9 +2720,9 @@ pub fn NewParser_(
                         });
 
                         p.import_records.items[new_import_id].path.namespace = js_ast.Macro.namespace;
-                        p.import_records.items[new_import_id].flags.is_unused = true;
+                        p.import_records.items[new_import_id].is_unused = true;
                         if (comptime only_scan_imports_and_do_not_visit) {
-                            p.import_records.items[new_import_id].flags.is_internal = true;
+                            p.import_records.items[new_import_id].is_internal = true;
                             p.import_records.items[new_import_id].path.is_disabled = true;
                         }
                         stmt.default_name = null;
@@ -2816,9 +2781,9 @@ pub fn NewParser_(
                         });
 
                         p.import_records.items[new_import_id].path.namespace = js_ast.Macro.namespace;
-                        p.import_records.items[new_import_id].flags.is_unused = true;
+                        p.import_records.items[new_import_id].is_unused = true;
                         if (comptime only_scan_imports_and_do_not_visit) {
-                            p.import_records.items[new_import_id].flags.is_internal = true;
+                            p.import_records.items[new_import_id].is_internal = true;
                             p.import_records.items[new_import_id].path.is_disabled = true;
                         }
                         remap_count += 1;
@@ -2844,11 +2809,11 @@ pub fn NewParser_(
 
             if (remap_count > 0 and stmt.items.len == 0 and stmt.default_name == null) {
                 p.import_records.items[stmt.import_record_index].path.namespace = js_ast.Macro.namespace;
-                p.import_records.items[stmt.import_record_index].flags.is_unused = true;
+                p.import_records.items[stmt.import_record_index].is_unused = true;
 
                 if (comptime only_scan_imports_and_do_not_visit) {
                     p.import_records.items[stmt.import_record_index].path.is_disabled = true;
-                    p.import_records.items[stmt.import_record_index].flags.is_internal = true;
+                    p.import_records.items[stmt.import_record_index].is_internal = true;
                 }
 
                 return p.s(S.Empty{}, loc);
@@ -3967,7 +3932,6 @@ pub fn NewParser_(
                 .e_undefined,
                 .e_missing,
                 .e_boolean,
-                .e_branch_boolean,
                 .e_number,
                 .e_big_int,
                 .e_string,

src/ast/Parser.zig

@@ -134,17 +134,17 @@ pub const Parser = struct {
                 // - import 'foo';
                 // - import("foo")
                 // - require("foo")
-                import_record.flags.is_unused = import_record.flags.is_unused or
+                import_record.is_unused = import_record.is_unused or
                     (import_record.kind == .stmt and
-                        !import_record.flags.was_originally_bare_import and
-                        !import_record.flags.calls_runtime_re_export_fn);
+                        !import_record.was_originally_bare_import and
+                        !import_record.calls_runtime_re_export_fn);
             }
 
             var iter = scan_pass.used_symbols.iterator();
             while (iter.next()) |entry| {
                 const val = entry.value_ptr;
                 if (val.used) {
-                    scan_pass.import_records.items[val.import_record_index].flags.is_unused = false;
+                    scan_pass.import_records.items[val.import_record_index].is_unused = false;
                 }
             }
         }
@@ -1023,7 +1023,7 @@ pub const Parser = struct {
 
                 const import_record: ?*const ImportRecord = brk: {
                     for (p.import_records.items) |*import_record| {
-                        if (import_record.flags.is_internal or import_record.flags.is_unused) continue;
+                        if (import_record.is_internal or import_record.is_unused) continue;
                         if (import_record.kind == .stmt) break :brk import_record;
                     }
 
@@ -1094,7 +1094,7 @@ pub const Parser = struct {
                     // If they use an import statement, we say it's ESM because that's not allowed in CommonJS files.
                     const uses_any_import_statements = brk: {
                         for (p.import_records.items) |*import_record| {
-                            if (import_record.flags.is_internal or import_record.flags.is_unused) continue;
+                            if (import_record.is_internal or import_record.is_unused) continue;
                             if (import_record.kind == .stmt) break :brk true;
                         }
 

src/ast/SideEffects.zig

@@ -72,7 +72,6 @@ pub const SideEffects = enum(u1) {
             .e_undefined,
             .e_string,
             .e_boolean,
-            .e_branch_boolean,
             .e_number,
             .e_big_int,
             .e_inlined_enum,
@@ -89,7 +88,6 @@ pub const SideEffects = enum(u1) {
             .e_undefined,
             .e_missing,
             .e_boolean,
-            .e_branch_boolean,
             .e_number,
             .e_big_int,
             .e_string,
@@ -279,7 +277,7 @@ pub const SideEffects = enum(u1) {
                                 }
                             }
 
-                            properties_slice[end] = prop;
+                            properties_slice[end] = prop_;
                             end += 1;
                         }
 
@@ -315,10 +313,6 @@ pub const SideEffects = enum(u1) {
                     );
                 }
 
-                if (result.isMissing()) {
-                    return null;
-                }
-
                 return result;
             },
             .e_array => {
@@ -551,7 +545,6 @@ pub const SideEffects = enum(u1) {
             .e_null,
             .e_undefined,
             .e_boolean,
-            .e_branch_boolean,
             .e_number,
             .e_big_int,
             .e_string,
@@ -658,7 +651,7 @@ pub const SideEffects = enum(u1) {
         }
         switch (exp) {
             // Never null or undefined
-            .e_boolean, .e_branch_boolean, .e_number, .e_string, .e_reg_exp, .e_function, .e_arrow, .e_big_int => {
+            .e_boolean, .e_number, .e_string, .e_reg_exp, .e_function, .e_arrow, .e_big_int => {
                 return Result{ .value = false, .side_effects = .no_side_effects, .ok = true };
             },
 
@@ -777,7 +770,7 @@ pub const SideEffects = enum(u1) {
             .e_null, .e_undefined => {
                 return Result{ .ok = true, .value = false, .side_effects = .no_side_effects };
             },
-            .e_boolean, .e_branch_boolean => |e| {
+            .e_boolean => |e| {
                 return Result{ .ok = true, .value = e.value, .side_effects = .no_side_effects };
             },
             .e_number => |e| {

src/ast/parseStmt.zig

@@ -327,7 +327,7 @@ pub fn ParseStmt(
 
                     if (comptime track_symbol_usage_during_parse_pass) {
                         // In the scan pass, we need _some_ way of knowing *not* to mark as unused
-                        p.import_records.items[import_record_index].flags.calls_runtime_re_export_fn = true;
+                        p.import_records.items[import_record_index].calls_runtime_re_export_fn = true;
                     }
 
                     try p.lexer.expectOrInsertSemicolon();
@@ -381,7 +381,7 @@ pub fn ParseStmt(
 
                         if (comptime track_symbol_usage_during_parse_pass) {
                             // In the scan pass, we need _some_ way of knowing *not* to mark as unused
-                            p.import_records.items[import_record_index].flags.calls_runtime_re_export_fn = true;
+                            p.import_records.items[import_record_index].calls_runtime_re_export_fn = true;
                         }
                         p.current_scope.is_after_const_local_prefix = true;
                         p.has_es_module_syntax = true;

src/ast/visitExpr.zig

@@ -923,10 +923,7 @@ pub fn VisitExpr(
                 const e_ = expr.data.e_if;
                 const is_call_target = @as(Expr.Data, p.call_target) == .e_if and expr.data.e_if == p.call_target.e_if;
 
-                const prev_in_branch = p.in_branch_condition;
-                p.in_branch_condition = true;
                 e_.test_ = p.visitExpr(e_.test_);
-                p.in_branch_condition = prev_in_branch;
 
                 e_.test_ = SideEffects.simplifyBoolean(p, e_.test_);
 
@@ -1280,15 +1277,6 @@ pub fn VisitExpr(
                     }
                 }
 
-                // Handle `feature("FLAG_NAME")` calls from `import { feature } from "bun:bundle"`
-                // Check if the bundler_feature_flag_ref is set before calling the function
-                // to avoid stack memory usage from copying values back and forth.
-                if (p.bundler_feature_flag_ref.isValid()) {
-                    if (maybeReplaceBundlerFeatureCall(p, e_, expr.loc)) |result| {
-                        return result;
-                    }
-                }
-
                 if (e_.target.data == .e_require_call_target) {
                     e_.can_be_unwrapped_if_unused = .never;
 
@@ -1643,66 +1631,6 @@ pub fn VisitExpr(
 
                 return expr;
             }
-
-            /// Handles `feature("FLAG_NAME")` calls from `import { feature } from "bun:bundle"`.
-            /// This enables statically analyzable dead-code elimination through feature gating.
-            ///
-            /// When a feature flag is enabled via `--feature=FLAG_NAME`, `feature("FLAG_NAME")`
-            /// is replaced with `true`, otherwise it's replaced with `false`. This allows
-            /// bundlers to eliminate dead code branches at build time.
-            ///
-            /// Returns the replacement expression if this is a feature() call, or null otherwise.
-            /// Note: Caller must check `p.bundler_feature_flag_ref.isValid()` before calling.
-            fn maybeReplaceBundlerFeatureCall(p: *P, e_: *E.Call, loc: logger.Loc) ?Expr {
-                // Check if the target is the `feature` function from "bun:bundle"
-                // It could be e_identifier (for unbound) or e_import_identifier (for imports)
-                const target_ref: ?Ref = switch (e_.target.data) {
-                    .e_identifier => |ident| ident.ref,
-                    .e_import_identifier => |ident| ident.ref,
-                    else => null,
-                };
-
-                if (target_ref == null or !target_ref.?.eql(p.bundler_feature_flag_ref)) {
-                    return null;
-                }
-
-                // If control flow is dead, just return false without validation errors
-                if (p.is_control_flow_dead) {
-                    return p.newExpr(E.Boolean{ .value = false }, loc);
-                }
-
-                // Validate: exactly one argument required
-                if (e_.args.len != 1) {
-                    p.log.addError(p.source, loc, "feature() requires exactly one string argument") catch unreachable;
-                    return p.newExpr(E.Boolean{ .value = false }, loc);
-                }
-
-                const arg = e_.args.slice()[0];
-
-                // Validate: argument must be a string literal
-                if (arg.data != .e_string) {
-                    p.log.addError(p.source, arg.loc, "feature() argument must be a string literal") catch unreachable;
-                    return p.newExpr(E.Boolean{ .value = false }, loc);
-                }
-
-                // Check if the feature flag is enabled
-                // Use the underlying string data directly without allocation.
-                // Feature flag names should be ASCII identifiers, so UTF-16 is unexpected.
-                const flag_string = arg.data.e_string;
-                if (flag_string.is_utf16) {
-                    p.log.addError(p.source, arg.loc, "feature() flag name must be an ASCII string") catch unreachable;
-                    return p.newExpr(E.Boolean{ .value = false }, loc);
-                }
-
-                // feature() can only be used directly in an if statement or ternary condition
-                if (!p.in_branch_condition) {
-                    p.log.addError(p.source, loc, "feature() from \"bun:bundle\" can only be used directly in an if statement or ternary condition") catch unreachable;
-                    return p.newExpr(E.Boolean{ .value = false }, loc);
-                }
-
-                const is_enabled = p.options.features.bundler_feature_flags.map.contains(flag_string.data);
-                return .{ .data = .{ .e_branch_boolean = .{ .value = is_enabled } }, .loc = loc };
-            }
         };
     };
 }

src/ast/visitStmt.zig

@@ -1000,10 +1000,7 @@ pub fn VisitStmt(
                 try stmts.append(stmt.*);
             }
             pub fn s_if(noalias p: *P, noalias stmts: *ListManaged(Stmt), noalias stmt: *Stmt, noalias data: *S.If) !void {
-                const prev_in_branch = p.in_branch_condition;
-                p.in_branch_condition = true;
                 data.test_ = p.visitExpr(data.test_);
-                p.in_branch_condition = prev_in_branch;
 
                 if (p.options.features.minify_syntax) {
                     data.test_ = SideEffects.simplifyBoolean(p, data.test_);

src/async/posix_event_loop.zig

@@ -150,7 +150,6 @@ pub const FilePoll = struct {
     const StaticPipeWriter = Subprocess.StaticPipeWriter.Poll;
     const ShellStaticPipeWriter = bun.shell.ShellSubprocess.StaticPipeWriter.Poll;
     const FileSink = jsc.WebCore.FileSink.Poll;
-    const TerminalPoll = bun.api.Terminal.Poll;
     const DNSResolver = bun.api.dns.Resolver;
     const GetAddrInfoRequest = bun.api.dns.GetAddrInfoRequest;
     const Request = bun.api.dns.internal.Request;
@@ -182,7 +181,6 @@ pub const FilePoll = struct {
         // LifecycleScriptSubprocessOutputReader,
         Process,
         ShellBufferedWriter, // i do not know why, but this has to be here otherwise compiler will complain about dependency loop
-        TerminalPoll,
     });
 
     pub const AllocatorType = enum {
@@ -416,12 +414,6 @@ pub const FilePoll = struct {
                 Request.MacAsyncDNS.onMachportChange(loader);
             },
 
-            @field(Owner.Tag, @typeName(TerminalPoll)) => {
-                log("onUpdate " ++ kqueue_or_epoll ++ " (fd: {f}) Terminal", .{poll.fd});
-                var handler: *TerminalPoll = ptr.as(TerminalPoll);
-                handler.onPoll(size_or_offset, poll.flags.contains(.hup));
-            },
-
             else => {
                 const possible_name = Owner.typeNameFromTag(@intFromEnum(ptr.tag()));
                 log("onUpdate " ++ kqueue_or_epoll ++ " (fd: {f}) disconnected? (maybe: {s})", .{ poll.fd, possible_name orelse "<unknown>" });

src/bake/BakeGlobalObject.cpp

@@ -36,7 +36,7 @@ bakeModuleLoaderImportModule(JSC::JSGlobalObject* global,
 
         if (!keyString) {
             auto promise = JSC::JSInternalPromise::create(vm, global->internalPromiseStructure());
-            promise->reject(vm, global, JSC::createError(global, "import() requires a string"_s));
+            promise->reject(global, JSC::createError(global, "import() requires a string"_s));
             return promise;
         }
 
@@ -141,10 +141,10 @@ JSC::JSInternalPromise* bakeModuleLoaderFetch(JSC::JSGlobalObject* globalObject,
                     globalObject,
                     source.toWTFString(),
                     origin,
-                    WTF::move(moduleKey),
+                    WTFMove(moduleKey),
                     WTF::TextPosition(),
                     JSC::SourceProviderSourceType::Module));
-                return resolvedInternalPromise(globalObject, JSC::JSSourceCode::create(vm, WTF::move(sourceCode)));
+                return resolvedInternalPromise(globalObject, JSC::JSSourceCode::create(vm, WTFMove(sourceCode)));
             }
 
             // We unconditionally prefix the key with "bake:" inside

src/bake/BakeSourceProvider.cpp

@@ -33,7 +33,7 @@ extern "C" JSC::EncodedJSValue BakeLoadInitialServerCode(JSC::JSGlobalObject* gl
     global,
     source.toWTFString(),
     origin,
-    WTF::move(string),
+    WTFMove(string),
     WTF::TextPosition(),
     JSC::SourceProviderSourceType::Program
   ));
@@ -67,7 +67,7 @@ extern "C" JSC::EncodedJSValue BakeLoadServerHmrPatch(GlobalObject* global, BunS
     global,
     source.toWTFString(),
     origin,
-    WTF::move(string),
+    WTFMove(string),
     WTF::TextPosition(),
     JSC::SourceProviderSourceType::Program
   ));
@@ -93,7 +93,7 @@ extern "C" JSC::EncodedJSValue BakeLoadServerHmrPatchWithSourceMap(GlobalObject*
     sourceMapJSONPtr,
     sourceMapJSONLength,
     origin,
-    WTF::move(string),
+    WTFMove(string),
     WTF::TextPosition(),
     JSC::SourceProviderSourceType::Program
   );
@@ -159,7 +159,7 @@ extern "C" JSC::EncodedJSValue BakeRegisterProductionChunk(JSC::JSGlobalObject*
     global,
     source.toWTFString(),
     origin,
-    WTF::move(string),
+    WTFMove(string),
     WTF::TextPosition(),
     JSC::SourceProviderSourceType::Module
   ));

src/bake/BakeSourceProvider.h

@@ -20,7 +20,7 @@ public:
         const TextPosition& startPosition,
         JSC::SourceProviderSourceType sourceType)
     {
-        auto provider = adoptRef(*new SourceProvider(source, sourceOrigin, WTF::move(sourceURL), startPosition, sourceType));
+        auto provider = adoptRef(*new SourceProvider(source, sourceOrigin, WTFMove(sourceURL), startPosition, sourceType));
         auto* zigGlobalObject = jsCast<Zig::GlobalObject*>(globalObject);
         auto specifier = Bun::toString(provider->sourceURL());
         Bun__addBakeSourceProviderSourceMap(zigGlobalObject->bunVM(), provider.ptr(), &specifier);
@@ -38,7 +38,7 @@ private:
               source,
               sourceOrigin,
               JSC::SourceTaintedOrigin::Untainted,
-              WTF::move(sourceURL),
+              WTFMove(sourceURL),
               startPosition,
               sourceType)
     {

src/bake/DevServer/IncrementalGraph.zig

@@ -925,7 +925,7 @@ pub fn IncrementalGraph(comptime side: bake.Side) type {
             // When an import record is duplicated, it gets marked unused.
             // This happens in `ConvertESMExportsForHmr.deduplicatedImport`
             // There is still a case where deduplication must happen.
-            if (import_record.flags.is_unused) return .stop;
+            if (import_record.is_unused) return .stop;
             if (import_record.source_index.isRuntime()) return .stop;
 
             const key = import_record.path.keyForIncrementalGraph();
@@ -1044,7 +1044,7 @@ pub fn IncrementalGraph(comptime side: bake.Side) type {
                 // When an import record is duplicated, it gets marked unused.
                 // This happens in `ConvertESMExportsForHmr.deduplicatedImport`
                 // There is still a case where deduplication must happen.
-                if (import_record.flags.is_unused) continue;
+                if (import_record.is_unused) continue;
 
                 if (!import_record.source_index.isRuntime()) try_index_record: {
                     // TODO: move this block into a function