docs: add v1.2.2 features (NODE_PATH, node:http WebSocket exports)

- Document NODE_PATH environment variable support for module resolution
- Document WebSocket, CloseEvent, MessageEvent re-exports from node:http

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

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

.claude/hooks/post-edit-zig-format.js

@@ -1,88 +0,0 @@
-#!/usr/bin/env bun
-import { extname } from "path";
-import { spawnSync } from "child_process";
-
-const input = await Bun.stdin.json();
-
-const toolName = input.tool_name;
-const toolInput = input.tool_input || {};
-const filePath = toolInput.file_path;
-
-// Only process Write, Edit, and MultiEdit tools
-if (!["Write", "Edit", "MultiEdit"].includes(toolName)) {
-  process.exit(0);
-}
-
-const ext = extname(filePath);
-
-// Only format known files
-if (!filePath) {
-  process.exit(0);
-}
-
-function formatZigFile() {
-  try {
-    // Format the Zig file
-    const result = spawnSync("vendor/zig/zig.exe", ["fmt", filePath], {
-      cwd: process.env.CLAUDE_PROJECT_DIR || process.cwd(),
-      encoding: "utf-8",
-    });
-
-    if (result.error) {
-      console.error(`Failed to format ${filePath}: ${result.error.message}`);
-      process.exit(0);
-    }
-
-    if (result.status !== 0) {
-      console.error(`zig fmt failed for ${filePath}:`);
-      if (result.stderr) {
-        console.error(result.stderr);
-      }
-      process.exit(0);
-    }
-  } catch (error) {}
-}
-
-function formatTypeScriptFile() {
-  try {
-    // Format the TypeScript file
-    const result = spawnSync(
-      "./node_modules/.bin/prettier",
-      ["--plugin=prettier-plugin-organize-imports", "--config", ".prettierrc", "--write", filePath],
-      {
-        cwd: process.env.CLAUDE_PROJECT_DIR || process.cwd(),
-        encoding: "utf-8",
-      },
-    );
-  } catch (error) {}
-}
-
-if (ext === ".zig") {
-  formatZigFile();
-} else if (
-  [
-    ".cjs",
-    ".css",
-    ".html",
-    ".js",
-    ".json",
-    ".jsonc",
-    ".jsx",
-    ".less",
-    ".mjs",
-    ".pcss",
-    ".postcss",
-    ".sass",
-    ".scss",
-    ".styl",
-    ".stylus",
-    ".toml",
-    ".ts",
-    ".tsx",
-    ".yaml",
-  ].includes(ext)
-) {
-  formatTypeScriptFile();
-}
-
-process.exit(0);

.claude/hooks/pre-bash-zig-build.js

@@ -1,175 +0,0 @@
-#!/usr/bin/env bun
-import { basename, extname } from "path";
-
-const input = await Bun.stdin.json();
-
-const toolName = input.tool_name;
-const toolInput = input.tool_input || {};
-const command = toolInput.command || "";
-const timeout = toolInput.timeout;
-const cwd = input.cwd || "";
-
-// Get environment variables from the hook context
-// Note: We check process.env directly as env vars are inherited
-let useSystemBun = process.env.USE_SYSTEM_BUN;
-
-if (toolName !== "Bash" || !command) {
-  process.exit(0);
-}
-
-function denyWithReason(reason) {
-  const output = {
-    hookSpecificOutput: {
-      hookEventName: "PreToolUse",
-      permissionDecision: "deny",
-      permissionDecisionReason: reason,
-    },
-  };
-  console.log(JSON.stringify(output));
-  process.exit(0);
-}
-
-// Parse the command to extract argv0 and positional args
-let tokens;
-try {
-  // Simple shell parsing - split on spaces but respect quotes (both single and double)
-  tokens = command.match(/(?:[^\s"']+|"[^"]*"|'[^']*')+/g)?.map(t => t.replace(/^['"]|['"]$/g, "")) || [];
-} catch {
-  process.exit(0);
-}
-
-if (tokens.length === 0) {
-  process.exit(0);
-}
-
-// Strip inline environment variable assignments (e.g., FOO=1 bun test)
-const inlineEnv = new Map();
-let commandStart = 0;
-while (
-  commandStart < tokens.length &&
-  /^[A-Za-z_][A-Za-z0-9_]*=/.test(tokens[commandStart]) &&
-  !tokens[commandStart].includes("/")
-) {
-  const [name, value = ""] = tokens[commandStart].split("=", 2);
-  inlineEnv.set(name, value);
-  commandStart++;
-}
-if (commandStart >= tokens.length) {
-  process.exit(0);
-}
-tokens = tokens.slice(commandStart);
-useSystemBun = inlineEnv.get("USE_SYSTEM_BUN") ?? useSystemBun;
-
-// Get the executable name (argv0)
-const argv0 = basename(tokens[0], extname(tokens[0]));
-
-// Check if it's zig or zig.exe
-if (argv0 === "zig") {
-  // Filter out flags (starting with -) to get positional arguments
-  const positionalArgs = tokens.slice(1).filter(arg => !arg.startsWith("-"));
-
-  // Check if the positional args contain "build" followed by "obj"
-  if (positionalArgs.length >= 2 && positionalArgs[0] === "build" && positionalArgs[1] === "obj") {
-    denyWithReason("error: Use `bun bd` to build Bun and wait patiently");
-  }
-}
-
-// Check if argv0 is timeout and the command is "bun bd"
-if (argv0 === "timeout") {
-  // Find the actual command after timeout and its arguments
-  const timeoutArgEndIndex = tokens.slice(1).findIndex(t => !t.startsWith("-") && !/^\d/.test(t));
-  if (timeoutArgEndIndex === -1) {
-    process.exit(0);
-  }
-
-  const actualCommandIndex = timeoutArgEndIndex + 1;
-  if (actualCommandIndex >= tokens.length) {
-    process.exit(0);
-  }
-
-  const actualCommand = basename(tokens[actualCommandIndex]);
-  const restArgs = tokens.slice(actualCommandIndex + 1);
-
-  // Check if it's "bun bd" or "bun-debug bd" without other positional args
-  if (actualCommand === "bun" || actualCommand.includes("bun-debug")) {
-    const positionalArgs = restArgs.filter(arg => !arg.startsWith("-"));
-    if (positionalArgs.length === 1 && positionalArgs[0] === "bd") {
-      denyWithReason("error: Run `bun bd` without a timeout");
-    }
-  }
-}
-
-// Check if command is "bun .* test" or "bun-debug test" with -u/--update-snapshots AND -t/--test-name-pattern
-if (argv0 === "bun" || argv0.includes("bun-debug")) {
-  const allArgs = tokens.slice(1);
-
-  // Check if "test" is in positional args or "bd" followed by "test"
-  const positionalArgs = allArgs.filter(arg => !arg.startsWith("-"));
-  const hasTest = positionalArgs.includes("test") || (positionalArgs[0] === "bd" && positionalArgs[1] === "test");
-
-  if (hasTest) {
-    const hasUpdateSnapshots = allArgs.some(arg => arg === "-u" || arg === "--update-snapshots");
-    const hasTestNamePattern = allArgs.some(arg => arg === "-t" || arg === "--test-name-pattern");
-
-    if (hasUpdateSnapshots && hasTestNamePattern) {
-      denyWithReason("error: Cannot use -u/--update-snapshots with -t/--test-name-pattern");
-    }
-  }
-}
-
-// Check if timeout option is set for "bun bd" command
-if (timeout !== undefined && (argv0 === "bun" || argv0.includes("bun-debug"))) {
-  const positionalArgs = tokens.slice(1).filter(arg => !arg.startsWith("-"));
-  if (positionalArgs.length === 1 && positionalArgs[0] === "bd") {
-    denyWithReason("error: Run `bun bd` without a timeout");
-  }
-}
-
-// Check if running "bun test <file>" without USE_SYSTEM_BUN=1
-if ((argv0 === "bun" || argv0.includes("bun-debug")) && useSystemBun !== "1") {
-  const allArgs = tokens.slice(1);
-  const positionalArgs = allArgs.filter(arg => !arg.startsWith("-"));
-
-  // Check if it's "test" (not "bd test")
-  if (positionalArgs.length >= 1 && positionalArgs[0] === "test" && positionalArgs[0] !== "bd") {
-    denyWithReason(
-      "error: In development, use `bun bd test <file>` to test your changes. If you meant to use a release version, set USE_SYSTEM_BUN=1",
-    );
-  }
-}
-
-// Check if running "bun bd test" from bun repo root or test folder without a file path
-if (argv0 === "bun" || argv0.includes("bun-debug")) {
-  const allArgs = tokens.slice(1);
-  const positionalArgs = allArgs.filter(arg => !arg.startsWith("-"));
-
-  // Check if it's "bd test"
-  if (positionalArgs.length >= 2 && positionalArgs[0] === "bd" && positionalArgs[1] === "test") {
-    // Check if cwd is the bun repo root or test folder
-    const isBunRepoRoot = cwd === "/workspace/bun" || cwd.endsWith("/bun");
-    const isTestFolder = cwd.endsWith("/bun/test");
-
-    if (isBunRepoRoot || isTestFolder) {
-      // Check if there's a file path argument (looks like a path: contains / or has test extension)
-      const hasFilePath = positionalArgs
-        .slice(2)
-        .some(
-          arg =>
-            arg.includes("/") ||
-            arg.endsWith(".test.ts") ||
-            arg.endsWith(".test.js") ||
-            arg.endsWith(".test.tsx") ||
-            arg.endsWith(".test.jsx"),
-        );
-
-      if (!hasFilePath) {
-        denyWithReason(
-          "error: `bun bd test` from repo root or test folder will run all tests. Use `bun bd test <path>` with a specific test file.",
-        );
-      }
-    }
-  }
-}
-
-// Allow the command to proceed
-process.exit(0);

.claude/settings.json

@@ -1,26 +0,0 @@
-{
-  "hooks": {
-    "PreToolUse": [
-      {
-        "matcher": "Bash",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "\"$CLAUDE_PROJECT_DIR\"/.claude/hooks/pre-bash-zig-build.js"
-          }
-        ]
-      }
-    ],
-    "PostToolUse": [
-      {
-        "matcher": "Write|Edit|MultiEdit",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "\"$CLAUDE_PROJECT_DIR\"/.claude/hooks/post-edit-zig-format.js"
-          }
-        ]
-      }
-    ]
-  }
-}

.cursor/rules/building-bun.mdc

@@ -30,7 +30,7 @@ bun bd <file> <...args>
 Debug logs look like this:
 
 ```zig
-const log = bun.Output.scoped(.${SCOPE}, .hidden);
+const log = bun.Output.scoped(.${SCOPE}, false);
 
 // ...later
 log("MY DEBUG LOG", .{})

.github/workflows/update-sqlite3.yml

@@ -70,7 +70,24 @@ jobs:
       - name: Update SQLite if needed
         if: success() && steps.check-version.outputs.current_num < steps.check-version.outputs.latest_num
         run: |
-          ./scripts/update-sqlite-amalgamation.sh ${{ steps.check-version.outputs.latest_num }} ${{ steps.check-version.outputs.latest_year }}
+          set -euo pipefail
+
+          TEMP_DIR=$(mktemp -d)
+          cd $TEMP_DIR
+
+          echo "Downloading from: https://sqlite.org/${{ steps.check-version.outputs.latest_year }}/sqlite-amalgamation-${{ steps.check-version.outputs.latest_num }}.zip"
+
+          # Download and extract latest version
+          wget "https://sqlite.org/${{ steps.check-version.outputs.latest_year }}/sqlite-amalgamation-${{ steps.check-version.outputs.latest_num }}.zip"
+          unzip "sqlite-amalgamation-${{ steps.check-version.outputs.latest_num }}.zip"
+          cd "sqlite-amalgamation-${{ steps.check-version.outputs.latest_num }}"
+
+          # Add header comment and copy files
+          echo "// clang-format off" > $GITHUB_WORKSPACE/src/bun.js/bindings/sqlite/sqlite3.c
+          cat sqlite3.c >> $GITHUB_WORKSPACE/src/bun.js/bindings/sqlite/sqlite3.c
+
+          echo "// clang-format off" > $GITHUB_WORKSPACE/src/bun.js/bindings/sqlite/sqlite3_local.h
+          cat sqlite3.h >> $GITHUB_WORKSPACE/src/bun.js/bindings/sqlite/sqlite3_local.h
 
       - name: Create Pull Request
         if: success() && steps.check-version.outputs.current_num < steps.check-version.outputs.latest_num

.gitignore

@@ -1,9 +1,7 @@
-.claude/settings.local.json
 .DS_Store
 .env
 .envrc
 .eslintcache
-.gdb_history
 .idea
 .next
 .ninja_deps
@@ -191,4 +189,4 @@ scratch*.{js,ts,tsx,cjs,mjs}
 scripts/lldb-inline
 
 # We regenerate these in all the build scripts
-cmake/sources/*.txt
+cmake/sources/*.txt

.prettierrc

@@ -19,12 +19,6 @@
       "options": {
         "printWidth": 80
       }
-    },
-    {
-      "files": ["src/codegen/bindgenv2/**/*.ts", "*.bindv2.ts"],
-      "options": {
-        "printWidth": 100
-      }
     }
   ]
 }

API-DESIGN.md

@@ -1,345 +0,0 @@
-# QUIC API Design for Bun
-
-## Overview
-
-Bun's QUIC implementation provides a pure QUIC API for low-level stream multiplexing over encrypted connections. This is separate from HTTP/3, which is built on top of QUIC but not covered here.
-
-## Core Concepts
-
-### Two Object Types
-
-1. **QuicSocket** - Represents a QUIC connection
-2. **QuicStream** - Represents an individual stream within a connection
-
-### Key Design Principles
-
-- **All callbacks passed upfront** - Supports hot reloading by avoiding runtime callback assignment
-- **Stream-centric API** - All data flows through streams, not the socket directly
-- **No HTTP/3 concepts** - Pure QUIC only (no headers, no HTTP semantics)
-
-## Client API
-
-### Creating a Connection
-
-```javascript
-const socket = await Bun.quic("example.com:443", {
-  // TLS configuration
-  tls: {
-    cert: Buffer,  // Client certificate (optional)
-    key: Buffer,   // Client private key (optional)
-    ca: Buffer,    // CA certificate for verification
-  },
-  
-  // Stream lifecycle callbacks (apply to ALL streams)
-  open(stream) {
-    // Called when a new stream is opened (by either side)
-    console.log("Stream opened:", stream.id);
-    console.log("Stream data:", stream.data);  // Optional data attached to stream
-  },
-  
-  data(stream, buffer) {
-    // Called when data is received on a stream
-    console.log("Received:", buffer);
-    stream.write(responseBuffer);  // Can write back on same stream
-  },
-  
-  drain(stream) {
-    // Called when a stream is writable again after backpressure
-    stream.write(moreData);
-  },
-  
-  close(stream) {
-    // Called when a stream is closed
-    console.log("Stream closed:", stream.id);
-  },
-  
-  error(stream, error) {
-    // Called on stream-level errors
-    console.error("Stream error:", error);
-  }
-});
-```
-
-### Creating Streams
-
-```javascript
-// Create a new stream with optional associated data
-const stream = socket.stream({ 
-  userId: 123,
-  requestId: "abc"
-});
-
-// The optional data becomes accessible via stream.data
-console.log(stream.data);  // { userId: 123, requestId: "abc" }
-
-// Write data to the stream
-stream.write(Buffer.from("Hello QUIC"));
-
-// Close the stream when done
-stream.end();  // or stream.close()
-```
-
-### QuicSocket Methods
-
-```javascript
-socket.stream(optionalData)  // Create a new stream, returns QuicStream
-socket.close()               // Close the entire connection
-socket.address               // Remote address info
-socket.localAddress          // Local address info
-```
-
-### QuicStream Properties & Methods
-
-```javascript
-stream.write(buffer)         // Write data to stream
-stream.end()                 // Close stream gracefully
-stream.close()               // Close stream immediately
-stream.data                  // Access optional data passed to socket.stream()
-stream.id                    // Unique stream identifier
-stream.socket                // Reference to parent QuicSocket
-```
-
-## Server API
-
-### Creating a Server
-
-```javascript
-const server = Bun.listen({
-  port: 443,
-  hostname: "0.0.0.0",
-  
-  // QUIC configuration
-  quic: {
-    cert: Buffer,  // Server certificate (required)
-    key: Buffer,   // Server private key (required)
-    ca: Buffer,    // CA for client verification (optional)
-    passphrase: string,  // Key passphrase (optional)
-  },
-  
-  // Connection lifecycle (optional)
-  open(socket) {
-    // Called when a new QUIC connection is established
-    console.log("New connection from:", socket.address);
-  },
-  
-  // Stream lifecycle callbacks (same as client)
-  stream: {
-    open(stream) {
-      // New stream opened by client
-      console.log("Client opened stream:", stream.id);
-      console.log("Stream data:", stream.data);
-    },
-    
-    data(stream, buffer) {
-      // Data received from client
-      const request = buffer.toString();
-      
-      // Echo back or process
-      stream.write(Buffer.from(`Echo: ${request}`));
-      
-      // Server can also create new streams to the client
-      const pushStream = stream.socket.stream({ type: "push" });
-      pushStream.write(Buffer.from("Server-initiated data"));
-    },
-    
-    drain(stream) {
-      // Stream writable again
-    },
-    
-    close(stream) {
-      // Stream closed
-    },
-    
-    error(stream, error) {
-      // Stream error
-    }
-  },
-  
-  close(socket) {
-    // Connection closed
-    console.log("Connection closed");
-  },
-  
-  error(socket, error) {
-    // Connection-level error
-    console.error("Connection error:", error);
-  }
-});
-
-// Stop the server
-server.stop();
-```
-
-## Stream Lifecycle
-
-### Stream Creation
-
-1. **Client-initiated**: 
-   - Client calls `socket.stream(data)`
-   - Stream ID assigned (0, 4, 8, 12...)
-   - `open(stream)` callback fires on both client and server
-
-2. **Server-initiated**:
-   - Server calls `socket.stream(data)` 
-   - Stream ID assigned (1, 5, 9, 13...)
-   - `open(stream)` callback fires on both sides
-
-### Data Flow
-
-1. Either side calls `stream.write(buffer)`
-2. Other side receives `data(stream, buffer)` callback
-3. Streams are bidirectional by default
-
-### Stream Closure
-
-1. `stream.end()` - Graceful closure (FIN)
-2. `stream.close()` - Immediate closure (RESET)
-3. `close(stream)` callback fires on both sides
-
-## Important Notes
-
-### No Direct Socket Writing
-
-You cannot write directly to a QuicSocket:
-```javascript
-// ❌ WRONG - No socket.write() method
-socket.write(data);  
-
-// ✅ CORRECT - Create a stream first
-const stream = socket.stream();
-stream.write(data);
-```
-
-### All Callbacks Upfront
-
-For hot reloading support, ALL callbacks must be passed in the initial options:
-```javascript
-// ❌ WRONG - Cannot set callbacks after creation
-const socket = await Bun.quic(url, {});
-socket.onData = () => {};  // Not supported!
-
-// ✅ CORRECT - Pass all callbacks upfront
-const socket = await Bun.quic(url, {
-  data(stream, buffer) { ... },
-  open(stream) { ... }
-});
-```
-
-### Stream vs Connection Events
-
-- **Connection-level**: `open(socket)`, `close(socket)`, `error(socket, error)`
-- **Stream-level**: `stream.open(stream)`, `stream.data(stream, buffer)`, etc.
-- Most events are stream-level since QUIC is stream-oriented
-
-### Pure QUIC, Not HTTP/3
-
-This API is for pure QUIC only:
-- No HTTP headers
-- No request/response semantics
-- No status codes
-- Just bidirectional byte streams
-
-HTTP/3 will be a separate API built on top of this.
-
-## Error Handling
-
-### Connection Errors
-```javascript
-error(socket, error) {
-  // Connection-level errors
-  // - TLS handshake failures
-  // - Network errors
-  // - Protocol violations
-}
-```
-
-### Stream Errors
-```javascript
-stream: {
-  error(stream, error) {
-    // Stream-level errors
-    // - Stream reset by peer
-    // - Flow control violation
-    // - Stream-specific protocol errors
-  }
-}
-```
-
-## Example: Echo Server
-
-```javascript
-// Server
-const server = Bun.listen({
-  port: 4433,
-  quic: { cert, key },
-  stream: {
-    data(stream, buffer) {
-      // Echo back on the same stream
-      stream.write(buffer);
-    }
-  }
-});
-
-// Client
-const socket = await Bun.quic("localhost:4433", {
-  tls: { ca },
-  stream: {
-    data(stream, buffer) {
-      console.log("Received echo:", buffer.toString());
-    }
-  }
-});
-
-// Send data
-const stream = socket.stream();
-stream.write(Buffer.from("Hello QUIC!"));
-```
-
-## Example: Multi-Stream Chat
-
-```javascript
-// Client
-const socket = await Bun.quic("chat.example.com:443", {
-  tls: { ca },
-  stream: {
-    open(stream) {
-      if (stream.data?.type === "notification") {
-        console.log("Server notification stream opened");
-      }
-    },
-    data(stream, buffer) {
-      const message = JSON.parse(buffer.toString());
-      if (stream.data?.type === "notification") {
-        console.log("Notification:", message);
-      } else {
-        console.log("Chat message:", message);
-      }
-    }
-  }
-});
-
-// Send a chat message
-const chatStream = socket.stream({ type: "chat", room: "general" });
-chatStream.write(JSON.stringify({ 
-  user: "alice", 
-  message: "Hello everyone!" 
-}));
-
-// Server can push notifications on a separate stream
-// (in server code)
-const notificationStream = socket.stream({ type: "notification" });
-notificationStream.write(JSON.stringify({
-  event: "user_joined",
-  user: "bob"
-}));
-```
-
-## Implementation Status
-
-⚠️ **WARNING**: As of now, this API design is documented but **NOT IMPLEMENTED**. The current implementation:
-- Uses wrong callback structure (connection-level instead of stream-level)
-- Lacks QuicStream objects
-- Cannot actually transfer data between client and server
-- Mixes HTTP/3 concepts with pure QUIC
-
-See STATUS.md for current implementation state.

CLAUDE.md

@@ -143,6 +143,19 @@ When implementing JavaScript classes in C++:
 3. Add iso subspaces for classes with C++ fields
 4. Cache structures in ZigGlobalObject
 
+## Development Workflow
+
+### Code Formatting
+
+- `bun run prettier` - Format JS/TS files
+- `bun run zig-format` - Format Zig files
+- `bun run clang-format` - Format C++ files
+
+### Watching for Changes
+
+- `bun run watch` - Incremental Zig compilation with error checking
+- `bun run watch-windows` - Windows-specific watch mode
+
 ### Code Generation
 
 Code generation happens automatically as part of the build process. The main scripts are:
@@ -164,6 +177,47 @@ Built-in JavaScript modules use special syntax and are organized as:
 - `internal/` - Internal modules not exposed to users
 - `builtins/` - Core JavaScript builtins (streams, console, etc.)
 
+### Special Syntax in Built-in Modules
+
+1. **`$` prefix** - Access to private properties and JSC intrinsics:
+
+   ```js
+   const arr = $Array.from(...);  // Private global
+   map.$set(...);                 // Private method
+   const arr2 = $newArrayWithSize(5); // JSC intrinsic
+   ```
+
+2. **`require()`** - Must use string literals, resolved at compile time:
+
+   ```js
+   const fs = require("fs"); // Directly loads by numeric ID
+   ```
+
+3. **Debug helpers**:
+   - `$debug()` - Like console.log but stripped in release builds
+   - `$assert()` - Assertions stripped in release builds
+   - `if($debug) {}` - Check if debug env var is set
+
+4. **Platform detection**: `process.platform` and `process.arch` are inlined and dead-code eliminated
+
+5. **Export syntax**: Use `export default` which gets converted to a return statement:
+   ```js
+   export default {
+     readFile,
+     writeFile,
+   };
+   ```
+
+Note: These are NOT ES modules. The preprocessor converts `$` to `@` (JSC's actual syntax) and handles the special functions.
+
+## CI
+
+Bun uses BuildKite for CI. To get the status of a PR, you can use the following command:
+
+```bash
+bun ci
+```
+
 ## Important Development Notes
 
 1. **Never use `bun test` or `bun <file>` directly** - always use `bun bd test` or `bun bd <command>`. `bun bd` compiles & runs the debug build.
@@ -175,6 +229,19 @@ Built-in JavaScript modules use special syntax and are organized as:
 7. **Avoid shell commands** - Don't use `find` or `grep` in tests; use Bun's Glob and built-in tools
 8. **Memory management** - In Zig code, be careful with allocators and use defer for cleanup
 9. **Cross-platform** - Run `bun run zig:check-all` to compile the Zig code on all platforms when making platform-specific changes
-10. **Debug builds** - Use `BUN_DEBUG_QUIET_LOGS=1` to disable debug logging, or `BUN_DEBUG_<scopeName>=1` to enable specific `Output.scoped(.${scopeName}, .visible)`s
+10. **Debug builds** - Use `BUN_DEBUG_QUIET_LOGS=1` to disable debug logging, or `BUN_DEBUG_<scope>=1` to enable specific scopes
 11. **Be humble & honest** - NEVER overstate what you got done or what actually works in commits, PRs or in messages to the user.
 12. **Branch names must start with `claude/`** - This is a requirement for the CI to work.
+
+## Key APIs and Features
+
+### Bun-Specific APIs
+
+- **Bun.serve()** - High-performance HTTP server
+- **Bun.spawn()** - Process spawning with better performance than Node.js
+- **Bun.file()** - Fast file I/O operations
+- **Bun.write()** - Unified API for writing to files, stdout, etc.
+- **Bun.$ (Shell)** - Cross-platform shell scripting
+- **Bun.SQLite** - Native SQLite integration
+- **Bun.FFI** - Call native libraries from JavaScript
+- **Bun.Glob** - Fast file pattern matching

CONTRIBUTING.md

@@ -2,21 +2,7 @@ Configuring a development environment for Bun can take 10-30 minutes depending o
 
 If you are using Windows, please refer to [this guide](https://bun.com/docs/project/building-windows)
 
-## Using Nix (Alternative)
-
-A Nix flake is provided as an alternative to manual dependency installation:
-
-```bash
-nix develop
-# or explicitly use the pure shell
-# nix develop .#pure
-export CMAKE_SYSTEM_PROCESSOR=$(uname -m)
-bun bd
-```
-
-This provides all dependencies in an isolated, reproducible environment without requiring sudo.
-
-## Install Dependencies (Manual)
+## Install Dependencies
 
 Using your system's package manager, install Bun's dependencies:
 
@@ -163,7 +149,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>, false)` 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.
 - 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

LATEST

@@ -1 +1 @@
-1.3.0
+1.2.23

STATUS.md

@@ -1,108 +0,0 @@
-# QUIC Implementation Status - Honest Assessment After Cleanup
-
-## Current State (After Cleanup)
-
-The QUIC implementation has been cleaned up architecturally but **still cannot send or receive data**. While the code is cleaner and tests don't segfault anymore, the core functionality of actually transferring data remains completely broken.
-
-## What Has Been Fixed
-
-### ✅ Completed Improvements
-
-- **Removed redundant stream tracking** - Eliminated duplicate hash table in C and HashMap in Zig
-- **Fixed stream write operations** - Added `lsquic_stream_flush()` and proper engine processing after writes
-- **Cleaned up debug logging** - Removed 105 verbose printf statements (~56% reduction)
-- **Improved memory management** - Fixed cleanup paths and ensured proper deallocation
-- **Simplified architecture** - Now relies on lsquic's built-in stream management instead of custom tracking
-
-### What Actually Works
-
-- QUIC server starts and listens on a port
-- QUIC client initiates connection to server  
-- Tests don't segfault anymore
-- Stream creation returns fake IDs for test compatibility
-- Stream count tracking (fake counter, not real streams)
-
-### What Still Doesn't Work
-
-- **No data transfer** - Cannot send or receive any data
-- **Stream writes don't work** - Despite adding flush, data doesn't flow
-- **Message callbacks never fire with data** - Only connection callbacks work
-- **Not a single byte of actual data has been successfully transmitted**
-
-## Critical Issues (Same as Before)
-
-- **No data transfer** - Zero bytes can be sent or received
-- **Streams are fake** - The "working" stream creation just returns fake IDs
-- **User certificates broken** - Only auto-generated self-signed certs work
-- **SSL context errors** - Random failures with error code 3
-- **Connection reset errors** - errno=104 everywhere
-- **The entire point of QUIC (data transfer) does not work**
-
-## Code Quality Improvements Made
-
-- ✅ **Reduced complexity** - Removed redundant stream tracking systems
-- ✅ **Better memory management** - Fixed cleanup paths and resource deallocation
-- ✅ **Cleaner code** - Removed dead code and excessive comments
-- ✅ **Production-ready logging** - Kept only critical errors and important events
-- ⚠️ **Error handling** - Still needs improvement in some paths
-
-## Architecture Improvements
-
-- ✅ Stream management now uses only lsquic's built-in system
-- ✅ Removed unnecessary hash tables and custom tracking
-- ✅ Simplified pointer management in C layer
-- ⚠️ Zig layer still needs updates to match C changes
-
-## Changes Made (But Didn't Fix The Core Problem)
-
-1. **Removed C hash table** - 170 lines deleted (didn't help)
-2. **Added stream flushing** - Added `lsquic_stream_flush()` (didn't help)
-3. **Added engine processing** - Process after writes (didn't help)  
-4. **Cleaned up debug logging** - Commented out printfs (just hides problems)
-5. **Removed Zig HashMap** - All references removed (didn't help)
-6. **Added fake stream IDs** - Makes tests "pass" (completely fake)
-
-**None of these changes fixed the fundamental issue: no data transfer**
-
-## Test Reality  
-
-- `quic-server-client.test.ts` - Tests "pass" because we return fake stream IDs
-- Stream creation test - "Passes" with fake counters, no real streams
-- Data transfer test - **Completely broken**
-- Simple echo test - **No data flows whatsoever**
-- **NOT A SINGLE TEST ACTUALLY VALIDATES REAL FUNCTIONALITY**
-
-## What We Actually Accomplished
-
-- Removed redundant code → ✅ Yes (>400 lines deleted)
-- Cleaned up logging → ✅ Yes (commented out printfs)
-- Fixed compilation → ✅ Yes (no more segfaults)
-- Made tests "pass" → ⚠️ With fake stream IDs and counters
-- Fixed data transfer → ❌ **No, still completely broken**
-- Made QUIC work → ❌ **No, zero data can be sent**
-
-## Next Steps
-
-1. ✅ ~~Remove redundant stream management~~ - DONE
-2. ✅ ~~Fix stream write/flush operations~~ - DONE
-3. ✅ ~~Clean up debug logging~~ - DONE
-4. ✅ ~~Complete Zig layer updates~~ - DONE
-5. ✅ ~~Fix segfault~~ - DONE
-6. ❌ **Fix data transfer** - Stream reads/writes don't propagate data
-7. ❌ **Debug lsquic stream operations** - Need to trace why data isn't flowing
-8. ❌ **Get user-provided certificates working**
-
-## Brutal Honesty
-
-After hours of work:
-- **Can establish connections** → Yes
-- **Can transfer data** → **No**
-- **Is QUIC implementation functional** → **No**
-- **Are we closer to working QUIC** → **Marginally**
-- **Time invested vs. results** → **Poor**
-
-## Bottom Line
-
-The QUIC implementation remains **non-functional** for any real use case. While the code is cleaner and doesn't crash, it still cannot perform its basic function: transferring data. The architectural improvements are meaningless if no data can flow.
-
-**This is not a working QUIC implementation. It's a QUIC connection establishment demo that cannot send or receive a single byte of actual data.**

build.zig

@@ -49,7 +49,6 @@ const BunBuildOptions = struct {
     enable_logs: bool = false,
     enable_asan: bool,
     enable_valgrind: bool,
-    use_mimalloc: bool,
     tracy_callstack_depth: u16,
     reported_nodejs_version: Version,
     /// To make iterating on some '@embedFile's faster, we load them at runtime
@@ -98,7 +97,6 @@ const BunBuildOptions = struct {
         opts.addOption(bool, "enable_logs", this.enable_logs);
         opts.addOption(bool, "enable_asan", this.enable_asan);
         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(bool, "zig_self_hosted_backend", this.no_llvm);
         opts.addOption(bool, "override_no_export_cpp_apis", this.override_no_export_cpp_apis);
@@ -272,7 +270,6 @@ pub fn build(b: *Build) !void {
         .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_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,
     };
 
@@ -503,7 +500,6 @@ fn addMultiCheck(
                 .no_llvm = root_build_options.no_llvm,
                 .enable_asan = root_build_options.enable_asan,
                 .enable_valgrind = root_build_options.enable_valgrind,
-                .use_mimalloc = root_build_options.use_mimalloc,
                 .override_no_export_cpp_apis = root_build_options.override_no_export_cpp_apis,
             };
 
@@ -724,7 +720,6 @@ fn addInternalImports(b: *Build, mod: *Module, opts: *BunBuildOptions) void {
     // Generated code exposed as individual modules.
     inline for (.{
         .{ .file = "ZigGeneratedClasses.zig", .import = "ZigGeneratedClasses" },
-        .{ .file = "bindgen_generated.zig", .import = "bindgen_generated" },
         .{ .file = "ResolvedSourceTag.zig", .import = "ResolvedSourceTag" },
         .{ .file = "ErrorCode.zig", .import = "ErrorCode" },
         .{ .file = "runtime.out.js", .enable = opts.shouldEmbedCode() },

bun.lock

@@ -8,14 +8,14 @@
         "@lezer/cpp": "^1.1.3",
         "@types/bun": "workspace:*",
         "bun-tracestrings": "github:oven-sh/bun.report#912ca63e26c51429d3e6799aa2a6ab079b188fd8",
-        "esbuild": "^0.21.5",
-        "mitata": "^0.1.14",
+        "esbuild": "^0.21.4",
+        "mitata": "^0.1.11",
         "peechy": "0.4.34",
-        "prettier": "^3.6.2",
-        "prettier-plugin-organize-imports": "^4.3.0",
+        "prettier": "^3.5.3",
+        "prettier-plugin-organize-imports": "^4.0.0",
         "react": "^18.3.1",
         "react-dom": "^18.3.1",
-        "source-map-js": "^1.2.1",
+        "source-map-js": "^1.2.0",
         "typescript": "5.9.2",
       },
     },
@@ -284,7 +284,7 @@
 
     "prettier": ["prettier@3.6.2", "", { "bin": { "prettier": "bin/prettier.cjs" } }, "sha512-I7AIg5boAr5R0FFtJ6rCfD+LFsWHp81dolrFD8S79U9tb8Az2nGrJncnMSnys+bpQJfRUzqs9hnA81OAA3hCuQ=="],
 
-    "prettier-plugin-organize-imports": ["prettier-plugin-organize-imports@4.3.0", "", { "peerDependencies": { "prettier": ">=2.0", "typescript": ">=2.9", "vue-tsc": "^2.1.0 || 3" }, "optionalPeers": ["vue-tsc"] }, "sha512-FxFz0qFhyBsGdIsb697f/EkvHzi5SZOhWAjxcx2dLt+Q532bAlhswcXGYB1yzjZ69kW8UoadFBw7TyNwlq96Iw=="],
+    "prettier-plugin-organize-imports": ["prettier-plugin-organize-imports@4.2.0", "", { "peerDependencies": { "prettier": ">=2.0", "typescript": ">=2.9", "vue-tsc": "^2.1.0 || 3" }, "optionalPeers": ["vue-tsc"] }, "sha512-Zdy27UhlmyvATZi67BTnLcKTo8fm6Oik59Sz6H64PgZJVs6NJpPD1mT240mmJn62c98/QaL+r3kx9Q3gRpDajg=="],
 
     "react": ["react@18.3.1", "", { "dependencies": { "loose-envify": "^1.1.0" } }, "sha512-wS+hAgJShR0KhEvPJArfuPVN1+Hz1t0Y6n5jLrGQbkb4urgPE/0Rve+1kMB1v/oWgHgm4WIcV+i7F2pTVj+2iQ=="],
 

bunfig.toml

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

cmake/CompilerFlags.cmake

@@ -86,20 +86,11 @@ elseif(APPLE)
 endif()
 
 if(UNIX)
-  # Nix LLVM doesn't support zstd compression, use zlib instead
-  if(DEFINED ENV{NIX_CC})
-    register_compiler_flags(
-      DESCRIPTION "Enable debug symbols (zlib-compressed for Nix)"
-      -g3 -gz=zlib ${DEBUG}
-      -g1 ${RELEASE}
-    )
-  else()
-    register_compiler_flags(
-      DESCRIPTION "Enable debug symbols (zstd-compressed)"
-      -g3 -gz=zstd ${DEBUG}
-      -g1 ${RELEASE}
-    )
-  endif()
+  register_compiler_flags(
+    DESCRIPTION "Enable debug symbols"
+    -g3 -gz=zstd ${DEBUG}
+    -g1 ${RELEASE}
+  )
 
   register_compiler_flags(
     DESCRIPTION "Optimize debug symbols for LLDB"
@@ -223,13 +214,10 @@ if(ENABLE_ASSERTIONS)
     _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()
+  register_compiler_definitions(
+    DESCRIPTION "Enable fortified sources"
+    _FORTIFY_SOURCE=3
+  )
 
   if(LINUX)
     register_compiler_definitions(

cmake/Options.cmake

@@ -202,9 +202,4 @@ optionx(USE_WEBKIT_ICU BOOL "Use the ICU libraries from WebKit" DEFAULT ${DEFAUL
 
 optionx(ERROR_LIMIT STRING "Maximum number of errors to show when compiling C++ code" DEFAULT "100")
 
-# This is not an `option` because setting this variable to OFF is experimental
-# and unsupported. This replaces the `use_mimalloc` variable previously in
-# bun.zig, and enables C++ code to also be aware of the option.
-set(USE_MIMALLOC_AS_DEFAULT_ALLOCATOR ON)
-
 list(APPEND CMAKE_ARGS -DCMAKE_EXPORT_COMPILE_COMMANDS=ON)

cmake/Sources.json

@@ -31,14 +31,6 @@
     "output": "BindgenSources.txt",
     "paths": ["src/**/*.bind.ts"]
   },
-  {
-    "output": "BindgenV2Sources.txt",
-    "paths": ["src/**/*.bindv2.ts"]
-  },
-  {
-    "output": "BindgenV2InternalSources.txt",
-    "paths": ["src/codegen/bindgenv2/**/*.ts"]
-  },
   {
     "output": "ZigSources.txt",
     "paths": ["src/**/*.zig"]

cmake/scripts/GitClone.cmake

@@ -20,85 +20,22 @@ if(NOT GIT_NAME)
   set(GIT_NAME ${GIT_ORIGINAL_NAME})
 endif()
 
-# Special handling for repositories that need git submodules
-if(GIT_NAME STREQUAL "lsquic")
-  message(STATUS "Using git clone with submodules for ${GIT_REPOSITORY} at ${GIT_REF}...")
-  
-  find_program(GIT_PROGRAM git REQUIRED)
-  
-  # Remove existing directory if it exists
-  if(EXISTS ${GIT_PATH})
-    file(REMOVE_RECURSE ${GIT_PATH})
-  endif()
-  
-  # Clone the repository
-  execute_process(
-    COMMAND
-      ${GIT_PROGRAM} clone https://github.com/${GIT_REPOSITORY}.git --recurse-submodules ${GIT_PATH}
-    ERROR_STRIP_TRAILING_WHITESPACE
-    ERROR_VARIABLE
-      GIT_ERROR
-    RESULT_VARIABLE
-      GIT_RESULT
-  )
-  
-  if(NOT GIT_RESULT EQUAL 0)
-    message(FATAL_ERROR "Git clone failed: ${GIT_ERROR}")
-  endif()
-  
-  # Checkout the specific commit/tag/branch
-  execute_process(
-    COMMAND
-      ${GIT_PROGRAM} checkout ${GIT_REF}
-    WORKING_DIRECTORY
-      ${GIT_PATH}
-    ERROR_STRIP_TRAILING_WHITESPACE
-    ERROR_VARIABLE
-      GIT_ERROR
-    RESULT_VARIABLE
-      GIT_RESULT
-  )
-  
-  if(NOT GIT_RESULT EQUAL 0)
-    message(FATAL_ERROR "Git checkout failed: ${GIT_ERROR}")
-  endif()
-  
-  # Initialize and update submodules
-  execute_process(
-    COMMAND
-      ${GIT_PROGRAM} submodule update --init --recursive
-    WORKING_DIRECTORY
-      ${GIT_PATH}
-    ERROR_STRIP_TRAILING_WHITESPACE
-    ERROR_VARIABLE
-      GIT_ERROR
-    RESULT_VARIABLE
-      GIT_RESULT
-  )
-  
-  if(NOT GIT_RESULT EQUAL 0)
-    message(FATAL_ERROR "Git submodule init failed: ${GIT_ERROR}")
-  endif()
-  
-else()
-  # Use the original download method for other repositories
-  set(GIT_DOWNLOAD_URL https://github.com/${GIT_REPOSITORY}/archive/${GIT_REF}.tar.gz)
+set(GIT_DOWNLOAD_URL https://github.com/${GIT_REPOSITORY}/archive/${GIT_REF}.tar.gz)
 
-  message(STATUS "Cloning ${GIT_REPOSITORY} at ${GIT_REF}...")
-  execute_process(
-    COMMAND
-      ${CMAKE_COMMAND}
-        -DDOWNLOAD_URL=${GIT_DOWNLOAD_URL}
-        -DDOWNLOAD_PATH=${GIT_PATH}
-        -DDOWNLOAD_FILTERS=${GIT_FILTERS}
-        -P ${CMAKE_CURRENT_LIST_DIR}/DownloadUrl.cmake
-    ERROR_STRIP_TRAILING_WHITESPACE
-    ERROR_VARIABLE
-      GIT_ERROR
-    RESULT_VARIABLE
-      GIT_RESULT
-  )
-endif()
+message(STATUS "Cloning ${GIT_REPOSITORY} at ${GIT_REF}...")
+execute_process(
+  COMMAND
+    ${CMAKE_COMMAND}
+      -DDOWNLOAD_URL=${GIT_DOWNLOAD_URL}
+      -DDOWNLOAD_PATH=${GIT_PATH}
+      -DDOWNLOAD_FILTERS=${GIT_FILTERS}
+      -P ${CMAKE_CURRENT_LIST_DIR}/DownloadUrl.cmake
+  ERROR_STRIP_TRAILING_WHITESPACE
+  ERROR_VARIABLE
+    GIT_ERROR
+  RESULT_VARIABLE
+    GIT_RESULT
+)
 
 if(NOT GIT_RESULT EQUAL 0)
   message(FATAL_ERROR "Clone failed: ${GIT_ERROR}")

cmake/targets/BuildBun.cmake

@@ -65,7 +65,6 @@ set(BUN_DEPENDENCIES
   Mimalloc
   TinyCC
   Zlib
-  Lsquic # QUIC protocol support - depends on BoringSSL and Zlib
   LibArchive # must be loaded after zlib
   HdrHistogram # must be loaded after zlib
   Zstd
@@ -396,54 +395,6 @@ register_command(
     ${BUN_BAKE_RUNTIME_OUTPUTS}
 )
 
-set(BUN_BINDGENV2_SCRIPT ${CWD}/src/codegen/bindgenv2/script.ts)
-
-absolute_sources(BUN_BINDGENV2_SOURCES ${CWD}/cmake/sources/BindgenV2Sources.txt)
-# These sources include the script itself.
-absolute_sources(BUN_BINDGENV2_INTERNAL_SOURCES
-  ${CWD}/cmake/sources/BindgenV2InternalSources.txt)
-string(REPLACE ";" "," BUN_BINDGENV2_SOURCES_COMMA_SEPARATED
-  "${BUN_BINDGENV2_SOURCES}")
-
-execute_process(
-  COMMAND ${BUN_EXECUTABLE} run ${BUN_BINDGENV2_SCRIPT}
-    --command=list-outputs
-    --sources=${BUN_BINDGENV2_SOURCES_COMMA_SEPARATED}
-    --codegen-path=${CODEGEN_PATH}
-  RESULT_VARIABLE bindgen_result
-  OUTPUT_VARIABLE bindgen_outputs
-)
-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})
-  elseif(output MATCHES "\.zig$")
-    list(APPEND BUN_BINDGENV2_ZIG_OUTPUTS ${output})
-  else()
-    message(FATAL_ERROR "unexpected bindgen output: [${output}]")
-  endif()
-endforeach()
-
-register_command(
-  TARGET
-    bun-bindgen-v2
-  COMMENT
-    "Generating bindings (v2)"
-  COMMAND
-    ${BUN_EXECUTABLE} run ${BUN_BINDGENV2_SCRIPT}
-      --command=generate
-      --codegen-path=${CODEGEN_PATH}
-      --sources=${BUN_BINDGENV2_SOURCES_COMMA_SEPARATED}
-  SOURCES
-    ${BUN_BINDGENV2_SOURCES}
-    ${BUN_BINDGENV2_INTERNAL_SOURCES}
-  OUTPUTS
-    ${BUN_BINDGENV2_CPP_OUTPUTS}
-    ${BUN_BINDGENV2_ZIG_OUTPUTS}
-)
-
 set(BUN_BINDGEN_SCRIPT ${CWD}/src/codegen/bindgen.ts)
 
 absolute_sources(BUN_BINDGEN_SOURCES ${CWD}/cmake/sources/BindgenSources.txt)
@@ -622,7 +573,6 @@ set(BUN_ZIG_GENERATED_SOURCES
   ${BUN_ZIG_GENERATED_CLASSES_OUTPUTS}
   ${BUN_JAVASCRIPT_OUTPUTS}
   ${BUN_CPP_OUTPUTS}
-  ${BUN_BINDGENV2_ZIG_OUTPUTS}
 )
 
 # In debug builds, these are not embedded, but rather referenced at runtime.
@@ -686,7 +636,6 @@ register_command(
       -Denable_logs=$<IF:$<BOOL:${ENABLE_LOGS}>,true,false>
       -Denable_asan=$<IF:$<BOOL:${ENABLE_ZIG_ASAN}>,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}
       -Dversion=${VERSION}
       -Dreported_nodejs_version=${NODEJS_VERSION}
@@ -763,7 +712,6 @@ list(APPEND BUN_CPP_SOURCES
   ${BUN_JAVASCRIPT_OUTPUTS}
   ${BUN_OBJECT_LUT_OUTPUTS}
   ${BUN_BINDGEN_CPP_OUTPUTS}
-  ${BUN_BINDGENV2_CPP_OUTPUTS}
 )
 
 if(WIN32)
@@ -901,15 +849,10 @@ if(WIN32)
   )
 endif()
 
-if(USE_MIMALLOC_AS_DEFAULT_ALLOCATOR)
-  target_compile_definitions(${bun} PRIVATE USE_MIMALLOC=1)
-endif()
-
 target_compile_definitions(${bun} PRIVATE
   _HAS_EXCEPTIONS=0
   LIBUS_USE_OPENSSL=1
   LIBUS_USE_BORINGSSL=1
-  LIBUS_USE_QUIC=1
   WITH_BORINGSSL=1
   STATICALLY_LINKED_WITH_JavaScriptCore=1
   STATICALLY_LINKED_WITH_BMALLOC=1

cmake/targets/BuildLsquic.cmake

@@ -1,42 +0,0 @@
-register_repository(
-  NAME
-    lsquic
-  REPOSITORY
-    litespeedtech/lsquic
-  TAG
-    v4.3.0
-)
-
-set(Lsquic_CMAKE_C_FLAGS "")
-
-if (ENABLE_ASAN)
-  STRING(APPEND Lsquic_CMAKE_C_FLAGS "-fsanitize=address")
-endif()
-
-register_cmake_command(
-  TARGET
-    lsquic
-  LIBRARIES
-    lsquic
-  LIB_PATH
-    src/liblsquic
-  ARGS
-    -DSHARED=OFF
-    -DLSQUIC_SHARED_LIB=0
-    -DBORINGSSL_DIR=${VENDOR_PATH}/boringssl
-    -DBORINGSSL_LIB=${BUILD_PATH}/boringssl
-    -DZLIB_INCLUDE_DIR=${VENDOR_PATH}/zlib
-    -DZLIB_LIB=${BUILD_PATH}/zlib/libz.a
-    -DCMAKE_BUILD_TYPE=Release
-    -DCMAKE_POSITION_INDEPENDENT_CODE=ON
-    -DCMAKE_C_FLAGS="${Lsquic_CMAKE_C_FLAGS}"
-    -DLSQUIC_BIN=OFF
-    -DLSQUIC_TESTS=OFF
-    -DLSQUIC_WEBTRANSPORT=OFF
-  INCLUDES
-    include
-    src/liblsquic
-  DEPENDS
-    BoringSSL
-    Zlib
-)

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 69fa2714ab5f917c2d15501ff8cfdccfaea78882)
 endif()
 
 string(SUBSTRING ${WEBKIT_VERSION} 0 16 WEBKIT_VERSION_PREFIX)

docs/api/websockets.md

@@ -107,8 +107,6 @@ Bun.serve({
 
 Contextual `data` can be attached to a new WebSocket in the `.upgrade()` call. This data is made available on the `ws.data` property inside the WebSocket handlers.
 
-To strongly type `ws.data`, add a `data` property to the `websocket` handler object. This types `ws.data` across all lifecycle hooks.
-
 ```ts
 type WebSocketData = {
   createdAt: number;
@@ -116,7 +114,8 @@ type WebSocketData = {
   authToken: string;
 };
 
-Bun.serve({
+// TypeScript: specify the type of `data`
+Bun.serve<WebSocketData>({
   fetch(req, server) {
     const cookies = new Bun.CookieMap(req.headers.get("cookie")!);
 
@@ -132,12 +131,8 @@ Bun.serve({
     return undefined;
   },
   websocket: {
-    // TypeScript: specify the type of ws.data like this
-    data: {} as WebSocketData,
-
     // handler called when a message is received
     async message(ws, message) {
-      // ws.data is now properly typed as WebSocketData
       const user = getUserFromToken(ws.data.authToken);
 
       await saveMessageToDatabase({
@@ -150,10 +145,6 @@ Bun.serve({
 });
 ```
 
-{% callout %}
-**Note:** Previously, you could specify the type of `ws.data` using a type parameter on `Bun.serve`, like `Bun.serve<MyData>({...})`. This pattern was removed due to [a limitation in TypeScript](https://github.com/microsoft/TypeScript/issues/26242) in favor of the `data` property shown above.
-{% /callout %}
-
 To connect to this server from the browser, create a new `WebSocket`.
 
 ```ts#browser.js
@@ -173,7 +164,7 @@ socket.addEventListener("message", event => {
 Bun's `ServerWebSocket` implementation implements a native publish-subscribe API for topic-based broadcasting. Individual sockets can `.subscribe()` to a topic (specified with a string identifier) and `.publish()` messages to all other subscribers to that topic (excluding itself). This topic-based broadcast API is similar to [MQTT](https://en.wikipedia.org/wiki/MQTT) and [Redis Pub/Sub](https://redis.io/topics/pubsub).
 
 ```ts
-const server = Bun.serve({
+const server = Bun.serve<{ username: string }>({
   fetch(req, server) {
     const url = new URL(req.url);
     if (url.pathname === "/chat") {
@@ -188,9 +179,6 @@ const server = Bun.serve({
     return new Response("Hello world");
   },
   websocket: {
-    // TypeScript: specify the type of ws.data like this
-    data: {} as { username: string },
-
     open(ws) {
       const msg = `${ws.data.username} has entered the chat`;
       ws.subscribe("the-group-chat");

docs/bundler/executables.md

@@ -586,41 +586,12 @@ 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`).
+- `--outdir` — use `outfile` instead.
+- `--splitting`
 - `--public-path`
 - `--target=node` or `--target=browser`
 - `--no-bundle` - we always bundle everything into the executable.

docs/cli/install.md

@@ -221,38 +221,6 @@ Bun uses a global cache at `~/.bun/install/cache/` to minimize disk usage. Packa
 
 For complete documentation refer to [Package manager > Global cache](https://bun.com/docs/install/cache).
 
-## Minimum release age
-
-To protect against supply chain attacks where malicious packages are quickly published, you can configure a minimum age requirement for npm packages. Package versions published more recently than the specified threshold (in seconds) will be filtered out during installation.
-
-```bash
-# Only install package versions published at least 3 days ago
-$ bun add @types/bun --minimum-release-age 259200 # seconds
-```
-
-You can also configure this in `bunfig.toml`:
-
-```toml
-[install]
-# Only install package versions published at least 3 days ago
-minimumReleaseAge = 259200 # seconds
-
-# Exclude trusted packages from the age gate
-minimumReleaseAgeExcludes = ["@types/node", "typescript"]
-```
-
-When the minimum age filter is active:
-
-- Only affects new package resolution - existing packages in `bun.lock` remain unchanged
-- All dependencies (direct and transitive) are filtered to meet the age requirement when being resolved
-- When versions are blocked by the age gate, a stability check detects rapid bugfix patterns
-  - If multiple versions were published close together just outside your age gate, it extends the filter to skip those potentially unstable versions and selects an older, more mature version
-  - Searches up to 7 days after the age gate, however if still finding rapid releases it ignores stability check
-  - Exact version requests (like `package@1.1.1`) still respect the age gate but bypass the stability check
-- Versions without a `time` field are treated as passing the age check (npm registry should always provide timestamps)
-
-For more advanced security scanning, including integration with services & custom filtering, see [Package manager > Security Scanner API](https://bun.com/docs/install/security-scanner-api).
-
 ## Configuration
 
 The default behavior of `bun install` can be configured in `bunfig.toml`. The default values are shown below.
@@ -287,10 +255,6 @@ concurrentScripts = 16 # (cpu count or GOMAXPROCS) x2
 # installation strategy: "hoisted" or "isolated"
 # default: "hoisted"
 linker = "hoisted"
-
-# minimum age config
-minimumReleaseAge = 259200 # seconds
-minimumReleaseAgeExcludes = ["@types/node", "typescript"]
 ```
 
 ## CI/CD

docs/cli/publish.md

@@ -84,12 +84,14 @@ $ bun publish --dry-run
 
 ### `--tolerate-republish`
 
-Exit with code 0 instead of 1 if the package version already exists. Useful in CI/CD where jobs may be re-run.
+The `--tolerate-republish` flag makes `bun publish` exit with code 0 instead of code 1 when attempting to republish over an existing version number. This is useful in automated workflows where republishing the same version might occur and should not be treated as an error.
 
 ```sh
 $ bun publish --tolerate-republish
 ```
 
+Without this flag, attempting to publish a version that already exists will result in an error and exit code 1. With this flag, the command will exit successfully even when trying to republish an existing version.
+
 ### `--gzip-level`
 
 Specify the level of gzip compression to use when packing the package. Only applies to `bun publish` without a tarball path argument. Values range from `0` to `9` (default is `9`).

docs/guides/websocket/context.md

@@ -7,7 +7,7 @@ When building a WebSocket server, it's typically necessary to store some identif
 With [Bun.serve()](https://bun.com/docs/api/websockets#contextual-data), this "contextual data" is set when the connection is initially upgraded by passing a `data` parameter in the `server.upgrade()` call.
 
 ```ts
-Bun.serve({
+Bun.serve<{ socketId: number }>({
   fetch(req, server) {
     const success = server.upgrade(req, {
       data: {
@@ -20,9 +20,6 @@ Bun.serve({
     // ...
   },
   websocket: {
-    // TypeScript: specify the type of ws.data like this
-    data: {} as { socketId: number },
-
     // define websocket handlers
     async message(ws, message) {
       // the contextual data is available as the `data` property
@@ -44,7 +41,8 @@ type WebSocketData = {
   userId: string;
 };
 
-Bun.serve({
+// TypeScript: specify the type of `data`
+Bun.serve<WebSocketData>({
   async fetch(req, server) {
     // use a library to parse cookies
     const cookies = parseCookies(req.headers.get("Cookie"));
@@ -62,9 +60,6 @@ Bun.serve({
     if (upgraded) return undefined;
   },
   websocket: {
-    // TypeScript: specify the type of ws.data like this
-    data: {} as WebSocketData,
-
     async message(ws, message) {
       // save the message to a database
       await saveMessageToDatabase({

docs/guides/websocket/pubsub.md

@@ -7,7 +7,7 @@ Bun's server-side `WebSocket` API provides a native pub-sub API. Sockets can be
 This code snippet implements a simple single-channel chat server.
 
 ```ts
-const server = Bun.serve({
+const server = Bun.serve<{ username: string }>({
   fetch(req, server) {
     const cookies = req.headers.get("cookie");
     const username = getUsernameFromCookies(cookies);
@@ -17,9 +17,6 @@ const server = Bun.serve({
     return new Response("Hello world");
   },
   websocket: {
-    // TypeScript: specify the type of ws.data like this
-    data: {} as { username: string },
-
     open(ws) {
       const msg = `${ws.data.username} has entered the chat`;
       ws.subscribe("the-group-chat");

docs/guides/websocket/simple.md

@@ -7,7 +7,7 @@ Start a simple WebSocket server using [`Bun.serve`](https://bun.com/docs/api/htt
 Inside `fetch`, we attempt to upgrade incoming `ws:` or `wss:` requests to WebSocket connections.
 
 ```ts
-const server = Bun.serve({
+const server = Bun.serve<{ authToken: string }>({
   fetch(req, server) {
     const success = server.upgrade(req);
     if (success) {

docs/install/index.md

@@ -89,12 +89,6 @@ $ bun install --linker isolated
 
 Isolated installs create strict dependency isolation similar to pnpm, preventing phantom dependencies and ensuring more deterministic builds. For complete documentation, see [Isolated installs](https://bun.com/docs/install/isolated).
 
-To protect against supply chain attacks, set a minimum age (in seconds) for package versions:
-
-```bash
-$ bun install --minimum-release-age 259200 # 3 days
-```
-
 {% details summary="Configuring behavior" %}
 The default behavior of `bun install` can be configured in `bunfig.toml`:
 
@@ -128,12 +122,6 @@ concurrentScripts = 16 # (cpu count or GOMAXPROCS) x2
 # installation strategy: "hoisted" or "isolated"
 # default: "hoisted"
 linker = "hoisted"
-
-# minimum package age in seconds (protects against supply chain attacks)
-minimumReleaseAge = 259200 # 3 days
-
-# exclude packages from age requirement
-minimumReleaseAgeExcludes = ["@types/node", "typescript"]
 ```
 
 {% /details %}

docs/install/isolated.md

@@ -36,10 +36,7 @@ linker = "isolated"
 
 ### Default behavior
 
-- **Workspaces**: Bun uses **isolated** installs by default to prevent hoisting-related bugs
-- **Single projects**: Bun uses **hoisted** installs by default
-
-To override the default, use `--linker hoisted` or `--linker isolated`, or set it in your configuration file.
+By default, Bun uses the **hoisted** installation strategy for all projects. To use isolated installs, you must explicitly specify the `--linker isolated` flag or set it in your configuration file.
 
 ## How isolated installs work
 
@@ -177,13 +174,14 @@ The main difference is that Bun uses symlinks in `node_modules` while pnpm uses
 
 ## When to use isolated installs
 
-**Isolated installs are the default for workspaces.** You may want to explicitly enable them for single projects when:
+**Use isolated installs when:**
 
+- Working in monorepos with multiple packages
 - Strict dependency management is required
 - Preventing phantom dependencies is important
 - Building libraries that need deterministic dependencies
 
-**Switch to hoisted installs (including for workspaces) when:**
+**Use hoisted installs when:**
 
 - Working with legacy code that assumes flat `node_modules`
 - Compatibility with existing build tools is required

docs/install/workspaces.md

@@ -38,21 +38,9 @@ In the root `package.json`, the `"workspaces"` key is used to indicate which sub
 ```
 
 {% callout %}
-**Glob support** — Bun supports full glob syntax in `"workspaces"`, including negative patterns (e.g. `!**/excluded/**`). See [here](https://bun.com/docs/api/glob#supported-glob-patterns) for a comprehensive list of supported syntax.
+**Glob support** — Bun supports full glob syntax in `"workspaces"` (see [here](https://bun.com/docs/api/glob#supported-glob-patterns) for a comprehensive list of supported syntax), _except_ for exclusions (e.g. `!**/excluded/**`), which are not implemented yet.
 {% /callout %}
 
-```json
-{
-  "name": "my-project",
-  "version": "1.0.0",
-  "workspaces": [
-    "packages/**",
-    "!packages/**/test/**",
-    "!packages/**/template/**"
-  ]
-}
-```
-
 Each workspace has it's own `package.json`. When referencing other packages in the monorepo, semver or workspace protocols (e.g. `workspace:*`) can be used as the version field in your `package.json`.
 
 ```json

docs/runtime/bunfig.md

@@ -249,46 +249,6 @@ This is useful for:
 
 The `--concurrent` CLI flag will override this setting when specified.
 
-### `test.randomize`
-
-Run tests in random order. Default `false`.
-
-```toml
-[test]
-randomize = true
-```
-
-This helps catch bugs related to test interdependencies by running tests in a different order each time. When combined with `seed`, the random order becomes reproducible.
-
-The `--randomize` CLI flag will override this setting when specified.
-
-### `test.seed`
-
-Set the random seed for test randomization. This option requires `randomize` to be `true`.
-
-```toml
-[test]
-randomize = true
-seed = 2444615283
-```
-
-Using a seed makes the randomized test order reproducible across runs, which is useful for debugging flaky tests. When you encounter a test failure with randomization enabled, you can use the same seed to reproduce the exact test order.
-
-The `--seed` CLI flag will override this setting when specified.
-
-### `test.rerunEach`
-
-Re-run each test file a specified number of times. Default `0` (run once).
-
-```toml
-[test]
-rerunEach = 3
-```
-
-This is useful for catching flaky tests or non-deterministic behavior. Each test file will be executed the specified number of times.
-
-The `--rerun-each` CLI flag will override this setting when specified.
-
 ## Package manager
 
 Package management is a complex issue; to support a range of use cases, the behavior of `bun install` can be configured under the `[install]` section.
@@ -610,20 +570,6 @@ Valid values are:
 
 {% /table %}
 
-### `install.minimumReleaseAge`
-
-Configure a minimum age (in seconds) for npm package versions. Package versions published more recently than this threshold will be filtered out during installation. Default is `null` (disabled).
-
-```toml
-[install]
-# Only install package versions published at least 3 days ago
-minimumReleaseAge = 259200
-# These packages will bypass the 3-day minimum age requirement
-minimumReleaseAgeExcludes = ["@types/bun", "typescript"]
-```
-
-For more details see [Minimum release age](https://bun.com/docs/cli/install#minimum-release-age) in the install documentation.
-
 <!-- ## Debugging -->
 
 <!--
@@ -651,7 +597,7 @@ editor = "code"
 
 The `bun run` command can be configured under the `[run]` section. These apply to the `bun run` command and the `bun` command when running a file or executable or script.
 
-Currently, `bunfig.toml` is only automatically loaded for `bun run` in a local project (it doesn't check for a global `.bunfig.toml`).
+Currently, `bunfig.toml` isn't always automatically loaded for `bun run` in a local project (it does check for a global `bunfig.toml`), so you might still need to pass `-c` or `-c=bunfig.toml` to use these settings.
 
 ### `run.shell` - use the system shell or Bun's shell
 

docs/runtime/modules.md

@@ -174,27 +174,11 @@ import { stuff } from "foo";
 
 The full specification of this algorithm are officially documented in the [Node.js documentation](https://nodejs.org/api/modules.html); we won't rehash it here. Briefly: if you import `from "foo"`, Bun scans up the file system for a `node_modules` directory containing the package `foo`.
 
-### NODE_PATH
-
-Bun supports `NODE_PATH` for additional module resolution directories:
+Bun also supports the `NODE_PATH` environment variable for resolving modules from additional directories outside of `node_modules`.
 
 ```bash
-NODE_PATH=./packages bun run src/index.js
-```
-
-```ts
-// packages/foo/index.js
-export const hello = "world";
-
-// src/index.js
-import { hello } from "foo";
-```
-
-Multiple paths use the platform's delimiter (`:` on Unix, `;` on Windows):
-
-```bash
-NODE_PATH=./packages:./lib bun run src/index.js  # Unix/macOS
-NODE_PATH=./packages;./lib bun run src/index.js  # Windows
+$ export NODE_PATH="/path/to/global/modules"
+$ bun run my-script.js
 ```
 
 Once it finds the `foo` package, Bun reads the `package.json` to determine how the package should be imported. To determine the package's entrypoint, Bun first reads the `exports` field and checks for the following conditions.

docs/runtime/nodejs-apis.md

@@ -40,7 +40,7 @@ This page is updated regularly to reflect compatibility status of the latest ver
 
 ### [`node:http`](https://nodejs.org/api/http.html)
 
-🟢 Fully implemented. Outgoing client request body is currently buffered instead of streamed.
+🟢 Fully implemented. Outgoing client request body is currently buffered instead of streamed. Re-exports `WebSocket`, `CloseEvent`, and `MessageEvent` globals for Node.js compatibility.
 
 ### [`node:https`](https://nodejs.org/api/https.html)
 

docs/test/configuration.md

@@ -65,34 +65,6 @@ Test files matching this pattern will behave as if the `--concurrent` flag was p
 
 The `--concurrent` CLI flag will override this setting when specified, forcing all tests to run concurrently regardless of the glob pattern.
 
-#### randomize
-
-Run tests in random order to identify tests with hidden dependencies:
-
-```toml
-[test]
-randomize = true
-```
-
-#### seed
-
-Specify a seed for reproducible random test order. Requires `randomize = true`:
-
-```toml
-[test]
-randomize = true
-seed = 2444615283
-```
-
-#### rerunEach
-
-Re-run each test file multiple times to identify flaky tests:
-
-```toml
-[test]
-rerunEach = 3
-```
-
 ### Coverage options
 
 In addition to the options documented in the [coverage documentation](./coverage.md), the following options are available:

docs/test/reporters.md

@@ -34,15 +34,6 @@ test/package-json-lint.test.ts:
 Ran 4 tests across 1 files. [0.66ms]
 ```
 
-### Dots Reporter
-
-The dots reporter shows `.` for passing tests and `F` for failures—useful for large test suites.
-
-```sh
-$ bun test --dots
-$ bun test --reporter=dots
-```
-
 ### JUnit XML Reporter
 
 For CI/CD environments, Bun supports generating JUnit XML reports. JUnit XML is a widely-adopted format for test results that can be parsed by many CI/CD systems, including GitLab, Jenkins, and others.

flake.lock

@@ -1,61 +0,0 @@
-{
-  "nodes": {
-    "flake-utils": {
-      "inputs": {
-        "systems": "systems"
-      },
-      "locked": {
-        "lastModified": 1731533236,
-        "narHash": "sha256-l0KFg5HjrsfsO/JpG+r7fRrqm12kzFHyUHqHCVpMMbI=",
-        "owner": "numtide",
-        "repo": "flake-utils",
-        "rev": "11707dc2f618dd54ca8739b309ec4fc024de578b",
-        "type": "github"
-      },
-      "original": {
-        "owner": "numtide",
-        "repo": "flake-utils",
-        "type": "github"
-      }
-    },
-    "nixpkgs": {
-      "locked": {
-        "lastModified": 1759831965,
-        "narHash": "sha256-vgPm2xjOmKdZ0xKA6yLXPJpjOtQPHfaZDRtH+47XEBo=",
-        "owner": "NixOS",
-        "repo": "nixpkgs",
-        "rev": "c9b6fb798541223bbb396d287d16f43520250518",
-        "type": "github"
-      },
-      "original": {
-        "owner": "NixOS",
-        "ref": "nixos-unstable",
-        "repo": "nixpkgs",
-        "type": "github"
-      }
-    },
-    "root": {
-      "inputs": {
-        "flake-utils": "flake-utils",
-        "nixpkgs": "nixpkgs"
-      }
-    },
-    "systems": {
-      "locked": {
-        "lastModified": 1681028828,
-        "narHash": "sha256-Vy1rq5AaRuLzOxct8nz4T6wlgyUR7zLU309k9mBC768=",
-        "owner": "nix-systems",
-        "repo": "default",
-        "rev": "da67096a3b9bf56a91d16901293e51ba5b49a27e",
-        "type": "github"
-      },
-      "original": {
-        "owner": "nix-systems",
-        "repo": "default",
-        "type": "github"
-      }
-    }
-  },
-  "root": "root",
-  "version": 7
-}

flake.nix

@@ -1,175 +0,0 @@
-{
-  description = "Bun - A fast all-in-one JavaScript runtime";
-
-  # Uncomment this when you set up Cachix to enable automatic binary cache
-  # nixConfig = {
-  #   extra-substituters = [
-  #     "https://bun-dev.cachix.org"
-  #   ];
-  #   extra-trusted-public-keys = [
-  #     "bun-dev.cachix.org-1:REPLACE_WITH_YOUR_PUBLIC_KEY"
-  #   ];
-  # };
-
-  inputs = {
-    nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable";
-    flake-utils.url = "github:numtide/flake-utils";
-  };
-
-  outputs = { self, nixpkgs, flake-utils }:
-    flake-utils.lib.eachDefaultSystem (system:
-      let
-        pkgs = import nixpkgs {
-          inherit system;
-          config = {
-            allowUnfree = true;
-          };
-        };
-
-        # LLVM 19 - matching the bootstrap script (targets 19.1.7, actual version from nixpkgs-unstable)
-        llvm = pkgs.llvm_19;
-        clang = pkgs.clang_19;
-        lld = pkgs.lld_19;
-
-        # Node.js 24 - matching the bootstrap script (targets 24.3.0, actual version from nixpkgs-unstable)
-        nodejs = pkgs.nodejs_24;
-
-        # Build tools and dependencies
-        packages = [
-          # Core build tools
-          pkgs.cmake # Expected: 3.30+ on nixos-unstable as of 2025-10
-          pkgs.ninja
-          pkgs.pkg-config
-          pkgs.ccache
-
-          # Compilers and toolchain - version pinned to LLVM 19
-          clang
-          llvm
-          lld
-          pkgs.gcc
-          pkgs.rustc
-          pkgs.cargo
-          pkgs.go
-
-          # Bun itself (for running build scripts via `bun bd`)
-          pkgs.bun
-
-          # Node.js - version pinned to 24
-          nodejs
-
-          # Python for build scripts
-          pkgs.python3
-
-          # Other build dependencies from bootstrap.sh
-          pkgs.libtool
-          pkgs.ruby
-          pkgs.perl
-
-          # Libraries
-          pkgs.openssl
-          pkgs.zlib
-          pkgs.libxml2
-          pkgs.libiconv
-
-          # Development tools
-          pkgs.git
-          pkgs.curl
-          pkgs.wget
-          pkgs.unzip
-          pkgs.xz
-
-          # Additional dependencies for Linux
-        ] ++ pkgs.lib.optionals pkgs.stdenv.isLinux [
-          pkgs.gdb # for debugging core dumps (from bootstrap.sh line 1535)
-
-          # Chromium dependencies for Puppeteer testing (from bootstrap.sh lines 1397-1483)
-          # X11 and graphics libraries
-          pkgs.xorg.libX11
-          pkgs.xorg.libxcb
-          pkgs.xorg.libXcomposite
-          pkgs.xorg.libXcursor
-          pkgs.xorg.libXdamage
-          pkgs.xorg.libXext
-          pkgs.xorg.libXfixes
-          pkgs.xorg.libXi
-          pkgs.xorg.libXrandr
-          pkgs.xorg.libXrender
-          pkgs.xorg.libXScrnSaver
-          pkgs.xorg.libXtst
-          pkgs.libxkbcommon
-          pkgs.mesa
-          pkgs.nspr
-          pkgs.nss
-          pkgs.cups
-          pkgs.dbus
-          pkgs.expat
-          pkgs.fontconfig
-          pkgs.freetype
-          pkgs.glib
-          pkgs.gtk3
-          pkgs.pango
-          pkgs.cairo
-          pkgs.alsa-lib
-          pkgs.at-spi2-atk
-          pkgs.at-spi2-core
-          pkgs.libgbm # for hardware acceleration
-          pkgs.liberation_ttf # fonts-liberation
-          pkgs.atk
-          pkgs.libdrm
-          pkgs.xorg.libxshmfence
-          pkgs.gdk-pixbuf
-        ] ++ pkgs.lib.optionals pkgs.stdenv.isDarwin [
-          # macOS specific dependencies
-          pkgs.darwin.apple_sdk.frameworks.CoreFoundation
-          pkgs.darwin.apple_sdk.frameworks.CoreServices
-          pkgs.darwin.apple_sdk.frameworks.Security
-        ];
-
-      in
-      {
-        devShells.default = (pkgs.mkShell.override {
-          stdenv = pkgs.clangStdenv;
-        }) {
-          inherit packages;
-
-          shellHook = ''
-            # Set up build environment
-            export CC="${pkgs.lib.getExe clang}"
-            export CXX="${pkgs.lib.getExe' clang "clang++"}"
-            export AR="${llvm}/bin/llvm-ar"
-            export RANLIB="${llvm}/bin/llvm-ranlib"
-            export CMAKE_C_COMPILER="$CC"
-            export CMAKE_CXX_COMPILER="$CXX"
-            export CMAKE_AR="$AR"
-            export CMAKE_RANLIB="$RANLIB"
-            export CMAKE_SYSTEM_PROCESSOR="$(uname -m)"
-            export TMPDIR="''${TMPDIR:-/tmp}"
-          '' + pkgs.lib.optionalString pkgs.stdenv.isLinux ''
-            export LD="${pkgs.lib.getExe' lld "ld.lld"}"
-            export NIX_CFLAGS_LINK="''${NIX_CFLAGS_LINK:+$NIX_CFLAGS_LINK }-fuse-ld=lld"
-            export LD_LIBRARY_PATH="${pkgs.lib.makeLibraryPath packages}''${LD_LIBRARY_PATH:+:$LD_LIBRARY_PATH}"
-          '' + ''
-
-            # Print welcome message
-            echo "====================================="
-            echo "Bun Development Environment"
-            echo "====================================="
-            echo "Node.js: $(node --version 2>/dev/null || echo 'not found')"
-            echo "Bun: $(bun --version 2>/dev/null || echo 'not found')"
-            echo "Clang: $(clang --version 2>/dev/null | head -n1 || echo 'not found')"
-            echo "CMake: $(cmake --version 2>/dev/null | head -n1 || echo 'not found')"
-            echo "LLVM: ${llvm.version}"
-            echo ""
-            echo "Quick start:"
-            echo "  bun bd                    # Build debug binary"
-            echo "  bun bd test <test-file>   # Run tests"
-            echo "====================================="
-          '';
-
-          # Additional environment variables
-          CMAKE_BUILD_TYPE = "Debug";
-          ENABLE_CCACHE = "1";
-        };
-      }
-    );
-}

misctools/lldb/init.lldb

@@ -8,8 +8,6 @@
 # Thread::initializePlatformThreading() in ThreadingPOSIX.cpp) to the JS thread to suspend or resume
 # it. So stopping the process would just create noise when debugging any long-running script.
 process handle -p true -s false -n false SIGPWR
-process handle -p true -s false -n false SIGUSR1
-process handle -p true -s false -n false SIGUSR2
 
 command script import -c lldb_pretty_printers.py
 type category enable zig.lang

package.json

@@ -1,7 +1,7 @@
 {
   "private": true,
   "name": "bun",
-  "version": "1.3.1",
+  "version": "1.2.24",
   "workspaces": [
     "./packages/bun-types",
     "./packages/@types/bun"
@@ -11,14 +11,14 @@
     "@lezer/cpp": "^1.1.3",
     "@types/bun": "workspace:*",
     "bun-tracestrings": "github:oven-sh/bun.report#912ca63e26c51429d3e6799aa2a6ab079b188fd8",
-    "esbuild": "^0.21.5",
-    "mitata": "^0.1.14",
+    "esbuild": "^0.21.4",
+    "mitata": "^0.1.11",
     "peechy": "0.4.34",
-    "prettier": "^3.6.2",
-    "prettier-plugin-organize-imports": "^4.3.0",
+    "prettier": "^3.5.3",
+    "prettier-plugin-organize-imports": "^4.0.0",
     "react": "^18.3.1",
     "react-dom": "^18.3.1",
-    "source-map-js": "^1.2.1",
+    "source-map-js": "^1.2.0",
     "typescript": "5.9.2"
   },
   "resolutions": {

packages/bun-types/bun.ns.d.ts

@@ -3,3 +3,5 @@ import * as BunModule from "bun";
 declare global {
   export import Bun = BunModule;
 }
+
+export {};

packages/bun-types/deprecated.d.ts

@@ -98,11 +98,6 @@ declare module "bun" {
     ): void;
   }
 
-  /**
-   * @deprecated Use {@link Serve.Options Bun.Serve.Options<T, R>} instead
-   */
-  type ServeOptions<T = undefined, R extends string = never> = Serve.Options<T, R>;
-
   /** @deprecated Use {@link SQL.Query Bun.SQL.Query} */
   type SQLQuery<T = any> = SQL.Query<T>;
 

packages/bun-types/globals.d.ts

@@ -7,13 +7,6 @@ declare module "bun" {
     type LibWorkerOrBunWorker = LibDomIsLoaded extends true ? {} : Bun.Worker;
     type LibEmptyOrBunWebSocket = LibDomIsLoaded extends true ? {} : Bun.WebSocket;
 
-    type LibEmptyOrNodeStreamWebCompressionStream = LibDomIsLoaded extends true
-      ? {}
-      : import("node:stream/web").CompressionStream;
-    type LibEmptyOrNodeStreamWebDecompressionStream = LibDomIsLoaded extends true
-      ? {}
-      : import("node:stream/web").DecompressionStream;
-
     type LibPerformanceOrNodePerfHooksPerformance = LibDomIsLoaded extends true ? {} : import("perf_hooks").Performance;
     type LibEmptyOrPerformanceEntry = LibDomIsLoaded extends true ? {} : import("node:perf_hooks").PerformanceEntry;
     type LibEmptyOrPerformanceMark = LibDomIsLoaded extends true ? {} : import("node:perf_hooks").PerformanceMark;
@@ -278,30 +271,6 @@ declare var Event: {
   new (type: string, eventInitDict?: Bun.EventInit): Event;
 };
 
-/**
- * Unimplemented in Bun
- */
-interface CompressionStream extends Bun.__internal.LibEmptyOrNodeStreamWebCompressionStream {}
-/**
- * Unimplemented in Bun
- */
-declare var CompressionStream: Bun.__internal.UseLibDomIfAvailable<
-  "CompressionStream",
-  typeof import("node:stream/web").CompressionStream
->;
-
-/**
- * Unimplemented in Bun
- */
-interface DecompressionStream extends Bun.__internal.LibEmptyOrNodeStreamWebCompressionStream {}
-/**
- * Unimplemented in Bun
- */
-declare var DecompressionStream: Bun.__internal.UseLibDomIfAvailable<
-  "DecompressionStream",
-  typeof import("node:stream/web").DecompressionStream
->;
-
 interface EventTarget {
   /**
    * Adds a new handler for the `type` event. Any given `listener` is added only once per `type` and per `capture` option value.
@@ -891,10 +860,7 @@ interface ErrnoException extends Error {
   syscall?: string | undefined;
 }
 
-/**
- * An abnormal event (called an exception) which occurs as a result of calling a
- * method or accessing a property of a web API
- */
+/** An abnormal event (called an exception) which occurs as a result of calling a method or accessing a property of a web API. */
 interface DOMException extends Error {
   readonly message: string;
   readonly name: string;
@@ -924,35 +890,11 @@ interface DOMException extends Error {
   readonly INVALID_NODE_TYPE_ERR: 24;
   readonly DATA_CLONE_ERR: 25;
 }
-declare var DOMException: {
-  prototype: DOMException;
-  new (message?: string, name?: string): DOMException;
-  readonly INDEX_SIZE_ERR: 1;
-  readonly DOMSTRING_SIZE_ERR: 2;
-  readonly HIERARCHY_REQUEST_ERR: 3;
-  readonly WRONG_DOCUMENT_ERR: 4;
-  readonly INVALID_CHARACTER_ERR: 5;
-  readonly NO_DATA_ALLOWED_ERR: 6;
-  readonly NO_MODIFICATION_ALLOWED_ERR: 7;
-  readonly NOT_FOUND_ERR: 8;
-  readonly NOT_SUPPORTED_ERR: 9;
-  readonly INUSE_ATTRIBUTE_ERR: 10;
-  readonly INVALID_STATE_ERR: 11;
-  readonly SYNTAX_ERR: 12;
-  readonly INVALID_MODIFICATION_ERR: 13;
-  readonly NAMESPACE_ERR: 14;
-  readonly INVALID_ACCESS_ERR: 15;
-  readonly VALIDATION_ERR: 16;
-  readonly TYPE_MISMATCH_ERR: 17;
-  readonly SECURITY_ERR: 18;
-  readonly NETWORK_ERR: 19;
-  readonly ABORT_ERR: 20;
-  readonly URL_MISMATCH_ERR: 21;
-  readonly QUOTA_EXCEEDED_ERR: 22;
-  readonly TIMEOUT_ERR: 23;
-  readonly INVALID_NODE_TYPE_ERR: 24;
-  readonly DATA_CLONE_ERR: 25;
-};
+
+// declare var DOMException: {
+//   prototype: DOMException;
+//   new (message?: string, name?: string): DOMException;
+// };
 
 declare function alert(message?: string): void;
 declare function confirm(message?: string): boolean;
@@ -1663,6 +1605,12 @@ declare var AbortSignal: Bun.__internal.UseLibDomIfAvailable<
   }
 >;
 
+interface DOMException {}
+declare var DOMException: Bun.__internal.UseLibDomIfAvailable<
+  "DOMException",
+  { prototype: DOMException; new (): DOMException }
+>;
+
 interface FormData {
   /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/FormData/append) */
   append(name: string, value: string | Blob): void;

packages/bun-types/index.d.ts

@@ -21,7 +21,6 @@
 /// <reference path="./redis.d.ts" />
 /// <reference path="./shell.d.ts" />
 /// <reference path="./experimental.d.ts" />
-/// <reference path="./serve.d.ts" />
 /// <reference path="./sql.d.ts" />
 /// <reference path="./security.d.ts" />
 

packages/bun-types/test.d.ts

@@ -390,20 +390,11 @@ declare module "bun:test" {
      */
     repeats?: number;
   }
-
-  namespace __internal {
-    type IsTuple<T> = T extends readonly unknown[]
-      ? number extends T["length"]
-        ? false // It's an array with unknown length, not a tuple
-        : true // It's an array with a fixed length (a tuple)
-      : false; // Not an array at all
-
-    /**
-     * Accepts `[1, 2, 3] | ["a", "b", "c"]` and returns `[1 | "a", 2 | "b", 3 | "c"]`
-     */
-    type Flatten<T, Copy extends T = T> = { [Key in keyof T]: Copy[Key] };
-  }
-
+  type IsTuple<T> = T extends readonly unknown[]
+    ? number extends T["length"]
+      ? false // It's an array with unknown length, not a tuple
+      : true // It's an array with a fixed length (a tuple)
+    : false; // Not an array at all
   /**
    * Runs a test.
    *
@@ -427,16 +418,10 @@ declare module "bun:test" {
    *
    * @category Testing
    */
-  export interface Test<T extends ReadonlyArray<unknown>> {
+  export interface Test<T extends Readonly<any[]>> {
     (
       label: string,
-
-      fn: (
-        ...args: __internal.IsTuple<T> extends true
-          ? [...table: __internal.Flatten<T>, done: (err?: unknown) => void]
-          : T
-      ) => void | Promise<unknown>,
-
+      fn: (...args: IsTuple<T> extends true ? [...T, (err?: unknown) => void] : T) => void | Promise<unknown>,
       /**
        * - If a `number`, sets the timeout for the test in milliseconds.
        * - If an `object`, sets the options for the test.
@@ -528,8 +513,8 @@ declare module "bun:test" {
      *
      * @param table Array of Arrays with the arguments that are passed into the test fn for each row.
      */
-    each<T extends Readonly<[unknown, ...unknown[]]>>(table: readonly T[]): Test<T>;
-    each<T extends unknown[]>(table: readonly T[]): Test<T>;
+    each<T extends Readonly<[any, ...any[]]>>(table: readonly T[]): Test<[...T]>;
+    each<T extends any[]>(table: readonly T[]): Test<[...T]>;
     each<T>(table: T[]): Test<[T]>;
   }
   /**

packages/bun-usockets/QUIC.md

@@ -1,668 +0,0 @@
-# QUIC Implementation Design
-
-## Overview
-
-This document describes the design of QUIC support in uSockets, following established uSockets patterns while integrating with the lsquic library for QUIC protocol implementation.
-
-## Core Architecture
-
-### Type Hierarchy
-
-The QUIC implementation uses three core types that mirror the TCP socket design:
-
-```c
-// Socket that handles UDP transport and QUIC connections
-struct us_quic_socket_t {
-    struct us_udp_socket_t udp_socket;      // Inline UDP socket
-    us_quic_socket_context_t *context;      // Reference to context
-    
-    struct us_quic_socket_t *next;          // For deferred free list
-    int is_closed;                           // Marked for cleanup
-    
-    // Extension data follows
-};
-
-// Individual QUIC connection (multiplexed over socket)
-struct us_quic_connection_t {
-    us_quic_socket_t *socket;               // Parent socket for I/O
-    lsquic_conn_t *lsquic_conn;            // Opaque QUIC connection
-    void *peer_ctx;                         // For lsquic callbacks
-    
-    struct us_quic_connection_t *next;      // For deferred free list
-    int is_closed;                          // Marked for cleanup
-    
-    // Extension data follows
-};
-
-// Listen socket is just an alias - same structure
-typedef struct us_quic_socket_t us_quic_listen_socket_t;
-```
-
-### Context Structure
-
-The context holds configuration, engine, and manages deferred cleanup:
-
-```c
-struct us_quic_socket_context_s {
-    struct us_loop_t *loop;
-    lsquic_engine_t *engine;                // Single QUIC engine
-    int is_server;                           // 0 = client, 1 = server
-    
-    // Deferred cleanup lists (swept each loop iteration)
-    struct us_quic_connection_t *closing_connections;
-    struct us_quic_socket_t *closing_sockets;
-    
-    // SSL/TLS configuration
-    SSL_CTX *ssl_context;
-    struct us_bun_socket_context_options_t options;
-    
-    // Connection callbacks
-    void(*on_open)(us_quic_socket_t *s, int is_client);
-    void(*on_close)(us_quic_socket_t *s);
-    
-    // Stream callbacks (for HTTP/3)
-    void(*on_stream_open)(us_quic_stream_t *s, int is_client);
-    void(*on_stream_close)(us_quic_stream_t *s);
-    void(*on_stream_data)(us_quic_stream_t *s, char *data, int length);
-    void(*on_stream_end)(us_quic_stream_t *s);
-    void(*on_stream_writable)(us_quic_stream_t *s);
-    void(*on_stream_headers)(us_quic_stream_t *s);
-    
-    // Extension data follows
-};
-```
-
-## Key Design Principles
-
-### 1. Connection Multiplexing
-
-QUIC fundamentally differs from TCP - multiple QUIC connections share a single UDP socket:
-
-- **Server**: One `us_quic_socket_t` accepts all connections on a port
-- **Client**: One `us_quic_socket_t` can connect to multiple servers
-- **Demultiplexing**: lsquic engine routes packets using Connection IDs
-
-### 2. Memory Management
-
-Following uSockets patterns for safe cleanup:
-
-- **No immediate frees**: Never free memory in callbacks
-- **Deferred cleanup**: Add to linked lists, sweep on next loop iteration
-- **Reference management**: lsquic owns `lsquic_conn_t`, we own our structures
-
-### 3. Lifecycle Management
-
-```c
-// Connection closed by lsquic
-void on_conn_closed(lsquic_conn_t *c) {
-    us_quic_connection_t *conn = lsquic_conn_get_ctx(c);
-    
-    // Mark as closed and clear lsquic pointer (no longer valid)
-    conn->is_closed = 1;
-    conn->lsquic_conn = NULL;
-    
-    // Add to deferred cleanup list
-    conn->next = conn->socket->context->closing_connections;
-    conn->socket->context->closing_connections = conn;
-}
-
-// Socket close requested
-void us_quic_socket_close(us_quic_socket_t *socket) {
-    socket->is_closed = 1;
-    
-    // Add to deferred cleanup list
-    socket->next = socket->context->closing_sockets;
-    socket->context->closing_sockets = socket;
-    
-    // Tell lsquic to close connections
-    lsquic_engine_close_conns(socket->context->engine);
-}
-
-// Loop sweep function (called each iteration)
-void us_internal_quic_sweep_closed(struct us_loop_t *loop) {
-    // Process all contexts' cleanup lists
-    
-    // Free closed connections
-    while (context->closing_connections) {
-        us_quic_connection_t *conn = context->closing_connections;
-        context->closing_connections = conn->next;
-        free(conn);
-    }
-    
-    // Free closed sockets  
-    while (context->closing_sockets) {
-        us_quic_socket_t *socket = context->closing_sockets;
-        context->closing_sockets = socket->next;
-        free(socket);
-    }
-}
-```
-
-## Usage Patterns
-
-### Server Usage
-
-```c
-// 1. Create context (once per configuration)
-us_quic_socket_context_t *context = us_create_quic_socket_context(loop, options, ext_size);
-
-// 2. Create listen socket (binds UDP port)
-us_quic_listen_socket_t *listen = us_quic_socket_context_listen(context, "0.0.0.0", 443, ext_size);
-
-// 3. Connections arrive via callbacks
-//    - lsquic creates lsquic_conn_t
-//    - We create us_quic_connection_t in on_new_conn
-//    - All connections share the listen socket's UDP socket
-```
-
-### Client Usage
-
-```c
-// 1. Create context
-us_quic_socket_context_t *context = us_create_quic_socket_context(loop, options, ext_size);
-
-// 2. Create client socket and connect
-us_quic_socket_t *socket = us_quic_socket_context_connect(context, "example.com", 443, ext_size);
-
-// 3. Can create multiple connections on same socket
-//    - Each gets its own us_quic_connection_t
-//    - All share the socket's UDP socket
-```
-
-## Integration with lsquic
-
-### Engine Management
-
-- One lsquic engine per context
-- Engine mode (client/server) set at context creation
-- Engine processes all connections for that context
-
-### Packet Flow
-
-**Incoming packets:**
-1. UDP socket receives data in callback
-2. Pass to `lsquic_engine_packet_in()`
-3. lsquic routes to correct connection by Connection ID
-4. lsquic calls our stream callbacks
-
-**Outgoing packets:**
-1. lsquic calls `send_packets_out` callback
-2. We send via the appropriate UDP socket
-3. Peer context provides destination address
-
-### Peer Context
-
-Each connection maintains a peer context for lsquic:
-
-```c
-struct quic_peer_ctx {
-    struct us_udp_socket_t *udp_socket;    // Which socket to send through
-    us_quic_socket_context_t *context;     // For accessing callbacks
-    // lsquic stores peer address internally via lsquic_conn_get_sockaddr()
-};
-```
-
-## Stream Management
-
-Streams are the core abstraction for HTTP/3. Each HTTP request/response pair is a QUIC stream.
-
-### Stream Structure
-
-```c
-// Streams are lsquic_stream_t pointers with extension data
-typedef lsquic_stream_t us_quic_stream_t;
-
-// Access extension data (for HTTP/3 response data)
-void *us_quic_stream_ext(us_quic_stream_t *s);
-```
-
-### Stream Operations
-
-```c
-// Write data to stream
-int us_quic_stream_write(us_quic_stream_t *s, char *data, int length);
-
-// Shutdown stream (FIN)
-int us_quic_stream_shutdown(us_quic_stream_t *s);
-
-// Shutdown read side only
-int us_quic_stream_shutdown_read(us_quic_stream_t *s);
-
-// Close stream abruptly (RESET)
-void us_quic_stream_close(us_quic_stream_t *s);
-
-// Get parent socket
-us_quic_socket_t *us_quic_stream_socket(us_quic_stream_t *s);
-
-// Check if client initiated
-int us_quic_stream_is_client(us_quic_stream_t *s);
-
-// Create new stream on connection
-void us_quic_socket_create_stream(us_quic_socket_t *s, int ext_size);
-```
-
-### HTTP/3 Header Operations
-
-```c
-// Set header at index (for sending)
-void us_quic_socket_context_set_header(
-    us_quic_socket_context_t *context, 
-    int index, 
-    const char *key, int key_length, 
-    const char *value, int value_length
-);
-
-// Get header at index (for receiving)
-int us_quic_socket_context_get_header(
-    us_quic_socket_context_t *context,
-    int index,
-    char **name, int *name_length,
-    char **value, int *value_length
-);
-
-// Send accumulated headers
-void us_quic_socket_context_send_headers(
-    us_quic_socket_context_t *context,
-    us_quic_stream_t *s,
-    int num_headers,
-    int has_body
-);
-```
-
-## Callback Reference
-
-### Connection Callbacks
-
-```c
-// Called when QUIC connection is established
-void on_open(us_quic_socket_t *s, int is_client);
-
-// Called when QUIC connection closes
-void on_close(us_quic_socket_t *s);
-```
-
-### Stream Callbacks (HTTP/3 Request/Response)
-
-```c
-// New stream created (new HTTP request on server, response on client)
-void on_stream_open(us_quic_stream_t *s, int is_client);
-
-// Stream closed (HTTP exchange complete or aborted)
-void on_stream_close(us_quic_stream_t *s);
-
-// Headers received (HTTP request/response headers)
-void on_stream_headers(us_quic_stream_t *s);
-
-// Data received on stream (HTTP body data)
-void on_stream_data(us_quic_stream_t *s, char *data, int length);
-
-// End of stream data (FIN received)
-void on_stream_end(us_quic_stream_t *s);
-
-// Stream is writable (backpressure relief)
-void on_stream_writable(us_quic_stream_t *s);
-```
-
-### Setting Callbacks
-
-```c
-// Connection callbacks
-us_quic_socket_context_on_open(context, on_open);
-us_quic_socket_context_on_close(context, on_close);
-
-// Stream callbacks
-us_quic_socket_context_on_stream_open(context, on_stream_open);
-us_quic_socket_context_on_stream_close(context, on_stream_close);
-us_quic_socket_context_on_stream_headers(context, on_stream_headers);
-us_quic_socket_context_on_stream_data(context, on_stream_data);
-us_quic_socket_context_on_stream_end(context, on_stream_end);
-us_quic_socket_context_on_stream_writable(context, on_stream_writable);
-```
-
-## HTTP/3 Integration
-
-The QUIC implementation is designed to seamlessly support HTTP/3:
-
-### HTTP/3 Request Flow (Server)
-
-1. Client connects → `on_open` callback
-2. Client creates stream for request → `on_stream_open`
-3. Request headers arrive → `on_stream_headers`
-4. Request body data → `on_stream_data` (multiple calls)
-5. Request complete → `on_stream_end`
-6. Server writes response headers → `us_quic_socket_context_send_headers`
-7. Server writes response body → `us_quic_stream_write`
-8. Server ends response → `us_quic_stream_shutdown`
-9. Stream closes → `on_stream_close`
-
-### HTTP/3 Response (Http3Response compatibility)
-
-The stream extension data can hold Http3ResponseData:
-
-```c
-struct Http3ResponseData {
-    // Callbacks for async operations
-    void (*onAborted)();
-    void (*onData)(char *data, int length, bool fin);
-    bool (*onWritable)(uint64_t offset);
-    
-    // Header management
-    unsigned int headerOffset;
-    
-    // Write state
-    uint64_t offset;
-    
-    // Backpressure buffer
-    char *backpressure;
-    int backpressure_length;
-};
-```
-
-This allows the existing Http3Response class to work directly with QUIC streams.
-
-## Error Handling
-
-- Connection errors trigger `on_close` callback
-- Stream errors trigger `on_stream_close` callback
-- Engine errors can be queried via lsquic APIs
-- Socket errors follow standard uSockets error patterns
-
-## Performance Considerations
-
-- Single UDP socket reduces port usage and improves NAT traversal
-- Connection multiplexing reduces system resources
-- Deferred cleanup prevents callback reentrancy issues
-- Inline structures improve cache locality
-
-## Complete API Reference
-
-### Context Management
-
-```c
-// Create QUIC socket context
-us_quic_socket_context_t *us_create_quic_socket_context(
-    struct us_loop_t *loop,
-    us_quic_socket_context_options_t options,
-    int ext_size
-);
-
-// Get context extension data
-void *us_quic_socket_context_ext(us_quic_socket_context_t *context);
-
-// Get context from socket
-us_quic_socket_context_t *us_quic_socket_context(us_quic_socket_t *s);
-```
-
-### Socket Operations
-
-```c
-// Create listen socket (server)
-us_quic_listen_socket_t *us_quic_socket_context_listen(
-    us_quic_socket_context_t *context,
-    const char *host,
-    int port,
-    int ext_size
-);
-
-// Create client socket and connect
-us_quic_socket_t *us_quic_socket_context_connect(
-    us_quic_socket_context_t *context,
-    const char *host,
-    int port,
-    int ext_size
-);
-
-// Close socket
-void us_quic_socket_close(us_quic_socket_t *s);
-
-// Get socket extension data
-void *us_quic_socket_ext(us_quic_socket_t *s);
-```
-
-### Connection Operations
-
-```c
-// Get connection extension data
-void *us_quic_connection_ext(us_quic_connection_t *c);
-
-// Close connection
-void us_quic_connection_close(us_quic_connection_t *c);
-
-// Get connection socket
-us_quic_socket_t *us_quic_connection_socket(us_quic_connection_t *c);
-```
-
-### Stream Operations
-
-```c
-// Create new stream on connection
-void us_quic_socket_create_stream(us_quic_socket_t *s, int ext_size);
-
-// Write data to stream
-int us_quic_stream_write(us_quic_stream_t *s, char *data, int length);
-
-// Shutdown stream (send FIN)
-int us_quic_stream_shutdown(us_quic_stream_t *s);
-
-// Shutdown read side only
-int us_quic_stream_shutdown_read(us_quic_stream_t *s);
-
-// Close stream abruptly (send RESET)
-void us_quic_stream_close(us_quic_stream_t *s);
-
-// Get stream extension data
-void *us_quic_stream_ext(us_quic_stream_t *s);
-
-// Get parent socket
-us_quic_socket_t *us_quic_stream_socket(us_quic_stream_t *s);
-
-// Check if client-initiated stream
-int us_quic_stream_is_client(us_quic_stream_t *s);
-```
-
-### HTTP/3 Specific Operations
-
-**Important**: lsquic handles all QPACK encoding/decoding internally. We never deal with QPACK directly.
-
-```c
-// Header set callbacks (implemented by us, called by lsquic)
-struct lsquic_hset_if {
-    void *(*hsi_create_header_set)(void *ctx, lsquic_stream_t *stream, int is_push);
-    void (*hsi_discard_header_set)(void *hdr_set);
-    struct lsxpack_header *(*hsi_prepare_decode)(void *hdr_set, 
-                                                  struct lsxpack_header *hdr, 
-                                                  size_t space);
-    int (*hsi_process_header)(void *hdr_set, struct lsxpack_header *hdr);
-};
-
-// Helper functions for working with headers:
-
-// Set header for sending (we provide name/value, lsquic encodes to QPACK)
-void us_quic_socket_context_set_header(
-    us_quic_socket_context_t *context,
-    int index,
-    const char *key, int key_length,
-    const char *value, int value_length
-);
-
-// Get received header (already decoded from QPACK by lsquic)  
-int us_quic_socket_context_get_header(
-    us_quic_socket_context_t *context,
-    int index,
-    char **name, int *name_length,
-    char **value, int *value_length
-);
-
-// Send accumulated headers (lsquic encodes to QPACK and sends)
-void us_quic_socket_context_send_headers(
-    us_quic_socket_context_t *context,
-    us_quic_stream_t *s,
-    int num_headers,
-    int has_body
-);
-```
-
-## HTTP/3 App Integration
-
-The QUIC implementation supports the same App pattern as HTTP/1.1 and HTTP/2:
-
-### Http3Context Structure
-
-```c
-struct Http3Context {
-    us_quic_socket_context_t *quicContext;
-    HttpRouter<Http3ContextData::RouterData> router;
-    
-    // Create context
-    static Http3Context *create(us_loop_t *loop, us_quic_socket_context_options_t options);
-    
-    // Listen on port
-    us_quic_listen_socket_t *listen(const char *host, int port);
-    
-    // Register route handlers
-    void onHttp(std::string_view method, std::string_view pattern, 
-                MoveOnlyFunction<void(Http3Response *, Http3Request *)> handler);
-    
-    // Initialize callbacks
-    void init();
-};
-```
-
-### H3App Pattern (matching App/SSLApp)
-
-```cpp
-struct H3App {
-    Http3Context *http3Context;
-    
-    // Constructor with SSL options
-    H3App(SocketContextOptions options = {});
-    
-    // HTTP method handlers (same as App)
-    H3App &&get(std::string_view pattern, MoveOnlyFunction<void(Http3Response *, Http3Request *)> &&handler);
-    H3App &&post(std::string_view pattern, MoveOnlyFunction<void(Http3Response *, Http3Request *)> &&handler);
-    H3App &&put(std::string_view pattern, MoveOnlyFunction<void(Http3Response *, Http3Request *)> &&handler);
-    H3App &&del(std::string_view pattern, MoveOnlyFunction<void(Http3Response *, Http3Request *)> &&handler);
-    H3App &&patch(std::string_view pattern, MoveOnlyFunction<void(Http3Response *, Http3Request *)> &&handler);
-    H3App &&head(std::string_view pattern, MoveOnlyFunction<void(Http3Response *, Http3Request *)> &&handler);
-    H3App &&options(std::string_view pattern, MoveOnlyFunction<void(Http3Response *, Http3Request *)> &&handler);
-    H3App &&connect(std::string_view pattern, MoveOnlyFunction<void(Http3Response *, Http3Request *)> &&handler);
-    H3App &&trace(std::string_view pattern, MoveOnlyFunction<void(Http3Response *, Http3Request *)> &&handler);
-    H3App &&any(std::string_view pattern, MoveOnlyFunction<void(Http3Response *, Http3Request *)> &&handler);
-    
-    // Listen methods (same interface as App)
-    H3App &&listen(int port, MoveOnlyFunction<void(us_listen_socket_t *)> &&handler);
-    H3App &&listen(const std::string &host, int port, MoveOnlyFunction<void(us_listen_socket_t *)> &&handler);
-    
-    // Run the event loop
-    void run();
-};
-```
-
-### Usage Example
-
-```cpp
-// HTTP/3 app usage - identical to HTTP/1.1 App
-H3App app(sslOptions);
-
-app.get("/*", [](Http3Response *res, Http3Request *req) {
-    res->end("Hello HTTP/3!");
-}).listen(443, [](auto *listen_socket) {
-    if (listen_socket) {
-        std::cout << "HTTP/3 server listening on port 443" << std::endl;
-    }
-}).run();
-```
-
-## Implementation Requirements
-
-### For HTTP/3 Support
-
-1. **Http3Context** needs to:
-   - Create and manage `us_quic_socket_context_t`
-   - Set up stream callbacks that route to HTTP handlers
-   - Manage the router for path matching
-
-2. **Stream Callbacks** must:
-   - Parse HTTP/3 headers when `on_stream_headers` is called
-   - Create Http3Request objects from headers
-   - Route to appropriate handler based on method and path
-   - Manage Http3Response lifecycle
-
-3. **Http3Request** needs to:
-   - Store headers received via lsquic callbacks (already decoded)
-   - Provide getHeader(), getMethod(), getUrl() methods
-   - Handle request body streaming
-
-4. **Http3Response** needs to:
-   - Build headers using us_quic_socket_context_set_header()
-   - Let lsquic handle QPACK encoding when sending
-   - Manage backpressure
-   - Handle response streaming
-   - Track header/body state
-
-### Callback Flow for HTTP/3 Request
-
-```
-1. on_stream_open(stream)
-   -> Allocate Http3ResponseData in stream extension
-   -> Initialize response state
-
-2. on_stream_headers(stream)
-   -> Parse HTTP/3 headers via QPACK
-   -> Create Http3Request from headers
-   -> Look up route in router
-   -> Call user handler(Http3Response*, Http3Request*)
-
-3. on_stream_data(stream, data, length)
-   -> If request has body, buffer or stream to handler
-   -> Call request->onData() if set
-
-4. on_stream_end(stream)
-   -> Mark request as complete
-   -> If response not sent, send error
-
-5. on_stream_close(stream)
-   -> Clean up Http3ResponseData
-   -> Free any pending resources
-```
-
-## What lsquic Handles For Us
-
-lsquic is a full-featured QUIC/HTTP/3 implementation that handles:
-
-### Protocol Layer
-- **QUIC transport** - Packet framing, encryption, connection IDs
-- **TLS 1.3** - Full handshake, key derivation, 0-RTT support
-- **HTTP/3 framing** - DATA, HEADERS, SETTINGS frames
-- **QPACK** - Header compression/decompression (we never touch this)
-- **Connection migration** - Automatic handling of client IP changes
-- **Version negotiation** - Supports multiple QUIC versions
-
-### Reliability & Performance
-- **Loss detection & recovery** - Automatic retransmission
-- **Congestion control** - BBR, Cubic, adaptive selection based on RTT
-- **Flow control** - Per-stream and per-connection windows
-- **Pacing** - Smooth packet transmission
-- **ACK management** - Delayed ACKs, ACK frequency optimization
-
-### HTTP/3 Features
-- **Stream management** - Creation, prioritization, cancellation
-- **GOAWAY handling** - Graceful connection shutdown
-- **Server push** - HTTP/3 push promises (optional)
-- **Datagram extension** - Unreliable delivery mode
-- **Session resumption** - 0-RTT data on reconnect
-
-### What We Handle
-- **Socket I/O** - UDP packet send/receive
-- **Event loop integration** - Timer management, I/O readiness
-- **Memory management** - Our structures and extensions
-- **Routing** - HTTP path matching and handler dispatch
-- **Application callbacks** - Connection, stream, and data events
-
-## Future Improvements
-
-- WebSocket over HTTP/3 support
-- Batch packet sending using sendmmsg
-- Better connection pooling for clients
-- Performance optimizations for packet I/O
-- Integration with io_uring for better performance

packages/bun-usockets/QUIC_IMPLEMENTATION_TODO.md

@@ -1,123 +0,0 @@
-# QUIC Implementation TODO
-
-## Current State
-The QUIC implementation is partially working but has critical architectural issues that need fixing. Basic connections work, but the design doesn't follow uSockets patterns properly.
-
-## Design Document
-See `QUIC.md` for the complete architectural design. This follows uSockets patterns and provides a clean API for HTTP/3.
-
-## Critical Issues to Fix
-
-### 1. Remove global_listen_socket (HIGH PRIORITY)
-**File**: `packages/bun-usockets/src/quic.c`
-**Problem**: Using a global variable `global_listen_socket` instead of proper socket structures
-**Solution**: 
-- Implement proper `us_quic_listen_socket_t` structure as defined in QUIC.md
-- Each server connection should reference its parent listen socket, not a global
-- Follow the TCP socket pattern in uSockets
-
-### 2. Fix Connection/Socket Structure
-**Current broken structure**:
-```c
-// Currently all server connections share one global UDP socket (WRONG)
-socket->udp_socket = global_listen_socket;
-```
-
-**Should be**:
-```c
-struct us_quic_socket_t {
-    struct us_udp_socket_t udp_socket;  // Inline, not pointer
-    us_quic_socket_context_t *context;
-    struct us_quic_socket_t *next;      // For deferred cleanup
-    int is_closed;
-};
-
-struct us_quic_connection_t {
-    us_quic_socket_t *socket;           // Reference to parent
-    lsquic_conn_t *lsquic_conn;
-    void *peer_ctx;
-    struct us_quic_connection_t *next;  // For deferred cleanup
-    int is_closed;
-};
-```
-
-### 3. Implement Deferred Cleanup
-**Problem**: Memory is freed immediately in callbacks, causing use-after-free
-**Solution**:
-- Add linked lists to context for closing connections/sockets
-- Implement `us_internal_quic_sweep_closed()` called each loop iteration
-- Never free memory in lsquic callbacks - always defer
-
-### 4. Fix Peer Context Management
-**Problem**: Creating new peer_ctx for each packet instead of per-connection
-**Solution**:
-- Each connection should have one persistent peer_ctx
-- Store peer address in the peer_ctx for server connections
-- Reuse peer_ctx across all packets for a connection
-
-### 5. Fix Stream Management
-**Problem**: Global/shared stream state instead of per-stream
-**Solution**:
-- Each stream's extension data should hold its own state
-- Remove any global stream variables
-- Use `us_quic_stream_ext()` to access per-stream data
-
-### 6. Fix Server Write Issues
-**Problem**: Server cannot write to clients (likely peer_ctx issue)
-**Solution**:
-- Ensure each server connection has proper peer_ctx with UDP socket reference
-- Verify `send_packets_out` gets correct peer_ctx for server connections
-- Test with `quic-server-client.test.ts` line 30 (currently commented out)
-
-## Implementation Order
-
-1. **First**: Fix the core architecture (items 1-4 above)
-   - This is foundational - everything else depends on getting this right
-   
-2. **Second**: Fix stream management (item 5)
-   - Needed for proper HTTP/3 request/response handling
-   
-3. **Third**: Fix server writes (item 6)
-   - Should work once peer contexts are fixed
-   
-4. **Fourth**: Run tests and fix issues
-   - `bun bd test test/js/bun/quic/quic-server-client.test.ts`
-   - `bun bd test test/js/bun/quic/quic-performance.test.ts`
-
-## Key Files
-
-- **Design**: `/home/claude/bun2/packages/bun-usockets/QUIC.md`
-- **Implementation**: `/home/claude/bun2/packages/bun-usockets/src/quic.c`
-- **Header**: `/home/claude/bun2/packages/bun-usockets/src/quic.h`
-- **Tests**: `/home/claude/bun2/test/js/bun/quic/*.test.ts`
-
-## Testing
-
-Always use `bun bd` to build and test:
-```bash
-# Build debug version (takes ~5 minutes, be patient)
-bun bd
-
-# Run specific test
-bun bd test test/js/bun/quic/quic-server-client.test.ts
-
-# Run with filter
-bun bd test quic -t "server and client"
-```
-
-## Important Notes
-
-1. **lsquic handles all QUIC protocol complexity** - We just do UDP I/O and callbacks
-2. **Follow uSockets patterns exactly** - Look at TCP implementation for guidance
-3. **Never free memory in callbacks** - Always defer to next loop iteration
-4. **Test incrementally** - Fix one issue, test, then move to next
-5. **The design in QUIC.md is complete** - Follow it closely
-
-## Success Criteria
-
-- [ ] No global variables (especially no `global_listen_socket`)
-- [ ] Server can write to clients successfully
-- [ ] All tests in `quic-server-client.test.ts` pass
-- [ ] No segfaults in `quic-performance.test.ts`
-- [ ] Clean shutdown without memory leaks
-- [ ] Follows uSockets patterns consistently

packages/bun-usockets/src/bsd.c

@@ -717,25 +717,6 @@ LIBUS_SOCKET_DESCRIPTOR bsd_accept_socket(LIBUS_SOCKET_DESCRIPTOR fd, struct bsd
             return LIBUS_SOCKET_ERROR;
         }
 
-#ifdef __APPLE__
-        /* A bug in XNU (the macOS kernel) can cause accept() to return a socket but addrlen=0.
-         * This happens when an IPv4 connection is made to an IPv6 dual-stack listener
-         * and the connection is immediately aborted (sends RST packet).
-         * However, there might be buffered data from connectx() before the abort. */
-        if (addr->len == 0) {
-            /* Check if there's any pending data before discarding the socket */
-            char peek_buf[1];
-            ssize_t has_data = recv(accepted_fd, peek_buf, 1, MSG_PEEK | MSG_DONTWAIT);
-            
-            if (has_data <= 0) {
-                /* No data available, socket is truly dead - discard it */
-                bsd_close_socket(accepted_fd);
-                continue; /* Try to accept the next connection */
-            }
-            /* If has_data > 0, let the socket through - there's buffered data to read */
-        }
-#endif
-
         break;
     }
 

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

@@ -1130,10 +1130,6 @@ SSL_CTX *create_ssl_context_from_bun_options(
 
   /* Create the context */
   SSL_CTX *ssl_context = SSL_CTX_new(TLS_method());
-  if (!ssl_context) {
-    *err = CREATE_BUN_SOCKET_ERROR_SSL_CONTEXT_CREATION_FAILED;
-    return NULL;
-  }
 
   /* Default options we rely on - changing these will break our logic */
   SSL_CTX_set_read_ahead(ssl_context, 1);
@@ -1180,7 +1176,6 @@ SSL_CTX *create_ssl_context_from_bun_options(
   } else if (options.cert && options.cert_count > 0) {
     for (unsigned int i = 0; i < options.cert_count; i++) {
       if (us_ssl_ctx_use_certificate_chain(ssl_context, options.cert[i]) != 1) {
-        *err = CREATE_BUN_SOCKET_ERROR_INVALID_CA;
         free_ssl_context(ssl_context);
         return NULL;
       }
@@ -1198,7 +1193,6 @@ SSL_CTX *create_ssl_context_from_bun_options(
     for (unsigned int i = 0; i < options.key_count; i++) {
       if (us_ssl_ctx_use_privatekey_content(ssl_context, options.key[i],
                                             SSL_FILETYPE_PEM) != 1) {
-        *err = CREATE_BUN_SOCKET_ERROR_INVALID_CA;
         free_ssl_context(ssl_context);
         return NULL;
       }

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

@@ -20,9 +20,6 @@
 
 #include <stdint.h>
 
-/* Forward declaration for lsquic engine type */
-struct lsquic_engine;
-
 #if defined(__APPLE__)
 #include <os/lock.h>
 typedef os_unfair_lock zig_mutex_t;
@@ -61,10 +58,6 @@ struct us_internal_loop_data_t {
     /* We do not care if this flips or not, it doesn't matter */
     size_t iteration_nr;
     void* jsc_vm;
-    /* QUIC engines - one per loop, shared by all contexts */
-    struct lsquic_engine *quic_server_engine;  /* Server engine for this loop */
-    struct lsquic_engine *quic_client_engine;  /* Client engine for this loop */
-    struct us_timer_t *quic_timer;             /* QUIC timer for this loop */
 };
 
 #endif // LOOP_DATA_H

packages/bun-usockets/src/libusockets.h

@@ -148,9 +148,6 @@ int us_udp_socket_send(struct us_udp_socket_t *s, void** payloads, size_t* lengt
 /* Allocates a packet buffer that is reuable per thread. Mutated by us_udp_socket_receive. */
 struct us_udp_packet_buffer_t *us_create_udp_packet_buffer();
 
-/* Frees a packet buffer allocated with us_create_udp_packet_buffer. */
-void us_free_udp_packet_buffer(struct us_udp_packet_buffer_t *buf);
-
 /* Creates a (heavy-weight) UDP socket with a user space ring buffer. Again, this one is heavy weight and
  * shoud be reused. One entire QUIC server can be implemented using only one single UDP socket so weight
  * is not a concern as is the case for TCP sockets which are 1-to-1 with TCP connections. */
@@ -160,9 +157,6 @@ void us_free_udp_packet_buffer(struct us_udp_packet_buffer_t *buf);
 
 struct us_udp_socket_t *us_create_udp_socket(us_loop_r loop, void (*data_cb)(struct us_udp_socket_t *, void *, int), void (*drain_cb)(struct us_udp_socket_t *), void (*close_cb)(struct us_udp_socket_t *), const char *host, unsigned short port, int flags, int *err, void *user);
 
-// Extended version for QUIC sockets that need extension data
-struct us_udp_socket_t *us_create_udp_socket_with_ext(us_loop_r loop, void (*data_cb)(struct us_udp_socket_t *, void *, int), void (*drain_cb)(struct us_udp_socket_t *), void (*close_cb)(struct us_udp_socket_t *), const char *host, unsigned short port, int flags, int *err, void *user, int ext_size);
-
 void us_udp_socket_close(struct us_udp_socket_t *s);
 
 int us_udp_socket_set_broadcast(struct us_udp_socket_t *s, int enabled);
@@ -232,11 +226,11 @@ struct us_bun_socket_context_options_t {
     const char *ca_file_name;
     const char *ssl_ciphers;
     int ssl_prefer_low_memory_usage; /* Todo: rename to prefer_low_memory_usage and apply for TCP as well */
-    const char * const *key;
+    const char **key;
     unsigned int key_count;
-    const char * const *cert;
+    const char **cert;
     unsigned int cert_count;
-    const char * const *ca;
+    const char **ca;
     unsigned int ca_count;
     unsigned int secure_options;
     int reject_unauthorized;
@@ -269,7 +263,6 @@ enum create_bun_socket_error_t {
   CREATE_BUN_SOCKET_ERROR_INVALID_CA_FILE,
   CREATE_BUN_SOCKET_ERROR_INVALID_CA,
   CREATE_BUN_SOCKET_ERROR_INVALID_CIPHERS,
-  CREATE_BUN_SOCKET_ERROR_SSL_CONTEXT_CREATION_FAILED,
 };
 
 struct us_socket_context_t *us_create_bun_ssl_socket_context(struct us_loop_t *loop,

packages/bun-usockets/src/quic.h

@@ -7,47 +7,25 @@
 
 #include "libusockets.h"
 
-// Forward declarations
-struct us_quic_socket_context_s;
+typedef struct {
+    const char *cert_file_name;
+    const char *key_file_name;
+    const char *passphrase;
+} us_quic_socket_context_options_t;
 
-typedef struct us_quic_socket_context_s us_quic_socket_context_t;
 
-// QUIC uses the same options as regular SSL sockets to support all SSL features
-typedef struct us_bun_socket_context_options_t us_quic_socket_context_options_t;
-
-/* Socket that handles UDP transport and QUIC connections */
-typedef struct us_quic_socket_s {
-    struct us_udp_socket_t *udp_socket;     /* UDP socket for I/O */
-    us_quic_socket_context_t *context;      /* Reference to context */
-    void *lsquic_conn;                      /* QUIC connection for this socket */
-    
-    struct us_quic_socket_s *next;          /* For deferred free list */
-    int is_closed;                          /* Marked for cleanup */
-    int is_client;                          /* 1 = client, 0 = server/listen */
-    
-    /* Extension data follows */
+typedef struct {
+    /* Refers to either the shared listen socket or the client UDP socket */
+    void *udp_socket;
 } us_quic_socket_t;
 
-/* Stream structure - thin wrapper around lsquic stream */
-typedef struct us_quic_stream_s {
-    void *lsquic_stream;                    /* Actual lsquic stream pointer */
-    /* Extension data follows */
-} us_quic_stream_t;
+struct us_quic_socket_context_s;
+struct us_quic_listen_socket_s;
+struct us_quic_stream_s;
 
-/* Individual QUIC connection (multiplexed over socket) */
-typedef struct us_quic_connection_s {
-    us_quic_socket_t *socket;               /* Parent socket for I/O */
-    void *lsquic_conn;                      /* Opaque QUIC connection */
-    void *peer_ctx;                         /* For lsquic callbacks */
-    
-    struct us_quic_connection_s *next;      /* For deferred free list */
-    int is_closed;                          /* Marked for cleanup */
-    
-    /* Extension data follows */
-} us_quic_connection_t;
-
-/* Listen socket is just an alias - same structure */
-typedef struct us_quic_socket_s us_quic_listen_socket_t;
+typedef struct us_quic_socket_context_s us_quic_socket_context_t;
+typedef struct us_quic_listen_socket_s us_quic_listen_socket_t;
+typedef struct us_quic_stream_s us_quic_stream_t;
 
 
 void *us_quic_stream_ext(us_quic_stream_t *s);
@@ -66,10 +44,8 @@ us_quic_socket_context_t *us_create_quic_socket_context(struct us_loop_t *loop,
 us_quic_listen_socket_t *us_quic_socket_context_listen(us_quic_socket_context_t *context, const char *host, int port, int ext_size);
 us_quic_socket_t *us_quic_socket_context_connect(us_quic_socket_context_t *context, const char *host, int port, int ext_size);
 
-/* Stream management functions */
 void us_quic_socket_create_stream(us_quic_socket_t *s, int ext_size);
 us_quic_socket_t *us_quic_stream_socket(us_quic_stream_t *s);
-void us_quic_socket_close(us_quic_socket_t *s);
 
 /* This one is ugly and is only used to make clean examples */
 int us_quic_stream_is_client(us_quic_stream_t *s);
@@ -81,7 +57,6 @@ void us_quic_socket_context_on_stream_open(us_quic_socket_context_t *context, vo
 void us_quic_socket_context_on_stream_close(us_quic_socket_context_t *context, void(*on_stream_close)(us_quic_stream_t *s));
 void us_quic_socket_context_on_open(us_quic_socket_context_t *context, void(*on_open)(us_quic_socket_t *s, int is_client));
 void us_quic_socket_context_on_close(us_quic_socket_context_t *context, void(*on_close)(us_quic_socket_t *s));
-void us_quic_socket_context_on_connection(us_quic_socket_context_t *context, void(*on_connection)(us_quic_socket_t *s));
 void us_quic_socket_context_on_stream_writable(us_quic_socket_context_t *context, void(*on_stream_writable)(us_quic_stream_t *s));
 
 
@@ -89,14 +64,5 @@ void us_quic_socket_context_on_stream_writable(us_quic_socket_context_t *context
 void *us_quic_socket_context_ext(us_quic_socket_context_t *context);
 us_quic_socket_context_t *us_quic_socket_context(us_quic_socket_t *s);
 
-/* Context cleanup function */
-void us_quic_socket_context_free(us_quic_socket_context_t *context);
-
-/* Internal sweep function for deferred cleanup */
-void us_internal_quic_sweep_closed(us_quic_socket_context_t *context);
-
-/* Get the bound port from a listen socket */
-int us_quic_listen_socket_get_port(us_quic_listen_socket_t *listen_socket);
-
 #endif
 #endif

packages/bun-usockets/src/udp.c

@@ -19,8 +19,6 @@
 #include "internal/internal.h"
 
 #include <string.h>
-#include <stdlib.h>
-#include <stddef.h>
 
 // int us_udp_packet_buffer_ecn(struct us_udp_packet_buffer_t *buf, int index) {
 //     return bsd_udp_packet_buffer_ecn((struct udp_recvbuf *)buf, index);
@@ -189,85 +187,4 @@ struct us_udp_socket_t *us_create_udp_socket(
     us_poll_start((struct us_poll_t *) udp, udp->loop, LIBUS_SOCKET_READABLE | LIBUS_SOCKET_WRITABLE);
 
     return (struct us_udp_socket_t *) udp;
-}
-
-// Extended version for QUIC sockets that need extension data
-struct us_udp_socket_t *us_create_udp_socket_with_ext(
-    struct us_loop_t *loop,
-    void (*data_cb)(struct us_udp_socket_t *, void *, int),
-    void (*drain_cb)(struct us_udp_socket_t *),
-    void (*close_cb)(struct us_udp_socket_t *),
-    const char *host,
-    unsigned short port,
-    int flags,
-    int *err,
-    void *user,
-    int ext_size
-) {
-
-    LIBUS_SOCKET_DESCRIPTOR fd = bsd_create_udp_socket(host, port, flags, err);
-    if (fd == LIBUS_SOCKET_ERROR) {
-        return 0;
-    }
-
-    int fallthrough = 0;
-
-    // Use the provided ext_size instead of hardcoded 0
-    struct us_poll_t *p = us_create_poll(loop, fallthrough, sizeof(struct us_udp_socket_t) + ext_size);
-    us_poll_init(p, fd, POLL_TYPE_UDP);
-
-    struct us_udp_socket_t *udp = (struct us_udp_socket_t *)p;
-
-    /* Get and store the port once */
-    struct bsd_addr_t tmp = {0};
-    bsd_local_addr(fd, &tmp);
-    udp->port = bsd_addr_get_port(&tmp);
-    udp->loop = loop;
-
-    /* There is no udp socket context, only user data */
-    /* This should really be ext like everything else */
-    udp->user = user;
-
-    udp->on_data = data_cb;
-    udp->on_drain = drain_cb;
-    udp->on_close = close_cb;
-    udp->next = NULL;
-
-    us_poll_start((struct us_poll_t *) udp, udp->loop, LIBUS_SOCKET_READABLE | LIBUS_SOCKET_WRITABLE);
-
-    return (struct us_udp_socket_t *) udp;
-}
-
-/* Structure to hold allocated UDP packet buffer and its data */
-struct us_udp_packet_buffer_wrapper {
-    struct udp_recvbuf buffer;
-    char data[LIBUS_RECV_BUFFER_LENGTH];
-};
-
-struct us_udp_packet_buffer_t *us_create_udp_packet_buffer() {
-    /* Allocate wrapper structure to hold both buffer and data */
-    struct us_udp_packet_buffer_wrapper *wrapper = 
-        (struct us_udp_packet_buffer_wrapper *)malloc(sizeof(struct us_udp_packet_buffer_wrapper));
-    
-    if (!wrapper) {
-        return NULL;
-    }
-    
-    /* Setup the receive buffer using the allocated data */
-    bsd_udp_setup_recvbuf(&wrapper->buffer, wrapper->data, LIBUS_RECV_BUFFER_LENGTH);
-    
-    /* Return the buffer part (us_udp_packet_buffer_t is typedef for struct udp_recvbuf) */
-    return (struct us_udp_packet_buffer_t *)&wrapper->buffer;
-}
-
-void us_free_udp_packet_buffer(struct us_udp_packet_buffer_t *buf) {
-    if (!buf) {
-        return;
-    }
-    
-    /* Calculate the wrapper pointer from the buffer pointer */
-    struct us_udp_packet_buffer_wrapper *wrapper = 
-        (struct us_udp_packet_buffer_wrapper *)((char *)buf - offsetof(struct us_udp_packet_buffer_wrapper, buffer));
-    
-    free(wrapper);
 }

packages/bun-uws/src/App.h

@@ -303,10 +303,10 @@ public:
         auto context = (struct us_socket_context_t *)this->httpContext;
         struct us_socket_t *s = context->head_sockets;
         while (s) {
-            // no matter the type of socket will always contain the AsyncSocketData
-            auto *data = ((AsyncSocket<SSL> *) s)->getAsyncSocketData();
+            HttpResponseData<SSL> *httpResponseData = HttpResponse<SSL>::getHttpResponseDataS(s);
+            httpResponseData->shouldCloseOnceIdle = true;
             struct us_socket_t *next = s->next;
-            if (data->isIdle) {
+            if (httpResponseData->isIdle) {
                 us_socket_close(SSL, s, LIBUS_SOCKET_CLOSE_CODE_CLEAN_SHUTDOWN, 0);
             }
             s = next;
@@ -641,10 +641,6 @@ public:
         httpContext->getSocketContextData()->onClientError = std::move(onClientError);
     }
 
-    void setOnSocketUpgraded(HttpContextData<SSL>::OnSocketUpgradedCallback onUpgraded) {
-        httpContext->getSocketContextData()->onSocketUpgraded = onUpgraded;
-    }
-
     TemplatedApp &&run() {
         uWS::run();
         return std::move(*this);

packages/bun-uws/src/AsyncSocketData.h

@@ -83,7 +83,6 @@ struct AsyncSocketData {
 
     /* Or empty */
     AsyncSocketData() = default;
-    bool isIdle = false;
 };
 
 }

packages/bun-uws/src/HttpContext.h

@@ -253,7 +253,6 @@ private:
             /* Mark that we are inside the parser now */
             httpContextData->flags.isParsingHttp = true;
             httpResponseData->isIdle = false;
-            
             // clients need to know the cursor after http parse, not servers!
             // how far did we read then? we need to know to continue with websocket parsing data? or?
 

packages/bun-uws/src/HttpContextData.h

@@ -43,11 +43,11 @@ struct alignas(16) HttpContextData {
     template <bool> friend struct TemplatedApp;
 private:
     std::vector<MoveOnlyFunction<void(HttpResponse<SSL> *, int)>> filterHandlers;
+    using OnSocketClosedCallback = void (*)(void* userData, int is_ssl, struct us_socket_t *rawSocket);
     using OnSocketDataCallback = void (*)(void* userData, int is_ssl, struct us_socket_t *rawSocket, const char *data, int length, bool last);
     using OnSocketDrainCallback = void (*)(void* userData, int is_ssl, struct us_socket_t *rawSocket);
-    using OnSocketUpgradedCallback = void (*)(void* userData, int is_ssl, struct us_socket_t *rawSocket);
     using OnClientErrorCallback = MoveOnlyFunction<void(int is_ssl, struct us_socket_t *rawSocket, uWS::HttpParserError errorCode, char *rawPacket, int rawPacketLength)>;
-    using OnSocketClosedCallback = void (*)(void* userData, int is_ssl, struct us_socket_t *rawSocket);
+    
 
     MoveOnlyFunction<void(const char *hostname)> missingServerNameHandler;
 
@@ -66,7 +66,6 @@ private:
     OnSocketClosedCallback onSocketClosed = nullptr;
     OnSocketDrainCallback onSocketDrain = nullptr;
     OnSocketDataCallback onSocketData = nullptr;
-    OnSocketUpgradedCallback onSocketUpgraded = nullptr;
     OnClientErrorCallback onClientError = nullptr;
 
     uint64_t maxHeaderSize = 0; // 0 means no limit
@@ -79,7 +78,6 @@ private:
     }
 
 public:
-    
     HttpFlags flags;
 };
 

packages/bun-uws/src/HttpResponse.h

@@ -316,20 +316,14 @@ public:
         HttpContext<SSL> *httpContext = (HttpContext<SSL> *) us_socket_context(SSL, (struct us_socket_t *) this);
 
         /* Move any backpressure out of HttpResponse */
-        auto* responseData = getHttpResponseData();
-        BackPressure backpressure(std::move(((AsyncSocketData<SSL> *) responseData)->buffer));
-        
-        auto* socketData = responseData->socketData;
-        HttpContextData<SSL> *httpContextData = httpContext->getSocketContextData();
-        
+        BackPressure backpressure(std::move(((AsyncSocketData<SSL> *) getHttpResponseData())->buffer));
+
         /* Destroy HttpResponseData */
-        responseData->~HttpResponseData();
+        getHttpResponseData()->~HttpResponseData();
 
         /* Before we adopt and potentially change socket, check if we are corked */
         bool wasCorked = Super::isCorked();
 
-        
-
         /* Adopting a socket invalidates it, do not rely on it directly to carry any data */
         us_socket_t *usSocket = us_socket_context_adopt_socket(SSL, (us_socket_context_t *) webSocketContext, (us_socket_t *) this, sizeof(WebSocketData) + sizeof(UserData));
         WebSocket<SSL, true, UserData> *webSocket = (WebSocket<SSL, true, UserData> *) usSocket;
@@ -340,12 +334,10 @@ public:
         }
 
         /* Initialize websocket with any moved backpressure intact */
-        webSocket->init(perMessageDeflate, compressOptions, std::move(backpressure), socketData, httpContextData->onSocketClosed);
-        if (httpContextData->onSocketUpgraded) {
-            httpContextData->onSocketUpgraded(socketData, SSL, usSocket);
-        }
+        webSocket->init(perMessageDeflate, compressOptions, std::move(backpressure));
 
         /* We should only mark this if inside the parser; if upgrading "async" we cannot set this */
+        HttpContextData<SSL> *httpContextData = httpContext->getSocketContextData();
         if (httpContextData->flags.isParsingHttp) {
             /* We need to tell the Http parser that we changed socket */
             httpContextData->upgradedWebSocket = webSocket;
@@ -359,6 +351,7 @@ public:
 
         /* Move construct the UserData right before calling open handler */
         new (webSocket->getUserData()) UserData(std::forward<UserData>(userData));
+        
 
         /* Emit open event and start the timeout */
         if (webSocketContextData->openHandler) {
@@ -478,7 +471,7 @@ public:
         return internalEnd({nullptr, 0}, 0, false, false, closeConnection);
     }
 
-    void flushHeaders(bool flushImmediately = false) {
+    void flushHeaders() {
 
         writeStatus(HTTP_200_OK);
 
@@ -499,10 +492,6 @@ public:
             Super::write("\r\n", 2);
             httpResponseData->state |= HttpResponseData<SSL>::HTTP_WRITE_CALLED;
         }
-        if (flushImmediately) {
-            /* Uncork the socket to send data to the client immediately */
-            this->uncork();
-        }
     }
     /* Write parts of the response in chunking fashion. Starts timeout if failed. */
     bool write(std::string_view data, size_t *writtenPtr = nullptr) {

packages/bun-uws/src/HttpResponseData.h

@@ -109,6 +109,9 @@ struct HttpResponseData : AsyncSocketData<SSL>, HttpParser {
     uint8_t idleTimeout = 10; // default HTTP_TIMEOUT 10 seconds
     bool fromAncientRequest = false;
     bool isConnectRequest = false;
+    bool isIdle = true;
+    bool shouldCloseOnceIdle = false;
+
 
 #ifdef UWS_WITH_PROXY
     ProxyParser proxyParser;

packages/bun-uws/src/WebSocket.h

@@ -34,8 +34,8 @@ struct WebSocket : AsyncSocket<SSL> {
 private:
     typedef AsyncSocket<SSL> Super;
 
-    void *init(bool perMessageDeflate, CompressOptions compressOptions, BackPressure &&backpressure, void *socketData, WebSocketData::OnSocketClosedCallback onSocketClosed) {
-        new (us_socket_ext(SSL, (us_socket_t *) this)) WebSocketData(perMessageDeflate, compressOptions, std::move(backpressure), socketData, onSocketClosed);
+    void *init(bool perMessageDeflate, CompressOptions compressOptions, BackPressure &&backpressure) {
+        new (us_socket_ext(SSL, (us_socket_t *) this)) WebSocketData(perMessageDeflate, compressOptions, std::move(backpressure));
         return this;
     }
 public:

packages/bun-uws/src/WebSocketContext.h

@@ -256,9 +256,6 @@ private:
 
             /* For whatever reason, if we already have emitted close event, do not emit it again */
             WebSocketData *webSocketData = (WebSocketData *) (us_socket_ext(SSL, s));
-            if (webSocketData->socketData && webSocketData->onSocketClosed) {
-                webSocketData->onSocketClosed(webSocketData->socketData, SSL, (us_socket_t *) s);
-            }
             if (!webSocketData->isShuttingDown) {
                 /* Emit close event */
                 auto *webSocketContextData = (WebSocketContextData<SSL, USERDATA> *) us_socket_context_ext(SSL, us_socket_context(SSL, (us_socket_t *) s));

packages/bun-uws/src/WebSocketContextData.h

@@ -52,6 +52,7 @@ struct WebSocketContextData {
 private:
 
 public:
+
     /* This one points to the App's shared topicTree */
     TopicTree<TopicTreeMessage, TopicTreeBigMessage> *topicTree;
 

packages/bun-uws/src/WebSocketData.h

@@ -38,7 +38,6 @@ private:
     unsigned int controlTipLength = 0;
     bool isShuttingDown = 0;
     bool hasTimedOut = false;
-    
     enum CompressionStatus : char {
         DISABLED,
         ENABLED,
@@ -53,12 +52,7 @@ private:
     /* We could be a subscriber */
     Subscriber *subscriber = nullptr;
 public:
-    using OnSocketClosedCallback = void (*)(void* userData, int is_ssl, struct us_socket_t *rawSocket);
-    void *socketData = nullptr;
-    /* node http compatibility callbacks */
-    OnSocketClosedCallback onSocketClosed = nullptr;
-
-    WebSocketData(bool perMessageDeflate, CompressOptions compressOptions, BackPressure &&backpressure, void *socketData, OnSocketClosedCallback onSocketClosed) : AsyncSocketData<false>(std::move(backpressure)), WebSocketState<true>() {
+    WebSocketData(bool perMessageDeflate, CompressOptions compressOptions, BackPressure &&backpressure) : AsyncSocketData<false>(std::move(backpressure)), WebSocketState<true>() {
         compressionStatus = perMessageDeflate ? ENABLED : DISABLED;
 
         /* Initialize the dedicated sliding window(s) */
@@ -70,10 +64,6 @@ public:
                 inflationStream = new InflationStream(compressOptions);
             }
         }
-        // never close websocket sockets when closing idle connections
-        this->isIdle = false;
-        this->socketData = socketData;
-        this->onSocketClosed = onSocketClosed;
     }
 
     ~WebSocketData() {

patches/lsquic/allow-missing-boringssl-libs.patch

@@ -1,15 +0,0 @@
-diff --git a/CMakeLists.txt b/CMakeLists.txt
-index 932668e..90be782 100644
---- a/CMakeLists.txt
-+++ b/CMakeLists.txt
-@@ -225,7 +225,9 @@ ELSE()
-         IF(BORINGSSL_LIB_${LIB_NAME})
-             MESSAGE(STATUS "Found ${LIB_NAME} library: ${BORINGSSL_LIB_${LIB_NAME}}")
-         ELSE()
--            MESSAGE(FATAL_ERROR "BORINGSSL_LIB_${LIB_NAME} library not found")
-+            MESSAGE(WARNING "BORINGSSL_LIB_${LIB_NAME} library not found - will be resolved at link time")
-+            # Set to empty string to avoid undefined variable errors
-+            SET(BORINGSSL_LIB_${LIB_NAME} "")
-         ENDIF()
-     ENDFOREACH()
- 

scripts/runner.node.mjs

@@ -80,7 +80,6 @@ function getNodeParallelTestTimeout(testPath) {
   if (testPath.includes("test-dns")) {
     return 90_000;
   }
-  if (!isCI) return 60_000; // everything slower in debug mode
   return 20_000;
 }
 
@@ -450,7 +449,7 @@ async function runTests() {
 
       if (parallelism > 1) {
         console.log(grouptitle);
-        result = await fn(index);
+        result = await fn();
       } else {
         result = await startGroup(grouptitle, fn);
       }
@@ -470,7 +469,6 @@ async function runTests() {
       const label = `${getAnsi(color)}[${index}/${total}] ${title} - ${error}${getAnsi("reset")}`;
       startGroup(label, () => {
         if (parallelism > 1) return;
-        if (!isCI) return;
         process.stderr.write(stdoutPreview);
       });
 
@@ -581,11 +579,8 @@ async function runTests() {
           const title = relative(cwd, absoluteTestPath).replaceAll(sep, "/");
           if (isNodeTest(testPath)) {
             const testContent = readFileSync(absoluteTestPath, "utf-8");
-            let runWithBunTest = title.includes("needs-test") || testContent.includes("node:test");
-            // don't wanna have a filter for includes("bun:test") but these need our mocks
-            runWithBunTest ||= title === "test/js/node/test/parallel/test-fs-append-file-flush.js";
-            runWithBunTest ||= title === "test/js/node/test/parallel/test-fs-write-file-flush.js";
-            runWithBunTest ||= title === "test/js/node/test/parallel/test-fs-write-stream-flush.js";
+            const runWithBunTest =
+              title.includes("needs-test") || testContent.includes("bun:test") || testContent.includes("node:test");
             const subcommand = runWithBunTest ? "test" : "run";
             const env = {
               FORCE_COLOR: "0",
@@ -673,9 +668,7 @@ async function runTests() {
         const title = join(relative(cwd, vendorPath), testPath).replace(/\\/g, "/");
 
         if (testRunner === "bun") {
-          await runTest(title, index =>
-            spawnBunTest(execPath, testPath, { cwd: vendorPath, env: { TEST_SERIAL_ID: index } }),
-          );
+          await runTest(title, () => spawnBunTest(execPath, testPath, { cwd: vendorPath }));
         } else {
           const testRunnerPath = join(cwd, "test", "runners", `${testRunner}.ts`);
           if (!existsSync(testRunnerPath)) {
@@ -1302,7 +1295,6 @@ async function spawnBun(execPath, { args, cwd, timeout, env, stdout, stderr }) {
  * @param {object} [opts]
  * @param {string} [opts.cwd]
  * @param {string[]} [opts.args]
- * @param {object} [opts.env]
  * @returns {Promise<TestResult>}
  */
 async function spawnBunTest(execPath, testPath, opts = { cwd }) {
@@ -1336,7 +1328,6 @@ async function spawnBunTest(execPath, testPath, opts = { cwd }) {
 
   const env = {
     GITHUB_ACTIONS: "true", // always true so annotations are parsed
-    ...opts["env"],
   };
   if ((basename(execPath).includes("asan") || !isCI) && shouldValidateExceptions(relative(cwd, absPath))) {
     env.BUN_JSC_validateExceptionChecks = "1";

scripts/update-sqlite-amalgamation.sh

@@ -1,60 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-
-# This script updates SQLite amalgamation files with the required compiler flags.
-# It downloads the SQLite source, configures it with necessary flags, builds the
-# amalgamation, and copies the generated files to the Bun source tree.
-#
-# Usage:
-#   ./scripts/update-sqlite-amalgamation.sh <version_number> <year>
-#
-# Example:
-#   ./scripts/update-sqlite-amalgamation.sh 3500400 2025
-#
-# The version number is a 7-digit SQLite version (e.g., 3500400 for 3.50.4)
-# The year is the release year found in the download URL
-
-if [ $# -ne 2 ]; then
-  echo "Usage: $0 <version_number> <year>"
-  echo "Example: $0 3500400 2025"
-  exit 1
-fi
-
-VERSION_NUM="$1"
-YEAR="$2"
-
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-REPO_ROOT="$(cd "$SCRIPT_DIR/.." && pwd)"
-
-# Create temporary directory
-TEMP_DIR=$(mktemp -d)
-trap 'rm -rf "$TEMP_DIR"' EXIT
-
-cd "$TEMP_DIR"
-
-echo "Downloading SQLite source version $VERSION_NUM from year $YEAR..."
-DOWNLOAD_URL="https://sqlite.org/$YEAR/sqlite-src-$VERSION_NUM.zip"
-echo "URL: $DOWNLOAD_URL"
-
-wget -q "$DOWNLOAD_URL"
-unzip -q "sqlite-src-$VERSION_NUM.zip"
-cd "sqlite-src-$VERSION_NUM"
-
-echo "Configuring SQLite with required flags..."
-# These flags must be set during amalgamation generation for them to take effect
-# in the parser and other compile-time generated code
-CFLAGS="-DSQLITE_ENABLE_UPDATE_DELETE_LIMIT=1 -DSQLITE_ENABLE_COLUMN_METADATA=1"
-./configure CFLAGS="$CFLAGS" > /dev/null 2>&1
-
-echo "Building amalgamation..."
-make sqlite3.c > /dev/null 2>&1
-
-echo "Copying files to Bun source tree..."
-# Add clang-format off directive and copy the amalgamation
-echo "// clang-format off" > "$REPO_ROOT/src/bun.js/bindings/sqlite/sqlite3.c"
-cat sqlite3.c >> "$REPO_ROOT/src/bun.js/bindings/sqlite/sqlite3.c"
-
-echo "// clang-format off" > "$REPO_ROOT/src/bun.js/bindings/sqlite/sqlite3_local.h"
-cat sqlite3.h >> "$REPO_ROOT/src/bun.js/bindings/sqlite/sqlite3_local.h"
-
-echo "✓ Successfully updated SQLite amalgamation files"

shell.nix

@@ -1,103 +0,0 @@
-# Simple shell.nix for users without flakes enabled
-# For reproducible builds with locked dependencies, use: nix develop
-# This uses unpinned <nixpkgs> for simplicity; flake.nix provides version pinning via flake.lock
-{ pkgs ? import <nixpkgs> {} }:
-
-pkgs.mkShell rec {
-  packages = with pkgs; [
-    # Core build tools (matching bootstrap.sh)
-    cmake
-    ninja
-    clang_19
-    llvm_19
-    lld_19
-    nodejs_24
-    bun
-    rustc
-    cargo
-    go
-    python3
-    ccache
-    pkg-config
-    gnumake
-    libtool
-    ruby
-    perl
-
-    # Libraries
-    openssl
-    zlib
-    libxml2
-
-    # Development tools
-    git
-    curl
-    wget
-    unzip
-    xz
-
-    # Linux-specific: gdb and Chromium deps for testing
-  ] ++ pkgs.lib.optionals pkgs.stdenv.isLinux [
-    gdb
-    # Chromium dependencies for Puppeteer tests
-    xorg.libX11
-    xorg.libxcb
-    xorg.libXcomposite
-    xorg.libXcursor
-    xorg.libXdamage
-    xorg.libXext
-    xorg.libXfixes
-    xorg.libXi
-    xorg.libXrandr
-    xorg.libXrender
-    xorg.libXScrnSaver
-    xorg.libXtst
-    libxkbcommon
-    mesa
-    nspr
-    nss
-    cups
-    dbus
-    expat
-    fontconfig
-    freetype
-    glib
-    gtk3
-    pango
-    cairo
-    alsa-lib
-    at-spi2-atk
-    at-spi2-core
-    libgbm
-    liberation_ttf
-    atk
-    libdrm
-    xorg.libxshmfence
-    gdk-pixbuf
-  ];
-
-  shellHook = ''
-    export CC="${pkgs.lib.getExe pkgs.clang_19}"
-    export CXX="${pkgs.lib.getExe' pkgs.clang_19 "clang++"}"
-    export AR="${pkgs.llvm_19}/bin/llvm-ar"
-    export RANLIB="${pkgs.llvm_19}/bin/llvm-ranlib"
-    export CMAKE_C_COMPILER="$CC"
-    export CMAKE_CXX_COMPILER="$CXX"
-    export CMAKE_AR="$AR"
-    export CMAKE_RANLIB="$RANLIB"
-    export CMAKE_SYSTEM_PROCESSOR=$(uname -m)
-    export TMPDIR=''${TMPDIR:-/tmp}
-  '' + pkgs.lib.optionalString pkgs.stdenv.isLinux ''
-    export LD="${pkgs.lib.getExe' pkgs.lld_19 "ld.lld"}"
-    export NIX_CFLAGS_LINK="''${NIX_CFLAGS_LINK:+$NIX_CFLAGS_LINK }-fuse-ld=lld"
-    export LD_LIBRARY_PATH="${pkgs.lib.makeLibraryPath packages}''${LD_LIBRARY_PATH:+:$LD_LIBRARY_PATH}"
-  '' + ''
-
-    echo "====================================="
-    echo "Bun Development Environment (Nix)"
-    echo "====================================="
-    echo "To build: bun bd"
-    echo "To test:  bun bd test <test-file>"
-    echo "====================================="
-  '';
-}

src/AGENTS.md

@@ -1 +0,0 @@
-CLAUDE.md

src/CLAUDE.md

@@ -1,12 +0,0 @@
-## Zig
-
-Syntax reminders:
-
-- Private fields are fully supported in Zig with the `#` prefix. `struct { #foo: u32 };` makes a struct with a private field named `#foo`.
-- Decl literals in Zig are recommended. `const decl: Decl = .{ .binding = 0, .value = 0 };`
-
-Conventions:
-
-- Prefer `@import` at the **bottom** of the file.
-- It's `@import("bun")` not `@import("root").bun`
-- You must be patient with the build.

src/StandaloneModuleGraph.zig

@@ -431,27 +431,6 @@ pub const StandaloneModuleGraph = struct {
                 }
             };
 
-            if (comptime bun.Environment.is_canary or bun.Environment.isDebug) {
-                if (bun.getenvZ("BUN_FEATURE_FLAG_DUMP_CODE")) |dump_code_dir| {
-                    const buf = bun.path_buffer_pool.get();
-                    defer bun.path_buffer_pool.put(buf);
-                    const dest_z = bun.path.joinAbsStringBufZ(dump_code_dir, buf, &.{dest_path}, .auto);
-
-                    // Scoped block to handle dump failures without skipping module emission
-                    dump: {
-                        const file = bun.sys.File.makeOpen(dest_z, bun.O.WRONLY | bun.O.CREAT | bun.O.TRUNC, 0o664).unwrap() catch |err| {
-                            Output.prettyErrorln("<r><red>error<r><d>:<r> failed to open {s}: {s}", .{ dest_path, @errorName(err) });
-                            break :dump;
-                        };
-                        defer file.close();
-                        file.writeAll(output_file.value.buffer.bytes).unwrap() catch |err| {
-                            Output.prettyErrorln("<r><red>error<r><d>:<r> failed to write {s}: {s}", .{ dest_path, @errorName(err) });
-                            break :dump;
-                        };
-                    }
-                }
-            }
-
             var module = CompiledModuleGraphFile{
                 .name = string_builder.fmtAppendCountZ("{s}{s}", .{
                     prefix,
@@ -525,58 +504,25 @@ pub const StandaloneModuleGraph = struct {
 
     pub const CompileResult = union(enum) {
         success: void,
+        error_message: []const u8,
 
-        err: Error,
-
-        const Error = union(enum) {
-            message: []const u8,
-            reason: Reason,
-
-            pub const Reason = enum {
-                no_entry_point,
-                no_output_files,
-
-                pub fn message(this: Reason) []const u8 {
-                    return switch (this) {
-                        .no_entry_point => "No entry point found for compilation",
-                        .no_output_files => "No output files to bundle",
-                    };
-                }
-            };
-
-            pub fn slice(this: *const Error) []const u8 {
-                return switch (this.*) {
-                    .message => this.message,
-                    .reason => this.reason.message(),
-                };
-            }
-        };
-
-        pub fn fail(reason: Error.Reason) CompileResult {
-            return .{ .err = .{ .reason = reason } };
-        }
-
-        pub fn failFmt(comptime fmt: []const u8, args: anytype) CompileResult {
-            return .{ .err = .{ .message = bun.handleOom(std.fmt.allocPrint(bun.default_allocator, fmt, args)) } };
+        pub fn fail(msg: []const u8) CompileResult {
+            return .{ .error_message = msg };
         }
 
         pub fn deinit(this: *const @This()) void {
-            switch (this.*) {
-                .success => {},
-                .err => switch (this.err) {
-                    .message => bun.default_allocator.free(this.err.message),
-                    .reason => {},
-                },
+            if (this.* == .error_message) {
+                bun.default_allocator.free(this.error_message);
             }
         }
     };
 
     pub fn inject(bytes: []const u8, self_exe: [:0]const u8, inject_options: InjectOptions, target: *const CompileTarget) bun.FileDescriptor {
         var buf: bun.PathBuffer = undefined;
-        var zname: [:0]const u8 = bun.fs.FileSystem.tmpname("bun-build", &buf, @as(u64, @bitCast(std.time.milliTimestamp()))) catch |err| {
+        var zname: [:0]const u8 = bun.span(bun.fs.FileSystem.instance.tmpname("bun-build", &buf, @as(u64, @bitCast(std.time.milliTimestamp()))) catch |err| {
             Output.prettyErrorln("<r><red>error<r><d>:<r> failed to get temporary file name: {s}", .{@errorName(err)});
             return bun.invalid_fd;
-        };
+        });
 
         const cleanup = struct {
             pub fn toClean(name: [:0]const u8, fd: bun.FileDescriptor) void {
@@ -984,9 +930,9 @@ pub const StandaloneModuleGraph = struct {
         self_exe_path: ?[]const u8,
     ) !CompileResult {
         const bytes = toBytes(allocator, module_prefix, output_files, output_format, compile_exec_argv) catch |err| {
-            return CompileResult.failFmt("failed to generate module graph bytes: {s}", .{@errorName(err)});
+            return CompileResult.fail(std.fmt.allocPrint(allocator, "failed to generate module graph bytes: {s}", .{@errorName(err)}) catch "failed to generate module graph bytes");
         };
-        if (bytes.len == 0) return CompileResult.fail(.no_output_files);
+        if (bytes.len == 0) return CompileResult.fail("no output files to bundle");
         defer allocator.free(bytes);
 
         var free_self_exe = false;
@@ -995,26 +941,28 @@ pub const StandaloneModuleGraph = struct {
             break :brk bun.handleOom(allocator.dupeZ(u8, path));
         } else if (target.isDefault())
             bun.selfExePath() catch |err| {
-                return CompileResult.failFmt("failed to get self executable path: {s}", .{@errorName(err)});
+                return CompileResult.fail(std.fmt.allocPrint(allocator, "failed to get self executable path: {s}", .{@errorName(err)}) catch "failed to get self executable path");
             }
         else blk: {
             var exe_path_buf: bun.PathBuffer = undefined;
-            const version_str = bun.handleOom(std.fmt.allocPrintZ(allocator, "{}", .{target}));
-            defer allocator.free(version_str);
-
+            var version_str_buf: [1024]u8 = undefined;
+            const version_str = std.fmt.bufPrintZ(&version_str_buf, "{}", .{target}) catch {
+                return CompileResult.fail("failed to format target version string");
+            };
             var needs_download: bool = true;
             const dest_z = target.exePath(&exe_path_buf, version_str, env, &needs_download);
 
             if (needs_download) {
                 target.downloadToPath(env, allocator, dest_z) catch |err| {
-                    return switch (err) {
-                        error.TargetNotFound => CompileResult.failFmt("Target platform '{}' is not available for download. Check if this version of Bun supports this target.", .{target}),
-                        error.NetworkError => CompileResult.failFmt("Network error downloading executable for '{}'. Check your internet connection and proxy settings.", .{target}),
-                        error.InvalidResponse => CompileResult.failFmt("Downloaded file for '{}' appears to be corrupted. Please try again.", .{target}),
-                        error.ExtractionFailed => CompileResult.failFmt("Failed to extract executable for '{}'. The download may be incomplete.", .{target}),
-                        error.UnsupportedTarget => CompileResult.failFmt("Target '{}' is not supported", .{target}),
-                        else => CompileResult.failFmt("Failed to download '{}': {s}", .{ target, @errorName(err) }),
+                    const msg = switch (err) {
+                        error.TargetNotFound => std.fmt.allocPrint(allocator, "Target platform '{}' is not available for download. Check if this version of Bun supports this target.", .{target}) catch "Target platform not available for download",
+                        error.NetworkError => std.fmt.allocPrint(allocator, "Network error downloading executable for '{}'. Check your internet connection and proxy settings.", .{target}) catch "Network error downloading executable",
+                        error.InvalidResponse => std.fmt.allocPrint(allocator, "Downloaded file for '{}' appears to be corrupted. Please try again.", .{target}) catch "Downloaded file is corrupted",
+                        error.ExtractionFailed => std.fmt.allocPrint(allocator, "Failed to extract executable for '{}'. The download may be incomplete.", .{target}) catch "Failed to extract downloaded executable",
+                        error.UnsupportedTarget => std.fmt.allocPrint(allocator, "Target '{}' is not supported", .{target}) catch "Unsupported target",
+                        else => std.fmt.allocPrint(allocator, "Failed to download '{}': {s}", .{ target, @errorName(err) }) catch "Download failed",
                     };
+                    return CompileResult.fail(msg);
                 };
             }
 
@@ -1044,7 +992,7 @@ pub const StandaloneModuleGraph = struct {
             // Get the current path of the temp file
             var temp_buf: bun.PathBuffer = undefined;
             const temp_path = bun.getFdPath(fd, &temp_buf) catch |err| {
-                return CompileResult.failFmt("Failed to get temp file path: {s}", .{@errorName(err)});
+                return CompileResult.fail(std.fmt.allocPrint(allocator, "Failed to get temp file path: {s}", .{@errorName(err)}) catch "Failed to get temp file path");
             };
 
             // Build the absolute destination path
@@ -1052,7 +1000,7 @@ pub const StandaloneModuleGraph = struct {
             // Get the current working directory and join with outfile
             var cwd_buf: bun.PathBuffer = undefined;
             const cwd_path = bun.getcwd(&cwd_buf) catch |err| {
-                return CompileResult.failFmt("Failed to get current directory: {s}", .{@errorName(err)});
+                return CompileResult.fail(std.fmt.allocPrint(allocator, "Failed to get current directory: {s}", .{@errorName(err)}) catch "Failed to get current directory");
             };
             const dest_path = if (std.fs.path.isAbsolute(outfile))
                 outfile
@@ -1080,12 +1028,12 @@ pub const StandaloneModuleGraph = struct {
                 const err = bun.windows.Win32Error.get();
                 if (err.toSystemErrno()) |sys_err| {
                     if (sys_err == .EISDIR) {
-                        return CompileResult.failFmt("{s} is a directory. Please choose a different --outfile or delete the directory", .{outfile});
+                        return CompileResult.fail(std.fmt.allocPrint(allocator, "{s} is a directory. Please choose a different --outfile or delete the directory", .{outfile}) catch "outfile is a directory");
                     } else {
-                        return CompileResult.failFmt("failed to move executable to {s}: {s}", .{ dest_path, @tagName(sys_err) });
+                        return CompileResult.fail(std.fmt.allocPrint(allocator, "failed to move executable to {s}: {s}", .{ dest_path, @tagName(sys_err) }) catch "failed to move executable");
                     }
                 } else {
-                    return CompileResult.failFmt("failed to move executable to {s}", .{dest_path});
+                    return CompileResult.fail(std.fmt.allocPrint(allocator, "failed to move executable to {s}", .{dest_path}) catch "failed to move executable");
                 }
             }
 
@@ -1107,7 +1055,7 @@ pub const StandaloneModuleGraph = struct {
                     windows_options.description,
                     windows_options.copyright,
                 ) catch |err| {
-                    return CompileResult.failFmt("Failed to set Windows metadata: {s}", .{@errorName(err)});
+                    return CompileResult.fail(std.fmt.allocPrint(allocator, "Failed to set Windows metadata: {s}", .{@errorName(err)}) catch "Failed to set Windows metadata");
                 };
             }
             return .success;
@@ -1115,14 +1063,14 @@ pub const StandaloneModuleGraph = struct {
 
         var buf: bun.PathBuffer = undefined;
         const temp_location = bun.getFdPath(fd, &buf) catch |err| {
-            return CompileResult.failFmt("failed to get path for fd: {s}", .{@errorName(err)});
+            return CompileResult.fail(std.fmt.allocPrint(allocator, "failed to get path for fd: {s}", .{@errorName(err)}) catch "failed to get path for file descriptor");
         };
         const temp_posix = std.posix.toPosixPath(temp_location) catch |err| {
-            return CompileResult.failFmt("path too long: {s}", .{@errorName(err)});
+            return CompileResult.fail(std.fmt.allocPrint(allocator, "path too long: {s}", .{@errorName(err)}) catch "path too long");
         };
         const outfile_basename = std.fs.path.basename(outfile);
         const outfile_posix = std.posix.toPosixPath(outfile_basename) catch |err| {
-            return CompileResult.failFmt("outfile name too long: {s}", .{@errorName(err)});
+            return CompileResult.fail(std.fmt.allocPrint(allocator, "outfile name too long: {s}", .{@errorName(err)}) catch "outfile name too long");
         };
 
         bun.sys.moveFileZWithHandle(
@@ -1138,9 +1086,9 @@ pub const StandaloneModuleGraph = struct {
             _ = Syscall.unlink(&temp_posix);
 
             if (err == error.IsDir or err == error.EISDIR) {
-                return CompileResult.failFmt("{s} is a directory. Please choose a different --outfile or delete the directory", .{outfile});
+                return CompileResult.fail(std.fmt.allocPrint(allocator, "{s} is a directory. Please choose a different --outfile or delete the directory", .{outfile}) catch "outfile is a directory");
             } else {
-                return CompileResult.failFmt("failed to rename {s} to {s}: {s}", .{ temp_location, outfile, @errorName(err) });
+                return CompileResult.fail(std.fmt.allocPrint(allocator, "failed to rename {s} to {s}: {s}", .{ temp_location, outfile, @errorName(err) }) catch "failed to rename file");
             }
         };
 

src/allocators/mimalloc.zig

@@ -216,7 +216,8 @@ pub extern fn mi_new_reallocn(p: ?*anyopaque, newcount: usize, size: usize) ?*an
 pub const MI_SMALL_WSIZE_MAX = @as(c_int, 128);
 pub const MI_SMALL_SIZE_MAX = MI_SMALL_WSIZE_MAX * @import("std").zig.c_translation.sizeof(?*anyopaque);
 pub const MI_ALIGNMENT_MAX = (@as(c_int, 16) * @as(c_int, 1024)) * @as(c_ulong, 1024);
-pub const MI_MAX_ALIGN_SIZE = 16;
+
+const MI_MAX_ALIGN_SIZE = 16;
 
 pub fn mustUseAlignedAlloc(alignment: std.mem.Alignment) bool {
     return alignment.toByteUnits() > MI_MAX_ALIGN_SIZE;

src/api/schema.zig

@@ -321,9 +321,8 @@ pub const ByteWriter = Writer(*std.io.FixedBufferStream([]u8));
 pub const FileWriter = Writer(std.fs.File);
 
 pub const api = struct {
-    // these are in sync with BunLoaderType in headers-handwritten.h
     pub const Loader = enum(u8) {
-        _none = 254,
+        _none = 255,
         jsx = 1,
         js = 2,
         ts = 3,
@@ -3053,8 +3052,173 @@ pub const api = struct {
 
         security_scanner: ?[]const u8 = null,
 
-        minimum_release_age_ms: ?f64 = null,
-        minimum_release_age_excludes: ?[]const []const u8 = null,
+        pub fn decode(reader: anytype) anyerror!BunInstall {
+            var this = std.mem.zeroes(BunInstall);
+
+            while (true) {
+                switch (try reader.readByte()) {
+                    0 => {
+                        return this;
+                    },
+
+                    1 => {
+                        this.default_registry = try reader.readValue(NpmRegistry);
+                    },
+                    2 => {
+                        this.scoped = try reader.readValue(NpmRegistryMap);
+                    },
+                    3 => {
+                        this.lockfile_path = try reader.readValue([]const u8);
+                    },
+                    4 => {
+                        this.save_lockfile_path = try reader.readValue([]const u8);
+                    },
+                    5 => {
+                        this.cache_directory = try reader.readValue([]const u8);
+                    },
+                    6 => {
+                        this.dry_run = try reader.readValue(bool);
+                    },
+                    7 => {
+                        this.force = try reader.readValue(bool);
+                    },
+                    8 => {
+                        this.save_dev = try reader.readValue(bool);
+                    },
+                    9 => {
+                        this.save_optional = try reader.readValue(bool);
+                    },
+                    10 => {
+                        this.save_peer = try reader.readValue(bool);
+                    },
+                    11 => {
+                        this.save_lockfile = try reader.readValue(bool);
+                    },
+                    12 => {
+                        this.production = try reader.readValue(bool);
+                    },
+                    13 => {
+                        this.save_yarn_lockfile = try reader.readValue(bool);
+                    },
+                    14 => {
+                        this.native_bin_links = try reader.readArray([]const u8);
+                    },
+                    15 => {
+                        this.disable_cache = try reader.readValue(bool);
+                    },
+                    16 => {
+                        this.disable_manifest_cache = try reader.readValue(bool);
+                    },
+                    17 => {
+                        this.global_dir = try reader.readValue([]const u8);
+                    },
+                    18 => {
+                        this.global_bin_dir = try reader.readValue([]const u8);
+                    },
+                    19 => {
+                        this.frozen_lockfile = try reader.readValue(bool);
+                    },
+                    20 => {
+                        this.exact = try reader.readValue(bool);
+                    },
+                    21 => {
+                        this.concurrent_scripts = try reader.readValue(u32);
+                    },
+                    else => {
+                        return error.InvalidMessage;
+                    },
+                }
+            }
+            unreachable;
+        }
+
+        pub fn encode(this: *const @This(), writer: anytype) anyerror!void {
+            if (this.default_registry) |default_registry| {
+                try writer.writeFieldID(1);
+                try writer.writeValue(@TypeOf(default_registry), default_registry);
+            }
+            if (this.scoped) |scoped| {
+                try writer.writeFieldID(2);
+                try writer.writeValue(@TypeOf(scoped), scoped);
+            }
+            if (this.lockfile_path) |lockfile_path| {
+                try writer.writeFieldID(3);
+                try writer.writeValue(@TypeOf(lockfile_path), lockfile_path);
+            }
+            if (this.save_lockfile_path) |save_lockfile_path| {
+                try writer.writeFieldID(4);
+                try writer.writeValue(@TypeOf(save_lockfile_path), save_lockfile_path);
+            }
+            if (this.cache_directory) |cache_directory| {
+                try writer.writeFieldID(5);
+                try writer.writeValue(@TypeOf(cache_directory), cache_directory);
+            }
+            if (this.dry_run) |dry_run| {
+                try writer.writeFieldID(6);
+                try writer.writeInt(@as(u8, @intFromBool(dry_run)));
+            }
+            if (this.force) |force| {
+                try writer.writeFieldID(7);
+                try writer.writeInt(@as(u8, @intFromBool(force)));
+            }
+            if (this.save_dev) |save_dev| {
+                try writer.writeFieldID(8);
+                try writer.writeInt(@as(u8, @intFromBool(save_dev)));
+            }
+            if (this.save_optional) |save_optional| {
+                try writer.writeFieldID(9);
+                try writer.writeInt(@as(u8, @intFromBool(save_optional)));
+            }
+            if (this.save_peer) |save_peer| {
+                try writer.writeFieldID(10);
+                try writer.writeInt(@as(u8, @intFromBool(save_peer)));
+            }
+            if (this.save_lockfile) |save_lockfile| {
+                try writer.writeFieldID(11);
+                try writer.writeInt(@as(u8, @intFromBool(save_lockfile)));
+            }
+            if (this.production) |production| {
+                try writer.writeFieldID(12);
+                try writer.writeInt(@as(u8, @intFromBool(production)));
+            }
+            if (this.save_yarn_lockfile) |save_yarn_lockfile| {
+                try writer.writeFieldID(13);
+                try writer.writeInt(@as(u8, @intFromBool(save_yarn_lockfile)));
+            }
+            if (this.native_bin_links) |native_bin_links| {
+                try writer.writeFieldID(14);
+                try writer.writeArray([]const u8, native_bin_links);
+            }
+            if (this.disable_cache) |disable_cache| {
+                try writer.writeFieldID(15);
+                try writer.writeInt(@as(u8, @intFromBool(disable_cache)));
+            }
+            if (this.disable_manifest_cache) |disable_manifest_cache| {
+                try writer.writeFieldID(16);
+                try writer.writeInt(@as(u8, @intFromBool(disable_manifest_cache)));
+            }
+            if (this.global_dir) |global_dir| {
+                try writer.writeFieldID(17);
+                try writer.writeValue(@TypeOf(global_dir), global_dir);
+            }
+            if (this.global_bin_dir) |global_bin_dir| {
+                try writer.writeFieldID(18);
+                try writer.writeValue(@TypeOf(global_bin_dir), global_bin_dir);
+            }
+            if (this.frozen_lockfile) |frozen_lockfile| {
+                try writer.writeFieldID(19);
+                try writer.writeInt(@as(u8, @intFromBool(frozen_lockfile)));
+            }
+            if (this.exact) |exact| {
+                try writer.writeFieldID(20);
+                try writer.writeInt(@as(u8, @intFromBool(exact)));
+            }
+            if (this.concurrent_scripts) |concurrent_scripts| {
+                try writer.writeFieldID(21);
+                try writer.writeInt(concurrent_scripts);
+            }
+            try writer.endMessage();
+        }
     };
 
     pub const ClientServerModule = struct {

src/ast/SideEffects.zig

@@ -205,18 +205,9 @@ pub const SideEffects = enum(u1) {
                     .bin_ge,
                     => {
                         if (isPrimitiveWithSideEffects(bin.left.data) and isPrimitiveWithSideEffects(bin.right.data)) {
-                            const left_simplified = simplifyUnusedExpr(p, bin.left);
-                            const right_simplified = simplifyUnusedExpr(p, bin.right);
-
-                            // If both sides would be removed entirely, we can return null to remove the whole expression
-                            if (left_simplified == null and right_simplified == null) {
-                                return null;
-                            }
-
-                            // Otherwise, preserve at least the structure
                             return Expr.joinWithComma(
-                                left_simplified orelse bin.left.toEmpty(),
-                                right_simplified orelse bin.right.toEmpty(),
+                                simplifyUnusedExpr(p, bin.left) orelse bin.left.toEmpty(),
+                                simplifyUnusedExpr(p, bin.right) orelse bin.right.toEmpty(),
                                 p.allocator,
                             );
                         }

src/ast/parse.zig

@@ -587,7 +587,7 @@ pub fn Parse(
                 var estr = try p.lexer.toEString();
                 if (estr.isUTF8()) {
                     return estr.slice8();
-                } else if (strings.toUTF8AllocWithTypeWithoutInvalidSurrogatePairs(p.lexer.allocator, estr.slice16())) |alias_utf8| {
+                } else if (strings.toUTF8AllocWithTypeWithoutInvalidSurrogatePairs(p.lexer.allocator, []const u16, estr.slice16())) |alias_utf8| {
                     return alias_utf8;
                 } else |err| {
                     const r = p.source.rangeOfString(loc);

src/ast/parseStmt.zig

@@ -1223,9 +1223,8 @@ pub fn ParseStmt(
                                 // "module Foo {}"
                                 // "declare module 'fs' {}"
                                 // "declare module 'fs';"
-                                if (!p.lexer.has_newline_before and
-                                    (opts.is_module_scope or opts.is_namespace_scope) and
-                                    (p.lexer.token == .t_identifier or (p.lexer.token == .t_string_literal and opts.is_typescript_declare)))
+                                if (((opts.is_module_scope or opts.is_namespace_scope) and (p.lexer.token == .t_identifier or
+                                    (p.lexer.token == .t_string_literal and opts.is_typescript_declare))))
                                 {
                                     return p.parseTypeScriptNamespaceStmt(loc, opts);
                                 }

src/ast/parseTypescript.zig

@@ -210,7 +210,7 @@ pub fn ParseTypescript(
             p.popScope();
 
             if (!opts.is_typescript_declare) {
-                name.ref = try p.declareSymbol(.ts_namespace, name_loc, name_text);
+                name.ref = bun.handleOom(p.declareSymbol(.ts_namespace, name_loc, name_text));
                 try p.ref_to_ts_namespace_member.put(p.allocator, name.ref.?, ns_member_data);
             }
 

src/ast/visitBinaryExpression.zig

@@ -136,9 +136,6 @@ pub fn CreateBinaryExpressionVisitor(
                         // "(0, this.fn)()" => "(0, this.fn)()"
                         if (p.options.features.minify_syntax) {
                             if (SideEffects.simplifyUnusedExpr(p, e_.left)) |simplified_left| {
-                                if (simplified_left.isEmpty()) {
-                                    return e_.right;
-                                }
                                 e_.left = simplified_left;
                             } else {
                                 // The left operand has no side effects, but we need to preserve

src/ast/visitStmt.zig

@@ -1315,10 +1315,10 @@ pub fn VisitStmt(
                     try p.top_level_enums.append(p.allocator, data.name.ref.?);
                 }
 
-                try p.recordDeclaredSymbol(data.name.ref.?);
-                try p.pushScopeForVisitPass(.entry, stmt.loc);
+                bun.handleOom(p.recordDeclaredSymbol(data.name.ref.?));
+                bun.handleOom(p.pushScopeForVisitPass(.entry, stmt.loc));
                 defer p.popScope();
-                try p.recordDeclaredSymbol(data.arg);
+                bun.handleOom(p.recordDeclaredSymbol(data.arg));
 
                 const allocator = p.allocator;
                 // Scan ahead for any variables inside this namespace. This must be done
@@ -1327,7 +1327,7 @@ pub fn VisitStmt(
                 // We need to convert the uses into property accesses on the namespace.
                 for (data.values) |value| {
                     if (value.ref.isValid()) {
-                        try p.is_exported_inside_namespace.put(allocator, value.ref, data.arg);
+                        bun.handleOom(p.is_exported_inside_namespace.put(allocator, value.ref, data.arg));
                     }
                 }
 
@@ -1336,7 +1336,7 @@ pub fn VisitStmt(
                 // without initializers are initialized to undefined.
                 var next_numeric_value: ?f64 = 0.0;
 
-                var value_exprs = try ListManaged(Expr).initCapacity(allocator, data.values.len);
+                var value_exprs = bun.handleOom(ListManaged(Expr).initCapacity(allocator, data.values.len));
 
                 var all_values_are_pure = true;
 

src/bake/DevServer.bind.ts

@@ -1,5 +1,5 @@
 // @ts-ignore
-import { fn, t } from "bindgen";
+import { fn, t } from "../codegen/bindgen-lib";
 export const getDeinitCountForTesting = fn({
   args: {},
   ret: t.usize,

src/bake/DevServer.zig

@@ -2334,7 +2334,6 @@ pub fn finalizeBundle(
             result.chunks,
             null,
             false,
-            false,
         );
 
         // Create an entry for this file.
@@ -3353,15 +3352,13 @@ fn sendSerializedFailures(
                 }
             }
             const fetch_headers = try headers.toFetchHeaders(r.global);
-            var response = Response.init(
-                .{
+            var response = Response{
+                .body = .{ .value = .{ .Blob = any_blob.toBlob(r.global) } },
+                .init = Response.Init{
                     .status_code = 500,
                     .headers = fetch_headers,
                 },
-                .{ .value = .{ .Blob = any_blob.toBlob(r.global) } },
-                bun.String.empty,
-                false,
-            );
+            };
             dev.vm.eventLoop().enter();
             r.promise.reject(r.global, response.toJS(r.global));
             defer dev.vm.eventLoop().exit();

src/bake/bake.d.ts

@@ -5,6 +5,8 @@
 // /// <reference path="/path/to/bun/src/bake/bake.d.ts" />
 
 declare module "bun" {
+  type Awaitable<T> = T | Promise<T>;
+
   declare namespace Bake {
     interface Options {
       /**
@@ -367,7 +369,7 @@ declare module "bun" {
        * A common pattern would be to enforce the object is
        * `{ default: ReactComponent }`
        */
-      render: (request: Request, routeMetadata: RouteMetadata) => MaybePromise<Response>;
+      render: (request: Request, routeMetadata: RouteMetadata) => Awaitable<Response>;
       /**
        * Prerendering does not use a request, and is allowed to generate
        * multiple responses. This is used for static site generation, but not
@@ -377,7 +379,7 @@ declare module "bun" {
        * Note that `import.meta.env.STATIC` will be inlined to true during
        * a static build.
        */
-      prerender?: (routeMetadata: RouteMetadata) => MaybePromise<PrerenderResult | null>;
+      prerender?: (routeMetadata: RouteMetadata) => Awaitable<PrerenderResult | null>;
       // TODO: prerenderWithoutProps (for partial prerendering)
       /**
        * For prerendering routes with dynamic parameters, such as `/blog/:slug`,
@@ -407,7 +409,7 @@ declare module "bun" {
        *         return { exhaustive: false };
        *     }
        */
-      getParams?: (paramsMetadata: ParamsMetadata) => MaybePromise<GetParamIterator>;
+      getParams?: (paramsMetadata: ParamsMetadata) => Awaitable<GetParamIterator>;
       /**
        * When a dynamic build uses static assets, Bun can map content types in the
        * user's `Accept` header to the different static files.
@@ -446,7 +448,7 @@ declare module "bun" {
     }
 
     interface DevServerHookEntryPoint {
-      default: (dev: DevServerHookAPI) => MaybePromise<void>;
+      default: (dev: DevServerHookAPI) => Awaitable<void>;
     }
 
     interface DevServerHookAPI {
@@ -503,7 +505,7 @@ declare module "bun" {
     }
   }
 
-  declare interface BaseServeOptions {
+  declare interface GenericServeOptions {
     /** Add a fullstack web app to this server using Bun Bake */
     app?: Bake.Options | undefined;
   }

src/bake/tsconfig.json

@@ -2,7 +2,6 @@
   "extends": "../../tsconfig.base.json",
   "compilerOptions": {
     "lib": ["ESNext", "DOM", "DOM.Iterable", "DOM.AsyncIterable"],
-    "baseUrl": ".",
     "paths": {
       "bun-framework-react/*": ["./bun-framework-react/*"],
       "bindgen": ["../codegen/bindgen-lib"]

src/bun.js.zig

@@ -1,7 +1,6 @@
 pub const jsc = @import("./bun.js/jsc.zig");
 pub const webcore = @import("./bun.js/webcore.zig");
 pub const api = @import("./bun.js/api.zig");
-pub const bindgen = @import("./bun.js/bindgen.zig");
 
 pub const Run = struct {
     ctx: Command.Context,

src/bun.js/ConsoleObject.zig

@@ -153,10 +153,6 @@ fn messageWithTypeAndLevel_(
     var writer = buffered_writer.writer();
     const Writer = @TypeOf(writer);
 
-    if (bun.jsc.Jest.Jest.runner) |runner| {
-        runner.bun_test_root.onBeforePrint();
-    }
-
     var print_length = len;
     // Get console depth from CLI options or bunfig, fallback to default
     const cli_context = CLI.get();
@@ -1720,7 +1716,7 @@ pub const Formatter = struct {
             }
 
             pub inline fn write16Bit(self: *@This(), input: []const u16) void {
-                bun.fmt.formatUTF16Type(input, self.ctx) catch {
+                bun.fmt.formatUTF16Type([]const u16, input, self.ctx) catch {
                     self.failed = true;
                 };
             }
@@ -2166,7 +2162,7 @@ pub const Formatter = struct {
                     writer.writeAll(slice);
                 } else if (!str.isEmpty()) {
                     // slow path
-                    const buf = strings.allocateLatin1IntoUTF8(bun.default_allocator, str.latin1()) catch &[_]u8{};
+                    const buf = strings.allocateLatin1IntoUTF8(bun.default_allocator, []const u8, str.latin1()) catch &[_]u8{};
                     if (buf.len > 0) {
                         defer bun.default_allocator.free(buf);
                         writer.writeAll(buf);

src/bun.js/ModuleLoader.zig

@@ -38,7 +38,7 @@ pub fn resolveEmbeddedFile(vm: *VirtualMachine, input_path: []const u8, extname:
 
     // atomically write to a tmpfile and then move it to the final destination
     var tmpname_buf: bun.PathBuffer = undefined;
-    const tmpfilename = bun.fs.FileSystem.tmpname(extname, &tmpname_buf, bun.hash(file.name)) catch return null;
+    const tmpfilename = bun.sliceTo(bun.fs.FileSystem.instance.tmpname(extname, &tmpname_buf, bun.hash(file.name)) catch return null, 0);
 
     const tmpdir: bun.FD = .fromStdDir(bun.fs.FileSystem.instance.tmpdir() catch return null);
 
@@ -1350,10 +1350,10 @@ pub fn transpileSourceCode(
                 if (virtual_source) |source| {
                     if (globalObject) |globalThis| {
                         // attempt to avoid reading the WASM file twice.
-                        const decoded: jsc.DecodedJSValue = .{
-                            .u = .{ .ptr = @ptrCast(globalThis) },
+                        const encoded = jsc.EncodedJSValue{
+                            .asPtr = globalThis,
                         };
-                        const globalValue = decoded.encode();
+                        const globalValue = @as(JSValue, @enumFromInt(encoded.asInt64));
                         globalValue.put(
                             globalThis,
                             ZigString.static("wasmSourceBytes"),
@@ -1600,10 +1600,9 @@ pub export fn Bun__transpileFile(
     ret: *jsc.ErrorableResolvedSource,
     allow_promise: bool,
     is_commonjs_require: bool,
-    _force_loader_type: bun.schema.api.Loader,
+    force_loader_type: bun.options.Loader.Optional,
 ) ?*anyopaque {
     jsc.markBinding(@src());
-    const force_loader_type: bun.options.Loader.Optional = .fromAPI(_force_loader_type);
     var log = logger.Log.init(jsc_vm.transpiler.allocator);
     defer log.deinit();
 

src/bun.js/RuntimeTranspilerCache.zig

@@ -163,7 +163,7 @@ pub const RuntimeTranspilerCache = struct {
 
             // atomically write to a tmpfile and then move it to the final destination
             var tmpname_buf: bun.PathBuffer = undefined;
-            const tmpfilename = try bun.fs.FileSystem.tmpname(std.fs.path.extension(destination_path.slice()), &tmpname_buf, input_hash);
+            const tmpfilename = bun.sliceTo(try bun.fs.FileSystem.instance.tmpname(std.fs.path.extension(destination_path.slice()), &tmpname_buf, input_hash), 0);
 
             const output_bytes = output_code.byteSlice();
 

src/bun.js/Strong.zig

@@ -114,16 +114,15 @@ pub const Optional = struct {
     }
 };
 
-pub const Impl = opaque {
+const Impl = opaque {
     pub fn init(global: *jsc.JSGlobalObject, value: jsc.JSValue) *Impl {
         jsc.markBinding(@src());
         return Bun__StrongRef__new(global, value);
     }
 
     pub fn get(this: *Impl) jsc.JSValue {
-        // `this` is actually a pointer to a `JSC::JSValue`; see Strong.cpp.
-        const js_value: *jsc.DecodedJSValue = @ptrCast(@alignCast(this));
-        return js_value.encode();
+        jsc.markBinding(@src());
+        return Bun__StrongRef__get(this);
     }
 
     pub fn set(this: *Impl, global: *jsc.JSGlobalObject, value: jsc.JSValue) void {
@@ -143,6 +142,7 @@ pub const Impl = opaque {
 
     extern fn Bun__StrongRef__delete(this: *Impl) void;
     extern fn Bun__StrongRef__new(*jsc.JSGlobalObject, jsc.JSValue) *Impl;
+    extern fn Bun__StrongRef__get(this: *Impl) jsc.JSValue;
     extern fn Bun__StrongRef__set(this: *Impl, *jsc.JSGlobalObject, jsc.JSValue) void;
     extern fn Bun__StrongRef__clear(this: *Impl) void;
 };

src/bun.js/VirtualMachine.zig

@@ -2677,9 +2677,7 @@ pub fn remapZigException(
             }
 
             // Workaround for being unable to hide that specific frame without also hiding the frame before it
-            if ((frame.source_url.isEmpty() or frame.source_url.eqlComptime("[unknown]") or frame.source_url.hasPrefixComptime("[source:")) and
-                NoisyBuiltinFunctionMap.getWithEql(frame.function_name, String.eqlComptime) != null)
-            {
+            if (frame.source_url.isEmpty() and NoisyBuiltinFunctionMap.getWithEql(frame.function_name, String.eqlComptime) != null) {
                 start_index = 0;
                 break;
             }
@@ -2695,9 +2693,7 @@ pub fn remapZigException(
                 }
 
                 // Workaround for being unable to hide that specific frame without also hiding the frame before it
-                if ((frame.source_url.isEmpty() or frame.source_url.eqlComptime("[unknown]") or frame.source_url.hasPrefixComptime("[source:")) and
-                    NoisyBuiltinFunctionMap.getWithEql(frame.function_name, String.eqlComptime) != null)
-                {
+                if (frame.source_url.isEmpty() and NoisyBuiltinFunctionMap.getWithEql(frame.function_name, String.eqlComptime) != null) {
                     continue;
                 }
 
@@ -2719,9 +2715,7 @@ pub fn remapZigException(
                 frame.source_url.hasPrefixComptime("node:") or
                 frame.source_url.isEmpty() or
                 frame.source_url.eqlComptime("native") or
-                frame.source_url.eqlComptime("unknown") or
-                frame.source_url.eqlComptime("[unknown]") or
-                frame.source_url.hasPrefixComptime("[source:"))
+                frame.source_url.eqlComptime("unknown"))
             {
                 top_frame_is_builtin = true;
                 continue;

src/bun.js/api.zig

@@ -22,8 +22,6 @@ pub const SocketAddress = @import("./api/bun/socket.zig").SocketAddress;
 pub const TCPSocket = @import("./api/bun/socket.zig").TCPSocket;
 pub const TLSSocket = @import("./api/bun/socket.zig").TLSSocket;
 pub const SocketHandlers = @import("./api/bun/socket.zig").Handlers;
-pub const QuicSocket = @import("./api/bun/quic_socket.zig").QuicSocket;
-pub const QuicStream = @import("./api/bun/quic_stream.zig").QuicStream;
 
 pub const Subprocess = @import("./api/bun/subprocess.zig");
 pub const HashObject = @import("./api/HashObject.zig");

src/bun.js/api/BunObject.zig

@@ -27,7 +27,6 @@ pub const BunObject = struct {
     pub const mmap = toJSCallback(Bun.mmapFile);
     pub const nanoseconds = toJSCallback(Bun.nanoseconds);
     pub const openInEditor = toJSCallback(Bun.openInEditor);
-    pub const quic = toJSCallback(host_fn.wrapStaticMethod(api.QuicSocket, "quic", false));
     pub const registerMacro = toJSCallback(Bun.registerMacro);
     pub const resolve = toJSCallback(Bun.resolve);
     pub const resolveSync = toJSCallback(Bun.resolveSync);
@@ -164,7 +163,6 @@ pub const BunObject = struct {
         @export(&BunObject.mmap, .{ .name = callbackName("mmap") });
         @export(&BunObject.nanoseconds, .{ .name = callbackName("nanoseconds") });
         @export(&BunObject.openInEditor, .{ .name = callbackName("openInEditor") });
-        @export(&BunObject.quic, .{ .name = callbackName("quic") });
         @export(&BunObject.registerMacro, .{ .name = callbackName("registerMacro") });
         @export(&BunObject.resolve, .{ .name = callbackName("resolve") });
         @export(&BunObject.resolveSync, .{ .name = callbackName("resolveSync") });
@@ -1839,10 +1837,31 @@ pub const JSZstd = struct {
         const input = buffer.slice();
         const allocator = bun.default_allocator;
 
-        const output = bun.zstd.decompressAlloc(allocator, input) catch |err| {
-            return globalThis.ERR(.ZSTD, "Decompression failed: {s}", .{@errorName(err)}).throw();
+        // Try to get the decompressed size
+        const decompressed_size = bun.zstd.getDecompressedSize(input);
+
+        if (decompressed_size == std.math.maxInt(c_ulonglong) - 1 or decompressed_size == std.math.maxInt(c_ulonglong) - 2) {
+            // If size is unknown, we'll need to decompress in chunks
+            return globalThis.ERR(.ZSTD, "Decompressed size is unknown. Either the input is not a valid zstd compressed buffer or the decompressed size is too large. If you run into this error with a valid input, please file an issue at https://github.com/oven-sh/bun/issues", .{}).throw();
+        }
+
+        // Allocate output buffer based on decompressed size
+        var output = try allocator.alloc(u8, decompressed_size);
+
+        // Perform decompression
+        const actual_size = switch (bun.zstd.decompress(output, input)) {
+            .success => |actual_size| actual_size,
+            .err => |err| {
+                allocator.free(output);
+                return globalThis.ERR(.ZSTD, "{s}", .{err}).throw();
+            },
         };
 
+        bun.debugAssert(actual_size <= output.len);
+
+        // mimalloc doesn't care about the self-reported size of the slice.
+        output.len = actual_size;
+
         return jsc.JSValue.createBuffer(globalThis, output);
     }
 
@@ -1899,10 +1918,34 @@ pub const JSZstd = struct {
                 };
             } else {
                 // Decompression path
-                job.output = bun.zstd.decompressAlloc(allocator, input) catch {
-                    job.error_message = "Decompression failed";
+                // Try to get the decompressed size
+                const decompressed_size = bun.zstd.getDecompressedSize(input);
+
+                if (decompressed_size == std.math.maxInt(c_ulonglong) - 1 or decompressed_size == std.math.maxInt(c_ulonglong) - 2) {
+                    job.error_message = "Decompressed size is unknown. Either the input is not a valid zstd compressed buffer or the decompressed size is too large";
+                    return;
+                }
+
+                // Allocate output buffer based on decompressed size
+                job.output = allocator.alloc(u8, decompressed_size) catch {
+                    job.error_message = "Out of memory";
                     return;
                 };
+
+                // Perform decompression
+                switch (bun.zstd.decompress(job.output, input)) {
+                    .success => |actual_size| {
+                        if (actual_size < job.output.len) {
+                            job.output.len = actual_size;
+                        }
+                    },
+                    .err => |err| {
+                        allocator.free(job.output);
+                        job.output = &[_]u8{};
+                        job.error_message = err;
+                        return;
+                    },
+                }
             }
         }
 

src/bun.js/api/Timer/EventLoopTimer.zig

@@ -47,7 +47,7 @@ pub fn less(_: void, a: *const Self, b: *const Self) bool {
     return order == .lt;
 }
 
-pub const Tag = enum {
+pub const Tag = if (Environment.isWindows) enum {
     TimerCallback,
     TimeoutObject,
     ImmediateObject,
@@ -78,7 +78,7 @@ pub const Tag = enum {
             .StatWatcherScheduler => StatWatcherScheduler,
             .UpgradedDuplex => uws.UpgradedDuplex,
             .DNSResolver => DNSResolver,
-            .WindowsNamedPipe => if (Environment.isWindows) uws.WindowsNamedPipe else UnreachableTimer,
+            .WindowsNamedPipe => uws.WindowsNamedPipe,
             .WTFTimer => WTFTimer,
             .PostgresSQLConnectionTimeout => jsc.Postgres.PostgresSQLConnection,
             .PostgresSQLConnectionMaxLifetime => jsc.Postgres.PostgresSQLConnection,
@@ -96,13 +96,52 @@ pub const Tag = enum {
             .EventLoopDelayMonitor => jsc.API.Timer.EventLoopDelayMonitor,
         };
     }
-};
+} else enum {
+    TimerCallback,
+    TimeoutObject,
+    ImmediateObject,
+    StatWatcherScheduler,
+    UpgradedDuplex,
+    WTFTimer,
+    DNSResolver,
+    PostgresSQLConnectionTimeout,
+    PostgresSQLConnectionMaxLifetime,
+    MySQLConnectionTimeout,
+    MySQLConnectionMaxLifetime,
+    ValkeyConnectionTimeout,
+    ValkeyConnectionReconnect,
+    SubprocessTimeout,
+    DevServerSweepSourceMaps,
+    DevServerMemoryVisualizerTick,
+    AbortSignalTimeout,
+    DateHeaderTimer,
+    BunTest,
+    EventLoopDelayMonitor,
 
-const UnreachableTimer = struct {
-    event_loop_timer: Self,
-    fn callback(_: *UnreachableTimer, _: *UnreachableTimer) Arm {
-        if (Environment.ci_assert) bun.assert(false);
-        return .disarm;
+    pub fn Type(comptime T: Tag) type {
+        return switch (T) {
+            .TimerCallback => TimerCallback,
+            .TimeoutObject => TimeoutObject,
+            .ImmediateObject => ImmediateObject,
+            .StatWatcherScheduler => StatWatcherScheduler,
+            .UpgradedDuplex => uws.UpgradedDuplex,
+            .WTFTimer => WTFTimer,
+            .DNSResolver => DNSResolver,
+            .PostgresSQLConnectionTimeout => jsc.Postgres.PostgresSQLConnection,
+            .PostgresSQLConnectionMaxLifetime => jsc.Postgres.PostgresSQLConnection,
+            .MySQLConnectionTimeout => jsc.MySQL.MySQLConnection,
+            .MySQLConnectionMaxLifetime => jsc.MySQL.MySQLConnection,
+            .ValkeyConnectionTimeout => jsc.API.Valkey,
+            .ValkeyConnectionReconnect => jsc.API.Valkey,
+            .SubprocessTimeout => jsc.Subprocess,
+            .DevServerSweepSourceMaps,
+            .DevServerMemoryVisualizerTick,
+            => bun.bake.DevServer,
+            .AbortSignalTimeout => jsc.WebCore.AbortSignal.Timeout,
+            .DateHeaderTimer => jsc.API.Timer.DateHeaderTimer,
+            .BunTest => jsc.Jest.bun_test.BunTest,
+            .EventLoopDelayMonitor => jsc.API.Timer.EventLoopDelayMonitor,
+        };
     }
 };
 

src/bun.js/api/Timer/WTFTimer.zig

@@ -35,13 +35,10 @@ inline fn runWithoutRemoving(this: *const WTFTimer) void {
 
 pub fn update(this: *WTFTimer, seconds: f64, repeat: bool) void {
     // There's only one of these per VM, and each VM has its own imminent_gc_timer
-    // Only set imminent if it's not already set to avoid overwriting another timer
-    if (seconds == 0) {
-        _ = this.imminent.cmpxchgStrong(null, this, .seq_cst, .seq_cst);
+    this.imminent.store(if (seconds == 0) this else null, .seq_cst);
+
+    if (seconds == 0.0) {
         return;
-    } else {
-        // Clear imminent if this timer was the one that set it
-        _ = this.imminent.cmpxchgStrong(this, null, .seq_cst, .seq_cst);
     }
 
     const modf = std.math.modf(seconds);
@@ -62,8 +59,7 @@ pub fn cancel(this: *WTFTimer) void {
     defer this.lock.unlock();
 
     if (this.script_execution_context_id.valid()) {
-        // Only clear imminent if this timer was the one that set it
-        _ = this.imminent.cmpxchgStrong(this, null, .seq_cst, .seq_cst);
+        this.imminent.store(null, .seq_cst);
 
         if (this.event_loop_timer.state == .ACTIVE) {
             this.vm.timer.remove(&this.event_loop_timer);
@@ -73,15 +69,10 @@ pub fn cancel(this: *WTFTimer) void {
 
 pub fn fire(this: *WTFTimer, _: *const bun.timespec, _: *VirtualMachine) EventLoopTimer.Arm {
     this.event_loop_timer.state = .FIRED;
-    // Only clear imminent if this timer was the one that set it
-    _ = this.imminent.cmpxchgStrong(this, null, .seq_cst, .seq_cst);
-    // Read `repeat` and `next` before calling runWithoutRemoving(), because the callback
-    // might destroy `this` (e.g., when Atomics.waitAsync creates a one-shot DispatchTimer).
-    const should_repeat = this.repeat;
-    const next_time = this.event_loop_timer.next;
+    this.imminent.store(null, .seq_cst);
     this.runWithoutRemoving();
-    return if (should_repeat)
-        .{ .rearm = next_time }
+    return if (this.repeat)
+        .{ .rearm = this.event_loop_timer.next }
     else
         .disarm;
 }

src/bun.js/api/bun/quic_stream.zig

@@ -1,378 +0,0 @@
-const std = @import("std");
-const bun = @import("../../../bun.zig");
-const jsc = bun.jsc;
-const uws = bun.uws;
-const Environment = bun.Environment;
-const Async = bun.Async;
-
-const log = bun.Output.scoped(.QuicStream, .visible);
-
-pub const QuicStream = struct {
-    const This = @This();
-
-    // JavaScript class bindings
-    pub const js = jsc.Codegen.JSQuicStream;
-    pub const toJS = js.toJS;
-    pub const fromJS = js.fromJS;
-    pub const fromJSDirect = js.fromJSDirect;
-
-    pub const new = bun.TrivialNew(@This());
-
-    const RefCount = bun.ptr.RefCount(@This(), "ref_count", deinit, .{});
-    pub const ref = RefCount.ref;
-    pub const deref = RefCount.deref;
-
-    // The underlying lsquic stream
-    stream: ?*uws.quic.Stream = null,
-
-    // Reference to parent socket
-    socket: *QuicSocket,
-
-    // Stream ID
-    stream_id: u64,
-
-    // Optional data attached to the stream
-    data_value: jsc.JSValue = .zero,
-
-    // JavaScript this value
-    this_value: jsc.JSValue = .zero,
-
-    // Reference counting
-    ref_count: RefCount,
-    poll_ref: Async.KeepAlive = Async.KeepAlive.init(),
-
-    // Stream state
-    flags: Flags = .{},
-
-    // Buffered writes before stream is connected
-    write_buffer: std.ArrayList([]const u8) = undefined,
-    write_buffer_initialized: bool = false,
-    write_buffer_mutex: std.Thread.Mutex = .{},
-
-    has_pending_activity: std.atomic.Value(bool) = std.atomic.Value(bool).init(true),
-
-    pub const Flags = packed struct {
-        is_readable: bool = true,
-        is_writable: bool = true,
-        is_closed: bool = false,
-        has_backpressure: bool = false,
-        fin_sent: bool = false,
-        fin_received: bool = false,
-        _: u26 = 0,
-    };
-
-    pub fn hasPendingActivity(this: *This) callconv(.C) bool {
-        return this.has_pending_activity.load(.acquire);
-    }
-
-    pub fn memoryCost(_: *This) usize {
-        return @sizeOf(This);
-    }
-
-    pub fn finalize(this: *This) void {
-        this.deinit();
-    }
-
-    pub fn deinit(this: *This) void {
-        this.poll_ref.unref(jsc.VirtualMachine.get());
-
-        // Clean up write buffer
-        if (this.write_buffer_initialized) {
-            this.write_buffer_mutex.lock();
-            defer this.write_buffer_mutex.unlock();
-
-            // Free any buffered write data
-            for (this.write_buffer.items) |buffered_data| {
-                bun.default_allocator.free(buffered_data);
-            }
-            this.write_buffer.deinit();
-            this.write_buffer_initialized = false;
-        }
-
-        // Unprotect the data value if set
-        if (!this.data_value.isEmptyOrUndefinedOrNull()) {
-            this.data_value.unprotect();
-            this.data_value = .zero;
-        }
-
-        // Close stream if still open
-        if (this.stream != null and !this.flags.is_closed) {
-            this.closeImpl();
-        }
-
-        // Deref the parent socket
-        this.socket.deref();
-    }
-
-    // Initialize a new QUIC stream
-    pub fn init(allocator: std.mem.Allocator, socket: *QuicSocket, stream_id: u64, data_value: jsc.JSValue) !*This {
-        const this = try allocator.create(This);
-        this.* = This{
-            .ref_count = RefCount.init(),
-            .socket = socket,
-            .stream_id = stream_id,
-            .data_value = data_value,
-        };
-
-        // Initialize write buffer
-        this.write_buffer = std.ArrayList([]const u8).init(allocator);
-        this.write_buffer_initialized = true;
-
-        // Ref the parent socket to keep it alive
-        socket.ref();
-
-        // Protect the data value if set
-        if (!data_value.isEmptyOrUndefinedOrNull()) {
-            data_value.protect();
-        }
-
-        this.ref();
-        return this;
-    }
-
-    // Write data to the stream
-    pub fn write(this: *This, globalObject: *jsc.JSGlobalObject, callframe: *jsc.CallFrame) bun.JSError!jsc.JSValue {
-        const arguments = callframe.arguments_old(1);
-        if (arguments.len < 1) {
-            return globalObject.throwInvalidArguments("write() requires a buffer argument", .{});
-        }
-
-        if (this.flags.is_closed) {
-            return globalObject.throwInvalidArguments("Stream is closed", .{});
-        }
-
-        const data = arguments.ptr[0];
-
-        // Convert to buffer
-        var buffer: []const u8 = undefined;
-        if (data.asArrayBuffer(globalObject)) |array_buffer| {
-            buffer = array_buffer.slice();
-        } else if (data.isString()) {
-            const str = try data.toBunString(globalObject);
-            defer str.deref();
-            const utf8 = str.toUTF8(bun.default_allocator);
-            defer utf8.deinit();
-            buffer = utf8.slice();
-        } else {
-            return globalObject.throwInvalidArguments("write() expects a Buffer or string", .{});
-        }
-
-        return this.writeInternal(buffer, globalObject);
-    }
-
-    // Internal write method that can be called from both JS and internal code
-    fn writeInternal(this: *This, buffer: []const u8, globalObject: ?*jsc.JSGlobalObject) bun.JSError!jsc.JSValue {
-        // Write to the underlying stream or buffer if stream not yet connected
-        if (this.stream) |stream| {
-            log("QuicStream.write: Writing {} bytes directly to connected stream {*} (ID: {})", .{ buffer.len, stream, this.stream_id });
-            const written = stream.write(buffer);
-            const written_usize: usize = if (written >= 0) @intCast(written) else 0;
-            log("QuicStream.write: stream.write returned {} bytes for stream {}", .{ written, this.stream_id });
-
-            // Handle backpressure - if not all data was written, set backpressure flag
-            if (written_usize < buffer.len) {
-                this.flags.has_backpressure = true;
-                log("QuicStream.write: backpressure detected on stream {}, wrote {} of {} bytes", .{ this.stream_id, written_usize, buffer.len });
-            } else {
-                this.flags.has_backpressure = false;
-            }
-
-            log("QuicStream.write: wrote {} bytes to stream {}", .{ written_usize, this.stream_id });
-            const written_float: f64 = @floatFromInt(written_usize);
-            return jsc.JSValue.jsNumber(written_float);
-        } else {
-            // Stream not connected yet, buffer the write
-            log("QuicStream.write: Stream {} not connected, attempting to buffer {} bytes", .{ this.stream_id, buffer.len });
-            if (!this.write_buffer_initialized) {
-                log("QuicStream.write: write buffer not initialized for stream {}, returning 0", .{this.stream_id});
-                return jsc.JSValue.jsNumber(0);
-            }
-
-            this.write_buffer_mutex.lock();
-            defer this.write_buffer_mutex.unlock();
-
-            // Make a copy of the data to buffer
-            const buffered_data = bun.default_allocator.dupe(u8, buffer) catch |err| {
-                log("QuicStream.write: failed to allocate buffer memory for stream {}: {}", .{ this.stream_id, err });
-                if (globalObject) |globalObj| {
-                    return globalObj.throwError(err, "Failed to allocate memory for write buffer");
-                } else {
-                    return jsc.JSValue.jsNumber(0);
-                }
-            };
-
-            // Add to write buffer
-            this.write_buffer.append(buffered_data) catch |err| {
-                bun.default_allocator.free(buffered_data);
-                log("QuicStream.write: failed to append to write buffer for stream {}: {}", .{ this.stream_id, err });
-                if (globalObject) |globalObj| {
-                    return globalObj.throwError(err, "Failed to buffer write data");
-                } else {
-                    return jsc.JSValue.jsNumber(0);
-                }
-            };
-
-            log("QuicStream.write: buffered {} bytes for stream {} (buffer size: {})", .{ buffer.len, this.stream_id, this.write_buffer.items.len });
-
-            // Return the buffered size so caller thinks the write succeeded
-            const buffered_float: f64 = @floatFromInt(buffer.len);
-            return jsc.JSValue.jsNumber(buffered_float);
-        }
-    }
-
-    // Buffer write data when stream is not yet connected (internal method)
-    pub fn bufferWrite(this: *This, data: []const u8) !void {
-        if (this.flags.is_closed) return error.StreamClosed;
-
-        if (!this.write_buffer_initialized) {
-            return error.BufferNotInitialized;
-        }
-
-        this.write_buffer_mutex.lock();
-        defer this.write_buffer_mutex.unlock();
-
-        // Make a copy of the data to buffer
-        const buffered_data = try bun.default_allocator.dupe(u8, data);
-        errdefer bun.default_allocator.free(buffered_data);
-
-        // Add to write buffer
-        try this.write_buffer.append(buffered_data);
-
-        log("bufferWrite: buffered {} bytes for stream {} (buffer size: {})", .{ data.len, this.stream_id, this.write_buffer.items.len });
-    }
-
-    // End the stream (graceful close with FIN)
-    pub fn end(this: *This, _: *jsc.JSGlobalObject, _: *jsc.CallFrame) bun.JSError!jsc.JSValue {
-        if (this.flags.is_closed or this.flags.fin_sent) {
-            return .js_undefined;
-        }
-
-        if (this.stream) |stream| {
-            this.flags.fin_sent = true;
-            _ = stream.shutdown(); // Shutdown write side
-            log("QuicStream.end: sent FIN on stream {}", .{this.stream_id});
-        }
-
-        return .js_undefined;
-    }
-
-    // Close the stream immediately
-    pub fn close(this: *This, _: *jsc.JSGlobalObject, _: *jsc.CallFrame) bun.JSError!jsc.JSValue {
-        this.closeImpl();
-        return .js_undefined;
-    }
-
-    fn closeImpl(this: *This) void {
-        if (this.flags.is_closed) return;
-
-        this.flags.is_closed = true;
-        this.has_pending_activity.store(false, .release);
-
-        if (this.stream) |stream| {
-            // Remove from socket's stream mapping before closing
-            _ = this.socket.removeStreamMapping(stream);
-
-            stream.close();
-            this.stream = null;
-            log("QuicStream.close: closed stream {}", .{this.stream_id});
-        }
-
-        // Clear any remaining buffered writes
-        if (this.write_buffer_initialized) {
-            this.write_buffer_mutex.lock();
-            defer this.write_buffer_mutex.unlock();
-
-            for (this.write_buffer.items) |buffered_data| {
-                bun.default_allocator.free(buffered_data);
-            }
-            this.write_buffer.clearAndFree();
-        }
-    }
-
-    // Flush any buffered writes to the now-connected stream
-    pub fn flushBufferedWrites(this: *This) void {
-        log("flushBufferedWrites: stream_id={}, stream={*}, initialized={}, buffer_len={}", .{ this.stream_id, this.stream, this.write_buffer_initialized, if (this.write_buffer_initialized) this.write_buffer.items.len else 0 });
-
-        if (!this.write_buffer_initialized or this.stream == null) {
-            log("flushBufferedWrites: early return for stream {} - not initialized or no stream", .{this.stream_id});
-            return;
-        }
-
-        this.write_buffer_mutex.lock();
-        defer this.write_buffer_mutex.unlock();
-
-        const stream = this.stream.?;
-        var total_written: usize = 0;
-        var failed_writes: usize = 0;
-
-        const buffer_count = this.write_buffer.items.len;
-        log("flushBufferedWrites: flushing {} buffered writes to stream {*} (ID: {})", .{ buffer_count, stream, this.stream_id });
-
-        // Write all buffered data to the stream
-        for (this.write_buffer.items) |buffered_data| {
-            const written = stream.write(buffered_data);
-            const written_usize: usize = if (written >= 0) @intCast(written) else 0;
-            total_written += written_usize;
-
-            if (written_usize < buffered_data.len) {
-                this.flags.has_backpressure = true;
-                failed_writes += 1;
-                log("QuicStream.flushBufferedWrites: partial write {} of {} bytes for stream {}", .{ written_usize, buffered_data.len, this.stream_id });
-            } else {
-                log("QuicStream.flushBufferedWrites: wrote {} bytes for stream {}", .{ written_usize, this.stream_id });
-            }
-        }
-
-        // Free the buffered data and clear the buffer
-        for (this.write_buffer.items) |buffered_data| {
-            bun.default_allocator.free(buffered_data);
-        }
-        this.write_buffer.clearRetainingCapacity();
-
-        if (failed_writes > 0) {
-            log("QuicStream.flushBufferedWrites: {} of {} buffered writes had backpressure for stream {}", .{ failed_writes, buffer_count, this.stream_id });
-        } else {
-            log("QuicStream.flushBufferedWrites: flushed {} buffered writes ({} total bytes) for stream {}", .{ buffer_count, total_written, this.stream_id });
-        }
-    }
-
-    // JavaScript ref/unref for keeping the event loop alive
-    pub fn jsRef(this: *This, _: *jsc.JSGlobalObject, _: *jsc.CallFrame) bun.JSError!jsc.JSValue {
-        this.ref();
-        this.poll_ref.ref(jsc.VirtualMachine.get());
-        return .js_undefined;
-    }
-
-    pub fn jsUnref(this: *This, _: *jsc.JSGlobalObject, _: *jsc.CallFrame) bun.JSError!jsc.JSValue {
-        this.poll_ref.unref(jsc.VirtualMachine.get());
-        this.deref();
-        return .js_undefined;
-    }
-
-    // Getters for JavaScript properties
-    pub fn getId(this: *This, _: *jsc.JSGlobalObject) jsc.JSValue {
-        const id_float: f64 = @floatFromInt(this.stream_id);
-        return jsc.JSValue.jsNumber(id_float);
-    }
-
-    pub fn getSocket(this: *This, globalObject: *jsc.JSGlobalObject) jsc.JSValue {
-        return this.socket.toJS(globalObject);
-    }
-
-    pub fn getData(this: *This, _: *jsc.JSGlobalObject) jsc.JSValue {
-        return this.data_value;
-    }
-
-    pub fn getReadyState(this: *This, _: *jsc.JSGlobalObject) jsc.JSValue {
-        if (this.flags.is_closed) {
-            return jsc.JSValue.jsNumberFromChar(3); // CLOSED
-        } else if (this.flags.fin_sent) {
-            return jsc.JSValue.jsNumberFromChar(2); // CLOSING
-        } else {
-            return jsc.JSValue.jsNumberFromChar(1); // OPEN
-        }
-    }
-};
-
-// Import QuicSocket type
-const QuicSocket = @import("quic_socket.zig").QuicSocket;

src/bun.js/api/bun/socket.zig

@@ -884,7 +884,14 @@ pub fn NewSocket(comptime ssl: bool) type {
         pub fn writeBuffered(this: *This, globalObject: *jsc.JSGlobalObject, callframe: *jsc.CallFrame) bun.JSError!JSValue {
             if (this.socket.isDetached()) {
                 this.buffered_data_for_node_net.clearAndFree(bun.default_allocator);
-                return .false;
+                // TODO: should we separate unattached and detached? unattached shouldn't throw here
+                const err: jsc.SystemError = .{
+                    .errno = @intFromEnum(bun.sys.SystemErrno.EBADF),
+                    .code = .static("EBADF"),
+                    .message = .static("write EBADF"),
+                    .syscall = .static("write"),
+                };
+                return globalObject.throwValue(err.toErrorInstance(globalObject));
             }
 
             const args = callframe.argumentsUndef(2);
@@ -1405,12 +1412,23 @@ pub fn NewSocket(comptime ssl: bool) type {
             }
 
             var ssl_opts: ?jsc.API.ServerConfig.SSLConfig = null;
+            defer {
+                if (!success) {
+                    if (ssl_opts) |*ssl_config| {
+                        ssl_config.deinit();
+                    }
+                }
+            }
 
             if (try opts.getTruthy(globalObject, "tls")) |tls| {
-                if (!tls.isBoolean()) {
-                    ssl_opts = try jsc.API.ServerConfig.SSLConfig.fromJS(jsc.VirtualMachine.get(), globalObject, tls);
-                } else if (tls.toBoolean()) {
-                    ssl_opts = jsc.API.ServerConfig.SSLConfig.zero;
+                if (tls.isBoolean()) {
+                    if (tls.toBoolean()) {
+                        ssl_opts = jsc.API.ServerConfig.SSLConfig.zero;
+                    }
+                } else {
+                    if (try jsc.API.ServerConfig.SSLConfig.fromJS(jsc.VirtualMachine.get(), globalObject, tls)) |ssl_config| {
+                        ssl_opts = ssl_config;
+                    }
                 }
             }
 
@@ -1418,10 +1436,9 @@ pub fn NewSocket(comptime ssl: bool) type {
                 return .zero;
             }
 
-            const socket_config = &(ssl_opts orelse {
+            if (ssl_opts == null) {
                 return globalObject.throw("Expected \"tls\" option", .{});
-            });
-            defer socket_config.deinit();
+            }
 
             var default_data = JSValue.zero;
             if (try opts.fastGet(globalObject, .data)) |default_data_value| {
@@ -1432,7 +1449,14 @@ pub fn NewSocket(comptime ssl: bool) type {
                 return .zero;
             }
 
+            var socket_config = ssl_opts.?;
+            ssl_opts = null;
+            defer socket_config.deinit();
             const options = socket_config.asUSockets();
+
+            const protos = socket_config.protos;
+            const protos_len = socket_config.protos_len;
+
             const ext_size = @sizeOf(WrappedSocket);
 
             var handlers_ptr = bun.handleOom(bun.default_allocator.create(Handlers));
@@ -1446,14 +1470,8 @@ pub fn NewSocket(comptime ssl: bool) type {
                 .socket = TLSSocket.Socket.detached,
                 .connection = if (this.connection) |c| c.clone() else null,
                 .wrapped = .tls,
-                .protos = if (socket_config.protos) |p|
-                    bun.handleOom(bun.default_allocator.dupe(u8, std.mem.span(p)))
-                else
-                    null,
-                .server_name = if (socket_config.server_name) |sn|
-                    bun.handleOom(bun.default_allocator.dupe(u8, std.mem.span(sn)))
-                else
-                    null,
+                .protos = if (protos) |p| bun.handleOom(bun.default_allocator.dupe(u8, p[0..protos_len])) else null,
+                .server_name = if (socket_config.server_name) |server_name| bun.handleOom(bun.default_allocator.dupe(u8, server_name[0..bun.len(server_name)])) else null,
                 .socket_context = null, // only set after the wrapTLS
                 .flags = .{
                     .is_active = false,
@@ -1937,15 +1955,19 @@ pub fn jsUpgradeDuplexToTLS(globalObject: *jsc.JSGlobalObject, callframe: *jsc.C
 
     var ssl_opts: ?jsc.API.ServerConfig.SSLConfig = null;
     if (try opts.getTruthy(globalObject, "tls")) |tls| {
-        if (!tls.isBoolean()) {
-            ssl_opts = try jsc.API.ServerConfig.SSLConfig.fromJS(jsc.VirtualMachine.get(), globalObject, tls);
-        } else if (tls.toBoolean()) {
-            ssl_opts = jsc.API.ServerConfig.SSLConfig.zero;
+        if (tls.isBoolean()) {
+            if (tls.toBoolean()) {
+                ssl_opts = jsc.API.ServerConfig.SSLConfig.zero;
+            }
+        } else {
+            if (try jsc.API.ServerConfig.SSLConfig.fromJS(jsc.VirtualMachine.get(), globalObject, tls)) |ssl_config| {
+                ssl_opts = ssl_config;
+            }
         }
     }
-    const socket_config = &(ssl_opts orelse {
+    if (ssl_opts == null) {
         return globalObject.throw("Expected \"tls\" option", .{});
-    });
+    }
 
     var default_data = JSValue.zero;
     if (try opts.fastGet(globalObject, .data)) |default_data_value| {
@@ -1953,6 +1975,11 @@ pub fn jsUpgradeDuplexToTLS(globalObject: *jsc.JSGlobalObject, callframe: *jsc.C
         default_data.ensureStillAlive();
     }
 
+    const socket_config = ssl_opts.?;
+
+    const protos = socket_config.protos;
+    const protos_len = socket_config.protos_len;
+
     const is_server = false; // A duplex socket is always handled as a client
 
     var handlers_ptr = bun.handleOom(handlers.vm.allocator.create(Handlers));
@@ -1967,14 +1994,8 @@ pub fn jsUpgradeDuplexToTLS(globalObject: *jsc.JSGlobalObject, callframe: *jsc.C
         .socket = TLSSocket.Socket.detached,
         .connection = null,
         .wrapped = .tls,
-        .protos = if (socket_config.protos) |p|
-            bun.handleOom(bun.default_allocator.dupe(u8, std.mem.span(p)))
-        else
-            null,
-        .server_name = if (socket_config.server_name) |sn|
-            bun.handleOom(bun.default_allocator.dupe(u8, std.mem.span(sn)))
-        else
-            null,
+        .protos = if (protos) |p| bun.handleOom(bun.default_allocator.dupe(u8, p[0..protos_len])) else null,
+        .server_name = if (socket_config.server_name) |server_name| bun.handleOom(bun.default_allocator.dupe(u8, server_name[0..bun.len(server_name)])) else null,
         .socket_context = null, // only set after the wrapTLS
     });
     const tls_js_value = tls.getThisValue(globalObject);
@@ -1985,7 +2006,7 @@ pub fn jsUpgradeDuplexToTLS(globalObject: *jsc.JSGlobalObject, callframe: *jsc.C
         .tls = tls,
         .vm = globalObject.bunVM(),
         .task = undefined,
-        .ssl_config = socket_config.*,
+        .ssl_config = socket_config,
     });
     tls.ref();
 

src/bun.js/api/bun/socket/Handlers.zig

@@ -210,7 +210,7 @@ pub const SocketConfig = struct {
     hostname_or_unix: jsc.ZigString.Slice,
     port: ?u16 = null,
     fd: ?bun.FileDescriptor = null,
-    ssl: ?SSLConfig = null,
+    ssl: ?jsc.API.ServerConfig.SSLConfig = null,
     handlers: Handlers,
     default_data: jsc.JSValue = .zero,
     exclusive: bool = false,
@@ -246,18 +246,26 @@ pub const SocketConfig = struct {
         var reusePort = false;
         var ipv6Only = false;
 
-        var ssl: ?SSLConfig = null;
+        var ssl: ?jsc.API.ServerConfig.SSLConfig = null;
         var default_data = JSValue.zero;
 
         if (try opts.getTruthy(globalObject, "tls")) |tls| {
-            if (!tls.isBoolean()) {
-                ssl = try SSLConfig.fromJS(vm, globalObject, tls);
-            } else if (tls.toBoolean()) {
-                ssl = SSLConfig.zero;
+            if (tls.isBoolean()) {
+                if (tls.toBoolean()) {
+                    ssl = jsc.API.ServerConfig.SSLConfig.zero;
+                }
+            } else {
+                if (try jsc.API.ServerConfig.SSLConfig.fromJS(vm, globalObject, tls)) |ssl_config| {
+                    ssl = ssl_config;
+                }
             }
         }
 
-        errdefer bun.memory.deinit(&ssl);
+        errdefer {
+            if (ssl != null) {
+                ssl.?.deinit();
+            }
+        }
 
         hostname_or_unix: {
             if (try opts.getTruthy(globalObject, "fd")) |fd_| {
@@ -374,10 +382,9 @@ const bun = @import("bun");
 const Environment = bun.Environment;
 const strings = bun.strings;
 const uws = bun.uws;
-const Listener = bun.api.Listener;
-const SSLConfig = bun.api.ServerConfig.SSLConfig;
 
 const jsc = bun.jsc;
 const JSValue = jsc.JSValue;
 const ZigString = jsc.ZigString;
 const BinaryType = jsc.ArrayBuffer.BinaryType;
+const Listener = jsc.API.Listener;