bun-types 1.3.2-canary.20251105T140650 → 1.3.2

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

@@ -1,10 +1,19 @@
+---
+title: Streams
+description: Use Bun's streams API to work with binary data without loading it all into memory at once
+---
+
 Streams are an important abstraction for working with binary data without loading it all into memory at once. They are commonly used for reading and writing files, sending and receiving network requests, and processing large amounts of data.
 
 Bun implements the Web APIs [`ReadableStream`](https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream) and [`WritableStream`](https://developer.mozilla.org/en-US/docs/Web/API/WritableStream).
 
-{% callout %}
-Bun also implements the `node:stream` module, including [`Readable`](https://nodejs.org/api/stream.html#stream_readable_streams), [`Writable`](https://nodejs.org/api/stream.html#stream_writable_streams), and [`Duplex`](https://nodejs.org/api/stream.html#stream_duplex_and_transform_streams). For complete documentation, refer to the [Node.js docs](https://nodejs.org/api/stream.html).
-{% /callout %}
+<Note>
+  Bun also implements the `node:stream` module, including
+  [`Readable`](https://nodejs.org/api/stream.html#stream_readable_streams),
+  [`Writable`](https://nodejs.org/api/stream.html#stream_writable_streams), and
+  [`Duplex`](https://nodejs.org/api/stream.html#stream_duplex_and_transform_streams). For complete documentation, refer
+  to the [Node.js docs](https://nodejs.org/api/stream.html).
+</Note>
 
 To create a simple `ReadableStream`:
 
@@ -23,28 +32,19 @@ The contents of a `ReadableStream` can be read chunk-by-chunk with `for await` s
 ```ts
 for await (const chunk of stream) {
   console.log(chunk);
-  // => "hello"
-  // => "world"
 }
-```
-
-`ReadableStream` also provides convenience methods for consuming the entire stream:
-
-```ts
-const stream = new ReadableStream({
-  start(controller) {
-    controller.enqueue("hello world");
-    controller.close();
-  },
-});
 
-const data = await stream.text(); // => "hello world"
-// Also available: .json(), .bytes(), .blob()
+// hello
+// world
 ```
 
+---
+
 ## Direct `ReadableStream`
 
-Bun implements an optimized version of `ReadableStream` that avoid unnecessary data copying & queue management logic. With a traditional `ReadableStream`, chunks of data are _enqueued_. Each chunk is copied into a queue, where it sits until the stream is ready to send more data.
+Bun implements an optimized version of `ReadableStream` that avoid unnecessary data copying & queue management logic.
+
+With a traditional `ReadableStream`, chunks of data are _enqueued_. Each chunk is copied into a queue, where it sits until the stream is ready to send more data.
 
 ```ts
 const stream = new ReadableStream({
@@ -60,7 +60,7 @@ With a direct `ReadableStream`, chunks of data are written directly to the strea
 
 ```ts
 const stream = new ReadableStream({
-  type: "direct",
+  type: "direct", // [!code ++]
   pull(controller) {
     controller.write("hello");
     controller.write("world");
@@ -70,6 +70,8 @@ const stream = new ReadableStream({
 
 When using a direct `ReadableStream`, all chunk queueing is handled by the destination. The consumer of the stream receives exactly what is passed to `controller.write()`, without any encoding or modification.
 
+---
+
 ## Async generator streams
 
 Bun also supports async generator functions as a source for `Response` and `Request`. This is an easy way to create a `ReadableStream` that fetches data from an asynchronous source.
@@ -111,6 +113,8 @@ const response = new Response({
 await response.text(); // "hello"
 ```
 
+---
+
 ## `Bun.ArrayBufferSink`
 
 The `Bun.ArrayBufferSink` class is a fast incremental writer for constructing an `ArrayBuffer` of unknown size.
@@ -130,10 +134,10 @@ sink.end();
 
 To instead retrieve the data as a `Uint8Array`, pass the `asUint8Array` option to the `start` method.
 
-```ts-diff
+```ts
 const sink = new Bun.ArrayBufferSink();
 sink.start({
-+ asUint8Array: true
+  asUint8Array: true, // [!code ++]
 });
 
 sink.write("h");
@@ -161,7 +165,7 @@ Once `.end()` is called, no more data can be written to the `ArrayBufferSink`. H
 ```ts
 const sink = new Bun.ArrayBufferSink();
 sink.start({
-  stream: true,
+  stream: true, // [!code ++]
 });
 
 sink.write("h");
@@ -183,13 +187,15 @@ To manually set the size of the internal buffer in bytes, pass a value for `high
 ```ts
 const sink = new Bun.ArrayBufferSink();
 sink.start({
-  highWaterMark: 1024 * 1024, // 1 MB
+  highWaterMark: 1024 * 1024, // 1 MB  // [!code ++]
 });
 ```
 
-{% details summary="Reference" %}
+---
 
-```ts
+## Reference
+
+```ts See Typescript Definitions expandable
 /**
  * Fast incremental writer that becomes an `ArrayBuffer` on end().
  */
@@ -210,9 +216,7 @@ export class ArrayBufferSink {
     stream?: boolean;
   }): void;
 
-  write(
-    chunk: string | ArrayBufferView | ArrayBuffer | SharedArrayBuffer,
-  ): number;
+  write(chunk: string | ArrayBufferView | ArrayBuffer | SharedArrayBuffer): number;
   /**
    * Flush the internal buffer
    *
@@ -226,5 +230,3 @@ export class ArrayBufferSink {
   end(): ArrayBuffer | Uint8Array<ArrayBuffer>;
 }
 ```
-
-{% /details %}

package/docs/{cli/bun-create.md → runtime/templating/create.mdx}

@@ -1,6 +1,14 @@
-{% callout %}
-**Note** — You don’t need `bun create` to use Bun. You don’t need any configuration at all. This command exists to make getting started a bit quicker and easier.
-{% /callout %}
+---
+title: bun create
+description: Create a new Bun project from a React component, a `create-<template>` npm package, a GitHub repo, or a local template
+---
+
+<Note>
+  You don't need `bun create` to use Bun. You don't need any configuration at all. This command exists to make getting
+  started a bit quicker and easier.
+</Note>
+
+---
 
 Template a new Bun project with `bun create`. This is a flexible command that can be used to create a new project from a React component, a `create-<template>` npm package, a GitHub repo, or a local template.
 
@@ -14,17 +22,25 @@ If you're looking to create a brand new empty project, use [`bun init`](https://
 $ bun create ./MyComponent.jsx # .tsx also supported
 ```
 
-{% raw %}
-
-<video style="aspect-ratio: 2062 / 1344; width: 100%; height: 100%; object-fit: contain;"  loop autoplay muted playsinline>
-  <source src="/bun-create-shadcn.mp4" style="width: 100%; height: 100%; object-fit: contain;" type="video/mp4">
-</video>
-
-{% /raw %}
-
-{% callout %}
+<Frame>
+  <video
+    style={{ aspectRatio: "2062 / 1344", width: "100%", height: "100%", objectFit: "contain" }}
+    loop
+    autoPlay
+    muted
+    playsInline
+  >
+    <source
+      src="/images/bun-create-shadcn.mp4"
+      style={{ width: "100%", height: "100%", objectFit: "contain" }}
+      type="video/mp4"
+    />
+  </video>
+</Frame>
+
+<Note>
 🚀 **Create React App Successor** — `bun create <component>` provides everything developers loved about Create React App, but with modern tooling, faster builds, and backend support.
-{% /callout %}
+</Note>
 
 #### How this works
 
@@ -47,7 +63,7 @@ When you run `bun create <component>`, Bun:
 
 When you run `bun create <component>`, Bun scans your JSX/TSX file for TailwindCSS class names (and any files it imports). If it detects TailwindCSS class names, it will add the following dependencies to your `package.json`:
 
-```json#package.json
+```json package.json icon="file-code"
 {
   "dependencies": {
     "tailwindcss": "^4",
@@ -58,14 +74,14 @@ When you run `bun create <component>`, Bun scans your JSX/TSX file for TailwindC
 
 We also configure `bunfig.toml` to use Bun's TailwindCSS plugin with `Bun.serve()`
 
-```toml#bunfig.toml
+```toml bunfig.toml icon="settings"
 [serve.static]
 plugins = ["bun-plugin-tailwind"]
 ```
 
 And a `${component}.css` file with `@import "tailwindcss";` at the top:
 
-```css#MyComponent.css
+```css MyComponent.css icon="file-code"
 @import "tailwindcss";
 ```
 
@@ -77,9 +93,9 @@ And a `${component}.css` file with `@import "tailwindcss";` at the top:
 
 If it finds any, it runs:
 
-```bash
+```bash terminal icon="terminal"
 # Assuming bun detected imports to @/components/ui/accordion and @/components/ui/button
-$ bunx shadcn@canary add accordion button # and any other components
+bunx shadcn@canary add accordion button # and any other components
 ```
 
 Since `shadcn/ui` itself uses TailwindCSS, `bun create` also adds the necessary TailwindCSS dependencies to your `package.json` and configures `bunfig.toml` to use Bun's TailwindCSS plugin with `Bun.serve()` as described above.
@@ -95,15 +111,15 @@ Additionally, we setup the following:
 
 ## From `npm`
 
-```sh
-$ bun create <template> [<destination>]
+```sh terminal icon="terminal"
+bun create <template> [<destination>]
 ```
 
 Assuming you don't have a [local template](#from-a-local-template) with the same name, this command will download and execute the `create-<template>` package from npm. The following two commands will behave identically:
 
-```sh
-$ bun create remix
-$ bunx create-remix
+```sh terminal icon="terminal"
+bun create remix
+bunx create-remix
 ```
 
 Refer to the documentation of the associated `create-<template>` package for complete documentation and usage instructions.
@@ -112,16 +128,16 @@ Refer to the documentation of the associated `create-<template>` package for com
 
 This will download the contents of the GitHub repo to disk.
 
-```bash
-$ bun create <user>/<repo>
-$ bun create github.com/<user>/<repo>
+```bash terminal icon="terminal"
+bun create <user>/<repo>
+bun create github.com/<user>/<repo>
 ```
 
 Optionally specify a name for the destination folder. If no destination is specified, the repo name will be used.
 
-```bash
-$ bun create <user>/<repo> mydir
-$ bun create github.com/<user>/<repo> mydir
+```bash terminal icon="terminal"
+bun create <user>/<repo> mydir
+bun create github.com/<user>/<repo> mydir
 ```
 
 Bun will perform the following steps:
@@ -132,77 +148,33 @@ Bun will perform the following steps:
 - Initialize a fresh Git repo. Opt out with the `--no-git` flag.
 - Run the template's configured `start` script, if defined.
 
-{% callout %}
-By default Bun will _not overwrite_ any existing files. Use the `--force` flag to overwrite existing files.
-{% /callout %}
-
-<!-- ### Official templates
-
-The following official templates are available.
-
-```bash
-bun create next ./myapp
-bun create react ./myapp
-bun create svelte-kit ./myapp
-bun create elysia ./myapp
-bun create hono ./myapp
-bun create kingworld ./myapp
-```
-
-Each of these corresponds to a directory in the [bun-community/create-templates](https://github.com/bun-community/create-templates) repo. If you think a major framework is missing, please open a PR there. This list will change over time as additional examples are added. To see an up-to-date list, run `bun create` with no arguments.
-
-```bash
-$ bun create
-Welcome to bun! Create a new project by pasting any of the following:
-  <list of templates>
-```
-
-{% callout %}
-⚡️ **Speed** — At the time of writing, `bun create react app` runs ~11x faster on a M1 Macbook Pro than `yarn create react-app app`.
-{% /callout %} -->
-
-<!-- ### GitHub repos
-
-A template of the form `<username>/<repo>` will be downloaded from GitHub.
-
-```bash
-$ bun create ahfarmer/calculator ./myapp
-```
-
-Complete GitHub URLs will also work:
-
-```bash
-$ bun create github.com/ahfarmer/calculator ./myapp
-$ bun create https://github.com/ahfarmer/calculator ./myapp
-```
-
-Bun installs the files as they currently exist current default branch (usually `main` or `master`). Unlike `git clone` it doesn't download the commit history or configure a remote. -->
+<Note>By default Bun will _not overwrite_ any existing files. Use the `--force` flag to overwrite existing files.</Note>
 
 ## From a local template
 
-{% callout %}
-**⚠️ Warning** — Unlike remote templates, running `bun create` with a local template will delete the entire destination folder if it already exists! Be careful.
-{% /callout %}
+<Warning>
+  Unlike remote templates, running `bun create` with a local template will delete the entire destination folder if it
+  already exists! Be careful.
+</Warning>
+
 Bun's templater can be extended to support custom templates defined on your local file system. These templates should live in one of the following directories:
 
 - `$HOME/.bun-create/<name>`: global templates
 - `<project root>/.bun-create/<name>`: project-specific templates
 
-{% callout %}
-**Note** — You can customize the global template path by setting the `BUN_CREATE_DIR` environment variable.
-{% /callout %}
+<Note>You can customize the global template path by setting the `BUN_CREATE_DIR` environment variable.</Note>
 
 To create a local template, navigate to `$HOME/.bun-create` and create a new directory with the desired name of your template.
 
 ```bash
-$ cd $HOME/.bun-create
-$ mkdir foo
-$ cd foo
+cd $HOME/.bun-create
+mkdir foo
+cd foo
 ```
 
 Then, create a `package.json` file in that directory with the following contents:
 
-```json
+```json package.json icon="file-json"
 {
   "name": "foo"
 }
@@ -214,7 +186,7 @@ You can run `bun create foo` elsewhere on your file system to verify that Bun is
 
 You can specify pre- and post-install setup scripts in the `"bun-create"` section of your local template's `package.json`.
 
-```json
+```json package.json icon="file-json"
 {
   "name": "@bun-examples/simplereact",
   "version": "0.0.1",
@@ -233,19 +205,10 @@ You can specify pre- and post-install setup scripts in the `"bun-create"` sectio
 
 The following fields are supported. Each of these can correspond to a string or array of strings. An array of commands will be executed in order.
 
-{% table %}
-
----
-
-- `postinstall`
-- runs after installing dependencies
-
----
-
-- `preinstall`
-- runs before installing dependencies
-
-{% /table %}
+| Field         | Description                         |
+| ------------- | ----------------------------------- |
+| `postinstall` | runs after installing dependencies  |
+| `preinstall`  | runs before installing dependencies |
 
 After cloning a template, `bun create` will automatically remove the `"bun-create"` section from `package.json` before writing it to the destination folder.
 
@@ -253,53 +216,21 @@ After cloning a template, `bun create` will automatically remove the `"bun-creat
 
 ### CLI flags
 
-{% table %}
-
-- Flag
-- Description
-
----
-
-- `--force`
-- Overwrite existing files
-
----
-
-- `--no-install`
-- Skip installing `node_modules` & tasks
-
----
-
-- `--no-git`
-- Don’t initialize a git repository
-
----
-
-- `--open`
-- Start & open in-browser after finish
-
-{% /table %}
+| Flag           | Description                            |
+| -------------- | -------------------------------------- |
+| `--force`      | Overwrite existing files               |
+| `--no-install` | Skip installing `node_modules` & tasks |
+| `--no-git`     | Don't initialize a git repository      |
+| `--open`       | Start & open in-browser after finish   |
 
 ### Environment variables
 
-{% table %}
-
-- Name
-- Description
-
----
-
-- `GITHUB_API_DOMAIN`
-- If you’re using a GitHub enterprise or a proxy, you can customize the GitHub domain Bun pings for downloads
-
----
-
-- `GITHUB_TOKEN` (or `GITHUB_ACCESS_TOKEN`)
-- This lets `bun create` work with private repositories or if you get rate-limited. `GITHUB_TOKEN` is chosen over `GITHUB_ACCESS_TOKEN` if both exist.
-
-{% /table %}
+| Name                                      | Description                                                                                                                                          |
+| ----------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `GITHUB_API_DOMAIN`                       | If you're using a GitHub enterprise or a proxy, you can customize the GitHub domain Bun pings for downloads                                          |
+| `GITHUB_TOKEN` (or `GITHUB_ACCESS_TOKEN`) | This lets `bun create` work with private repositories or if you get rate-limited. `GITHUB_TOKEN` is chosen over `GITHUB_ACCESS_TOKEN` if both exist. |
 
-{% details summary="How `bun create` works" %}
+<Accordion title={<span>How <code>bun create</code> works</span>}>
 
 When you run `bun create ${template} ${destination}`, here’s what happens:
 
@@ -324,7 +255,7 @@ ELSE IF local template
 
 4. Parse the `package.json` (again!), update `name` to be `${basename(destination)}`, remove the `bun-create` section from the `package.json` and save the updated `package.json` to disk.
    - IF Next.js is detected, add `bun-framework-next` to the list of dependencies
-   - IF Create React App is detected, add the entry point in /src/index.{js,jsx,ts,tsx} to `public/index.html`
+   - IF Create React App is detected, add the entry point in `/src/index.{js,jsx,ts,tsx}` to `public/index.html`
    - IF Relay is detected, add `bun-macro-relay` so that Relay works
 5. Auto-detect the npm client, preferring `pnpm`, `yarn` (v1), and lastly `npm`
 6. Run any tasks defined in `"bun-create": { "preinstall" }` with the npm client
@@ -335,4 +266,4 @@ ELSE IF local template
    - If there are dependencies, this runs in a separate thread concurrently while node_modules are being installed
    - Using libgit2 if available was tested and performed 3x slower in microbenchmarks
 
-{% /details %}
+</Accordion>

package/docs/{cli/init.md → runtime/templating/init.mdx}

@@ -1,8 +1,17 @@
-Scaffold an empty Bun project with the interactive `bun init` command.
+---
+title: "bun init"
+description: "Scaffold an empty Bun project with the interactive `bun init` command"
+---
 
-```bash
-$ bun init
+import Init from "/snippets/cli/init.mdx";
 
+Get started with Bun by scaffolding a new project with `bun init`.
+
+```bash terminal icon="terminal"
+bun init my-app
+```
+
+```txt
 ? Select a project template - Press return to submit.
 ❯ Blank
   React
@@ -10,30 +19,23 @@ $ bun init
 
 ✓ Select a project template: Blank
 
-+ .gitignore
-+ index.ts
-+ tsconfig.json (for editor autocomplete)
-+ README.md
-
-To get started, run:
-
-    bun run index.ts
-
-bun install v1.3.2-canary.20251105T140650
-
-+ @types/bun@1.3.2-canary.20251105T140650
-+ typescript@5.9.2
-
-7 packages installed
+ + .gitignore
+ + CLAUDE.md
+ + .cursor/rules/use-bun-instead-of-node-vite-npm-pnpm.mdc -> CLAUDE.md
+ + index.ts
+ + tsconfig.json (for editor autocomplete)
+ + README.md
 ```
 
 Press `enter` to accept the default answer for each prompt, or pass the `-y` flag to auto-accept the defaults.
 
-{% details summary="How `bun init` works" %}
+---
 
 `bun init` is a quick way to start a blank project with Bun. It guesses with sane defaults and is non-destructive when run multiple times.
 
-![Demo](https://user-images.githubusercontent.com/709451/183006613-271960a3-ff22-4f7c-83f5-5e18f684c836.gif)
+<Frame>
+  ![Demo](https://user-images.githubusercontent.com/709451/183006613-271960a3-ff22-4f7c-83f5-5e18f684c836.gif)
+</Frame>
 
 It creates:
 
@@ -51,35 +53,6 @@ If you pass `-y` or `--yes`, it will assume you want to continue without asking
 
 At the end, it runs `bun install` to install `@types/bun`.
 
-{% /details %}
-
-{% bunCLIUsage command="init" /%}
-
-## React
-
-The `--react` flag will scaffold a React project:
+---
 
-```bash
-$ bun init --react
-```
-
-The `--react` flag accepts the following values:
-
-- `tailwind` - Scaffold a React project with Tailwind CSS
-- `shadcn` - Scaffold a React project with Shadcn/UI and Tailwind CSS
-
-### React + TailwindCSS
-
-This will create a React project with Tailwind CSS configured with Bun's bundler and dev server.
-
-```bash
-$ bun init --react=tailwind
-```
-
-### React + @shadcn/ui
-
-This will create a React project with shadcn/ui and Tailwind CSS configured with Bun's bundler and dev server.
-
-```bash
-$ bun init --react=shadcn
-```
+<Init />