bun-types 1.3.2-canary.20251105T140650 → 1.3.2

package/docs/guides/install/{from-npm-install-to-bun-install.md → from-npm-install-to-bun-install.mdx}

@@ -1,5 +1,7 @@
 ---
-name: Migrate from npm install to bun install
+title: Migrate from npm install to bun install
+sidebarTitle: Migrate from npm to bun
+mode: center
 ---
 
 `bun install` is a Node.js compatible npm client designed to be an incredibly fast successor to npm.
@@ -11,18 +13,18 @@ We've put a lot of work into making sure that the migration path from `npm insta
 - **`.npmrc` compatible**: bun install reads npm registry configuration from npm's `.npmrc`, so you can use the same configuration for both npm and Bun.
 - **Hardlinks**: On Windows and Linux, `bun install` uses hardlinks to conserve disk space and install times.
 
-```bash
+```bash terminal icon="terminal"
 # It only takes one command to migrate
-$ bun i
+bun i
 
 # To add dependencies:
-$ bun i @types/bun
+bun i @types/bun
 
 # To add devDependencies:
-$ bun i -d @types/bun
+bun i -d @types/bun
 
 # To remove a dependency:
-$ bun rm @types/bun
+bun rm @types/bun
 ```
 
 ---
@@ -40,17 +42,17 @@ Run scripts from package.json, executables from `node_modules/.bin` (sort of lik
 
 When you use `bun run <executable>`, it will choose the locally-installed executable
 
-```sh
+```sh terminal icon="terminal"
 # Run a package.json script:
-$ bun my-script
-$ bun run my-script
+bun my-script
+bun run my-script
 
 # Run an executable in node_modules/.bin:
-$ bun my-executable # such as tsc, esbuild, etc.
-$ bun run my-executable
+bun my-executable # such as tsc, esbuild, etc.
+bun run my-executable
 
 # Run a JavaScript/TypeScript file:
-$ bun ./index.ts
+bun ./index.ts
 ```
 
 ---
@@ -61,7 +63,7 @@ $ bun ./index.ts
 
 In package.json, you can set `"workspaces"` to an array of relative paths.
 
-```json#package.json
+```json package.json icon="file-json"
 {
   "name": "my-app",
   "workspaces": ["packages/*", "apps/*"]
@@ -74,8 +76,8 @@ In package.json, you can set `"workspaces"` to an array of relative paths.
 
 In Bun, the `--filter` flag accepts a glob pattern, and will run the command concurrently for all workspace packages with a `name` that matches the pattern, respecting dependency order.
 
-```sh
-$ bun --filter 'lib-*' my-script
+```sh terminal icon="terminal"
+bun --filter 'lib-*' my-script
 # instead of:
 # npm run --workspace lib-foo --workspace lib-bar my-script
 ```
@@ -86,21 +88,21 @@ $ bun --filter 'lib-*' my-script
 
 To update a dependency, you can use `bun update <package>`. This will update the dependency to the latest version that satisfies the semver range specified in package.json.
 
-```sh
+```sh terminal icon="terminal"
 # Update a single dependency
-$ bun update @types/bun
+bun update @types/bun
 
 # Update all dependencies
-$ bun update
+bun update
 
 # Ignore semver, update to the latest version
-$ bun update @types/bun --latest
+bun update @types/bun --latest
 
 # Update a dependency to a specific version
-$ bun update @types/bun@1.3.2-canary.20251105T140650
+bun update @types/bun@1.3.1
 
 # Update all dependencies to the latest versions
-$ bun update --latest
+bun update --latest
 ```
 
 ---
@@ -109,8 +111,11 @@ $ bun update --latest
 
 To view outdated dependencies, run `bun outdated`. This is like `npm outdated` but with more compact output.
 
-```sh
-$ bun outdated
+```sh terminal icon="terminal"
+bun outdated
+```
+
+```txt
 ┌────────────────────────────────────────┬─────────┬────────┬────────┐
 │ Package                                │ Current │ Update │ Latest │
 ├────────────────────────────────────────┼─────────┼────────┼────────┤
@@ -144,18 +149,27 @@ $ bun outdated
 
 To list installed packages, you can use `bun pm ls`. This will list all the packages that are installed in the `node_modules` folder using Bun's lockfile as the source of truth. You can pass the `-a` flag to list all installed packages, including transitive dependencies.
 
-```sh
+```sh terminal icon="terminal"
 # List top-level installed packages:
-$ bun pm ls
+bun pm ls
+```
+
+```txt
 my-pkg node_modules (781)
 ├── @types/node@20.16.5
 ├── @types/react@18.3.8
 ├── @types/react-dom@18.3.0
 ├── eslint@8.57.1
 ├── eslint-config-next@14.2.8
+...
+```
 
+```sh terminal icon="terminal"
 # List all installed packages:
-$ bun pm ls -a
+bun pm ls -a
+```
+
+```txt
 my-pkg node_modules
 ├── @alloc/quick-lru@5.2.0
 ├── @isaacs/cliui@8.0.2
@@ -172,10 +186,12 @@ my-pkg node_modules
 
 To create a package tarball, you can use `bun pm pack`. This will create a tarball of the package in the current directory.
 
-```sh
+```sh terminal icon="terminal"
 # Create a tarball
-$ bun pm pack
+bun pm pack
+```
 
+```txt
 Total files: 46
 Shasum: 2ee19b6f0c6b001358449ca0eadead703f326216
 Integrity: sha512-ZV0lzWTEkGAMz[...]Gl4f8lA9sl97g==
@@ -191,12 +207,12 @@ If the package references `node` in the `#!/usr/bin/env node` shebang, `bun run`
 
 When you pass `--bun` to `bun run`, we create a symlink to the locally-installed Bun executable named `"node"` in a temporary directory and add that to your `PATH` for the duration of the script's execution.
 
-```sh
+```sh terminal icon="terminal"
 # Force using Bun's runtime instead of node
-$ bun --bun my-script
+bun --bun my-script
 
 # This also works:
-$ bun run --bun my-script
+bun run --bun my-script
 ```
 
 ---
@@ -205,10 +221,10 @@ $ bun run --bun my-script
 
 You can install packages globally using `bun i -g <package>`. This will install into a `.bun/install/global/node_modules` folder inside your home directory by default.
 
-```sh
+```sh terminal icon="terminal"
 # Install a package globally
-$ bun i -g eslint
+bun i -g eslint
 
 # Run a globally-installed package without the `bun run` prefix
-$ eslint --init
+eslint --init
 ```

package/docs/guides/install/{git-diff-bun-lockfile.md → git-diff-bun-lockfile.mdx}

@@ -1,16 +1,19 @@
 ---
-name: Configure git to diff Bun's lockb lockfile
+title: Configure git to diff Bun's lockb lockfile
+sidebarTitle: Configure git to diff Bun's lockfile
+mode: center
 ---
 
-{% callout %}
-Bun v1.1.39 introduced `bun.lock`, a JSONC formatted lockfile. `bun.lock` is human-readable and git-diffable without configuration, at no cost to performance. [**Learn more.**](https://bun.com/docs/install/lockfile#text-based-lockfile)
-{% /callout %}
+<Note>
+  Bun v1.1.39 introduced `bun.lock`, a JSONC formatted lockfile. `bun.lock` is human-readable and git-diffable without
+  configuration, at no cost to performance. [**Learn more.**](https://bun.com/docs/install/lockfile#text-based-lockfile)
+</Note>
 
 ---
 
 To teach `git` how to generate a human-readable diff of Bun's binary lockfile format (`.lockb`), add the following to your local or global `.gitattributes` file:
 
-```js
+```js gitattributes icon="file-code"
 *.lockb binary diff=lockb
 ```
 
@@ -18,18 +21,18 @@ To teach `git` how to generate a human-readable diff of Bun's binary lockfile fo
 
 Then add the following to you local git config with:
 
-```sh
-$ git config diff.lockb.textconv bun
-$ git config diff.lockb.binary true
+```sh terminal icon="terminal"
+git config diff.lockb.textconv bun
+git config diff.lockb.binary true
 ```
 
 ---
 
 To globally configure git to diff Bun's lockfile, add the following to your global git config with:
 
-```sh
-$ git config --global diff.lockb.textconv bun
-$ git config --global diff.lockb.binary true
+```sh terminal icon="terminal"
+git config --global diff.lockb.textconv bun
+git config --global diff.lockb.binary true
 ```
 
 ---

package/docs/guides/install/{jfrog-artifactory.md → jfrog-artifactory.mdx}

@@ -1,5 +1,7 @@
 ---
-name: Using bun install with Artifactory
+title: Using bun install with Artifactory
+sidebarTitle: JFrog Artifactory with Bun
+mode: center
 ---
 
 [JFrog Artifactory](https://jfrog.com/artifactory/) is a package management system for npm, Docker, Maven, NuGet, Ruby, Helm, and more. It allows you to host your own private npm registry, npm packages, and other types of packages as well.
@@ -12,7 +14,7 @@ To use it with `bun install`, add a `bunfig.toml` file to your project with the
 
 Make sure to replace `MY_SUBDOMAIN` with your JFrog Artifactory subdomain, such as `jarred1234` and MY_TOKEN with your JFrog Artifactory token.
 
-```toml#bunfig.toml
+```toml bunfig.toml icon="settings"
 [install.registry]
 url = "https://MY_SUBDOMAIN.jfrog.io/artifactory/api/npm/npm/_auth=MY_TOKEN"
 # Bun v1.0.3+ supports using an environment variable here
@@ -24,5 +26,3 @@ url = "https://MY_SUBDOMAIN.jfrog.io/artifactory/api/npm/npm/_auth=MY_TOKEN"
 ### Configure with `$NPM_CONFIG_REGISTRY`
 
 Like with npm, you can use the `NPM_CONFIG_REGISTRY` environment variable to configure JFrog Artifactory with bun install.
-
----

package/docs/guides/install/{npm-alias.md → npm-alias.mdx}

@@ -1,18 +1,20 @@
 ---
-name: Install a package under a different name
+title: Install a package under a different name
+sidebarTitle: Install with alias
+mode: center
 ---
 
 To install an npm package under an alias:
 
-```sh
-$ bun add my-custom-name@npm:zod
+```sh terminal icon="terminal"
+bun add my-custom-name@npm:zod
 ```
 
 ---
 
 The `zod` package can now be imported as `my-custom-name`.
 
-```ts
+```ts index.ts icon="/icons/typescript.svg"
 import { z } from "my-custom-name";
 
 z.string();

package/docs/guides/install/{registry-scope.md → registry-scope.mdx}

@@ -1,15 +1,17 @@
 ---
-name: Configure a private registry for an organization scope with bun install
+title: Configure a private registry for an organization scope with bun install
+sidebarTitle: Configure a scoped registry
+mode: center
 ---
 
 Private registries can be configured using either [`.npmrc`](https://bun.com/docs/install/npmrc) or [`bunfig.toml`](https://bun.com/docs/runtime/bunfig#install-registry). While both are supported, we recommend using **bunfig.toml** for enhanced flexibility and Bun-specific options.
 
 To configure a registry for a particular npm scope:
 
-```toml#bunfig.toml
+```toml bunfig.toml icon="settings"
 [install.scopes]
 # as a string
-"@myorg1" = "https://username:password@registry.myorg.com/"
+"@myorg1" = "https://usertitle:password@registry.myorg.com/"
 
 # as an object with username/password
 # you can reference environment variables
@@ -28,7 +30,7 @@ To configure a registry for a particular npm scope:
 
 Your `bunfig.toml` can reference environment variables. Bun automatically loads environment variables from `.env.local`, `.env.[NODE_ENV]`, and `.env`. See [Docs > Environment variables](https://bun.com/docs/runtime/env) for more information.
 
-```toml#bunfig.toml
+```toml bunfig.toml icon="settings"
 [install.scopes]
 "@myorg3" = { token = "$npm_token", url = "https://registry.myorg.com/" }
 ```

package/docs/guides/install/{trusted.md → trusted.mdx}

@@ -1,12 +1,15 @@
 ---
-name: Add a trusted dependency
+title: Add a trusted dependency
+sidebarTitle: Add a trusted dependency
+mode: center
 ---
 
 Unlike other npm clients, Bun does not execute arbitrary lifecycle scripts for installed dependencies, such as `postinstall` and `node-gyp` builds. These scripts represent a potential security risk, as they can execute arbitrary code on your machine.
 
-{% callout %}
-Bun includes a default allowlist of popular packages containing `postinstall` scripts that are known to be safe. You can see this list [here](https://github.com/oven-sh/bun/blob/main/src/install/default-trusted-dependencies.txt).
-{% /callout %}
+<Note>
+  Bun includes a default allowlist of popular packages containing `postinstall` scripts that are known to be safe. You
+  can see this list [here](https://github.com/oven-sh/bun/blob/main/src/install/default-trusted-dependencies.txt).
+</Note>
 
 ---
 
@@ -19,26 +22,27 @@ If you are seeing one of the following errors, you are probably trying to use a
 
 To allow Bun to execute lifecycle scripts for a specific package, add the package to `trustedDependencies` in your package.json file. You can do this automatically by running the command `bun pm trust <pkg>`.
 
-{% callout %}
-Note that this only allows lifecycle scripts for the specific package listed in `trustedDependencies`, _not_ the dependencies of that dependency!
-{% /callout %}
-
-```json-diff
-  {
-    "name": "my-app",
-    "version": "1.0.0",
-+   "trustedDependencies": ["my-trusted-package"]
-  }
+<Note>
+  Note that this only allows lifecycle scripts for the specific package listed in `trustedDependencies`, _not_ the
+  dependencies of that dependency!
+</Note>
+
+```json package.json icon="file-json"
+{
+  "name": "my-app",
+  "version": "1.0.0",
+  "trustedDependencies": ["my-trusted-package"] // [!code ++]
+}
 ```
 
 ---
 
 Once this is added, run a fresh install. Bun will re-install your dependencies and properly install
 
-```sh
-$ rm -rf node_modules
-$ rm bun.lock
-$ bun install
+```sh terminal icon="terminal"
+rm -rf node_modules
+rm bun.lock
+bun install
 ```
 
 ---

package/docs/guides/install/{workspaces.md → workspaces.mdx}

@@ -1,5 +1,7 @@
 ---
-name: Configuring a monorepo using workspaces
+title: Configuring a monorepo using workspaces
+sidebarTitle: Workspaces with Bun
+mode: center
 ---
 
 Bun's package manager supports npm `"workspaces"`. This allows you to split a codebase into multiple distinct "packages" that live in the same repository, can depend on each other, and (when possible) share a `node_modules` directory.
@@ -10,13 +12,11 @@ Clone [this sample project](https://github.com/colinhacks/bun-workspaces) to exp
 
 The root `package.json` should not contain any `"dependencies"`, `"devDependencies"`, etc. Each individual package should be self-contained and declare its own dependencies. Similarly, it's conventional to declare `"private": true` to avoid accidentally publishing the root package to `npm`.
 
-```json#package.json
+```json package.json icon="file-json"
 {
   "name": "my-monorepo",
   "private": true,
-  "workspaces": [
-    "packages/*"
-  ]
+  "workspaces": ["packages/*"]
 }
 ```
 
@@ -24,7 +24,7 @@ The root `package.json` should not contain any `"dependencies"`, `"devDependenci
 
 It's common to place all packages in a `packages` directory. The `"workspaces"` field in package.json supports glob patterns, so you can use `packages/*` to indicate that each subdirectory of `packages` should be considered separate _package_ (also known as a workspace).
 
-```txt
+```txt File Tree icon="folder-tree"
 .
 ├── package.json
 ├── node_modules
@@ -39,11 +39,11 @@ It's common to place all packages in a `packages` directory. The `"workspaces"`
 
 To add dependencies between workspaces, use the `"workspace:*"` syntax. Here we're adding `stuff-a` as a dependency of `stuff-b`.
 
-```json-diff#packages/stuff-b/package.json
+```json packages/stuff-b/package.json icon="file-json"
 {
   "name": "stuff-b",
   "dependencies": {
-+   "stuff-a": "workspace:*"
+    "stuff-a": "workspace:*" // [!code ++]
   }
 }
 ```
@@ -52,17 +52,17 @@ To add dependencies between workspaces, use the `"workspace:*"` syntax. Here we'
 
 Once added, run `bun install` from the project root to install dependencies for all workspaces.
 
-```sh
-$ bun install
+```sh terminal icon="terminal"
+bun install
 ```
 
 ---
 
 To add npm dependencies to a particular workspace, just `cd` to the appropriate directory and run `bun add` commands as you would normally. Bun will detect that you are in a workspace and hoist the dependency as needed.
 
-```sh
-$ cd packages/stuff-a
-$ bun add zod
+```sh terminal icon="terminal"
+cd packages/stuff-a
+bun add zod
 ```
 
 ---

package/docs/guides/install/{yarnlock.md → yarnlock.mdx}

@@ -1,24 +1,27 @@
 ---
-name: Generate a yarn-compatible lockfile
+title: Generate a yarn-compatible lockfile
+sidebarTitle: Generate a yarn-compatible lockfile
+mode: center
 ---
 
-{% callout %}
-Bun v1.1.39 introduced `bun.lock`, a JSONC formatted lockfile. `bun.lock` is human-readable and git-diffable without configuration, at no cost to performance. [**Learn more.**](https://bun.com/docs/install/lockfile#text-based-lockfile)
-{% /callout %}
+<Note>
+  Bun v1.1.39 introduced `bun.lock`, a JSONC formatted lockfile. `bun.lock` is human-readable and git-diffable without
+  configuration, at no cost to performance. [**Learn more.**](https://bun.com/docs/install/lockfile#text-based-lockfile)
+</Note>
 
 ---
 
 Use the `--yarn` flag to generate a Yarn-compatible `yarn.lock` file (in addition to `bun.lock`).
 
-```sh
-$ bun install --yarn
+```sh terminal icon="terminal"
+bun install --yarn
 ```
 
 ---
 
 To set this as the default behavior, add the following to your `bunfig.toml` file.
 
-```toml#bunfig.toml
+```toml bunfig.toml icon="settings"
 [install.lockfile]
 print = "yarn"
 ```
@@ -27,8 +30,11 @@ print = "yarn"
 
 To print a Yarn lockfile to your console without writing it to disk, "run" your `bun.lockb` with `bun`.
 
-```sh
-$ bun bun.lockb
+```sh terminal icon="terminal"
+bun bun.lockb
+```
+
+```txt
 # THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY.
 # yarn lockfile v1
 # bun ./bun.lockb --hash: 9BFBF11D86084AAB-9418b03ff880c569-390CE6459EACEC9A...

package/docs/guides/process/{argv.md → argv.mdx}

@@ -1,10 +1,12 @@
 ---
-name: Parse command-line arguments
+title: Parse command-line arguments
+sidebarTitle: Parse command-line arguments
+mode: center
 ---
 
 The _argument vector_ is the list of arguments passed to the program when it is run. It is available as `Bun.argv`.
 
-```ts#cli.ts
+```ts cli.ts icon="/icons/typescript.svg"
 console.log(Bun.argv);
 ```
 
@@ -12,8 +14,11 @@ console.log(Bun.argv);
 
 Running this file with arguments results in the following:
 
-```sh
-$ bun run cli.ts --flag1 --flag2 value
+```sh terminal icon="terminal"
+bun run cli.ts --flag1 --flag2 value
+```
+
+```txt
 [ '/path/to/bun', '/path/to/cli.ts', '--flag1', '--flag2', 'value' ]
 ```
 
@@ -23,17 +28,17 @@ To parse `argv` into a more useful format, `util.parseArgs` would be helpful.
 
 Example:
 
-```ts#cli.ts
+```ts cli.ts icon="/icons/typescript.svg"
 import { parseArgs } from "util";
 
 const { values, positionals } = parseArgs({
   args: Bun.argv,
   options: {
     flag1: {
-      type: 'boolean',
+      type: "boolean",
     },
     flag2: {
-      type: 'string',
+      type: "string",
     },
   },
   strict: true,
@@ -48,8 +53,11 @@ console.log(positionals);
 
 then it outputs
 
-```sh
-$ bun run cli.ts --flag1 --flag2 value
+```sh terminal icon="terminal"
+bun run cli.ts --flag1 --flag2 value
+```
+
+```txt
 {
   flag1: true,
   flag2: "value",

package/docs/guides/process/{ctrl-c.md → ctrl-c.mdx}

@@ -1,10 +1,12 @@
 ---
-name: Listen for CTRL+C
+title: Listen for CTRL+C
+sidebarTitle: Listen for CTRL+C
+mode: center
 ---
 
 The `ctrl+c` shortcut sends an _interrupt signal_ to the running process. This signal can be intercepted by listening for the `SIGINT` event. If you want to close the process, you must explicitly call `process.exit()`.
 
-```ts
+```ts process.ts icon="/icons/typescript.svg"
 process.on("SIGINT", () => {
   console.log("Ctrl-C was pressed");
   process.exit();

package/docs/guides/process/{ipc.md → ipc.mdx}

@@ -1,14 +1,17 @@
 ---
-name: Spawn a child process and communicate using IPC
+title: Spawn a child process and communicate using IPC
+sidebarTitle: Spawn a child process and communicate using IPC
+mode: center
 ---
 
 Use [`Bun.spawn()`](https://bun.com/docs/api/spawn) to spawn a child process. When spawning a second `bun` process, you can open a direct inter-process communication (IPC) channel between the two processes.
 
-{%callout%}
-**Note** — This API is only compatible with other `bun` processes. Use `process.execPath` to get a path to the currently running `bun` executable.
-{%/callout%}
+<Note>
+  This API is only compatible with other `bun` processes. Use `process.execPath` to get a path to the currently running
+  `bun` executable.
+</Note>
 
-```ts#parent.ts
+```ts parent.ts icon="/icons/typescript.svg"
 const child = Bun.spawn(["bun", "child.ts"], {
   ipc(message) {
     /**
@@ -22,13 +25,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");
   },
 });
 
@@ -39,11 +42,11 @@ 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 icon="/icons/typescript.svg"
 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);
 });
@@ -53,7 +56,7 @@ process.on("message", (message) => {
 
 All messages are serialized using the JSC `serialize` API, which allows for the same set of [transferrable types](https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API/Transferable_objects) supported by `postMessage` and `structuredClone`, including strings, typed arrays, streams, and objects.
 
-```ts#child.ts
+```ts child.ts icon="/icons/typescript.svg"
 // send a string
 process.send("Hello from child as string");
 

package/docs/guides/process/{nanoseconds.md → nanoseconds.mdx}

@@ -1,5 +1,7 @@
 ---
-name: Get the process uptime in nanoseconds
+title: Get the process uptime in nanoseconds
+sidebarTitle: Process uptime
+mode: center
 ---
 
 Use `Bun.nanoseconds()` to get the total number of nanoseconds the `bun` process has been alive.

package/docs/guides/process/{os-signals.md → os-signals.mdx}

@@ -1,5 +1,7 @@
 ---
-name: Listen to OS signals
+title: Listen to OS signals
+sidebarTitle: OS signals
+mode: center
 ---
 
 Bun supports the Node.js `process` global, including the `process.on()` method for listening to OS signals.