test

## Summary
- Change Archive API from `Bun.Archive.from(data)` to `new
Bun.Archive(data, options?)`
- Change compression options from `{ gzip: true }` to `{ compress:
"gzip", level?: number }`
- Default to no compression when no options provided
- Use `{ compress: "gzip" }` to enable gzip compression (level 6 by
default)
- Add Archive support for S3 and local file writes via `Bun.write()`

## New API

```typescript
// Create archive - defaults to uncompressed tar
const archive = new Bun.Archive({
  "hello.txt": "Hello, World!",
  "data.json": JSON.stringify({ foo: "bar" }),
});

// Enable gzip compression
const compressed = new Bun.Archive(files, { compress: "gzip" });

// Gzip with custom level (1-12)
const maxCompression = new Bun.Archive(files, { compress: "gzip", level: 12 });

// Write to local file
await Bun.write("archive.tar", archive);           // uncompressed by default
await Bun.write("archive.tar.gz", compressed);     // gzipped

// Write to S3
await client.write("archive.tar.gz", compressed);          // S3Client.write()
await Bun.write("s3://bucket/archive.tar.gz", compressed); // S3 URL
await s3File.write(compressed);                            // s3File.write()

// Get bytes/blob (uses compression setting from constructor)
const bytes = await archive.bytes();
const blob = await archive.blob();
```

## TypeScript Types

```typescript
type ArchiveCompression = "gzip";

type ArchiveOptions = {
  compress?: "gzip";
  level?: number;  // 1-12, default 6 when gzip enabled
};
```

## Test plan
- [x] 98 archive tests pass
- [x] S3 integration tests updated to new API
- [x] TypeScript types updated
- [x] Documentation updated with new examples

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

---------

Co-authored-by: Claude <noreply@anthropic.com>
Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>
Co-authored-by: Jarred Sumner <jarred@jarredsumner.com>

.aikido

@@ -0,0 +1,19 @@
+exclude:
+  paths:
+    - test
+    - scripts
+    - bench
+    - packages/bun-lambda
+    - packages/bun-release
+    - packages/bun-wasm
+    - packages/bun-vscode
+    - packages/bun-plugin-yaml
+    - packages/bun-plugin-svelte
+    - packages/bun-native-plugin-rs
+    - packages/bun-native-bundler-plugin-api
+    - packages/bun-inspector-protocol
+    - packages/bun-inspector-frontend
+    - packages/bun-error
+    - packages/bun-debug-adapter-protocol
+    - packages/bun-build-mdx-rs
+    - packages/@types/bun

.buildkite/Dockerfile

@@ -26,7 +26,7 @@ RUN apt-get update && apt-get install -y --no-install-recommends \
    wget curl git python3 python3-pip ninja-build \
    software-properties-common apt-transport-https \
    ca-certificates gnupg lsb-release unzip \
-   libxml2-dev ruby ruby-dev bison gawk perl make golang \
+   libxml2-dev ruby ruby-dev bison gawk perl make golang ccache \
    && add-apt-repository ppa:ubuntu-toolchain-r/test \
    && apt-get update \
    && apt-get install -y gcc-13 g++-13 libgcc-13-dev libstdc++-13-dev \
@@ -35,7 +35,8 @@ RUN apt-get update && apt-get install -y --no-install-recommends \
    && wget https://apt.llvm.org/llvm.sh \
    && chmod +x llvm.sh \
    && ./llvm.sh ${LLVM_VERSION} all \
-   && rm llvm.sh
+   && rm llvm.sh \
+   && rm -rf /var/lib/apt/lists/*
 
 
 RUN --mount=type=tmpfs,target=/tmp \
@@ -110,14 +111,14 @@ ARG BUILDKITE_AGENT_TAGS
 
 
 # Install Rust nightly
-RUN curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y \ 
+RUN curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y \
     && export PATH=$HOME/.cargo/bin:$PATH \
     && rustup install nightly \
     && rustup default nightly
 
 
 RUN ARCH=$(if [ "$TARGETARCH" = "arm64" ]; then echo "arm64"; else echo "amd64"; fi) && \
-    echo "Downloading buildkite" && \ 
+    echo "Downloading buildkite" && \
     curl -fsSL "https://github.com/buildkite/agent/releases/download/v3.87.0/buildkite-agent-linux-${ARCH}-3.87.0.tar.gz" -o /tmp/buildkite-agent.tar.gz && \
     mkdir -p /tmp/buildkite-agent && \
     tar -xzf /tmp/buildkite-agent.tar.gz -C /tmp/buildkite-agent && \
@@ -125,6 +126,18 @@ 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.
+RUN mkdir -p -m 755 /var/lib/buildkite-agent/hooks && \
+    cat <<'EOF' > /var/lib/buildkite-agent/hooks/environment
+#!/bin/sh
+set -efu
+
+export BUILDKITE_BUILD_CHECKOUT_PATH=/var/lib/buildkite-agent/build
+EOF
+
+RUN chmod 744 /var/lib/buildkite-agent/hooks/environment
+
 COPY  ../*/agent.mjs /var/bun/scripts/
 
 ENV BUN_INSTALL_CACHE=/var/lib/buildkite-agent/cache/bun
@@ -147,7 +160,7 @@ COPY . /workspace/bun
 
 
 # Install Rust nightly
-RUN curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y \ 
+RUN curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y \
     && export PATH=$HOME/.cargo/bin:$PATH \
     && rustup install nightly \
     && rustup default nightly
@@ -161,4 +174,4 @@ RUN --mount=type=tmpfs,target=/workspace/bun/build \
     ls -la \
     && bun run build:release \
     && mkdir -p /target \
-    && cp -r /workspace/bun/build/release/bun /target/bun
+    && cp -r /workspace/bun/build/release/bun /target/bun

.buildkite/ci.mjs

@@ -16,6 +16,7 @@ import {
   getEmoji,
   getEnv,
   getLastSuccessfulBuild,
+  getSecret,
   isBuildkite,
   isBuildManual,
   isFork,
@@ -123,16 +124,13 @@ const testPlatforms = [
   { os: "darwin", arch: "aarch64", release: "13", tier: "previous" },
   { os: "darwin", arch: "x64", release: "14", tier: "latest" },
   { os: "darwin", arch: "x64", release: "13", tier: "previous" },
-  { os: "linux", arch: "aarch64", distro: "debian", release: "12", tier: "latest" },
-  { os: "linux", arch: "x64", distro: "debian", release: "12", tier: "latest" },
-  { os: "linux", arch: "x64", baseline: true, distro: "debian", release: "12", tier: "latest" },
-  { os: "linux", arch: "x64", profile: "asan", distro: "debian", release: "12", tier: "latest" },
+  { os: "linux", arch: "aarch64", distro: "debian", release: "13", tier: "latest" },
+  { os: "linux", arch: "x64", distro: "debian", release: "13", tier: "latest" },
+  { os: "linux", arch: "x64", baseline: true, distro: "debian", release: "13", tier: "latest" },
+  { os: "linux", arch: "x64", profile: "asan", distro: "debian", release: "13", tier: "latest" },
   { os: "linux", arch: "aarch64", distro: "ubuntu", release: "25.04", tier: "latest" },
-  { os: "linux", arch: "aarch64", distro: "ubuntu", release: "24.04", tier: "latest" },
   { os: "linux", arch: "x64", distro: "ubuntu", release: "25.04", tier: "latest" },
-  { os: "linux", arch: "x64", distro: "ubuntu", release: "24.04", tier: "latest" },
   { os: "linux", arch: "x64", baseline: true, distro: "ubuntu", release: "25.04", tier: "latest" },
-  { os: "linux", arch: "x64", baseline: true, distro: "ubuntu", release: "24.04", tier: "latest" },
   { os: "linux", arch: "aarch64", abi: "musl", distro: "alpine", release: "3.22", tier: "latest" },
   { os: "linux", arch: "x64", abi: "musl", distro: "alpine", release: "3.22", tier: "latest" },
   { os: "linux", arch: "x64", abi: "musl", baseline: true, distro: "alpine", release: "3.22", tier: "latest" },
@@ -223,7 +221,7 @@ function getImageName(platform, options) {
  * @param {number} [limit]
  * @link https://buildkite.com/docs/pipelines/command-step#retry-attributes
  */
-function getRetry(limit = 0) {
+function getRetry() {
   return {
     manual: {
       permit_on_passed: true,
@@ -292,7 +290,7 @@ function getEc2Agent(platform, options, ec2Options) {
  * @returns {string}
  */
 function getCppAgent(platform, options) {
-  const { os, arch, distro } = platform;
+  const { os, arch } = platform;
 
   if (os === "darwin") {
     return {
@@ -313,7 +311,7 @@ function getCppAgent(platform, options) {
  * @returns {string}
  */
 function getLinkBunAgent(platform, options) {
-  const { os, arch, distro } = platform;
+  const { os, arch } = platform;
 
   if (os === "darwin") {
     return {
@@ -352,14 +350,7 @@ function getZigPlatform() {
  * @param {PipelineOptions} options
  * @returns {Agent}
  */
-function getZigAgent(platform, options) {
-  const { arch } = platform;
-
-  // Uncomment to restore to using macOS on-prem for Zig.
-  // return {
-  //   queue: "build-zig",
-  // };
-
+function getZigAgent(_platform, options) {
   return getEc2Agent(getZigPlatform(), options, {
     instanceType: "r8g.large",
   });
@@ -461,23 +452,6 @@ function getBuildCommand(target, options, label) {
   return `bun run build:${buildProfile}`;
 }
 
-/**
- * @param {Platform} platform
- * @param {PipelineOptions} options
- * @returns {Step}
- */
-function getBuildVendorStep(platform, options) {
-  return {
-    key: `${getTargetKey(platform)}-build-vendor`,
-    label: `${getTargetLabel(platform)} - build-vendor`,
-    agents: getCppAgent(platform, options),
-    retry: getRetry(),
-    cancel_on_build_failing: isMergeQueue(),
-    env: getBuildEnv(platform, options),
-    command: `${getBuildCommand(platform, options)} --target dependencies`,
-  };
-}
-
 /**
  * @param {Platform} platform
  * @param {PipelineOptions} options
@@ -527,9 +501,9 @@ function getBuildZigStep(platform, options) {
   const toolchain = getBuildToolchain(platform);
   return {
     key: `${getTargetKey(platform)}-build-zig`,
+    retry: getRetry(),
     label: `${getTargetLabel(platform)} - build-zig`,
     agents: getZigAgent(platform, options),
-    retry: getRetry(),
     cancel_on_build_failing: isMergeQueue(),
     env: getBuildEnv(platform, options),
     command: `${getBuildCommand(platform, options)} --target bun-zig --toolchain ${toolchain}`,
@@ -579,7 +553,6 @@ function getBuildBunStep(platform, options) {
 /**
  * @typedef {Object} TestOptions
  * @property {string} [buildId]
- * @property {boolean} [unifiedTests]
  * @property {string[]} [testFiles]
  * @property {boolean} [dryRun]
  */
@@ -592,12 +565,13 @@ function getBuildBunStep(platform, options) {
  */
 function getTestBunStep(platform, options, testOptions = {}) {
   const { os, profile } = platform;
-  const { buildId, unifiedTests, testFiles } = testOptions;
+  const { buildId, testFiles } = testOptions;
 
   const args = [`--step=${getTargetKey(platform)}-build-bun`];
   if (buildId) {
     args.push(`--build-id=${buildId}`);
   }
+
   if (testFiles) {
     args.push(...testFiles.map(testFile => `--include=${testFile}`));
   }
@@ -614,7 +588,7 @@ function getTestBunStep(platform, options, testOptions = {}) {
     agents: getTestAgent(platform, options),
     retry: getRetry(),
     cancel_on_build_failing: isMergeQueue(),
-    parallelism: unifiedTests ? undefined : os === "darwin" ? 2 : 10,
+    parallelism: os === "darwin" ? 2 : 20,
     timeout_in_minutes: profile === "asan" || os === "windows" ? 45 : 30,
     env: {
       ASAN_OPTIONS: "allow_user_segv_handler=1:disable_coredump=0:detect_leaks=0",
@@ -796,8 +770,6 @@ function getBenchmarkStep() {
  * @property {Platform[]} [buildPlatforms]
  * @property {Platform[]} [testPlatforms]
  * @property {string[]} [testFiles]
- * @property {boolean} [unifiedBuilds]
- * @property {boolean} [unifiedTests]
  */
 
 /**
@@ -968,22 +940,6 @@ function getOptionsStep() {
         default: "false",
         options: booleanOptions,
       },
-      {
-        key: "unified-builds",
-        select: "Do you want to build each platform in a single step?",
-        hint: "If true, builds will not be split into separate steps (this will likely slow down the build)",
-        required: false,
-        default: "false",
-        options: booleanOptions,
-      },
-      {
-        key: "unified-tests",
-        select: "Do you want to run tests in a single step?",
-        hint: "If true, tests will not be split into separate steps (this will be very slow)",
-        required: false,
-        default: "false",
-        options: booleanOptions,
-      },
     ],
   };
 }
@@ -1049,8 +1005,6 @@ async function getPipelineOptions() {
       buildImages: parseBoolean(options["build-images"]),
       publishImages: parseBoolean(options["publish-images"]),
       testFiles: parseArray(options["test-files"]),
-      unifiedBuilds: parseBoolean(options["unified-builds"]),
-      unifiedTests: parseBoolean(options["unified-tests"]),
       buildPlatforms: buildPlatformKeys?.length
         ? buildPlatformKeys.flatMap(key => buildProfiles.map(profile => ({ ...buildPlatformsMap.get(key), profile })))
         : Array.from(buildPlatformsMap.values()),
@@ -1116,7 +1070,7 @@ async function getPipeline(options = {}) {
   const imagePlatforms = new Map(
     buildImages || publishImages
       ? [...buildPlatforms, ...testPlatforms]
-          .filter(({ os }) => os === "linux" || os === "windows")
+          .filter(({ os }) => os !== "darwin")
           .map(platform => [getImageKey(platform), platform])
       : [],
   );
@@ -1132,7 +1086,7 @@ async function getPipeline(options = {}) {
     });
   }
 
-  let { skipBuilds, forceBuilds, unifiedBuilds, dryRun } = options;
+  let { skipBuilds, forceBuilds, dryRun } = options;
   dryRun = dryRun || !!buildImages;
 
   /** @type {string | undefined} */
@@ -1150,7 +1104,7 @@ async function getPipeline(options = {}) {
   const includeASAN = !isMainBranch();
 
   if (!buildId) {
-    const relevantBuildPlatforms = includeASAN
+    let relevantBuildPlatforms = includeASAN
       ? buildPlatforms
       : buildPlatforms.filter(({ profile }) => profile !== "asan");
 
@@ -1163,13 +1117,16 @@ async function getPipeline(options = {}) {
           dependsOn.push(`${imageKey}-build-image`);
         }
 
+        const steps = [];
+        steps.push(getBuildCppStep(target, options));
+        steps.push(getBuildZigStep(target, options));
+        steps.push(getLinkBunStep(target, options));
+
         return getStepWithDependsOn(
           {
             key: getTargetKey(target),
             group: getTargetLabel(target),
-            steps: unifiedBuilds
-              ? [getBuildBunStep(target, options)]
-              : [getBuildCppStep(target, options), getBuildZigStep(target, options), getLinkBunStep(target, options)],
+            steps,
           },
           ...dependsOn,
         );
@@ -1178,13 +1135,13 @@ async function getPipeline(options = {}) {
   }
 
   if (!isMainBranch()) {
-    const { skipTests, forceTests, unifiedTests, testFiles } = options;
+    const { skipTests, forceTests, testFiles } = options;
     if (!skipTests || forceTests) {
       steps.push(
         ...testPlatforms.map(target => ({
           key: getTargetKey(target),
           group: getTargetLabel(target),
-          steps: [getTestBunStep(target, options, { unifiedTests, testFiles, buildId })],
+          steps: [getTestBunStep(target, options, { testFiles, buildId })],
         })),
       );
     }
@@ -1227,6 +1184,43 @@ async function main() {
     console.log("Generated options:", options);
   }
 
+  startGroup("Querying GitHub for files...");
+  if (options && isBuildkite && !isMainBranch()) {
+    /** @type {string[]} */
+    let allFiles = [];
+    /** @type {string[]} */
+    let newFiles = [];
+    let prFileCount = 0;
+    try {
+      console.log("on buildkite: collecting new files from PR");
+      const per_page = 50;
+      const { BUILDKITE_PULL_REQUEST } = process.env;
+      for (let i = 1; i <= 10; i++) {
+        const res = await fetch(
+          `https://api.github.com/repos/oven-sh/bun/pulls/${BUILDKITE_PULL_REQUEST}/files?per_page=${per_page}&page=${i}`,
+          { headers: { Authorization: `Bearer ${getSecret("GITHUB_TOKEN")}` } },
+        );
+        const doc = await res.json();
+        console.log(`-> page ${i}, found ${doc.length} items`);
+        if (doc.length === 0) break;
+        for (const { filename, status } of doc) {
+          prFileCount += 1;
+          allFiles.push(filename);
+          if (status !== "added") continue;
+          newFiles.push(filename);
+        }
+        if (doc.length < per_page) break;
+      }
+      console.log(`- PR ${BUILDKITE_PULL_REQUEST}, ${prFileCount} files, ${newFiles.length} new files`);
+    } catch (e) {
+      console.error(e);
+    }
+    if (allFiles.every(filename => filename.startsWith("docs/"))) {
+      console.log(`- PR is only docs, skipping tests!`);
+      return;
+    }
+  }
+
   startGroup("Generating pipeline...");
   const pipeline = await getPipeline(options);
   if (!pipeline) {

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

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

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

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

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

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

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

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

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

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

.coderabbit.yaml

@@ -0,0 +1,147 @@
+language: en-US
+
+issue_enrichment:
+  auto_enrich:
+    enabled: false
+
+reviews:
+  profile: assertive
+  request_changes_workflow: false
+  high_level_summary: false
+  high_level_summary_placeholder: "@coderabbitai summary"
+  high_level_summary_in_walkthrough: true
+  auto_title_placeholder: "@coderabbitai"
+  review_status: false
+  commit_status: false
+  fail_commit_status: false
+  collapse_walkthrough: false
+  changed_files_summary: true
+  sequence_diagrams: false
+  estimate_code_review_effort: false
+  assess_linked_issues: true
+  related_issues: true
+  related_prs: true
+  suggested_labels: false
+  suggested_reviewers: true
+  in_progress_fortune: false
+  poem: false
+  abort_on_close: true
+
+  path_filters:
+    - "!test/js/node/test/"
+
+  auto_review:
+    enabled: true
+    auto_incremental_review: true
+    drafts: false
+
+  finishing_touches:
+    docstrings:
+      enabled: false
+    unit_tests:
+      enabled: false
+
+  pre_merge_checks:
+    docstrings:
+      mode: off
+    title:
+      mode: warning
+    description:
+      mode: warning
+    issue_assessment:
+      mode: warning
+
+  tools:
+    shellcheck:
+      enabled: true
+    ruff:
+      enabled: true
+    markdownlint:
+      enabled: true
+    github-checks:
+      enabled: true
+      timeout_ms: 90000
+    languagetool:
+      enabled: true
+      enabled_only: false
+      level: default
+    biome:
+      enabled: true
+    hadolint:
+      enabled: true
+    swiftlint:
+      enabled: true
+    phpstan:
+      enabled: true
+      level: default
+    phpmd:
+      enabled: true
+    phpcs:
+      enabled: true
+    golangci-lint:
+      enabled: true
+    yamllint:
+      enabled: true
+    gitleaks:
+      enabled: true
+    checkov:
+      enabled: true
+    detekt:
+      enabled: true
+    eslint:
+      enabled: true
+    flake8:
+      enabled: true
+    rubocop:
+      enabled: true
+    buf:
+      enabled: true
+    regal:
+      enabled: true
+    actionlint:
+      enabled: true
+    pmd:
+      enabled: true
+    clang:
+      enabled: true
+    cppcheck:
+      enabled: true
+    semgrep:
+      enabled: true
+    circleci:
+      enabled: true
+    clippy:
+      enabled: true
+    sqlfluff:
+      enabled: true
+    prismaLint:
+      enabled: true
+    pylint:
+      enabled: true
+    oxc:
+      enabled: true
+    shopifyThemeCheck:
+      enabled: true
+    luacheck:
+      enabled: true
+    brakeman:
+      enabled: true
+    dotenvLint:
+      enabled: true
+    htmlhint:
+      enabled: true
+    checkmake:
+      enabled: true
+    osvScanner:
+      enabled: true
+
+chat:
+  auto_reply: true
+
+knowledge_base:
+  opt_out: false
+  code_guidelines:
+    enabled: true
+    filePatterns:
+      - "**/.cursor/rules/*.mdc"
+      - "**/CLAUDE.md"

.cursor/rules/building-bun.mdc

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

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

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

.cursor/rules/javascriptcore-class.mdc

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

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

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

.cursor/rules/writing-tests.mdc

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

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

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

.gitattributes

@@ -16,6 +16,7 @@
 *.map text eol=lf whitespace=blank-at-eol,-blank-at-eof,-space-before-tab,tab-in-indent,tabwidth=2
 *.md text eol=lf whitespace=blank-at-eol,-blank-at-eof,-space-before-tab,tab-in-indent,tabwidth=2
 *.mdc text eol=lf whitespace=blank-at-eol,-blank-at-eof,-space-before-tab,tab-in-indent,tabwidth=2
+*.mdx text eol=lf whitespace=blank-at-eol,-blank-at-eof,-space-before-tab,tab-in-indent,tabwidth=2
 *.mjs text eol=lf whitespace=blank-at-eol,-blank-at-eof,-space-before-tab,tab-in-indent,tabwidth=2
 *.mts text eol=lf whitespace=blank-at-eol,-blank-at-eof,-space-before-tab,tab-in-indent,tabwidth=2
 

.github/workflows/claude.yml

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

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

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

.github/workflows/docs.yml

@@ -1,24 +0,0 @@
-name: Docs
-
-on:
-  push:
-    paths:
-      - "docs/**"
-      - "packages/bun-types/**.d.ts"
-      - "CONTRIBUTING.md"
-      - "src/cli/install.sh"
-      - "src/cli/install.ps1"
-    branches:
-      - main
-
-jobs:
-  deploy:
-    name: Deploy
-    runs-on: ubuntu-latest
-    if: ${{ github.repository_owner == 'oven-sh' }}
-    steps:
-      # redeploy Vercel site when a file in `docs` changes
-      # using VERCEL_DEPLOY_HOOK environment variable
-      - name: Trigger Webhook
-        run: |
-          curl -v ${{ secrets.VERCEL_DEPLOY_HOOK }}

.github/workflows/format.yml

@@ -9,7 +9,7 @@ on:
   pull_request:
   merge_group:
 env:
-  BUN_VERSION: "1.2.20"
+  BUN_VERSION: "1.3.2"
   LLVM_VERSION: "19.1.7"
   LLVM_VERSION_MAJOR: "19"
 

.github/workflows/typos.yml

@@ -1,19 +0,0 @@
-name: Typos
-
-on:
-  push:
-    branches:
-      - main
-  pull_request:
-    branches:
-      - main
-
-jobs:
-  docs:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - name: Spellcheck
-        uses: crate-ci/typos@v1.29.4
-        with:
-          files: docs/**/*

.gitignore

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

.prettierignore

@@ -7,4 +7,8 @@ src/react-refresh.js
 *.min.js
 test/snippets
 test/js/node/test
+test/napi/node-napi-tests
 bun.lock
+
+# the output codeblocks need to stay minified
+docs/bundler/minifier.mdx

.vscode/settings.json

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

CLAUDE.md

@@ -6,7 +6,7 @@ This is the Bun repository - an all-in-one JavaScript runtime & toolkit designed
 
 - **Build Bun**: `bun bd`
   - Creates a debug build at `./build/debug/bun-debug`
-  - **CRITICAL**: no need for a timeout, the build is really fast!
+  - **CRITICAL**: do not set a timeout when running `bun bd`
 - **Run tests with your debug build**: `bun bd test <test-file>`
   - **CRITICAL**: Never use `bun test` directly - it won't include your changes
 - **Run any command with debug build**: `bun bd <command>`
@@ -38,16 +38,36 @@ If no valid issue number is provided, find the best existing file to modify inst
 
 ### Writing Tests
 
-Tests use Bun's Jest-compatible test runner with proper test fixtures:
+Tests use Bun's Jest-compatible test runner with proper test fixtures.
+
+- For **single-file tests**, prefer `-e` over `tempDir`.
+- For **multi-file tests**, prefer `tempDir` and `Bun.spawn`.
 
 ```typescript
 import { test, expect } from "bun:test";
 import { bunEnv, bunExe, normalizeBunSnapshot, tempDir } from "harness";
 
-test("my feature", async () => {
+test("(single-file test) my feature", async () => {
+  await using proc = Bun.spawn({
+    cmd: [bunExe(), "-e", "console.log('Hello, world!')"],
+    env: bunEnv,
+  });
+
+  const [stdout, stderr, exitCode] = await Promise.all([
+    proc.stdout.text(),
+    proc.stderr.text(),
+    proc.exited,
+  ]);
+
+  expect(normalizeBunSnapshot(stdout)).toMatchInlineSnapshot(`"Hello, world!"`);
+  expect(exitCode).toBe(0);
+});
+
+test("(multi-file test) my feature", async () => {
   // Create temp directory with test files
   using dir = tempDir("test-prefix", {
-    "index.js": `console.log("hello");`,
+    "index.js": `import { foo } from "./foo.ts"; foo();`,
+    "foo.ts": `export function foo() { console.log("foo"); }`,
   });
 
   // Spawn Bun process
@@ -74,7 +94,7 @@ test("my feature", async () => {
 
 - Always use `port: 0`. Do not hardcode ports. Do not use your own random port number function.
 - Use `normalizeBunSnapshot` to normalize snapshot output of the test.
-- NEVER write tests that check for no "panic" or "uncaught exception" or similar in the test output. That is NOT a valid test.
+- NEVER write tests that check for no "panic" or "uncaught exception" or similar in the test output. These tests will never fail in CI.
 - Use `tempDir` from `"harness"` to create a temporary directory. **Do not** use `tmpdirSync` or `fs.mkdtempSync` to create temporary directories.
 - When spawning processes, tests should expect(stdout).toBe(...) BEFORE expect(exitCode).toBe(0). This gives you a more useful error message on test failure.
 - **CRITICAL**: Do not write flaky tests. Do not use `setTimeout` in tests. Instead, `await` the condition to be met. You are not testing the TIME PASSING, you are testing the CONDITION.

CMakeLists.txt

@@ -24,7 +24,6 @@ if(CMAKE_HOST_APPLE)
   include(SetupMacSDK)
 endif()
 include(SetupLLVM)
-include(SetupCcache)
 
 # --- Project ---
 
@@ -48,6 +47,8 @@ include(SetupEsbuild)
 include(SetupZig)
 include(SetupRust)
 
+include(SetupCcache)
+
 # Generate dependency versions header
 include(GenerateDependencyVersions)
 

CONTRIBUTING.md

@@ -27,15 +27,15 @@ $ brew install automake ccache cmake coreutils gnu-sed go icu4c libiconv libtool
 ```
 
 ```bash#Ubuntu/Debian
-$ sudo apt install curl wget lsb-release software-properties-common cargo ccache cmake git golang libtool ninja-build pkg-config rustc ruby-full xz-utils
+$ sudo apt install curl wget lsb-release software-properties-common cargo cmake git golang libtool ninja-build pkg-config rustc ruby-full xz-utils
 ```
 
 ```bash#Arch
-$ sudo pacman -S base-devel ccache cmake git go libiconv libtool make ninja pkg-config python rust sed unzip ruby
+$ sudo pacman -S base-devel cmake git go libiconv libtool make ninja pkg-config python rust sed unzip ruby
 ```
 
 ```bash#Fedora
-$ sudo dnf install cargo clang19 llvm19 lld19 ccache cmake git golang libtool ninja-build pkg-config rustc ruby libatomic-static libstdc++-static sed unzip which libicu-devel 'perl(Math::BigInt)'
+$ sudo dnf install cargo clang19 llvm19 lld19 cmake git golang libtool ninja-build pkg-config rustc ruby libatomic-static libstdc++-static sed unzip which libicu-devel 'perl(Math::BigInt)'
 ```
 
 ```bash#openSUSE Tumbleweed
@@ -65,6 +65,29 @@ $ brew install bun
 
 {% /codetabs %}
 
+### Optional: Install `ccache`
+
+ccache is used to cache compilation artifacts, significantly speeding up builds:
+
+```bash
+# For macOS
+$ brew install ccache
+
+# 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
+```
+
+Our build scripts will automatically detect and use `ccache` if available. You can check cache statistics with `ccache --show-stats`.
+
 ## Install LLVM
 
 Bun requires LLVM 19 (`clang` is part of LLVM). This version requirement is to match WebKit (precompiled), as mismatching versions will cause memory allocation failures at runtime. In most cases, you can install LLVM through your system package manager:
@@ -163,7 +186,7 @@ Bun generally takes about 2.5 minutes to compile a debug build when there are Zi
 - Batch up your changes
 - Ensure zls is running with incremental watching for LSP errors (if you use VSCode and install Zig and run `bun run build` once to download Zig, this should just work)
 - Prefer using the debugger ("CodeLLDB" in VSCode) to step through the code.
-- Use debug logs. `BUN_DEBUG_<scope>=1` will enable debug logging for the corresponding `Output.scoped(.<scope>, .hidden)` logs. You can also set `BUN_DEBUG_QUIET_LOGS=1` to disable all debug logging that isn't explicitly enabled. To dump debug lgos into a file, `BUN_DEBUG=<path-to-file>.log`. Debug logs are aggressively removed in release builds.
+- Use debug logs. `BUN_DEBUG_<scope>=1` will enable debug logging for the corresponding `Output.scoped(.<scope>, .hidden)` logs. You can also set `BUN_DEBUG_QUIET_LOGS=1` to disable all debug logging that isn't explicitly enabled. To dump debug logs into a file, `BUN_DEBUG=<path-to-file>.log`. Debug logs are aggressively removed in release builds.
 - src/js/\*\*.ts changes are pretty much instant to rebuild. C++ changes are a bit slower, but still much faster than the Zig code (Zig is one compilation unit, C++ is many).
 
 ## Code generation scripts
@@ -331,15 +354,6 @@ $ bun run build -DUSE_STATIC_LIBATOMIC=OFF
 
 The built version of Bun may not work on other systems if compiled this way.
 
-### ccache conflicts with building TinyCC on macOS
-
-If you run into issues with `ccache` when building TinyCC, try reinstalling ccache
-
-```bash
-brew uninstall ccache
-brew install ccache
-```
-
 ## Using bun-debug
 
 - Disable logging: `BUN_DEBUG_QUIET_LOGS=1 bun-debug ...` (to disable all debug logging)

LATEST

@@ -1 +1 @@
-1.3.1
+1.3.5

README.md

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

bench/bun.lock

@@ -1,5 +1,6 @@
 {
   "lockfileVersion": 1,
+  "configVersion": 0,
   "workspaces": {
     "": {
       "name": "bench",
@@ -22,6 +23,7 @@
         "react-dom": "^18.3.1",
         "string-width": "7.1.0",
         "strip-ansi": "^7.1.0",
+        "tar": "^7.4.3",
         "tinycolor2": "^1.6.0",
         "zx": "^7.2.3",
       },
@@ -107,6 +109,8 @@
 
     "@fastify/proxy-addr": ["@fastify/proxy-addr@5.0.0", "", { "dependencies": { "@fastify/forwarded": "^3.0.0", "ipaddr.js": "^2.1.0" } }, "sha512-37qVVA1qZ5sgH7KpHkkC4z9SK6StIsIcOmpjvMPXNb3vx2GQxhZocogVYbr2PbbeLCQxYIPDok307xEvRZOzGA=="],
 
+    "@isaacs/fs-minipass": ["@isaacs/fs-minipass@4.0.1", "", { "dependencies": { "minipass": "^7.0.4" } }, "sha512-wgm9Ehl2jpeqP3zw/7mo3kRHFp5MEDhqAdwy1fTGkHAwnkGOVsgpvQhL8B5n1qlb01jV3n/bI0ZfZp5lWA1k4w=="],
+
     "@jridgewell/gen-mapping": ["@jridgewell/gen-mapping@0.1.1", "", { "dependencies": { "@jridgewell/set-array": "^1.0.0", "@jridgewell/sourcemap-codec": "^1.4.10" } }, "sha512-sQXCasFk+U8lWYEe66WxRDOE9PjVz4vSM51fTu3Hw+ClTpUSQb718772vH3pyS5pShp6lvQM7SxgIDXXXmOX7w=="],
 
     "@jridgewell/resolve-uri": ["@jridgewell/resolve-uri@3.1.0", "", {}, "sha512-F2msla3tad+Mfht5cJq7LSXcdudKTWCVYUgw6pLFOOHSTtZlj6SWNYAp+AhuqLmWdBO2X5hPrLcu8cVP8fy28w=="],
@@ -181,6 +185,8 @@
 
     "chalk": ["chalk@5.3.0", "", {}, "sha512-dLitG79d+GV1Nb/VYcCDFivJeK1hiukt9QjRNVOsUtTy1rR1YJsmpGGTZ3qJos+uw7WmWF4wUwBd9jxjocFC2w=="],
 
+    "chownr": ["chownr@3.0.0", "", {}, "sha512-+IxzY9BZOQd/XuYPRmrvEVjF/nqj5kgT4kEq7VofrDoM1MxoRjEWkrCC3EtLi59TVawxTAn+orJwFQcrqEN1+g=="],
+
     "color": ["color@4.2.3", "", { "dependencies": { "color-convert": "^2.0.1", "color-string": "^1.9.0" } }, "sha512-1rXeuUUiGGrykh+CeBdu5Ie7OJwinCgQY0bc7GCRxy5xVHy+moaqkpL/jqQq0MtQOeYcrqEz4abc5f0KtU7W4A=="],
 
     "color-convert": ["color-convert@2.0.1", "", { "dependencies": { "color-name": "~1.1.4" } }, "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ=="],
@@ -361,6 +367,10 @@
 
     "minimist": ["minimist@1.2.8", "", {}, "sha512-2yyAR8qBkN3YuheJanUpWC5U3bb5osDywNB8RzDVlDwDHbocAJveqqj1u8+SVD7jkWT4yvsHCpWqqWqAxb0zCA=="],
 
+    "minipass": ["minipass@7.1.2", "", {}, "sha512-qOOzS1cBTWYF4BH8fVePDBOO9iptMnGUEZwNc/cMWnTV2nVLZ7VoNWEPHkYczZA0pdoA7dl6e7FL659nX9S2aw=="],
+
+    "minizlib": ["minizlib@3.1.0", "", { "dependencies": { "minipass": "^7.1.2" } }, "sha512-KZxYo1BUkWD2TVFLr0MQoM8vUUigWD3LlD83a/75BqC+4qE0Hb1Vo5v1FgcfaNXvfXzr+5EhQ6ing/CaBijTlw=="],
+
     "mitata": ["mitata@1.0.25", "", {}, "sha512-0v5qZtVW5vwj9FDvYfraR31BMDcRLkhSFWPTLaxx/Z3/EvScfVtAAWtMI2ArIbBcwh7P86dXh0lQWKiXQPlwYA=="],
 
     "ms": ["ms@2.1.2", "", {}, "sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w=="],
@@ -457,6 +467,8 @@
 
     "supports-color": ["supports-color@5.5.0", "", { "dependencies": { "has-flag": "^3.0.0" } }, "sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow=="],
 
+    "tar": ["tar@7.5.2", "", { "dependencies": { "@isaacs/fs-minipass": "^4.0.0", "chownr": "^3.0.0", "minipass": "^7.1.2", "minizlib": "^3.1.0", "yallist": "^5.0.0" } }, "sha512-7NyxrTE4Anh8km8iEy7o0QYPs+0JKBTj5ZaqHg6B39erLg0qYXN3BijtShwbsNSvQ+LN75+KV+C4QR/f6Gwnpg=="],
+
     "thread-stream": ["thread-stream@3.1.0", "", { "dependencies": { "real-require": "^0.2.0" } }, "sha512-OqyPZ9u96VohAyMfJykzmivOrY2wfMSf3C5TtFJVgN+Hm6aj+voFhlK+kZEIv2FBh1X6Xp3DlnCOfEQ3B2J86A=="],
 
     "through": ["through@2.3.8", "", {}, "sha512-w89qg7PI8wAdvX60bMDP+bFoD5Dvhm9oLheFp5O4a2QF0cSBGsBX4qZmadPMvVqlLJBBci+WqGGOAPvcDeNSVg=="],
@@ -481,7 +493,7 @@
 
     "which": ["which@3.0.1", "", { "dependencies": { "isexe": "^2.0.0" }, "bin": { "node-which": "bin/which.js" } }, "sha512-XA1b62dzQzLfaEOSQFTCOd5KFf/1VSzZo7/7TUjnya6u0vGGKzU96UQBZTAThCb2j4/xjBAyii1OhRLJEivHvg=="],
 
-    "yallist": ["yallist@3.1.1", "", {}, "sha512-a4UGQaWPH59mOXUYnAG2ewncQS4i4F43Tv3JoAM+s2VDAmS9NsK8GpDMLrCHPksFT7h3K6TOoUNn2pb7RoXx4g=="],
+    "yallist": ["yallist@5.0.0", "", {}, "sha512-YgvUTfwqyc7UXVMrB+SImsVYSmTS8X/tSrtdNZMImM+n7+QTriRXyXim0mBrTXNeqzVF0KWGgHPeiyViFFrNDw=="],
 
     "yaml": ["yaml@2.3.4", "", {}, "sha512-8aAvwVUSHpfEqTQ4w/KMlf3HcRdt50E5ODIQJBw1fQ5RL34xabzxtUlzTXVqc4rkZsPbvrXKWnABCD7kWSmocA=="],
 
@@ -501,6 +513,8 @@
 
     "light-my-request/process-warning": ["process-warning@4.0.1", "", {}, "sha512-3c2LzQ3rY9d0hc1emcsHhfT9Jwz0cChib/QN89oME2R451w5fy3f0afAhERFZAwrbDU43wk12d0ORBpDVME50Q=="],
 
+    "lru-cache/yallist": ["yallist@3.1.1", "", {}, "sha512-a4UGQaWPH59mOXUYnAG2ewncQS4i4F43Tv3JoAM+s2VDAmS9NsK8GpDMLrCHPksFT7h3K6TOoUNn2pb7RoXx4g=="],
+
     "npm-run-path/path-key": ["path-key@4.0.0", "", {}, "sha512-haREypq7xkM7ErfgIyA0z+Bj4AGKlMSdlQE2jvJo6huWD1EdkKYV+G/T4nq0YEF2vgTT8kqMFKo1uHn950r4SQ=="],
 
     "ansi-styles/color-convert/color-name": ["color-name@1.1.3", "", {}, "sha512-72fSenhMw2HZMTVHeCA9KCmpEIbzWiQsjN+BHcBbS9vr1mtt+vJjPdksIBNUmKAW8TFUDPJK5SUU3QhE9NEXDw=="],

bench/install/README.md

@@ -1,40 +1,29 @@
-# `install` benchmark
+# Create T3 App
 
-Requires [`hyperfine`](https://github.com/sharkdp/hyperfine). The goal of this benchmark is to compare installation performance of Bun with other package managers _when caches are hot_.
+This is a [T3 Stack](https://create.t3.gg/) project bootstrapped with `create-t3-app`.
 
-### With lockfile, online mode
+## What's next? How do I make an app with this?
 
-To run the benchmark with the standard "install" command for each package manager:
+We try to keep this project as simple as possible, so you can start with just the scaffolding we set up for you, and add additional things later when they become necessary.
 
-```sh
-$ hyperfine --prepare 'rm -rf node_modules' --warmup 1 --runs 3 'bun install' 'pnpm install' 'yarn' 'npm install'
-```
+If you are not familiar with the different technologies used in this project, please refer to the respective docs. If you still are in the wind, please join our [Discord](https://t3.gg/discord) and ask for help.
 
-### With lockfile, offline mode
+- [Next.js](https://nextjs.org)
+- [NextAuth.js](https://next-auth.js.org)
+- [Prisma](https://prisma.io)
+- [Drizzle](https://orm.drizzle.team)
+- [Tailwind CSS](https://tailwindcss.com)
+- [tRPC](https://trpc.io)
 
-Even though all packages are cached, some tools may hit the npm API during the version resolution step. (This is not the same as re-downloading a package.) To entirely avoid network calls, the other package managers require `--prefer-offline/--offline` flag. To run the benchmark using "offline" mode:
+## Learn More
 
-```sh
-$ hyperfine --prepare 'rm -rf node_modules' --runs 1 'bun install' 'pnpm install --prefer-offline' 'yarn --offline' 'npm install --prefer-offline'
-```
+To learn more about the [T3 Stack](https://create.t3.gg/), take a look at the following resources:
 
-### Without lockfile, offline mode
+- [Documentation](https://create.t3.gg/)
+- [Learn the T3 Stack](https://create.t3.gg/en/faq#what-learning-resources-are-currently-available) — Check out these awesome tutorials
 
-To run the benchmark with offline mode but without lockfiles:
+You can check out the [create-t3-app GitHub repository](https://github.com/t3-oss/create-t3-app) — your feedback and contributions are welcome!
 
-```sh
-$ hyperfine --prepare 'rm -rf node_modules' --warmup 1 'rm bun.lock && bun install' 'rm pnpm-lock.yaml && pnpm install --prefer-offline' 'rm yarn.lock && yarn --offline' 'rm package-lock.json && npm install --prefer-offline'
-```
+## How do I deploy this?
 
-##
-
-To check that the app is working as expected:
-
-```
-$ bun run dev
-$ npm run dev
-$ yarn dev
-$ pnpm dev
-```
-
-Then visit [http://localhost:3000](http://localhost:3000).
+Follow our deployment guides for [Vercel](https://create.t3.gg/en/deployment/vercel), [Netlify](https://create.t3.gg/en/deployment/netlify) and [Docker](https://create.t3.gg/en/deployment/docker) for more information.

bench/install/app/entry.client.tsx

@@ -1,18 +0,0 @@
-/**
- * By default, Remix will handle hydrating your app on the client for you.
- * You are free to delete this file if you'd like to, but if you ever want it revealed again, you can run `npx remix reveal` ✨
- * For more information, see https://remix.run/docs/en/main/file-conventions/entry.client
- */
-
-import { RemixBrowser } from "@remix-run/react";
-import { startTransition, StrictMode } from "react";
-import { hydrateRoot } from "react-dom/client";
-
-startTransition(() => {
-  hydrateRoot(
-    document,
-    <StrictMode>
-      <RemixBrowser />
-    </StrictMode>,
-  );
-});

bench/install/app/entry.server.tsx

@@ -1,101 +0,0 @@
-/**
- * By default, Remix will handle generating the HTTP Response for you.
- * You are free to delete this file if you'd like to, but if you ever want it revealed again, you can run `npx remix reveal` ✨
- * For more information, see https://remix.run/docs/en/main/file-conventions/entry.server
- */
-
-import type { EntryContext } from "@remix-run/node";
-import { Response } from "@remix-run/node";
-import { RemixServer } from "@remix-run/react";
-import isbot from "isbot";
-import { PassThrough } from "node:stream";
-import { renderToPipeableStream } from "react-dom/server";
-
-const ABORT_DELAY = 5_000;
-
-export default function handleRequest(
-  request: Request,
-  responseStatusCode: number,
-  responseHeaders: Headers,
-  remixContext: EntryContext,
-) {
-  return isbot(request.headers.get("user-agent"))
-    ? handleBotRequest(request, responseStatusCode, responseHeaders, remixContext)
-    : handleBrowserRequest(request, responseStatusCode, responseHeaders, remixContext);
-}
-
-function handleBotRequest(
-  request: Request,
-  responseStatusCode: number,
-  responseHeaders: Headers,
-  remixContext: EntryContext,
-) {
-  return new Promise((resolve, reject) => {
-    const { pipe, abort } = renderToPipeableStream(
-      <RemixServer context={remixContext} url={request.url} abortDelay={ABORT_DELAY} />,
-      {
-        onAllReady() {
-          const body = new PassThrough();
-
-          responseHeaders.set("Content-Type", "text/html");
-
-          resolve(
-            new Response(body, {
-              headers: responseHeaders,
-              status: responseStatusCode,
-            }),
-          );
-
-          pipe(body);
-        },
-        onShellError(error: unknown) {
-          reject(error);
-        },
-        onError(error: unknown) {
-          responseStatusCode = 500;
-          console.error(error);
-        },
-      },
-    );
-
-    setTimeout(abort, ABORT_DELAY);
-  });
-}
-
-function handleBrowserRequest(
-  request: Request,
-  responseStatusCode: number,
-  responseHeaders: Headers,
-  remixContext: EntryContext,
-) {
-  return new Promise((resolve, reject) => {
-    const { pipe, abort } = renderToPipeableStream(
-      <RemixServer context={remixContext} url={request.url} abortDelay={ABORT_DELAY} />,
-      {
-        onShellReady() {
-          const body = new PassThrough();
-
-          responseHeaders.set("Content-Type", "text/html");
-
-          resolve(
-            new Response(body, {
-              headers: responseHeaders,
-              status: responseStatusCode,
-            }),
-          );
-
-          pipe(body);
-        },
-        onShellError(error: unknown) {
-          reject(error);
-        },
-        onError(error: unknown) {
-          console.error(error);
-          responseStatusCode = 500;
-        },
-      },
-    );
-
-    setTimeout(abort, ABORT_DELAY);
-  });
-}

bench/install/app/root.tsx

@@ -1,20 +0,0 @@
-import { Links, LiveReload, Meta, Outlet, Scripts, ScrollRestoration } from "@remix-run/react";
-
-export default function App() {
-  return (
-    <html lang="en">
-      <head>
-        <meta charSet="utf-8" />
-        <meta name="viewport" content="width=device-width,initial-scale=1" />
-        <Meta />
-        <Links />
-      </head>
-      <body>
-        <Outlet />
-        <ScrollRestoration />
-        <Scripts />
-        <LiveReload />
-      </body>
-    </html>
-  );
-}

bench/install/app/routes/_index.tsx

@@ -1,30 +0,0 @@
-import type { V2_MetaFunction } from "@remix-run/node";
-
-export const meta: V2_MetaFunction = () => {
-  return [{ title: "New Remix App" }];
-};
-
-export default function Index() {
-  return (
-    <div style={{ fontFamily: "system-ui, sans-serif", lineHeight: "1.4" }}>
-      <h1>Welcome to Remix</h1>
-      <ul>
-        <li>
-          <a target="_blank" href="https://remix.run/tutorials/blog" rel="noreferrer">
-            15m Quickstart Blog Tutorial
-          </a>
-        </li>
-        <li>
-          <a target="_blank" href="https://remix.run/tutorials/jokes" rel="noreferrer">
-            Deep Dive Jokes App Tutorial
-          </a>
-        </li>
-        <li>
-          <a target="_blank" href="https://remix.run/docs" rel="noreferrer">
-            Remix Docs
-          </a>
-        </li>
-      </ul>
-    </div>
-  );
-}

bench/install/bun.lock

@@ -0,0 +1,489 @@
+{
+  "lockfileVersion": 1,
+  "configVersion": 0,
+  "workspaces": {
+    "": {
+      "name": "installbench",
+      "dependencies": {
+        "@auth/drizzle-adapter": "^1.7.2",
+        "@t3-oss/env-nextjs": "^0.12.0",
+        "@tanstack/react-query": "^5.69.0",
+        "@trpc/client": "^11.0.0",
+        "@trpc/react-query": "^11.0.0",
+        "@trpc/server": "^11.0.0",
+        "drizzle-orm": "^0.41.0",
+        "esbuild": "^0.25.11",
+        "next": "15.5.7",
+        "next-auth": "5.0.0-beta.25",
+        "postgres": "^3.4.4",
+        "react": "^19.0.0",
+        "react-dom": "^19.0.0",
+        "server-only": "^0.0.1",
+        "superjson": "^2.2.1",
+        "zod": "^3.24.2",
+      },
+      "devDependencies": {
+        "@biomejs/biome": "1.9.4",
+        "@tailwindcss/postcss": "^4.0.15",
+        "@types/node": "^20.14.10",
+        "@types/react": "^19.0.0",
+        "@types/react-dom": "^19.0.0",
+        "drizzle-kit": "^0.30.5",
+        "postcss": "^8.5.3",
+        "tailwindcss": "^4.0.15",
+        "typescript": "^5.8.2",
+      },
+    },
+  },
+  "packages": {
+    "@alloc/quick-lru": ["@alloc/quick-lru@5.2.0", "", {}, "sha512-UrcABB+4bUrFABwbluTIBErXwvbsU/V7TZWfmbgJfbkwiBuziS9gxdODUyuiecfdGQ85jglMW6juS3+z5TsKLw=="],
+
+    "@auth/core": ["@auth/core@0.41.1", "", { "dependencies": { "@panva/hkdf": "1.2.1", "jose": "6.1.0", "oauth4webapi": "3.8.2", "preact": "10.24.3", "preact-render-to-string": "6.5.11" } }, "sha512-t9cJ2zNYAdWMacGRMT6+r4xr1uybIdmYa49calBPeTqwgAFPV/88ac9TEvCR85pvATiSPt8VaNf+Gt24JIT/uw=="],
+
+    "@auth/drizzle-adapter": ["@auth/drizzle-adapter@1.11.1", "", { "dependencies": { "@auth/core": "0.41.1" } }, "sha512-cQTvDZqsyF7RPhDm/B6SvqdVP9EzQhy3oM4Muu7fjjmSYFLbSR203E6dH631ZHSKDn2b4WZkfMnjPDzRsPSAeA=="],
+
+    "@biomejs/biome": ["@biomejs/biome@1.9.4", "", { "optionalDependencies": { "@biomejs/cli-darwin-arm64": "1.9.4", "@biomejs/cli-darwin-x64": "1.9.4", "@biomejs/cli-linux-arm64": "1.9.4", "@biomejs/cli-linux-arm64-musl": "1.9.4", "@biomejs/cli-linux-x64": "1.9.4", "@biomejs/cli-linux-x64-musl": "1.9.4", "@biomejs/cli-win32-arm64": "1.9.4", "@biomejs/cli-win32-x64": "1.9.4" }, "bin": { "biome": "bin/biome" } }, "sha512-1rkd7G70+o9KkTn5KLmDYXihGoTaIGO9PIIN2ZB7UJxFrWw04CZHPYiMRjYsaDvVV7hP1dYNRLxSANLaBFGpog=="],
+
+    "@biomejs/cli-darwin-arm64": ["@biomejs/cli-darwin-arm64@1.9.4", "", { "os": "darwin", "cpu": "arm64" }, "sha512-bFBsPWrNvkdKrNCYeAp+xo2HecOGPAy9WyNyB/jKnnedgzl4W4Hb9ZMzYNbf8dMCGmUdSavlYHiR01QaYR58cw=="],
+
+    "@biomejs/cli-darwin-x64": ["@biomejs/cli-darwin-x64@1.9.4", "", { "os": "darwin", "cpu": "x64" }, "sha512-ngYBh/+bEedqkSevPVhLP4QfVPCpb+4BBe2p7Xs32dBgs7rh9nY2AIYUL6BgLw1JVXV8GlpKmb/hNiuIxfPfZg=="],
+
+    "@biomejs/cli-linux-arm64": ["@biomejs/cli-linux-arm64@1.9.4", "", { "os": "linux", "cpu": "arm64" }, "sha512-fJIW0+LYujdjUgJJuwesP4EjIBl/N/TcOX3IvIHJQNsAqvV2CHIogsmA94BPG6jZATS4Hi+xv4SkBBQSt1N4/g=="],
+
+    "@biomejs/cli-linux-arm64-musl": ["@biomejs/cli-linux-arm64-musl@1.9.4", "", { "os": "linux", "cpu": "arm64" }, "sha512-v665Ct9WCRjGa8+kTr0CzApU0+XXtRgwmzIf1SeKSGAv+2scAlW6JR5PMFo6FzqqZ64Po79cKODKf3/AAmECqA=="],
+
+    "@biomejs/cli-linux-x64": ["@biomejs/cli-linux-x64@1.9.4", "", { "os": "linux", "cpu": "x64" }, "sha512-lRCJv/Vi3Vlwmbd6K+oQ0KhLHMAysN8lXoCI7XeHlxaajk06u7G+UsFSO01NAs5iYuWKmVZjmiOzJ0OJmGsMwg=="],
+
+    "@biomejs/cli-linux-x64-musl": ["@biomejs/cli-linux-x64-musl@1.9.4", "", { "os": "linux", "cpu": "x64" }, "sha512-gEhi/jSBhZ2m6wjV530Yy8+fNqG8PAinM3oV7CyO+6c3CEh16Eizm21uHVsyVBEB6RIM8JHIl6AGYCv6Q6Q9Tg=="],
+
+    "@biomejs/cli-win32-arm64": ["@biomejs/cli-win32-arm64@1.9.4", "", { "os": "win32", "cpu": "arm64" }, "sha512-tlbhLk+WXZmgwoIKwHIHEBZUwxml7bRJgk0X2sPyNR3S93cdRq6XulAZRQJ17FYGGzWne0fgrXBKpl7l4M87Hg=="],
+
+    "@biomejs/cli-win32-x64": ["@biomejs/cli-win32-x64@1.9.4", "", { "os": "win32", "cpu": "x64" }, "sha512-8Y5wMhVIPaWe6jw2H+KlEm4wP/f7EW3810ZLmDlrEEy5KvBsb9ECEfu/kMWD484ijfQ8+nIi0giMgu9g1UAuuA=="],
+
+    "@drizzle-team/brocli": ["@drizzle-team/brocli@0.10.2", "", {}, "sha512-z33Il7l5dKjUgGULTqBsQBQwckHh5AbIuxhdsIxDDiZAzBOrZO6q9ogcWC65kU382AfynTfgNumVcNIjuIua6w=="],
+
+    "@emnapi/runtime": ["@emnapi/runtime@1.6.0", "", { "dependencies": { "tslib": "2.8.1" } }, "sha512-obtUmAHTMjll499P+D9A3axeJFlhdjOWdKUNs/U6QIGT7V5RjcUW1xToAzjvmgTSQhDbYn/NwfTRoJcQ2rNBxA=="],
+
+    "@esbuild-kit/core-utils": ["@esbuild-kit/core-utils@3.3.2", "", { "dependencies": { "esbuild": "0.18.20", "source-map-support": "0.5.21" } }, "sha512-sPRAnw9CdSsRmEtnsl2WXWdyquogVpB3yZ3dgwJfe8zrOzTsV7cJvmwrKVa+0ma5BoiGJ+BoqkMvawbayKUsqQ=="],
+
+    "@esbuild-kit/esm-loader": ["@esbuild-kit/esm-loader@2.6.5", "", { "dependencies": { "@esbuild-kit/core-utils": "3.3.2", "get-tsconfig": "4.13.0" } }, "sha512-FxEMIkJKnodyA1OaCUoEvbYRkoZlLZ4d/eXFu9Fh8CbBBgP5EmZxrfTRyN0qpXZ4vOvqnE5YdRdcrmUUXuU+dA=="],
+
+    "@esbuild/aix-ppc64": ["@esbuild/aix-ppc64@0.25.11", "", { "os": "aix", "cpu": "ppc64" }, "sha512-Xt1dOL13m8u0WE8iplx9Ibbm+hFAO0GsU2P34UNoDGvZYkY8ifSiy6Zuc1lYxfG7svWE2fzqCUmFp5HCn51gJg=="],
+
+    "@esbuild/android-arm": ["@esbuild/android-arm@0.25.11", "", { "os": "android", "cpu": "arm" }, "sha512-uoa7dU+Dt3HYsethkJ1k6Z9YdcHjTrSb5NUy66ZfZaSV8hEYGD5ZHbEMXnqLFlbBflLsl89Zke7CAdDJ4JI+Gg=="],
+
+    "@esbuild/android-arm64": ["@esbuild/android-arm64@0.25.11", "", { "os": "android", "cpu": "arm64" }, "sha512-9slpyFBc4FPPz48+f6jyiXOx/Y4v34TUeDDXJpZqAWQn/08lKGeD8aDp9TMn9jDz2CiEuHwfhRmGBvpnd/PWIQ=="],
+
+    "@esbuild/android-x64": ["@esbuild/android-x64@0.25.11", "", { "os": "android", "cpu": "x64" }, "sha512-Sgiab4xBjPU1QoPEIqS3Xx+R2lezu0LKIEcYe6pftr56PqPygbB7+szVnzoShbx64MUupqoE0KyRlN7gezbl8g=="],
+
+    "@esbuild/darwin-arm64": ["@esbuild/darwin-arm64@0.25.11", "", { "os": "darwin", "cpu": "arm64" }, "sha512-VekY0PBCukppoQrycFxUqkCojnTQhdec0vevUL/EDOCnXd9LKWqD/bHwMPzigIJXPhC59Vd1WFIL57SKs2mg4w=="],
+
+    "@esbuild/darwin-x64": ["@esbuild/darwin-x64@0.25.11", "", { "os": "darwin", "cpu": "x64" }, "sha512-+hfp3yfBalNEpTGp9loYgbknjR695HkqtY3d3/JjSRUyPg/xd6q+mQqIb5qdywnDxRZykIHs3axEqU6l1+oWEQ=="],
+
+    "@esbuild/freebsd-arm64": ["@esbuild/freebsd-arm64@0.25.11", "", { "os": "freebsd", "cpu": "arm64" }, "sha512-CmKjrnayyTJF2eVuO//uSjl/K3KsMIeYeyN7FyDBjsR3lnSJHaXlVoAK8DZa7lXWChbuOk7NjAc7ygAwrnPBhA=="],
+
+    "@esbuild/freebsd-x64": ["@esbuild/freebsd-x64@0.25.11", "", { "os": "freebsd", "cpu": "x64" }, "sha512-Dyq+5oscTJvMaYPvW3x3FLpi2+gSZTCE/1ffdwuM6G1ARang/mb3jvjxs0mw6n3Lsw84ocfo9CrNMqc5lTfGOw=="],
+
+    "@esbuild/linux-arm": ["@esbuild/linux-arm@0.25.11", "", { "os": "linux", "cpu": "arm" }, "sha512-TBMv6B4kCfrGJ8cUPo7vd6NECZH/8hPpBHHlYI3qzoYFvWu2AdTvZNuU/7hsbKWqu/COU7NIK12dHAAqBLLXgw=="],
+
+    "@esbuild/linux-arm64": ["@esbuild/linux-arm64@0.25.11", "", { "os": "linux", "cpu": "arm64" }, "sha512-Qr8AzcplUhGvdyUF08A1kHU3Vr2O88xxP0Tm8GcdVOUm25XYcMPp2YqSVHbLuXzYQMf9Bh/iKx7YPqECs6ffLA=="],
+
+    "@esbuild/linux-ia32": ["@esbuild/linux-ia32@0.25.11", "", { "os": "linux", "cpu": "ia32" }, "sha512-TmnJg8BMGPehs5JKrCLqyWTVAvielc615jbkOirATQvWWB1NMXY77oLMzsUjRLa0+ngecEmDGqt5jiDC6bfvOw=="],
+
+    "@esbuild/linux-loong64": ["@esbuild/linux-loong64@0.25.11", "", { "os": "linux", "cpu": "none" }, "sha512-DIGXL2+gvDaXlaq8xruNXUJdT5tF+SBbJQKbWy/0J7OhU8gOHOzKmGIlfTTl6nHaCOoipxQbuJi7O++ldrxgMw=="],
+
+    "@esbuild/linux-mips64el": ["@esbuild/linux-mips64el@0.25.11", "", { "os": "linux", "cpu": "none" }, "sha512-Osx1nALUJu4pU43o9OyjSCXokFkFbyzjXb6VhGIJZQ5JZi8ylCQ9/LFagolPsHtgw6himDSyb5ETSfmp4rpiKQ=="],
+
+    "@esbuild/linux-ppc64": ["@esbuild/linux-ppc64@0.25.11", "", { "os": "linux", "cpu": "ppc64" }, "sha512-nbLFgsQQEsBa8XSgSTSlrnBSrpoWh7ioFDUmwo158gIm5NNP+17IYmNWzaIzWmgCxq56vfr34xGkOcZ7jX6CPw=="],
+
+    "@esbuild/linux-riscv64": ["@esbuild/linux-riscv64@0.25.11", "", { "os": "linux", "cpu": "none" }, "sha512-HfyAmqZi9uBAbgKYP1yGuI7tSREXwIb438q0nqvlpxAOs3XnZ8RsisRfmVsgV486NdjD7Mw2UrFSw51lzUk1ww=="],
+
+    "@esbuild/linux-s390x": ["@esbuild/linux-s390x@0.25.11", "", { "os": "linux", "cpu": "s390x" }, "sha512-HjLqVgSSYnVXRisyfmzsH6mXqyvj0SA7pG5g+9W7ESgwA70AXYNpfKBqh1KbTxmQVaYxpzA/SvlB9oclGPbApw=="],
+
+    "@esbuild/linux-x64": ["@esbuild/linux-x64@0.25.11", "", { "os": "linux", "cpu": "x64" }, "sha512-HSFAT4+WYjIhrHxKBwGmOOSpphjYkcswF449j6EjsjbinTZbp8PJtjsVK1XFJStdzXdy/jaddAep2FGY+wyFAQ=="],
+
+    "@esbuild/netbsd-arm64": ["@esbuild/netbsd-arm64@0.25.11", "", { "os": "none", "cpu": "arm64" }, "sha512-hr9Oxj1Fa4r04dNpWr3P8QKVVsjQhqrMSUzZzf+LZcYjZNqhA3IAfPQdEh1FLVUJSiu6sgAwp3OmwBfbFgG2Xg=="],
+
+    "@esbuild/netbsd-x64": ["@esbuild/netbsd-x64@0.25.11", "", { "os": "none", "cpu": "x64" }, "sha512-u7tKA+qbzBydyj0vgpu+5h5AeudxOAGncb8N6C9Kh1N4n7wU1Xw1JDApsRjpShRpXRQlJLb9wY28ELpwdPcZ7A=="],
+
+    "@esbuild/openbsd-arm64": ["@esbuild/openbsd-arm64@0.25.11", "", { "os": "openbsd", "cpu": "arm64" }, "sha512-Qq6YHhayieor3DxFOoYM1q0q1uMFYb7cSpLD2qzDSvK1NAvqFi8Xgivv0cFC6J+hWVw2teCYltyy9/m/14ryHg=="],
+
+    "@esbuild/openbsd-x64": ["@esbuild/openbsd-x64@0.25.11", "", { "os": "openbsd", "cpu": "x64" }, "sha512-CN+7c++kkbrckTOz5hrehxWN7uIhFFlmS/hqziSFVWpAzpWrQoAG4chH+nN3Be+Kzv/uuo7zhX716x3Sn2Jduw=="],
+
+    "@esbuild/openharmony-arm64": ["@esbuild/openharmony-arm64@0.25.11", "", { "os": "none", "cpu": "arm64" }, "sha512-rOREuNIQgaiR+9QuNkbkxubbp8MSO9rONmwP5nKncnWJ9v5jQ4JxFnLu4zDSRPf3x4u+2VN4pM4RdyIzDty/wQ=="],
+
+    "@esbuild/sunos-x64": ["@esbuild/sunos-x64@0.25.11", "", { "os": "sunos", "cpu": "x64" }, "sha512-nq2xdYaWxyg9DcIyXkZhcYulC6pQ2FuCgem3LI92IwMgIZ69KHeY8T4Y88pcwoLIjbed8n36CyKoYRDygNSGhA=="],
+
+    "@esbuild/win32-arm64": ["@esbuild/win32-arm64@0.25.11", "", { "os": "win32", "cpu": "arm64" }, "sha512-3XxECOWJq1qMZ3MN8srCJ/QfoLpL+VaxD/WfNRm1O3B4+AZ/BnLVgFbUV3eiRYDMXetciH16dwPbbHqwe1uU0Q=="],
+
+    "@esbuild/win32-ia32": ["@esbuild/win32-ia32@0.25.11", "", { "os": "win32", "cpu": "ia32" }, "sha512-3ukss6gb9XZ8TlRyJlgLn17ecsK4NSQTmdIXRASVsiS2sQ6zPPZklNJT5GR5tE/MUarymmy8kCEf5xPCNCqVOA=="],
+
+    "@esbuild/win32-x64": ["@esbuild/win32-x64@0.25.11", "", { "os": "win32", "cpu": "x64" }, "sha512-D7Hpz6A2L4hzsRpPaCYkQnGOotdUpDzSGRIv9I+1ITdHROSFUWW95ZPZWQmGka1Fg7W3zFJowyn9WGwMJ0+KPA=="],
+
+    "@img/colour": ["@img/colour@1.0.0", "", {}, "sha512-A5P/LfWGFSl6nsckYtjw9da+19jB8hkJ6ACTGcDfEJ0aE+l2n2El7dsVM7UVHZQ9s2lmYMWlrS21YLy2IR1LUw=="],
+
+    "@img/sharp-darwin-arm64": ["@img/sharp-darwin-arm64@0.34.4", "", { "optionalDependencies": { "@img/sharp-libvips-darwin-arm64": "1.2.3" }, "os": "darwin", "cpu": "arm64" }, "sha512-sitdlPzDVyvmINUdJle3TNHl+AG9QcwiAMsXmccqsCOMZNIdW2/7S26w0LyU8euiLVzFBL3dXPwVCq/ODnf2vA=="],
+
+    "@img/sharp-darwin-x64": ["@img/sharp-darwin-x64@0.34.4", "", { "optionalDependencies": { "@img/sharp-libvips-darwin-x64": "1.2.3" }, "os": "darwin", "cpu": "x64" }, "sha512-rZheupWIoa3+SOdF/IcUe1ah4ZDpKBGWcsPX6MT0lYniH9micvIU7HQkYTfrx5Xi8u+YqwLtxC/3vl8TQN6rMg=="],
+
+    "@img/sharp-libvips-darwin-arm64": ["@img/sharp-libvips-darwin-arm64@1.2.3", "", { "os": "darwin", "cpu": "arm64" }, "sha512-QzWAKo7kpHxbuHqUC28DZ9pIKpSi2ts2OJnoIGI26+HMgq92ZZ4vk8iJd4XsxN+tYfNJxzH6W62X5eTcsBymHw=="],
+
+    "@img/sharp-libvips-darwin-x64": ["@img/sharp-libvips-darwin-x64@1.2.3", "", { "os": "darwin", "cpu": "x64" }, "sha512-Ju+g2xn1E2AKO6YBhxjj+ACcsPQRHT0bhpglxcEf+3uyPY+/gL8veniKoo96335ZaPo03bdDXMv0t+BBFAbmRA=="],
+
+    "@img/sharp-libvips-linux-arm": ["@img/sharp-libvips-linux-arm@1.2.3", "", { "os": "linux", "cpu": "arm" }, "sha512-x1uE93lyP6wEwGvgAIV0gP6zmaL/a0tGzJs/BIDDG0zeBhMnuUPm7ptxGhUbcGs4okDJrk4nxgrmxpib9g6HpA=="],
+
+    "@img/sharp-libvips-linux-arm64": ["@img/sharp-libvips-linux-arm64@1.2.3", "", { "os": "linux", "cpu": "arm64" }, "sha512-I4RxkXU90cpufazhGPyVujYwfIm9Nk1QDEmiIsaPwdnm013F7RIceaCc87kAH+oUB1ezqEvC6ga4m7MSlqsJvQ=="],
+
+    "@img/sharp-libvips-linux-ppc64": ["@img/sharp-libvips-linux-ppc64@1.2.3", "", { "os": "linux", "cpu": "ppc64" }, "sha512-Y2T7IsQvJLMCBM+pmPbM3bKT/yYJvVtLJGfCs4Sp95SjvnFIjynbjzsa7dY1fRJX45FTSfDksbTp6AGWudiyCg=="],
+
+    "@img/sharp-libvips-linux-s390x": ["@img/sharp-libvips-linux-s390x@1.2.3", "", { "os": "linux", "cpu": "s390x" }, "sha512-RgWrs/gVU7f+K7P+KeHFaBAJlNkD1nIZuVXdQv6S+fNA6syCcoboNjsV2Pou7zNlVdNQoQUpQTk8SWDHUA3y/w=="],
+
+    "@img/sharp-libvips-linux-x64": ["@img/sharp-libvips-linux-x64@1.2.3", "", { "os": "linux", "cpu": "x64" }, "sha512-3JU7LmR85K6bBiRzSUc/Ff9JBVIFVvq6bomKE0e63UXGeRw2HPVEjoJke1Yx+iU4rL7/7kUjES4dZ/81Qjhyxg=="],
+
+    "@img/sharp-libvips-linuxmusl-arm64": ["@img/sharp-libvips-linuxmusl-arm64@1.2.3", "", { "os": "linux", "cpu": "arm64" }, "sha512-F9q83RZ8yaCwENw1GieztSfj5msz7GGykG/BA+MOUefvER69K/ubgFHNeSyUu64amHIYKGDs4sRCMzXVj8sEyw=="],
+
+    "@img/sharp-libvips-linuxmusl-x64": ["@img/sharp-libvips-linuxmusl-x64@1.2.3", "", { "os": "linux", "cpu": "x64" }, "sha512-U5PUY5jbc45ANM6tSJpsgqmBF/VsL6LnxJmIf11kB7J5DctHgqm0SkuXzVWtIY90GnJxKnC/JT251TDnk1fu/g=="],
+
+    "@img/sharp-linux-arm": ["@img/sharp-linux-arm@0.34.4", "", { "optionalDependencies": { "@img/sharp-libvips-linux-arm": "1.2.3" }, "os": "linux", "cpu": "arm" }, "sha512-Xyam4mlqM0KkTHYVSuc6wXRmM7LGN0P12li03jAnZ3EJWZqj83+hi8Y9UxZUbxsgsK1qOEwg7O0Bc0LjqQVtxA=="],
+
+    "@img/sharp-linux-arm64": ["@img/sharp-linux-arm64@0.34.4", "", { "optionalDependencies": { "@img/sharp-libvips-linux-arm64": "1.2.3" }, "os": "linux", "cpu": "arm64" }, "sha512-YXU1F/mN/Wu786tl72CyJjP/Ngl8mGHN1hST4BGl+hiW5jhCnV2uRVTNOcaYPs73NeT/H8Upm3y9582JVuZHrQ=="],
+
+    "@img/sharp-linux-ppc64": ["@img/sharp-linux-ppc64@0.34.4", "", { "optionalDependencies": { "@img/sharp-libvips-linux-ppc64": "1.2.3" }, "os": "linux", "cpu": "ppc64" }, "sha512-F4PDtF4Cy8L8hXA2p3TO6s4aDt93v+LKmpcYFLAVdkkD3hSxZzee0rh6/+94FpAynsuMpLX5h+LRsSG3rIciUQ=="],
+
+    "@img/sharp-linux-s390x": ["@img/sharp-linux-s390x@0.34.4", "", { "optionalDependencies": { "@img/sharp-libvips-linux-s390x": "1.2.3" }, "os": "linux", "cpu": "s390x" }, "sha512-qVrZKE9Bsnzy+myf7lFKvng6bQzhNUAYcVORq2P7bDlvmF6u2sCmK2KyEQEBdYk+u3T01pVsPrkj943T1aJAsw=="],
+
+    "@img/sharp-linux-x64": ["@img/sharp-linux-x64@0.34.4", "", { "optionalDependencies": { "@img/sharp-libvips-linux-x64": "1.2.3" }, "os": "linux", "cpu": "x64" }, "sha512-ZfGtcp2xS51iG79c6Vhw9CWqQC8l2Ot8dygxoDoIQPTat/Ov3qAa8qpxSrtAEAJW+UjTXc4yxCjNfxm4h6Xm2A=="],
+
+    "@img/sharp-linuxmusl-arm64": ["@img/sharp-linuxmusl-arm64@0.34.4", "", { "optionalDependencies": { "@img/sharp-libvips-linuxmusl-arm64": "1.2.3" }, "os": "linux", "cpu": "arm64" }, "sha512-8hDVvW9eu4yHWnjaOOR8kHVrew1iIX+MUgwxSuH2XyYeNRtLUe4VNioSqbNkB7ZYQJj9rUTT4PyRscyk2PXFKA=="],
+
+    "@img/sharp-linuxmusl-x64": ["@img/sharp-linuxmusl-x64@0.34.4", "", { "optionalDependencies": { "@img/sharp-libvips-linuxmusl-x64": "1.2.3" }, "os": "linux", "cpu": "x64" }, "sha512-lU0aA5L8QTlfKjpDCEFOZsTYGn3AEiO6db8W5aQDxj0nQkVrZWmN3ZP9sYKWJdtq3PWPhUNlqehWyXpYDcI9Sg=="],
+
+    "@img/sharp-wasm32": ["@img/sharp-wasm32@0.34.4", "", { "dependencies": { "@emnapi/runtime": "1.6.0" }, "cpu": "none" }, "sha512-33QL6ZO/qpRyG7woB/HUALz28WnTMI2W1jgX3Nu2bypqLIKx/QKMILLJzJjI+SIbvXdG9fUnmrxR7vbi1sTBeA=="],
+
+    "@img/sharp-win32-arm64": ["@img/sharp-win32-arm64@0.34.4", "", { "os": "win32", "cpu": "arm64" }, "sha512-2Q250do/5WXTwxW3zjsEuMSv5sUU4Tq9VThWKlU2EYLm4MB7ZeMwF+SFJutldYODXF6jzc6YEOC+VfX0SZQPqA=="],
+
+    "@img/sharp-win32-ia32": ["@img/sharp-win32-ia32@0.34.4", "", { "os": "win32", "cpu": "ia32" }, "sha512-3ZeLue5V82dT92CNL6rsal6I2weKw1cYu+rGKm8fOCCtJTR2gYeUfY3FqUnIJsMUPIH68oS5jmZ0NiJ508YpEw=="],
+
+    "@img/sharp-win32-x64": ["@img/sharp-win32-x64@0.34.4", "", { "os": "win32", "cpu": "x64" }, "sha512-xIyj4wpYs8J18sVN3mSQjwrw7fKUqRw+Z5rnHNCy5fYTxigBz81u5mOMPmFumwjcn8+ld1ppptMBCLic1nz6ig=="],
+
+    "@jridgewell/gen-mapping": ["@jridgewell/gen-mapping@0.3.13", "", { "dependencies": { "@jridgewell/sourcemap-codec": "1.5.5", "@jridgewell/trace-mapping": "0.3.31" } }, "sha512-2kkt/7niJ6MgEPxF0bYdQ6etZaA+fQvDcLKckhy1yIQOzaoKjBBjSj63/aLVjYE3qhRt5dvM+uUyfCg6UKCBbA=="],
+
+    "@jridgewell/remapping": ["@jridgewell/remapping@2.3.5", "", { "dependencies": { "@jridgewell/gen-mapping": "0.3.13", "@jridgewell/trace-mapping": "0.3.31" } }, "sha512-LI9u/+laYG4Ds1TDKSJW2YPrIlcVYOwi2fUC6xB43lueCjgxV4lffOCZCtYFiH6TNOX+tQKXx97T4IKHbhyHEQ=="],
+
+    "@jridgewell/resolve-uri": ["@jridgewell/resolve-uri@3.1.2", "", {}, "sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw=="],
+
+    "@jridgewell/sourcemap-codec": ["@jridgewell/sourcemap-codec@1.5.5", "", {}, "sha512-cYQ9310grqxueWbl+WuIUIaiUaDcj7WOq5fVhEljNVgRfOUhY9fy2zTvfoqWsnebh8Sl70VScFbICvJnLKB0Og=="],
+
+    "@jridgewell/trace-mapping": ["@jridgewell/trace-mapping@0.3.31", "", { "dependencies": { "@jridgewell/resolve-uri": "3.1.2", "@jridgewell/sourcemap-codec": "1.5.5" } }, "sha512-zzNR+SdQSDJzc8joaeP8QQoCQr8NuYx2dIIytl1QeBEZHJ9uW6hebsrYgbz8hJwUQao3TWCMtmfV8Nu1twOLAw=="],
+
+    "@next/env": ["@next/env@15.5.7", "", {}, "sha512-4h6Y2NyEkIEN7Z8YxkA27pq6zTkS09bUSYC0xjd0NpwFxjnIKeZEeH591o5WECSmjpUhLn3H2QLJcDye3Uzcvg=="],
+
+    "@next/swc-darwin-arm64": ["@next/swc-darwin-arm64@15.5.7", "", { "os": "darwin", "cpu": "arm64" }, "sha512-IZwtxCEpI91HVU/rAUOOobWSZv4P2DeTtNaCdHqLcTJU4wdNXgAySvKa/qJCgR5m6KI8UsKDXtO2B31jcaw1Yw=="],
+
+    "@next/swc-darwin-x64": ["@next/swc-darwin-x64@15.5.7", "", { "os": "darwin", "cpu": "x64" }, "sha512-UP6CaDBcqaCBuiq/gfCEJw7sPEoX1aIjZHnBWN9v9qYHQdMKvCKcAVs4OX1vIjeE+tC5EIuwDTVIoXpUes29lg=="],
+
+    "@next/swc-linux-arm64-gnu": ["@next/swc-linux-arm64-gnu@15.5.7", "", { "os": "linux", "cpu": "arm64" }, "sha512-NCslw3GrNIw7OgmRBxHtdWFQYhexoUCq+0oS2ccjyYLtcn1SzGzeM54jpTFonIMUjNbHmpKpziXnpxhSWLcmBA=="],
+
+    "@next/swc-linux-arm64-musl": ["@next/swc-linux-arm64-musl@15.5.7", "", { "os": "linux", "cpu": "arm64" }, "sha512-nfymt+SE5cvtTrG9u1wdoxBr9bVB7mtKTcj0ltRn6gkP/2Nu1zM5ei8rwP9qKQP0Y//umK+TtkKgNtfboBxRrw=="],
+
+    "@next/swc-linux-x64-gnu": ["@next/swc-linux-x64-gnu@15.5.7", "", { "os": "linux", "cpu": "x64" }, "sha512-hvXcZvCaaEbCZcVzcY7E1uXN9xWZfFvkNHwbe/n4OkRhFWrs1J1QV+4U1BN06tXLdaS4DazEGXwgqnu/VMcmqw=="],
+
+    "@next/swc-linux-x64-musl": ["@next/swc-linux-x64-musl@15.5.7", "", { "os": "linux", "cpu": "x64" }, "sha512-4IUO539b8FmF0odY6/SqANJdgwn1xs1GkPO5doZugwZ3ETF6JUdckk7RGmsfSf7ws8Qb2YB5It33mvNL/0acqA=="],
+
+    "@next/swc-win32-arm64-msvc": ["@next/swc-win32-arm64-msvc@15.5.7", "", { "os": "win32", "cpu": "arm64" }, "sha512-CpJVTkYI3ZajQkC5vajM7/ApKJUOlm6uP4BknM3XKvJ7VXAvCqSjSLmM0LKdYzn6nBJVSjdclx8nYJSa3xlTgQ=="],
+
+    "@next/swc-win32-x64-msvc": ["@next/swc-win32-x64-msvc@15.5.7", "", { "os": "win32", "cpu": "x64" }, "sha512-gMzgBX164I6DN+9/PGA+9dQiwmTkE4TloBNx8Kv9UiGARsr9Nba7IpcBRA1iTV9vwlYnrE3Uy6I7Aj6qLjQuqw=="],
+
+    "@panva/hkdf": ["@panva/hkdf@1.2.1", "", {}, "sha512-6oclG6Y3PiDFcoyk8srjLfVKyMfVCKJ27JwNPViuXziFpmdz+MZnZN/aKY0JGXgYuO/VghU0jcOAZgWXZ1Dmrw=="],
+
+    "@petamoriken/float16": ["@petamoriken/float16@3.9.3", "", {}, "sha512-8awtpHXCx/bNpFt4mt2xdkgtgVvKqty8VbjHI/WWWQuEw+KLzFot3f4+LkQY9YmOtq7A5GdOnqoIC8Pdygjk2g=="],
+
+    "@swc/helpers": ["@swc/helpers@0.5.15", "", { "dependencies": { "tslib": "2.8.1" } }, "sha512-JQ5TuMi45Owi4/BIMAJBoSQoOJu12oOk/gADqlcUL9JEdHB8vyjUSsxqeNXnmXHjYKMi2WcYtezGEEhqUI/E2g=="],
+
+    "@t3-oss/env-core": ["@t3-oss/env-core@0.12.0", "", { "optionalDependencies": { "typescript": "5.9.3", "zod": "3.25.76" } }, "sha512-lOPj8d9nJJTt81mMuN9GMk8x5veOt7q9m11OSnCBJhwp1QrL/qR+M8Y467ULBSm9SunosryWNbmQQbgoiMgcdw=="],
+
+    "@t3-oss/env-nextjs": ["@t3-oss/env-nextjs@0.12.0", "", { "dependencies": { "@t3-oss/env-core": "0.12.0" }, "optionalDependencies": { "typescript": "5.9.3", "zod": "3.25.76" } }, "sha512-rFnvYk1049RnNVUPvY8iQ55AuQh1Rr+qZzQBh3t++RttCGK4COpXGNxS4+45afuQq02lu+QAOy/5955aU8hRKw=="],
+
+    "@tailwindcss/node": ["@tailwindcss/node@4.1.16", "", { "dependencies": { "@jridgewell/remapping": "2.3.5", "enhanced-resolve": "5.18.3", "jiti": "2.6.1", "lightningcss": "1.30.2", "magic-string": "0.30.21", "source-map-js": "1.2.1", "tailwindcss": "4.1.16" } }, "sha512-BX5iaSsloNuvKNHRN3k2RcCuTEgASTo77mofW0vmeHkfrDWaoFAFvNHpEgtu0eqyypcyiBkDWzSMxJhp3AUVcw=="],
+
+    "@tailwindcss/oxide": ["@tailwindcss/oxide@4.1.16", "", { "optionalDependencies": { "@tailwindcss/oxide-android-arm64": "4.1.16", "@tailwindcss/oxide-darwin-arm64": "4.1.16", "@tailwindcss/oxide-darwin-x64": "4.1.16", "@tailwindcss/oxide-freebsd-x64": "4.1.16", "@tailwindcss/oxide-linux-arm-gnueabihf": "4.1.16", "@tailwindcss/oxide-linux-arm64-gnu": "4.1.16", "@tailwindcss/oxide-linux-arm64-musl": "4.1.16", "@tailwindcss/oxide-linux-x64-gnu": "4.1.16", "@tailwindcss/oxide-linux-x64-musl": "4.1.16", "@tailwindcss/oxide-wasm32-wasi": "4.1.16", "@tailwindcss/oxide-win32-arm64-msvc": "4.1.16", "@tailwindcss/oxide-win32-x64-msvc": "4.1.16" } }, "sha512-2OSv52FRuhdlgyOQqgtQHuCgXnS8nFSYRp2tJ+4WZXKgTxqPy7SMSls8c3mPT5pkZ17SBToGM5LHEJBO7miEdg=="],
+
+    "@tailwindcss/oxide-android-arm64": ["@tailwindcss/oxide-android-arm64@4.1.16", "", { "os": "android", "cpu": "arm64" }, "sha512-8+ctzkjHgwDJ5caq9IqRSgsP70xhdhJvm+oueS/yhD5ixLhqTw9fSL1OurzMUhBwE5zK26FXLCz2f/RtkISqHA=="],
+
+    "@tailwindcss/oxide-darwin-arm64": ["@tailwindcss/oxide-darwin-arm64@4.1.16", "", { "os": "darwin", "cpu": "arm64" }, "sha512-C3oZy5042v2FOALBZtY0JTDnGNdS6w7DxL/odvSny17ORUnaRKhyTse8xYi3yKGyfnTUOdavRCdmc8QqJYwFKA=="],
+
+    "@tailwindcss/oxide-darwin-x64": ["@tailwindcss/oxide-darwin-x64@4.1.16", "", { "os": "darwin", "cpu": "x64" }, "sha512-vjrl/1Ub9+JwU6BP0emgipGjowzYZMjbWCDqwA2Z4vCa+HBSpP4v6U2ddejcHsolsYxwL5r4bPNoamlV0xDdLg=="],
+
+    "@tailwindcss/oxide-freebsd-x64": ["@tailwindcss/oxide-freebsd-x64@4.1.16", "", { "os": "freebsd", "cpu": "x64" }, "sha512-TSMpPYpQLm+aR1wW5rKuUuEruc/oOX3C7H0BTnPDn7W/eMw8W+MRMpiypKMkXZfwH8wqPIRKppuZoedTtNj2tg=="],
+
+    "@tailwindcss/oxide-linux-arm-gnueabihf": ["@tailwindcss/oxide-linux-arm-gnueabihf@4.1.16", "", { "os": "linux", "cpu": "arm" }, "sha512-p0GGfRg/w0sdsFKBjMYvvKIiKy/LNWLWgV/plR4lUgrsxFAoQBFrXkZ4C0w8IOXfslB9vHK/JGASWD2IefIpvw=="],
+
+    "@tailwindcss/oxide-linux-arm64-gnu": ["@tailwindcss/oxide-linux-arm64-gnu@4.1.16", "", { "os": "linux", "cpu": "arm64" }, "sha512-DoixyMmTNO19rwRPdqviTrG1rYzpxgyYJl8RgQvdAQUzxC1ToLRqtNJpU/ATURSKgIg6uerPw2feW0aS8SNr/w=="],
+
+    "@tailwindcss/oxide-linux-arm64-musl": ["@tailwindcss/oxide-linux-arm64-musl@4.1.16", "", { "os": "linux", "cpu": "arm64" }, "sha512-H81UXMa9hJhWhaAUca6bU2wm5RRFpuHImrwXBUvPbYb+3jo32I9VIwpOX6hms0fPmA6f2pGVlybO6qU8pF4fzQ=="],
+
+    "@tailwindcss/oxide-linux-x64-gnu": ["@tailwindcss/oxide-linux-x64-gnu@4.1.16", "", { "os": "linux", "cpu": "x64" }, "sha512-ZGHQxDtFC2/ruo7t99Qo2TTIvOERULPl5l0K1g0oK6b5PGqjYMga+FcY1wIUnrUxY56h28FxybtDEla+ICOyew=="],
+
+    "@tailwindcss/oxide-linux-x64-musl": ["@tailwindcss/oxide-linux-x64-musl@4.1.16", "", { "os": "linux", "cpu": "x64" }, "sha512-Oi1tAaa0rcKf1Og9MzKeINZzMLPbhxvm7rno5/zuP1WYmpiG0bEHq4AcRUiG2165/WUzvxkW4XDYCscZWbTLZw=="],
+
+    "@tailwindcss/oxide-wasm32-wasi": ["@tailwindcss/oxide-wasm32-wasi@4.1.16", "", { "cpu": "none" }, "sha512-B01u/b8LteGRwucIBmCQ07FVXLzImWESAIMcUU6nvFt/tYsQ6IHz8DmZ5KtvmwxD+iTYBtM1xwoGXswnlu9v0Q=="],
+
+    "@tailwindcss/oxide-win32-arm64-msvc": ["@tailwindcss/oxide-win32-arm64-msvc@4.1.16", "", { "os": "win32", "cpu": "arm64" }, "sha512-zX+Q8sSkGj6HKRTMJXuPvOcP8XfYON24zJBRPlszcH1Np7xuHXhWn8qfFjIujVzvH3BHU+16jBXwgpl20i+v9A=="],
+
+    "@tailwindcss/oxide-win32-x64-msvc": ["@tailwindcss/oxide-win32-x64-msvc@4.1.16", "", { "os": "win32", "cpu": "x64" }, "sha512-m5dDFJUEejbFqP+UXVstd4W/wnxA4F61q8SoL+mqTypId2T2ZpuxosNSgowiCnLp2+Z+rivdU0AqpfgiD7yCBg=="],
+
+    "@tailwindcss/postcss": ["@tailwindcss/postcss@4.1.16", "", { "dependencies": { "@alloc/quick-lru": "5.2.0", "@tailwindcss/node": "4.1.16", "@tailwindcss/oxide": "4.1.16", "postcss": "8.5.6", "tailwindcss": "4.1.16" } }, "sha512-Qn3SFGPXYQMKR/UtqS+dqvPrzEeBZHrFA92maT4zijCVggdsXnDBMsPFJo1eArX3J+O+Gi+8pV4PkqjLCNBk3A=="],
+
+    "@tanstack/query-core": ["@tanstack/query-core@5.90.5", "", {}, "sha512-wLamYp7FaDq6ZnNehypKI5fNvxHPfTYylE0m/ZpuuzJfJqhR5Pxg9gvGBHZx4n7J+V5Rg5mZxHHTlv25Zt5u+w=="],
+
+    "@tanstack/react-query": ["@tanstack/react-query@5.90.5", "", { "dependencies": { "@tanstack/query-core": "5.90.5" }, "peerDependencies": { "react": "19.2.0" } }, "sha512-pN+8UWpxZkEJ/Rnnj2v2Sxpx1WFlaa9L6a4UO89p6tTQbeo+m0MS8oYDjbggrR8QcTyjKoYWKS3xJQGr3ExT8Q=="],
+
+    "@trpc/client": ["@trpc/client@11.7.1", "", { "peerDependencies": { "@trpc/server": "11.7.1", "typescript": "5.9.3" } }, "sha512-uOnAjElKI892/U6aQMcBHYs3x7mme3Cvv1F87ytBL56rBvs7+DyK7r43zgaXKf13+GtPEI6ex5xjVUfyDW8XcQ=="],
+
+    "@trpc/react-query": ["@trpc/react-query@11.7.1", "", { "peerDependencies": { "@tanstack/react-query": "5.90.5", "@trpc/client": "11.7.1", "@trpc/server": "11.7.1", "react": "19.2.0", "react-dom": "19.2.0", "typescript": "5.9.3" } }, "sha512-dEHDjIqSTzO8nLlCbtiFBMBwhbSkK1QP7aYVo3nP3sYBna0b+iCtrPXdxVPCSopr9/aIqDTEh+dMRZa7yBgjfQ=="],
+
+    "@trpc/server": ["@trpc/server@11.7.1", "", { "peerDependencies": { "typescript": "5.9.3" } }, "sha512-N3U8LNLIP4g9C7LJ/sLkjuPHwqlvE3bnspzC4DEFVdvx2+usbn70P80E3wj5cjOTLhmhRiwJCSXhlB+MHfGeCw=="],
+
+    "@types/cookie": ["@types/cookie@0.6.0", "", {}, "sha512-4Kh9a6B2bQciAhf7FSuMRRkUWecJgJu9nPnx3yzpsfXX/c50REIqpHY4C82bXP90qrLtXtkDxTZosYO3UpOwlA=="],
+
+    "@types/node": ["@types/node@20.19.24", "", { "dependencies": { "undici-types": "6.21.0" } }, "sha512-FE5u0ezmi6y9OZEzlJfg37mqqf6ZDSF2V/NLjUyGrR9uTZ7Sb9F7bLNZ03S4XVUNRWGA7Ck4c1kK+YnuWjl+DA=="],
+
+    "@types/react": ["@types/react@19.2.2", "", { "dependencies": { "csstype": "3.1.3" } }, "sha512-6mDvHUFSjyT2B2yeNx2nUgMxh9LtOWvkhIU3uePn2I2oyNymUAX1NIsdgviM4CH+JSrp2D2hsMvJOkxY+0wNRA=="],
+
+    "@types/react-dom": ["@types/react-dom@19.2.2", "", { "peerDependencies": { "@types/react": "19.2.2" } }, "sha512-9KQPoO6mZCi7jcIStSnlOWn2nEF3mNmyr3rIAsGnAbQKYbRLyqmeSc39EVgtxXVia+LMT8j3knZLAZAh+xLmrw=="],
+
+    "buffer-from": ["buffer-from@1.1.2", "", {}, "sha512-E+XQCRwSbaaiChtv6k6Dwgc+bx+Bs6vuKJHHl5kox/BaKbhiXzqQOwK4cO22yElGp2OCmjwVhT3HmxgyPGnJfQ=="],
+
+    "caniuse-lite": ["caniuse-lite@1.0.30001752", "", {}, "sha512-vKUk7beoukxE47P5gcVNKkDRzXdVofotshHwfR9vmpeFKxmI5PBpgOMC18LUJUA/DvJ70Y7RveasIBraqsyO/g=="],
+
+    "client-only": ["client-only@0.0.1", "", {}, "sha512-IV3Ou0jSMzZrd3pZ48nLkT9DA7Ag1pnPzaiQhpW7c3RbcqqzvzzVu+L8gfqMp/8IM2MQtSiqaCxrrcfu8I8rMA=="],
+
+    "cookie": ["cookie@0.7.1", "", {}, "sha512-6DnInpx7SJ2AK3+CTUE/ZM0vWTUboZCegxhC2xiIydHR9jNuTAASBrfEpHhiGOZw/nX51bHt6YQl8jsGo4y/0w=="],
+
+    "copy-anything": ["copy-anything@4.0.5", "", { "dependencies": { "is-what": "5.5.0" } }, "sha512-7Vv6asjS4gMOuILabD3l739tsaxFQmC+a7pLZm02zyvs8p977bL3zEgq3yDk5rn9B0PbYgIv++jmHcuUab4RhA=="],
+
+    "csstype": ["csstype@3.1.3", "", {}, "sha512-M1uQkMl8rQK/szD0LNhtqxIPLpimGm8sOBwU7lLnCpSbTyY3yeU1Vc7l4KT5zT4s/yOxHH5O7tIuuLOCnLADRw=="],
+
+    "debug": ["debug@4.4.3", "", { "dependencies": { "ms": "2.1.3" } }, "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA=="],
+
+    "detect-libc": ["detect-libc@2.1.2", "", {}, "sha512-Btj2BOOO83o3WyH59e8MgXsxEQVcarkUOpEYrubB0urwnN10yQ364rsiByU11nZlqWYZm05i/of7io4mzihBtQ=="],
+
+    "drizzle-kit": ["drizzle-kit@0.30.6", "", { "dependencies": { "@drizzle-team/brocli": "0.10.2", "@esbuild-kit/esm-loader": "2.6.5", "esbuild": "0.19.12", "esbuild-register": "3.6.0", "gel": "2.1.1" }, "bin": { "drizzle-kit": "bin.cjs" } }, "sha512-U4wWit0fyZuGuP7iNmRleQyK2V8wCuv57vf5l3MnG4z4fzNTjY/U13M8owyQ5RavqvqxBifWORaR3wIUzlN64g=="],
+
+    "drizzle-orm": ["drizzle-orm@0.41.0", "", { "optionalDependencies": { "gel": "2.1.1", "postgres": "3.4.7" } }, "sha512-7A4ZxhHk9gdlXmTdPj/lREtP+3u8KvZ4yEN6MYVxBzZGex5Wtdc+CWSbu7btgF6TB0N+MNPrvW7RKBbxJchs/Q=="],
+
+    "enhanced-resolve": ["enhanced-resolve@5.18.3", "", { "dependencies": { "graceful-fs": "4.2.11", "tapable": "2.3.0" } }, "sha512-d4lC8xfavMeBjzGr2vECC3fsGXziXZQyJxD868h2M/mBI3PwAuODxAkLkq5HYuvrPYcUtiLzsTo8U3PgX3Ocww=="],
+
+    "env-paths": ["env-paths@3.0.0", "", {}, "sha512-dtJUTepzMW3Lm/NPxRf3wP4642UWhjL2sQxc+ym2YMj1m/H2zDNQOlezafzkHwn6sMstjHTwG6iQQsctDW/b1A=="],
+
+    "esbuild": ["esbuild@0.25.11", "", { "optionalDependencies": { "@esbuild/aix-ppc64": "0.25.11", "@esbuild/android-arm": "0.25.11", "@esbuild/android-arm64": "0.25.11", "@esbuild/android-x64": "0.25.11", "@esbuild/darwin-arm64": "0.25.11", "@esbuild/darwin-x64": "0.25.11", "@esbuild/freebsd-arm64": "0.25.11", "@esbuild/freebsd-x64": "0.25.11", "@esbuild/linux-arm": "0.25.11", "@esbuild/linux-arm64": "0.25.11", "@esbuild/linux-ia32": "0.25.11", "@esbuild/linux-loong64": "0.25.11", "@esbuild/linux-mips64el": "0.25.11", "@esbuild/linux-ppc64": "0.25.11", "@esbuild/linux-riscv64": "0.25.11", "@esbuild/linux-s390x": "0.25.11", "@esbuild/linux-x64": "0.25.11", "@esbuild/netbsd-arm64": "0.25.11", "@esbuild/netbsd-x64": "0.25.11", "@esbuild/openbsd-arm64": "0.25.11", "@esbuild/openbsd-x64": "0.25.11", "@esbuild/openharmony-arm64": "0.25.11", "@esbuild/sunos-x64": "0.25.11", "@esbuild/win32-arm64": "0.25.11", "@esbuild/win32-ia32": "0.25.11", "@esbuild/win32-x64": "0.25.11" }, "bin": { "esbuild": "bin/esbuild" } }, "sha512-KohQwyzrKTQmhXDW1PjCv3Tyspn9n5GcY2RTDqeORIdIJY8yKIF7sTSopFmn/wpMPW4rdPXI0UE5LJLuq3bx0Q=="],
+
+    "esbuild-register": ["esbuild-register@3.6.0", "", { "dependencies": { "debug": "4.4.3" }, "peerDependencies": { "esbuild": "0.19.12" } }, "sha512-H2/S7Pm8a9CL1uhp9OvjwrBh5Pvx0H8qVOxNu8Wed9Y7qv56MPtq+GGM8RJpq6glYJn9Wspr8uw7l55uyinNeg=="],
+
+    "gel": ["gel@2.1.1", "", { "dependencies": { "@petamoriken/float16": "3.9.3", "debug": "4.4.3", "env-paths": "3.0.0", "semver": "7.7.3", "shell-quote": "1.8.3", "which": "4.0.0" }, "bin": { "gel": "dist/cli.mjs" } }, "sha512-Newg9X7mRYskoBjSw70l1YnJ/ZGbq64VPyR821H5WVkTGpHG2O0mQILxCeUhxdYERLFY9B4tUyKLyf3uMTjtKw=="],
+
+    "get-tsconfig": ["get-tsconfig@4.13.0", "", { "dependencies": { "resolve-pkg-maps": "1.0.0" } }, "sha512-1VKTZJCwBrvbd+Wn3AOgQP/2Av+TfTCOlE4AcRJE72W1ksZXbAx8PPBR9RzgTeSPzlPMHrbANMH3LbltH73wxQ=="],
+
+    "graceful-fs": ["graceful-fs@4.2.11", "", {}, "sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ=="],
+
+    "is-what": ["is-what@5.5.0", "", {}, "sha512-oG7cgbmg5kLYae2N5IVd3jm2s+vldjxJzK1pcu9LfpGuQ93MQSzo0okvRna+7y5ifrD+20FE8FvjusyGaz14fw=="],
+
+    "isexe": ["isexe@3.1.1", "", {}, "sha512-LpB/54B+/2J5hqQ7imZHfdU31OlgQqx7ZicVlkm9kzg9/w8GKLEcFfJl/t7DCEDueOyBAD6zCCwTO6Fzs0NoEQ=="],
+
+    "jiti": ["jiti@2.6.1", "", { "bin": { "jiti": "lib/jiti-cli.mjs" } }, "sha512-ekilCSN1jwRvIbgeg/57YFh8qQDNbwDb9xT/qu2DAHbFFZUicIl4ygVaAvzveMhMVr3LnpSKTNnwt8PoOfmKhQ=="],
+
+    "jose": ["jose@6.1.0", "", {}, "sha512-TTQJyoEoKcC1lscpVDCSsVgYzUDg/0Bt3WE//WiTPK6uOCQC2KZS4MpugbMWt/zyjkopgZoXhZuCi00gLudfUA=="],
+
+    "lightningcss": ["lightningcss@1.30.2", "", { "dependencies": { "detect-libc": "2.1.2" }, "optionalDependencies": { "lightningcss-android-arm64": "1.30.2", "lightningcss-darwin-arm64": "1.30.2", "lightningcss-darwin-x64": "1.30.2", "lightningcss-freebsd-x64": "1.30.2", "lightningcss-linux-arm-gnueabihf": "1.30.2", "lightningcss-linux-arm64-gnu": "1.30.2", "lightningcss-linux-arm64-musl": "1.30.2", "lightningcss-linux-x64-gnu": "1.30.2", "lightningcss-linux-x64-musl": "1.30.2", "lightningcss-win32-arm64-msvc": "1.30.2", "lightningcss-win32-x64-msvc": "1.30.2" } }, "sha512-utfs7Pr5uJyyvDETitgsaqSyjCb2qNRAtuqUeWIAKztsOYdcACf2KtARYXg2pSvhkt+9NfoaNY7fxjl6nuMjIQ=="],
+
+    "lightningcss-android-arm64": ["lightningcss-android-arm64@1.30.2", "", { "os": "android", "cpu": "arm64" }, "sha512-BH9sEdOCahSgmkVhBLeU7Hc9DWeZ1Eb6wNS6Da8igvUwAe0sqROHddIlvU06q3WyXVEOYDZ6ykBZQnjTbmo4+A=="],
+
+    "lightningcss-darwin-arm64": ["lightningcss-darwin-arm64@1.30.2", "", { "os": "darwin", "cpu": "arm64" }, "sha512-ylTcDJBN3Hp21TdhRT5zBOIi73P6/W0qwvlFEk22fkdXchtNTOU4Qc37SkzV+EKYxLouZ6M4LG9NfZ1qkhhBWA=="],
+
+    "lightningcss-darwin-x64": ["lightningcss-darwin-x64@1.30.2", "", { "os": "darwin", "cpu": "x64" }, "sha512-oBZgKchomuDYxr7ilwLcyms6BCyLn0z8J0+ZZmfpjwg9fRVZIR5/GMXd7r9RH94iDhld3UmSjBM6nXWM2TfZTQ=="],
+
+    "lightningcss-freebsd-x64": ["lightningcss-freebsd-x64@1.30.2", "", { "os": "freebsd", "cpu": "x64" }, "sha512-c2bH6xTrf4BDpK8MoGG4Bd6zAMZDAXS569UxCAGcA7IKbHNMlhGQ89eRmvpIUGfKWNVdbhSbkQaWhEoMGmGslA=="],
+
+    "lightningcss-linux-arm-gnueabihf": ["lightningcss-linux-arm-gnueabihf@1.30.2", "", { "os": "linux", "cpu": "arm" }, "sha512-eVdpxh4wYcm0PofJIZVuYuLiqBIakQ9uFZmipf6LF/HRj5Bgm0eb3qL/mr1smyXIS1twwOxNWndd8z0E374hiA=="],
+
+    "lightningcss-linux-arm64-gnu": ["lightningcss-linux-arm64-gnu@1.30.2", "", { "os": "linux", "cpu": "arm64" }, "sha512-UK65WJAbwIJbiBFXpxrbTNArtfuznvxAJw4Q2ZGlU8kPeDIWEX1dg3rn2veBVUylA2Ezg89ktszWbaQnxD/e3A=="],
+
+    "lightningcss-linux-arm64-musl": ["lightningcss-linux-arm64-musl@1.30.2", "", { "os": "linux", "cpu": "arm64" }, "sha512-5Vh9dGeblpTxWHpOx8iauV02popZDsCYMPIgiuw97OJ5uaDsL86cnqSFs5LZkG3ghHoX5isLgWzMs+eD1YzrnA=="],
+
+    "lightningcss-linux-x64-gnu": ["lightningcss-linux-x64-gnu@1.30.2", "", { "os": "linux", "cpu": "x64" }, "sha512-Cfd46gdmj1vQ+lR6VRTTadNHu6ALuw2pKR9lYq4FnhvgBc4zWY1EtZcAc6EffShbb1MFrIPfLDXD6Xprbnni4w=="],
+
+    "lightningcss-linux-x64-musl": ["lightningcss-linux-x64-musl@1.30.2", "", { "os": "linux", "cpu": "x64" }, "sha512-XJaLUUFXb6/QG2lGIW6aIk6jKdtjtcffUT0NKvIqhSBY3hh9Ch+1LCeH80dR9q9LBjG3ewbDjnumefsLsP6aiA=="],
+
+    "lightningcss-win32-arm64-msvc": ["lightningcss-win32-arm64-msvc@1.30.2", "", { "os": "win32", "cpu": "arm64" }, "sha512-FZn+vaj7zLv//D/192WFFVA0RgHawIcHqLX9xuWiQt7P0PtdFEVaxgF9rjM/IRYHQXNnk61/H/gb2Ei+kUQ4xQ=="],
+
+    "lightningcss-win32-x64-msvc": ["lightningcss-win32-x64-msvc@1.30.2", "", { "os": "win32", "cpu": "x64" }, "sha512-5g1yc73p+iAkid5phb4oVFMB45417DkRevRbt/El/gKXJk4jid+vPFF/AXbxn05Aky8PapwzZrdJShv5C0avjw=="],
+
+    "magic-string": ["magic-string@0.30.21", "", { "dependencies": { "@jridgewell/sourcemap-codec": "1.5.5" } }, "sha512-vd2F4YUyEXKGcLHoq+TEyCjxueSeHnFxyyjNp80yg0XV4vUhnDer/lvvlqM/arB5bXQN5K2/3oinyCRyx8T2CQ=="],
+
+    "ms": ["ms@2.1.3", "", {}, "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA=="],
+
+    "nanoid": ["nanoid@3.3.11", "", { "bin": { "nanoid": "bin/nanoid.cjs" } }, "sha512-N8SpfPUnUp1bK+PMYW8qSWdl9U+wwNWI4QKxOYDy9JAro3WMX7p2OeVRF9v+347pnakNevPmiHhNmZ2HbFA76w=="],
+
+    "next": ["next@15.5.7", "", { "dependencies": { "@next/env": "15.5.7", "@swc/helpers": "0.5.15", "caniuse-lite": "^1.0.30001579", "postcss": "8.4.31", "styled-jsx": "5.1.6" }, "optionalDependencies": { "@next/swc-darwin-arm64": "15.5.7", "@next/swc-darwin-x64": "15.5.7", "@next/swc-linux-arm64-gnu": "15.5.7", "@next/swc-linux-arm64-musl": "15.5.7", "@next/swc-linux-x64-gnu": "15.5.7", "@next/swc-linux-x64-musl": "15.5.7", "@next/swc-win32-arm64-msvc": "15.5.7", "@next/swc-win32-x64-msvc": "15.5.7", "sharp": "^0.34.3" }, "peerDependencies": { "@opentelemetry/api": "^1.1.0", "@playwright/test": "^1.51.1", "babel-plugin-react-compiler": "*", "react": "^18.2.0 || 19.0.0-rc-de68d2f4-20241204 || ^19.0.0", "react-dom": "^18.2.0 || 19.0.0-rc-de68d2f4-20241204 || ^19.0.0", "sass": "^1.3.0" }, "optionalPeers": ["@opentelemetry/api", "@playwright/test", "babel-plugin-react-compiler", "sass"], "bin": { "next": "dist/bin/next" } }, "sha512-+t2/0jIJ48kUpGKkdlhgkv+zPTEOoXyr60qXe68eB/pl3CMJaLeIGjzp5D6Oqt25hCBiBTt8wEeeAzfJvUKnPQ=="],
+
+    "next-auth": ["next-auth@5.0.0-beta.25", "", { "dependencies": { "@auth/core": "0.37.2" }, "peerDependencies": { "next": "15.5.6", "react": "19.2.0" } }, "sha512-2dJJw1sHQl2qxCrRk+KTQbeH+izFbGFPuJj5eGgBZFYyiYYtvlrBeUw1E/OJJxTRjuxbSYGnCTkUIRsIIW0bog=="],
+
+    "oauth4webapi": ["oauth4webapi@3.8.2", "", {}, "sha512-FzZZ+bht5X0FKe7Mwz3DAVAmlH1BV5blSak/lHMBKz0/EBMhX6B10GlQYI51+oRp8ObJaX0g6pXrAxZh5s8rjw=="],
+
+    "picocolors": ["picocolors@1.1.1", "", {}, "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA=="],
+
+    "postcss": ["postcss@8.5.6", "", { "dependencies": { "nanoid": "3.3.11", "picocolors": "1.1.1", "source-map-js": "1.2.1" } }, "sha512-3Ybi1tAuwAP9s0r1UQ2J4n5Y0G05bJkpUIO0/bI9MhwmD70S5aTWbXGBwxHrelT+XM1k6dM0pk+SwNkpTRN7Pg=="],
+
+    "postgres": ["postgres@3.4.7", "", {}, "sha512-Jtc2612XINuBjIl/QTWsV5UvE8UHuNblcO3vVADSrKsrc6RqGX6lOW1cEo3CM2v0XG4Nat8nI+YM7/f26VxXLw=="],
+
+    "preact": ["preact@10.24.3", "", {}, "sha512-Z2dPnBnMUfyQfSQ+GBdsGa16hz35YmLmtTLhM169uW944hYL6xzTYkJjC07j+Wosz733pMWx0fgON3JNw1jJQA=="],
+
+    "preact-render-to-string": ["preact-render-to-string@6.5.11", "", { "peerDependencies": { "preact": "10.24.3" } }, "sha512-ubnauqoGczeGISiOh6RjX0/cdaF8v/oDXIjO85XALCQjwQP+SB4RDXXtvZ6yTYSjG+PC1QRP2AhPgCEsM2EvUw=="],
+
+    "pretty-format": ["pretty-format@3.8.0", "", {}, "sha512-WuxUnVtlWL1OfZFQFuqvnvs6MiAGk9UNsBostyBOB0Is9wb5uRESevA6rnl/rkksXaGX3GzZhPup5d6Vp1nFew=="],
+
+    "react": ["react@19.2.0", "", {}, "sha512-tmbWg6W31tQLeB5cdIBOicJDJRR2KzXsV7uSK9iNfLWQ5bIZfxuPEHp7M8wiHyHnn0DD1i7w3Zmin0FtkrwoCQ=="],
+
+    "react-dom": ["react-dom@19.2.0", "", { "dependencies": { "scheduler": "0.27.0" }, "peerDependencies": { "react": "19.2.0" } }, "sha512-UlbRu4cAiGaIewkPyiRGJk0imDN2T3JjieT6spoL2UeSf5od4n5LB/mQ4ejmxhCFT1tYe8IvaFulzynWovsEFQ=="],
+
+    "resolve-pkg-maps": ["resolve-pkg-maps@1.0.0", "", {}, "sha512-seS2Tj26TBVOC2NIc2rOe2y2ZO7efxITtLZcGSOnHHNOQ7CkiUBfw0Iw2ck6xkIhPwLhKNLS8BO+hEpngQlqzw=="],
+
+    "scheduler": ["scheduler@0.27.0", "", {}, "sha512-eNv+WrVbKu1f3vbYJT/xtiF5syA5HPIMtf9IgY/nKg0sWqzAUEvqY/xm7OcZc/qafLx/iO9FgOmeSAp4v5ti/Q=="],
+
+    "semver": ["semver@7.7.3", "", { "bin": { "semver": "bin/semver.js" } }, "sha512-SdsKMrI9TdgjdweUSR9MweHA4EJ8YxHn8DFaDisvhVlUOe4BF1tLD7GAj0lIqWVl+dPb/rExr0Btby5loQm20Q=="],
+
+    "server-only": ["server-only@0.0.1", "", {}, "sha512-qepMx2JxAa5jjfzxG79yPPq+8BuFToHd1hm7kI+Z4zAq1ftQiP7HcxMhDDItrbtwVeLg/cY2JnKnrcFkmiswNA=="],
+
+    "sharp": ["sharp@0.34.4", "", { "dependencies": { "@img/colour": "1.0.0", "detect-libc": "2.1.2", "semver": "7.7.3" }, "optionalDependencies": { "@img/sharp-darwin-arm64": "0.34.4", "@img/sharp-darwin-x64": "0.34.4", "@img/sharp-libvips-darwin-arm64": "1.2.3", "@img/sharp-libvips-darwin-x64": "1.2.3", "@img/sharp-libvips-linux-arm": "1.2.3", "@img/sharp-libvips-linux-arm64": "1.2.3", "@img/sharp-libvips-linux-ppc64": "1.2.3", "@img/sharp-libvips-linux-s390x": "1.2.3", "@img/sharp-libvips-linux-x64": "1.2.3", "@img/sharp-libvips-linuxmusl-arm64": "1.2.3", "@img/sharp-libvips-linuxmusl-x64": "1.2.3", "@img/sharp-linux-arm": "0.34.4", "@img/sharp-linux-arm64": "0.34.4", "@img/sharp-linux-ppc64": "0.34.4", "@img/sharp-linux-s390x": "0.34.4", "@img/sharp-linux-x64": "0.34.4", "@img/sharp-linuxmusl-arm64": "0.34.4", "@img/sharp-linuxmusl-x64": "0.34.4", "@img/sharp-wasm32": "0.34.4", "@img/sharp-win32-arm64": "0.34.4", "@img/sharp-win32-ia32": "0.34.4", "@img/sharp-win32-x64": "0.34.4" } }, "sha512-FUH39xp3SBPnxWvd5iib1X8XY7J0K0X7d93sie9CJg2PO8/7gmg89Nve6OjItK53/MlAushNNxteBYfM6DEuoA=="],
+
+    "shell-quote": ["shell-quote@1.8.3", "", {}, "sha512-ObmnIF4hXNg1BqhnHmgbDETF8dLPCggZWBjkQfhZpbszZnYur5DUljTcCHii5LC3J5E0yeO/1LIMyH+UvHQgyw=="],
+
+    "source-map": ["source-map@0.6.1", "", {}, "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g=="],
+
+    "source-map-js": ["source-map-js@1.2.1", "", {}, "sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA=="],
+
+    "source-map-support": ["source-map-support@0.5.21", "", { "dependencies": { "buffer-from": "1.1.2", "source-map": "0.6.1" } }, "sha512-uBHU3L3czsIyYXKX88fdrGovxdSCoTGDRZ6SYXtSRxLZUzHg5P/66Ht6uoUlHu9EZod+inXhKo3qQgwXUT/y1w=="],
+
+    "styled-jsx": ["styled-jsx@5.1.6", "", { "dependencies": { "client-only": "0.0.1" }, "peerDependencies": { "react": "19.2.0" } }, "sha512-qSVyDTeMotdvQYoHWLNGwRFJHC+i+ZvdBRYosOFgC+Wg1vx4frN2/RG/NA7SYqqvKNLf39P2LSRA2pu6n0XYZA=="],
+
+    "superjson": ["superjson@2.2.5", "", { "dependencies": { "copy-anything": "4.0.5" } }, "sha512-zWPTX96LVsA/eVYnqOM2+ofcdPqdS1dAF1LN4TS2/MWuUpfitd9ctTa87wt4xrYnZnkLtS69xpBdSxVBP5Rm6w=="],
+
+    "tailwindcss": ["tailwindcss@4.1.16", "", {}, "sha512-pONL5awpaQX4LN5eiv7moSiSPd/DLDzKVRJz8Q9PgzmAdd1R4307GQS2ZpfiN7ZmekdQrfhZZiSE5jkLR4WNaA=="],
+
+    "tapable": ["tapable@2.3.0", "", {}, "sha512-g9ljZiwki/LfxmQADO3dEY1CbpmXT5Hm2fJ+QaGKwSXUylMybePR7/67YW7jOrrvjEgL1Fmz5kzyAjWVWLlucg=="],
+
+    "tslib": ["tslib@2.8.1", "", {}, "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w=="],
+
+    "typescript": ["typescript@5.9.3", "", { "bin": { "tsc": "bin/tsc", "tsserver": "bin/tsserver" } }, "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw=="],
+
+    "undici-types": ["undici-types@6.21.0", "", {}, "sha512-iwDZqg0QAGrg9Rav5H4n0M64c3mkR59cJ6wQp+7C4nI0gsmExaedaYLNO44eT4AtBBwjbTiGPMlt2Md0T9H9JQ=="],
+
+    "which": ["which@4.0.0", "", { "dependencies": { "isexe": "3.1.1" }, "bin": { "node-which": "bin/which.js" } }, "sha512-GlaYyEb07DPxYCKhKzplCWBJtvxZcZMrL+4UkrTSJHHPyZU4mYYTv3qaOe77H7EODLSSopAUFAc6W8U4yqvscg=="],
+
+    "zod": ["zod@3.25.76", "", {}, "sha512-gzUt/qt81nXsFGKIFcC3YnfEAx5NkunCfnDlvuBSSFS02bcXu4Lmea0AFIUwbLWxWPx3d9p8S5QoaujKcNQxcQ=="],
+
+    "@esbuild-kit/core-utils/esbuild": ["esbuild@0.18.20", "", { "optionalDependencies": { "@esbuild/android-arm": "0.18.20", "@esbuild/android-arm64": "0.18.20", "@esbuild/android-x64": "0.18.20", "@esbuild/darwin-arm64": "0.18.20", "@esbuild/darwin-x64": "0.18.20", "@esbuild/freebsd-arm64": "0.18.20", "@esbuild/freebsd-x64": "0.18.20", "@esbuild/linux-arm": "0.18.20", "@esbuild/linux-arm64": "0.18.20", "@esbuild/linux-ia32": "0.18.20", "@esbuild/linux-loong64": "0.18.20", "@esbuild/linux-mips64el": "0.18.20", "@esbuild/linux-ppc64": "0.18.20", "@esbuild/linux-riscv64": "0.18.20", "@esbuild/linux-s390x": "0.18.20", "@esbuild/linux-x64": "0.18.20", "@esbuild/netbsd-x64": "0.18.20", "@esbuild/openbsd-x64": "0.18.20", "@esbuild/sunos-x64": "0.18.20", "@esbuild/win32-arm64": "0.18.20", "@esbuild/win32-ia32": "0.18.20", "@esbuild/win32-x64": "0.18.20" }, "bin": { "esbuild": "bin/esbuild" } }, "sha512-ceqxoedUrcayh7Y7ZX6NdbbDzGROiyVBgC4PriJThBKSVPWnnFHZAkfI1lJT8QFkOwH4qOS2SJkS4wvpGl8BpA=="],
+
+    "drizzle-kit/esbuild": ["esbuild@0.19.12", "", { "optionalDependencies": { "@esbuild/aix-ppc64": "0.19.12", "@esbuild/android-arm": "0.19.12", "@esbuild/android-arm64": "0.19.12", "@esbuild/android-x64": "0.19.12", "@esbuild/darwin-arm64": "0.19.12", "@esbuild/darwin-x64": "0.19.12", "@esbuild/freebsd-arm64": "0.19.12", "@esbuild/freebsd-x64": "0.19.12", "@esbuild/linux-arm": "0.19.12", "@esbuild/linux-arm64": "0.19.12", "@esbuild/linux-ia32": "0.19.12", "@esbuild/linux-loong64": "0.19.12", "@esbuild/linux-mips64el": "0.19.12", "@esbuild/linux-ppc64": "0.19.12", "@esbuild/linux-riscv64": "0.19.12", "@esbuild/linux-s390x": "0.19.12", "@esbuild/linux-x64": "0.19.12", "@esbuild/netbsd-x64": "0.19.12", "@esbuild/openbsd-x64": "0.19.12", "@esbuild/sunos-x64": "0.19.12", "@esbuild/win32-arm64": "0.19.12", "@esbuild/win32-ia32": "0.19.12", "@esbuild/win32-x64": "0.19.12" }, "bin": { "esbuild": "bin/esbuild" } }, "sha512-aARqgq8roFBj054KvQr5f1sFu0D65G+miZRCuJyJ0G13Zwx7vRar5Zhn2tkQNzIXcBrNVsv/8stehpj+GAjgbg=="],
+
+    "next/postcss": ["postcss@8.4.31", "", { "dependencies": { "nanoid": "3.3.11", "picocolors": "1.1.1", "source-map-js": "1.2.1" } }, "sha512-PS08Iboia9mts/2ygV3eLpY5ghnUcfLV/EXTOW1E2qYxJKGGBUtNjN76FYHnMs36RmARn41bC0AZmn+rR0OVpQ=="],
+
+    "next-auth/@auth/core": ["@auth/core@0.37.2", "", { "dependencies": { "@panva/hkdf": "1.2.1", "@types/cookie": "0.6.0", "cookie": "0.7.1", "jose": "5.10.0", "oauth4webapi": "3.8.2", "preact": "10.11.3", "preact-render-to-string": "5.2.3" } }, "sha512-kUvzyvkcd6h1vpeMAojK2y7+PAV5H+0Cc9+ZlKYDFhDY31AlvsB+GW5vNO4qE3Y07KeQgvNO9U0QUx/fN62kBw=="],
+
+    "@esbuild-kit/core-utils/esbuild/@esbuild/android-arm": ["@esbuild/android-arm@0.18.20", "", { "os": "android", "cpu": "arm" }, "sha512-fyi7TDI/ijKKNZTUJAQqiG5T7YjJXgnzkURqmGj13C6dCqckZBLdl4h7bkhHt/t0WP+zO9/zwroDvANaOqO5Sw=="],
+
+    "@esbuild-kit/core-utils/esbuild/@esbuild/android-arm64": ["@esbuild/android-arm64@0.18.20", "", { "os": "android", "cpu": "arm64" }, "sha512-Nz4rJcchGDtENV0eMKUNa6L12zz2zBDXuhj/Vjh18zGqB44Bi7MBMSXjgunJgjRhCmKOjnPuZp4Mb6OKqtMHLQ=="],
+
+    "@esbuild-kit/core-utils/esbuild/@esbuild/android-x64": ["@esbuild/android-x64@0.18.20", "", { "os": "android", "cpu": "x64" }, "sha512-8GDdlePJA8D6zlZYJV/jnrRAi6rOiNaCC/JclcXpB+KIuvfBN4owLtgzY2bsxnx666XjJx2kDPUmnTtR8qKQUg=="],
+
+    "@esbuild-kit/core-utils/esbuild/@esbuild/darwin-arm64": ["@esbuild/darwin-arm64@0.18.20", "", { "os": "darwin", "cpu": "arm64" }, "sha512-bxRHW5kHU38zS2lPTPOyuyTm+S+eobPUnTNkdJEfAddYgEcll4xkT8DB9d2008DtTbl7uJag2HuE5NZAZgnNEA=="],
+
+    "@esbuild-kit/core-utils/esbuild/@esbuild/darwin-x64": ["@esbuild/darwin-x64@0.18.20", "", { "os": "darwin", "cpu": "x64" }, "sha512-pc5gxlMDxzm513qPGbCbDukOdsGtKhfxD1zJKXjCCcU7ju50O7MeAZ8c4krSJcOIJGFR+qx21yMMVYwiQvyTyQ=="],
+
+    "@esbuild-kit/core-utils/esbuild/@esbuild/freebsd-arm64": ["@esbuild/freebsd-arm64@0.18.20", "", { "os": "freebsd", "cpu": "arm64" }, "sha512-yqDQHy4QHevpMAaxhhIwYPMv1NECwOvIpGCZkECn8w2WFHXjEwrBn3CeNIYsibZ/iZEUemj++M26W3cNR5h+Tw=="],
+
+    "@esbuild-kit/core-utils/esbuild/@esbuild/freebsd-x64": ["@esbuild/freebsd-x64@0.18.20", "", { "os": "freebsd", "cpu": "x64" }, "sha512-tgWRPPuQsd3RmBZwarGVHZQvtzfEBOreNuxEMKFcd5DaDn2PbBxfwLcj4+aenoh7ctXcbXmOQIn8HI6mCSw5MQ=="],
+
+    "@esbuild-kit/core-utils/esbuild/@esbuild/linux-arm": ["@esbuild/linux-arm@0.18.20", "", { "os": "linux", "cpu": "arm" }, "sha512-/5bHkMWnq1EgKr1V+Ybz3s1hWXok7mDFUMQ4cG10AfW3wL02PSZi5kFpYKrptDsgb2WAJIvRcDm+qIvXf/apvg=="],
+
+    "@esbuild-kit/core-utils/esbuild/@esbuild/linux-arm64": ["@esbuild/linux-arm64@0.18.20", "", { "os": "linux", "cpu": "arm64" }, "sha512-2YbscF+UL7SQAVIpnWvYwM+3LskyDmPhe31pE7/aoTMFKKzIc9lLbyGUpmmb8a8AixOL61sQ/mFh3jEjHYFvdA=="],
+
+    "@esbuild-kit/core-utils/esbuild/@esbuild/linux-ia32": ["@esbuild/linux-ia32@0.18.20", "", { "os": "linux", "cpu": "ia32" }, "sha512-P4etWwq6IsReT0E1KHU40bOnzMHoH73aXp96Fs8TIT6z9Hu8G6+0SHSw9i2isWrD2nbx2qo5yUqACgdfVGx7TA=="],
+
+    "@esbuild-kit/core-utils/esbuild/@esbuild/linux-loong64": ["@esbuild/linux-loong64@0.18.20", "", { "os": "linux", "cpu": "none" }, "sha512-nXW8nqBTrOpDLPgPY9uV+/1DjxoQ7DoB2N8eocyq8I9XuqJ7BiAMDMf9n1xZM9TgW0J8zrquIb/A7s3BJv7rjg=="],
+
+    "@esbuild-kit/core-utils/esbuild/@esbuild/linux-mips64el": ["@esbuild/linux-mips64el@0.18.20", "", { "os": "linux", "cpu": "none" }, "sha512-d5NeaXZcHp8PzYy5VnXV3VSd2D328Zb+9dEq5HE6bw6+N86JVPExrA6O68OPwobntbNJ0pzCpUFZTo3w0GyetQ=="],
+
+    "@esbuild-kit/core-utils/esbuild/@esbuild/linux-ppc64": ["@esbuild/linux-ppc64@0.18.20", "", { "os": "linux", "cpu": "ppc64" }, "sha512-WHPyeScRNcmANnLQkq6AfyXRFr5D6N2sKgkFo2FqguP44Nw2eyDlbTdZwd9GYk98DZG9QItIiTlFLHJHjxP3FA=="],
+
+    "@esbuild-kit/core-utils/esbuild/@esbuild/linux-riscv64": ["@esbuild/linux-riscv64@0.18.20", "", { "os": "linux", "cpu": "none" }, "sha512-WSxo6h5ecI5XH34KC7w5veNnKkju3zBRLEQNY7mv5mtBmrP/MjNBCAlsM2u5hDBlS3NGcTQpoBvRzqBcRtpq1A=="],
+
+    "@esbuild-kit/core-utils/esbuild/@esbuild/linux-s390x": ["@esbuild/linux-s390x@0.18.20", "", { "os": "linux", "cpu": "s390x" }, "sha512-+8231GMs3mAEth6Ja1iK0a1sQ3ohfcpzpRLH8uuc5/KVDFneH6jtAJLFGafpzpMRO6DzJ6AvXKze9LfFMrIHVQ=="],
+
+    "@esbuild-kit/core-utils/esbuild/@esbuild/linux-x64": ["@esbuild/linux-x64@0.18.20", "", { "os": "linux", "cpu": "x64" }, "sha512-UYqiqemphJcNsFEskc73jQ7B9jgwjWrSayxawS6UVFZGWrAAtkzjxSqnoclCXxWtfwLdzU+vTpcNYhpn43uP1w=="],
+
+    "@esbuild-kit/core-utils/esbuild/@esbuild/netbsd-x64": ["@esbuild/netbsd-x64@0.18.20", "", { "os": "none", "cpu": "x64" }, "sha512-iO1c++VP6xUBUmltHZoMtCUdPlnPGdBom6IrO4gyKPFFVBKioIImVooR5I83nTew5UOYrk3gIJhbZh8X44y06A=="],
+
+    "@esbuild-kit/core-utils/esbuild/@esbuild/openbsd-x64": ["@esbuild/openbsd-x64@0.18.20", "", { "os": "openbsd", "cpu": "x64" }, "sha512-e5e4YSsuQfX4cxcygw/UCPIEP6wbIL+se3sxPdCiMbFLBWu0eiZOJ7WoD+ptCLrmjZBK1Wk7I6D/I3NglUGOxg=="],
+
+    "@esbuild-kit/core-utils/esbuild/@esbuild/sunos-x64": ["@esbuild/sunos-x64@0.18.20", "", { "os": "sunos", "cpu": "x64" }, "sha512-kDbFRFp0YpTQVVrqUd5FTYmWo45zGaXe0X8E1G/LKFC0v8x0vWrhOWSLITcCn63lmZIxfOMXtCfti/RxN/0wnQ=="],
+
+    "@esbuild-kit/core-utils/esbuild/@esbuild/win32-arm64": ["@esbuild/win32-arm64@0.18.20", "", { "os": "win32", "cpu": "arm64" }, "sha512-ddYFR6ItYgoaq4v4JmQQaAI5s7npztfV4Ag6NrhiaW0RrnOXqBkgwZLofVTlq1daVTQNhtI5oieTvkRPfZrePg=="],
+
+    "@esbuild-kit/core-utils/esbuild/@esbuild/win32-ia32": ["@esbuild/win32-ia32@0.18.20", "", { "os": "win32", "cpu": "ia32" }, "sha512-Wv7QBi3ID/rROT08SABTS7eV4hX26sVduqDOTe1MvGMjNd3EjOz4b7zeexIR62GTIEKrfJXKL9LFxTYgkyeu7g=="],
+
+    "@esbuild-kit/core-utils/esbuild/@esbuild/win32-x64": ["@esbuild/win32-x64@0.18.20", "", { "os": "win32", "cpu": "x64" }, "sha512-kTdfRcSiDfQca/y9QIkng02avJ+NCaQvrMejlsB3RRv5sE9rRoeBPISaZpKxHELzRxZyLvNts1P27W3wV+8geQ=="],
+
+    "drizzle-kit/esbuild/@esbuild/aix-ppc64": ["@esbuild/aix-ppc64@0.19.12", "", { "os": "aix", "cpu": "ppc64" }, "sha512-bmoCYyWdEL3wDQIVbcyzRyeKLgk2WtWLTWz1ZIAZF/EGbNOwSA6ew3PftJ1PqMiOOGu0OyFMzG53L0zqIpPeNA=="],
+
+    "drizzle-kit/esbuild/@esbuild/android-arm": ["@esbuild/android-arm@0.19.12", "", { "os": "android", "cpu": "arm" }, "sha512-qg/Lj1mu3CdQlDEEiWrlC4eaPZ1KztwGJ9B6J+/6G+/4ewxJg7gqj8eVYWvao1bXrqGiW2rsBZFSX3q2lcW05w=="],
+
+    "drizzle-kit/esbuild/@esbuild/android-arm64": ["@esbuild/android-arm64@0.19.12", "", { "os": "android", "cpu": "arm64" }, "sha512-P0UVNGIienjZv3f5zq0DP3Nt2IE/3plFzuaS96vihvD0Hd6H/q4WXUGpCxD/E8YrSXfNyRPbpTq+T8ZQioSuPA=="],
+
+    "drizzle-kit/esbuild/@esbuild/android-x64": ["@esbuild/android-x64@0.19.12", "", { "os": "android", "cpu": "x64" }, "sha512-3k7ZoUW6Q6YqhdhIaq/WZ7HwBpnFBlW905Fa4s4qWJyiNOgT1dOqDiVAQFwBH7gBRZr17gLrlFCRzF6jFh7Kew=="],
+
+    "drizzle-kit/esbuild/@esbuild/darwin-arm64": ["@esbuild/darwin-arm64@0.19.12", "", { "os": "darwin", "cpu": "arm64" }, "sha512-B6IeSgZgtEzGC42jsI+YYu9Z3HKRxp8ZT3cqhvliEHovq8HSX2YX8lNocDn79gCKJXOSaEot9MVYky7AKjCs8g=="],
+
+    "drizzle-kit/esbuild/@esbuild/darwin-x64": ["@esbuild/darwin-x64@0.19.12", "", { "os": "darwin", "cpu": "x64" }, "sha512-hKoVkKzFiToTgn+41qGhsUJXFlIjxI/jSYeZf3ugemDYZldIXIxhvwN6erJGlX4t5h417iFuheZ7l+YVn05N3A=="],
+
+    "drizzle-kit/esbuild/@esbuild/freebsd-arm64": ["@esbuild/freebsd-arm64@0.19.12", "", { "os": "freebsd", "cpu": "arm64" }, "sha512-4aRvFIXmwAcDBw9AueDQ2YnGmz5L6obe5kmPT8Vd+/+x/JMVKCgdcRwH6APrbpNXsPz+K653Qg8HB/oXvXVukA=="],
+
+    "drizzle-kit/esbuild/@esbuild/freebsd-x64": ["@esbuild/freebsd-x64@0.19.12", "", { "os": "freebsd", "cpu": "x64" }, "sha512-EYoXZ4d8xtBoVN7CEwWY2IN4ho76xjYXqSXMNccFSx2lgqOG/1TBPW0yPx1bJZk94qu3tX0fycJeeQsKovA8gg=="],
+
+    "drizzle-kit/esbuild/@esbuild/linux-arm": ["@esbuild/linux-arm@0.19.12", "", { "os": "linux", "cpu": "arm" }, "sha512-J5jPms//KhSNv+LO1S1TX1UWp1ucM6N6XuL6ITdKWElCu8wXP72l9MM0zDTzzeikVyqFE6U8YAV9/tFyj0ti+w=="],
+
+    "drizzle-kit/esbuild/@esbuild/linux-arm64": ["@esbuild/linux-arm64@0.19.12", "", { "os": "linux", "cpu": "arm64" }, "sha512-EoTjyYyLuVPfdPLsGVVVC8a0p1BFFvtpQDB/YLEhaXyf/5bczaGeN15QkR+O4S5LeJ92Tqotve7i1jn35qwvdA=="],
+
+    "drizzle-kit/esbuild/@esbuild/linux-ia32": ["@esbuild/linux-ia32@0.19.12", "", { "os": "linux", "cpu": "ia32" }, "sha512-Thsa42rrP1+UIGaWz47uydHSBOgTUnwBwNq59khgIwktK6x60Hivfbux9iNR0eHCHzOLjLMLfUMLCypBkZXMHA=="],
+
+    "drizzle-kit/esbuild/@esbuild/linux-loong64": ["@esbuild/linux-loong64@0.19.12", "", { "os": "linux", "cpu": "none" }, "sha512-LiXdXA0s3IqRRjm6rV6XaWATScKAXjI4R4LoDlvO7+yQqFdlr1Bax62sRwkVvRIrwXxvtYEHHI4dm50jAXkuAA=="],
+
+    "drizzle-kit/esbuild/@esbuild/linux-mips64el": ["@esbuild/linux-mips64el@0.19.12", "", { "os": "linux", "cpu": "none" }, "sha512-fEnAuj5VGTanfJ07ff0gOA6IPsvrVHLVb6Lyd1g2/ed67oU1eFzL0r9WL7ZzscD+/N6i3dWumGE1Un4f7Amf+w=="],
+
+    "drizzle-kit/esbuild/@esbuild/linux-ppc64": ["@esbuild/linux-ppc64@0.19.12", "", { "os": "linux", "cpu": "ppc64" }, "sha512-nYJA2/QPimDQOh1rKWedNOe3Gfc8PabU7HT3iXWtNUbRzXS9+vgB0Fjaqr//XNbd82mCxHzik2qotuI89cfixg=="],
+
+    "drizzle-kit/esbuild/@esbuild/linux-riscv64": ["@esbuild/linux-riscv64@0.19.12", "", { "os": "linux", "cpu": "none" }, "sha512-2MueBrlPQCw5dVJJpQdUYgeqIzDQgw3QtiAHUC4RBz9FXPrskyyU3VI1hw7C0BSKB9OduwSJ79FTCqtGMWqJHg=="],
+
+    "drizzle-kit/esbuild/@esbuild/linux-s390x": ["@esbuild/linux-s390x@0.19.12", "", { "os": "linux", "cpu": "s390x" }, "sha512-+Pil1Nv3Umes4m3AZKqA2anfhJiVmNCYkPchwFJNEJN5QxmTs1uzyy4TvmDrCRNT2ApwSari7ZIgrPeUx4UZDg=="],
+
+    "drizzle-kit/esbuild/@esbuild/linux-x64": ["@esbuild/linux-x64@0.19.12", "", { "os": "linux", "cpu": "x64" }, "sha512-B71g1QpxfwBvNrfyJdVDexenDIt1CiDN1TIXLbhOw0KhJzE78KIFGX6OJ9MrtC0oOqMWf+0xop4qEU8JrJTwCg=="],
+
+    "drizzle-kit/esbuild/@esbuild/netbsd-x64": ["@esbuild/netbsd-x64@0.19.12", "", { "os": "none", "cpu": "x64" }, "sha512-3ltjQ7n1owJgFbuC61Oj++XhtzmymoCihNFgT84UAmJnxJfm4sYCiSLTXZtE00VWYpPMYc+ZQmB6xbSdVh0JWA=="],
+
+    "drizzle-kit/esbuild/@esbuild/openbsd-x64": ["@esbuild/openbsd-x64@0.19.12", "", { "os": "openbsd", "cpu": "x64" }, "sha512-RbrfTB9SWsr0kWmb9srfF+L933uMDdu9BIzdA7os2t0TXhCRjrQyCeOt6wVxr79CKD4c+p+YhCj31HBkYcXebw=="],
+
+    "drizzle-kit/esbuild/@esbuild/sunos-x64": ["@esbuild/sunos-x64@0.19.12", "", { "os": "sunos", "cpu": "x64" }, "sha512-HKjJwRrW8uWtCQnQOz9qcU3mUZhTUQvi56Q8DPTLLB+DawoiQdjsYq+j+D3s9I8VFtDr+F9CjgXKKC4ss89IeA=="],
+
+    "drizzle-kit/esbuild/@esbuild/win32-arm64": ["@esbuild/win32-arm64@0.19.12", "", { "os": "win32", "cpu": "arm64" }, "sha512-URgtR1dJnmGvX864pn1B2YUYNzjmXkuJOIqG2HdU62MVS4EHpU2946OZoTMnRUHklGtJdJZ33QfzdjGACXhn1A=="],
+
+    "drizzle-kit/esbuild/@esbuild/win32-ia32": ["@esbuild/win32-ia32@0.19.12", "", { "os": "win32", "cpu": "ia32" }, "sha512-+ZOE6pUkMOJfmxmBZElNOx72NKpIa/HFOMGzu8fqzQJ5kgf6aTGrcJaFsNiVMH4JKpMipyK+7k0n2UXN7a8YKQ=="],
+
+    "drizzle-kit/esbuild/@esbuild/win32-x64": ["@esbuild/win32-x64@0.19.12", "", { "os": "win32", "cpu": "x64" }, "sha512-T1QyPSDCyMXaO3pzBkF96E8xMkiRYbUEZADd29SyPGabqxMViNoii+NcK7eWJAEoU6RZyEm5lVSIjTmcdoB9HA=="],
+
+    "next-auth/@auth/core/jose": ["jose@5.10.0", "", {}, "sha512-s+3Al/p9g32Iq+oqXxkW//7jk2Vig6FF1CFqzVXoTUXt2qz89YWbL+OwS17NFYEvxC35n0FKeGO2LGYSxeM2Gg=="],
+
+    "next-auth/@auth/core/preact": ["preact@10.11.3", "", {}, "sha512-eY93IVpod/zG3uMF22Unl8h9KkrcKIRs2EGar8hwLZZDU1lkjph303V9HZBwufh2s736U6VXuhD109LYqPoffg=="],
+
+    "next-auth/@auth/core/preact-render-to-string": ["preact-render-to-string@5.2.3", "", { "dependencies": { "pretty-format": "3.8.0" }, "peerDependencies": { "preact": "10.11.3" } }, "sha512-aPDxUn5o3GhWdtJtW0svRC2SS/l8D9MAgo2+AWml+BhDImb27ALf04Q2d+AHqUUOc6RdSXFIBVa2gxzgMKgtZA=="],
+  }
+}

bench/install/next-env.d.ts

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

bench/install/next.config.js

@@ -0,0 +1,10 @@
+/**
+ * Run `build` or `dev` with `SKIP_ENV_VALIDATION` to skip env validation. This is especially useful
+ * for Docker builds.
+ */
+import "./src/env.js";
+
+/** @type {import("next").NextConfig} */
+const config = {};
+
+export default config;

bench/install/package.json

@@ -1,31 +1,52 @@
 {
+  "name": "installbench",
+  "version": "0.1.0",
   "private": true,
-  "sideEffects": false,
+  "type": "module",
   "scripts": {
-    "build": "remix build",
-    "dev": "remix dev",
-    "start": "remix-serve build",
-    "typecheck": "tsc",
-    "clean": "rm -rf node_modules",
-    "bench": "hyperfine --prepare 'rm -rf node_modules' --warmup 1 --runs 3 'bun install' 'pnpm install' 'yarn' 'npm install'"
+    "build": "next build",
+    "check": "biome check .",
+    "check:unsafe": "biome check --write --unsafe .",
+    "check:write": "biome check --write .",
+    "db:generate": "drizzle-kit generate",
+    "db:migrate": "drizzle-kit migrate",
+    "db:push": "drizzle-kit push",
+    "db:studio": "drizzle-kit studio",
+    "dev": "next dev --turbo",
+    "preview": "next build && next start",
+    "start": "next start",
+    "typecheck": "tsc --noEmit"
   },
   "dependencies": {
-    "@remix-run/node": "^1.15.0",
-    "@remix-run/react": "^1.15.0",
-    "@remix-run/serve": "^1.15.0",
-    "isbot": "^3.6.5",
-    "react": "^18.2.0",
-    "react-dom": "^18.2.0"
+    "@auth/drizzle-adapter": "^1.7.2",
+    "@t3-oss/env-nextjs": "^0.12.0",
+    "@tanstack/react-query": "^5.69.0",
+    "@trpc/client": "^11.0.0",
+    "@trpc/react-query": "^11.0.0",
+    "@trpc/server": "^11.0.0",
+    "drizzle-orm": "^0.41.0",
+    "esbuild": "^0.25.11",
+    "next": "15.5.7",
+    "next-auth": "5.0.0-beta.25",
+    "postgres": "^3.4.4",
+    "react": "^19.0.0",
+    "react-dom": "^19.0.0",
+    "server-only": "^0.0.1",
+    "superjson": "^2.2.1",
+    "zod": "^3.24.2"
   },
   "devDependencies": {
-    "@remix-run/dev": "^1.15.0",
-    "@remix-run/eslint-config": "^1.15.0",
-    "@types/react": "^18.0.25",
-    "@types/react-dom": "^18.0.8",
-    "eslint": "^8.27.0",
-    "typescript": "^4.8.4"
+    "@biomejs/biome": "1.9.4",
+    "@tailwindcss/postcss": "^4.0.15",
+    "@types/node": "^20.14.10",
+    "@types/react": "^19.0.0",
+    "@types/react-dom": "^19.0.0",
+    "drizzle-kit": "^0.30.5",
+    "postcss": "^8.5.3",
+    "tailwindcss": "^4.0.15",
+    "typescript": "^5.8.2"
   },
-  "engines": {
-    "node": ">=14"
+  "ct3aMetadata": {
+    "initVersion": "7.39.3"
   }
 }

bench/install/remix.config.js

@@ -1,14 +0,0 @@
-/** @type {import('@remix-run/dev').AppConfig} */
-module.exports = {
-  ignoredRouteFiles: ["**/.*"],
-  // appDirectory: "app",
-  // assetsBuildDirectory: "public/build",
-  // serverBuildPath: "build/index.js",
-  // publicPath: "/build/",
-  future: {
-    v2_errorBoundary: true,
-    v2_meta: true,
-    v2_normalizeFormMethod: true,
-    v2_routeConvention: true,
-  },
-};

bench/install/remix.env.d.ts

@@ -1,2 +0,0 @@
-/// <reference types="@remix-run/dev" />
-/// <reference types="@remix-run/node" />

bench/install/tsconfig.json

@@ -1,22 +0,0 @@
-{
-  "include": ["remix.env.d.ts", "**/*.ts", "**/*.tsx"],
-  "compilerOptions": {
-    "lib": ["DOM", "DOM.Iterable", "ES2019"],
-    "isolatedModules": true,
-    "esModuleInterop": true,
-    "jsx": "react-jsx",
-    "moduleResolution": "node",
-    "resolveJsonModule": true,
-    "target": "ES2019",
-    "strict": true,
-    "allowJs": true,
-    "forceConsistentCasingInFileNames": true,
-    "baseUrl": ".",
-    "paths": {
-      "~/*": ["./app/*"]
-    },
-
-    // Remix takes care of building everything in `remix build`.
-    "noEmit": true
-  }
-}

bench/package.json

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

bench/runner.mjs

@@ -13,7 +13,4 @@ export function run(opts = {}) {
 }
 
 export const bench = Mitata.bench;
-
-export function group(_name, fn) {
-  return Mitata.group(fn);
-}
+export const group = Mitata.group;

bench/snippets/archive.mjs

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

bench/snippets/array-of.js

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

bench/snippets/compression-streams.mjs

@@ -0,0 +1,156 @@
+import { bench, group, run } from "../runner.mjs";
+
+const runAll = !process.argv.includes("--simple");
+
+const small = new Uint8Array(1024);
+const medium = new Uint8Array(1024 * 100);
+const large = new Uint8Array(1024 * 1024);
+
+for (let i = 0; i < large.length; i++) {
+  const value = Math.floor(Math.sin(i / 100) * 128 + 128);
+  if (i < small.length) small[i] = value;
+  if (i < medium.length) medium[i] = value;
+  large[i] = value;
+}
+
+const format = new Intl.NumberFormat("en-US", { notation: "compact", unit: "byte" });
+
+async function compress(data, format) {
+  const cs = new CompressionStream(format);
+  const writer = cs.writable.getWriter();
+  const reader = cs.readable.getReader();
+
+  writer.write(data);
+  writer.close();
+
+  const chunks = [];
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    chunks.push(value);
+  }
+
+  const result = new Uint8Array(chunks.reduce((acc, chunk) => acc + chunk.length, 0));
+  let offset = 0;
+  for (const chunk of chunks) {
+    result.set(chunk, offset);
+    offset += chunk.length;
+  }
+  return result;
+}
+
+async function decompress(data, format) {
+  const ds = new DecompressionStream(format);
+  const writer = ds.writable.getWriter();
+  const reader = ds.readable.getReader();
+
+  writer.write(data);
+  writer.close();
+
+  const chunks = [];
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    chunks.push(value);
+  }
+
+  const result = new Uint8Array(chunks.reduce((acc, chunk) => acc + chunk.length, 0));
+  let offset = 0;
+  for (const chunk of chunks) {
+    result.set(chunk, offset);
+    offset += chunk.length;
+  }
+  return result;
+}
+
+async function roundTrip(data, format) {
+  const compressed = await compress(data, format);
+  return await decompress(compressed, format);
+}
+
+const formats = ["deflate", "gzip", "deflate-raw"];
+if (runAll) formats.push("brotli", "zstd");
+
+// Small data benchmarks (1KB)
+group(`CompressionStream ${format.format(small.length)}`, () => {
+  for (const fmt of formats) {
+    try {
+      new CompressionStream(fmt);
+      bench(fmt, async () => await compress(small, fmt));
+    } catch (e) {
+      // Skip unsupported formats
+    }
+  }
+});
+
+// Medium data benchmarks (100KB)
+group(`CompressionStream ${format.format(medium.length)}`, () => {
+  for (const fmt of formats) {
+    try {
+      new CompressionStream(fmt);
+      bench(fmt, async () => await compress(medium, fmt));
+    } catch (e) {}
+  }
+});
+
+// Large data benchmarks (1MB)
+group(`CompressionStream ${format.format(large.length)}`, () => {
+  for (const fmt of formats) {
+    try {
+      new CompressionStream(fmt);
+      bench(fmt, async () => await compress(large, fmt));
+    } catch (e) {
+      // Skip unsupported formats
+    }
+  }
+});
+
+const compressedData = {};
+for (const fmt of formats) {
+  try {
+    compressedData[fmt] = {
+      small: await compress(small, fmt),
+      medium: await compress(medium, fmt),
+      large: await compress(large, fmt),
+    };
+  } catch (e) {
+    // Skip unsupported formats
+  }
+}
+
+group(`DecompressionStream ${format.format(small.length)}`, () => {
+  for (const fmt of formats) {
+    if (compressedData[fmt]) {
+      bench(fmt, async () => await decompress(compressedData[fmt].small, fmt));
+    }
+  }
+});
+
+group(`DecompressionStream ${format.format(medium.length)}`, () => {
+  for (const fmt of formats) {
+    if (compressedData[fmt]) {
+      bench(fmt, async () => await decompress(compressedData[fmt].medium, fmt));
+    }
+  }
+});
+
+group(`DecompressionStream ${format.format(large.length)}`, () => {
+  for (const fmt of formats) {
+    if (compressedData[fmt]) {
+      bench(fmt, async () => await decompress(compressedData[fmt].large, fmt));
+    }
+  }
+});
+
+group(`roundtrip ${format.format(large.length)}`, () => {
+  for (const fmt of formats) {
+    try {
+      new CompressionStream(fmt);
+      bench(fmt, async () => await roundTrip(large, fmt));
+    } catch (e) {
+      // Skip unsupported formats
+    }
+  }
+});
+
+await run();

bench/snippets/ipc-json-child.mjs

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

bench/snippets/ipc-json.mjs

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

bench/snippets/object-hasown.mjs

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

bench/snippets/promise-race.mjs

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

bench/snippets/require-builtins.mjs

@@ -11,10 +11,10 @@ const builtin = ${JSON.stringify(builtin)};
 const now = performance.now();
 require(builtin);
 const end = performance.now();
-process.stdout.write(JSON.stringify({builtin, time: end - now}) + "\\n");
+process.stdout.write(JSON.stringify({ builtin, time: end - now }) + "\\n");
   `,
   );
-  const result = spawnSync(typeof Bun !== "undefined" ? "bun" : "node", [path], {
+  spawnSync(process.execPath, [path], {
     stdio: ["inherit", "inherit", "inherit"],
     env: {
       ...process.env,

bench/snippets/response-json.mjs

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

bench/snippets/string-includes.mjs

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

bench/snippets/urlpattern.js

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

build.zig

@@ -18,22 +18,6 @@ const OperatingSystem = @import("src/env.zig").OperatingSystem;
 
 const pathRel = fs.path.relative;
 
-/// When updating this, make sure to adjust SetupZig.cmake
-const recommended_zig_version = "0.14.0";
-
-// comptime {
-//     if (!std.mem.eql(u8, builtin.zig_version_string, recommended_zig_version)) {
-//         @compileError(
-//             "" ++
-//                 "Bun requires Zig version " ++ recommended_zig_version ++ ", but you have " ++
-//                 builtin.zig_version_string ++ ". This is automatically configured via Bun's " ++
-//                 "CMake setup. You likely meant to run `bun run build`. If you are trying to " ++
-//                 "upgrade the Zig compiler, edit ZIG_COMMIT in cmake/tools/SetupZig.cmake or " ++
-//                 "comment this error out.",
-//         );
-//     }
-// }
-
 const zero_sha = "0000000000000000000000000000000000000000";
 
 const BunBuildOptions = struct {
@@ -48,6 +32,7 @@ const BunBuildOptions = struct {
     /// enable debug logs in release builds
     enable_logs: bool = false,
     enable_asan: bool,
+    enable_fuzzilli: bool,
     enable_valgrind: bool,
     use_mimalloc: bool,
     tracy_callstack_depth: u16,
@@ -97,9 +82,10 @@ const BunBuildOptions = struct {
         opts.addOption(bool, "baseline", this.isBaseline());
         opts.addOption(bool, "enable_logs", this.enable_logs);
         opts.addOption(bool, "enable_asan", this.enable_asan);
+        opts.addOption(bool, "enable_fuzzilli", this.enable_fuzzilli);
         opts.addOption(bool, "enable_valgrind", this.enable_valgrind);
         opts.addOption(bool, "use_mimalloc", this.use_mimalloc);
-        opts.addOption([]const u8, "reported_nodejs_version", b.fmt("{}", .{this.reported_nodejs_version}));
+        opts.addOption([]const u8, "reported_nodejs_version", b.fmt("{f}", .{this.reported_nodejs_version}));
         opts.addOption(bool, "zig_self_hosted_backend", this.no_llvm);
         opts.addOption(bool, "override_no_export_cpp_apis", this.override_no_export_cpp_apis);
 
@@ -134,8 +120,8 @@ pub fn getOSVersionMin(os: OperatingSystem) ?Target.Query.OsVersion {
 
 pub fn getOSGlibCVersion(os: OperatingSystem) ?Version {
     return switch (os) {
-        // Compiling with a newer glibc than this will break certain cloud environments.
-        .linux => .{ .major = 2, .minor = 27, .patch = 0 },
+        // Compiling with a newer glibc than this will break certain cloud environments. See symbols.test.ts.
+        .linux => .{ .major = 2, .minor = 26, .patch = 0 },
 
         else => null,
     };
@@ -271,6 +257,7 @@ pub fn build(b: *Build) !void {
         .tracy_callstack_depth = b.option(u16, "tracy_callstack_depth", "") orelse 10,
         .enable_logs = b.option(bool, "enable_logs", "Enable logs in release") orelse false,
         .enable_asan = b.option(bool, "enable_asan", "Enable asan") orelse false,
+        .enable_fuzzilli = b.option(bool, "enable_fuzzilli", "Enable fuzzilli instrumentation") orelse false,
         .enable_valgrind = b.option(bool, "enable_valgrind", "Enable valgrind") orelse false,
         .use_mimalloc = b.option(bool, "use_mimalloc", "Use mimalloc as default allocator") orelse false,
         .llvm_codegen_threads = b.option(u32, "llvm_codegen_threads", "Number of threads to use for LLVM codegen") orelse 1,
@@ -290,14 +277,16 @@ pub fn build(b: *Build) !void {
         var o = build_options;
         var unit_tests = b.addTest(.{
             .name = "bun-test",
-            .optimize = build_options.optimize,
-            .root_source_file = b.path("src/unit_test.zig"),
             .test_runner = .{ .path = b.path("src/main_test.zig"), .mode = .simple },
-            .target = build_options.target,
+            .root_module = b.createModule(.{
+                .optimize = build_options.optimize,
+                .root_source_file = b.path("src/unit_test.zig"),
+                .target = build_options.target,
+                .omit_frame_pointer = false,
+                .strip = false,
+            }),
             .use_llvm = !build_options.no_llvm,
             .use_lld = if (build_options.os == .mac) false else !build_options.no_llvm,
-            .omit_frame_pointer = false,
-            .strip = false,
         });
         configureObj(b, &o, unit_tests);
         // Setting `linker_allow_shlib_undefined` causes the linker to ignore
@@ -331,6 +320,7 @@ pub fn build(b: *Build) !void {
         var step = b.step("check", "Check for semantic analysis errors");
         var bun_check_obj = addBunObject(b, &build_options);
         bun_check_obj.generated_bin = null;
+        // bun_check_obj.use_llvm = false;
         step.dependOn(&bun_check_obj.step);
 
         // The default install step will run zig build check. This is so ZLS
@@ -503,6 +493,7 @@ fn addMultiCheck(
                 .no_llvm = root_build_options.no_llvm,
                 .enable_asan = root_build_options.enable_asan,
                 .enable_valgrind = root_build_options.enable_valgrind,
+                .enable_fuzzilli = root_build_options.enable_fuzzilli,
                 .use_mimalloc = root_build_options.use_mimalloc,
                 .override_no_export_cpp_apis = root_build_options.override_no_export_cpp_apis,
             };
@@ -616,15 +607,22 @@ fn configureObj(b: *Build, opts: *BunBuildOptions, obj: *Compile) void {
             obj.llvm_codegen_threads = opts.llvm_codegen_threads orelse 0;
     }
 
-    obj.no_link_obj = true;
+    obj.no_link_obj = opts.os != .windows and !opts.no_llvm;
+
 
     if (opts.enable_asan and !enableFastBuild(b)) {
         if (@hasField(Build.Module, "sanitize_address")) {
+            if (opts.enable_fuzzilli) {
+                obj.sanitize_coverage_trace_pc_guard = true;
+            }
             obj.root_module.sanitize_address = true;
         } else {
             const fail_step = b.addFail("asan is not supported on this platform");
             obj.step.dependOn(&fail_step.step);
         }
+    } else if (opts.enable_fuzzilli) {
+        const fail_step = b.addFail("fuzzilli requires asan");
+        obj.step.dependOn(&fail_step.step);
     }
     obj.bundle_compiler_rt = false;
     obj.bundle_ubsan_rt = false;
@@ -779,6 +777,13 @@ fn addInternalImports(b: *Build, mod: *Module, opts: *BunBuildOptions) void {
         mod.addImport("cpp", cppImport);
         cppImport.addImport("bun", mod);
     }
+    {
+        const ciInfoImport = b.createModule(.{
+            .root_source_file = (std.Build.LazyPath{ .cwd_relative = opts.codegen_path }).path(b, "ci_info.zig"),
+        });
+        mod.addImport("ci_info", ciInfoImport);
+        ciInfoImport.addImport("bun", mod);
+    }
     inline for (.{
         .{ .import = "completions-bash", .file = b.path("completions/bun.bash") },
         .{ .import = "completions-zsh", .file = b.path("completions/bun.zsh") },
@@ -804,7 +809,7 @@ fn addInternalImports(b: *Build, mod: *Module, opts: *BunBuildOptions) void {
 fn propagateImports(source_mod: *Module) !void {
     var seen = std.AutoHashMap(*Module, void).init(source_mod.owner.graph.arena);
     defer seen.deinit();
-    var queue = std.ArrayList(*Module).init(source_mod.owner.graph.arena);
+    var queue = std.array_list.Managed(*Module).init(source_mod.owner.graph.arena);
     defer queue.deinit();
     try queue.appendSlice(source_mod.import_table.values());
     while (queue.pop()) |mod| {

bun.lock

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

bunfig.toml

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

cmake/CompilerFlags.cmake

@@ -51,6 +51,23 @@ if(ENABLE_ASAN)
   )
 endif()
 
+if(ENABLE_FUZZILLI)
+  register_compiler_flags(
+    DESCRIPTION "Enable coverage instrumentation for fuzzing"
+    -fsanitize-coverage=trace-pc-guard
+  )
+
+  register_linker_flags(
+    DESCRIPTION "Link coverage instrumentation"
+    -fsanitize-coverage=trace-pc-guard
+  )
+
+  register_compiler_flags(
+    DESCRIPTION "Enable fuzzilli-specific code"
+    -DFUZZILLI_ENABLED
+  )
+endif()
+
 # --- Optimization level ---
 if(DEBUG)
   register_compiler_flags(
@@ -215,46 +232,6 @@ if(ENABLE_ASSERTIONS)
     DESCRIPTION "Do not eliminate null-pointer checks"
     -fno-delete-null-pointer-checks
   )
-
-  register_compiler_definitions(
-    DESCRIPTION "Enable libc++ assertions"
-    _LIBCPP_ENABLE_ASSERTIONS=1
-    _LIBCPP_HARDENING_MODE=_LIBCPP_HARDENING_MODE_EXTENSIVE ${RELEASE}
-    _LIBCPP_HARDENING_MODE=_LIBCPP_HARDENING_MODE_DEBUG ${DEBUG}
-  )
-
-  # Nix glibc already sets _FORTIFY_SOURCE, don't override it
-  if(NOT DEFINED ENV{NIX_CC})
-    register_compiler_definitions(
-      DESCRIPTION "Enable fortified sources (Release only)"
-      _FORTIFY_SOURCE=3 ${RELEASE}
-    )
-  endif()
-
-  if(LINUX)
-    register_compiler_definitions(
-      DESCRIPTION "Enable glibc++ assertions"
-      _GLIBCXX_ASSERTIONS=1
-    )
-  endif()
-else()
-  register_compiler_definitions(
-    DESCRIPTION "Disable debug assertions"
-    NDEBUG=1
-  )
-
-  register_compiler_definitions(
-    DESCRIPTION "Disable libc++ assertions"
-    _LIBCPP_ENABLE_ASSERTIONS=0
-    _LIBCPP_HARDENING_MODE=_LIBCPP_HARDENING_MODE_NONE
-  )
-
-  if(LINUX)
-    register_compiler_definitions(
-      DESCRIPTION "Disable glibc++ assertions"
-      _GLIBCXX_ASSERTIONS=0
-    )
-  endif()
 endif()
 
 # --- Diagnostics ---
@@ -305,14 +282,6 @@ if(UNIX AND CI)
   )
 endif()
 
-# --- Features ---
-
-# Valgrind cannot handle SSE4.2 instructions
-# This is needed for picohttpparser
-if(ENABLE_VALGRIND AND ARCH STREQUAL "x64")
-  register_compiler_definitions(__SSE4_2__=0)
-endif()
-
 # --- Other ---
 
 # Workaround for CMake and clang-cl bug.

cmake/Globals.cmake

@@ -125,7 +125,8 @@ setx(CWD ${CMAKE_SOURCE_DIR})
 setx(BUILD_PATH ${CMAKE_BINARY_DIR})
 
 optionx(CACHE_PATH FILEPATH "The path to the cache directory" DEFAULT ${BUILD_PATH}/cache)
-optionx(CACHE_STRATEGY "read-write|read-only|write-only|none" "The strategy to use for caching" DEFAULT "read-write")
+optionx(CACHE_STRATEGY "auto|distributed|local|none" "The strategy to use for caching" DEFAULT
+"auto")
 
 optionx(CI BOOL "If CI is enabled" DEFAULT OFF)
 optionx(ENABLE_ANALYSIS BOOL "If static analysis targets should be enabled" DEFAULT OFF)
@@ -136,21 +137,44 @@ else()
   set(WARNING WARNING)
 endif()
 
-# TODO: This causes flaky zig builds in CI, so temporarily disable it.
-# if(CI)
-#   set(DEFAULT_VENDOR_PATH ${CACHE_PATH}/vendor)
-# else()
-#   set(DEFAULT_VENDOR_PATH ${CWD}/vendor)
-# endif()
-
 optionx(VENDOR_PATH FILEPATH "The path to the vendor directory" DEFAULT ${CWD}/vendor)
 optionx(TMP_PATH FILEPATH "The path to the temporary directory" DEFAULT ${BUILD_PATH}/tmp)
 
 # --- Helper functions ---
 
+# list_filter_out_regex()
+#
+# Description:
+#   Filters out elements from a list that match a regex pattern.
+#
+# Arguments:
+#   list - The list of strings to traverse
+#   pattern - The regex pattern to filter out
+#   touched - A variable to set if any items were removed
+function(list_filter_out_regex list pattern touched)
+  set(result_list "${${list}}")
+  set(keep_list)
+  set(was_modified OFF)
+
+  foreach(line IN LISTS result_list)
+    if(line MATCHES "${pattern}")
+      set(was_modified ON)
+    else()
+      list(APPEND keep_list ${line})
+    endif()
+  endforeach()
+
+  set(${list} "${keep_list}" PARENT_SCOPE)
+  set(${touched} ${was_modified} PARENT_SCOPE)
+endfunction()
+
 # setenv()
 # Description:
 #   Sets an environment variable during the build step, and writes it to a .env file.
+#
+# See Also:
+#   unsetenv()
+#
 # Arguments:
 #   variable string - The variable to set
 #   value    string - The value to set the variable to
@@ -163,13 +187,7 @@ function(setenv variable value)
 
   if(EXISTS ${ENV_PATH})
     file(STRINGS ${ENV_PATH} ENV_FILE ENCODING UTF-8)
-
-    foreach(line ${ENV_FILE})
-      if(line MATCHES "^${variable}=")
-        list(REMOVE_ITEM ENV_FILE ${line})
-        set(ENV_MODIFIED ON)
-      endif()
-    endforeach()
+    list_filter_out_regex(ENV_FILE "^${variable}=" ENV_MODIFIED)
 
     if(ENV_MODIFIED)
       list(APPEND ENV_FILE "${variable}=${value}")
@@ -185,6 +203,28 @@ function(setenv variable value)
   message(STATUS "Set ENV ${variable}: ${value}")
 endfunction()
 
+# See setenv()
+# Description:
+#   Exact opposite of setenv().
+# Arguments:
+#   variable string - The variable to unset.
+# See Also:
+#   setenv()
+function(unsetenv variable)
+  set(ENV_PATH ${BUILD_PATH}/.env)
+  if(NOT EXISTS ${ENV_PATH})
+    return()
+  endif()
+
+  file(STRINGS ${ENV_PATH} ENV_FILE ENCODING UTF-8)
+  list_filter_out_regex(ENV_FILE "^${variable}=" ENV_MODIFIED)
+
+  if(ENV_MODIFIED)
+    list(JOIN ENV_FILE "\n" ENV_FILE)
+    file(WRITE ${ENV_PATH} ${ENV_FILE})
+  endif()
+endfunction()
+
 # satisfies_range()
 # Description:
 #   Check if a version satisfies a version range or list of ranges
@@ -317,7 +357,7 @@ function(find_command)
     ${FIND_VALIDATOR}
   )
 
-  if(NOT FIND_REQUIRED STREQUAL "OFF" AND ${FIND_VARIABLE} MATCHES "NOTFOUND")
+  if(FIND_REQUIRED AND ${FIND_VARIABLE} MATCHES "NOTFOUND")
     set(error "Command not found: \"${FIND_NAME}\"")
 
     if(FIND_VERSION)
@@ -917,10 +957,6 @@ function(register_compiler_flags)
   endforeach()
 endfunction()
 
-function(register_compiler_definitions)
-
-endfunction()
-
 # register_linker_flags()
 # Description:
 #   Registers a linker flag, similar to `add_link_options()`.

cmake/Options.cmake

@@ -127,6 +127,8 @@ if (NOT ENABLE_ASAN)
   set(ENABLE_ZIG_ASAN OFF)
 endif()
 
+optionx(ENABLE_FUZZILLI BOOL "If fuzzilli support should be enabled" DEFAULT OFF)
+
 if(RELEASE AND LINUX AND CI AND NOT ENABLE_ASSERTIONS AND NOT ENABLE_ASAN)
   set(DEFAULT_LTO ON)
 else()
@@ -140,11 +142,6 @@ if(ENABLE_ASAN AND ENABLE_LTO)
   setx(ENABLE_LTO OFF)
 endif()
 
-if(USE_VALGRIND AND NOT USE_BASELINE)
-  message(WARNING "If valgrind is enabled, baseline must also be enabled")
-  setx(USE_BASELINE ON)
-endif()
-
 if(BUILDKITE_COMMIT)
   set(DEFAULT_REVISION ${BUILDKITE_COMMIT})
 else()

cmake/analysis/RunClangFormat.cmake

@@ -34,26 +34,6 @@ register_command(
   ALWAYS_RUN
 )
 
-if(GIT_CHANGED_SOURCES)
-  set(CLANG_FORMAT_CHANGED_SOURCES)
-  foreach(source ${CLANG_FORMAT_SOURCES})
-    list(FIND GIT_CHANGED_SOURCES ${source} index)
-    if(NOT ${index} EQUAL -1)
-      list(APPEND CLANG_FORMAT_CHANGED_SOURCES ${source})
-    endif()
-  endforeach()
-endif()
-
-if(CLANG_FORMAT_CHANGED_SOURCES)
-  set(CLANG_FORMAT_DIFF_COMMAND ${CLANG_FORMAT_PROGRAM}
-    -i # edits files in-place
-    --verbose
-    ${CLANG_FORMAT_CHANGED_SOURCES}
-  )
-else()
-  set(CLANG_FORMAT_DIFF_COMMAND ${CMAKE_COMMAND} -E echo "No changed files for clang-format")
-endif()
-
 register_command(
   TARGET
     clang-format-diff

cmake/analysis/RunClangTidy.cmake

@@ -3,7 +3,7 @@
 set(CLANG_TIDY_SOURCES ${BUN_C_SOURCES} ${BUN_CXX_SOURCES})
 
 set(CLANG_TIDY_COMMAND ${CLANG_TIDY_PROGRAM}
-  -p ${BUILD_PATH}  
+  -p ${BUILD_PATH}
   --config-file=${CWD}/.clang-tidy
 )
 
@@ -40,27 +40,6 @@ register_command(
   ALWAYS_RUN
 )
 
-if(GIT_CHANGED_SOURCES)
-  set(CLANG_TIDY_CHANGED_SOURCES)
-  foreach(source ${CLANG_TIDY_SOURCES})
-    list(FIND GIT_CHANGED_SOURCES ${source} index)
-    if(NOT ${index} EQUAL -1)
-      list(APPEND CLANG_TIDY_CHANGED_SOURCES ${source})
-    endif()
-  endforeach()
-endif()
-
-if(CLANG_TIDY_CHANGED_SOURCES)
-  set(CLANG_TIDY_DIFF_COMMAND ${CLANG_TIDY_PROGRAM}
-    ${CLANG_TIDY_CHANGED_SOURCES}
-    --fix
-    --fix-errors
-    --fix-notes
-  )
-else()
-  set(CLANG_TIDY_DIFF_COMMAND ${CMAKE_COMMAND} -E echo "No changed files for clang-tidy")
-endif()
-
 register_command(
   TARGET
     clang-tidy-diff

cmake/analysis/RunCppCheck.cmake

@@ -1,33 +0,0 @@
-# https://cppcheck.sourceforge.io/
-
-find_command(
-  VARIABLE
-    CPPCHECK_EXECUTABLE
-  COMMAND
-    cppcheck
-  REQUIRED
-    OFF
-)
-
-set(CPPCHECK_COMMAND ${CPPCHECK_EXECUTABLE}
-  --cppcheck-build-dir=${BUILD_PATH}/cppcheck
-  --project=${BUILD_PATH}/compile_commands.json
-  --clang=${CMAKE_CXX_COMPILER}
-  --std=c++${CMAKE_CXX_STANDARD}
-  --report-progress
-  --showtime=summary
-)
-
-register_command(
-  TARGET
-    cppcheck
-  COMMENT
-    "Running cppcheck"
-  COMMAND
-    ${CMAKE_COMMAND} -E make_directory cppcheck
-    && ${CPPCHECK_COMMAND} 
-  CWD
-    ${BUILD_PATH}
-  TARGETS
-    ${bun}
-)

cmake/analysis/RunCppLint.cmake

@@ -1,22 +0,0 @@
-find_command(
-  VARIABLE
-    CPPLINT_PROGRAM
-  COMMAND
-    cpplint
-  REQUIRED
-    OFF
-)
-
-register_command(
-  TARGET
-    cpplint
-  COMMENT
-    "Running cpplint"
-  COMMAND
-    ${CPPLINT_PROGRAM}
-    ${BUN_CPP_SOURCES}
-  CWD
-    ${BUILD_PATH}
-  TARGETS
-    ${bun}
-)

cmake/analysis/RunIWYU.cmake

@@ -1,67 +0,0 @@
-# IWYU = "Include What You Use"
-# https://include-what-you-use.org/
-
-setx(IWYU_SOURCE_PATH ${CACHE_PATH}/iwyu-${LLVM_VERSION})
-setx(IWYU_BUILD_PATH ${IWYU_SOURCE_PATH}/build)
-setx(IWYU_PROGRAM ${IWYU_BUILD_PATH}/bin/include-what-you-use)
-
-register_repository(
-  NAME
-    iwyu
-  REPOSITORY
-    include-what-you-use/include-what-you-use
-  BRANCH
-    clang_${LLVM_VERSION}
-  PATH
-    ${IWYU_SOURCE_PATH}
-)
-
-register_command(
-  TARGET
-    build-iwyu
-  COMMENT
-    "Building iwyu"
-  COMMAND
-    ${CMAKE_COMMAND}
-      -B${IWYU_BUILD_PATH}
-      -G${CMAKE_GENERATOR}
-      -DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}
-      -DCMAKE_CXX_COMPILER_LAUNCHER=${CMAKE_CXX_COMPILER_LAUNCHER}
-      -DIWYU_LLVM_ROOT_PATH=${LLVM_PREFIX}
-    && ${CMAKE_COMMAND}
-      --build ${IWYU_BUILD_PATH}
-  CWD
-    ${IWYU_SOURCE_PATH}
-  TARGETS
-    clone-iwyu
-)
-
-find_command(
-  VARIABLE
-    PYTHON_EXECUTABLE
-  COMMAND
-    python3
-    python
-  VERSION
-    >=3.0.0
-  REQUIRED
-    OFF
-)
-
-register_command(
-  TARGET
-    iwyu
-  COMMENT
-    "Running iwyu"
-  COMMAND
-    ${CMAKE_COMMAND}
-      -E env IWYU_BINARY=${IWYU_PROGRAM}
-      ${PYTHON_EXECUTABLE}
-      ${IWYU_SOURCE_PATH}/iwyu_tool.py
-      -p ${BUILD_PATH}
-  CWD
-    ${BUILD_PATH}
-  TARGETS
-    build-iwyu
-    ${bun}
-)

cmake/analysis/RunPrettier.cmake

@@ -92,26 +92,6 @@ register_command(
   ALWAYS_RUN
 )
 
-if(GIT_CHANGED_SOURCES)
-  set(PRETTIER_CHANGED_SOURCES)
-  foreach(source ${PRETTIER_SOURCES})
-    list(FIND GIT_CHANGED_SOURCES ${source} index)
-    if(NOT ${index} EQUAL -1)
-      list(APPEND PRETTIER_CHANGED_SOURCES ${source})
-    endif()
-  endforeach()
-endif()
-
-if(PRETTIER_CHANGED_SOURCES)
-  set(PRETTIER_DIFF_COMMAND ${PRETTIER_COMMAND}
-    --write
-    --plugin=prettier-plugin-organize-imports
-    ${PRETTIER_CHANGED_SOURCES}
-  )
-else()
-  set(PRETTIER_DIFF_COMMAND ${CMAKE_COMMAND} -E echo "No changed files for prettier")
-endif()
-
 register_command(
   TARGET
     prettier-diff

cmake/analysis/RunZigFormat.cmake

@@ -25,25 +25,6 @@ register_command(
   ALWAYS_RUN
 )
 
-if(GIT_CHANGED_SOURCES)
-  set(ZIG_FORMAT_CHANGED_SOURCES)
-  foreach(source ${ZIG_FORMAT_SOURCES})
-    list(FIND GIT_CHANGED_SOURCES ${source} index)
-    if(NOT ${index} EQUAL -1)
-      list(APPEND ZIG_FORMAT_CHANGED_SOURCES ${source})
-    endif()
-  endforeach()
-endif()
-
-if(ZIG_FORMAT_CHANGED_SOURCES)
-  set(ZIG_FORMAT_DIFF_COMMAND ${ZIG_EXECUTABLE}
-    fmt
-    ${ZIG_FORMAT_CHANGED_SOURCES}
-  )
-else()
-  set(ZIG_FORMAT_DIFF_COMMAND ${CMAKE_COMMAND} -E echo "No changed files for zig-format")
-endif()
-
 register_command(
   TARGET
     zig-format-diff

cmake/targets/BuildBun.cmake

@@ -45,12 +45,6 @@ else()
 endif()
 
 set(LLVM_ZIG_CODEGEN_THREADS 0)
-# This makes the build slower, so we turn it off for now.
-# if (DEBUG)
-#   include(ProcessorCount)
-#   ProcessorCount(CPU_COUNT)
-#   set(LLVM_ZIG_CODEGEN_THREADS ${CPU_COUNT})
-# endif()
 
 # --- Dependencies ---
 
@@ -71,9 +65,6 @@ set(BUN_DEPENDENCIES
 )
 
 include(CloneZstd)
-# foreach(dependency ${BUN_DEPENDENCIES})
-#   include(Clone${dependency})
-# endforeach()
 
 # --- Codegen ---
 
@@ -326,6 +317,10 @@ set(BUN_CPP_OUTPUTS
   ${CODEGEN_PATH}/cpp.zig
 )
 
+set(BUN_CI_INFO_OUTPUTS
+  ${CODEGEN_PATH}/ci_info.zig
+)
+
 register_command(
   TARGET
     bun-cppbind
@@ -343,6 +338,21 @@ register_command(
     ${BUN_CPP_OUTPUTS}
 )
 
+register_command(
+  TARGET
+    bun-ci-info
+  COMMENT
+    "Generating CI info"
+  COMMAND
+    ${BUN_EXECUTABLE}
+      ${CWD}/src/codegen/ci_info.ts
+      ${CODEGEN_PATH}/ci_info.zig
+  SOURCES
+    ${BUN_JAVASCRIPT_CODEGEN_SOURCES}
+  OUTPUTS
+    ${BUN_CI_INFO_OUTPUTS}
+)
+
 register_command(
   TARGET
     bun-js-modules
@@ -409,12 +419,9 @@ execute_process(
     --command=list-outputs
     --sources=${BUN_BINDGENV2_SOURCES_COMMA_SEPARATED}
     --codegen-path=${CODEGEN_PATH}
-  RESULT_VARIABLE bindgen_result
   OUTPUT_VARIABLE bindgen_outputs
+  COMMAND_ERROR_IS_FATAL ANY
 )
-if(${bindgen_result})
-  message(FATAL_ERROR "bindgenv2/script.ts exited with non-zero status")
-endif()
 foreach(output IN LISTS bindgen_outputs)
   if(output MATCHES "\.cpp$")
     list(APPEND BUN_BINDGENV2_CPP_OUTPUTS ${output})
@@ -621,6 +628,7 @@ set(BUN_ZIG_GENERATED_SOURCES
   ${BUN_ZIG_GENERATED_CLASSES_OUTPUTS}
   ${BUN_JAVASCRIPT_OUTPUTS}
   ${BUN_CPP_OUTPUTS}
+  ${BUN_CI_INFO_OUTPUTS}
   ${BUN_BINDGENV2_ZIG_OUTPUTS}
 )
 
@@ -684,6 +692,7 @@ register_command(
       -Dcpu=${ZIG_CPU}
       -Denable_logs=$<IF:$<BOOL:${ENABLE_LOGS}>,true,false>
       -Denable_asan=$<IF:$<BOOL:${ENABLE_ZIG_ASAN}>,true,false>
+      -Denable_fuzzilli=$<IF:$<BOOL:${ENABLE_FUZZILLI}>,true,false>
       -Denable_valgrind=$<IF:$<BOOL:${ENABLE_VALGRIND}>,true,false>
       -Duse_mimalloc=$<IF:$<BOOL:${USE_MIMALLOC_AS_DEFAULT_ALLOCATOR}>,true,false>
       -Dllvm_codegen_threads=${LLVM_ZIG_CODEGEN_THREADS}
@@ -860,6 +869,7 @@ target_include_directories(${bun} PRIVATE
   ${CODEGEN_PATH}
   ${VENDOR_PATH}
   ${VENDOR_PATH}/picohttpparser
+  ${VENDOR_PATH}/zlib
   ${NODEJS_HEADERS_PATH}/include
   ${NODEJS_HEADERS_PATH}/include/node
 )
@@ -1187,6 +1197,29 @@ set_target_properties(${bun} PROPERTIES LINK_DEPENDS ${BUN_SYMBOLS_PATH})
 
 include(SetupWebKit)
 
+if(BUN_LINK_ONLY)
+  register_command(
+    TARGET
+      ${bun}
+    TARGET_PHASE
+      POST_BUILD
+    COMMENT
+      "Uploading link metadata"
+    COMMAND
+      ${CMAKE_COMMAND} -E env
+        BUN_VERSION=${VERSION}
+        WEBKIT_DOWNLOAD_URL=${WEBKIT_DOWNLOAD_URL}
+        WEBKIT_VERSION=${WEBKIT_VERSION}
+        ZIG_COMMIT=${ZIG_COMMIT}
+        ${BUN_EXECUTABLE} ${CWD}/scripts/create-link-metadata.mjs ${BUILD_PATH} ${bun}
+    SOURCES
+      ${BUN_ZIG_OUTPUT}
+      ${BUN_CPP_OUTPUT}
+    ARTIFACTS
+      ${BUILD_PATH}/link-metadata.json
+  )
+endif()
+
 if(WIN32)
   if(DEBUG)
     target_link_libraries(${bun} PRIVATE
@@ -1261,15 +1294,9 @@ if(LINUX)
     target_link_libraries(${bun} PUBLIC libatomic.so)
   endif()
 
-  if(USE_SYSTEM_ICU)
-    target_link_libraries(${bun} PRIVATE libicudata.a)
-    target_link_libraries(${bun} PRIVATE libicui18n.a)
-    target_link_libraries(${bun} PRIVATE libicuuc.a)
-  else()
-    target_link_libraries(${bun} PRIVATE ${WEBKIT_LIB_PATH}/libicudata.a)
-    target_link_libraries(${bun} PRIVATE ${WEBKIT_LIB_PATH}/libicui18n.a)
-    target_link_libraries(${bun} PRIVATE ${WEBKIT_LIB_PATH}/libicuuc.a)
-  endif()
+  target_link_libraries(${bun} PRIVATE ${WEBKIT_LIB_PATH}/libicudata.a)
+  target_link_libraries(${bun} PRIVATE ${WEBKIT_LIB_PATH}/libicui18n.a)
+  target_link_libraries(${bun} PRIVATE ${WEBKIT_LIB_PATH}/libicuuc.a)
 endif()
 
 if(WIN32)
@@ -1322,32 +1349,32 @@ if(NOT BUN_CPP_ONLY)
       OUTPUTS
         ${BUILD_PATH}/${bunStripExe}
     )
-    
+
     # Then sign both executables on Windows
     if(WIN32 AND ENABLE_WINDOWS_CODESIGNING)
       set(SIGN_SCRIPT "${CMAKE_SOURCE_DIR}/.buildkite/scripts/sign-windows.ps1")
-      
+
       # Verify signing script exists
       if(NOT EXISTS "${SIGN_SCRIPT}")
         message(FATAL_ERROR "Windows signing script not found: ${SIGN_SCRIPT}")
       endif()
-      
+
       # Use PowerShell for Windows code signing (native Windows, no path issues)
-      find_program(POWERSHELL_EXECUTABLE 
+      find_program(POWERSHELL_EXECUTABLE
         NAMES pwsh.exe powershell.exe
-        PATHS 
+        PATHS
           "C:/Program Files/PowerShell/7"
           "C:/Program Files (x86)/PowerShell/7"
           "C:/Windows/System32/WindowsPowerShell/v1.0"
         DOC "Path to PowerShell executable"
       )
-      
+
       if(NOT POWERSHELL_EXECUTABLE)
         set(POWERSHELL_EXECUTABLE "powershell.exe")
       endif()
-      
+
       message(STATUS "Using PowerShell executable: ${POWERSHELL_EXECUTABLE}")
-      
+
       # Sign both bun-profile.exe and bun.exe after stripping
       register_command(
         TARGET

cmake/targets/BuildCares.cmake

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

cmake/targets/BuildLibDeflate.cmake

@@ -4,7 +4,7 @@ register_repository(
   REPOSITORY
     ebiggers/libdeflate
   COMMIT
-    96836d7d9d10e3e0d53e6edb54eb908514e336c4
+    c8c56a20f8f621e6a966b716b31f1dedab6a41e3
 )
 
 register_cmake_command(

cmake/tools/SetupBuildkite.cmake

@@ -48,6 +48,9 @@ if(NOT BUILDKITE_BUILD_STATUS EQUAL 0)
 endif()
 
 file(READ ${BUILDKITE_BUILD_PATH}/build.json BUILDKITE_BUILD)
+# Escape backslashes so CMake doesn't interpret JSON escape sequences (e.g., \n in commit messages)
+string(REPLACE "\\" "\\\\" BUILDKITE_BUILD "${BUILDKITE_BUILD}")
+
 string(JSON BUILDKITE_BUILD_UUID GET ${BUILDKITE_BUILD} id)
 string(JSON BUILDKITE_JOBS GET ${BUILDKITE_BUILD} jobs)
 string(JSON BUILDKITE_JOBS_COUNT LENGTH ${BUILDKITE_JOBS})

cmake/tools/SetupCcache.cmake

@@ -5,18 +5,12 @@ if(NOT ENABLE_CCACHE OR CACHE_STRATEGY STREQUAL "none")
   return()
 endif()
 
-if (CI AND NOT APPLE)
-  setenv(CCACHE_DISABLE 1)
-  return()
-endif()
 
 find_command(
   VARIABLE
     CCACHE_PROGRAM
   COMMAND
     ccache
-  REQUIRED
-    ${CI}
 )
 
 if(NOT CCACHE_PROGRAM)
@@ -49,3 +43,6 @@ else()
   setenv(CCACHE_MAXSIZE 100G)
   setenv(CCACHE_SLOPPINESS "pch_defines,time_macros,locale,random_seed,clang_index_store,gcno_cwd")
 endif()
+
+
+

cmake/tools/SetupGit.cmake

@@ -4,41 +4,9 @@ find_command(
   COMMAND
     git
   REQUIRED
-    OFF
+    ${CI}
 )
 
 if(NOT GIT_PROGRAM)
   return()
 endif()
-
-set(GIT_DIFF_COMMAND ${GIT_PROGRAM} diff --no-color --name-only --diff-filter=AMCR origin/main HEAD)
-
-execute_process(
-  COMMAND
-    ${GIT_DIFF_COMMAND}
-  WORKING_DIRECTORY
-    ${CWD}
-  OUTPUT_STRIP_TRAILING_WHITESPACE
-  OUTPUT_VARIABLE
-    GIT_DIFF
-  ERROR_STRIP_TRAILING_WHITESPACE
-  ERROR_VARIABLE
-    GIT_DIFF_ERROR
-  RESULT_VARIABLE
-    GIT_DIFF_RESULT
-)
-
-if(NOT GIT_DIFF_RESULT EQUAL 0)
-  message(WARNING "Command failed: ${GIT_DIFF_COMMAND} ${GIT_DIFF_ERROR}")
-  return()
-endif()
-
-string(REPLACE "\n" ";" GIT_CHANGED_SOURCES "${GIT_DIFF}")
-
-if(CI)
-  set(GIT_CHANGED_SOURCES "${GIT_CHANGED_SOURCES}")
-  message(STATUS "Set GIT_CHANGED_SOURCES: ${GIT_CHANGED_SOURCES}")
-endif()
-
-list(TRANSFORM GIT_CHANGED_SOURCES PREPEND ${CWD}/)
-list(LENGTH GIT_CHANGED_SOURCES GIT_CHANGED_SOURCES_COUNT)

cmake/tools/SetupWebKit.cmake

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

cmake/tools/SetupZig.cmake

@@ -20,7 +20,7 @@ else()
   unsupported(CMAKE_SYSTEM_NAME)
 endif()
 
-set(ZIG_COMMIT "55fdbfa0c86be86b68d43a4ba761e6909eb0d7b2")
+set(ZIG_COMMIT "c1423ff3fc7064635773a4a4616c5bf986eb00fe")
 optionx(ZIG_TARGET STRING "The zig target to use" DEFAULT ${DEFAULT_ZIG_TARGET})
 
 if(CMAKE_BUILD_TYPE STREQUAL "Release")
@@ -55,13 +55,7 @@ optionx(ZIG_OBJECT_FORMAT "obj|bc" "Output file format for Zig object files" DEF
 optionx(ZIG_LOCAL_CACHE_DIR FILEPATH "The path to local the zig cache directory" DEFAULT ${CACHE_PATH}/zig/local)
 optionx(ZIG_GLOBAL_CACHE_DIR FILEPATH "The path to the global zig cache directory" DEFAULT ${CACHE_PATH}/zig/global)
 
-if(CI)
-  set(ZIG_COMPILER_SAFE_DEFAULT ON)
-else()
-  set(ZIG_COMPILER_SAFE_DEFAULT OFF)
-endif()
-
-optionx(ZIG_COMPILER_SAFE BOOL "Download a ReleaseSafe build of the Zig compiler." DEFAULT ${ZIG_COMPILER_SAFE_DEFAULT})
+optionx(ZIG_COMPILER_SAFE BOOL "Download a ReleaseSafe build of the Zig compiler." DEFAULT ${CI})
 
 setenv(ZIG_LOCAL_CACHE_DIR ${ZIG_LOCAL_CACHE_DIR})
 setenv(ZIG_GLOBAL_CACHE_DIR ${ZIG_GLOBAL_CACHE_DIR})

dockerhub/debian-slim/Dockerfile

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

dockerhub/debian/Dockerfile

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

dockerhub/distroless/Dockerfile

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

docs/README.md

@@ -0,0 +1,28 @@
+<p align="center">
+  <a href="https://bun.com">
+		<img src="https://github.com/user-attachments/assets/50282090-adfd-4ddb-9e27-c30753c6b161" alt="Logo" height="170" />
+	</a>
+</p>
+<h1 align="center">Bun Documentation</h1>
+
+Official documentation for Bun: the fast, all-in-one JavaScript runtime.
+
+## Development
+
+Install the [Mintlify CLI](https://www.npmjs.com/package/mint) to preview the documentation locally:
+
+```bash
+bun install -g mint
+```
+
+Run the development server:
+
+```bash
+mint dev
+```
+
+The site will be available at `http://localhost:3000`.
+
+## Contributing
+
+Contributions are welcome! Please open an issue or submit a pull request.

docs/api/file.md

@@ -1,19 +0,0 @@
-Bun.js has fast paths for common use cases that make Web APIs live up to the performance demands of servers and CLIs.
-
-`Bun.file(path)` returns a [`Blob`](https://developer.mozilla.org/en-US/docs/Web/API/Blob) that represents a lazily-loaded file.
-
-When you pass a file blob to `Bun.write`, Bun automatically uses a faster system call:
-
-```js
-const blob = Bun.file("input.txt");
-await Bun.write("output.txt", blob);
-```
-
-On Linux, this uses the [`copy_file_range`](https://man7.org/linux/man-pages/man2/copy_file_range.2.html) syscall and on macOS, this becomes `clonefile` (or [`fcopyfile`](https://developer.apple.com/library/archive/documentation/System/Conceptual/ManPages_iPhoneOS/man3/copyfile.3.html)).
-
-`Bun.write` also supports [`Response`](https://developer.mozilla.org/en-US/docs/Web/API/Response) objects. It automatically converts to a [`Blob`](https://developer.mozilla.org/en-US/docs/Web/API/Blob).
-
-```js
-// Eventually, this will stream the response to disk but today it buffers
-await Bun.write("index.html", await fetch("https://example.com"));
-```

docs/api/globals.md

@@ -1,387 +0,0 @@
-Bun implements the following globals.
-
-{% table %}
-
-- Global
-- Source
-- Notes
-
----
-
-- [`AbortController`](https://developer.mozilla.org/en-US/docs/Web/API/AbortController)
-- Web
--  
-
----
-
-- [`AbortSignal`](https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal)
-- Web
--  
-
----
-
-- [`alert`](https://developer.mozilla.org/en-US/docs/Web/API/Window/alert)
-- Web
-- Intended for command-line tools
-
----
-
-- [`Blob`](https://developer.mozilla.org/en-US/docs/Web/API/Blob)
-- Web
--  
-
----
-
-- [`Buffer`](https://nodejs.org/api/buffer.html#class-buffer)
-- Node.js
-- See [Node.js > `Buffer`](https://bun.com/docs/runtime/nodejs-apis#node-buffer)
-
----
-
-- `Bun`
-- Bun
-- Subject to change as additional APIs are added
-
----
-
-- [`ByteLengthQueuingStrategy`](https://developer.mozilla.org/en-US/docs/Web/API/ByteLengthQueuingStrategy)
-- Web
--  
-
----
-
-- [`confirm`](https://developer.mozilla.org/en-US/docs/Web/API/Window/confirm)
-- Web
-- Intended for command-line tools
-
----
-
-- [`__dirname`](https://nodejs.org/api/globals.html#__dirname)
-- Node.js
--  
-
----
-
-- [`__filename`](https://nodejs.org/api/globals.html#__filename)
-- Node.js
--  
-
----
-
-- [`atob()`](https://developer.mozilla.org/en-US/docs/Web/API/atob)
-- Web
--  
-
----
-
-- [`btoa()`](https://developer.mozilla.org/en-US/docs/Web/API/btoa)
-- Web
--  
-
----
-
-- `BuildMessage`
-- Bun
--  
-
----
-
-- [`clearImmediate()`](https://developer.mozilla.org/en-US/docs/Web/API/Window/clearImmediate)
-- Web
--  
-
----
-
-- [`clearInterval()`](https://developer.mozilla.org/en-US/docs/Web/API/Window/clearInterval)
-- Web
--  
-
----
-
-- [`clearTimeout()`](https://developer.mozilla.org/en-US/docs/Web/API/Window/clearTimeout)
-- Web
--  
-
----
-
-- [`console`](https://developer.mozilla.org/en-US/docs/Web/API/console)
-- Web
--  
-
----
-
-- [`CountQueuingStrategy`](https://developer.mozilla.org/en-US/docs/Web/API/CountQueuingStrategy)
-- Web
--  
-
----
-
-- [`Crypto`](https://developer.mozilla.org/en-US/docs/Web/API/Crypto)
-- Web
--  
-
----
-
-- [`crypto`](https://developer.mozilla.org/en-US/docs/Web/API/crypto)
-- Web
--  
-
----
-
-- [`CryptoKey`](https://developer.mozilla.org/en-US/docs/Web/API/CryptoKey)
-- Web
--  
-
----
-
-- [`CustomEvent`](https://developer.mozilla.org/en-US/docs/Web/API/CustomEvent)
-- Web
--  
-
----
-
-- [`Event`](https://developer.mozilla.org/en-US/docs/Web/API/Event)
-- Web
-- Also [`ErrorEvent`](https://developer.mozilla.org/en-US/docs/Web/API/ErrorEvent) [`CloseEvent`](https://developer.mozilla.org/en-US/docs/Web/API/CloseEvent) [`MessageEvent`](https://developer.mozilla.org/en-US/docs/Web/API/MessageEvent).
-
----
-
-- [`EventTarget`](https://developer.mozilla.org/en-US/docs/Web/API/EventTarget)
-- Web
--  
-
----
-
-- [`exports`](https://nodejs.org/api/globals.html#exports)
-- Node.js
--  
-
----
-
-- [`fetch`](https://developer.mozilla.org/en-US/docs/Web/API/fetch)
-- Web
--  
-
----
-
-- [`FormData`](https://developer.mozilla.org/en-US/docs/Web/API/FormData)
-- Web
--  
-
----
-
-- [`global`](https://nodejs.org/api/globals.html#global)
-- Node.js
-- See [Node.js > `global`](https://bun.com/docs/runtime/nodejs-apis#global).
-
----
-
-- [`globalThis`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/globalThis)
-- Cross-platform
-- Aliases to `global`
-
----
-
-- [`Headers`](https://developer.mozilla.org/en-US/docs/Web/API/Headers)
-- Web
--  
-
----
-
-- [`HTMLRewriter`](https://bun.com/docs/api/html-rewriter)
-- Cloudflare
--  
-
----
-
-- [`JSON`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON)
-- Web
--  
-
----
-
-- [`MessageEvent`](https://developer.mozilla.org/en-US/docs/Web/API/MessageEvent)
-- Web
--  
-
----
-
-- [`module`](https://nodejs.org/api/globals.html#module)
-- Node.js
--  
-
----
-
-- [`performance`](https://developer.mozilla.org/en-US/docs/Web/API/performance)
-- Web
--  
-
----
-
-- [`process`](https://nodejs.org/api/process.html)
-- Node.js
-- See [Node.js > `process`](https://bun.com/docs/runtime/nodejs-apis#node-process)
-
----
-
-- [`prompt`](https://developer.mozilla.org/en-US/docs/Web/API/Window/prompt)
-- Web
-- Intended for command-line tools
-
----
-
-- [`queueMicrotask()`](https://developer.mozilla.org/en-US/docs/Web/API/queueMicrotask)
-- Web
--  
-
----
-
-- [`ReadableByteStreamController`](https://developer.mozilla.org/en-US/docs/Web/API/ReadableByteStreamController)
-- Web
--  
-
----
-
-- [`ReadableStream`](https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream)
-- Web
--  
-
----
-
-- [`ReadableStreamDefaultController`](https://developer.mozilla.org/en-US/docs/Web/API/ReadableStreamDefaultController)
-- Web
--  
-
----
-
-- [`ReadableStreamDefaultReader`](https://developer.mozilla.org/en-US/docs/Web/API/ReadableStreamDefaultReader)
-- Web
--  
-
----
-
-- [`reportError`](https://developer.mozilla.org/en-US/docs/Web/API/reportError)
-- Web
--  
-
----
-
-- [`require()`](https://nodejs.org/api/globals.html#require)
-- Node.js
--  
-
----
-
-- `ResolveMessage`
-- Bun
--  
-
----
-
-- [`Response`](https://developer.mozilla.org/en-US/docs/Web/API/Response)
-- Web
--  
-
----
-
-- [`Request`](https://developer.mozilla.org/en-US/docs/Web/API/Request)
-- Web
--  
-
----
-
-- [`setImmediate()`](https://developer.mozilla.org/en-US/docs/Web/API/Window/setImmediate)
-- Web
--  
-
----
-
-- [`setInterval()`](https://developer.mozilla.org/en-US/docs/Web/API/Window/setInterval)
-- Web
--  
-
----
-
-- [`setTimeout()`](https://developer.mozilla.org/en-US/docs/Web/API/Window/setTimeout)
-- Web
--  
-
----
-
-- [`ShadowRealm`](https://github.com/tc39/proposal-shadowrealm)
-- Web
-- Stage 3 proposal
-
----
-
-- [`SubtleCrypto`](https://developer.mozilla.org/en-US/docs/Web/API/SubtleCrypto)
-- Web
--  
-
----
-
-- [`DOMException`](https://developer.mozilla.org/en-US/docs/Web/API/DOMException)
-- Web
--  
-
----
-
-- [`TextDecoder`](https://developer.mozilla.org/en-US/docs/Web/API/TextDecoder)
-- Web
--  
-
----
-
-- [`TextEncoder`](https://developer.mozilla.org/en-US/docs/Web/API/TextEncoder)
-- Web
--  
-
----
-
-- [`TransformStream`](https://developer.mozilla.org/en-US/docs/Web/API/TransformStream)
-- Web
--  
-
----
-
-- [`TransformStreamDefaultController`](https://developer.mozilla.org/en-US/docs/Web/API/TransformStreamDefaultController)
-- Web
--  
-
----
-
-- [`URL`](https://developer.mozilla.org/en-US/docs/Web/API/URL)
-- Web
--  
-
----
-
-- [`URLSearchParams`](https://developer.mozilla.org/en-US/docs/Web/API/URLSearchParams)
-- Web
--  
-
----
-
-- [`WebAssembly`](https://nodejs.org/api/globals.html#webassembly)
-- Web
--  
-
----
-
-- [`WritableStream`](https://developer.mozilla.org/en-US/docs/Web/API/WritableStream)
-- Web
--  
-
----
-
-- [`WritableStreamDefaultController`](https://developer.mozilla.org/en-US/docs/Web/API/WritableStreamDefaultController)
-- Web
--  
-
----
-
-- [`WritableStreamDefaultWriter`](https://developer.mozilla.org/en-US/docs/Web/API/WritableStreamDefaultWriter)
-- Web
--  
-
-{% /table %}

docs/api/import-meta.md

@@ -1,69 +0,0 @@
-The `import.meta` object is a way for a module to access information about itself. It's part of the JavaScript language, but its contents are not standardized. Each "host" (browser, runtime, etc) is free to implement any properties it wishes on the `import.meta` object.
-
-Bun implements the following properties.
-
-```ts#/path/to/project/file.ts
-import.meta.dir;   // => "/path/to/project"
-import.meta.file;  // => "file.ts"
-import.meta.path;  // => "/path/to/project/file.ts"
-import.meta.url;   // => "file:///path/to/project/file.ts"
-
-import.meta.main;  // `true` if this file is directly executed by `bun run`
-                   // `false` otherwise
-
-import.meta.resolve("zod"); // => "file:///path/to/project/node_modules/zod/index.js"
-```
-
-{% table %}
-
----
-
-- `import.meta.dir`
-- Absolute path to the directory containing the current file, e.g. `/path/to/project`. Equivalent to `__dirname` in CommonJS modules (and Node.js)
-
----
-
-- `import.meta.dirname`
-- An alias to `import.meta.dir`, for Node.js compatibility
-
----
-
-- `import.meta.env`
-- An alias to `process.env`.
-
----
-
-- `import.meta.file`
-- The name of the current file, e.g. `index.tsx`
-
----
-
-- `import.meta.path`
-- Absolute path to the current file, e.g. `/path/to/project/index.ts`. Equivalent to `__filename` in CommonJS modules (and Node.js)
-
----
-
-- `import.meta.filename`
-- An alias to `import.meta.path`, for Node.js compatibility
-
----
-
-- `import.meta.main`
-- Indicates whether the current file is the entrypoint to the current `bun` process. Is the file being directly executed by `bun run` or is it being imported?
-
----
-
-- `import.meta.resolve`
-- Resolve a module specifier (e.g. `"zod"` or `"./file.tsx"`) to a url. Equivalent to [`import.meta.resolve` in browsers](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/import.meta#resolve)
-
-  ```ts
-  import.meta.resolve("zod");
-  // => "file:///path/to/project/node_modules/zod/index.ts"
-  ```
-
----
-
-- `import.meta.url`
-- A `string` url to the current file, e.g. `file:///path/to/project/index.ts`. Equivalent to [`import.meta.url` in browsers](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/import.meta#url)
-
-{% /table %}

docs/benchmarks.md

@@ -1,120 +0,0 @@
-Bun.js focuses on performance, developer experience, and compatibility with the JavaScript ecosystem.
-
-## HTTP Requests
-
-```ts
-// http.ts
-export default {
-  port: 3000,
-  fetch(request: Request) {
-    return new Response("Hello World");
-  },
-};
-
-// bun ./http.ts
-```
-
-| Requests per second                                                    | OS    | CPU                            | Bun version |
-| ---------------------------------------------------------------------- | ----- | ------------------------------ | ----------- |
-| [260,000](https://twitter.com/jarredsumner/status/1512040623200616449) | macOS | Apple Silicon M1 Max           | 0.0.76      |
-| [160,000](https://twitter.com/jarredsumner/status/1511988933587976192) | Linux | AMD Ryzen 5 3600 6-Core 2.2ghz | 0.0.76      |
-
-{% details summary="See benchmark details" %}
-Measured with [`http_load_test`](https://github.com/uNetworking/uSockets/blob/master/examples/http_load_test.c) by running:
-
-```bash
-$ ./http_load_test  20 127.0.0.1 3000
-```
-
-{% /details %}
-
-## File System
-
-`cat` clone that runs [2x faster than GNU cat](https://twitter.com/jarredsumner/status/1511707890708586496) for large files on Linux
-
-```js
-// cat.js
-import { resolve } from "path";
-import { write, stdout, file, argv } from "bun";
-
-const path = resolve(argv.at(-1));
-
-await write(
-  // stdout is a Blob
-  stdout,
-  // file(path) returns a Blob - https://developer.mozilla.org/en-US/docs/Web/API/Blob
-  file(path),
-);
-```
-
-Run this with `bun cat.js /path/to/big/file`.
-
-## Reading from standard input
-
-```ts
-for await (const line of console) {
-  // line of text from stdin
-  console.log(line);
-}
-```
-
-## React SSR
-
-```js
-import { renderToReadableStream } from "react-dom/server";
-
-const dt = new Intl.DateTimeFormat();
-
-export default {
-  port: 3000,
-  async fetch(request: Request) {
-    return new Response(
-      await renderToReadableStream(
-        <html>
-          <head>
-            <title>Hello World</title>
-          </head>
-          <body>
-            <h1>Hello from React!</h1>
-            <p>The date is {dt.format(new Date())}</p>
-          </body>
-        </html>,
-      ),
-    );
-  },
-};
-```
-
-Write to stdout with `console.write`:
-
-```js
-// no trailing newline
-// works with strings and typed arrays
-console.write("Hello World!");
-```
-
-There are some more examples in the [examples](./examples) folder.
-
-PRs adding more examples are very welcome!
-
-## Fast paths for Web APIs
-
-Bun.js has fast paths for common use cases that make Web APIs live up to the performance demands of servers and CLIs.
-
-`Bun.file(path)` returns a [`Blob`](https://developer.mozilla.org/en-US/docs/Web/API/Blob) that represents a lazily-loaded file.
-
-When you pass a file blob to `Bun.write`, Bun automatically uses a faster system call:
-
-```js
-const blob = Bun.file("input.txt");
-await Bun.write("output.txt", blob);
-```
-
-On Linux, this uses the [`copy_file_range`](https://man7.org/linux/man-pages/man2/copy_file_range.2.html) syscall and on macOS, this becomes `clonefile` (or [`fcopyfile`](https://developer.apple.com/library/archive/documentation/System/Conceptual/ManPages_iPhoneOS/man3/copyfile.3.html)).
-
-`Bun.write` also supports [`Response`](https://developer.mozilla.org/en-US/docs/Web/API/Response) objects. It automatically converts to a [`Blob`](https://developer.mozilla.org/en-US/docs/Web/API/Blob).
-
-```js
-// Eventually, this will stream the response to disk but today it buffers
-await Bun.write("index.html", await fetch("https://example.com"));
-```

docs/bun-flavored-toml.md

@@ -1,42 +0,0 @@
-[TOML](https://toml.io/) is a minimal configuration file format designed to be easy for humans to read.
-
-Bun implements a TOML parser with a few tweaks designed for better interoperability with INI files and with JavaScript.
-
-### ; and # are comments
-
-In Bun-flavored TOML, comments start with `#` or `;`
-
-```ini
-# This is a comment
-; This is also a comment
-```
-
-This matches the behavior of INI files.
-
-In TOML, comments start with `#`
-
-```toml
-# This is a comment
-```
-
-### String escape characters
-
-Bun-flavored adds a few more escape sequences to TOML to work better with JavaScript strings.
-
-```
-# Bun-flavored TOML extras
-\x{XX}     - ASCII           (U+00XX)
-\u{x+}     - unicode         (U+0000000X) - (U+XXXXXXXX)
-\v         - vertical tab
-
-# Regular TOML
-\b         - backspace       (U+0008)
-\t         - tab             (U+0009)
-\n         - linefeed        (U+000A)
-\f         - form feed       (U+000C)
-\r         - carriage return (U+000D)
-\"         - quote           (U+0022)
-\\         - backslash       (U+005C)
-\uXXXX     - unicode         (U+XXXX)
-\UXXXXXXXX - unicode         (U+XXXXXXXX)
-```

docs/bundler/bytecode.mdx

@@ -0,0 +1,465 @@
+---
+title: Bytecode Caching
+description: Speed up JavaScript execution with bytecode caching in Bun's bundler
+---
+
+Bytecode caching is a build-time optimization that dramatically improves application startup time by pre-compiling your JavaScript to bytecode. For example, when compiling TypeScript's `tsc` with bytecode enabled, startup time improves by **2x**.
+
+## Usage
+
+### Basic usage
+
+Enable bytecode caching with the `--bytecode` flag:
+
+```bash terminal icon="terminal"
+bun build ./index.ts --target=bun --bytecode --outdir=./dist
+```
+
+This generates two files:
+
+- `dist/index.js` - Your bundled JavaScript
+- `dist/index.jsc` - The bytecode cache file
+
+At runtime, Bun automatically detects and uses the `.jsc` file:
+
+```bash terminal icon="terminal"
+bun ./dist/index.js  # Automatically uses index.jsc
+```
+
+### With standalone executables
+
+When creating executables with `--compile`, bytecode is embedded into the binary:
+
+```bash terminal icon="terminal"
+bun build ./cli.ts --compile --bytecode --outfile=mycli
+```
+
+The resulting executable contains both the code and bytecode, giving you maximum performance in a single file.
+
+### Combining with other optimizations
+
+Bytecode works great with minification and source maps:
+
+```bash terminal icon="terminal"
+bun build --compile --bytecode --minify --sourcemap ./cli.ts --outfile=mycli
+```
+
+- `--minify` reduces code size before generating bytecode (less code -> less bytecode)
+- `--sourcemap` preserves error reporting (errors still point to original source)
+- `--bytecode` eliminates parsing overhead
+
+## Performance impact
+
+The performance improvement scales with your codebase size:
+
+| Application size          | Typical startup improvement |
+| ------------------------- | --------------------------- |
+| Small CLI (< 100 KB)      | 1.5-2x faster               |
+| Medium-large app (> 5 MB) | 2.5x-4x faster              |
+
+Larger applications benefit more because they have more code to parse.
+
+## When to use bytecode
+
+### Great for:
+
+#### CLI tools
+
+- Invoked frequently (linters, formatters, git hooks)
+- Startup time is the entire user experience
+- Users notice the difference between 90ms and 45ms startup
+- Example: TypeScript compiler, Prettier, ESLint
+
+#### Build tools and task runners
+
+- Run hundreds or thousands of times during development
+- Milliseconds saved per run compound quickly
+- Developer experience improvement
+- Example: Build scripts, test runners, code generators
+
+#### Standalone executables
+
+- Distributed to users who care about snappy performance
+- Single-file distribution is convenient
+- File size less important than startup time
+- Example: CLIs distributed via npm or as binaries
+
+### Skip it for:
+
+- ❌ **Small scripts**
+- ❌ **Code that runs once**
+- ❌ **Development builds**
+- ❌ **Size-constrained environments**
+- ❌ **Code with top-level await** (not supported)
+
+## Limitations
+
+### CommonJS only
+
+Bytecode caching currently works with CommonJS output format. Bun's bundler automatically converts most ESM code to CommonJS, but **top-level await** is the exception:
+
+```js
+// This prevents bytecode caching
+const data = await fetch("https://api.example.com");
+export default data;
+```
+
+**Why**: Top-level await requires async module evaluation, which can't be represented in CommonJS. The module graph becomes asynchronous, and the CommonJS wrapper function model breaks down.
+
+**Workaround**: Move async initialization into a function:
+
+```js
+async function init() {
+  const data = await fetch("https://api.example.com");
+  return data;
+}
+
+export default init;
+```
+
+Now the module exports a function that the consumer can await when needed.
+
+### Version compatibility
+
+Bytecode is **not portable across Bun versions**. The bytecode format is tied to JavaScriptCore's internal representation, which changes between versions.
+
+When you update Bun, you must regenerate bytecode:
+
+```bash terminal icon="terminal"
+# After updating Bun
+bun build --bytecode ./index.ts --outdir=./dist
+```
+
+If bytecode doesn't match the current Bun version, it's automatically ignored and your code falls back to parsing the JavaScript source. Your app still runs - you just lose the performance optimization.
+
+**Best practice**: Generate bytecode as part of your CI/CD build process. Don't commit `.jsc` files to git. Regenerate them whenever you update Bun.
+
+### Source code still required
+
+- The `.js` file (your bundled source code)
+- The `.jsc` file (the bytecode cache)
+
+At runtime:
+
+1. Bun loads the `.js` file, sees a `@bytecode` pragma, and checks the `.jsc` file
+2. Bun loads the `.jsc` file
+3. Bun validates the bytecode hash matches the source
+4. If valid, Bun uses the bytecode
+5. If invalid, Bun falls back to parsing the source
+
+### Bytecode is not obfuscation
+
+Bytecode **does not obscure your source code**. It's an optimization, not a security measure.
+
+## Production deployment
+
+### Docker
+
+Include bytecode generation in your Dockerfile:
+
+```dockerfile Dockerfile icon="docker"
+FROM oven/bun:1 AS builder
+WORKDIR /app
+COPY package.json bun.lock ./
+RUN bun install --frozen-lockfile
+
+COPY . .
+RUN bun build --bytecode --minify --sourcemap \
+  --target=bun \
+  --outdir=./dist \
+  --compile \
+  ./src/server.ts --outfile=./dist/server
+
+FROM oven/bun:1 AS runner
+WORKDIR /app
+COPY --from=builder /dist/server /app/server
+CMD ["./server"]
+```
+
+The bytecode is architecture-independent.
+
+### CI/CD
+
+Generate bytecode during your build pipeline:
+
+```yaml workflow.yml icon="file-code"
+# GitHub Actions
+- name: Build with bytecode
+  run: |
+    bun install
+    bun build --bytecode --minify \
+      --outdir=./dist \
+      --target=bun \
+      ./src/index.ts
+```
+
+## Debugging
+
+### Verify bytecode is being used
+
+Check that the `.jsc` file exists:
+
+```bash terminal icon="terminal"
+ls -lh dist/
+```
+
+```txt
+-rw-r--r--  1 user  staff   245K  index.js
+-rw-r--r--  1 user  staff   1.1M  index.jsc
+```
+
+The `.jsc` file should be 2-8x larger than the `.js` file.
+
+To log if bytecode is being used, set `BUN_JSC_verboseDiskCache=1` in your environment.
+
+On success, it will log something like:
+
+```txt
+[Disk cache] cache hit for sourceCode
+```
+
+If you see a cache miss, it will log something like:
+
+```txt
+[Disk cache] cache miss for sourceCode
+```
+
+It's normal for it it to log a cache miss multiple times since Bun doesn't currently bytecode cache JavaScript code used in builtin modules.
+
+### Common issues
+
+**Bytecode silently ignored**: Usually caused by a Bun version update. The cache version doesn't match, so bytecode is rejected. Regenerate to fix.
+
+**File size too large**: This is expected. Consider:
+
+- Using `--minify` to reduce code size before bytecode generation
+- Compressing `.jsc` files for network transfer (gzip/brotli)
+- Evaluating if the startup performance gain is worth the size increase
+
+**Top-level await**: Not supported. Refactor to use async initialization functions.
+
+## What is bytecode?
+
+When you run JavaScript, the JavaScript engine doesn't execute your source code directly. Instead, it goes through several steps:
+
+1. **Parsing**: The engine reads your JavaScript source code and converts it into an Abstract Syntax Tree (AST)
+2. **Bytecode compilation**: The AST is compiled into bytecode - a lower-level representation that's faster to execute
+3. **Execution**: The bytecode is executed by the engine's interpreter or JIT compiler
+
+Bytecode is an intermediate representation - it's lower-level than JavaScript source code, but higher-level than machine code. Think of it as assembly language for a virtual machine. Each bytecode instruction represents a single operation like "load this variable," "add two numbers," or "call this function."
+
+This happens **every single time** you run your code. If you have a CLI tool that runs 100 times a day, your code gets parsed 100 times. If you have a serverless function with frequent cold starts, parsing happens on every cold start.
+
+With bytecode caching, Bun moves steps 1 and 2 to the build step. At runtime, the engine loads the pre-compiled bytecode and jumps straight to execution.
+
+### Why lazy parsing makes this even better
+
+Modern JavaScript engines use a clever optimization called **lazy parsing**. They don't parse all your code upfront - instead, functions are only parsed when they're first called:
+
+```js
+// Without bytecode caching:
+function rarely_used() {
+  // This 500-line function is only parsed
+  // when it's actually called
+}
+
+function main() {
+  console.log("Starting app");
+  // rarely_used() is never called, so it's never parsed
+}
+```
+
+This means parsing overhead isn't just a startup cost - it happens throughout your application's lifetime as different code paths execute. With bytecode caching, **all functions are pre-compiled**, even the ones that are lazily parsed. The parsing work happens once at build time instead of being distributed throughout your application's execution.
+
+## The bytecode format
+
+### Inside a .jsc file
+
+A `.jsc` file contains a serialized bytecode structure. Understanding what's inside helps explain both the performance benefits and the file size tradeoff.
+
+**Header section** (validated on every load):
+
+- **Cache version**: A hash tied to the JavaScriptCore framework version. This ensures bytecode generated with one version of Bun only runs with that exact version.
+- **Code block type tag**: Identifies whether this is a Program, Module, Eval, or Function code block.
+
+**SourceCodeKey** (validates bytecode matches source):
+
+- **Source code hash**: A hash of the original JavaScript source code. Bun verifies this matches before using the bytecode.
+- **Source code length**: The exact length of the source, for additional validation.
+- **Compilation flags**: Critical compilation context like strict mode, whether it's a script vs module, eval context type, etc. The same source code compiled with different flags produces different bytecode.
+
+**Bytecode instructions**:
+
+- **Instruction stream**: The actual bytecode opcodes - the compiled representation of your JavaScript. This is a variable-length sequence of bytecode instructions.
+- **Metadata table**: Each opcode has associated metadata - things like profiling counters, type hints, and execution counts (even if not yet populated).
+- **Jump targets**: Pre-computed addresses for control flow (if/else, loops, switch statements).
+- **Switch tables**: Optimized lookup tables for switch statements.
+
+**Constants and identifiers**:
+
+- **Constant pool**: All literal values in your code - numbers, strings, booleans, null, undefined. These are stored as actual JavaScript values (JSValues) so they don't need to be parsed from source at runtime.
+- **Identifier table**: All variable and function names used in the code. Stored as deduplicated strings.
+- **Source code representation markers**: Flags indicating how constants should be represented (as integers, doubles, big ints, etc.).
+
+**Function metadata** (for each function in your code):
+
+- **Register allocation**: How many registers (local variables) the function needs - `thisRegister`, `scopeRegister`, `numVars`, `numCalleeLocals`, `numParameters`.
+- **Code features**: A bitmask of function characteristics: is it a constructor? an arrow function? does it use `super`? does it have tail calls? These affect how the function is executed.
+- **Lexically scoped features**: Strict mode and other lexical context.
+- **Parse mode**: The mode in which the function was parsed (normal, async, generator, async generator).
+
+**Nested structures**:
+
+- **Function declarations and expressions**: Each nested function gets its own bytecode block, recursively. A file with 100 functions has 100 separate bytecode blocks, all nested in the structure.
+- **Exception handlers**: Try/catch/finally blocks with their boundaries and handler addresses pre-computed.
+- **Expression info**: Maps bytecode positions back to source code locations for error reporting and debugging.
+
+### What bytecode does NOT contain
+
+Importantly, **bytecode does not embed your source code**. Instead:
+
+- The JavaScript source is stored separately (in the `.js` file)
+- The bytecode only stores a hash and length of the source
+- At load time, Bun validates the bytecode matches the current source code
+
+This is why you need to deploy both the `.js` and `.jsc` files. The `.jsc` file is useless without its corresponding `.js` file.
+
+## The tradeoff: file size
+
+Bytecode files are significantly larger than source code - typically 2-8x larger.
+
+### Why is bytecode so much larger?
+
+**Bytecode instructions are verbose**:
+A single line of minified JavaScript might compile to dozens of bytecode instructions. For example:
+
+```js
+const sum = arr.reduce((a, b) => a + b, 0);
+```
+
+Compiles to bytecode that:
+
+- Loads the `arr` variable
+- Gets the `reduce` property
+- Creates the arrow function (which itself has bytecode)
+- Loads the initial value `0`
+- Sets up the call with the right number of arguments
+- Actually performs the call
+- Stores the result in `sum`
+
+Each of these steps is a separate bytecode instruction with its own metadata.
+
+**Constant pools store everything**:
+Every string literal, number, property name - everything gets stored in the constant pool. Even if your source code has `"hello"` a hundred times, the constant pool stores it once, but the identifier table and constant references add overhead.
+
+**Per-function metadata**:
+Each function - even small one-line functions - gets its own complete metadata:
+
+- Register allocation info
+- Code features bitmask
+- Parse mode
+- Exception handlers
+- Expression info for debugging
+
+A file with 1,000 small functions has 1,000 sets of metadata.
+
+**Profiling data structures**:
+Even though profiling data isn't populated yet, the _structures_ to hold profiling data are allocated. This includes:
+
+- Value profile slots (tracking what types flow through each operation)
+- Array profile slots (tracking array access patterns)
+- Binary arithmetic profile slots (tracking number types in math operations)
+- Unary arithmetic profile slots
+
+These take up space even when empty.
+
+**Pre-computed control flow**:
+Jump targets, switch tables, and exception handler boundaries are all pre-computed and stored. This makes execution faster but increases file size.
+
+### Mitigation strategies
+
+**Compression**:
+Bytecode compresses extremely well with gzip/brotli (60-70% compression). The repetitive structure and metadata compress efficiently.
+
+**Minification first**:
+Using `--minify` before bytecode generation helps:
+
+- Shorter identifiers → smaller identifier table
+- Dead code elimination → less bytecode generated
+- Constant folding → fewer constants in the pool
+
+**The tradeoff**:
+You're trading 2-4x larger files for 2-4x faster startup. For CLIs, this is usually worth it. For long-running servers where a few megabytes of disk space don't matter, it's even less of an issue.
+
+## Versioning and portability
+
+### Cross-architecture portability: ✅
+
+Bytecode is **architecture-independent**. You can:
+
+- Build on macOS ARM64, deploy to Linux x64
+- Build on Linux x64, deploy to AWS Lambda ARM64
+- Build on Windows x64, deploy to macOS ARM64
+
+The bytecode contains abstract instructions that work on any architecture. Architecture-specific optimizations happen during JIT compilation at runtime, not in the cached bytecode.
+
+### Cross-version portability: ❌
+
+Bytecode is **not stable across Bun versions**. Here's why:
+
+**Bytecode format changes**:
+JavaScriptCore's bytecode format evolves. New opcodes get added, old ones get removed or changed, metadata structures change. Each version of JavaScriptCore has a different bytecode format.
+
+**Version validation**:
+The cache version in the `.jsc` file header is a hash of the JavaScriptCore framework. When Bun loads bytecode:
+
+1. It extracts the cache version from the `.jsc` file
+2. It computes the current JavaScriptCore version
+3. If they don't match, the bytecode is **silently rejected**
+4. Bun falls back to parsing the `.js` source code
+
+Your application still runs - you just lose the performance optimization.
+
+**Graceful degradation**:
+This design means bytecode caching "fails open" - if anything goes wrong (version mismatch, corrupted file, missing file), your code still runs normally. You might see slower startup, but you won't see errors.
+
+## Unlinked vs. linked bytecode
+
+JavaScriptCore makes a crucial distinction between "unlinked" and "linked" bytecode. This separation is what makes bytecode caching possible:
+
+### Unlinked bytecode (what's cached)
+
+The bytecode saved in `.jsc` files is **unlinked bytecode**. It contains:
+
+- The compiled bytecode instructions
+- Structural information about the code
+- Constants and identifiers
+- Control flow information
+
+But it **doesn't** contain:
+
+- Pointers to actual runtime objects
+- JIT-compiled machine code
+- Profiling data from previous runs
+- Call link information (which functions call which)
+
+Unlinked bytecode is **immutable and shareable**. Multiple executions of the same code can all reference the same unlinked bytecode.
+
+### Linked bytecode (runtime execution)
+
+When Bun runs bytecode, it "links" it - creating a runtime wrapper that adds:
+
+- **Call link information**: As your code runs, the engine learns which functions call which and optimizes those call sites.
+- **Profiling data**: The engine tracks how many times each instruction executes, what types of values flow through the code, array access patterns, etc.
+- **JIT compilation state**: References to baseline JIT or optimizing JIT (DFG/FTL) compiled versions of hot code.
+- **Runtime objects**: Pointers to actual JavaScript objects, prototypes, scopes, etc.
+
+This linked representation is created fresh every time you run your code. This allows:
+
+1. **Caching the expensive work** (parsing and compilation to unlinked bytecode)
+2. **Still collecting runtime profiling data** to guide optimizations
+3. **Still applying JIT optimizations** based on actual execution patterns
+
+Bytecode caching moves expensive work (parsing and compiling to bytecode) from runtime to build time. For applications that start frequently, this can halve your startup time at the cost of larger files on disk.
+
+For production CLIs and serverless deployments, the combination of `--bytecode --minify --sourcemap` gives you the best performance while maintaining debuggability.

docs/bundler/css.mdx

@@ -1,3 +1,8 @@
+---
+title: CSS
+description: Bun's bundler has built-in support for CSS with modern features
+---
+
 Bun's bundler has built-in support for CSS with the following features:
 
 - Transpiling modern/future features to work on all browsers (including vendor prefixing)
@@ -9,11 +14,11 @@ Bun's bundler has built-in support for CSS with the following features:
 
 Bun's CSS bundler lets you use modern/future CSS features without having to worry about browser compatibility — all thanks to its transpiling and vendor prefixing features which are enabled by default.
 
-Bun's CSS parser and bundler is a direct Rust → Zig port of [LightningCSS](https://lightningcss.dev/), with a bundling approach inspired by esbuild. The transpiler converts modern CSS syntax into backwards-compatible equivalents that work across browsers.
+Bun's CSS parser and bundler is a direct Rust → Zig port of LightningCSS, with a bundling approach inspired by esbuild. The transpiler converts modern CSS syntax into backwards-compatible equivalents that work across browsers.
 
-A huge thanks goes to the amazing work from the authors of [LightningCSS](https://lightningcss.dev/) and [esbuild](https://esbuild.github.io/).
+<Note>A huge thanks goes to the amazing work from the authors of LightningCSS and esbuild.</Note>
 
-### Browser Compatibility
+## Browser Compatibility
 
 By default, Bun's CSS bundler targets the following browsers:
 
@@ -23,13 +28,13 @@ By default, Bun's CSS bundler targets the following browsers:
 - Chrome 87+
 - Safari 14+
 
-### Syntax Lowering
+## Syntax Lowering
 
-#### Nesting
+### Nesting
 
 The CSS Nesting specification allows you to write more concise and intuitive stylesheets by nesting selectors inside one another. Instead of repeating parent selectors across your CSS file, you can write child styles directly within their parent blocks.
 
-```css
+```scss title="styles.css" icon="file-code"
 /* With nesting */
 .card {
   background: white;
@@ -48,7 +53,7 @@ The CSS Nesting specification allows you to write more concise and intuitive sty
 
 Bun's CSS bundler automatically converts this nested syntax into traditional flat CSS that works in all browsers:
 
-```css
+```css title="styles.css" icon="file-code"
 /* Compiled output */
 .card {
   background: white;
@@ -67,7 +72,7 @@ Bun's CSS bundler automatically converts this nested syntax into traditional fla
 
 You can also nest media queries and other at-rules inside selectors, eliminating the need to repeat selector patterns:
 
-```css
+```scss title="styles.css" icon="file-code"
 .responsive-element {
   display: block;
 
@@ -79,7 +84,7 @@ You can also nest media queries and other at-rules inside selectors, eliminating
 
 This compiles to:
 
-```css
+```css title="styles.css" icon="file-code"
 .responsive-element {
   display: block;
 }
@@ -91,11 +96,11 @@ This compiles to:
 }
 ```
 
-#### Color mix
+### Color mix
 
 The `color-mix()` function gives you an easy way to blend two colors together according to a specified ratio in a chosen color space. This powerful feature lets you create color variations without manually calculating the resulting values.
 
-```css
+```scss title="styles.css" icon="file-code"
 .button {
   /* Mix blue and red in the RGB color space with a 30/70 proportion */
   background-color: color-mix(in srgb, blue 30%, red);
@@ -109,7 +114,7 @@ The `color-mix()` function gives you an easy way to blend two colors together ac
 
 Bun's CSS bundler evaluates these color mixes at build time when all color values are known (not CSS variables), generating static color values that work in all browsers:
 
-```css
+```css title="styles.css" icon="file-code"
 .button {
   /* Computed to the exact resulting color */
   background-color: #b31a1a;
@@ -122,11 +127,11 @@ Bun's CSS bundler evaluates these color mixes at build time when all color value
 
 This feature is particularly useful for creating color systems with programmatically derived shades, tints, and accents without needing preprocessors or custom tooling.
 
-#### Relative colors
+### Relative colors
 
 CSS now allows you to modify individual components of a color using relative color syntax. This powerful feature lets you create color variations by adjusting specific attributes like lightness, saturation, or individual channels without having to recalculate the entire color.
 
-```css
+```css title="styles.css" icon="file-code"
 .theme-color {
   /* Start with a base color and increase lightness by 15% */
   --accent: lch(from purple calc(l + 15%) c h);
@@ -147,27 +152,23 @@ Bun's CSS bundler computes these relative color modifications at build time (whe
 
 This approach is extremely useful for theme generation, creating accessible color variants, or building color scales based on mathematical relationships instead of hard-coding each value.
 
-#### LAB colors
+### LAB colors
 
 Modern CSS supports perceptually uniform color spaces like LAB, LCH, OKLAB, and OKLCH that offer significant advantages over traditional RGB. These color spaces can represent colors outside the standard RGB gamut, resulting in more vibrant and visually consistent designs.
 
-```css
+```css title="styles.css" icon="file-code"
 .vibrant-element {
   /* A vibrant red that exceeds sRGB gamut boundaries */
   color: lab(55% 78 35);
 
   /* A smooth gradient using perceptual color space */
-  background: linear-gradient(
-    to right,
-    oklch(65% 0.25 10deg),
-    oklch(65% 0.25 250deg)
-  );
+  background: linear-gradient(to right, oklch(65% 0.25 10deg), oklch(65% 0.25 250deg));
 }
 ```
 
 Bun's CSS bundler automatically converts these advanced color formats to backwards-compatible alternatives for browsers that don't yet support them:
 
-```css
+```css title="styles.css" icon="file-code"
 .vibrant-element {
   /* Fallback to closest RGB approximation */
   color: #ff0f52;
@@ -177,21 +178,17 @@ Bun's CSS bundler automatically converts these advanced color formats to backwar
   color: lab(55% 78 35);
 
   background: linear-gradient(to right, #cd4e15, #3887ab);
-  background: linear-gradient(
-    to right,
-    oklch(65% 0.25 10deg),
-    oklch(65% 0.25 250deg)
-  );
+  background: linear-gradient(to right, oklch(65% 0.25 10deg), oklch(65% 0.25 250deg));
 }
 ```
 
 This layered approach ensures optimal color rendering across all browsers while allowing you to use the latest color technologies in your designs.
 
-#### Color function
+### Color function
 
 The `color()` function provides a standardized way to specify colors in various predefined color spaces, expanding your design options beyond the traditional RGB space. This allows you to access wider color gamuts and create more vibrant designs.
 
-```css
+```css title="styles.css" icon="file-code"
 .vivid-element {
   /* Using the Display P3 color space for wider gamut colors */
   color: color(display-p3 1 0.1 0.3);
@@ -203,7 +200,7 @@ The `color()` function provides a standardized way to specify colors in various
 
 For browsers that don't support these advanced color functions yet, Bun's CSS bundler provides appropriate RGB fallbacks:
 
-```css
+```css title="styles.css" icon="file-code"
 .vivid-element {
   /* RGB fallback first for maximum compatibility */
   color: #fa1a4c;
@@ -217,11 +214,11 @@ For browsers that don't support these advanced color functions yet, Bun's CSS bu
 
 This functionality lets you use modern color spaces immediately while ensuring your designs remain functional across all browsers, with optimal colors displayed in supporting browsers and reasonable approximations elsewhere.
 
-#### HWB colors
+### HWB colors
 
 The HWB (Hue, Whiteness, Blackness) color model provides an intuitive way to express colors based on how much white or black is mixed with a pure hue. Many designers find this approach more natural for creating color variations compared to manipulating RGB or HSL values.
 
-```css
+```css title="styles.css" icon="file-code"
 .easy-theming {
   /* Pure cyan with no white or black added */
   --primary: hwb(180 0% 0%);
@@ -239,7 +236,7 @@ The HWB (Hue, Whiteness, Blackness) color model provides an intuitive way to exp
 
 Bun's CSS bundler automatically converts HWB colors to RGB for compatibility with all browsers:
 
-```css
+```css title="styles.css" icon="file-code"
 .easy-theming {
   --primary: #00ffff;
   --primary-light: #33ffff;
@@ -250,11 +247,11 @@ Bun's CSS bundler automatically converts HWB colors to RGB for compatibility wit
 
 The HWB model makes it particularly easy to create systematic color variations for design systems, providing a more intuitive approach to creating consistent tints and shades than working directly with RGB or HSL values.
 
-#### Color notation
+### Color notation
 
 Modern CSS has introduced more intuitive and concise ways to express colors. Space-separated color syntax eliminates the need for commas in RGB and HSL values, while hex colors with alpha channels provide a compact way to specify transparency.
 
-```css
+```css title="styles.css" icon="file-code"
 .modern-styling {
   /* Space-separated RGB notation (no commas) */
   color: rgb(50 100 200);
@@ -272,7 +269,7 @@ Modern CSS has introduced more intuitive and concise ways to express colors. Spa
 
 Bun's CSS bundler automatically converts these modern color formats to ensure compatibility with older browsers:
 
-```css
+```css title="styles.css" icon="file-code"
 .modern-styling {
   /* Converted to comma format for older browsers */
   color: rgb(50, 100, 200);
@@ -289,11 +286,11 @@ Bun's CSS bundler automatically converts these modern color formats to ensure co
 
 This conversion process lets you write cleaner, more modern CSS while ensuring your styles work correctly across all browsers.
 
-#### light-dark() color function
+### light-dark() color function
 
 The `light-dark()` function provides an elegant solution for implementing color schemes that respect the user's system preference without requiring complex media queries. This function accepts two color values and automatically selects the appropriate one based on the current color scheme context.
 
-```css
+```css title="styles.css" icon="file-code"
 :root {
   /* Define color scheme support */
   color-scheme: light dark;
@@ -318,7 +315,7 @@ The `light-dark()` function provides an elegant solution for implementing color
 
 For browsers that don't support this feature yet, Bun's CSS bundler converts it to use CSS variables with proper fallbacks:
 
-```css
+```css title="styles.css" icon="file-code"
 :root {
   --lightningcss-light: initial;
   --lightningcss-dark: ;
@@ -345,21 +342,19 @@ For browsers that don't support this feature yet, Bun's CSS bundler converts it
 }
 
 .themed-component {
-  background-color: var(--lightningcss-light, #ffffff)
-    var(--lightningcss-dark, #121212);
+  background-color: var(--lightningcss-light, #ffffff) var(--lightningcss-dark, #121212);
   color: var(--lightningcss-light, #333333) var(--lightningcss-dark, #eeeeee);
-  border-color: var(--lightningcss-light, #dddddd)
-    var(--lightningcss-dark, #555555);
+  border-color: var(--lightningcss-light, #dddddd) var(--lightningcss-dark, #555555);
 }
 ```
 
 This approach gives you a clean way to handle light and dark themes without duplicating styles or writing complex media queries, while maintaining compatibility with browsers that don't yet support the feature natively.
 
-#### Logical properties
+### Logical properties
 
 CSS logical properties let you define layout, spacing, and sizing relative to the document's writing mode and text direction rather than physical screen directions. This is crucial for creating truly international layouts that automatically adapt to different writing systems.
 
-```css
+```css title="styles.css" icon="file-code"
 .multilingual-component {
   /* Margin that adapts to writing direction */
   margin-inline-start: 1rem;
@@ -378,7 +373,7 @@ CSS logical properties let you define layout, spacing, and sizing relative to th
 
 For browsers that don't fully support logical properties, Bun's CSS bundler compiles them to physical properties with appropriate directional adjustments:
 
-```css
+```css title="styles.css" icon="file-code"
 /* For left-to-right languages */
 .multilingual-component:dir(ltr) {
   margin-left: 1rem;
@@ -402,11 +397,11 @@ For browsers that don't fully support logical properties, Bun's CSS bundler comp
 
 If the `:dir()` selector isn't supported, additional fallbacks are automatically generated to ensure your layouts work properly across all browsers and writing systems. This makes creating internationalized designs much simpler while maintaining compatibility with older browsers.
 
-#### :dir() selector
+### :dir() selector
 
 The `:dir()` pseudo-class selector allows you to style elements based on their text direction (RTL or LTR), providing a powerful way to create direction-aware designs without JavaScript. This selector matches elements based on their directionality as determined by the document or explicit direction attributes.
 
-```css
+```css title="styles.css" icon="file-code"
 /* Apply different styles based on text direction */
 .nav-arrow:dir(ltr) {
   transform: rotate(0deg);
@@ -428,7 +423,7 @@ The `:dir()` pseudo-class selector allows you to style elements based on their t
 
 For browsers that don't support the `:dir()` selector yet, Bun's CSS bundler converts it to the more widely supported `:lang()` selector with appropriate language mappings:
 
-```css
+```css title="styles.css" icon="file-code"
 /* Converted to use language-based selectors as fallback */
 .nav-arrow:lang(en, fr, de, es, it, pt, nl) {
   transform: rotate(0deg);
@@ -449,11 +444,11 @@ For browsers that don't support the `:dir()` selector yet, Bun's CSS bundler con
 
 This conversion lets you write direction-aware CSS that works reliably across browsers, even those that don't yet support the `:dir()` selector natively. If multiple arguments to `:lang()` aren't supported, further fallbacks are automatically provided.
 
-#### :lang() selector
+### :lang() selector
 
 The `:lang()` pseudo-class selector allows you to target elements based on the language they're in, making it easy to apply language-specific styling. Modern CSS allows the `:lang()` selector to accept multiple language codes, letting you group language-specific rules more efficiently.
 
-```css
+```css title="styles.css" icon="file-code"
 /* Typography adjustments for CJK languages */
 :lang(zh, ja, ko) {
   line-height: 1.8;
@@ -472,7 +467,7 @@ blockquote:lang(de, nl, da, sv) {
 
 For browsers that don't support multiple arguments in the `:lang()` selector, Bun's CSS bundler converts this syntax to use the `:is()` selector to maintain the same behavior:
 
-```css
+```css title="styles.css" icon="file-code"
 /* Multiple languages grouped with :is() for better browser support */
 :is(:lang(zh), :lang(ja), :lang(ko)) {
   line-height: 1.8;
@@ -490,11 +485,11 @@ blockquote:is(:lang(de), :lang(nl), :lang(da), :lang(sv)) {
 
 If needed, Bun can provide additional fallbacks for `:is()` as well, ensuring your language-specific styles work across all browsers. This approach simplifies creating internationalized designs with distinct typographic and styling rules for different language groups.
 
-#### :is() selector
+### :is() selector
 
 The `:is()` pseudo-class function (formerly `:matches()`) allows you to create more concise and readable selectors by grouping multiple selectors together. It accepts a selector list as its argument and matches if any of the selectors in that list match, significantly reducing repetition in your CSS.
 
-```css
+```css title="styles.css" icon="file-code"
 /* Instead of writing these separately */
 /* 
 .article h1,
@@ -547,13 +542,17 @@ For browsers that don't support `:is()`, Bun's CSS bundler provides fallbacks us
 }
 ```
 
-It's worth noting that the vendor-prefixed versions have some limitations compared to the standardized `:is()` selector, particularly with complex selectors. Bun handles these limitations intelligently, only using prefixed versions when they'll work correctly.
+<Warning>
+  The vendor-prefixed versions have some limitations compared to the standardized `:is()` selector, particularly with
+  complex selectors. Bun handles these limitations intelligently, only using prefixed versions when they'll work
+  correctly.
+</Warning>
 
-#### :not() selector
+### :not() selector
 
 The `:not()` pseudo-class allows you to exclude elements that match a specific selector. The modern version of this selector accepts multiple arguments, letting you exclude multiple patterns with a single, concise selector.
 
-```css
+```css title="styles.css" icon="file-code"
 /* Select all buttons except primary and secondary variants */
 button:not(.primary, .secondary) {
   background-color: #f5f5f5;
@@ -568,7 +567,7 @@ h2:not(.sidebar *, footer *) {
 
 For browsers that don't support multiple arguments in `:not()`, Bun's CSS bundler converts this syntax to a more compatible form while preserving the same behavior:
 
-```css
+```css title="styles.css" icon="file-code"
 /* Converted to use :not with :is() for compatibility */
 button:not(:is(.primary, .secondary)) {
   background-color: #f5f5f5;
@@ -582,7 +581,7 @@ h2:not(:is(.sidebar *, footer *)) {
 
 And if `:is()` isn't supported, Bun can generate further fallbacks:
 
-```css
+```css title="styles.css" icon="file-code"
 /* Even more fallbacks for maximum compatibility */
 button:not(:-webkit-any(.primary, .secondary)) {
   background-color: #f5f5f5;
@@ -602,11 +601,11 @@ button:not(:is(.primary, .secondary)) {
 
 This conversion ensures your negative selectors work correctly across all browsers while maintaining the correct specificity and behavior of the original selector.
 
-#### Math functions
+### Math functions
 
 CSS now includes a rich set of mathematical functions that let you perform complex calculations directly in your stylesheets. These include standard math functions (`round()`, `mod()`, `rem()`, `abs()`, `sign()`), trigonometric functions (`sin()`, `cos()`, `tan()`, `asin()`, `acos()`, `atan()`, `atan2()`), and exponential functions (`pow()`, `sqrt()`, `exp()`, `log()`, `hypot()`).
 
-```css
+```css title="styles.css" icon="file-code"
 .dynamic-sizing {
   /* Clamp a value between minimum and maximum */
   width: clamp(200px, 50%, 800px);
@@ -625,7 +624,7 @@ CSS now includes a rich set of mathematical functions that let you perform compl
 
 Bun's CSS bundler evaluates these mathematical expressions at build time when all values are known constants (not variables), resulting in optimized output:
 
-```css
+```css title="styles.css" icon="file-code"
 .dynamic-sizing {
   width: clamp(200px, 50%, 800px);
   padding: 15px;
@@ -637,11 +636,11 @@ Bun's CSS bundler evaluates these mathematical expressions at build time when al
 
 This approach lets you write more expressive and maintainable CSS with meaningful mathematical relationships, which then gets compiled to optimized values for maximum browser compatibility and performance.
 
-#### Media query ranges
+### Media query ranges
 
 Modern CSS supports intuitive range syntax for media queries, allowing you to specify breakpoints using comparison operators like `<`, `>`, `<=`, and `>=` instead of the more verbose `min-` and `max-` prefixes. This syntax is more readable and matches how we normally think about values and ranges.
 
-```css
+```css title="styles.css" icon="file-code"
 /* Modern syntax with comparison operators */
 @media (width >= 768px) {
   .container {
@@ -666,7 +665,7 @@ Modern CSS supports intuitive range syntax for media queries, allowing you to sp
 
 Bun's CSS bundler converts these modern range queries to traditional media query syntax for compatibility with all browsers:
 
-```css
+```css title="styles.css" icon="file-code"
 /* Converted to traditional min/max syntax */
 @media (min-width: 768px) {
   .container {
@@ -689,11 +688,11 @@ Bun's CSS bundler converts these modern range queries to traditional media query
 
 This lets you write more intuitive and mathematical media queries while ensuring your stylesheets work correctly across all browsers, including those that don't support the modern range syntax.
 
-#### Shorthands
+### Shorthands
 
 CSS has introduced several modern shorthand properties that improve code readability and maintainability. Bun's CSS bundler ensures these convenient shorthands work on all browsers by converting them to their longhand equivalents when needed.
 
-```css
+```css title="styles.css" icon="file-code"
 /* Alignment shorthands */
 .flex-container {
   /* Shorthand for align-items and justify-items */
@@ -729,7 +728,7 @@ CSS has introduced several modern shorthand properties that improve code readabi
 
 For browsers that don't support these modern shorthands, Bun converts them to their component longhand properties:
 
-```css
+```css title="styles.css" icon="file-code"
 .flex-container {
   /* Expanded alignment properties */
   align-items: center;
@@ -766,11 +765,11 @@ For browsers that don't support these modern shorthands, Bun converts them to th
 
 This conversion ensures your stylesheets remain clean and maintainable while providing the broadest possible browser compatibility.
 
-#### Double position gradients
+### Double position gradients
 
 The double position gradient syntax is a modern CSS feature that allows you to create hard color stops in gradients by specifying the same color at two adjacent positions. This creates a sharp transition rather than a smooth fade, which is useful for creating stripes, color bands, and other multi-color designs.
 
-```css
+```css title="styles.css" icon="file-code"
 .striped-background {
   /* Creates a sharp transition from green to red at 30%-40% */
   background: linear-gradient(
@@ -799,7 +798,7 @@ The double position gradient syntax is a modern CSS feature that allows you to c
 
 For browsers that don't support this syntax, Bun's CSS bundler automatically converts it to the traditional format by duplicating color stops:
 
-```css
+```css title="styles.css" icon="file-code"
 .striped-background {
   background: linear-gradient(
     to right,
@@ -830,11 +829,11 @@ For browsers that don't support this syntax, Bun's CSS bundler automatically con
 
 This conversion lets you use the cleaner double position syntax in your source code while ensuring gradients display correctly in all browsers.
 
-#### system-ui font
+### system-ui font
 
 The `system-ui` generic font family lets you use the device's native UI font, creating interfaces that feel more integrated with the operating system. This provides a more native look and feel without having to specify different font stacks for each platform.
 
-```css
+```css title="styles.css" icon="file-code"
 .native-interface {
   /* Use the system's default UI font */
   font-family: system-ui;
@@ -848,7 +847,7 @@ The `system-ui` generic font family lets you use the device's native UI font, cr
 
 For browsers that don't support `system-ui`, Bun's CSS bundler automatically expands it to a comprehensive cross-platform font stack:
 
-```css
+```css title="styles.css" icon="file-code"
 .native-interface {
   /* Expanded to support all major platforms */
   font-family:
@@ -883,7 +882,7 @@ This approach gives you the simplicity of writing just `system-ui` in your sourc
 
 ## CSS Modules
 
-Bun's bundler also supports bundling [CSS modules](https://css-tricks.com/css-modules-part-1-need/) in addition to [regular CSS](/docs/bundler/css) with support for the following features:
+Bun's bundler also supports bundling CSS modules in addition to regular CSS with support for the following features:
 
 - Automatically detecting CSS module files (`.module.css`) with zero configuration
 - Composition (`composes` property)
@@ -894,17 +893,17 @@ A CSS module is a CSS file (with the `.module.css` extension) where are all clas
 
 Under the hood, Bun's bundler transforms locally scoped class names into unique identifiers.
 
-## Getting started
+### Getting started
 
 Create a CSS file with the `.module.css` extension:
 
-```css
-/* styles.module.css */
+```css title="styles.module.css" icon="file-code"
 .button {
   color: red;
 }
+```
 
-/* other-styles.module.css */
+```css title="other-styles.module.css" icon="file-code"
 .button {
   color: blue;
 }
@@ -912,7 +911,7 @@ Create a CSS file with the `.module.css` extension:
 
 You can then import this file, for example into a TSX file:
 
-```tsx
+```tsx title="app.tsx" icon="/icons/typescript.svg"
 import styles from "./styles.module.css";
 import otherStyles from "./other-styles.module.css";
 
@@ -926,10 +925,9 @@ export default function App() {
 }
 ```
 
-The `styles` object from importing the CSS module file will be an object with all class names as keys and
-their unique identifiers as values:
+The styles object from importing the CSS module file will be an object with all class names as keys and their unique identifiers as values:
 
-```tsx
+```ts title="app.tsx" icon="/icons/typescript.svg"
 import styles from "./styles.module.css";
 import otherStyles from "./other-styles.module.css";
 
@@ -939,7 +937,7 @@ console.log(otherStyles);
 
 This will output:
 
-```ts
+```ts title="app.tsx" icon="/icons/typescript.svg"
 {
   button: "button_123";
 }
@@ -953,12 +951,11 @@ As you can see, the class names are unique to each file, avoiding any collisions
 
 ### Composition
 
-CSS modules allow you to _compose_ class selectors together. This lets you reuse style rules across multiple classes.
+CSS modules allow you to compose class selectors together. This lets you reuse style rules across multiple classes.
 
 For example:
 
-```css
-/* styles.module.css */
+```css title="styles.module.css" icon="file-code"
 .button {
   composes: background;
   color: red;
@@ -971,7 +968,7 @@ For example:
 
 Would be the same as writing:
 
-```css
+```css title="styles.module.css" icon="file-code"
 .button {
   background-color: blue;
   color: red;
@@ -982,13 +979,14 @@ Would be the same as writing:
 }
 ```
 
-{% callout %}
 There are a couple rules to keep in mind when using `composes`:
 
-- A `composes` property must come before any regular CSS properties or declarations
-- You can only use `composes` on a **simple selector with a single class name**:
+<Info>
+  **Composition Rules:** - A `composes` property must come before any regular CSS properties or declarations - You can
+  only use `composes` on a simple selector with a single class name
+</Info>
 
-```css
+```css title="styles.module.css" icon="file-code"
 #button {
   /* Invalid! `#button` is not a class selector */
   composes: background;
@@ -1001,28 +999,26 @@ There are a couple rules to keep in mind when using `composes`:
 }
 ```
 
-{% /callout %}
-
 ### Composing from a separate CSS module file
 
 You can also compose from a separate CSS module file:
 
-```css
-/* background.module.css */
+```css title="background.module.css" icon="file-code"
 .background {
   background-color: blue;
 }
+```
 
-/* styles.module.css */
+```css title="styles.module.css" icon="file-code"
 .button {
   composes: background from "./background.module.css";
   color: red;
 }
 ```
 
-{% callout %}
+<Warning>
 When composing classes from separate files, be sure that they do not contain the same properties.
 
-The CSS module spec says that composing classes from separate files with conflicting properties is
-undefined behavior, meaning that the output may differ and be unreliable.
-{% /callout %}
+The CSS module spec says that composing classes from separate files with conflicting properties is undefined behavior, meaning that the output may differ and be unreliable.
+
+</Warning>

docs/bundler/css_modules.md

@@ -1,145 +0,0 @@
-# CSS Modules
-
-Bun's bundler also supports bundling [CSS modules](https://css-tricks.com/css-modules-part-1-need/) in addition to [regular CSS](/docs/bundler/css) with support for the following features:
-
-- Automatically detecting CSS module files (`.module.css`) with zero configuration
-- Composition (`composes` property)
-- Importing CSS modules into JSX/TSX
-- Warnings/errors for invalid usages of CSS modules
-
-A CSS module is a CSS file (with the `.module.css` extension) where are all class names and animations are scoped to the file. This helps you avoid class name collisions as CSS declarations are globally scoped by default.
-
-Under the hood, Bun's bundler transforms locally scoped class names into unique identifiers.
-
-## Getting started
-
-Create a CSS file with the `.module.css` extension:
-
-```css
-/* styles.module.css */
-.button {
-  color: red;
-}
-
-/* other-styles.module.css */
-.button {
-  color: blue;
-}
-```
-
-You can then import this file, for example into a TSX file:
-
-```tsx
-import styles from "./styles.module.css";
-import otherStyles from "./other-styles.module.css";
-
-export default function App() {
-  return (
-    <>
-      <button className={styles.button}>Red button!</button>
-      <button className={otherStyles.button}>Blue button!</button>
-    </>
-  );
-}
-```
-
-The `styles` object from importing the CSS module file will be an object with all class names as keys and
-their unique identifiers as values:
-
-```tsx
-import styles from "./styles.module.css";
-import otherStyles from "./other-styles.module.css";
-
-console.log(styles);
-console.log(otherStyles);
-```
-
-This will output:
-
-```ts
-{
-  button: "button_123";
-}
-
-{
-  button: "button_456";
-}
-```
-
-As you can see, the class names are unique to each file, avoiding any collisions!
-
-### Composition
-
-CSS modules allow you to _compose_ class selectors together. This lets you reuse style rules across multiple classes.
-
-For example:
-
-```css
-/* styles.module.css */
-.button {
-  composes: background;
-  color: red;
-}
-
-.background {
-  background-color: blue;
-}
-```
-
-Would be the same as writing:
-
-```css
-.button {
-  background-color: blue;
-  color: red;
-}
-
-.background {
-  background-color: blue;
-}
-```
-
-{% callout %}
-There are a couple rules to keep in mind when using `composes`:
-
-- A `composes` property must come before any regular CSS properties or declarations
-- You can only use `composes` on a **simple selector with a single class name**:
-
-```css
-#button {
-  /* Invalid! `#button` is not a class selector */
-  composes: background;
-}
-
-.button,
-.button-secondary {
-  /* Invalid! `.button, .button-secondary` is not a simple selector */
-  composes: background;
-}
-```
-
-{% /callout %}
-
-### Composing from a separate CSS module file
-
-You can also compose from a separate CSS module file:
-
-```css
-/* background.module.css */
-.background {
-  background-color: blue;
-}
-
-/* styles.module.css */
-.button {
-  composes: background from "./background.module.css";
-  color: red;
-}
-```
-
-{% callout %}
-When composing classes from separate files, be sure that they do not contain the same properties.
-
-The CSS module spec says that composing classes from separate files with conflicting properties is
-undefined behavior, meaning that the output may differ and be unreliable.
-{% /callout %}

docs/bundler/esbuild.mdx

@@ -0,0 +1,298 @@
+---
+title: esbuild
+description: Migration guide from esbuild to Bun's bundler
+---
+
+Bun's bundler API is inspired heavily by esbuild. Migrating to Bun's bundler from esbuild should be relatively painless. This guide will briefly explain why you might consider migrating to Bun's bundler and provide a side-by-side API comparison reference for those who are already familiar with esbuild's API.
+
+There are a few behavioral differences to note.
+
+<Note>
+  **Bundling by default.** Unlike esbuild, Bun always bundles by default. This is why the `--bundle` flag isn't
+  necessary in the Bun example. To transpile each file individually, use `Bun.Transpiler`.
+</Note>
+
+<Note>
+  **It's just a bundler.** Unlike esbuild, Bun's bundler does not include a built-in development server or file watcher.
+  It's just a bundler. The bundler is intended for use in conjunction with `Bun.serve` and other runtime APIs to achieve
+  the same effect. As such, all options relating to HTTP/file watching are not applicable.
+</Note>
+
+## Performance
+
+With a performance-minded API coupled with the extensively optimized Zig-based JS/TS parser, Bun's bundler is 1.75x faster than esbuild on esbuild's three.js benchmark.
+
+<Info>Bundling 10 copies of three.js from scratch, with sourcemaps and minification</Info>
+
+## CLI API
+
+Bun and esbuild both provide a command-line interface.
+
+```bash terminal icon="terminal"
+# esbuild
+esbuild <entrypoint> --outdir=out --bundle
+
+# bun
+bun build <entrypoint> --outdir=out
+```
+
+In Bun's CLI, simple boolean flags like `--minify` do not accept an argument. Other flags like `--outdir <path>` do accept an argument; these flags can be written as `--outdir out` or `--outdir=out`. Some flags like `--define` can be specified several times: `--define foo=bar --define bar=baz`.
+
+| esbuild                | bun build                  | Notes                                                                                                                                                                                                                                                                                                                                                               |
+| ---------------------- | -------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `--bundle`             | n/a                        | Bun always bundles, use `--no-bundle` to disable this behavior.                                                                                                                                                                                                                                                                                                     |
+| `--define:K=V`         | `--define K=V`             | Small syntax difference; no colon.<br/>`esbuild --define:foo=bar`<br/>`bun build --define foo=bar`                                                                                                                                                                                                                                                                  |
+| `--external:<pkg>`     | `--external <pkg>`         | Small syntax difference; no colon.<br/>`esbuild --external:react`<br/>`bun build --external react`                                                                                                                                                                                                                                                                  |
+| `--format`             | `--format`                 | Bun supports `"esm"` and `"cjs"` currently, but more module formats are planned. esbuild defaults to `"iife"`.                                                                                                                                                                                                                                                      |
+| `--loader:.ext=loader` | `--loader .ext:loader`     | Bun supports a different set of built-in loaders than esbuild; see Bundler > Loaders for a complete reference. The esbuild loaders `dataurl`, `binary`, `base64`, `copy`, and `empty` are not yet implemented.<br/><br/>The syntax for `--loader` is slightly different.<br/>`esbuild app.ts --bundle --loader:.svg=text`<br/>`bun build app.ts --loader .svg:text` |
+| `--minify`             | `--minify`                 | No differences                                                                                                                                                                                                                                                                                                                                                      |
+| `--outdir`             | `--outdir`                 | No differences                                                                                                                                                                                                                                                                                                                                                      |
+| `--outfile`            | `--outfile`                | No differences                                                                                                                                                                                                                                                                                                                                                      |
+| `--packages`           | `--packages`               | No differences                                                                                                                                                                                                                                                                                                                                                      |
+| `--platform`           | `--target`                 | Renamed to `--target` for consistency with tsconfig. Does not support `neutral`.                                                                                                                                                                                                                                                                                    |
+| `--serve`              | n/a                        | Not applicable                                                                                                                                                                                                                                                                                                                                                      |
+| `--sourcemap`          | `--sourcemap`              | No differences                                                                                                                                                                                                                                                                                                                                                      |
+| `--splitting`          | `--splitting`              | No differences                                                                                                                                                                                                                                                                                                                                                      |
+| `--target`             | n/a                        | Not supported. Bun's bundler performs no syntactic down-leveling at this time.                                                                                                                                                                                                                                                                                      |
+| `--watch`              | `--watch`                  | No differences                                                                                                                                                                                                                                                                                                                                                      |
+| `--allow-overwrite`    | n/a                        | Overwriting is never allowed                                                                                                                                                                                                                                                                                                                                        |
+| `--analyze`            | n/a                        | Not supported                                                                                                                                                                                                                                                                                                                                                       |
+| `--asset-names`        | `--asset-naming`           | Renamed for consistency with naming in JS API                                                                                                                                                                                                                                                                                                                       |
+| `--banner`             | `--banner`                 | Only applies to js bundles                                                                                                                                                                                                                                                                                                                                          |
+| `--footer`             | `--footer`                 | Only applies to js bundles                                                                                                                                                                                                                                                                                                                                          |
+| `--certfile`           | n/a                        | Not applicable                                                                                                                                                                                                                                                                                                                                                      |
+| `--charset=utf8`       | n/a                        | Not supported                                                                                                                                                                                                                                                                                                                                                       |
+| `--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` |                                                                                                                                                                                                                                                                                                                                                                     |
+| `--inject`             | n/a                        | Not supported                                                                                                                                                                                                                                                                                                                                                       |
+| `--jsx`                | `--jsx-runtime <runtime>`  | Supports `"automatic"` (uses jsx transform) and `"classic"` (uses `React.createElement`)                                                                                                                                                                                                                                                                            |
+| `--jsx-dev`            | n/a                        | Bun reads `compilerOptions.jsx` from `tsconfig.json` to determine a default. If `compilerOptions.jsx` is `"react-jsx"`, or if `NODE_ENV=production`, Bun will use the jsx transform. Otherwise, it uses `jsxDEV`. The bundler does not support `preserve`.                                                                                                          |
+| `--jsx-factory`        | `--jsx-factory`            |                                                                                                                                                                                                                                                                                                                                                                     |
+| `--jsx-fragment`       | `--jsx-fragment`           |                                                                                                                                                                                                                                                                                                                                                                     |
+| `--jsx-import-source`  | `--jsx-import-source`      |                                                                                                                                                                                                                                                                                                                                                                     |
+| `--jsx-side-effects`   | n/a                        | JSX is always assumed to be side-effect-free                                                                                                                                                                                                                                                                                                                        |
+| `--keep-names`         | n/a                        | Not supported                                                                                                                                                                                                                                                                                                                                                       |
+| `--keyfile`            | n/a                        | Not applicable                                                                                                                                                                                                                                                                                                                                                      |
+| `--legal-comments`     | n/a                        | Not supported                                                                                                                                                                                                                                                                                                                                                       |
+| `--log-level`          | n/a                        | Not supported. This can be set in `bunfig.toml` as `logLevel`.                                                                                                                                                                                                                                                                                                      |
+| `--log-limit`          | n/a                        | Not supported                                                                                                                                                                                                                                                                                                                                                       |
+| `--log-override:X=Y`   | n/a                        | Not supported                                                                                                                                                                                                                                                                                                                                                       |
+| `--main-fields`        | n/a                        | Not supported                                                                                                                                                                                                                                                                                                                                                       |
+| `--mangle-cache`       | n/a                        | Not supported                                                                                                                                                                                                                                                                                                                                                       |
+| `--mangle-props`       | n/a                        | Not supported                                                                                                                                                                                                                                                                                                                                                       |
+| `--mangle-quoted`      | n/a                        | Not supported                                                                                                                                                                                                                                                                                                                                                       |
+| `--metafile`           | n/a                        | Not supported                                                                                                                                                                                                                                                                                                                                                       |
+| `--minify-whitespace`  | `--minify-whitespace`      |                                                                                                                                                                                                                                                                                                                                                                     |
+| `--minify-identifiers` | `--minify-identifiers`     |                                                                                                                                                                                                                                                                                                                                                                     |
+| `--minify-syntax`      | `--minify-syntax`          |                                                                                                                                                                                                                                                                                                                                                                     |
+| `--out-extension`      | n/a                        | Not supported                                                                                                                                                                                                                                                                                                                                                       |
+| `--outbase`            | `--root`                   |                                                                                                                                                                                                                                                                                                                                                                     |
+| `--preserve-symlinks`  | n/a                        | Not supported                                                                                                                                                                                                                                                                                                                                                       |
+| `--public-path`        | `--public-path`            |                                                                                                                                                                                                                                                                                                                                                                     |
+| `--pure`               | n/a                        | Not supported                                                                                                                                                                                                                                                                                                                                                       |
+| `--reserve-props`      | n/a                        | Not supported                                                                                                                                                                                                                                                                                                                                                       |
+| `--resolve-extensions` | n/a                        | Not supported                                                                                                                                                                                                                                                                                                                                                       |
+| `--servedir`           | n/a                        | Not applicable                                                                                                                                                                                                                                                                                                                                                      |
+| `--source-root`        | n/a                        | Not supported                                                                                                                                                                                                                                                                                                                                                       |
+| `--sourcefile`         | n/a                        | Not supported. Bun does not support stdin input yet.                                                                                                                                                                                                                                                                                                                |
+| `--sourcemap`          | `--sourcemap`              | No differences                                                                                                                                                                                                                                                                                                                                                      |
+| `--sources-content`    | n/a                        | Not supported                                                                                                                                                                                                                                                                                                                                                       |
+| `--supported`          | n/a                        | Not supported                                                                                                                                                                                                                                                                                                                                                       |
+| `--tree-shaking`       | n/a                        | Always true                                                                                                                                                                                                                                                                                                                                                         |
+| `--tsconfig`           | `--tsconfig-override`      |                                                                                                                                                                                                                                                                                                                                                                     |
+| `--version`            | n/a                        | Run `bun --version` to see the version of Bun.                                                                                                                                                                                                                                                                                                                      |
+
+## JavaScript API
+
+| esbuild.build()     | Bun.build()                | Notes                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
+| ------------------- | -------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `absWorkingDir`     | n/a                        | Always set to `process.cwd()`                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
+| `alias`             | n/a                        | Not supported                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
+| `allowOverwrite`    | n/a                        | Always false                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
+| `assetNames`        | `naming.asset`             | Uses same templating syntax as esbuild, but `[ext]` must be included explicitly.<br/><br/>`ts<br/>Bun.build({<br/>  entrypoints: ["./index.tsx"],<br/>  naming: {<br/>    asset: "[name].[ext]",<br/>  },<br/>});<br/>`                                                                                                                                                                                                                                                                |
+| `banner`            | n/a                        | Not supported                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
+| `bundle`            | n/a                        | Always true. Use `Bun.Transpiler` to transpile without bundling.                                                                                                                                                                                                                                                                                                                                                                                                                       |
+| `charset`           | n/a                        | Not supported                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
+| `chunkNames`        | `naming.chunk`             | Uses same templating syntax as esbuild, but `[ext]` must be included explicitly.<br/><br/>`ts<br/>Bun.build({<br/>  entrypoints: ["./index.tsx"],<br/>  naming: {<br/>    chunk: "[name].[ext]",<br/>  },<br/>});<br/>`                                                                                                                                                                                                                                                                |
+| `color`             | n/a                        | Bun returns logs in the `logs` property of the build result.                                                                                                                                                                                                                                                                                                                                                                                                                           |
+| `conditions`        | n/a                        | Not supported. Export conditions priority is determined by `target`.                                                                                                                                                                                                                                                                                                                                                                                                                   |
+| `define`            | `define`                   |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
+| `drop`              | n/a                        | Not supported                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
+| `entryNames`        | `naming` or `naming.entry` | Bun supports a `naming` key that can either be a string or an object. Uses same templating syntax as esbuild, but `[ext]` must be included explicitly.<br/><br/>`ts<br/>Bun.build({<br/>  entrypoints: ["./index.tsx"],<br/>  // when string, this is equivalent to entryNames<br/>  naming: "[name].[ext]",<br/><br/>  // granular naming options<br/>  naming: {<br/>    entry: "[name].[ext]",<br/>    asset: "[name].[ext]",<br/>    chunk: "[name].[ext]",<br/>  },<br/>});<br/>` |
+| `entryPoints`       | `entrypoints`              | Capitalization difference                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
+| `external`          | `external`                 | No differences                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| `footer`            | n/a                        | Not supported                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
+| `format`            | `format`                   | Only supports `"esm"` currently. Support for `"cjs"` and `"iife"` is planned.                                                                                                                                                                                                                                                                                                                                                                                                          |
+| `globalName`        | n/a                        | Not supported                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
+| `ignoreAnnotations` | n/a                        | Not supported                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
+| `inject`            | n/a                        | Not supported                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
+| `jsx`               | `jsx`                      | Not supported in JS API, configure in `tsconfig.json`                                                                                                                                                                                                                                                                                                                                                                                                                                  |
+| `jsxDev`            | `jsxDev`                   | Not supported in JS API, configure in `tsconfig.json`                                                                                                                                                                                                                                                                                                                                                                                                                                  |
+| `jsxFactory`        | `jsxFactory`               | Not supported in JS API, configure in `tsconfig.json`                                                                                                                                                                                                                                                                                                                                                                                                                                  |
+| `jsxFragment`       | `jsxFragment`              | Not supported in JS API, configure in `tsconfig.json`                                                                                                                                                                                                                                                                                                                                                                                                                                  |
+| `jsxImportSource`   | `jsxImportSource`          | Not supported in JS API, configure in `tsconfig.json`                                                                                                                                                                                                                                                                                                                                                                                                                                  |
+| `jsxSideEffects`    | `jsxSideEffects`           | Not supported in JS API, configure in `tsconfig.json`                                                                                                                                                                                                                                                                                                                                                                                                                                  |
+| `keepNames`         | n/a                        | Not supported                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
+| `legalComments`     | n/a                        | Not supported                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
+| `loader`            | `loader`                   | Bun supports a different set of built-in loaders than esbuild; see Bundler > Loaders for a complete reference. The esbuild loaders `dataurl`, `binary`, `base64`, `copy`, and `empty` are not yet implemented.                                                                                                                                                                                                                                                                         |
+| `logLevel`          | n/a                        | Not supported                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
+| `logLimit`          | n/a                        | Not supported                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
+| `logOverride`       | n/a                        | Not supported                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
+| `mainFields`        | n/a                        | Not supported                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
+| `mangleCache`       | n/a                        | Not supported                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
+| `mangleProps`       | n/a                        | Not supported                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
+| `mangleQuoted`      | n/a                        | Not supported                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
+| `metafile`          | n/a                        | Not supported                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
+| `minify`            | `minify`                   | In Bun, `minify` can be a boolean or an object.<br/><br/>`ts<br/>await Bun.build({<br/>  entrypoints: ['./index.tsx'],<br/>  // enable all minification<br/>  minify: true<br/><br/>  // granular options<br/>  minify: {<br/>    identifiers: true,<br/>    syntax: true,<br/>    whitespace: true<br/>  }<br/>})<br/>`                                                                                                                                                               |
+| `minifyIdentifiers` | `minify.identifiers`       | See `minify`                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
+| `minifySyntax`      | `minify.syntax`            | See `minify`                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
+| `minifyWhitespace`  | `minify.whitespace`        | See `minify`                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
+| `nodePaths`         | n/a                        | Not supported                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
+| `outExtension`      | n/a                        | Not supported                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
+| `outbase`           | `root`                     | Different name                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| `outdir`            | `outdir`                   | No differences                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| `outfile`           | `outfile`                  | No differences                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| `packages`          | n/a                        | Not supported, use `external`                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
+| `platform`          | `target`                   | Supports `"bun"`, `"node"` and `"browser"` (the default). Does not support `"neutral"`.                                                                                                                                                                                                                                                                                                                                                                                                |
+| `plugins`           | `plugins`                  | Bun's plugin API is a subset of esbuild's. Some esbuild plugins will work out of the box with Bun.                                                                                                                                                                                                                                                                                                                                                                                     |
+| `preserveSymlinks`  | n/a                        | Not supported                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
+| `publicPath`        | `publicPath`               | No differences                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| `pure`              | n/a                        | Not supported                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
+| `reserveProps`      | n/a                        | Not supported                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
+| `resolveExtensions` | n/a                        | Not supported                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
+| `sourceRoot`        | n/a                        | Not supported                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
+| `sourcemap`         | `sourcemap`                | Supports `"inline"`, `"external"`, and `"none"`                                                                                                                                                                                                                                                                                                                                                                                                                                        |
+| `sourcesContent`    | n/a                        | Not supported                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
+| `splitting`         | `splitting`                | No differences                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| `stdin`             | n/a                        | Not supported                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
+| `supported`         | n/a                        | Not supported                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
+| `target`            | n/a                        | No support for syntax downleveling                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
+| `treeShaking`       | n/a                        | Always true                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
+| `tsconfig`          | n/a                        | Not supported                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
+| `write`             | n/a                        | Set to true if `outdir`/`outfile` is set, otherwise false                                                                                                                                                                                                                                                                                                                                                                                                                              |
+
+## Plugin API
+
+Bun's plugin API is designed to be esbuild compatible. Bun doesn't support esbuild's entire plugin API surface, but the core functionality is implemented. Many third-party esbuild plugins will work out of the box with Bun.
+
+<Note>
+  Long term, we aim for feature parity with esbuild's API, so if something doesn't work please file an issue to help us
+  prioritize.
+</Note>
+
+Plugins in Bun and esbuild are defined with a builder object.
+
+```ts title="myPlugin.ts" icon="/icons/typescript.svg"
+import type { BunPlugin } from "bun";
+
+const myPlugin: BunPlugin = {
+  name: "my-plugin",
+  setup(builder) {
+    // define plugin
+  },
+};
+```
+
+The builder object provides some methods for hooking into parts of the bundling process. Bun implements `onResolve` and `onLoad`; it does not yet implement the esbuild hooks `onStart`, `onEnd`, and `onDispose`, and `resolve` utilities. `initialOptions` is partially implemented, being read-only and only having a subset of esbuild's options; use `config` (same thing but with Bun's `BuildConfig` format) instead.
+
+```ts title="myPlugin.ts" icon="/icons/typescript.svg"
+import type { BunPlugin } from "bun";
+const myPlugin: BunPlugin = {
+  name: "my-plugin",
+  setup(builder) {
+    builder.onResolve(
+      {
+        /* onResolve.options */
+      },
+      args => {
+        return {
+          /* onResolve.results */
+        };
+      },
+    );
+    builder.onLoad(
+      {
+        /* onLoad.options */
+      },
+      args => {
+        return {
+          /* onLoad.results */
+        };
+      },
+    );
+  },
+};
+```
+
+### onResolve
+
+<Tabs>
+  <Tab title="options">
+
+    - 🟢 `filter`
+    - 🟢 `namespace`
+
+  </Tab>
+  <Tab title="arguments">
+
+    - 🟢 `path`
+    - 🟢 `importer`
+    - 🔴 `namespace`
+    - 🔴 `resolveDir`
+    - 🔴 `kind`
+    - 🔴 `pluginData`
+
+  </Tab>
+  <Tab title="results">
+
+    - 🟢 `namespace`
+    - 🟢 `path`
+    - 🔴 `errors`
+    - 🔴 `external`
+    - 🔴 `pluginData`
+    - 🔴 `pluginName`
+    - 🔴 `sideEffects`
+    - 🔴 `suffix`
+    - 🔴 `warnings`
+    - 🔴 `watchDirs`
+    - 🔴 `watchFiles`
+
+  </Tab>
+</Tabs>
+
+### onLoad
+
+<Tabs>
+  <Tab title="options">
+
+    - 🟢 `filter`
+    - 🟢 `namespace`
+
+  </Tab>
+  <Tab title="arguments">
+  
+    - 🟢 `path`
+    - 🔴 `namespace`
+    - 🔴 `suffix`
+    - 🔴 `pluginData`
+
+  </Tab>
+  <Tab title="results">
+
+    - 🟢 `contents`
+    - 🟢 `loader`
+    - 🔴 `errors`
+    - 🔴 `pluginData`
+    - 🔴 `pluginName`
+    - 🔴 `resolveDir`
+    - 🔴 `warnings`
+    - 🔴 `watchDirs`
+    - 🔴 `watchFiles`
+
+  </Tab>
+</Tabs>

docs/bundler/executables.md

@@ -1,626 +0,0 @@
-Bun's bundler implements a `--compile` flag for generating a standalone binary from a TypeScript or JavaScript file.
-
-{% codetabs %}
-
-```bash
-$ bun build ./cli.ts --compile --outfile mycli
-```
-
-```ts#cli.ts
-console.log("Hello world!");
-```
-
-{% /codetabs %}
-
-This bundles `cli.ts` into an executable that can be executed directly:
-
-```
-$ ./mycli
-Hello world!
-```
-
-All imported files and packages are bundled into the executable, along with a copy of the Bun runtime. All built-in Bun and Node.js APIs are supported.
-
-## Cross-compile to other platforms
-
-The `--target` flag lets you compile your standalone executable for a different operating system, architecture, or version of Bun than the machine you're running `bun build` on.
-
-To build for Linux x64 (most servers):
-
-```sh
-bun build --compile --target=bun-linux-x64 ./index.ts --outfile myapp
-
-# To support CPUs from before 2013, use the baseline version (nehalem)
-bun build --compile --target=bun-linux-x64-baseline ./index.ts --outfile myapp
-
-# To explicitly only support CPUs from 2013 and later, use the modern version (haswell)
-# modern is faster, but baseline is more compatible.
-bun build --compile --target=bun-linux-x64-modern ./index.ts --outfile myapp
-```
-
-To build for Linux ARM64 (e.g. Graviton or Raspberry Pi):
-
-```sh
-# Note: the default architecture is x64 if no architecture is specified.
-bun build --compile --target=bun-linux-arm64 ./index.ts --outfile myapp
-```
-
-To build for Windows x64:
-
-```sh
-bun build --compile --target=bun-windows-x64 ./path/to/my/app.ts --outfile myapp
-
-# To support CPUs from before 2013, use the baseline version (nehalem)
-bun build --compile --target=bun-windows-x64-baseline ./path/to/my/app.ts --outfile myapp
-
-# To explicitly only support CPUs from 2013 and later, use the modern version (haswell)
-bun build --compile --target=bun-windows-x64-modern ./path/to/my/app.ts --outfile myapp
-
-# note: if no .exe extension is provided, Bun will automatically add it for Windows executables
-```
-
-To build for macOS arm64:
-
-```sh
-bun build --compile --target=bun-darwin-arm64 ./path/to/my/app.ts --outfile myapp
-```
-
-To build for macOS x64:
-
-```sh
-bun build --compile --target=bun-darwin-x64 ./path/to/my/app.ts --outfile myapp
-```
-
-#### Supported targets
-
-The order of the `--target` flag does not matter, as long as they're delimited by a `-`.
-
-| --target              | Operating System | Architecture | Modern | Baseline | Libc  |
-| --------------------- | ---------------- | ------------ | ------ | -------- | ----- |
-| bun-linux-x64         | Linux            | x64          | ✅     | ✅       | glibc |
-| bun-linux-arm64       | Linux            | arm64        | ✅     | N/A      | glibc |
-| bun-windows-x64       | Windows          | x64          | ✅     | ✅       | -     |
-| ~~bun-windows-arm64~~ | Windows          | arm64        | ❌     | ❌       | -     |
-| bun-darwin-x64        | macOS            | x64          | ✅     | ✅       | -     |
-| bun-darwin-arm64      | macOS            | arm64        | ✅     | N/A      | -     |
-| bun-linux-x64-musl    | Linux            | x64          | ✅     | ✅       | musl  |
-| bun-linux-arm64-musl  | Linux            | arm64        | ✅     | N/A      | musl  |
-
-On x64 platforms, Bun uses SIMD optimizations which require a modern CPU supporting AVX2 instructions. The `-baseline` build of Bun is for older CPUs that don't support these optimizations. Normally, when you install Bun we automatically detect which version to use but this can be harder to do when cross-compiling since you might not know the target CPU. You usually don't need to worry about it on Darwin x64, but it is relevant for Windows x64 and Linux x64. If you or your users see `"Illegal instruction"` errors, you might need to use the baseline version.
-
-## Build-time constants
-
-Use the `--define` flag to inject build-time constants into your executable, such as version numbers, build timestamps, or configuration values:
-
-```bash
-$ bun build --compile --define BUILD_VERSION='"1.2.3"' --define BUILD_TIME='"2024-01-15T10:30:00Z"' src/cli.ts --outfile mycli
-```
-
-These constants are embedded directly into your compiled binary at build time, providing zero runtime overhead and enabling dead code elimination optimizations.
-
-{% callout type="info" %}
-For comprehensive examples and advanced patterns, see the [Build-time constants guide](/guides/runtime/build-time-constants).
-{% /callout %}
-
-## Deploying to production
-
-Compiled executables reduce memory usage and improve Bun's start time.
-
-Normally, Bun reads and transpiles JavaScript and TypeScript files on `import` and `require`. This is part of what makes so much of Bun "just work", but it's not free. It costs time and memory to read files from disk, resolve file paths, parse, transpile, and print source code.
-
-With compiled executables, you can move that cost from runtime to build-time.
-
-When deploying to production, we recommend the following:
-
-```sh
-bun build --compile --minify --sourcemap ./path/to/my/app.ts --outfile myapp
-```
-
-### Bytecode compilation
-
-To improve startup time, enable bytecode compilation:
-
-```sh
-bun build --compile --minify --sourcemap --bytecode ./path/to/my/app.ts --outfile myapp
-```
-
-Using bytecode compilation, `tsc` starts 2x faster:
-
-{% image src="https://github.com/user-attachments/assets/dc8913db-01d2-48f8-a8ef-ac4e984f9763" width="689" /%}
-
-Bytecode compilation moves parsing overhead for large input files from runtime to bundle time. Your app starts faster, in exchange for making the `bun build` command a little slower. It doesn't obscure source code.
-
-**Experimental:** Bytecode compilation is an experimental feature introduced in Bun v1.1.30. Only `cjs` format is supported (which means no top-level-await). Let us know if you run into any issues!
-
-### What do these flags do?
-
-The `--minify` argument optimizes the size of the transpiled output code. If you have a large application, this can save megabytes of space. For smaller applications, it might still improve start time a little.
-
-The `--sourcemap` argument embeds a sourcemap compressed with zstd, so that errors & stacktraces point to their original locations instead of the transpiled location. Bun will automatically decompress & resolve the sourcemap when an error occurs.
-
-The `--bytecode` argument enables bytecode compilation. Every time you run JavaScript code in Bun, JavaScriptCore (the engine) will compile your source code into bytecode. We can move this parsing work from runtime to bundle time, saving you startup time.
-
-## Embedding runtime arguments
-
-**`--compile-exec-argv="args"`** - Embed runtime arguments that are available via `process.execArgv`:
-
-```bash
-bun build --compile --compile-exec-argv="--smol --user-agent=MyBot" ./app.ts --outfile myapp
-```
-
-```js
-// In the compiled app
-console.log(process.execArgv); // ["--smol", "--user-agent=MyBot"]
-```
-
-## Act as the Bun CLI
-
-{% note %}
-
-New in Bun v1.2.16
-
-{% /note %}
-
-You can run a standalone executable as if it were the `bun` CLI itself by setting the `BUN_BE_BUN=1` environment variable. When this variable is set, the executable will ignore its bundled entrypoint and instead expose all the features of Bun's CLI.
-
-For example, consider an executable compiled from a simple script:
-
-```sh
-$ cat such-bun.js
-console.log("you shouldn't see this");
-
-$ bun build --compile ./such-bun.js
- [3ms] bundle 1 modules
-[89ms] compile such-bun
-```
-
-Normally, running `./such-bun` with arguments would execute the script. However, with the `BUN_BE_BUN=1` environment variable, it acts just like the `bun` binary:
-
-```sh
-# Executable runs its own entrypoint by default
-$ ./such-bun install
-you shouldn't see this
-
-# With the env var, the executable acts like the `bun` CLI
-$ BUN_BE_BUN=1 ./such-bun install
-bun install v1.2.16-canary.1 (1d1db811)
-Checked 63 installs across 64 packages (no changes) [5.00ms]
-```
-
-This is useful for building CLI tools on top of Bun that may need to install packages, bundle dependencies, run different or local files and more without needing to download a separate binary or install bun.
-
-## Full-stack executables
-
-{% note %}
-
-New in Bun v1.2.17
-
-{% /note %}
-
-Bun's `--compile` flag can create standalone executables that contain both server and client code, making it ideal for full-stack applications. When you import an HTML file in your server code, Bun automatically bundles all frontend assets (JavaScript, CSS, etc.) and embeds them into the executable. When Bun sees the HTML import on the server, it kicks off a frontend build process to bundle JavaScript, CSS, and other assets.
-
-{% codetabs %}
-
-```ts#server.ts
-import { serve } from "bun";
-import index from "./index.html";
-
-const server = serve({
-  routes: {
-    "/": index,
-    "/api/hello": { GET: () => Response.json({ message: "Hello from API" }) },
-  },
-});
-
-console.log(`Server running at http://localhost:${server.port}`);
-```
-
-```html#index.html
-<!DOCTYPE html>
-<html>
-  <head>
-    <title>My App</title>
-    <link rel="stylesheet" href="./styles.css">
-  </head>
-  <body>
-    <h1>Hello World</h1>
-    <script src="./app.js"></script>
-  </body>
-</html>
-```
-
-```js#app.js
-console.log("Hello from the client!");
-```
-
-```css#styles.css
-body {
-  background-color: #f0f0f0;
-}
-```
-
-{% /codetabs %}
-
-To build this into a single executable:
-
-```sh
-bun build --compile ./server.ts --outfile myapp
-```
-
-This creates a self-contained binary that includes:
-
-- Your server code
-- The Bun runtime
-- All frontend assets (HTML, CSS, JavaScript)
-- Any npm packages used by your server
-
-The result is a single file that can be deployed anywhere without needing Node.js, Bun, or any dependencies installed. Just run:
-
-```sh
-./myapp
-```
-
-Bun automatically handles serving the frontend assets with proper MIME types and cache headers. The HTML import is replaced with a manifest object that `Bun.serve` uses to efficiently serve pre-bundled assets.
-
-For more details on building full-stack applications with Bun, see the [full-stack guide](/docs/bundler/fullstack).
-
-## Worker
-
-To use workers in a standalone executable, add the worker's entrypoint to the CLI arguments:
-
-```sh
-$ bun build --compile ./index.ts ./my-worker.ts --outfile myapp
-```
-
-Then, reference the worker in your code:
-
-```ts
-console.log("Hello from Bun!");
-
-// Any of these will work:
-new Worker("./my-worker.ts");
-new Worker(new URL("./my-worker.ts", import.meta.url));
-new Worker(new URL("./my-worker.ts", import.meta.url).href);
-```
-
-As of Bun v1.1.25, when you add multiple entrypoints to a standalone executable, they will be bundled separately into the executable.
-
-In the future, we may automatically detect usages of statically-known paths in `new Worker(path)` and then bundle those into the executable, but for now, you'll need to add it to the shell command manually like the above example.
-
-If you use a relative path to a file not included in the standalone executable, it will attempt to load that path from disk relative to the current working directory of the process (and then error if it doesn't exist).
-
-## SQLite
-
-You can use `bun:sqlite` imports with `bun build --compile`.
-
-By default, the database is resolved relative to the current working directory of the process.
-
-```js
-import db from "./my.db" with { type: "sqlite" };
-
-console.log(db.query("select * from users LIMIT 1").get());
-```
-
-That means if the executable is located at `/usr/bin/hello`, the user's terminal is located at `/home/me/Desktop`, it will look for `/home/me/Desktop/my.db`.
-
-```
-$ cd /home/me/Desktop
-$ ./hello
-```
-
-## Embed assets & files
-
-Standalone executables support embedding files.
-
-To embed files into an executable with `bun build --compile`, import the file in your code.
-
-```ts
-// this becomes an internal file path
-import icon from "./icon.png" with { type: "file" };
-import { file } from "bun";
-
-export default {
-  fetch(req) {
-    // Embedded files can be streamed from Response objects
-    return new Response(file(icon));
-  },
-};
-```
-
-Embedded files can be read using `Bun.file`'s functions or the Node.js `fs.readFile` function (in `"node:fs"`).
-
-For example, to read the contents of the embedded file:
-
-```js
-import icon from "./icon.png" with { type: "file" };
-import { file } from "bun";
-
-const bytes = await file(icon).arrayBuffer();
-// await fs.promises.readFile(icon)
-// fs.readFileSync(icon)
-```
-
-### Embed SQLite databases
-
-If your application wants to embed a SQLite database, set `type: "sqlite"` in the import attribute and the `embed` attribute to `"true"`.
-
-```js
-import myEmbeddedDb from "./my.db" with { type: "sqlite", embed: "true" };
-
-console.log(myEmbeddedDb.query("select * from users LIMIT 1").get());
-```
-
-This database is read-write, but all changes are lost when the executable exits (since it's stored in memory).
-
-### Embed N-API Addons
-
-As of Bun v1.0.23, you can embed `.node` files into executables.
-
-```js
-const addon = require("./addon.node");
-
-console.log(addon.hello());
-```
-
-Unfortunately, if you're using `@mapbox/node-pre-gyp` or other similar tools, you'll need to make sure the `.node` file is directly required or it won't bundle correctly.
-
-### Embed directories
-
-To embed a directory with `bun build --compile`, use a shell glob in your `bun build` command:
-
-```sh
-$ bun build --compile ./index.ts ./public/**/*.png
-```
-
-Then, you can reference the files in your code:
-
-```ts
-import icon from "./public/assets/icon.png" with { type: "file" };
-import { file } from "bun";
-
-export default {
-  fetch(req) {
-    // Embedded files can be streamed from Response objects
-    return new Response(file(icon));
-  },
-};
-```
-
-This is honestly a workaround, and we expect to improve this in the future with a more direct API.
-
-### Listing embedded files
-
-To get a list of all embedded files, use `Bun.embeddedFiles`:
-
-```js
-import "./icon.png" with { type: "file" };
-import { embeddedFiles } from "bun";
-
-console.log(embeddedFiles[0].name); // `icon-${hash}.png`
-```
-
-`Bun.embeddedFiles` returns an array of `Blob` objects which you can use to get the size, contents, and other properties of the files.
-
-```ts
-embeddedFiles: Blob[]
-```
-
-The list of embedded files excludes bundled source code like `.ts` and `.js` files.
-
-#### Content hash
-
-By default, embedded files have a content hash appended to their name. This is useful for situations where you want to serve the file from a URL or CDN and have fewer cache invalidation issues. But sometimes, this is unexpected and you might want the original name instead:
-
-To disable the content hash, pass `--asset-naming` to `bun build --compile` like this:
-
-```sh
-$ bun build --compile --asset-naming="[name].[ext]" ./index.ts
-```
-
-## Minification
-
-To trim down the size of the executable a little, pass `--minify` to `bun build --compile`. This uses Bun's minifier to reduce the code size. Overall though, Bun's binary is still way too big and we need to make it smaller.
-
-## Using Bun.build() API
-
-You can also generate standalone executables using the `Bun.build()` JavaScript API. This is useful when you need programmatic control over the build process.
-
-### Basic usage
-
-```js
-await Bun.build({
-  entrypoints: ["./app.ts"],
-  outdir: "./dist",
-  compile: {
-    target: "bun-windows-x64",
-    outfile: "myapp.exe",
-  },
-});
-```
-
-### Windows metadata with Bun.build()
-
-When targeting Windows, you can specify metadata through the `windows` object:
-
-```js
-await Bun.build({
-  entrypoints: ["./app.ts"],
-  outdir: "./dist",
-  compile: {
-    target: "bun-windows-x64",
-    outfile: "myapp.exe",
-    windows: {
-      title: "My Application",
-      publisher: "My Company Inc",
-      version: "1.2.3.4",
-      description: "A powerful application built with Bun",
-      copyright: "© 2024 My Company Inc",
-      hideConsole: false, // Set to true for GUI applications
-      icon: "./icon.ico", // Path to icon file
-    },
-  },
-});
-```
-
-### Cross-compilation with Bun.build()
-
-You can cross-compile for different platforms:
-
-```js
-// Build for multiple platforms
-const platforms = [
-  { target: "bun-windows-x64", outfile: "app-windows.exe" },
-  { target: "bun-linux-x64", outfile: "app-linux" },
-  { target: "bun-darwin-arm64", outfile: "app-macos" },
-];
-
-for (const platform of platforms) {
-  await Bun.build({
-    entrypoints: ["./app.ts"],
-    outdir: "./dist",
-    compile: platform,
-  });
-}
-```
-
-## Windows-specific flags
-
-When compiling a standalone executable for Windows, there are several platform-specific options that can be used to customize the generated `.exe` file:
-
-### Visual customization
-
-- `--windows-icon=path/to/icon.ico` - Set the executable file icon
-- `--windows-hide-console` - Disable the background terminal window (useful for GUI applications)
-
-### Metadata customization
-
-You can embed version information and other metadata into your Windows executable:
-
-- `--windows-title <STR>` - Set the product name (appears in file properties)
-- `--windows-publisher <STR>` - Set the company name
-- `--windows-version <STR>` - Set the version number (e.g. "1.2.3.4")
-- `--windows-description <STR>` - Set the file description
-- `--windows-copyright <STR>` - Set the copyright information
-
-#### Example with all metadata flags:
-
-```sh
-bun build --compile ./app.ts \
-  --outfile myapp.exe \
-  --windows-title "My Application" \
-  --windows-publisher "My Company Inc" \
-  --windows-version "1.2.3.4" \
-  --windows-description "A powerful application built with Bun" \
-  --windows-copyright "© 2024 My Company Inc"
-```
-
-This metadata will be visible in Windows Explorer when viewing the file properties:
-
-1. Right-click the executable in Windows Explorer
-2. Select "Properties"
-3. Go to the "Details" tab
-
-#### Version string format
-
-The `--windows-version` flag accepts version strings in the following formats:
-
-- `"1"` - Will be normalized to "1.0.0.0"
-- `"1.2"` - Will be normalized to "1.2.0.0"
-- `"1.2.3"` - Will be normalized to "1.2.3.0"
-- `"1.2.3.4"` - Full version format
-
-Each version component must be a number between 0 and 65535.
-
-{% callout %}
-
-These flags currently cannot be used when cross-compiling because they depend on Windows APIs. They are only available when building on Windows itself.
-
-{% /callout %}
-
-## Code signing on macOS
-
-To codesign a standalone executable on macOS (which fixes Gatekeeper warnings), use the `codesign` command.
-
-```sh
-$ codesign --deep --force -vvvv --sign "XXXXXXXXXX" ./myapp
-```
-
-We recommend including an `entitlements.plist` file with JIT permissions.
-
-```xml#entitlements.plist
-<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-<plist version="1.0">
-<dict>
-    <key>com.apple.security.cs.allow-jit</key>
-    <true/>
-    <key>com.apple.security.cs.allow-unsigned-executable-memory</key>
-    <true/>
-    <key>com.apple.security.cs.disable-executable-page-protection</key>
-    <true/>
-    <key>com.apple.security.cs.allow-dyld-environment-variables</key>
-    <true/>
-    <key>com.apple.security.cs.disable-library-validation</key>
-    <true/>
-</dict>
-</plist>
-```
-
-To codesign with JIT support, pass the `--entitlements` flag to `codesign`.
-
-```sh
-$ codesign --deep --force -vvvv --sign "XXXXXXXXXX" --entitlements entitlements.plist ./myapp
-```
-
-After codesigning, verify the executable:
-
-```sh
-$ codesign -vvv --verify ./myapp
-./myapp: valid on disk
-./myapp: satisfies its Designated Requirement
-```
-
-{% callout %}
-
-Codesign support requires Bun v1.2.4 or newer.
-
-{% /callout %}
-
-## Code splitting
-
-Standalone executables support code splitting. Use `--compile` with `--splitting` to create an executable that loads code-split chunks at runtime.
-
-```bash
-$ bun build --compile --splitting ./src/entry.ts --outdir ./build
-```
-
-{% codetabs %}
-
-```ts#src/entry.ts
-console.log("Entrypoint loaded");
-const lazy = await import("./lazy.ts");
-lazy.hello();
-```
-
-```ts#src/lazy.ts
-export function hello() {
-  console.log("Lazy module loaded");
-}
-```
-
-{% /codetabs %}
-
-```bash
-$ ./build/entry
-Entrypoint loaded
-Lazy module loaded
-```
-
-## Unsupported CLI arguments
-
-Currently, the `--compile` flag can only accept a single entrypoint at a time and does not support the following flags:
-
-- `--outdir` — use `outfile` instead (except when using with `--splitting`).
-- `--public-path`
-- `--target=node` or `--target=browser`
-- `--no-bundle` - we always bundle everything into the executable.

docs/bundler/fullstack.md

@@ -1,418 +0,0 @@
-To get started, import HTML files and pass them to the `routes` option in `Bun.serve()`.
-
-```ts
-import { sql, serve } from "bun";
-import dashboard from "./dashboard.html";
-import homepage from "./index.html";
-
-const server = serve({
-  routes: {
-    // ** HTML imports **
-    // Bundle & route index.html to "/". This uses HTMLRewriter to scan the HTML for `<script>` and `<link>` tags, run's Bun's JavaScript & CSS bundler on them, transpiles any TypeScript, JSX, and TSX, downlevels CSS with Bun's CSS parser and serves the result.
-    "/": homepage,
-    // Bundle & route dashboard.html to "/dashboard"
-    "/dashboard": dashboard,
-
-    // ** API endpoints ** (Bun v1.2.3+ required)
-    "/api/users": {
-      async GET(req) {
-        const users = await sql`SELECT * FROM users`;
-        return Response.json(users);
-      },
-      async POST(req) {
-        const { name, email } = await req.json();
-        const [user] =
-          await sql`INSERT INTO users (name, email) VALUES (${name}, ${email})`;
-        return Response.json(user);
-      },
-    },
-    "/api/users/:id": async req => {
-      const { id } = req.params;
-      const [user] = await sql`SELECT * FROM users WHERE id = ${id}`;
-      return Response.json(user);
-    },
-  },
-
-  // Enable development mode for:
-  // - Detailed error messages
-  // - Hot reloading (Bun v1.2.3+ required)
-  development: true,
-
-  // Prior to v1.2.3, the `fetch` option was used to handle all API requests. It is now optional.
-  // async fetch(req) {
-  //   // Return 404 for unmatched routes
-  //   return new Response("Not Found", { status: 404 });
-  // },
-});
-
-console.log(`Listening on ${server.url}`);
-```
-
-```bash
-$ bun run app.ts
-```
-
-## HTML imports are routes
-
-The web starts with HTML, and so does Bun's fullstack dev server.
-
-To specify entrypoints to your frontend, import HTML files into your JavaScript/TypeScript/TSX/JSX files.
-
-```ts
-import dashboard from "./dashboard.html";
-import homepage from "./index.html";
-```
-
-These HTML files are used as routes in Bun's dev server you can pass to `Bun.serve()`.
-
-```ts
-Bun.serve({
-  routes: {
-    "/": homepage,
-    "/dashboard": dashboard,
-  }
-
-  fetch(req) {
-    // ... api requests
-  },
-});
-```
-
-When you make a request to `/dashboard` or `/`, Bun automatically bundles the `<script>` and `<link>` tags in the HTML files, exposes them as static routes, and serves the result.
-
-An index.html file like this:
-
-```html#index.html
-<!DOCTYPE html>
-<html>
-  <head>
-    <title>Home</title>
-    <link rel="stylesheet" href="./reset.css" />
-    <link rel="stylesheet" href="./styles.css" />
-  </head>
-  <body>
-    <div id="root"></div>
-    <script type="module" src="./sentry-and-preloads.ts"></script>
-    <script type="module" src="./my-app.tsx"></script>
-  </body>
-</html>
-```
-
-Becomes something like this:
-
-```html#index.html
-<!DOCTYPE html>
-<html>
-  <head>
-    <title>Home</title>
-    <link rel="stylesheet" href="/index-[hash].css" />
-  </head>
-  <body>
-    <div id="root"></div>
-    <script type="module" src="/index-[hash].js"></script>
-  </body>
-</html>
-```
-
-### How to use with React
-
-To use React in your client-side code, import `react-dom/client` and render your app.
-
-{% codetabs %}
-
-```ts#src/backend.ts
-import dashboard from "../public/dashboard.html";
-import { serve } from "bun";
-
-serve({
-  routes: {
-    "/": dashboard,
-  },
-
-  async fetch(req) {
-    // ...api requests
-    return new Response("hello world");
-  },
-});
-```
-
-```ts#src/frontend.tsx
-import "./styles.css";
-import { createRoot } from "react-dom/client";
-import { App } from "./app.tsx";
-
-document.addEventListener("DOMContentLoaded", () => {
-  const root = createRoot(document.getElementById("root"));
-  root.render(<App />);
-});
-```
-
-```html#public/dashboard.html
-<!DOCTYPE html>
-<html>
-  <head>
-    <title>Dashboard</title>
-  </head>
-  <body>
-    <div id="root"></div>
-    <script type="module" src="../src/frontend.tsx"></script>
-  </body>
-</html>
-```
-
-```css#src/styles.css
-body {
-  background-color: red;
-}
-```
-
-```tsx#src/app.tsx
-export function App() {
-  return <div>Hello World</div>;
-}
-```
-
-{% /codetabs %}
-
-### Development mode
-
-When building locally, enable development mode by setting `development: true` in `Bun.serve()`.
-
-```js-diff
-import homepage from "./index.html";
-import dashboard from "./dashboard.html";
-
-Bun.serve({
-  routes: {
-    "/": homepage,
-    "/dashboard": dashboard,
-  }
-
-+ development: true,
-
-  fetch(req) {
-    // ... api requests
-  },
-});
-```
-
-When `development` is `true`, Bun will:
-
-- Include the `SourceMap` header in the response so that devtools can show the original source code
-- Disable minification
-- Re-bundle assets on each request to a .html file
-- Enable hot module reloading (unless `hmr: false` is set)
-
-#### Echo console logs from browser to terminal
-
-Bun.serve() supports echoing console logs from the browser to the terminal.
-
-To enable this, pass `console: true` in the `development` object in `Bun.serve()`.
-
-```ts
-import homepage from "./index.html";
-
-Bun.serve({
-  // development can also be an object.
-  development: {
-    // Enable Hot Module Reloading
-    hmr: true,
-
-    // Echo console logs from the browser to the terminal
-    console: true,
-  },
-
-  routes: {
-    "/": homepage,
-  },
-});
-```
-
-When `console: true` is set, Bun will stream console logs from the browser to the terminal. This reuses the existing WebSocket connection from HMR to send the logs.
-
-#### Production mode
-
-Hot reloading and `development: true` helps you iterate quickly, but in production, your server should be as fast as possible and have as few external dependencies as possible.
-
-##### Ahead of time bundling (recommended)
-
-As of Bun v1.2.17, you can use `Bun.build` or `bun build` to bundle your full-stack application ahead of time.
-
-```sh
-$ bun build --target=bun --production --outdir=dist ./src/index.ts
-```
-
-When Bun's bundler sees an HTML import from server-side code, it will bundle the referenced JavaScript/TypeScript/TSX/JSX and CSS files into a manifest object that Bun.serve() can use to serve the assets.
-
-```ts
-import { serve } from "bun";
-import index from "./index.html";
-
-serve({
-  routes: { "/": index },
-});
-```
-
-{% details summary="Internally, the `index` variable is a manifest object that looks something like this" %}
-
-```json
-{
-  "index": "./index.html",
-  "files": [
-    {
-      "input": "index.html",
-      "path": "./index-f2me3qnf.js",
-      "loader": "js",
-      "isEntry": true,
-      "headers": {
-        "etag": "eet6gn75",
-        "content-type": "text/javascript;charset=utf-8"
-      }
-    },
-    {
-      "input": "index.html",
-      "path": "./index.html",
-      "loader": "html",
-      "isEntry": true,
-      "headers": {
-        "etag": "r9njjakd",
-        "content-type": "text/html;charset=utf-8"
-      }
-    },
-    {
-      "input": "index.html",
-      "path": "./index-gysa5fmk.css",
-      "loader": "css",
-      "isEntry": true,
-      "headers": {
-        "etag": "50zb7x61",
-        "content-type": "text/css;charset=utf-8"
-      }
-    },
-    {
-      "input": "logo.svg",
-      "path": "./logo-kygw735p.svg",
-      "loader": "file",
-      "isEntry": false,
-      "headers": {
-        "etag": "kygw735p",
-        "content-type": "application/octet-stream"
-      }
-    },
-    {
-      "input": "react.svg",
-      "path": "./react-ck11dneg.svg",
-      "loader": "file",
-      "isEntry": false,
-      "headers": {
-        "etag": "ck11dneg",
-        "content-type": "application/octet-stream"
-      }
-    }
-  ]
-}
-```
-
-{% /details %}
-
-##### Runtime bundling
-
-When adding a build step is too complicated, you can set `development: false` in `Bun.serve()`.
-
-- Enable in-memory caching of bundled assets. Bun will bundle assets lazily on the first request to an `.html` file, and cache the result in memory until the server restarts.
-- Enables `Cache-Control` headers and `ETag` headers
-- Minifies JavaScript/TypeScript/TSX/JSX files
-
-## Plugins
-
-Bun's [bundler plugins](https://bun.com/docs/bundler/plugins) are also supported when bundling static routes.
-
-To configure plugins for `Bun.serve`, add a `plugins` array in the `[serve.static]` section of your `bunfig.toml`.
-
-### Using TailwindCSS in HTML routes
-
-For example, enable TailwindCSS on your routes by installing and adding the `bun-plugin-tailwind` plugin:
-
-```sh
-$ bun add bun-plugin-tailwind
-```
-
-```toml#bunfig.toml
-[serve.static]
-plugins = ["bun-plugin-tailwind"]
-```
-
-This will allow you to use TailwindCSS utility classes in your HTML and CSS files. All you need to do is import `tailwindcss` somewhere:
-
-```html#index.html
-<!doctype html>
-<html>
-  <head>
-    <title>Home</title>
-    <link rel="stylesheet" href="tailwindcss" />
-  </head>
-  <body>
-    <!-- the rest of your HTML... -->
-  </body>
-</html>
-```
-
-Or in your CSS:
-
-```css#style.css
-@import "tailwindcss";
-```
-
-### Custom plugins
-
-Any JS file or module which exports a [valid bundler plugin object](https://bun.com/docs/bundler/plugins#usage) (essentially an object with a `name` and `setup` field) can be placed inside the `plugins` array:
-
-```toml#bunfig.toml
-[serve.static]
-plugins = ["./my-plugin-implementation.ts"]
-```
-
-Bun will lazily resolve and load each plugin and use them to bundle your routes.
-
-Note: this is currently in `bunfig.toml` to make it possible to know statically which plugins are in use when we eventually integrate this with the `bun build` CLI. These plugins work in `Bun.build()`'s JS API, but are not yet supported in the CLI.
-
-## How this works
-
-Bun uses [`HTMLRewriter`](/docs/api/html-rewriter) to scan for `<script>` and `<link>` tags in HTML files, uses them as entrypoints for [Bun's bundler](/docs/bundler), generates an optimized bundle for the JavaScript/TypeScript/TSX/JSX and CSS files, and serves the result.
-
-1. **`<script>` processing**
-   - Transpiles TypeScript, JSX, and TSX in `<script>` tags
-   - Bundles imported dependencies
-   - Generates sourcemaps for debugging
-   - Minifies when `development` is not `true` in `Bun.serve()`
-
-   ```html
-   <script type="module" src="./counter.tsx"></script>
-   ```
-
-2. **`<link>` processing**
-   - Processes CSS imports and `<link>` tags
-   - Concatenates CSS files
-   - Rewrites `url` and asset paths to include content-addressable hashes in URLs
-
-   ```html
-   <link rel="stylesheet" href="./styles.css" />
-   ```
-
-3. **`<img>` & asset processing**
-   - Links to assets are rewritten to include content-addressable hashes in URLs
-   - Small assets in CSS files are inlined into `data:` URLs, reducing the total number of HTTP requests sent over the wire
-
-4. **Rewrite HTML**
-   - Combines all `<script>` tags into a single `<script>` tag with a content-addressable hash in the URL
-   - Combines all `<link>` tags into a single `<link>` tag with a content-addressable hash in the URL
-   - Outputs a new HTML file
-
-5. **Serve**
-   - All the output files from the bundler are exposed as static routes, using the same mechanism internally as when you pass a `Response` object to [`static` in `Bun.serve()`](/docs/api/http#static-routes).
-
-This works similarly to how [`Bun.build` processes HTML files](/docs/bundler/html).
-
-## This is a work in progress
-
-- This doesn't support `bun build` yet. It also will in the future.

docs/bundler/hmr.md

@@ -1,234 +0,0 @@
-Hot Module Replacement (HMR) allows you to update modules in a running
-application without needing a full page reload. This preserves the application
-state and improves the development experience.
-
-HMR is enabled by default when using Bun's full-stack development server.
-
-## `import.meta.hot` API Reference
-
-Bun implements a client-side HMR API modeled after [Vite's `import.meta.hot` API](https://vitejs.dev/guide/api-hmr.html). It can be checked for with `if (import.meta.hot)`, tree-shaking it in production
-
-```ts
-if (import.meta.hot) {
-  // HMR APIs are available.
-}
-```
-
-However, **this check is often not needed** as Bun will dead-code-eliminate
-calls to all of the HMR APIs in production builds.
-
-```ts
-// This entire function call will be removed in production!
-import.meta.hot.dispose(() => {
-  console.log("dispose");
-});
-```
-
-For this to work, Bun forces these APIs to be called without indirection. That means the following do not work:
-
-```ts#invalid-hmr-usage.ts
-// INVALID: Assigning `hot` to a variable
-const hot = import.meta.hot;
-hot.accept();
-
-// INVALID: Assigning `import.meta` to a variable
-const meta = import.meta;
-meta.hot.accept();
-console.log(meta.hot.data);
-
-// INVALID: Passing to a function
-doSomething(import.meta.hot.dispose);
-
-// OK: The full phrase "import.meta.hot.<API>" must be called directly:
-import.meta.hot.accept();
-
-// OK: `data` can be passed to functions:
-doSomething(import.meta.hot.data);
-```
-
-{% callout %}
-
-**Note** — The HMR API is still a work in progress. Some features are missing. HMR can be disabled in `Bun.serve` by setting the `development` option to `{ hmr: false }`.
-
-{% endcallout %}
-
-|     | Method             | Notes                                                                 |
-| --- | ------------------ | --------------------------------------------------------------------- |
-| ✅  | `hot.accept()`     | Indicate that a hot update can be replaced gracefully.                |
-| ✅  | `hot.data`         | Persist data between module evaluations.                              |
-| ✅  | `hot.dispose()`    | Add a callback function to run when a module is about to be replaced. |
-| ❌  | `hot.invalidate()` |                                                                       |
-| ✅  | `hot.on()`         | Attach an event listener                                              |
-| ✅  | `hot.off()`        | Remove an event listener from `on`.                                   |
-| ❌  | `hot.send()`       |                                                                       |
-| 🚧  | `hot.prune()`      | **NOTE**: Callback is currently never called.                         |
-| ✅  | `hot.decline()`    | No-op to match Vite's `import.meta.hot`                               |
-
-### `import.meta.hot.accept()`
-
-The `accept()` method indicates that a module can be hot-replaced. When called
-without arguments, it indicates that this module can be replaced simply by
-re-evaluating the file. After a hot update, importers of this module will be
-automatically patched.
-
-```ts#index.ts
-import { getCount } from "./foo.ts";
-
-console.log("count is ", getCount());
-
-import.meta.hot.accept();
-
-export function getNegativeCount() {
-  return -getCount();
-}
-```
-
-This creates a hot-reloading boundary for all of the files that `index.ts`
-imports. That means whenever `foo.ts` or any of its dependencies are saved, the
-update will bubble up to `index.ts` will re-evaluate. Files that import
-`index.ts` will then be patched to import the new version of
-`getNegativeCount()`. If only `index.ts` is updated, only the one file will be
-re-evaluated, and the counter in `foo.ts` is reused.
-
-This may be used in combination with `import.meta.hot.data` to transfer state
-from the previous module to the new one.
-
-When no modules call `import.meta.hot.accept()` (and there isn't React Fast
-Refresh or a plugin calling it for you), the page will reload when the file
-updates, and a console warning shows which files were invalidated. This warning
-is safe to ignore if it makes more sense to rely on full page reloads.
-
-#### With callback
-
-When provided one callback, `import.meta.hot.accept` will function how it does
-in Vite. Instead of patching the importers of this module, it will call the
-callback with the new module.
-
-```ts
-export const count = 0;
-
-import.meta.hot.accept(newModule => {
-  if (newModule) {
-    // newModule is undefined when SyntaxError happened
-    console.log("updated: count is now ", newModule.count);
-  }
-});
-```
-
-Prefer using `import.meta.hot.accept()` without an argument as it usually makes your code easier to understand.
-
-#### Accepting other modules
-
-```ts
-import { count } from "./foo";
-
-import.meta.hot.accept("./foo", () => {
-  if (!newModule) return;
-
-  console.log("updated: count is now ", count);
-});
-```
-
-Indicates that a dependency's module can be accepted. When the dependency is updated, the callback will be called with the new module.
-
-#### With multiple dependencies
-
-```ts
-import.meta.hot.accept(["./foo", "./bar"], newModules => {
-  // newModules is an array where each item corresponds to the updated module
-  // or undefined if that module had a syntax error
-});
-```
-
-Indicates that multiple dependencies' modules can be accepted. This variant accepts an array of dependencies, where the callback will receive the updated modules, and `undefined` for any that had errors.
-
-### `import.meta.hot.data`
-
-`import.meta.hot.data` maintains state between module instances during hot
-replacement, enabling data transfer from previous to new versions. When
-`import.meta.hot.data` is written into, Bun will also mark this module as
-capable of self-accepting (equivalent of calling `import.meta.hot.accept()`).
-
-```ts
-import { createRoot } from "react-dom/client";
-import { App } from "./app";
-
-const root = import.meta.hot.data.root ??= createRoot(elem);
-root.render(<App />); // re-use an existing root
-```
-
-In production, `data` is inlined to be `{}`, meaning it cannot be used as a state holder.
-
-The above pattern is recommended for stateful modules because Bun knows it can minify `{}.prop ??= value` into `value` in production.
-
-### `import.meta.hot.dispose()`
-
-Attaches an on-dispose callback. This is called:
-
-- Just before the module is replaced with another copy (before the next is loaded)
-- After the module is detached (removing all imports to this module, see `import.meta.hot.prune()`)
-
-```ts
-const sideEffect = setupSideEffect();
-
-import.meta.hot.dispose(() => {
-  sideEffect.cleanup();
-});
-```
-
-This callback is not called on route navigation or when the browser tab closes.
-
-Returning a promise will delay module replacement until the module is disposed.
-All dispose callbacks are called in parallel.
-
-### `import.meta.hot.prune()`
-
-Attaches an on-prune callback. This is called when all imports to this module
-are removed, but the module was previously loaded.
-
-This can be used to clean up resources that were created when the module was
-loaded. Unlike `import.meta.hot.dispose()`, this pairs much better with `accept`
-and `data` to manage stateful resources. A full example managing a `WebSocket`:
-
-```ts
-import { something } from "./something";
-
-// Initialize or re-use a WebSocket connection
-export const ws = (import.meta.hot.data.ws ??= new WebSocket(location.origin));
-
-// If the module's import is removed, clean up the WebSocket connection.
-import.meta.hot.prune(() => {
-  ws.close();
-});
-```
-
-If `dispose` was used instead, the WebSocket would close and re-open on every
-hot update. Both versions of the code will prevent page reloads when imported
-files are updated.
-
-### `import.meta.hot.on()` and `off()`
-
-`on()` and `off()` are used to listen for events from the HMR runtime. Event names are prefixed with a prefix so that plugins do not conflict with each other.
-
-```ts
-import.meta.hot.on("bun:beforeUpdate", () => {
-  console.log("before a hot update");
-});
-```
-
-When a file is replaced, all of its event listeners are automatically removed.
-
-A list of all built-in events:
-
-| Event                  | Emitted when                                                                                    |
-| ---------------------- | ----------------------------------------------------------------------------------------------- |
-| `bun:beforeUpdate`     | before a hot update is applied.                                                                 |
-| `bun:afterUpdate`      | after a hot update is applied.                                                                  |
-| `bun:beforeFullReload` | before a full page reload happens.                                                              |
-| `bun:beforePrune`      | before prune callbacks are called.                                                              |
-| `bun:invalidate`       | when a module is invalidated with `import.meta.hot.invalidate()`                                |
-| `bun:error`            | when a build or runtime error occurs                                                            |
-| `bun:ws:disconnect`    | when the HMR WebSocket connection is lost. This can indicate the development server is offline. |
-| `bun:ws:connect`       | when the HMR WebSocket connects or re-connects.                                                 |
-
-For compatibility with Vite, the above events are also available via `vite:*` prefix instead of `bun:*`.

docs/bundler/hot-reloading.mdx

@@ -0,0 +1,229 @@
+---
+title: Hot reloading
+description: Hot Module Replacement (HMR) for Bun's development server
+---
+
+Hot Module Replacement (HMR) allows you to update modules in a running application without needing a full page reload. This preserves the application state and improves the development experience.
+
+<Note>HMR is enabled by default when using Bun's full-stack development server.</Note>
+
+## `import.meta.hot` API Reference
+
+Bun implements a client-side HMR API modeled after [Vite's `import.meta.hot` API](https://vite.dev/guide/api-hmr). It can be checked for with `if (import.meta.hot)`, tree-shaking it in production.
+
+```ts title="index.ts" icon="/icons/typescript.svg"
+if (import.meta.hot) {
+  // HMR APIs are available.
+}
+```
+
+However, this check is often not needed as Bun will dead-code-eliminate calls to all of the HMR APIs in production builds.
+
+```ts title="index.ts" icon="/icons/typescript.svg"
+// This entire function call will be removed in production!
+import.meta.hot.dispose(() => {
+  console.log("dispose");
+});
+```
+
+<Warning>
+For this to work, Bun forces these APIs to be called without indirection. That means the following do not work:
+
+```ts title="index.ts" icon="/icons/typescript.svg"
+// INVALID: Assigning `hot` to a variable
+const hot = import.meta.hot;
+hot.accept();
+
+// INVALID: Assigning `import.meta` to a variable
+const meta = import.meta;
+meta.hot.accept();
+console.log(meta.hot.data);
+
+// INVALID: Passing to a function
+doSomething(import.meta.hot.dispose);
+
+// OK: The full phrase "import.meta.hot.<API>" must be called directly:
+import.meta.hot.accept();
+
+// OK: `data` can be passed to functions:
+doSomething(import.meta.hot.data);
+```
+
+</Warning>
+
+<Note>
+The HMR API is still a work in progress. Some features are missing. HMR can be disabled in `Bun.serve` by setting the development option to `{ hmr: false }`.
+</Note>
+
+## API Methods
+
+| Method             | Status | Notes                                                                 |
+| ------------------ | ------ | --------------------------------------------------------------------- |
+| `hot.accept()`     | ✅     | Indicate that a hot update can be replaced gracefully.                |
+| `hot.data`         | ✅     | Persist data between module evaluations.                              |
+| `hot.dispose()`    | ✅     | Add a callback function to run when a module is about to be replaced. |
+| `hot.invalidate()` | ❌     |                                                                       |
+| `hot.on()`         | ✅     | Attach an event listener                                              |
+| `hot.off()`        | ✅     | Remove an event listener from `on`.                                   |
+| `hot.send()`       | ❌     |                                                                       |
+| `hot.prune()`      | 🚧     | NOTE: Callback is currently never called.                             |
+| `hot.decline()`    | ✅     | No-op to match Vite's `import.meta.hot`                               |
+
+## import.meta.hot.accept()
+
+The `accept()` method indicates that a module can be hot-replaced. When called without arguments, it indicates that this module can be replaced simply by re-evaluating the file. After a hot update, importers of this module will be automatically patched.
+
+```ts title="index.ts" icon="/icons/typescript.svg"
+// index.ts
+import { getCount } from "./foo.ts";
+
+console.log("count is ", getCount());
+
+import.meta.hot.accept();
+
+export function getNegativeCount() {
+  return -getCount();
+}
+```
+
+This creates a hot-reloading boundary for all of the files that `index.ts` imports. That means whenever `foo.ts` or any of its dependencies are saved, the update will bubble up to `index.ts` will re-evaluate. Files that import `index.ts` will then be patched to import the new version of `getNegativeCount()`. If only `index.ts` is updated, only the one file will be re-evaluated, and the counter in `foo.ts` is reused.
+
+This may be used in combination with `import.meta.hot.data` to transfer state from the previous module to the new one.
+
+<Info>
+  When no modules call `import.meta.hot.accept()` (and there isn't React Fast Refresh or a plugin calling it for you),
+  the page will reload when the file updates, and a console warning shows which files were invalidated. This warning is
+  safe to ignore if it makes more sense to rely on full page reloads.
+</Info>
+
+### With callback
+
+When provided one callback, `import.meta.hot.accept` will function how it does in Vite. Instead of patching the importers of this module, it will call the callback with the new module.
+
+```ts title="index.ts" icon="/icons/typescript.svg"
+export const count = 0;
+
+import.meta.hot.accept(newModule => {
+  if (newModule) {
+    // newModule is undefined when SyntaxError happened
+    console.log("updated: count is now ", newModule.count);
+  }
+});
+```
+
+<Tip>
+  Prefer using `import.meta.hot.accept()` without an argument as it usually makes your code easier to understand.
+</Tip>
+
+### Accepting other modules
+
+```ts title="index.ts" icon="/icons/typescript.svg"
+import { count } from "./foo";
+
+import.meta.hot.accept("./foo", () => {
+  if (!newModule) return;
+
+  console.log("updated: count is now ", count);
+});
+```
+
+Indicates that a dependency's module can be accepted. When the dependency is updated, the callback will be called with the new module.
+
+### With multiple dependencies
+
+```ts title="index.ts" icon="/icons/typescript.svg"
+import.meta.hot.accept(["./foo", "./bar"], newModules => {
+  // newModules is an array where each item corresponds to the updated module
+  // or undefined if that module had a syntax error
+});
+```
+
+Indicates that multiple dependencies' modules can be accepted. This variant accepts an array of dependencies, where the callback will receive the updated modules, and `undefined` for any that had errors.
+
+## import.meta.hot.data
+
+`import.meta.hot.data` maintains state between module instances during hot replacement, enabling data transfer from previous to new versions. When `import.meta.hot.data` is written into, Bun will also mark this module as capable of self-accepting (equivalent of calling `import.meta.hot.accept()`).
+
+```tsx title="index.tsx" icon="/icons/typescript.svg"
+import { createRoot } from "react-dom/client";
+import { App } from "./app";
+
+const root = (import.meta.hot.data.root ??= createRoot(elem));
+root.render(<App />); // re-use an existing root
+```
+
+In production, `data` is inlined to be `{}`, meaning it cannot be used as a state holder.
+
+<Tip>
+  The above pattern is recommended for stateful modules because Bun knows it can minify `{}.prop ??= value` into `value`
+  in production.
+</Tip>
+
+## import.meta.hot.dispose()
+
+Attaches an on-dispose callback. This is called:
+
+- Just before the module is replaced with another copy (before the next is loaded)
+- After the module is detached (removing all imports to this module, see `import.meta.hot.prune()`)
+
+```ts title="index.ts" icon="/icons/typescript.svg"
+const sideEffect = setupSideEffect();
+
+import.meta.hot.dispose(() => {
+  sideEffect.cleanup();
+});
+```
+
+<Warning>This callback is not called on route navigation or when the browser tab closes.</Warning>
+
+Returning a promise will delay module replacement until the module is disposed. All dispose callbacks are called in parallel.
+
+## import.meta.hot.prune()
+
+Attaches an on-prune callback. This is called when all imports to this module are removed, but the module was previously loaded.
+
+This can be used to clean up resources that were created when the module was loaded. Unlike `import.meta.hot.dispose()`, this pairs much better with `accept` and `data` to manage stateful resources. A full example managing a WebSocket:
+
+```ts title="index.ts" icon="/icons/typescript.svg"
+import { something } from "./something";
+
+// Initialize or re-use a WebSocket connection
+export const ws = (import.meta.hot.data.ws ??= new WebSocket(location.origin));
+
+// If the module's import is removed, clean up the WebSocket connection.
+import.meta.hot.prune(() => {
+  ws.close();
+});
+```
+
+<Info>
+  If `dispose` was used instead, the WebSocket would close and re-open on every hot update. Both versions of the code
+  will prevent page reloads when imported files are updated.
+</Info>
+
+## import.meta.hot.on() and off()
+
+`on()` and `off()` are used to listen for events from the HMR runtime. Event names are prefixed with a prefix so that plugins do not conflict with each other.
+
+```ts title="index.ts" icon="/icons/typescript.svg"
+import.meta.hot.on("bun:beforeUpdate", () => {
+  console.log("before a hot update");
+});
+```
+
+When a file is replaced, all of its event listeners are automatically removed.
+
+### Built-in events
+
+| Event                  | Emitted when                                                                                    |
+| ---------------------- | ----------------------------------------------------------------------------------------------- |
+| `bun:beforeUpdate`     | before a hot update is applied.                                                                 |
+| `bun:afterUpdate`      | after a hot update is applied.                                                                  |
+| `bun:beforeFullReload` | before a full page reload happens.                                                              |
+| `bun:beforePrune`      | before prune callbacks are called.                                                              |
+| `bun:invalidate`       | when a module is invalidated with `import.meta.hot.invalidate()`                                |
+| `bun:error`            | when a build or runtime error occurs                                                            |
+| `bun:ws:disconnect`    | when the HMR WebSocket connection is lost. This can indicate the development server is offline. |
+| `bun:ws:connect`       | when the HMR WebSocket connects or re-connects.                                                 |
+
+<Note>For compatibility with Vite, the above events are also available via `vite:*` prefix instead of `bun:*`.</Note>

docs/bundler/html-static.mdx

@@ -0,0 +1,488 @@
+---
+title: HTML & static sites
+description: Build static sites, landing pages, and web applications with Bun's bundler
+---
+
+Bun's bundler has first-class support for HTML. Build static sites, landing pages, and web applications with zero configuration. Just point Bun at your HTML file and it handles everything else.
+
+```html title="index.html" icon="file-code"
+<!doctype html>
+<html>
+  <head>
+    <link rel="stylesheet" href="./styles.css" />
+    <script src="./app.ts" type="module"></script>
+  </head>
+  <body>
+    <img src="./logo.png" />
+  </body>
+</html>
+```
+
+To get started, pass HTML files to `bun`.
+
+```bash terminal icon="terminal"
+bun ./index.html
+```
+
+```
+Bun v1.3.3
+ready in 6.62ms
+→ http://localhost:3000/
+Press h + Enter to show shortcuts
+```
+
+Bun's development server provides powerful features with zero configuration:
+
+- **Automatic Bundling** - Bundles and serves your HTML, JavaScript, and CSS
+- **Multi-Entry Support** - Handles multiple HTML entry points and glob entry points
+- **Modern JavaScript** - TypeScript & JSX support out of the box
+- **Smart Configuration** - Reads `tsconfig.json` for paths, JSX options, experimental decorators, and more
+- **Plugins** - Plugins for TailwindCSS and more
+- **ESM & CommonJS** - Use ESM and CommonJS in your JavaScript, TypeScript, and JSX files
+- **CSS Bundling & Minification** - Bundles CSS from `<link>` tags and `@import` statements
+- **Asset Management** - Automatic copying & hashing of images and assets; Rewrites asset paths in JavaScript, CSS, and HTML
+
+## Single Page Apps (SPA)
+
+When you pass a single `.html` file to Bun, Bun will use it as a fallback route for all paths. This makes it perfect for single page apps that use client-side routing:
+
+```bash terminal icon="terminal"
+bun index.html
+```
+
+```
+Bun v1.3.3
+ready in 6.62ms
+→ http://localhost:3000/
+Press h + Enter to show shortcuts
+```
+
+Your React or other SPA will work out of the box — no configuration needed. All routes like `/about`, `/users/123`, etc. will serve the same HTML file, letting your client-side router handle the navigation.
+
+```html title="index.html" icon="file-code"
+<!doctype html>
+<html>
+  <head>
+    <title>My SPA</title>
+    <script src="./app.tsx" type="module"></script>
+  </head>
+  <body>
+    <div id="root"></div>
+  </body>
+</html>
+```
+
+## Multi-page apps (MPA)
+
+Some projects have several separate routes or HTML files as entry points. To support multiple entry points, pass them all to `bun`:
+
+```bash terminal icon="terminal"
+bun ./index.html ./about.html
+```
+
+```txt
+Bun v1.3.3
+ready in 6.62ms
+→ http://localhost:3000/
+Routes:
+  / ./index.html
+  /about ./about.html
+Press h + Enter to show shortcuts
+```
+
+This will serve:
+
+- `index.html` at `/`
+- `about.html` at `/about`
+
+### Glob patterns
+
+To specify multiple files, you can use glob patterns that end in `.html`:
+
+```bash terminal icon="terminal"
+bun ./**/*.html
+```
+
+```
+Bun v1.3.3
+ready in 6.62ms
+→ http://localhost:3000/
+Routes:
+  / ./index.html
+  /about ./about.html
+Press h + Enter to show shortcuts
+```
+
+### Path normalization
+
+The base path is chosen from the longest common prefix among all the files.
+
+```bash terminal icon="terminal"
+bun ./index.html ./about/index.html ./about/foo/index.html
+```
+
+```
+Bun v1.3.3
+ready in 6.62ms
+→ http://localhost:3000/
+Routes:
+  / ./index.html
+  /about ./about/index.html
+  /about/foo ./about/foo/index.html
+Press h + Enter to show shortcuts
+```
+
+## JavaScript, TypeScript, and JSX
+
+Bun's transpiler natively implements JavaScript, TypeScript, and JSX support. Learn more about loaders in Bun.
+
+<Note>Bun's transpiler is also used at runtime.</Note>
+
+### ES Modules & CommonJS
+
+You can use ESM and CJS in your JavaScript, TypeScript, and JSX files. Bun will handle the transpilation and bundling automatically.
+
+There is no pre-build or separate optimization step. It's all done at the same time.
+
+Learn more about module resolution in Bun.
+
+## CSS
+
+Bun's CSS parser is also natively implemented (clocking in around 58,000 lines of Zig).
+
+It's also a CSS bundler. You can use `@import` in your CSS files to import other CSS files.
+
+For example:
+
+<CodeGroup>
+
+```css styles.css icon="file-code"
+@import "./abc.css";
+
+.container {
+  background-color: blue;
+}
+```
+
+```css abc.css icon="file-code"
+body {
+  background-color: red;
+}
+```
+
+</CodeGroup>
+
+This outputs:
+
+```css styles.css icon="file-code"
+body {
+  background-color: red;
+}
+
+.container {
+  background-color: blue;
+}
+```
+
+### Referencing local assets in CSS
+
+You can reference local assets in your CSS files.
+
+```css styles.css icon="file-code"
+body {
+  background-image: url("./logo.png");
+}
+```
+
+This will copy `./logo.png` to the output directory and rewrite the path in the CSS file to include a content hash.
+
+```css styles.css icon="file-code"
+body {
+  background-image: url("./logo-[ABC123].png");
+}
+```
+
+### Importing CSS in JavaScript
+
+To associate a CSS file with a JavaScript file, you can import it in your JavaScript file.
+
+```ts app.ts icon="/icons/typescript.svg"
+import "./styles.css";
+import "./more-styles.css";
+```
+
+This generates `./app.css` and `./app.js` in the output directory. All CSS files imported from JavaScript will be bundled into a single CSS file per entry point. If you import the same CSS file from multiple JavaScript files, it will only be included once in the output CSS file.
+
+## Plugins
+
+The dev server supports plugins.
+
+### Tailwind CSS
+
+To use TailwindCSS, install the `bun-plugin-tailwind` plugin:
+
+```bash terminal icon="terminal"
+# Or any npm client
+bun install --dev bun-plugin-tailwind
+```
+
+Then, add the plugin to your `bunfig.toml`:
+
+```toml title="bunfig.toml" icon="settings"
+[serve.static]
+plugins = ["bun-plugin-tailwind"]
+```
+
+Then, reference TailwindCSS in your HTML via `<link>` tag, `@import` in CSS, or import in JavaScript.
+
+<Tabs>
+  <Tab title="index.html">
+
+    ```html title="index.html" icon="file-code"
+    <!-- Reference TailwindCSS in your HTML -->
+    <link rel="stylesheet" href="tailwindcss" />
+    ```
+
+  </Tab>
+  <Tab title="styles.css">
+
+    ```css title="styles.css" icon="file-code"
+    @import "tailwindcss";
+    ```
+
+  </Tab>
+  <Tab title="app.ts">
+
+    ```ts title="app.ts" icon="/icons/typescript.svg"
+    import "tailwindcss";
+    ```
+
+  </Tab>
+</Tabs>
+
+<Info>Only one of those are necessary, not all three.</Info>
+
+## Inline environment variables
+
+Bun can replace `process.env.*` references in your JavaScript and TypeScript with their actual values at build time. This is useful for injecting configuration like API URLs or feature flags into your frontend code.
+
+### Dev server (runtime)
+
+To inline environment variables when using `bun ./index.html`, configure the `env` option in your `bunfig.toml`:
+
+```toml title="bunfig.toml" icon="settings"
+[serve.static]
+env = "PUBLIC_*"  # only inline env vars starting with PUBLIC_ (recommended)
+# env = "inline"  # inline all environment variables
+# env = "disable" # disable env var replacement (default)
+```
+
+<Note>
+  This only works with literal `process.env.FOO` references, not `import.meta.env` or indirect access like `const env =
+  process.env; env.FOO`.
+
+If an environment variable is not set, you may see runtime errors like `ReferenceError: process
+  is not defined` in the browser.
+
+</Note>
+
+Then run the dev server:
+
+```bash terminal icon="terminal"
+PUBLIC_API_URL=https://api.example.com bun ./index.html
+```
+
+### Build for production
+
+When building static HTML for production, use the `env` option to inline environment variables:
+
+<Tabs>
+  <Tab title="CLI">
+    ```bash terminal icon="terminal"
+    # Inline all environment variables
+    bun build ./index.html --outdir=dist --env=inline
+
+    # Only inline env vars with a specific prefix (recommended)
+    bun build ./index.html --outdir=dist --env=PUBLIC_*
+    ```
+
+  </Tab>
+  <Tab title="API">
+    ```ts title="build.ts" icon="/icons/typescript.svg"
+    // Inline all environment variables
+    await Bun.build({
+      entrypoints: ["./index.html"],
+      outdir: "./dist",
+      env: "inline", // [!code highlight]
+    });
+
+    // Only inline env vars with a specific prefix (recommended)
+    await Bun.build({
+      entrypoints: ["./index.html"],
+      outdir: "./dist",
+      env: "PUBLIC_*", // [!code highlight]
+    });
+    ```
+
+  </Tab>
+</Tabs>
+
+### Example
+
+Given this source file:
+
+```ts title="app.ts" icon="/icons/typescript.svg"
+const apiUrl = process.env.PUBLIC_API_URL;
+console.log(`API URL: ${apiUrl}`);
+```
+
+And running with `PUBLIC_API_URL=https://api.example.com`:
+
+```bash terminal icon="terminal"
+PUBLIC_API_URL=https://api.example.com bun build ./index.html --outdir=dist --env=PUBLIC_*
+```
+
+The bundled output will contain:
+
+```js title="dist/app.js" icon="/icons/javascript.svg"
+const apiUrl = "https://api.example.com";
+console.log(`API URL: ${apiUrl}`);
+```
+
+## Echo console logs from browser to terminal
+
+Bun's dev server supports streaming console logs from the browser to the terminal.
+
+To enable, pass the `--console` CLI flag.
+
+```bash terminal icon="terminal"
+bun ./index.html --console
+```
+
+```
+Bun v1.3.3
+ready in 6.62ms
+→ http://localhost:3000/
+Press h + Enter to show shortcuts
+```
+
+Each call to `console.log` or `console.error` will be broadcast to the terminal that started the server. This is useful to see errors from the browser in the same place you run your server. This is also useful for AI agents that watch terminal output.
+
+Internally, this reuses the existing WebSocket connection from hot module reloading to send the logs.
+
+## Edit files in the browser
+
+Bun's frontend dev server has support for Automatic Workspace Folders in Chrome DevTools, which lets you save edits to files in the browser.
+
+## Keyboard Shortcuts
+
+While the server is running:
+
+- `o + Enter` - Open in browser
+- `c + Enter` - Clear console
+- `q + Enter` (or `Ctrl+C`) - Quit server
+
+## Build for Production
+
+When you're ready to deploy, use `bun build` to create optimized production bundles:
+
+<Tabs>
+  <Tab title="CLI">
+    ```bash terminal icon="terminal"
+    bun build ./index.html --minify --outdir=dist
+    ```
+  </Tab>
+  <Tab title="API">
+    ```ts title="build.ts" icon="/icons/typescript.svg"
+    await Bun.build({
+      entrypoints: ["./index.html"],
+      outdir: "./dist",
+      minify: true,
+    });
+    ```
+  </Tab>
+</Tabs>
+
+<Warning>
+  Currently, plugins are only supported through `Bun.build`'s API or through `bunfig.toml` with the frontend dev server
+  - not yet supported in `bun build`'s CLI.
+</Warning>
+
+### Watch Mode
+
+You can run `bun build --watch` to watch for changes and rebuild automatically. This works nicely for library development.
+
+<Info>You've never seen a watch mode this fast.</Info>
+
+## Plugin API
+
+Need more control? Configure the bundler through the JavaScript API and use Bun's builtin `HTMLRewriter` to preprocess HTML.
+
+```ts title="build.ts" icon="/icons/typescript.svg"
+await Bun.build({
+  entrypoints: ["./index.html"],
+  outdir: "./dist",
+  minify: true,
+
+  plugins: [
+    {
+      // A plugin that makes every HTML tag lowercase
+      name: "lowercase-html-plugin",
+      setup({ onLoad }) {
+        const rewriter = new HTMLRewriter().on("*", {
+          element(element) {
+            element.tagName = element.tagName.toLowerCase();
+          },
+          text(element) {
+            element.replace(element.text.toLowerCase());
+          },
+        });
+
+        onLoad({ filter: /\.html$/ }, async args => {
+          const html = await Bun.file(args.path).text();
+
+          return {
+            // Bun's bundler will scan the HTML for <script> tags, <link rel="stylesheet"> tags, and other assets
+            // and bundle them automatically
+            contents: rewriter.transform(html),
+            loader: "html",
+          };
+        });
+      },
+    },
+  ],
+});
+```
+
+## What Gets Processed?
+
+Bun automatically handles all common web assets:
+
+- **Scripts** (`<script src>`) are run through Bun's JavaScript/TypeScript/JSX bundler
+- **Stylesheets** (`<link rel="stylesheet">`) are run through Bun's CSS parser & bundler
+- **Images** (`<img>`, `<picture>`) are copied and hashed
+- **Media** (`<video>`, `<audio>`, `<source>`) are copied and hashed
+- Any `<link>` tag with an `href` attribute pointing to a local file is rewritten to the new path, and hashed
+
+All paths are resolved relative to your HTML file, making it easy to organize your project however you want.
+
+<Warning>
+**This is a work in progress**
+- Need more plugins
+- Need more configuration options for things like asset handling
+- Need a way to configure CORS, headers, etc.
+
+{/* todo: find the correct link to link to as this 404's and there isn't any similar files */}
+{/* If you want to submit a PR, most of the code is [here](https://github.com/oven-sh/bun/blob/main/src/bun.js/api/bun/html-rewriter.ts). You could even copy paste that file into your project and use it as a starting point. */}
+
+</Warning>
+
+## How this works
+
+This is a small wrapper around Bun's support for HTML imports in JavaScript.
+
+## Adding a backend to your frontend
+
+To add a backend to your frontend, you can use the "routes" option in `Bun.serve`.
+
+Learn more in the full-stack docs.