bun-types 1.3.2-canary.20251105T140650 → 1.3.2

package/docs/{api/cc.md → runtime/c-compiler.mdx}

@@ -1,12 +1,19 @@
+---
+title: C Compiler
+description: Compile and run C from JavaScript with low overhead
+---
+
 `bun:ffi` has experimental support for compiling and running C from JavaScript with low overhead.
 
+---
+
 ## Usage (cc in `bun:ffi`)
 
 See the [introduction blog post](https://bun.com/blog/compile-and-run-c-in-js) for more information.
 
 JavaScript:
 
-```ts#hello.js
+```ts hello.js icon="file-code"
 import { cc } from "bun:ffi";
 import source from "./hello.c" with { type: "file" };
 
@@ -27,7 +34,7 @@ console.log("What is the answer to the universe?", hello());
 
 C source:
 
-```c#hello.c
+```c hello.c
 int hello() {
   return 42;
 }
@@ -35,8 +42,8 @@ int hello() {
 
 When you run `hello.js`, it will print:
 
-```sh
-$ bun hello.js
+```sh terminal icon="terminal"
+bun hello.js
 What is the answer to the universe? 42
 ```
 
@@ -44,7 +51,7 @@ Under the hood, `cc` uses [TinyCC](https://bellard.org/tcc/) to compile the C co
 
 ### Primitive types
 
-The same `FFIType` values in [`dlopen`](/docs/api/ffi) are supported in `cc`.
+The same `FFIType` values in [`dlopen`](/runtime/ffi) are supported in `cc`.
 
 | `FFIType`  | C Type         | Aliases                     |
 | ---------- | -------------- | --------------------------- |
@@ -80,7 +87,7 @@ You can also pass a `napi_env` to receive the N-API environment used to call the
 
 For example, if you have a string in C, you can return it to JavaScript like this:
 
-```ts#hello.js
+```ts hello.js
 import { cc } from "bun:ffi";
 import source from "./hello.c" with { type: "file" };
 
@@ -101,7 +108,7 @@ const result = hello();
 
 And in C:
 
-```c#hello.c
+```c hello.c
 #include <node/node_api.h>
 
 napi_value hello(napi_env env) {
@@ -113,7 +120,7 @@ napi_value hello(napi_env env) {
 
 You can also use this to return other types like objects and arrays:
 
-```c#hello.c
+```c hello.c
 #include <node/node_api.h>
 
 napi_value hello(napi_env env) {
@@ -189,7 +196,7 @@ type Defines = Record<string, string>;
 cc({
   source: "hello.c",
   define: {
-    "NDEBUG": "1",
+    NDEBUG: "1",
   },
 });
 ```

package/docs/{api/spawn.md → runtime/child-process.mdx}

@@ -1,4 +1,7 @@
-Spawn child processes with `Bun.spawn` or `Bun.spawnSync`.
+---
+title: Spawn
+description: Spawn child processes with `Bun.spawn` or `Bun.spawnSync`
+---
 
 ## Spawn a process (`Bun.spawn()`)
 
@@ -29,68 +32,25 @@ By default, the input stream of the subprocess is undefined; it can be configure
 
 ```ts
 const proc = Bun.spawn(["cat"], {
-  stdin: await fetch(
-    "https://raw.githubusercontent.com/oven-sh/bun/main/examples/hashing.js",
-  ),
+  stdin: await fetch("https://raw.githubusercontent.com/oven-sh/bun/main/examples/hashing.js"),
 });
 
 const text = await proc.stdout.text();
 console.log(text); // "const input = "hello world".repeat(400); ..."
 ```
 
-{% table %}
-
----
-
-- `null`
-- **Default.** Provide no input to the subprocess
-
----
-
-- `"pipe"`
-- Return a `FileSink` for fast incremental writing
-
----
-
-- `"inherit"`
-- Inherit the `stdin` of the parent process
-
----
-
-- `Bun.file()`
-- Read from the specified file.
-
----
-
-- `TypedArray | DataView`
-- Use a binary buffer as input.
-
----
-
-- `Response`
-- Use the response `body` as input.
-
----
-
-- `Request`
-- Use the request `body` as input.
-
----
-
-- `ReadableStream`
-- Use a readable stream as input.
-
----
-
-- `Blob`
-- Use a blob as input.
-
----
-
-- `number`
-- Read from the file with a given file descriptor.
-
-{% /table %}
+| Value                    | Description                                      |
+| ------------------------ | ------------------------------------------------ |
+| `null`                   | **Default.** Provide no input to the subprocess  |
+| `"pipe"`                 | Return a `FileSink` for fast incremental writing |
+| `"inherit"`              | Inherit the `stdin` of the parent process        |
+| `Bun.file()`             | Read from the specified file                     |
+| `TypedArray \| DataView` | Use a binary buffer as input                     |
+| `Response`               | Use the response `body` as input                 |
+| `Request`                | Use the request `body` as input                  |
+| `ReadableStream`         | Use a readable stream as input                   |
+| `Blob`                   | Use a blob as input                              |
+| `number`                 | Read from the file with a given file descriptor  |
 
 The `"pipe"` option lets incrementally write to the subprocess's input stream from the parent process.
 
@@ -129,7 +89,7 @@ const proc = Bun.spawn(["cat"], {
   stdout: "pipe",
 });
 
-const output = await new Response(proc.stdout).text();
+const output = await proc.stdout.text();
 console.log(output); // "Hello from ReadableStream!"
 ```
 
@@ -140,45 +100,24 @@ 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.3.2-canary.20251105T140650\n"
+console.log(text); // => "1.3.1\n"
 ```
 
 Configure the output stream by passing one of the following values to `stdout/stderr`:
 
-{% table %}
-
----
-
-- `"pipe"`
-- **Default for `stdout`.** Pipe the output to a `ReadableStream` on the returned `Subprocess` object.
-
----
-
-- `"inherit"`
-- **Default for `stderr`.** Inherit from the parent process.
-
----
-
-- `"ignore"`
-- Discard the output.
-
----
-
-- `Bun.file()`
-- Write to the specified file.
-
----
-
-- `number`
-- Write to the file with the given file descriptor.
-
-{% /table %}
+| Value        | Description                                                                                         |
+| ------------ | --------------------------------------------------------------------------------------------------- |
+| `"pipe"`     | **Default for `stdout`.** Pipe the output to a `ReadableStream` on the returned `Subprocess` object |
+| `"inherit"`  | **Default for `stderr`.** Inherit from the parent process                                           |
+| `"ignore"`   | Discard the output                                                                                  |
+| `Bun.file()` | Write to the specified file                                                                         |
+| `number`     | Write to the file with the given file descriptor                                                    |
 
 ## Exit handling
 
 Use the `onExit` callback to listen for the process exiting or being killed.
 
-```ts
+```ts index.ts icon="/icons/typescript.svg"
 const proc = Bun.spawn(["bun", "--version"], {
   onExit(proc, exitCode, signalCode, error) {
     // exit handler
@@ -188,7 +127,7 @@ const proc = Bun.spawn(["bun", "--version"], {
 
 For convenience, the `exited` property is a `Promise` that resolves when the process exits.
 
-```ts
+```ts index.ts icon="/icons/typescript.svg"
 const proc = Bun.spawn(["bun", "--version"]);
 
 await proc.exited; // resolves when process exit
@@ -199,7 +138,7 @@ proc.signalCode; // null | "SIGABRT" | "SIGALRM" | ...
 
 To kill a process:
 
-```ts
+```ts index.ts icon="/icons/typescript.svg"
 const proc = Bun.spawn(["bun", "--version"]);
 proc.kill();
 proc.killed; // true
@@ -210,7 +149,7 @@ proc.kill("SIGTERM"); // specify a signal name
 
 The parent `bun` process will not terminate until all child processes have exited. Use `proc.unref()` to detach the child process from the parent.
 
-```ts
+```ts index.ts icon="/icons/typescript.svg"
 const proc = Bun.spawn(["bun", "--version"]);
 proc.unref();
 ```
@@ -219,7 +158,7 @@ proc.unref();
 
 You can get information about the process's resource usage after it has exited:
 
-```ts
+```ts index.ts icon="/icons/typescript.svg"
 const proc = Bun.spawn(["bun", "--version"]);
 await proc.exited;
 
@@ -233,7 +172,7 @@ console.log(`CPU time (system): ${usage.cpuTime.system} µs`);
 
 You can abort a subprocess using an `AbortSignal`:
 
-```ts
+```ts index.ts icon="/icons/typescript.svg"
 const controller = new AbortController();
 const { signal } = controller;
 
@@ -250,7 +189,7 @@ controller.abort();
 
 You can set a timeout for a subprocess to automatically terminate after a specific duration:
 
-```ts
+```ts index.ts icon="/icons/typescript.svg"
 // Kill the process after 5 seconds
 const proc = Bun.spawn({
   cmd: ["sleep", "10"],
@@ -262,7 +201,7 @@ await proc.exited; // Will resolve after 5 seconds
 
 By default, timed-out processes are killed with the `SIGTERM` signal. You can specify a different signal with the `killSignal` option:
 
-```ts
+```ts index.ts icon="/icons/typescript.svg"
 // Kill the process with SIGKILL after 5 seconds
 const proc = Bun.spawn({
   cmd: ["sleep", "10"],
@@ -277,10 +216,10 @@ The `killSignal` option also controls which signal is sent when an AbortSignal i
 
 For spawnSync, you can limit the maximum number of bytes of output before the process is killed:
 
-```ts
-// KIll 'yes' after it emits over 100 bytes of output
+```ts index.ts icon="/icons/typescript.svg"
+// Kill 'yes' after it emits over 100 bytes of output
 const result = Bun.spawnSync({
-  cmd: ["yes"], // or ["bun", "exec", "yes"] on windows
+  cmd: ["yes"], // or ["bun", "exec", "yes"] on Windows
   maxBuffer: 100,
 });
 // process exits
@@ -290,7 +229,7 @@ const result = Bun.spawnSync({
 
 Bun supports direct inter-process communication channel between two `bun` processes. To receive messages from a spawned Bun subprocess, specify an `ipc` handler.
 
-```ts#parent.ts
+```ts parent.ts icon="/icons/typescript.svg"
 const child = Bun.spawn(["bun", "child.ts"], {
   ipc(message) {
     /**
@@ -302,13 +241,13 @@ const child = Bun.spawn(["bun", "child.ts"], {
 
 The parent process can send messages to the subprocess using the `.send()` method on the returned `Subprocess` instance. A reference to the sending subprocess is also available as the second argument in the `ipc` handler.
 
-```ts#parent.ts
+```ts parent.ts icon="/icons/typescript.svg"
 const childProc = Bun.spawn(["bun", "child.ts"], {
   ipc(message, childProc) {
     /**
      * The message received from the sub process
      **/
-    childProc.send("Respond to child")
+    childProc.send("Respond to child");
   },
 });
 
@@ -317,17 +256,17 @@ childProc.send("I am your father"); // The parent can send messages to the child
 
 Meanwhile the child process can send messages to its parent using with `process.send()` and receive messages with `process.on("message")`. This is the same API used for `child_process.fork()` in Node.js.
 
-```ts#child.ts
+```ts child.ts
 process.send("Hello from child as string");
 process.send({ message: "Hello from child as object" });
 
-process.on("message", (message) => {
+process.on("message", message => {
   // print message from parent
   console.log(message);
 });
 ```
 
-```ts#child.ts
+```ts child.ts
 // send a string
 process.send("Hello from child as string");
 
@@ -350,7 +289,7 @@ childProc.disconnect();
 
 To use IPC between a `bun` process and a Node.js process, set `serialization: "json"` in `Bun.spawn`. This is because Node.js and Bun use different JavaScript engines with different object serialization formats.
 
-```js#bun-node-ipc.js
+```ts bun-node-ipc.js icon="file-code"
 if (typeof Bun !== "undefined") {
   const prefix = `[bun ${process.versions.bun} 🐇]`;
   const node = Bun.spawn({
@@ -374,6 +313,8 @@ if (typeof Bun !== "undefined") {
 }
 ```
 
+---
+
 ## Blocking API (`Bun.spawnSync()`)
 
 Bun provides a synchronous equivalent of `Bun.spawn` called `Bun.spawnSync`. This is a blocking API that supports the same inputs and parameters as `Bun.spawn`. It returns a `SyncSubprocess` object, which differs from `Subprocess` in a few ways.
@@ -391,23 +332,35 @@ console.log(proc.stdout.toString());
 
 As a rule of thumb, the asynchronous `Bun.spawn` API is better for HTTP servers and apps, and `Bun.spawnSync` is better for building command-line tools.
 
+---
+
 ## Benchmarks
 
-{%callout%}
-⚡️ Under the hood, `Bun.spawn` and `Bun.spawnSync` use [`posix_spawn(3)`](https://man7.org/linux/man-pages/man3/posix_spawn.3.html).
-{%/callout%}
+<Note>
+  ⚡️ Under the hood, `Bun.spawn` and `Bun.spawnSync` use
+  [`posix_spawn(3)`](https://man7.org/linux/man-pages/man3/posix_spawn.3.html).
+</Note>
 
 Bun's `spawnSync` spawns processes 60% faster than the Node.js `child_process` module.
 
-```bash
-$ bun spawn.mjs
+```bash terminal icon="terminal"
+bun spawn.mjs
+```
+
+```txt
 cpu: Apple M1 Max
 runtime: bun 1.x (arm64-darwin)
 
 benchmark              time (avg)             (min … max)       p75       p99      p995
 --------------------------------------------------------- -----------------------------
 spawnSync echo hi  888.14 µs/iter    (821.83 µs … 1.2 ms) 905.92 µs      1 ms   1.03 ms
-$ node spawn.node.mjs
+```
+
+```sh terminal icon="terminal"
+node spawn.node.mjs
+```
+
+```txt
 cpu: Apple M1 Max
 runtime: node v18.9.1 (arm64-darwin)
 
@@ -416,22 +369,19 @@ benchmark              time (avg)             (min … max)       p75       p99
 spawnSync echo hi    1.47 ms/iter     (1.14 ms … 2.64 ms)   1.57 ms   2.37 ms   2.52 ms
 ```
 
+---
+
 ## Reference
 
 A reference of the Spawn API and types are shown below. The real types have complex generics to strongly type the `Subprocess` streams with the options passed to `Bun.spawn` and `Bun.spawnSync`. For full details, find these types as defined [bun.d.ts](https://github.com/oven-sh/bun/blob/main/packages/bun-types/bun.d.ts).
 
-```ts
+```ts See Typescript Definitions expandable
 interface Bun {
   spawn(command: string[], options?: SpawnOptions.OptionsObject): Subprocess;
-  spawnSync(
-    command: string[],
-    options?: SpawnOptions.OptionsObject,
-  ): SyncSubprocess;
+  spawnSync(command: string[], options?: SpawnOptions.OptionsObject): SyncSubprocess;
 
   spawn(options: { cmd: string[] } & SpawnOptions.OptionsObject): Subprocess;
-  spawnSync(
-    options: { cmd: string[] } & SpawnOptions.OptionsObject,
-  ): SyncSubprocess;
+  spawnSync(options: { cmd: string[] } & SpawnOptions.OptionsObject): SyncSubprocess;
 }
 
 namespace SpawnOptions {

package/docs/{api/color.md → runtime/color.mdx}

@@ -1,3 +1,8 @@
+---
+title: Color
+description: Format colors as CSS, ANSI, numbers, hex strings, and more
+---
+
 `Bun.color(input, outputFormat?)` leverages Bun's CSS parser to parse, normalize, and convert colors from user input to a variety of output formats, including:
 
 | Format       | Example                          |
@@ -242,7 +247,7 @@ Bun.color([255, 0, 0], "HEX"); // "#FF0000"
 
 Like many of Bun's APIs, you can use macros to invoke `Bun.color` at bundle-time for use in client-side JavaScript builds:
 
-```ts#client-side.ts
+```ts client-side.ts
 import { color } from "bun" with { type: "macro" };
 
 console.log(color("#f00", "css"));

package/docs/{api/console.md → runtime/console.mdx}

@@ -1,6 +1,14 @@
-{% callout %}
-**Note** — Bun provides a browser- and Node.js-compatible [console](https://developer.mozilla.org/en-US/docs/Web/API/console) global. This page only documents Bun-native APIs.
-{% /callout %}
+---
+title: Console
+description: The console object in Bun
+---
+
+<Note>
+  Bun provides a browser- and Node.js-compatible [console](https://developer.mozilla.org/en-US/docs/Web/API/console)
+  global. This page only documents Bun-native APIs.
+</Note>
+
+---
 
 ## Object inspection depth
 
@@ -19,11 +27,13 @@ console.log(nested);
 
 The CLI flag takes precedence over the configuration file setting.
 
+---
+
 ## Reading from stdin
 
 In Bun, the `console` object can be used as an `AsyncIterable` to sequentially read lines from `process.stdin`.
 
-```ts
+```ts adder.ts icon="/icons/typescript.svg"
 for await (const line of console) {
   console.log(line);
 }
@@ -31,7 +41,7 @@ for await (const line of console) {
 
 This is useful for implementing interactive programs, like the following addition calculator.
 
-```ts#adder.ts
+```ts adder.ts icon="/icons/typescript.svg"
 console.log(`Let's add some numbers!`);
 console.write(`Count: 0\n> `);
 
@@ -44,8 +54,8 @@ for await (const line of console) {
 
 To run the file:
 
-```bash
-$ bun adder.ts
+```bash terminal icon="terminal"
+bun adder.ts
 Let's add some numbers!
 Count: 0
 > 5

package/docs/{api/cookie.md → runtime/cookies.mdx}

@@ -1,10 +1,15 @@
+---
+title: Cookies
+description: Use Bun's native APIs for working with HTTP cookies
+---
+
 Bun provides native APIs for working with HTTP cookies through `Bun.Cookie` and `Bun.CookieMap`. These APIs offer fast, easy-to-use methods for parsing, generating, and manipulating cookies in HTTP requests and responses.
 
 ## CookieMap class
 
 `Bun.CookieMap` provides a Map-like interface for working with collections of cookies. It implements the `Iterable` interface, allowing you to use it with `for...of` loops and other iteration methods.
 
-```ts
+```ts filename="cookies.ts" icon="/icons/typescript.svg"
 // Empty cookie map
 const cookies = new Bun.CookieMap();
 
@@ -28,7 +33,7 @@ const cookies3 = new Bun.CookieMap([
 
 In Bun's HTTP server, the `cookies` property on the request object (in `routes`) is an instance of `CookieMap`:
 
-```ts
+```ts filename="server.ts" icon="/icons/typescript.svg"
 const server = Bun.serve({
   routes: {
     "/": req => {
@@ -63,7 +68,7 @@ console.log("Server listening at: " + server.url);
 
 Retrieves a cookie by name. Returns `null` if the cookie doesn't exist.
 
-```ts
+```ts filename="get-cookie.ts" icon="/icons/typescript.svg"
 // Get by name
 const cookie = cookies.get("session");
 
@@ -76,7 +81,7 @@ if (cookie != null) {
 
 Checks if a cookie with the given name exists.
 
-```ts
+```ts filename="has-cookie.ts" icon="/icons/typescript.svg"
 // Check if cookie exists
 if (cookies.has("session")) {
   // Cookie exists
@@ -91,7 +96,7 @@ if (cookies.has("session")) {
 
 Adds or updates a cookie in the map. Cookies default to `{ path: "/", sameSite: "lax" }`.
 
-```ts
+```ts filename="set-cookie.ts" icon="/icons/typescript.svg"
 // Set by name and value
 cookies.set("session", "abc123");
 
@@ -114,7 +119,7 @@ cookies.set(cookie);
 
 Removes a cookie from the map. When applied to a Response, this adds a cookie with an empty string value and an expiry date in the past. A cookie will only delete successfully on the browser if the domain and path is the same as it was when the cookie was created.
 
-```ts
+```ts filename="delete-cookie.ts" icon="/icons/typescript.svg"
 // Delete by name using default domain and path.
 cookies.delete("session");
 
@@ -130,7 +135,7 @@ cookies.delete({
 
 Converts the cookie map to a serializable format.
 
-```ts
+```ts filename="cookie-to-json.ts" icon="/icons/typescript.svg"
 const json = cookies.toJSON();
 ```
 
@@ -140,7 +145,7 @@ Returns an array of values for Set-Cookie headers that can be used to apply all
 
 When using `Bun.serve()`, you don't need to call this method explicitly. Any changes made to the `req.cookies` map are automatically applied to the response headers. This method is primarily useful when working with other HTTP server implementations.
 
-```js
+```ts filename="node-server.js" icon="file-code"
 import { createServer } from "node:http";
 import { CookieMap } from "bun";
 
@@ -167,7 +172,7 @@ server.listen(3000, () => {
 
 `CookieMap` provides several methods for iteration:
 
-```ts
+```ts filename="iterate-cookies.ts" icon="/icons/typescript.svg"
 // Iterate over [name, cookie] entries
 for (const [name, value] of cookies) {
   console.log(`${name}: ${value}`);
@@ -200,7 +205,7 @@ cookies.forEach((value, name) => {
 
 Returns the number of cookies in the map.
 
-```ts
+```ts filename="cookie-size.ts" icon="/icons/typescript.svg"
 console.log(cookies.size); // Number of cookies
 ```
 
@@ -208,7 +213,7 @@ console.log(cookies.size); // Number of cookies
 
 `Bun.Cookie` represents an HTTP cookie with its name, value, and attributes.
 
-```ts
+```ts filename="cookie-class.ts" icon="/icons/typescript.svg"
 import { Cookie } from "bun";
 
 // Create a basic cookie
@@ -238,7 +243,7 @@ const objCookie = new Bun.Cookie({
 
 ### Constructors
 
-```ts
+```ts filename="constructors.ts" icon="/icons/typescript.svg"
 // Basic constructor with name/value
 new Bun.Cookie(name: string, value: string);
 
@@ -254,7 +259,7 @@ new Bun.Cookie(options: CookieInit);
 
 ### Properties
 
-```ts
+```ts filename="cookie-properties.ts" icon="/icons/typescript.svg"
 cookie.name; // string - Cookie name
 cookie.value; // string - Cookie value
 cookie.domain; // string | null - Domain scope (null if not specified)
@@ -273,7 +278,7 @@ cookie.httpOnly; // boolean - Accessible only via HTTP (not JavaScript)
 
 Checks if the cookie has expired.
 
-```ts
+```ts filename="is-expired.ts" icon="/icons/typescript.svg"
 // Expired cookie (Date in the past)
 const expiredCookie = new Bun.Cookie("name", "value", {
   expires: new Date(Date.now() - 1000),
@@ -297,7 +302,7 @@ console.log(sessionCookie.isExpired()); // false
 
 Returns a string representation of the cookie suitable for a `Set-Cookie` header.
 
-```ts
+```ts filename="serialize-cookie.ts" icon="/icons/typescript.svg"
 const cookie = new Bun.Cookie("session", "abc123", {
   domain: "example.com",
   path: "/admin",
@@ -317,7 +322,7 @@ console.log(cookie.toString());
 
 Converts the cookie to a plain object suitable for JSON serialization.
 
-```ts
+```ts filename="cookie-json.ts" icon="/icons/typescript.svg"
 const cookie = new Bun.Cookie("session", "abc123", {
   secure: true,
   httpOnly: true,
@@ -344,7 +349,7 @@ const jsonString = JSON.stringify(cookie);
 
 Parses a cookie string into a `Cookie` instance.
 
-```ts
+```ts filename="parse-cookie.ts" icon="/icons/typescript.svg"
 const cookie = Bun.Cookie.parse("name=value; Path=/; Secure; SameSite=Lax");
 
 console.log(cookie.name); // "name"
@@ -358,7 +363,7 @@ console.log(cookie.sameSite); // "lax"
 
 Factory method to create a cookie.
 
-```ts
+```ts filename="cookie-from.ts" icon="/icons/typescript.svg"
 const cookie = Bun.Cookie.from("session", "abc123", {
   httpOnly: true,
   secure: true,
@@ -368,7 +373,7 @@ const cookie = Bun.Cookie.from("session", "abc123", {
 
 ## Types
 
-```ts
+```ts filename="types.ts" icon="/icons/typescript.svg"
 interface CookieInit {
   name?: string;
   value?: string;