bun-types 1.3.2-canary.20251105T140650 → 1.3.2-canary.20251106T140813

package/docs/cli/bun-install.md

@@ -1,349 +0,0 @@
-### `bun install`
-
-bun install is a fast package manager & npm client.
-
-bun install can be configured via `bunfig.toml`, environment variables, and CLI flags.
-
-#### Configuring `bun install` with `bunfig.toml`
-
-`bunfig.toml` is searched for in the following paths on `bun install`, `bun remove`, and `bun add`:
-
-1. `$XDG_CONFIG_HOME/.bunfig.toml` or `$HOME/.bunfig.toml`
-2. `./bunfig.toml`
-
-If both are found, the results are merged together.
-
-Configuring with `bunfig.toml` is optional. Bun tries to be zero configuration in general, but that's not always possible.
-
-```toml
-# Using scoped packages with bun install
-[install.scopes]
-
-# Scope name      The value can be a URL string or an object
-"@mybigcompany" = { token = "123456", url = "https://registry.mybigcompany.com" }
-# URL is optional and falls back to the default registry
-
-# The "@" in the scope is optional
-mybigcompany2 = { token = "123456" }
-
-# Environment variables can be referenced as a string that starts with $ and it will be replaced
-mybigcompany3 = { token = "$npm_config_token" }
-
-# Setting username and password turns it into a Basic Auth header by taking base64("username:password")
-mybigcompany4 = { username = "myusername", password = "$npm_config_password", url = "https://registry.yarnpkg.com/" }
-# You can set username and password in the registry URL. This is the same as above.
-mybigcompany5 = "https://username:password@registry.yarnpkg.com/"
-
-# You can set a token for a registry URL:
-mybigcompany6 = "https://:$NPM_CONFIG_TOKEN@registry.yarnpkg.com/"
-
-[install]
-# Default registry
-# can be a URL string or an object
-registry = "https://registry.yarnpkg.com/"
-# as an object
-#registry = { url = "https://registry.yarnpkg.com/", token = "123456" }
-
-# Install for production? This is the equivalent to the "--production" CLI argument
-production = false
-
-# Save a text-based lockfile? This is equivalent to the "--save-text-lockfile" CLI argument
-saveTextLockfile = false
-
-# Disallow changes to lockfile? This is the equivalent to the "--frozen-lockfile" CLI argument
-frozenLockfile = false
-
-# Don't actually install
-dryRun = true
-
-# Install optionalDependencies (default: true)
-# Setting this to false is equivalent to the `--omit=optional` CLI argument
-optional = true
-
-# Install local devDependencies (default: true)
-# Setting this to false is equivalent to the `--omit=dev` CLI argument
-dev = true
-
-# Install peerDependencies (default: true)
-# Setting this to false is equivalent to the `--omit=peer` CLI argument
-peer = true
-
-# Max number of concurrent lifecycle scripts (default: (cpu count or GOMAXPROCS) x2)
-concurrentScripts = 16
-
-# When using `bun install -g`, install packages here
-globalDir = "~/.bun/install/global"
-
-# When using `bun install -g`, link package bins here
-globalBinDir = "~/.bun/bin"
-
-# cache-related configuration
-[install.cache]
-# The directory to use for the cache
-dir = "~/.bun/install/cache"
-
-# Don't load from the global cache.
-# Note: Bun may still write to node_modules/.cache
-disable = false
-
-
-# Always resolve the latest versions from the registry
-disableManifest = false
-
-
-# Lockfile-related configuration
-[install.lockfile]
-
-# Print a yarn v1 lockfile
-# Note: it does not load the lockfile, it just converts bun.lock into a yarn.lock
-print = "yarn"
-
-# Save the lockfile to disk
-save = true
-
-```
-
-If it's easier to read as TypeScript types:
-
-```ts
-export interface Root {
-  install: Install;
-}
-
-export interface Install {
-  scopes: Scopes;
-  registry: Registry;
-  production: boolean;
-  saveTextLockfile: boolean;
-  frozenLockfile: boolean;
-  dryRun: boolean;
-  optional: boolean;
-  dev: boolean;
-  peer: boolean;
-  globalDir: string;
-  globalBinDir: string;
-  cache: Cache;
-  lockfile: Lockfile;
-  logLevel: "debug" | "error" | "warn";
-}
-
-type Registry =
-  | string
-  | {
-      url?: string;
-      token?: string;
-      username?: string;
-      password?: string;
-    };
-
-type Scopes = Record<string, Registry>;
-
-export interface Cache {
-  dir: string;
-  disable: boolean;
-  disableManifest: boolean;
-}
-
-export interface Lockfile {
-  print?: "yarn";
-  save: boolean;
-}
-```
-
-## Configuring with environment variables
-
-Environment variables have a higher priority than `bunfig.toml`.
-
-| Name                             | Description                                                   |
-| -------------------------------- | ------------------------------------------------------------- |
-| BUN_CONFIG_REGISTRY              | Set an npm registry (default: <https://registry.npmjs.org>)   |
-| BUN_CONFIG_TOKEN                 | Set an auth token (currently does nothing)                    |
-| BUN_CONFIG_YARN_LOCKFILE         | Save a Yarn v1-style yarn.lock                                |
-| BUN_CONFIG_LINK_NATIVE_BINS      | Point `bin` in package.json to a platform-specific dependency |
-| BUN_CONFIG_SKIP_SAVE_LOCKFILE    | Don’t save a lockfile                                         |
-| BUN_CONFIG_SKIP_LOAD_LOCKFILE    | Don’t load a lockfile                                         |
-| BUN_CONFIG_SKIP_INSTALL_PACKAGES | Don’t install any packages                                    |
-
-Bun always tries to use the fastest available installation method for the target platform. On macOS, that’s `clonefile` and on Linux, that’s `hardlink`. You can change which installation method is used with the `--backend` flag. When unavailable or on error, `clonefile` and `hardlink` fallsback to a platform-specific implementation of copying files.
-
-Bun stores installed packages from npm in `~/.bun/install/cache/${name}@${version}`. Note that if the semver version has a `build` or a `pre` tag, it is replaced with a hash of that value instead. This is to reduce the chances of errors from long file paths, but unfortunately complicates figuring out where a package was installed on disk.
-
-When the `node_modules` folder exists, before installing, Bun checks if the `"name"` and `"version"` in `package/package.json` in the expected node_modules folder matches the expected `name` and `version`. This is how it determines whether it should install. It uses a custom JSON parser which stops parsing as soon as it finds `"name"` and `"version"`.
-
-When a `bun.lock` doesn’t exist or `package.json` has changed dependencies, tarballs are downloaded & extracted eagerly while resolving.
-
-When a `bun.lock` exists and `package.json` hasn’t changed, Bun downloads missing dependencies lazily. If the package with a matching `name` & `version` already exists in the expected location within `node_modules`, Bun won’t attempt to download the tarball.
-
-## Platform-specific dependencies?
-
-bun stores normalized `cpu` and `os` values from npm in the lockfile, along with the resolved packages. It skips downloading, extracting, and installing packages disabled for the current target at runtime. This means the lockfile won't change between platforms/architectures even if the packages ultimately installed do change.
-
-### `--cpu` and `--os` flags
-
-You can override the target platform for package selection:
-
-```bash
-bun install --cpu=x64 --os=linux
-```
-
-This installs packages for the specified platform instead of the current system. Useful for cross-platform builds or when preparing deployments for different environments.
-
-**Accepted values for `--cpu`**: `arm64`, `x64`, `ia32`, `ppc64`, `s390x`
-
-**Accepted values for `--os`**: `linux`, `darwin`, `win32`, `freebsd`, `openbsd`, `sunos`, `aix`
-
-## Peer dependencies?
-
-Peer dependencies are handled similarly to yarn. `bun install` will automatically install peer dependencies. If the dependency is marked optional in `peerDependenciesMeta`, an existing dependency will be chosen if possible.
-
-## Lockfile
-
-`bun.lock` is Bun’s lockfile format. See [our blogpost about the text lockfile](https://bun.com/blog/bun-lock-text-lockfile).
-
-Prior to Bun 1.2, the lockfile was binary and called `bun.lockb`. Old lockfiles can be upgraded to the new format by running `bun install --save-text-lockfile --frozen-lockfile --lockfile-only`, and then deleting `bun.lockb`.
-
-## Cache
-
-To delete the cache:
-
-```bash
-$ rm -rf ~/.bun/install/cache
-```
-
-## Platform-specific backends
-
-`bun install` uses different system calls to install dependencies depending on the platform. This is a performance optimization. You can force a specific backend with the `--backend` flag.
-
-**`hardlink`** is the default backend on Linux. Benchmarking showed it to be the fastest on Linux.
-
-```bash
-$ rm -rf node_modules
-$ bun install --backend hardlink
-```
-
-**`clonefile`** is the default backend on macOS. Benchmarking showed it to be the fastest on macOS. It is only available on macOS.
-
-```bash
-$ rm -rf node_modules
-$ bun install --backend clonefile
-```
-
-**`clonefile_each_dir`** is similar to `clonefile`, except it clones each file individually per directory. It is only available on macOS and tends to perform slower than `clonefile`. Unlike `clonefile`, this does not recursively clone subdirectories in one system call.
-
-```bash
-$ rm -rf node_modules
-$ bun install --backend clonefile_each_dir
-```
-
-**`copyfile`** is the fallback used when any of the above fail, and is the slowest. on macOS, it uses `fcopyfile()` and on linux it uses `copy_file_range()`.
-
-```bash
-$ rm -rf node_modules
-$ bun install --backend copyfile
-```
-
-**`symlink`** is typically only used for `file:` dependencies (and eventually `link:`) internally. To prevent infinite loops, it skips symlinking the `node_modules` folder.
-
-If you install with `--backend=symlink`, Node.js won't resolve node_modules of dependencies unless each dependency has its own node_modules folder or you pass `--preserve-symlinks` to `node` or `bun`. See [Node.js documentation on `--preserve-symlinks`](https://nodejs.org/api/cli.html#--preserve-symlinks).
-
-```bash
-$ rm -rf node_modules
-$ bun install --backend symlink
-$ bun --preserve-symlinks ./my-file.js
-$ node --preserve-symlinks ./my-file.js # https://nodejs.org/api/cli.html#--preserve-symlinks
-```
-
-## npm registry metadata
-
-bun uses a binary format for caching NPM registry responses. This loads much faster than JSON and tends to be smaller on disk.
-You will see these files in `~/.bun/install/cache/*.npm`. The filename pattern is `${hash(packageName)}.npm`. It’s a hash so that extra directories don’t need to be created for scoped packages.
-
-Bun's usage of `Cache-Control` ignores `Age`. This improves performance, but means bun may be about 5 minutes out of date to receive the latest package version metadata from npm.
-
-## pnpm migration
-
-Bun automatically migrates projects from pnpm to bun. When a `pnpm-lock.yaml` file is detected and no `bun.lock` file exists, Bun will automatically migrate the lockfile to `bun.lock` during installation. The original `pnpm-lock.yaml` file remains unmodified.
-
-```bash
-bun install
-```
-
-**Note**: Migration only runs when `bun.lock` is absent. There is currently no opt-out flag for pnpm migration.
-
-The migration process handles:
-
-### Lockfile Migration
-
-- Converts `pnpm-lock.yaml` to `bun.lock` format
-- Preserves package versions and resolution information
-- Maintains dependency relationships and peer dependencies
-- Handles patched dependencies with integrity hashes
-
-### Workspace Configuration
-
-When a `pnpm-workspace.yaml` file exists, Bun migrates workspace settings to your root `package.json`:
-
-```yaml
-# pnpm-workspace.yaml
-packages:
-  - "apps/*"
-  - "packages/*"
-
-catalog:
-  react: ^18.0.0
-  typescript: ^5.0.0
-
-catalogs:
-  build:
-    webpack: ^5.0.0
-    babel: ^7.0.0
-```
-
-The workspace packages list and catalogs are moved to the `workspaces` field in `package.json`:
-
-```json
-{
-  "workspaces": {
-    "packages": ["apps/*", "packages/*"],
-    "catalog": {
-      "react": "^18.0.0",
-      "typescript": "^5.0.0"
-    },
-    "catalogs": {
-      "build": {
-        "webpack": "^5.0.0",
-        "babel": "^7.0.0"
-      }
-    }
-  }
-}
-```
-
-### Catalog Dependencies
-
-Dependencies using pnpm's `catalog:` protocol are preserved:
-
-```json
-{
-  "dependencies": {
-    "react": "catalog:",
-    "webpack": "catalog:build"
-  }
-}
-```
-
-### Configuration Migration
-
-The following pnpm configuration is migrated from both `pnpm-lock.yaml` and `pnpm-workspace.yaml`:
-
-- **Overrides**: Moved from `pnpm.overrides` to root-level `overrides` in `package.json`
-- **Patched Dependencies**: Moved from `pnpm.patchedDependencies` to root-level `patchedDependencies` in `package.json`
-- **Workspace Overrides**: Applied from `pnpm-workspace.yaml` to root `package.json`
-
-### Requirements
-
-- Requires pnpm lockfile version 7 or higher
-- Workspace packages must have a `name` field in their `package.json`
-- All catalog entries referenced by dependencies must exist in the catalogs definition
-
-After migration, you can safely remove `pnpm-lock.yaml` and `pnpm-workspace.yaml` files.

package/docs/cli/bun-upgrade.md

@@ -1,39 +0,0 @@
-To upgrade Bun, run `bun upgrade`.
-
-It automatically downloads the latest version of Bun and overwrites the currently-running version.
-
-This works by checking the latest version of Bun in [bun-releases-for-updater](https://github.com/Jarred-Sumner/bun-releases-for-updater/releases) and unzipping it using the system-provided `unzip` library (so that Gatekeeper works on macOS)
-
-If for any reason you run into issues, you can also use the curl install script:
-
-```bash
-$ curl https://bun.com/install | bash
-```
-
-It will still work when Bun is already installed.
-
-Bun is distributed as a single binary file, so you can also do this manually:
-
-- Download the latest version of Bun for your platform in [bun-releases-for-updater](https://github.com/Jarred-Sumner/bun-releases-for-updater/releases/latest) (`darwin` == macOS)
-- Unzip the folder
-- Move the `bun` binary to `~/.bun/bin` (or anywhere)
-
-## `--canary`
-
-[Canary](https://github.com/oven-sh/bun/releases/tag/canary) builds are generated on every commit.
-
-To install a [canary](https://github.com/oven-sh/bun/releases/tag/canary) build of Bun, run:
-
-```bash
-$ bun upgrade --canary
-```
-
-This flag is not persistent (though that might change in the future). If you want to always run the canary build of Bun, set the `BUN_CANARY` environment variable to `1` in your shell's startup script.
-
-This will download the release zip from https://github.com/oven-sh/bun/releases/tag/canary.
-
-To revert to the latest published version of Bun, run:
-
-```bash
-$ bun upgrade
-```

package/docs/cli/bunx.md

@@ -1,89 +0,0 @@
-{% callout %}
-**Note** — `bunx` is an alias for `bun x`. The `bunx` CLI will be auto-installed when you install `bun`.
-{% /callout %}
-
-Use `bunx` to auto-install and run packages from `npm`. It's Bun's equivalent of `npx` or `yarn dlx`.
-
-```bash
-$ bunx cowsay "Hello world!"
-```
-
-{% callout %}
-⚡️ **Speed** — With Bun's fast startup times, `bunx` is [roughly 100x faster](https://twitter.com/jarredsumner/status/1606163655527059458) than `npx` for locally installed packages.
-{% /callout %}
-
-Packages can declare executables in the `"bin"` field of their `package.json`. These are known as _package executables_ or _package binaries_.
-
-```jsonc#package.json
-{
-  // ... other fields
-  "name": "my-cli",
-  "bin": {
-    "my-cli": "dist/index.js"
-  }
-}
-```
-
-These executables are commonly plain JavaScript files marked with a [shebang line](<https://en.wikipedia.org/wiki/Shebang_(Unix)>) to indicate which program should be used to execute them. The following file indicates that it should be executed with `node`.
-
-```js#dist/index.js
-#!/usr/bin/env node
-
-console.log("Hello world!");
-```
-
-These executables can be run with `bunx`,
-
-```bash
-$ bunx my-cli
-```
-
-As with `npx`, `bunx` will check for a locally installed package first, then fall back to auto-installing the package from `npm`. Installed packages will be stored in Bun's global cache for future use.
-
-## Arguments and flags
-
-To pass additional command-line flags and arguments through to the executable, place them after the executable name.
-
-```bash
-$ bunx my-cli --foo bar
-```
-
-## Shebangs
-
-By default, Bun respects shebangs. If an executable is marked with `#!/usr/bin/env node`, Bun will spin up a `node` process to execute the file. However, in some cases it may be desirable to run executables using Bun's runtime, even if the executable indicates otherwise. To do so, include the `--bun` flag.
-
-```bash
-$ bunx --bun my-cli
-```
-
-The `--bun` flag must occur _before_ the executable name. Flags that appear _after_ the name are passed through to the executable.
-
-```bash
-$ bunx --bun my-cli # good
-$ bunx my-cli --bun # bad
-```
-
-## Package flag
-
-**`--package <pkg>` or `-p <pkg>`** - Run binary from specific package. Useful when binary name differs from package name:
-
-```bash
-bunx -p renovate renovate-config-validator
-bunx --package @angular/cli ng
-```
-
-To force bun to always be used with a script, use a shebang.
-
-```
-#!/usr/bin/env bun
-```
-
-<!-- ## Environment variables
-
-Bun automatically loads environment variables from `.env` files before running a file, script, or executable. The following files are checked, in order:
-
-1. `.env.local` (first)
-2. `NODE_ENV` === `"production"` ? `.env.production` : `.env.development`
-3. `.env`
-
-To debug environment variables, run `bun --print process.env` to view a list of resolved environment variables. -->

package/docs/cli/filter.md

@@ -1,90 +0,0 @@
-The `--filter` (or `-F`) flag is used for selecting packages by pattern in a monorepo. Patterns can be used to match package names or package paths, with full glob syntax support.
-
-Currently `--filter` is supported by `bun install` and `bun outdated`, and can also be used to run scripts for multiple packages at once.
-
-## Matching
-
-### Package Name `--filter <pattern>`
-
-Name patterns select packages based on the package name, as specified in `package.json`. For example, if you have packages `pkg-a`, `pkg-b` and `other`, you can match all packages with `*`, only `pkg-a` and `pkg-b` with `pkg*`, and a specific package by providing the full name of the package.
-
-### Package Path `--filter ./<glob>`
-
-Path patterns are specified by starting the pattern with `./`, and will select all packages in directories that match the pattern. For example, to match all packages in subdirectories of `packages`, you can use `--filter './packages/**'`. To match a package located in `packages/foo`, use `--filter ./packages/foo`.
-
-## `bun install` and `bun outdated`
-
-Both `bun install` and `bun outdated` support the `--filter` flag.
-
-`bun install` by default will install dependencies for all packages in the monorepo. To install dependencies for specific packages, use `--filter`.
-
-Given a monorepo with workspaces `pkg-a`, `pkg-b`, and `pkg-c` under `./packages`:
-
-```bash
-# Install dependencies for all workspaces except `pkg-c`
-$ bun install --filter '!pkg-c'
-
-# Install dependencies for packages in `./packages` (`pkg-a`, `pkg-b`, `pkg-c`)
-$ bun install --filter './packages/*'
-
-# Save as above, but exclude the root package.json
-$ bun install --filter '!./' --filter './packages/*'
-```
-
-Similarly, `bun outdated` will display outdated dependencies for all packages in the monorepo, and `--filter` can be used to restrict the command to a subset of the packages:
-
-```bash
-# Display outdated dependencies for workspaces starting with `pkg-`
-$ bun outdated --filter 'pkg-*'
-
-# Display outdated dependencies for only the root package.json
-$ bun outdated --filter './'
-```
-
-For more information on both these commands, see [`bun install`](https://bun.com/docs/cli/install) and [`bun outdated`](https://bun.com/docs/cli/outdated).
-
-## Running scripts with `--filter`
-
-Use the `--filter` flag to execute scripts in multiple packages at once:
-
-```bash
-bun --filter <pattern> <script>
-```
-
-Say you have a monorepo with two packages: `packages/api` and `packages/frontend`, both with a `dev` script that will start a local development server. Normally, you would have to open two separate terminal tabs, cd into each package directory, and run `bun dev`:
-
-```bash
-cd packages/api
-bun dev
-
-# in another terminal
-cd packages/frontend
-bun dev
-```
-
-Using `--filter`, you can run the `dev` script in both packages at once:
-
-```bash
-bun --filter '*' dev
-```
-
-Both commands will be run in parallel, and you will see a nice terminal UI showing their respective outputs:
-![Terminal Output](https://github.com/oven-sh/bun/assets/48869301/2a103e42-9921-4c33-948f-a1ad6e6bac71)
-
-### Running scripts in workspaces
-
-Filters respect your [workspace configuration](https://bun.com/docs/install/workspaces): If you have a `package.json` file that specifies which packages are part of the workspace,
-`--filter` will be restricted to only these packages. Also, in a workspace you can use `--filter` to run scripts in packages that are located anywhere in the workspace:
-
-```bash
-# Packages
-# src/foo
-# src/bar
-
-# in src/bar: runs myscript in src/foo, no need to cd!
-bun run --filter foo myscript
-```
-
-### Dependency Order
-
-Bun will respect package dependency order when running scripts. Say you have a package `foo` that depends on another package `bar` in your workspace, and both packages have a `build` script. When you run `bun --filter '*' build`, you will notice that `foo` will only start running once `bar` is done.

package/docs/cli/info.md

@@ -1,65 +0,0 @@
-`bun info` displays package metadata from the npm registry.
-
-## Usage
-
-```bash
-$ bun info react
-```
-
-This will display information about the `react` package, including its latest version, description, homepage, dependencies, and more.
-
-## Viewing specific versions
-
-To view information about a specific version:
-
-```bash
-$ bun info react@18.0.0
-```
-
-## Viewing specific properties
-
-You can also query specific properties from the package metadata:
-
-```bash
-$ bun info react version
-$ bun info react dependencies
-$ bun info react repository.url
-```
-
-## JSON output
-
-To get the output in JSON format, use the `--json` flag:
-
-```bash
-$ bun info react --json
-```
-
-## Alias
-
-`bun pm view` is an alias for `bun info`:
-
-```bash
-$ bun pm view react  # equivalent to: bun info react
-```
-
-## Examples
-
-```bash
-# View basic package information
-$ bun info is-number
-
-# View a specific version
-$ bun info is-number@7.0.0
-
-# View all available versions
-$ bun info is-number versions
-
-# View package dependencies
-$ bun info express dependencies
-
-# View package homepage
-$ bun info lodash homepage
-
-# Get JSON output
-$ bun info react --json
-```