Changed stuff, added filter for statistics module

2025-09-02 16:37:06 +02:00 · 2025-09-02 16:37:06 +02:00 · fe87374e47
commit fe87374e47
parent 4a91ae2bf9
251 changed files with 3295 additions and 1705 deletions
--- a/node_modules/bun-types/bun.d.ts
+++ b/node_modules/bun-types/bun.d.ts
--- a/node_modules/bun-types/deprecated.d.ts
+++ b/node_modules/bun-types/deprecated.d.ts
@ -1,4 +1,88 @@
 declare module "bun" {
+  /** @deprecated This type is unused in Bun's types and might be removed in the near future */
+  type Platform =
+    | "aix"
+    | "android"
+    | "darwin"
+    | "freebsd"
+    | "haiku"
+    | "linux"
+    | "openbsd"
+    | "sunos"
+    | "win32"
+    | "cygwin"
+    | "netbsd";
+
+  /** @deprecated This type is unused in Bun's types and might be removed in the near future */
+  type Architecture = "arm" | "arm64" | "ia32" | "mips" | "mipsel" | "ppc" | "ppc64" | "s390" | "s390x" | "x64";
+
+  /** @deprecated This type is unused in Bun's types and might be removed in the near future */
+  type UncaughtExceptionListener = (error: Error, origin: UncaughtExceptionOrigin) => void;
+
+  /**
+   * Most of the time the unhandledRejection will be an Error, but this should not be relied upon
+   * as *anything* can be thrown/rejected, it is therefore unsafe to assume that the value is an Error.
+   *
+   * @deprecated This type is unused in Bun's types and might be removed in the near future
+   */
+  type UnhandledRejectionListener = (reason: unknown, promise: Promise<unknown>) => void;
+
+  /** @deprecated This type is unused in Bun's types and might be removed in the near future */
+  type MultipleResolveListener = (type: MultipleResolveType, promise: Promise<unknown>, value: unknown) => void;
+
+  /**
+   * Consume all data from a {@link ReadableStream} until it closes or errors.
+   *
+   * Concatenate the chunks into a single {@link ArrayBuffer}.
+   *
+   * Each chunk must be a TypedArray or an ArrayBuffer. If you need to support
+   * chunks of different types, consider {@link readableStreamToBlob}
+   *
+   * @param stream The stream to consume.
+   * @returns A promise that resolves with the concatenated chunks or the concatenated chunks as a {@link Uint8Array}.
+   *
+   * @deprecated Use {@link ReadableStream.bytes}
+   */
+  function readableStreamToBytes(
+    stream: ReadableStream<ArrayBufferView | ArrayBufferLike>,
+  ): Promise<Uint8Array<ArrayBuffer>> | Uint8Array<ArrayBuffer>;
+
+  /**
+   * Consume all data from a {@link ReadableStream} until it closes or errors.
+   *
+   * Concatenate the chunks into a single {@link Blob}.
+   *
+   * @param stream The stream to consume.
+   * @returns A promise that resolves with the concatenated chunks as a {@link Blob}.
+   *
+   * @deprecated Use {@link ReadableStream.blob}
+   */
+  function readableStreamToBlob(stream: ReadableStream): Promise<Blob>;
+
+  /**
+   * Consume all data from a {@link ReadableStream} until it closes or errors.
+   *
+   * Concatenate the chunks into a single string. Chunks must be a TypedArray or an ArrayBuffer. If you need to support chunks of different types, consider {@link readableStreamToBlob}.
+   *
+   * @param stream The stream to consume.
+   * @returns A promise that resolves with the concatenated chunks as a {@link String}.
+   *
+   * @deprecated Use {@link ReadableStream.text}
+   */
+  function readableStreamToText(stream: ReadableStream): Promise<string>;
+
+  /**
+   * Consume all data from a {@link ReadableStream} until it closes or errors.
+   *
+   * Concatenate the chunks into a single string and parse as JSON. Chunks must be a TypedArray or an ArrayBuffer. If you need to support chunks of different types, consider {@link readableStreamToBlob}.
+   *
+   * @param stream The stream to consume.
+   * @returns A promise that resolves with the concatenated chunks as a {@link String}.
+   *
+   * @deprecated Use {@link ReadableStream.json}
+   */
+  function readableStreamToJSON(stream: ReadableStream): Promise<any>;
+
  interface BunMessageEvent<T> {
    /**
     * @deprecated
@ -31,6 +115,9 @@ declare module "bun" {
   */
  type Errorlike = ErrorLike;

+  /** @deprecated This is unused in Bun's types and may be removed in the future */
+  type ShellFunction = (input: Uint8Array<ArrayBuffer>) => Uint8Array<ArrayBuffer>;
+
  interface TLSOptions {
    /**
     * File path to a TLS key
@ -59,7 +146,7 @@ declare module "bun" {
  }

  /** @deprecated This type is unused in Bun's declarations and may be removed in the future */
-  type ReadableIO = ReadableStream<Uint8Array> | number | undefined;
+  type ReadableIO = ReadableStream<Uint8Array<ArrayBuffer>> | number | undefined;
 }

 declare namespace NodeJS {
--- a/node_modules/bun-types/docs/api/fetch.md
+++ b/node_modules/bun-types/docs/api/fetch.md
@ -320,7 +320,6 @@ Bun automatically sets the `Content-Type` header for request bodies when not exp

 - For `Blob` objects, uses the blob's `type`
 - For `FormData`, sets appropriate multipart boundary
- For JSON objects, sets `application/json`

 ## Debugging

@ -337,7 +336,7 @@ This will print the request and response headers to your terminal:
 ```sh
 [fetch] > HTTP/1.1 GET http://example.com/
 [fetch] > Connection: keep-alive
-[fetch] > User-Agent: Bun/1.2.19
+[fetch] > User-Agent: Bun/1.2.21
 [fetch] > Accept: */*
 [fetch] > Host: example.com
 [fetch] > Accept-Encoding: gzip, deflate, br
--- a/node_modules/bun-types/docs/api/http.md
+++ b/node_modules/bun-types/docs/api/http.md
@ -164,6 +164,70 @@ Static responses do not allocate additional memory after initialization. You can

 Static route responses are cached for the lifetime of the server object. To reload static routes, call `server.reload(options)`.

+### File Responses vs Static Responses
+
+When serving files in routes, there are two distinct behaviors depending on whether you buffer the file content or serve it directly:
+
+```ts
+Bun.serve({
+  routes: {
+    // Static route - content is buffered in memory at startup
+    "/logo.png": new Response(await Bun.file("./logo.png").bytes()),
+
+    // File route - content is read from filesystem on each request
+    "/download.zip": new Response(Bun.file("./download.zip")),
+  },
+});
+```
+
+**Static routes** (`new Response(await file.bytes())`) buffer content in memory at startup:
+
+- **Zero filesystem I/O** during requests - content served entirely from memory
+- **ETag support** - Automatically generates and validates ETags for caching
+- **If-None-Match** - Returns `304 Not Modified` when client ETag matches
+- **No 404 handling** - Missing files cause startup errors, not runtime 404s
+- **Memory usage** - Full file content stored in RAM
+- **Best for**: Small static assets, API responses, frequently accessed files
+
+**File routes** (`new Response(Bun.file(path))`) read from filesystem per request:
+
+- **Filesystem reads** on each request - checks file existence and reads content
+- **Built-in 404 handling** - Returns `404 Not Found` if file doesn't exist or becomes inaccessible
+- **Last-Modified support** - Uses file modification time for `If-Modified-Since` headers
+- **If-Modified-Since** - Returns `304 Not Modified` when file hasn't changed since client's cached version
+- **Range request support** - Automatically handles partial content requests with `Content-Range` headers
+- **Streaming transfers** - Uses buffered reader with backpressure handling for efficient memory usage
+- **Memory efficient** - Only buffers small chunks during transfer, not entire file
+- **Best for**: Large files, dynamic content, user uploads, files that change frequently
+
+### HTTP Caching Behavior
+
+Both route types implement HTTP caching standards but with different strategies:
+
+#### Static Routes Caching
+
+- **ETag generation**: Automatically computes ETag hash from content at startup
+- **If-None-Match**: Validates client ETag against server ETag
+- **304 responses**: Returns `304 Not Modified` with empty body when ETags match
+- **Cache headers**: Inherits any `Cache-Control` headers you provide in the Response
+- **Consistency**: ETag remains constant until server restart or route reload
+
+#### File Routes Caching
+
+- **Last-Modified**: Uses file's `mtime` for `Last-Modified` header
+- **If-Modified-Since**: Compares client date with file modification time
+- **304 responses**: Returns `304 Not Modified` when file unchanged since client's cached version
+- **Content-Length**: Automatically set based on current file size
+- **Dynamic validation**: Checks file modification time on each request
+
+#### Status Code Handling
+
+Both route types automatically adjust status codes:
+
+- **200 → 204**: Empty files (0 bytes) return `204 No Content` instead of `200 OK`
+- **200 → 304**: Successful cache validation returns `304 Not Modified`
+- **File routes only**: Missing or inaccessible files return `404 Not Found`
+
 ```ts
 const server = Bun.serve({
  static: {
--- a/node_modules/bun-types/docs/api/spawn.md
+++ b/node_modules/bun-types/docs/api/spawn.md
@ -140,7 +140,7 @@ You can read results from the subprocess via the `stdout` and `stderr` propertie
 ```ts
 const proc = Bun.spawn(["bun", "--version"]);
 const text = await proc.stdout.text();
-console.log(text); // => "1.2.19\n"
+console.log(text); // => "1.2.21\n"
 ```

 Configure the output stream by passing one of the following values to `stdout/stderr`:
--- a/node_modules/bun-types/docs/api/sql.md
+++ b/node_modules/bun-types/docs/api/sql.md
@ -1,20 +1,20 @@
-Bun provides native bindings for working with PostgreSQL databases with a modern, Promise-based API. The interface is designed to be simple and performant, using tagged template literals for queries and offering features like connection pooling, transactions, and prepared statements.
+Bun provides native bindings for working with SQL databases through a unified Promise-based API that supports both PostgreSQL and SQLite. The interface is designed to be simple and performant, using tagged template literals for queries and offering features like connection pooling, transactions, and prepared statements.

 ```ts
-import { sql } from "bun";
+import { sql, SQL } from "bun";

+// PostgreSQL (default)
 const users = await sql`
  SELECT * FROM users
  WHERE active = ${true}
  LIMIT ${10}
 `;

-// Select with multiple conditions
-const activeUsers = await sql`
-  SELECT * 
-  FROM users 
-  WHERE active = ${true} 
-  AND age >= ${18}
+// With a a SQLite db
+const sqlite = new SQL("sqlite://myapp.db");
+const results = await sqlite`
+  SELECT * FROM users 
+  WHERE active = ${1}
 `;
 ```

@ -44,6 +44,115 @@ const activeUsers = await sql`

 {% /features %}

+## Database Support
+
+Bun.SQL provides a unified API for multiple database systems:
+
+### PostgreSQL
+
+PostgreSQL is used when:
+
+- The connection string doesn't match SQLite patterns (it's the fallback adapter)
+- The connection string explicitly uses `postgres://` or `postgresql://` protocols
+- No connection string is provided and environment variables point to PostgreSQL
+
+```ts
+import { sql } from "bun";
+// Uses PostgreSQL if DATABASE_URL is not set or is a PostgreSQL URL
+await sql`SELECT ...`;
+
+import { SQL } from "bun";
+const pg = new SQL("postgres://user:pass@localhost:5432/mydb");
+await pg`SELECT ...`;
+```
+
+### SQLite
+
+SQLite support is now built into Bun.SQL, providing the same tagged template literal interface as PostgreSQL:
+
+```ts
+import { SQL } from "bun";
+
+// In-memory database
+const memory = new SQL(":memory:");
+const memory2 = new SQL("sqlite://:memory:");
+
+// File-based database
+const db = new SQL("sqlite://myapp.db");
+
+// Using options object
+const db2 = new SQL({
+  adapter: "sqlite",
+  filename: "./data/app.db",
+});
+
+// For simple filenames, specify adapter explicitly
+const db3 = new SQL("myapp.db", { adapter: "sqlite" });
+```
+
+<details>
+<summary>SQLite Connection String Formats</summary>
+
+SQLite accepts various URL formats for connection strings:
+
+```ts
+// Standard sqlite:// protocol
+new SQL("sqlite://path/to/database.db");
+new SQL("sqlite:path/to/database.db"); // Without slashes
+
+// file:// protocol (also recognized as SQLite)
+new SQL("file://path/to/database.db");
+new SQL("file:path/to/database.db");
+
+// Special :memory: database
+new SQL(":memory:");
+new SQL("sqlite://:memory:");
+new SQL("file://:memory:");
+
+// Relative and absolute paths
+new SQL("sqlite://./local.db"); // Relative to current directory
+new SQL("sqlite://../parent/db.db"); // Parent directory
+new SQL("sqlite:///absolute/path.db"); // Absolute path
+
+// With query parameters
+new SQL("sqlite://data.db?mode=ro"); // Read-only mode
+new SQL("sqlite://data.db?mode=rw"); // Read-write mode (no create)
+new SQL("sqlite://data.db?mode=rwc"); // Read-write-create mode (default)
+```
+
+**Note:** Simple filenames without a protocol (like `"myapp.db"`) require explicitly specifying `{ adapter: "sqlite" }` to avoid ambiguity with PostgreSQL.
+
+</details>
+
+<details>
+<summary>SQLite-Specific Options</summary>
+
+SQLite databases support additional configuration options:
+
+```ts
+const db = new SQL({
+  adapter: "sqlite",
+  filename: "app.db",
+
+  // SQLite-specific options
+  readonly: false, // Open in read-only mode
+  create: true, // Create database if it doesn't exist
+  readwrite: true, // Open for reading and writing
+
+  // Additional Bun:sqlite options
+  strict: true, // Enable strict mode
+  safeIntegers: false, // Use JavaScript numbers for integers
+});
+```
+
+Query parameters in the URL are parsed to set these options:
+
+- `?mode=ro` → `readonly: true`
+- `?mode=rw` → `readonly: false, create: false`
+- `?mode=rwc` → `readonly: false, create: true` (default)
+
+</details>
+
 ### Inserting data

 You can pass JavaScript values directly to the SQL template literal and escaping will be handled for you.
@ -251,14 +360,55 @@ await query;

 ## Database Environment Variables

-`sql` connection parameters can be configured using environment variables. The client checks these variables in a specific order of precedence.
+`sql` connection parameters can be configured using environment variables. The client checks these variables in a specific order of precedence and automatically detects the database type based on the connection string format.

-The following environment variables can be used to define the connection URL:
+### Automatic Database Detection
+
+When using `Bun.sql()` without arguments or `new SQL()` with a connection string, the adapter is automatically detected based on the URL format. SQLite becomes the default adapter in these cases:
+
+#### SQLite Auto-Detection
+
+SQLite is automatically selected when the connection string matches these patterns:
+
+- `:memory:` - In-memory database
+- `sqlite://...` - SQLite protocol URLs
+- `sqlite:...` - SQLite protocol without slashes
+- `file://...` - File protocol URLs
+- `file:...` - File protocol without slashes
+
+```ts
+// These all use SQLite automatically (no adapter needed)
+const sql1 = new SQL(":memory:");
+const sql2 = new SQL("sqlite://app.db");
+const sql3 = new SQL("file://./database.db");
+
+// Works with DATABASE_URL environment variable
+DATABASE_URL=":memory:" bun run app.js
+DATABASE_URL="sqlite://myapp.db" bun run app.js
+DATABASE_URL="file://./data/app.db" bun run app.js
+```
+
+#### PostgreSQL Auto-Detection
+
+PostgreSQL is the default for all other connection strings:
+
+```bash
+# PostgreSQL is detected for these patterns
+DATABASE_URL="postgres://user:pass@localhost:5432/mydb" bun run app.js
+DATABASE_URL="postgresql://user:pass@localhost:5432/mydb" bun run app.js
+
+# Or any URL that doesn't match SQLite patterns
+DATABASE_URL="localhost:5432/mydb" bun run app.js
+```
+
+### PostgreSQL Environment Variables
+
+The following environment variables can be used to define the PostgreSQL connection:

 | Environment Variable        | Description                                |
 | --------------------------- | ------------------------------------------ |
 | `POSTGRES_URL`              | Primary connection URL for PostgreSQL      |
-| `DATABASE_URL`              | Alternative connection URL                 |
+| `DATABASE_URL`              | Alternative connection URL (auto-detected) |
 | `PGURL`                     | Alternative connection URL                 |
 | `PG_URL`                    | Alternative connection URL                 |
 | `TLS_POSTGRES_DATABASE_URL` | SSL/TLS-enabled connection URL             |
@ -274,6 +424,19 @@ If no connection URL is provided, the system checks for the following individual
 | `PGPASSWORD`         | -                            | (empty)       | Database password |
 | `PGDATABASE`         | -                            | username      | Database name     |

+### SQLite Environment Variables
+
+SQLite connections can be configured via `DATABASE_URL` when it contains a SQLite-compatible URL:
+
+```bash
+# These are all recognized as SQLite
+DATABASE_URL=":memory:"
+DATABASE_URL="sqlite://./app.db"
+DATABASE_URL="file:///absolute/path/to/db.sqlite"
+```
+
+**Note:** PostgreSQL-specific environment variables (`POSTGRES_URL`, `PGHOST`, etc.) are ignored when using SQLite.
+
 ## Runtime Preconnection

 Bun can preconnect to PostgreSQL at startup to improve performance by establishing database connections before your application code runs. This is useful for reducing connection latency on the first database query.
@ -293,16 +456,18 @@ The `--sql-preconnect` flag will automatically establish a PostgreSQL connection

 ## Connection Options

-You can configure your database connection manually by passing options to the SQL constructor:
+You can configure your database connection manually by passing options to the SQL constructor. Options vary depending on the database adapter:
+
+### PostgreSQL Options

 ```ts
 import { SQL } from "bun";

 const db = new SQL({
-  // Required
+  // Connection details (adapter is auto-detected as PostgreSQL)
  url: "postgres://user:pass@localhost:5432/dbname",

-  // Optional configuration
+  // Alternative connection parameters
  hostname: "localhost",
  port: 5432,
  database: "myapp",
@ -330,14 +495,53 @@ const db = new SQL({

  // Callbacks
  onconnect: client => {
-    console.log("Connected to database");
+    console.log("Connected to PostgreSQL");
  },
  onclose: client => {
-    console.log("Connection closed");
+    console.log("PostgreSQL connection closed");
  },
 });
 ```

+### SQLite Options
+
+```ts
+import { SQL } from "bun";
+
+const db = new SQL({
+  // Required for SQLite
+  adapter: "sqlite",
+  filename: "./data/app.db", // or ":memory:" for in-memory database
+
+  // SQLite-specific access modes
+  readonly: false, // Open in read-only mode
+  create: true, // Create database if it doesn't exist
+  readwrite: true, // Allow read and write operations
+
+  // SQLite data handling
+  strict: true, // Enable strict mode for better type safety
+  safeIntegers: false, // Use BigInt for integers exceeding JS number range
+
+  // Callbacks
+  onconnect: client => {
+    console.log("SQLite database opened");
+  },
+  onclose: client => {
+    console.log("SQLite database closed");
+  },
+});
+```
+
+<details>
+<summary>SQLite Connection Notes</summary>
+
+- **Connection Pooling**: SQLite doesn't use connection pooling as it's a file-based database. Each `SQL` instance represents a single connection.
+- **Transactions**: SQLite supports nested transactions through savepoints, similar to PostgreSQL.
+- **Concurrent Access**: SQLite handles concurrent access through file locking. Use WAL mode for better concurrency.
+- **Memory Databases**: Using `:memory:` creates a temporary database that exists only for the connection lifetime.
+
+</details>
+
 ## Dynamic passwords

 When clients need to use alternative authentication schemes such as access tokens or connections to databases with rotating passwords, provide either a synchronous or asynchronous function that will resolve the dynamic password value at connection time.
@ -353,11 +557,66 @@ const sql = new SQL(url, {
 });
 ```

+## SQLite-Specific Features
+
+### Query Execution
+
+SQLite executes queries synchronously, unlike PostgreSQL which uses asynchronous I/O. However, the API remains consistent using Promises:
+
+```ts
+const sqlite = new SQL("sqlite://app.db");
+
+// Works the same as PostgreSQL, but executes synchronously under the hood
+const users = await sqlite`SELECT * FROM users`;
+
+// Parameters work identically
+const user = await sqlite`SELECT * FROM users WHERE id = ${userId}`;
+```
+
+### SQLite Pragmas
+
+You can use PRAGMA statements to configure SQLite behavior:
+
+```ts
+const sqlite = new SQL("sqlite://app.db");
+
+// Enable foreign keys
+await sqlite`PRAGMA foreign_keys = ON`;
+
+// Set journal mode to WAL for better concurrency
+await sqlite`PRAGMA journal_mode = WAL`;
+
+// Check integrity
+const integrity = await sqlite`PRAGMA integrity_check`;
+```
+
+### Data Type Differences
+
+SQLite has a more flexible type system than PostgreSQL:
+
+```ts
+// SQLite stores data in 5 storage classes: NULL, INTEGER, REAL, TEXT, BLOB
+const sqlite = new SQL("sqlite://app.db");
+
+// SQLite is more lenient with types
+await sqlite`
+  CREATE TABLE flexible (
+    id INTEGER PRIMARY KEY,
+    data TEXT,        -- Can store numbers as strings
+    value NUMERIC,    -- Can store integers, reals, or text
+    blob BLOB         -- Binary data
+  )
+`;
+
+// JavaScript values are automatically converted
+await sqlite`INSERT INTO flexible VALUES (${1}, ${"text"}, ${123.45}, ${Buffer.from("binary")})`;
+```
+
 ## Transactions

-To start a new transaction, use `sql.begin`. This method reserves a dedicated connection for the duration of the transaction and provides a scoped `sql` instance to use within the callback function. Once the callback completes, `sql.begin` resolves with the return value of the callback.
+To start a new transaction, use `sql.begin`. This method works for both PostgreSQL and SQLite. For PostgreSQL, it reserves a dedicated connection from the pool. For SQLite, it begins a transaction on the single connection.

-The `BEGIN` command is sent automatically, including any optional configurations you specify. If an error occurs during the transaction, a `ROLLBACK` is triggered to release the reserved connection and ensure the process continues smoothly.
+The `BEGIN` command is sent automatically, including any optional configurations you specify. If an error occurs during the transaction, a `ROLLBACK` is triggered to ensure the process continues smoothly.

 ### Basic Transactions

@ -552,9 +811,34 @@ Note that disabling prepared statements may impact performance for queries that

 ## Error Handling

-The client provides typed errors for different failure scenarios:
+The client provides typed errors for different failure scenarios. Errors are database-specific and extend from base error classes:

-### Connection Errors
+### Error Classes
+
+```ts
+import { SQL } from "bun";
+
+try {
+  await sql`SELECT * FROM users`;
+} catch (error) {
+  if (error instanceof SQL.PostgresError) {
+    // PostgreSQL-specific error
+    console.log(error.code); // PostgreSQL error code
+    console.log(error.detail); // Detailed error message
+    console.log(error.hint); // Helpful hint from PostgreSQL
+  } else if (error instanceof SQL.SQLiteError) {
+    // SQLite-specific error
+    console.log(error.code); // SQLite error code (e.g., "SQLITE_CONSTRAINT")
+    console.log(error.errno); // SQLite error number
+    console.log(error.byteOffset); // Byte offset in SQL statement (if available)
+  } else if (error instanceof SQL.SQLError) {
+    // Generic SQL error (base class)
+    console.log(error.message);
+  }
+}
+```
+
+### PostgreSQL Connection Errors

 | Connection Errors                 | Description                                          |
 | --------------------------------- | ---------------------------------------------------- |
@ -619,6 +903,50 @@ The client provides typed errors for different failure scenarios:
 | `ERR_POSTGRES_UNSAFE_TRANSACTION`        | Unsafe transaction operation detected |
 | `ERR_POSTGRES_INVALID_TRANSACTION_STATE` | Invalid transaction state             |

+### SQLite-Specific Errors
+
+SQLite errors provide error codes and numbers that correspond to SQLite's standard error codes:
+
+<details>
+<summary>Common SQLite Error Codes</summary>
+
+| Error Code          | errno | Description                                          |
+| ------------------- | ----- | ---------------------------------------------------- |
+| `SQLITE_CONSTRAINT` | 19    | Constraint violation (UNIQUE, CHECK, NOT NULL, etc.) |
+| `SQLITE_BUSY`       | 5     | Database is locked                                   |
+| `SQLITE_LOCKED`     | 6     | Table in the database is locked                      |
+| `SQLITE_READONLY`   | 8     | Attempt to write to a readonly database              |
+| `SQLITE_IOERR`      | 10    | Disk I/O error                                       |
+| `SQLITE_CORRUPT`    | 11    | Database disk image is malformed                     |
+| `SQLITE_FULL`       | 13    | Database or disk is full                             |
+| `SQLITE_CANTOPEN`   | 14    | Unable to open database file                         |
+| `SQLITE_PROTOCOL`   | 15    | Database lock protocol error                         |
+| `SQLITE_SCHEMA`     | 17    | Database schema has changed                          |
+| `SQLITE_TOOBIG`     | 18    | String or BLOB exceeds size limit                    |
+| `SQLITE_MISMATCH`   | 20    | Data type mismatch                                   |
+| `SQLITE_MISUSE`     | 21    | Library used incorrectly                             |
+| `SQLITE_AUTH`       | 23    | Authorization denied                                 |
+
+Example error handling:
+
+```ts
+const sqlite = new SQL("sqlite://app.db");
+
+try {
+  await sqlite`INSERT INTO users (id, name) VALUES (1, 'Alice')`;
+  await sqlite`INSERT INTO users (id, name) VALUES (1, 'Bob')`; // Duplicate ID
+} catch (error) {
+  if (error instanceof SQL.SQLiteError) {
+    if (error.code === "SQLITE_CONSTRAINT") {
+      console.log("Constraint violation:", error.message);
+      // Handle unique constraint violation
+    }
+  }
+}
+```
+
+</details>
+
 ## Numbers and BigInt

 Bun's SQL client includes special handling for large numbers that exceed the range of a 53-bit integer. Here's how it works:
@ -652,7 +980,6 @@ There's still some things we haven't finished yet.

 - Connection preloading via `--db-preconnect` Bun CLI flag
 - MySQL support: [we're working on it](https://github.com/oven-sh/bun/pull/15274)
- SQLite support: planned, but not started. Ideally, we implement it natively instead of wrapping `bun:sqlite`.
 - Column name transforms (e.g. `snake_case` to `camelCase`). This is mostly blocked on a unicode-aware implementation of changing the case in C++ using WebKit's `WTF::String`.
 - Column type transforms

--- a/node_modules/bun-types/docs/api/streams.md
+++ b/node_modules/bun-types/docs/api/streams.md
@ -208,8 +208,8 @@ export class ArrayBufferSink {
   *
   * This API might change later to separate Uint8ArraySink and ArrayBufferSink
   */
-  flush(): number | Uint8Array | ArrayBuffer;
-  end(): ArrayBuffer | Uint8Array;
+  flush(): number | Uint8Array<ArrayBuffer> | ArrayBuffer;
+  end(): ArrayBuffer | Uint8Array<ArrayBuffer>;
 }
 ```

--- a/node_modules/bun-types/docs/api/utils.md
+++ b/node_modules/bun-types/docs/api/utils.md
@ -772,6 +772,65 @@ console.log(obj); // => { foo: "bar" }

 Internally, [`structuredClone`](https://developer.mozilla.org/en-US/docs/Web/API/structuredClone) and [`postMessage`](https://developer.mozilla.org/en-US/docs/Web/API/Window/postMessage) serialize and deserialize the same way. This exposes the underlying [HTML Structured Clone Algorithm](https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API/Structured_clone_algorithm) to JavaScript as an ArrayBuffer.

+## `Bun.stripANSI()` ~6-57x faster `strip-ansi` alternative
+
+`Bun.stripANSI(text: string): string`
+
+Strip ANSI escape codes from a string. This is useful for removing colors and formatting from terminal output.
+
+```ts
+const coloredText = "\u001b[31mHello\u001b[0m \u001b[32mWorld\u001b[0m";
+const plainText = Bun.stripANSI(coloredText);
+console.log(plainText); // => "Hello World"
+
+// Works with various ANSI codes
+const formatted = "\u001b[1m\u001b[4mBold and underlined\u001b[0m";
+console.log(Bun.stripANSI(formatted)); // => "Bold and underlined"
+```
+
+`Bun.stripANSI` is significantly faster than the popular [`strip-ansi`](https://www.npmjs.com/package/strip-ansi) npm package:
+
+```js
+> bun bench/snippets/strip-ansi.mjs
+cpu: Apple M3 Max
+runtime: bun 1.2.21 (arm64-darwin)
+
+benchmark                               avg (min … max) p75 / p99
+------------------------------------------------------- ----------
+Bun.stripANSI      11 chars no-ansi        8.13 ns/iter   8.27 ns
+                                   (7.45 ns … 33.59 ns)  10.29 ns
+
+Bun.stripANSI      13 chars ansi          51.68 ns/iter  52.51 ns
+                                 (46.16 ns … 113.71 ns)  57.71 ns
+
+Bun.stripANSI  16,384 chars long-no-ansi 298.39 ns/iter 305.44 ns
+                                (281.50 ns … 331.65 ns) 320.70 ns
+
+Bun.stripANSI 212,992 chars long-ansi    227.65 µs/iter 234.50 µs
+                                (216.46 µs … 401.92 µs) 262.25 µs
+```
+
+```js
+> node bench/snippets/strip-ansi.mjs
+cpu: Apple M3 Max
+runtime: node 24.6.0 (arm64-darwin)
+
+benchmark                                avg (min … max) p75 / p99
+-------------------------------------------------------- ---------
+npm/strip-ansi      11 chars no-ansi      466.79 ns/iter 468.67 ns
+                                 (454.08 ns … 570.67 ns) 543.67 ns
+
+npm/strip-ansi      13 chars ansi         546.77 ns/iter 550.23 ns
+                                 (532.74 ns … 651.08 ns) 590.35 ns
+
+npm/strip-ansi  16,384 chars long-no-ansi   4.85 µs/iter   4.89 µs
+                                     (4.71 µs … 5.00 µs)   4.98 µs
+
+npm/strip-ansi 212,992 chars long-ansi      1.36 ms/iter   1.38 ms
+                                     (1.27 ms … 1.73 ms)   1.49 ms
+
+```
+
 ## `estimateShallowMemoryUsageOf` in `bun:jsc`

 The `estimateShallowMemoryUsageOf` function returns a best-effort estimate of the memory usage of an object in bytes, excluding the memory usage of properties or other objects it references. For accurate per-object memory usage, use `Bun.generateHeapSnapshot`.
--- a/node_modules/bun-types/docs/api/workers.md
+++ b/node_modules/bun-types/docs/api/workers.md
@ -1,5 +1,5 @@
 {% callout %}
-**🚧** — The `Worker` API is still experimental and should not be considered ready for production.
+**🚧** — The `Worker` API is still experimental (particularly for terminating workers). We are actively working on improving this.
 {% /callout %}

 [`Worker`](https://developer.mozilla.org/en-US/docs/Web/API/Worker) lets you start and communicate with a new JavaScript instance running on a separate thread while sharing I/O resources with the main thread.
--- a/node_modules/bun-types/docs/bundler/executables.md
+++ b/node_modules/bun-types/docs/bundler/executables.md
@ -408,16 +408,119 @@ $ bun build --compile --asset-naming="[name].[ext]" ./index.ts

 To trim down the size of the executable a little, pass `--minify` to `bun build --compile`. This uses Bun's minifier to reduce the code size. Overall though, Bun's binary is still way too big and we need to make it smaller.

+## Using Bun.build() API
+
+You can also generate standalone executables using the `Bun.build()` JavaScript API. This is useful when you need programmatic control over the build process.
+
+### Basic usage
+
+```js
+await Bun.build({
+  entrypoints: ["./app.ts"],
+  outdir: "./dist",
+  compile: {
+    target: "bun-windows-x64",
+    outfile: "myapp.exe",
+  },
+});
+```
+
+### Windows metadata with Bun.build()
+
+When targeting Windows, you can specify metadata through the `windows` object:
+
+```js
+await Bun.build({
+  entrypoints: ["./app.ts"],
+  outdir: "./dist",
+  compile: {
+    target: "bun-windows-x64",
+    outfile: "myapp.exe",
+    windows: {
+      title: "My Application",
+      publisher: "My Company Inc",
+      version: "1.2.3.4",
+      description: "A powerful application built with Bun",
+      copyright: "© 2024 My Company Inc",
+      hideConsole: false, // Set to true for GUI applications
+      icon: "./icon.ico", // Path to icon file
+    },
+  },
+});
+```
+
+### Cross-compilation with Bun.build()
+
+You can cross-compile for different platforms:
+
+```js
+// Build for multiple platforms
+const platforms = [
+  { target: "bun-windows-x64", outfile: "app-windows.exe" },
+  { target: "bun-linux-x64", outfile: "app-linux" },
+  { target: "bun-darwin-arm64", outfile: "app-macos" },
+];
+
+for (const platform of platforms) {
+  await Bun.build({
+    entrypoints: ["./app.ts"],
+    outdir: "./dist",
+    compile: platform,
+  });
+}
+```
+
 ## Windows-specific flags

-When compiling a standalone executable on Windows, there are two platform-specific options that can be used to customize metadata on the generated `.exe` file:
+When compiling a standalone executable for Windows, there are several platform-specific options that can be used to customize the generated `.exe` file:

- `--windows-icon=path/to/icon.ico` to customize the executable file icon.
- `--windows-hide-console` to disable the background terminal, which can be used for applications that do not need a TTY.
+### Visual customization
+
+- `--windows-icon=path/to/icon.ico` - Set the executable file icon
+- `--windows-hide-console` - Disable the background terminal window (useful for GUI applications)
+
+### Metadata customization
+
+You can embed version information and other metadata into your Windows executable:
+
+- `--windows-title <STR>` - Set the product name (appears in file properties)
+- `--windows-publisher <STR>` - Set the company name
+- `--windows-version <STR>` - Set the version number (e.g. "1.2.3.4")
+- `--windows-description <STR>` - Set the file description
+- `--windows-copyright <STR>` - Set the copyright information
+
+#### Example with all metadata flags:
+
+```sh
+bun build --compile ./app.ts \
+  --outfile myapp.exe \
+  --windows-title "My Application" \
+  --windows-publisher "My Company Inc" \
+  --windows-version "1.2.3.4" \
+  --windows-description "A powerful application built with Bun" \
+  --windows-copyright "© 2024 My Company Inc"
+```
+
+This metadata will be visible in Windows Explorer when viewing the file properties:
+
+1. Right-click the executable in Windows Explorer
+2. Select "Properties"
+3. Go to the "Details" tab
+
+#### Version string format
+
+The `--windows-version` flag accepts version strings in the following formats:
+
+- `"1"` - Will be normalized to "1.0.0.0"
+- `"1.2"` - Will be normalized to "1.2.0.0"
+- `"1.2.3"` - Will be normalized to "1.2.3.0"
+- `"1.2.3.4"` - Full version format
+
+Each version component must be a number between 0 and 65535.

 {% callout %}

-These flags currently cannot be used when cross-compiling because they depend on Windows APIs.
+These flags currently cannot be used when cross-compiling because they depend on Windows APIs. They are only available when building on Windows itself.

 {% /callout %}

--- a/node_modules/bun-types/docs/bundler/index.md
+++ b/node_modules/bun-types/docs/bundler/index.md
@ -1,4 +1,4 @@
-Bun's fast native bundler is now in beta. It can be used via the `bun build` CLI command or the `Bun.build()` JavaScript API.
+Bun's fast native bundler can be used via the `bun build` CLI command or the `Bun.build()` JavaScript API.

 {% codetabs group="a" %}

--- a/node_modules/bun-types/docs/bundler/loaders.md
+++ b/node_modules/bun-types/docs/bundler/loaders.md
@ -1,6 +1,6 @@
 The Bun bundler implements a set of default loaders out of the box. As a rule of thumb, the bundler and the runtime both support the same set of file types out of the box.

-`.js` `.cjs` `.mjs` `.mts` `.cts` `.ts` `.tsx` `.jsx` `.toml` `.json` `.txt` `.wasm` `.node` `.html`
+`.js` `.cjs` `.mjs` `.mts` `.cts` `.ts` `.tsx` `.jsx` `.toml` `.json` `.yaml` `.yml` `.txt` `.wasm` `.node` `.html`

 Bun uses the file extension to determine which built-in _loader_ should be used to parse the file. Every loader has a name, such as `js`, `tsx`, or `json`. These names are used when building [plugins](https://bun.com/docs/bundler/plugins) that extend Bun with custom loaders.

@ -121,6 +121,55 @@ export default {

 {% /codetabs %}

+### `yaml`
+
+**YAML loader**. Default for `.yaml` and `.yml`.
+
+YAML files can be directly imported. Bun will parse them with its fast native YAML parser.
+
+```ts
+import config from "./config.yaml";
+config.database.host; // => "localhost"
+
+// via import attribute:
+// import myCustomYAML from './my.config' with {type: "yaml"};
+```
+
+During bundling, the parsed YAML is inlined into the bundle as a JavaScript object.
+
+```ts
+var config = {
+  database: {
+    host: "localhost",
+    port: 5432,
+  },
+  // ...other fields
+};
+config.database.host;
+```
+
+If a `.yaml` or `.yml` file is passed as an entrypoint, it will be converted to a `.js` module that `export default`s the parsed object.
+
+{% codetabs %}
+
+```yaml#Input
+name: John Doe
+age: 35
+email: johndoe@example.com
+```
+
+```js#Output
+export default {
+  name: "John Doe",
+  age: 35,
+  email: "johndoe@example.com"
+}
+```
+
+{% /codetabs %}
+
+For more details on YAML support including the runtime API `Bun.YAML.parse()`, see the [YAML API documentation](/docs/api/yaml).
+
 ### `text`

 **Text loader**. Default for `.txt`.
--- a/node_modules/bun-types/docs/cli/install.md
+++ b/node_modules/bun-types/docs/cli/install.md
@ -183,6 +183,30 @@ Bun supports installing dependencies from Git, GitHub, and local or remotely-hos
 }
 ```

+## Installation strategies
+
+Bun supports two package installation strategies that determine how dependencies are organized in `node_modules`:
+
+### Hoisted installs (default for single projects)
+
+The traditional npm/Yarn approach that flattens dependencies into a shared `node_modules` directory:
+
+```bash
+$ bun install --linker hoisted
+```
+
+### Isolated installs
+
+A pnpm-like approach that creates strict dependency isolation to prevent phantom dependencies:
+
+```bash
+$ bun install --linker isolated
+```
+
+Isolated installs create a central package store in `node_modules/.bun/` with symlinks in the top-level `node_modules`. This ensures packages can only access their declared dependencies.
+
+For complete documentation on isolated installs, refer to [Package manager > Isolated installs](https://bun.com/docs/install/isolated).
+
 ## Configuration

 The default behavior of `bun install` can be configured in `bunfig.toml`. The default values are shown below.
@ -213,11 +237,15 @@ dryRun = false

 # equivalent to `--concurrent-scripts` flag
 concurrentScripts = 16 # (cpu count or GOMAXPROCS) x2
+
+# installation strategy: "hoisted" or "isolated"
+# default: "hoisted"
+linker = "hoisted"
 ```

 ## CI/CD

-Looking to speed up your CI? Use the official [`oven-sh/setup-bun`](https://github.com/oven-sh/setup-bun) action to install `bun` in a GitHub Actions pipeline.
+Use the official [`oven-sh/setup-bun`](https://github.com/oven-sh/setup-bun) action to install `bun` in a GitHub Actions pipeline:

 ```yaml#.github/workflows/release.yml
 name: bun-types
@ -236,4 +264,31 @@ jobs:
        run: bun run build
 ```

+For CI/CD environments that want to enforce reproducible builds, use `bun ci` to fail the build if the package.json is out of sync with the lockfile:
+
+```bash
+$ bun ci
+```
+
+This is equivalent to `bun install --frozen-lockfile`. It installs exact versions from `bun.lock` and fails if `package.json` doesn't match the lockfile. To use `bun ci` or `bun install --frozen-lockfile`, you must commit `bun.lock` to version control.
+
+And instead of running `bun install`, run `bun ci`.
+
+```yaml#.github/workflows/release.yml
+name: bun-types
+jobs:
+  build:
+    name: build-app
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repo
+        uses: actions/checkout@v4
+      - name: Install bun
+        uses: oven-sh/setup-bun@v2
+      - name: Install dependencies
+        run: bun ci
+      - name: Build app
+        run: bun run build
+```
+
 {% bunCLIUsage command="install" /%}
--- a/node_modules/bun-types/docs/cli/pm.md
+++ b/node_modules/bun-types/docs/cli/pm.md
@ -213,7 +213,7 @@ To display current package version and help:

 ```bash
 $ bun pm version
-bun pm version v1.2.19 (ca7428e9)
+bun pm version v1.2.21 (ca7428e9)
 Current package version: v1.0.0

 Increment:
--- a/node_modules/bun-types/docs/cli/publish.md
+++ b/node_modules/bun-types/docs/cli/publish.md
@ -7,7 +7,7 @@ Use `bun publish` to publish a package to the npm registry.
 $ bun publish

 ## Output
-bun publish v1.2.19 (ca7428e9)
+bun publish v1.2.21 (ca7428e9)

 packed 203B package.json
 packed 224B README.md
--- a/node_modules/bun-types/docs/cli/test.md
+++ b/node_modules/bun-types/docs/cli/test.md
@ -158,7 +158,7 @@ See [Test > Lifecycle](https://bun.com/docs/test/lifecycle) for complete documen

 ## Mocks

-Create mock functions with the `mock` function. Mocks are automatically reset between tests.
+Create mock functions with the `mock` function.

 ```ts
 import { test, expect, mock } from "bun:test";
--- a/node_modules/bun-types/docs/cli/update.md
+++ b/node_modules/bun-types/docs/cli/update.md
@ -10,6 +10,86 @@ To update a specific dependency to the latest version:
 $ bun update [package]
 ```

+## `--interactive`
+
+For a more controlled update experience, use the `--interactive` flag to select which packages to update:
+
+```sh
+$ bun update --interactive
+$ bun update -i
+```
+
+This launches an interactive terminal interface that shows all outdated packages with their current and target versions. You can then select which packages to update.
+
+### Interactive Interface
+
+The interface displays packages grouped by dependency type:
+
+```
+? Select packages to update - Space to toggle, Enter to confirm, a to select all, n to select none, i to invert, l to toggle latest
+
+  dependencies                Current  Target   Latest
+    □ react                   17.0.2   18.2.0   18.3.1
+    □ lodash                  4.17.20  4.17.21  4.17.21
+
+  devDependencies             Current  Target   Latest
+    □ typescript              4.8.0    5.0.0    5.3.3
+    □ @types/node             16.11.7  18.0.0   20.11.5
+
+  optionalDependencies        Current  Target   Latest
+    □ some-optional-package   1.0.0    1.1.0    1.2.0
+```
+
+**Sections:**
+
+- Packages are grouped under section headers: `dependencies`, `devDependencies`, `peerDependencies`, `optionalDependencies`
+- Each section shows column headers aligned with the package data
+
+**Columns:**
+
+- **Package**: Package name (may have suffix like ` dev`, ` peer`, ` optional` for clarity)
+- **Current**: Currently installed version
+- **Target**: Version that would be installed (respects semver constraints)
+- **Latest**: Latest available version
+
+### Keyboard Controls
+
+**Selection:**
+
+- **Space**: Toggle package selection
+- **Enter**: Confirm selections and update
+- **a/A**: Select all packages
+- **n/N**: Select none
+- **i/I**: Invert selection
+
+**Navigation:**
+
+- **↑/↓ Arrow keys** or **j/k**: Move cursor
+- **l/L**: Toggle between target and latest version for current package
+
+**Exit:**
+
+- **Ctrl+C** or **Ctrl+D**: Cancel without updating
+
+### Visual Indicators
+
+- **☑** Selected packages (will be updated)
+- **□** Unselected packages
+- **>** Current cursor position
+- **Colors**: Red (major), yellow (minor), green (patch) version changes
+- **Underlined**: Currently selected update target
+
+### Package Grouping
+
+Packages are organized in sections by dependency type:
+
+- **dependencies** - Regular runtime dependencies
+- **devDependencies** - Development dependencies
+- **peerDependencies** - Peer dependencies
+- **optionalDependencies** - Optional dependencies
+
+Within each section, individual packages may have additional suffixes (` dev`, ` peer`, ` optional`) for extra clarity.
+
 ## `--latest`

 By default, `bun update` will update to the latest version of a dependency that satisfies the version range specified in your `package.json`.
@ -20,6 +100,8 @@ To update to the latest version, regardless of if it's compatible with the curre
 $ bun update --latest
 ```

+In interactive mode, you can toggle individual packages between their target version (respecting semver) and latest version using the **l** key.
+
 For example, with the following `package.json`:

 ```json
--- a/node_modules/bun-types/docs/guides/ecosystem/nuxt.md
+++ b/node_modules/bun-types/docs/guides/ecosystem/nuxt.md
@ -9,7 +9,7 @@ $ bunx nuxi init my-nuxt-app
 ✔ Which package manager would you like to use?
 bun
 ◐ Installing dependencies...
-bun install v1.2.19 (16b4bf34)
+bun install v1.2.21 (16b4bf34)
 + @nuxt/devtools@0.8.2
 + nuxt@3.7.0
 785 packages installed [2.67s]
--- a/node_modules/bun-types/docs/guides/install/add-peer.md
+++ b/node_modules/bun-types/docs/guides/install/add-peer.md
@ -15,7 +15,7 @@ This will add the package to `peerDependencies` in `package.json`.
 ```json-diff
 {
  "peerDependencies": {
-+   "@types/bun": "^1.2.19"
+   "@types/bun": "^1.2.21"
  }
 }
 ```
@ -27,7 +27,7 @@ Running `bun install` will install peer dependencies by default, unless marked o
 ```json-diff
 {
  "peerDependencies": {
-    "@types/bun": "^1.2.19"
+    "@types/bun": "^1.2.21"
  },
  "peerDependenciesMeta": {
 +   "@types/bun": {
--- a/node_modules/bun-types/docs/guides/install/from-npm-install-to-bun-install.md
+++ b/node_modules/bun-types/docs/guides/install/from-npm-install-to-bun-install.md
@ -97,7 +97,7 @@ $ bun update
 $ bun update @types/bun --latest

 # Update a dependency to a specific version
-$ bun update @types/bun@1.2.19
+$ bun update @types/bun@1.2.21

 # Update all dependencies to the latest versions
 $ bun update --latest
--- a/node_modules/bun-types/docs/guides/test/run-tests.md
+++ b/node_modules/bun-types/docs/guides/test/run-tests.md
@ -21,7 +21,7 @@ Here's what the output of a typical test run looks like. In this case, there are

 ```sh
 $ bun test
-bun test v1.2.19 (9c68abdb)
+bun test v1.2.21 (9c68abdb)

 test.test.js:
 ✓ add [0.87ms]
@ -47,7 +47,7 @@ To only run certain test files, pass a positional argument to `bun test`. The ru

 ```sh
 $ bun test test3
-bun test v1.2.19 (9c68abdb)
+bun test v1.2.21 (9c68abdb)

 test3.test.js:
 ✓ add [1.40ms]
@ -85,7 +85,7 @@ Adding `-t add` will only run tests with "add" in the name. This works with test

 ```sh
 $ bun test -t add
-bun test v1.2.19 (9c68abdb)
+bun test v1.2.21 (9c68abdb)

 test.test.js:
 ✓ add [1.79ms]
--- a/node_modules/bun-types/docs/guides/test/snapshot.md
+++ b/node_modules/bun-types/docs/guides/test/snapshot.md
@ -18,7 +18,7 @@ The first time this test is executed, Bun will evaluate the value passed into `e

 ```sh
 $ bun test test/snap
-bun test v1.2.19 (9c68abdb)
+bun test v1.2.21 (9c68abdb)

 test/snap.test.ts:
 ✓ snapshot [1.48ms]
@ -61,7 +61,7 @@ Later, when this test file is executed again, Bun will read the snapshot file an

 ```sh
 $ bun test
-bun test v1.2.19 (9c68abdb)
+bun test v1.2.21 (9c68abdb)

 test/snap.test.ts:
 ✓ snapshot [1.05ms]
@ -78,7 +78,7 @@ To update snapshots, use the `--update-snapshots` flag.

 ```sh
 $ bun test --update-snapshots
-bun test v1.2.19 (9c68abdb)
+bun test v1.2.21 (9c68abdb)

 test/snap.test.ts:
 ✓ snapshot [0.86ms]
--- a/node_modules/bun-types/docs/guides/test/update-snapshots.md
+++ b/node_modules/bun-types/docs/guides/test/update-snapshots.md
@ -29,7 +29,7 @@ To regenerate snapshots, use the `--update-snapshots` flag.

 ```sh
 $ bun test --update-snapshots
-bun test v1.2.19 (9c68abdb)
+bun test v1.2.21 (9c68abdb)

 test/snap.test.ts:
 ✓ snapshot [0.86ms]
--- a/node_modules/bun-types/docs/guides/util/detect-bun.md
+++ b/node_modules/bun-types/docs/guides/util/detect-bun.md
@ -14,7 +14,7 @@ if (typeof Bun !== "undefined") {

 ---

-In TypeScript environments, the previous approach will result in a type error unless `bun-types` is globally installed. To avoid this, you can check `process.versions` instead.
+In TypeScript environments, the previous approach will result in a type error unless `@types/bun` is installed. To avoid this, you can check `process.versions` instead.

 ```ts
 if (process.versions.bun) {
--- a/node_modules/bun-types/docs/guides/util/version.md
+++ b/node_modules/bun-types/docs/guides/util/version.md
@ -5,7 +5,7 @@ name: Get the current Bun version
 Get the current version of Bun in a semver format.

 ```ts#index.ts
-Bun.version; // => "1.2.19"
+Bun.version; // => "1.2.21"
 ```

 ---
--- a/node_modules/bun-types/docs/install/index.md
+++ b/node_modules/bun-types/docs/install/index.md
@ -81,6 +81,14 @@ $ bun install --verbose # debug logging
 $ bun install --silent  # no logging
 ```

+To use isolated installs instead of the default hoisted strategy:
+
+```bash
+$ 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).
+
 {% details summary="Configuring behavior" %}
 The default behavior of `bun install` can be configured in `bunfig.toml`:

@ -110,6 +118,10 @@ dryRun = false

 # equivalent to `--concurrent-scripts` flag
 concurrentScripts = 16 # (cpu count or GOMAXPROCS) x2
+
+# installation strategy: "hoisted" or "isolated"
+# default: "hoisted"
+linker = "hoisted"
 ```

 {% /details %}
--- a/node_modules/bun-types/docs/installation.md
+++ b/node_modules/bun-types/docs/installation.md
@ -14,7 +14,7 @@ Kernel version 5.6 or higher is strongly recommended, but the minimum is 5.1. Us
 ```bash#macOS/Linux_(curl)
 $ curl -fsSL https://bun.com/install | bash # for macOS, Linux, and WSL
 # to install a specific version
-$ curl -fsSL https://bun.com/install | bash -s "bun-v1.2.19"
+$ curl -fsSL https://bun.com/install | bash -s "bun-v1.2.21"
 ```

 ```bash#npm
@ -189,10 +189,10 @@ Since Bun is a single binary, you can install older versions of Bun by re-runnin

 ### Installing a specific version of Bun on Linux/Mac

-To install a specific version of Bun, you can pass the git tag of the version you want to install to the install script, such as `bun-v1.2.0` or `bun-v1.2.19`.
+To install a specific version of Bun, you can pass the git tag of the version you want to install to the install script, such as `bun-v1.2.0` or `bun-v1.2.21`.

 ```sh
-$ curl -fsSL https://bun.com/install | bash -s "bun-v1.2.19"
+$ curl -fsSL https://bun.com/install | bash -s "bun-v1.2.21"
 ```

 ### Installing a specific version of Bun on Windows
@ -201,7 +201,7 @@ On Windows, you can install a specific version of Bun by passing the version num

 ```sh
 # PowerShell:
-$ iex "& {$(irm https://bun.com/install.ps1)} -Version 1.2.19"
+$ iex "& {$(irm https://bun.com/install.ps1)} -Version 1.2.21"
 ```

 ## Downloading Bun binaries directly
--- a/node_modules/bun-types/docs/project/bindgen.md
+++ b/node_modules/bun-types/docs/project/bindgen.md
@ -20,7 +20,7 @@ this one:
 Given a file implementing a simple function, such as `add`

 ```zig#src/bun.js/math.zig
-pub fn add(global: *JSC.JSGlobalObject, a: i32, b: i32) !i32 {
+pub fn add(global: *jsc.JSGlobalObject, a: i32, b: i32) !i32 {
    return std.math.add(i32, a, b) catch {
        // Binding functions can return `error.OutOfMemory` and `error.JSError`.
        // Others like `error.Overflow` from `std.math.add` must be converted.
@ -33,7 +33,7 @@ const gen = bun.gen.math; // "math" being this file's basename

 const std = @import("std");
 const bun = @import("bun");
-const JSC = bun.JSC;
+const jsc = bun.jsc;
 ```

 Then describe the API schema using a `.bind.ts` function. The binding file goes next to the Zig file.
--- a/node_modules/bun-types/docs/project/contributing.md
+++ b/node_modules/bun-types/docs/project/contributing.md
@ -160,6 +160,7 @@ In particular, these are:

 - `./src/codegen/generate-jssink.ts` -- Generates `build/debug/codegen/JSSink.cpp`, `build/debug/codegen/JSSink.h` which implement various classes for interfacing with `ReadableStream`. This is internally how `FileSink`, `ArrayBufferSink`, `"type": "direct"` streams and other code related to streams works.
 - `./src/codegen/generate-classes.ts` -- Generates `build/debug/codegen/ZigGeneratedClasses*`, which generates Zig & C++ bindings for JavaScriptCore classes implemented in Zig. In `**/*.classes.ts` files, we define the interfaces for various classes, methods, prototypes, getters/setters etc which the code generator reads to generate boilerplate code implementing the JavaScript objects in C++ and wiring them up to Zig
+- `./src/codegen/cppbind.ts` -- Generates automatic Zig bindings for C++ functions marked with `[[ZIG_EXPORT]]` attributes.
 - `./src/codegen/bundle-modules.ts` -- Bundles built-in modules like `node:fs`, `bun:ffi` into files we can include in the final binary. In development, these can be reloaded without rebuilding Zig (you still need to run `bun run build`, but it re-reads the transpiled files from disk afterwards). In release builds, these are embedded into the binary.
 - `./src/codegen/bundle-functions.ts` -- Bundles globally-accessible functions implemented in JavaScript/TypeScript like `ReadableStream`, `WritableStream`, and a handful more. These are used similarly to the builtin modules, but the output more closely aligns with what WebKit/Safari does for Safari's built-in functions so that we can copy-paste the implementations from WebKit as a starting point.

--- a/node_modules/bun-types/docs/runtime/bun-apis.md
+++ b/node_modules/bun-types/docs/runtime/bun-apis.md
@ -195,12 +195,12 @@ Click the link in the right column to jump to the associated documentation.
 ---

 - Parsing & Formatting
- [`Bun.semver`](https://bun.com/docs/api/semver), `Bun.TOML.parse`, [`Bun.color`](https://bun.com/docs/api/color)
+- [`Bun.semver`](https://bun.com/docs/api/semver), `Bun.TOML.parse`, [`Bun.YAML.parse`](https://bun.com/docs/api/yaml), [`Bun.color`](https://bun.com/docs/api/color)

 ---

 - Low-level / Internals
- `Bun.mmap`, `Bun.gc`, `Bun.generateHeapSnapshot`, [`bun:jsc`](https://bun.com/docs/api/bun-jsc)
+- `Bun.mmap`, `Bun.gc`, `Bun.generateHeapSnapshot`, [`bun:jsc`](https://bun.com/reference/bun/jsc)

 ---

--- a/node_modules/bun-types/docs/runtime/bunfig.md
+++ b/node_modules/bun-types/docs/runtime/bunfig.md
@ -94,6 +94,7 @@ Bun supports the following loaders:
 - `file`
 - `json`
 - `toml`
+- `yaml`
 - `wasm`
 - `napi`
 - `base64`
@ -496,6 +497,62 @@ Whether to generate a non-Bun lockfile alongside `bun.lock`. (A `bun.lock` will
 print = "yarn"
 ```

+### `install.security.scanner`
+
+Configure a security scanner to scan packages for vulnerabilities before installation.
+
+First, install a security scanner from npm:
+
+```bash
+$ bun add -d @acme/bun-security-scanner
+```
+
+Then configure it in your `bunfig.toml`:
+
+```toml
+[install.security]
+scanner = "@acme/bun-security-scanner"
+```
+
+When a security scanner is configured:
+
+- Auto-install is automatically disabled for security
+- Packages are scanned before installation
+- Installation is cancelled if fatal issues are found
+- Security warnings are displayed during installation
+
+Learn more about [using and writing security scanners](/docs/install/security).
+
+### `install.linker`
+
+Configure the default linker strategy. Default `"hoisted"`.
+
+For complete documentation refer to [Package manager > Isolated installs](https://bun.com/docs/install/isolated).
+
+```toml
+[install]
+linker = "hoisted"
+```
+
+Valid values are:
+
+{% table %}
+
+- Value
+- Description
+
+---
+
+- `"hoisted"`
+- Link dependencies in a shared `node_modules` directory.
+
+---
+
+- `"isolated"`
+- Link dependencies inside each package installation.
+
+{% /table %}
+
 <!-- ## Debugging -->

 <!--
--- a/node_modules/bun-types/docs/runtime/debugger.md
+++ b/node_modules/bun-types/docs/runtime/debugger.md
@ -124,11 +124,11 @@ await fetch("https://example.com", {
 This prints the `fetch` request as a single-line `curl` command to let you copy-paste into your terminal to replicate the request.

 ```sh
-[fetch] $ curl --http1.1 "https://example.com/" -X POST -H "content-type: application/json" -H "Connection: keep-alive" -H "User-Agent: Bun/1.2.19" -H "Accept: */*" -H "Host: example.com" -H "Accept-Encoding: gzip, deflate, br" --compressed -H "Content-Length: 13" --data-raw "{\"foo\":\"bar\"}"
+[fetch] $ curl --http1.1 "https://example.com/" -X POST -H "content-type: application/json" -H "Connection: keep-alive" -H "User-Agent: Bun/1.2.21" -H "Accept: */*" -H "Host: example.com" -H "Accept-Encoding: gzip, deflate, br" --compressed -H "Content-Length: 13" --data-raw "{\"foo\":\"bar\"}"
 [fetch] > HTTP/1.1 POST https://example.com/
 [fetch] > content-type: application/json
 [fetch] > Connection: keep-alive
-[fetch] > User-Agent: Bun/1.2.19
+[fetch] > User-Agent: Bun/1.2.21
 [fetch] > Accept: */*
 [fetch] > Host: example.com
 [fetch] > Accept-Encoding: gzip, deflate, br
@ -170,7 +170,7 @@ This prints the following to the console:
 [fetch] > HTTP/1.1 POST https://example.com/
 [fetch] > content-type: application/json
 [fetch] > Connection: keep-alive
-[fetch] > User-Agent: Bun/1.2.19
+[fetch] > User-Agent: Bun/1.2.21
 [fetch] > Accept: */*
 [fetch] > Host: example.com
 [fetch] > Accept-Encoding: gzip, deflate, br
--- a/node_modules/bun-types/docs/runtime/index.md
+++ b/node_modules/bun-types/docs/runtime/index.md
@ -92,15 +92,18 @@ every file before execution. Its transpiler  can directly run TypeScript and JSX

 ## JSX

-## JSON and TOML
+## JSON, TOML, and YAML

-Source files can import a `*.json` or `*.toml` file to load its contents as a plain old JavaScript object.
+Source files can import `*.json`, `*.toml`, or `*.yaml` files to load their contents as plain JavaScript objects.

 ```ts
 import pkg from "./package.json";
 import bunfig from "./bunfig.toml";
+import config from "./config.yaml";
 ```

+See the [YAML API documentation](/docs/api/yaml) for more details on YAML support.
+
 ## WASI

 {% callout %}
--- a/node_modules/bun-types/docs/runtime/loaders.md
+++ b/node_modules/bun-types/docs/runtime/loaders.md
@ -52,15 +52,18 @@ Hello world!

 {% /codetabs %}

-## JSON and TOML
+## JSON, TOML, and YAML

-JSON and TOML files can be directly imported from a source file. The contents will be loaded and returned as a JavaScript object.
+JSON, TOML, and YAML files can be directly imported from a source file. The contents will be loaded and returned as a JavaScript object.

 ```ts
 import pkg from "./package.json";
 import data from "./data.toml";
+import config from "./config.yaml";
 ```

+For more details on YAML support, see the [YAML API documentation](/docs/api/yaml).
+
 ## WASI

 {% callout %}
--- a/node_modules/bun-types/docs/runtime/nodejs-apis.md
+++ b/node_modules/bun-types/docs/runtime/nodejs-apis.md
@ -148,7 +148,7 @@ This page is updated regularly to reflect compatibility status of the latest ver

 ### [`node:vm`](https://nodejs.org/api/vm.html)

-🟡 Core functionality works, but experimental VM ES modules are not implemented, including `vm.Module`, `vm.SourceTextModule`, `vm.SyntheticModule`,`importModuleDynamically`, and `vm.measureMemory`. Options like `timeout`, `breakOnSigint`, `cachedData` are not implemented yet.
+🟡 Core functionality and ES modules are implemented, including `vm.Script`, `vm.createContext`, `vm.runInContext`, `vm.runInNewContext`, `vm.runInThisContext`, `vm.compileFunction`, `vm.isContext`, `vm.Module`, `vm.SourceTextModule`, `vm.SyntheticModule`, and `importModuleDynamically` support. Options like `timeout` and `breakOnSigint` are fully supported. Missing `vm.measureMemory` and some `cachedData` functionality.

 ### [`node:wasi`](https://nodejs.org/api/wasi.html)

@ -214,6 +214,10 @@ The table below lists all globals implemented by Node.js and Bun's current compa

 🟢 Fully implemented.

+### [`Atomics`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Atomics)
+
+🟢 Fully implemented.
+
 ### [`BroadcastChannel`](https://developer.mozilla.org/en-US/docs/Web/API/BroadcastChannel)

 🟢 Fully implemented.
--- a/node_modules/bun-types/docs/runtime/shell.md
+++ b/node_modules/bun-types/docs/runtime/shell.md
@ -532,6 +532,74 @@ Hello World! pwd=C:\Users\Demo

 Bun Shell is a small programming language in Bun that is implemented in Zig. It includes a handwritten lexer, parser, and interpreter. Unlike bash, zsh, and other shells, Bun Shell runs operations concurrently.

+## Security in the Bun shell
+
+By design, the Bun shell _does not invoke a system shell_ (like `/bin/sh`) and
+is instead a re-implementation of bash that runs in the same Bun process,
+designed with security in mind.
+
+When parsing command arguments, it treats all _interpolated variables_ as single, literal strings.
+
+This protects the Bun shell against **command injection**:
+
+```js
+import { $ } from "bun";
+
+const userInput = "my-file.txt; rm -rf /";
+
+// SAFE: `userInput` is treated as a single quoted string
+await $`ls ${userInput}`;
+```
+
+In the above example, `userInput` is treated as a single string. This causes
+the `ls` command to try to read the contents of a single directory named
+"my-file; rm -rf /".
+
+### Security considerations
+
+While command injection is prevented by default, developers are still
+responsible for security in certain scenarios.
+
+Similar to the `Bun.spawn` or `node:child_process.exec()` APIs, you can intentionally
+execute a command which spawns a new shell (e.g. `bash -c`) with arguments.
+
+When you do this, you hand off control, and Bun's built-in protections no
+longer apply to the string interpreted by that new shell.
+
+```js
+import { $ } from "bun";
+
+const userInput = "world; touch /tmp/pwned";
+
+// UNSAFE: You have explicitly started a new shell process with `bash -c`.
+// This new shell will execute the `touch` command. Any user input
+// passed this way must be rigorously sanitized.
+await $`bash -c "echo ${userInput}"`;
+```
+
+### Argument injection
+
+The Bun shell cannot know how an external command interprets its own
+command-line arguments. An attacker can supply input that the target program
+recognizes as one of its own options or flags, leading to unintended behavior.
+
+```js
+import { $ } from "bun";
+
+// Malicious input formatted as a Git command-line flag
+const branch = "--upload-pack=echo pwned";
+
+// UNSAFE: While Bun safely passes the string as a single argument,
+// the `git` program itself sees and acts upon the malicious flag.
+await $`git ls-remote origin ${branch}`;
+```
+
+{% callout %}
+**Recommendation** — As is best practice in every language, always sanitize
+user-provided input before passing it as an argument to an external command.
+The responsibility for validating arguments rests with your application code.
+{% /callout %}
+
 ## Credits

 Large parts of this API were inspired by [zx](https://github.com/google/zx), [dax](https://github.com/dsherret/dax), and [bnx](https://github.com/wobsoriano/bnx). Thank you to the authors of those projects.
--- a/node_modules/bun-types/docs/test/dom.md
+++ b/node_modules/bun-types/docs/test/dom.md
@ -55,7 +55,7 @@ Let's run this test with `bun test`:

 ```bash
 $ bun test
-bun test v1.2.19
+bun test v1.2.21

 dom.test.ts:
 ✓ dom test [0.82ms]
--- a/node_modules/bun-types/docs/test/writing.md
+++ b/node_modules/bun-types/docs/test/writing.md
@ -426,6 +426,54 @@ test("exactly two assertions", () => {

 This helps ensure all your assertions run, especially in complex async code with multiple code paths.

+## Type Testing
+
+Bun includes `expectTypeOf` for testing typescript types, compatible with Vitest.
+
+### expectTypeOf
+
+{% callout %}
+
+**Note** — These functions are no-ops at runtime - you need to run TypeScript separately to verify the type checks.
+
+{% endcallout %}
+
+The `expectTypeOf` function provides type-level assertions that are checked by TypeScript's type checker. **Important**:
+
+To test your types:
+
+1. Write your type assertions using `expectTypeOf`
+2. Run `bunx tsc --noEmit` to check that your types are correct
+
+```ts
+import { expectTypeOf } from "bun:test";
+
+// Basic type assertions
+expectTypeOf<string>().toEqualTypeOf<string>();
+expectTypeOf(123).toBeNumber();
+expectTypeOf("hello").toBeString();
+
+// Object type matching
+expectTypeOf({ a: 1, b: "hello" }).toMatchObjectType<{ a: number }>();
+
+// Function types
+function greet(name: string): string {
+  return `Hello ${name}`;
+}
+
+expectTypeOf(greet).toBeFunction();
+expectTypeOf(greet).parameters.toEqualTypeOf<[string]>();
+expectTypeOf(greet).returns.toEqualTypeOf<string>();
+
+// Array types
+expectTypeOf([1, 2, 3]).items.toBeNumber();
+
+// Promise types
+expectTypeOf(Promise.resolve(42)).resolves.toBeNumber();
+```
+
+For full documentation on expectTypeOf matchers, see the [API Reference](/reference/bun/test/expectTypeOf)
+
 ## Matchers

 Bun implements the following matchers. Full Jest compatibility is on the roadmap; track progress [here](https://github.com/oven-sh/bun/issues/1825).
@ -629,17 +677,17 @@ Bun implements the following matchers. Full Jest compatibility is on the roadmap

 ---

- ❌
+- ✅
 - [`.toHaveReturnedWith()`](https://jestjs.io/docs/expect#tohavereturnedwithvalue)

 ---

- ❌
+- ✅
 - [`.toHaveLastReturnedWith()`](https://jestjs.io/docs/expect#tohavelastreturnedwithvalue)

 ---

- ❌
+- ✅
 - [`.toHaveNthReturnedWith()`](https://jestjs.io/docs/expect#tohaventhreturnedwithnthcall-value)

 ---
--- a/node_modules/bun-types/extensions.d.ts
+++ b/node_modules/bun-types/extensions.d.ts
@ -8,6 +8,16 @@ declare module "*.toml" {
  export = contents;
 }

+declare module "*.yaml" {
+  var contents: any;
+  export = contents;
+}
+
+declare module "*.yml" {
+  var contents: any;
+  export = contents;
+}
+
 declare module "*.jsonc" {
  var contents: any;
  export = contents;
--- a/node_modules/bun-types/fetch.d.ts
+++ b/node_modules/bun-types/fetch.d.ts
@ -1,19 +1,21 @@
 /*
-
-  This file does not declare any global types.
-
-  That should only happen in [./globals.d.ts](./globals.d.ts)
-  so that our documentation generator can pick it up, as it
-  expects all globals to be declared in one file.
-
+ * This file does not declare any global types.
+ *
+ * That should only happen in [./globals.d.ts](./globals.d.ts)
+ * so that our documentation generator can pick it up, as it
+ * expects all globals to be declared in one file.
+ *
+ * This may change in the future, which would be
+ * a nice thing as it would allow us to split up
+ * relevant types into their own files.
 */
-
 declare module "bun" {
  type HeadersInit = string[][] | Record<string, string | ReadonlyArray<string>> | Headers;
  type BodyInit =
    | ReadableStream
    | Bun.XMLHttpRequestBodyInit
-    | URLSearchParams
+    // Extras that Bun supports:
+    | AsyncIterable<string | ArrayBuffer | ArrayBufferView>
    | AsyncGenerator<string | ArrayBuffer | ArrayBufferView>
    | (() => AsyncGenerator<string | ArrayBuffer | ArrayBufferView>);

@ -26,7 +28,7 @@ declare module "bun" {
      ? {}
      : Omit<import("undici-types").RequestInit, "body" | "headers"> & {
          body?: Bun.BodyInit | null | undefined;
-          headers?: Bun.HeadersInit;
+          headers?: Bun.HeadersInit | undefined;
        };

    interface BunHeadersOverride extends LibOrFallbackHeaders {
--- a/node_modules/bun-types/globals.d.ts
+++ b/node_modules/bun-types/globals.d.ts
@ -999,6 +999,7 @@ interface ArrayBuffer {
   * Read-only. The length of the ArrayBuffer (in bytes).
   */
  readonly byteLength: number;
+
  /**
   * Resize an ArrayBuffer in-place.
   */
@ -1008,7 +1009,6 @@ interface ArrayBuffer {
   * Returns a section of an ArrayBuffer.
   */
  slice(begin: number, end?: number): ArrayBuffer;
-  readonly [Symbol.toStringTag]: string;
 }

 interface SharedArrayBuffer {
@ -1284,7 +1284,7 @@ interface ImportMeta {
   * )
   * ```
   */
-  readonly main: boolean;
+  main: boolean;

  /** Alias of `import.meta.dir`. Exists for Node.js compatibility */
  dirname: string;
@ -1426,12 +1426,12 @@ interface Blob {
  /**
   * Returns a promise that resolves to the contents of the blob as a Uint8Array (array of bytes) its the same as `new Uint8Array(await blob.arrayBuffer())`
   */
-  bytes(): Promise<Uint8Array>;
+  bytes(): Promise<Uint8Array<ArrayBuffer>>;

  /**
   * Returns a readable stream of the blob's contents
   */
-  stream(): ReadableStream<Uint8Array>;
+  stream(): ReadableStream<Uint8Array<ArrayBuffer>>;
 }

 declare var Blob: Bun.__internal.UseLibDomIfAvailable<
@ -1506,14 +1506,14 @@ interface Uint8ArrayConstructor {
      alphabet?: "base64" | "base64url";
      lastChunkHandling?: "loose" | "strict" | "stop-before-partial";
    },
-  ): Uint8Array;
+  ): Uint8Array<ArrayBuffer>;

  /**
   * Create a new Uint8Array from a hex encoded string
   * @param hex The hex encoded string to convert to a Uint8Array
   * @returns A new Uint8Array containing the decoded data
   */
-  fromHex(hex: string): Uint8Array;
+  fromHex(hex: string): Uint8Array<ArrayBuffer>;
 }

 interface BroadcastChannel extends Bun.__internal.LibEmptyOrBroadcastChannel {}
@ -1888,6 +1888,25 @@ interface BunFetchRequestInit extends RequestInit {
   * ```
   */
  unix?: string;
+
+  /**
+   * Control automatic decompression of the response body.
+   * When set to `false`, the response body will not be automatically decompressed,
+   * and the `Content-Encoding` header will be preserved. This can improve performance
+   * when you need to handle compressed data manually or forward it as-is.
+   * This is a custom property that is not part of the Fetch API specification.
+   *
+   * @default true
+   * @example
+   * ```js
+   * // Disable automatic decompression for a proxy server
+   * const response = await fetch("https://example.com/api", {
+   *   decompress: false
+   * });
+   * // response.headers.get('content-encoding') might be 'gzip' or 'br'
+   * ```
+   */
+  decompress?: boolean;
 }

 /**
--- a/node_modules/bun-types/index.d.ts
+++ b/node_modules/bun-types/index.d.ts
@ -21,6 +21,8 @@
 /// <reference path="./redis.d.ts" />
 /// <reference path="./shell.d.ts" />
 /// <reference path="./experimental.d.ts" />
+/// <reference path="./sql.d.ts" />
+/// <reference path="./security.d.ts" />

 /// <reference path="./bun.ns.d.ts" />

--- a/node_modules/bun-types/overrides.d.ts
+++ b/node_modules/bun-types/overrides.d.ts
@ -6,14 +6,17 @@ declare module "stream/web" {
     * Consume a ReadableStream as text
     */
    text(): Promise<string>;
+
    /**
     * Consume a ReadableStream as a Uint8Array
     */
-    bytes(): Promise<Uint8Array>;
+    bytes(): Promise<Uint8Array<ArrayBuffer>>;
+
    /**
     * Consume a ReadableStream as JSON
     */
    json(): Promise<any>;
+
    /**
     * Consume a ReadableStream as a Blob
     */
@ -21,6 +24,12 @@ declare module "stream/web" {
  }
 }

+declare module "url" {
+  interface URLSearchParams {
+    toJSON(): Record<string, string>;
+  }
+}
+
 declare global {
  namespace NodeJS {
    interface ProcessEnv extends Bun.Env {}
--- a/node_modules/bun-types/package.json
+++ b/node_modules/bun-types/package.json
@ -1,5 +1,5 @@
 {
-  "version": "1.2.19",
+  "version": "1.2.21",
  "name": "bun-types",
  "license": "MIT",
  "types": "./index.d.ts",
@ -11,10 +11,11 @@
  },
  "files": [
    "./*.d.ts",
-    "docs/**/*.md",
-    "docs/*.md",
-    "CLAUDE.md",
-    "README.md"
+    "./vendor/**/*.d.ts",
+    "./docs/**/*.md",
+    "./docs/*.md",
+    "./CLAUDE.md",
+    "./README.md"
  ],
  "homepage": "https://bun.com",
  "dependencies": {
@ -24,8 +25,7 @@
    "@types/react": "^19"
  },
  "devDependencies": {
-    "@types/react": "^19",
-    "typescript": "^5.0.2"
+    "@types/react": "^19"
  },
  "scripts": {
    "prebuild": "echo $(pwd)",
--- a/node_modules/bun-types/redis.d.ts
+++ b/node_modules/bun-types/redis.d.ts
@ -574,6 +574,50 @@ declare module "bun" {
     */
    getex(key: RedisClient.KeyLike): Promise<string | null>;

+    /**
+     * Get the value of a key and set its expiration in seconds
+     * @param key The key to get
+     * @param ex Set the specified expire time, in seconds
+     * @param seconds The number of seconds until expiration
+     * @returns Promise that resolves with the value of the key, or null if the key doesn't exist
+     */
+    getex(key: RedisClient.KeyLike, ex: "EX", seconds: number): Promise<string | null>;
+
+    /**
+     * Get the value of a key and set its expiration in milliseconds
+     * @param key The key to get
+     * @param px Set the specified expire time, in milliseconds
+     * @param milliseconds The number of milliseconds until expiration
+     * @returns Promise that resolves with the value of the key, or null if the key doesn't exist
+     */
+    getex(key: RedisClient.KeyLike, px: "PX", milliseconds: number): Promise<string | null>;
+
+    /**
+     * Get the value of a key and set its expiration at a specific Unix timestamp in seconds
+     * @param key The key to get
+     * @param exat Set the specified Unix time at which the key will expire, in seconds
+     * @param timestampSeconds The Unix timestamp in seconds
+     * @returns Promise that resolves with the value of the key, or null if the key doesn't exist
+     */
+    getex(key: RedisClient.KeyLike, exat: "EXAT", timestampSeconds: number): Promise<string | null>;
+
+    /**
+     * Get the value of a key and set its expiration at a specific Unix timestamp in milliseconds
+     * @param key The key to get
+     * @param pxat Set the specified Unix time at which the key will expire, in milliseconds
+     * @param timestampMilliseconds The Unix timestamp in milliseconds
+     * @returns Promise that resolves with the value of the key, or null if the key doesn't exist
+     */
+    getex(key: RedisClient.KeyLike, pxat: "PXAT", timestampMilliseconds: number): Promise<string | null>;
+
+    /**
+     * Get the value of a key and remove its expiration
+     * @param key The key to get
+     * @param persist Remove the expiration from the key
+     * @returns Promise that resolves with the value of the key, or null if the key doesn't exist
+     */
+    getex(key: RedisClient.KeyLike, persist: "PERSIST"): Promise<string | null>;
+
    /**
     *  Ping the server
     *  @returns Promise that resolves with "PONG" if the server is reachable, or throws an error if the server is not reachable
--- a/node_modules/bun-types/s3.d.ts
+++ b/node_modules/bun-types/s3.d.ts
@ -487,8 +487,8 @@ declare module "bun" {
     *       // Process text chunk by chunk
     *     }
     */
-    readonly readable: ReadableStream;
-    stream(): ReadableStream;
+    readonly readable: ReadableStream<Uint8Array<ArrayBuffer>>;
+    stream(): ReadableStream<Uint8Array<ArrayBuffer>>;

    /**
     * The name or path of the file in the bucket.
--- a/node_modules/bun-types/shell.d.ts
+++ b/node_modules/bun-types/shell.d.ts
@ -1,6 +1,4 @@
 declare module "bun" {
-  type ShellFunction = (input: Uint8Array) => Uint8Array;
-
  type ShellExpression =
    | { toString(): string }
    | Array<ShellExpression>
@ -213,7 +211,7 @@ declare module "bun" {
     * try {
     *   const result = await $`exit 1`;
     * } catch (error) {
-     *   if (error instanceof ShellError) {
+     *   if (error instanceof $.ShellError) {
     *     console.log(error.exitCode); // 1
     *   }
     * }
@ -294,7 +292,7 @@ declare module "bun" {
       * console.log(output.bytes()); // Uint8Array { byteLength: 6 }
       * ```
       */
-      bytes(): Uint8Array;
+      bytes(): Uint8Array<ArrayBuffer>;
    }

    interface ShellOutput {
@ -361,7 +359,7 @@ declare module "bun" {
       * console.log(output.bytes()); // Uint8Array { byteLength: 6 }
       * ```
       */
-      bytes(): Uint8Array;
+      bytes(): Uint8Array<ArrayBuffer>;

      /**
       * Read from stdout as a Blob
--- a/node_modules/bun-types/sqlite.d.ts
+++ b/node_modules/bun-types/sqlite.d.ts
@ -24,6 +24,66 @@
 * | `null`          | `NULL`                 |
 */
 declare module "bun:sqlite" {
+  /**
+   * Options for {@link Database}
+   */
+  export interface DatabaseOptions {
+    /**
+     * Open the database as read-only (no write operations, no create).
+     *
+     * Equivalent to {@link constants.SQLITE_OPEN_READONLY}
+     */
+    readonly?: boolean;
+
+    /**
+     * Allow creating a new database
+     *
+     * Equivalent to {@link constants.SQLITE_OPEN_CREATE}
+     */
+    create?: boolean;
+
+    /**
+     * Open the database as read-write
+     *
+     * Equivalent to {@link constants.SQLITE_OPEN_READWRITE}
+     */
+    readwrite?: boolean;
+
+    /**
+     * When set to `true`, integers are returned as `bigint` types.
+     *
+     * When set to `false`, integers are returned as `number` types and truncated to 52 bits.
+     *
+     * @default false
+     * @since v1.1.14
+     */
+    safeIntegers?: boolean;
+
+    /**
+     * When set to `false` or `undefined`:
+     * - Queries missing bound parameters will NOT throw an error
+     * - Bound named parameters in JavaScript need to exactly match the SQL query.
+     *
+     * @example
+     * ```ts
+     * const db = new Database(":memory:", { strict: false });
+     * db.run("INSERT INTO foo (name) VALUES ($name)", { $name: "foo" });
+     * ```
+     *
+     * When set to `true`:
+     * - Queries missing bound parameters will throw an error
+     * - Bound named parameters in JavaScript no longer need to be `$`, `:`, or `@`. The SQL query will remain prefixed.
+     *
+     * @example
+     * ```ts
+     * const db = new Database(":memory:", { strict: true });
+     * db.run("INSERT INTO foo (name) VALUES ($name)", { name: "foo" });
+     * ```
+     * @since v1.1.14
+     */
+    strict?: boolean;
+  }
+
  /**
   * A SQLite3 database
   *
@ -53,8 +113,6 @@ declare module "bun:sqlite" {
   * ```ts
   * const db = new Database("mydb.sqlite", {readonly: true});
   * ```
-   *
-   * @category Database
   */
  export class Database implements Disposable {
    /**
@ -63,96 +121,19 @@ declare module "bun:sqlite" {
     * @param filename The filename of the database to open. Pass an empty string (`""`) or `":memory:"` or undefined for an in-memory database.
     * @param options defaults to `{readwrite: true, create: true}`. If a number, then it's treated as `SQLITE_OPEN_*` constant flags.
     */
-    constructor(
-      filename?: string,
-      options?:
-        | number
-        | {
-            /**
-             * Open the database as read-only (no write operations, no create).
-             *
-             * Equivalent to {@link constants.SQLITE_OPEN_READONLY}
-             */
-            readonly?: boolean;
-            /**
-             * Allow creating a new database
-             *
-             * Equivalent to {@link constants.SQLITE_OPEN_CREATE}
-             */
-            create?: boolean;
-            /**
-             * Open the database as read-write
-             *
-             * Equivalent to {@link constants.SQLITE_OPEN_READWRITE}
-             */
-            readwrite?: boolean;
-
-            /**
-             * When set to `true`, integers are returned as `bigint` types.
-             *
-             * When set to `false`, integers are returned as `number` types and truncated to 52 bits.
-             *
-             * @default false
-             * @since v1.1.14
-             */
-            safeIntegers?: boolean;
-
-            /**
-             * When set to `false` or `undefined`:
-             * - Queries missing bound parameters will NOT throw an error
-             * - Bound named parameters in JavaScript need to exactly match the SQL query.
-             *
-             * @example
-             * ```ts
-             * const db = new Database(":memory:", { strict: false });
-             * db.run("INSERT INTO foo (name) VALUES ($name)", { $name: "foo" });
-             * ```
-             *
-             * When set to `true`:
-             * - Queries missing bound parameters will throw an error
-             * - Bound named parameters in JavaScript no longer need to be `$`, `:`, or `@`. The SQL query will remain prefixed.
-             *
-             * @example
-             * ```ts
-             * const db = new Database(":memory:", { strict: true });
-             * db.run("INSERT INTO foo (name) VALUES ($name)", { name: "foo" });
-             * ```
-             * @since v1.1.14
-             */
-            strict?: boolean;
-          },
-    );
+    constructor(filename?: string, options?: number | DatabaseOptions);

    /**
+     * Open or create a SQLite3 databases
+     *
+     * @param filename The filename of the database to open. Pass an empty string (`""`) or `":memory:"` or undefined for an in-memory database.
+     * @param options defaults to `{readwrite: true, create: true}`. If a number, then it's treated as `SQLITE_OPEN_*` constant flags.
+     *
     * This is an alias of `new Database()`
     *
     * See {@link Database}
     */
-    static open(
-      filename: string,
-      options?:
-        | number
-        | {
-            /**
-             * Open the database as read-only (no write operations, no create).
-             *
-             * Equivalent to {@link constants.SQLITE_OPEN_READONLY}
-             */
-            readonly?: boolean;
-            /**
-             * Allow creating a new database
-             *
-             * Equivalent to {@link constants.SQLITE_OPEN_CREATE}
-             */
-            create?: boolean;
-            /**
-             * Open the database as read-write
-             *
-             * Equivalent to {@link constants.SQLITE_OPEN_READWRITE}
-             */
-            readwrite?: boolean;
-          },
-    ): Database;
+    static open(filename: string, options?: number | DatabaseOptions): Database;

    /**
     * Execute a SQL query **without returning any results**.
@ -203,8 +184,11 @@ declare module "bun:sqlite" {
     * @returns `Database` instance
     */
    run<ParamsType extends SQLQueryBindings[]>(sql: string, ...bindings: ParamsType[]): Changes;
+
    /**
     * This is an alias of {@link Database.run}
+     *
+     * @deprecated Prefer {@link Database.run}
     */
    exec<ParamsType extends SQLQueryBindings[]>(sql: string, ...bindings: ParamsType[]): Changes;

@ -351,6 +335,16 @@ declare module "bun:sqlite" {
     */
    static setCustomSQLite(path: string): boolean;

+    /**
+     * Closes the database when using the async resource proposal
+     *
+     * @example
+     * ```
+     * using db = new Database("myapp.db");
+     * doSomethingWithDatabase(db);
+     * // Automatically closed when `db` goes out of scope
+     * ```
+     */
    [Symbol.dispose](): void;

    /**
@ -383,19 +377,28 @@ declare module "bun:sqlite" {
     * ]);
     * ```
     */
-    transaction(insideTransaction: (...args: any) => void): CallableFunction & {
+    transaction<A extends any[], T>(
+      insideTransaction: (...args: A) => T,
+    ): {
      /**
-       * uses "BEGIN DEFERRED"
+       * Execute the transaction
       */
-      deferred: (...args: any) => void;
+      (...args: A): T;
+
      /**
-       * uses "BEGIN IMMEDIATE"
+       * Execute the transaction using "BEGIN DEFERRED"
       */
-      immediate: (...args: any) => void;
+      deferred: (...args: A) => T;
+
      /**
-       * uses "BEGIN EXCLUSIVE"
+       * Execute the transaction using "BEGIN IMMEDIATE"
       */
-      exclusive: (...args: any) => void;
+      immediate: (...args: A) => T;
+
+      /**
+       * Execute the transaction using "BEGIN EXCLUSIVE"
+       */
+      exclusive: (...args: A) => T;
    };

    /**
@ -664,7 +667,7 @@ declare module "bun:sqlite" {
    [Symbol.iterator](): IterableIterator<ReturnType>;

    /**
-     * Execute the prepared statement. This returns `undefined`.
+     * Execute the prepared statement.
     *
     * @param params optional values to bind to the statement. If omitted, the statement is run with the last bound values or no parameters if there are none.
     *
@ -735,6 +738,30 @@ declare module "bun:sqlite" {
     */
    values(...params: ParamsType): Array<Array<string | bigint | number | boolean | Uint8Array>>;

+    /**
+     * Execute the prepared statement and return all results as arrays of
+     * `Uint8Array`s.
+     *
+     * This is similar to `values()` but returns all values as Uint8Array
+     * objects, regardless of their original SQLite type.
+     *
+     * @param params optional values to bind to the statement. If omitted, the
+     * statement is run with the last bound values or no parameters if there are
+     * none.
+     *
+     * @example
+     * ```ts
+     * const stmt = db.prepare("SELECT * FROM foo WHERE bar = ?");
+     *
+     * stmt.raw("baz");
+     * // => [[Uint8Array(24)]]
+     *
+     * stmt.raw();
+     * // => [[Uint8Array(24)]]
+     * ```
+     */
+    raw(...params: ParamsType): Array<Array<Uint8Array | null>>;
+
    /**
     * The names of the columns returned by the prepared statement.
     * @example
--- a/node_modules/bun-types/test-globals.d.ts
+++ b/node_modules/bun-types/test-globals.d.ts
@ -10,6 +10,7 @@ declare var test: typeof import("bun:test").test;
 declare var it: typeof import("bun:test").it;
 declare var describe: typeof import("bun:test").describe;
 declare var expect: typeof import("bun:test").expect;
+declare var expectTypeOf: typeof import("bun:test").expectTypeOf;
 declare var beforeAll: typeof import("bun:test").beforeAll;
 declare var beforeEach: typeof import("bun:test").beforeEach;
 declare var afterEach: typeof import("bun:test").afterEach;
--- a/node_modules/bun-types/test.d.ts
+++ b/node_modules/bun-types/test.d.ts
@ -56,6 +56,11 @@ declare module "bun:test" {
     * Restore the previous value of mocks.
     */
    restore(): void;
+
+    /**
+     * Reset all mock function state (calls, results, etc.) without restoring their original implementation.
+     */
+    clearAllMocks(): void;
  };

  /**
@ -1642,6 +1647,26 @@ declare module "bun:test" {
     */
    toHaveReturnedTimes(times: number): void;

+    /**
+     * Ensures that a mock function has returned a specific value.
+     * This matcher uses deep equality, like toEqual(), and supports asymmetric matchers.
+     */
+    toHaveReturnedWith(expected: unknown): void;
+
+    /**
+     * Ensures that a mock function has returned a specific value on its last invocation.
+     * This matcher uses deep equality, like toEqual(), and supports asymmetric matchers.
+     */
+    toHaveLastReturnedWith(expected: unknown): void;
+
+    /**
+     * Ensures that a mock function has returned a specific value on the nth invocation.
+     * This matcher uses deep equality, like toEqual(), and supports asymmetric matchers.
+     * @param n The 1-based index of the function call
+     * @param expected The expected return value
+     */
+    toHaveNthReturnedWith(n: number, expected: unknown): void;
+
    /**
     * Ensures that a mock function is called.
     */
@ -2182,4 +2207,6 @@ declare module "bun:test" {

    export type UnknownFunction = (...args: unknown[]) => unknown;
  }
+
+  export const expectTypeOf: typeof import("./vendor/expect-type").expectTypeOf;
 }