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

package/docs/cli/pm.md

@@ -1,285 +0,0 @@
-The `bun pm` command group provides a set of utilities for working with Bun's package manager.
-
-## pack
-
-To create a tarball of the current workspace:
-
-```bash
-$ bun pm pack
-```
-
-This command creates a `.tgz` file containing all files that would be published to npm, following the same rules as `npm pack`.
-
-## Examples
-
-Basic usage:
-
-```bash
-$ bun pm pack
-# Creates my-package-1.0.0.tgz in current directory
-```
-
-Quiet mode for scripting:
-
-```bash
-$ TARBALL=$(bun pm pack --quiet)
-$ echo "Created: $TARBALL"
-# Output: Created: my-package-1.0.0.tgz
-```
-
-Custom destination:
-
-```bash
-$ bun pm pack --destination ./dist
-# Saves tarball in ./dist/ directory
-```
-
-## Options
-
-- `--dry-run`: Perform all tasks except writing the tarball to disk. Shows what would be included.
-- `--destination <dir>`: Specify the directory where the tarball will be saved.
-- `--filename <name>`: Specify an exact file name for the tarball to be saved at.
-- `--ignore-scripts`: Skip running pre/postpack and prepare scripts.
-- `--gzip-level <0-9>`: Set a custom compression level for gzip, ranging from 0 to 9 (default is 9).
-- `--quiet`: Only output the tarball filename, suppressing verbose output. Ideal for scripts and automation.
-
-> **Note:** `--filename` and `--destination` cannot be used at the same time.
-
-## Output Modes
-
-**Default output:**
-
-```bash
-$ bun pm pack
-bun pack v1.2.19
-
-packed 131B package.json
-packed 40B index.js
-
-my-package-1.0.0.tgz
-
-Total files: 2
-Shasum: f2451d6eb1e818f500a791d9aace80b394258a90
-Unpacked size: 171B
-Packed size: 249B
-```
-
-**Quiet output:**
-
-```bash
-$ bun pm pack --quiet
-my-package-1.0.0.tgz
-```
-
-The `--quiet` flag is particularly useful for automation workflows where you need to capture the generated tarball filename for further processing.
-
-## bin
-
-To print the path to the `bin` directory for the local project:
-
-```bash
-$ bun pm bin
-/path/to/current/project/node_modules/.bin
-```
-
-To print the path to the global `bin` directory:
-
-```bash
-$ bun pm bin -g
-<$HOME>/.bun/bin
-```
-
-## ls
-
-To print a list of installed dependencies in the current project and their resolved versions, excluding their dependencies.
-
-```bash
-$ bun pm ls
-/path/to/project node_modules (135)
-├── eslint@8.38.0
-├── react@18.2.0
-├── react-dom@18.2.0
-├── typescript@5.0.4
-└── zod@3.21.4
-```
-
-To print all installed dependencies, including nth-order dependencies.
-
-```bash
-$ bun pm ls --all
-/path/to/project node_modules (135)
-├── @eslint-community/eslint-utils@4.4.0
-├── @eslint-community/regexpp@4.5.0
-├── @eslint/eslintrc@2.0.2
-├── @eslint/js@8.38.0
-├── @nodelib/fs.scandir@2.1.5
-├── @nodelib/fs.stat@2.0.5
-├── @nodelib/fs.walk@1.2.8
-├── acorn@8.8.2
-├── acorn-jsx@5.3.2
-├── ajv@6.12.6
-├── ansi-regex@5.0.1
-├── ...
-```
-
-## whoami
-
-Print your npm username. Requires you to be logged in (`bunx npm login`) with credentials in either `bunfig.toml` or `.npmrc`:
-
-```bash
-$ bun pm whoami
-```
-
-## hash
-
-To generate and print the hash of the current lockfile:
-
-```bash
-$ bun pm hash
-```
-
-To print the string used to hash the lockfile:
-
-```bash
-$ bun pm hash-string
-```
-
-To print the hash stored in the current lockfile:
-
-```bash
-$ bun pm hash-print
-```
-
-## cache
-
-To print the path to Bun's global module cache:
-
-```bash
-$ bun pm cache
-```
-
-To clear Bun's global module cache:
-
-```bash
-$ bun pm cache rm
-```
-
-## migrate
-
-To migrate another package manager's lockfile without installing anything:
-
-```bash
-$ bun pm migrate
-```
-
-## untrusted
-
-To print current untrusted dependencies with scripts:
-
-```bash
-$ bun pm untrusted
-
-./node_modules/@biomejs/biome @1.8.3
- » [postinstall]: node scripts/postinstall.js
-
-These dependencies had their lifecycle scripts blocked during install.
-```
-
-## trust
-
-To run scripts for untrusted dependencies and add to `trustedDependencies`:
-
-```bash
-$ bun pm trust <names>
-```
-
-Options for the `trust` command:
-
-- `--all`: Trust all untrusted dependencies.
-
-## default-trusted
-
-To print the default trusted dependencies list:
-
-```bash
-$ bun pm default-trusted
-```
-
-see the current list on GitHub [here](https://github.com/oven-sh/bun/blob/main/src/install/default-trusted-dependencies.txt)
-
-## version
-
-To display current package version and help:
-
-```bash
-$ bun pm version
-bun pm version v1.3.2-canary.20251105T140650 (ca7428e9)
-Current package version: v1.0.0
-
-Increment:
-  patch      1.0.0 → 1.0.1
-  minor      1.0.0 → 1.1.0
-  major      1.0.0 → 2.0.0
-  prerelease 1.0.0 → 1.0.1-0
-  prepatch   1.0.0 → 1.0.1-0
-  preminor   1.0.0 → 1.1.0-0
-  premajor   1.0.0 → 2.0.0-0
-  from-git   Use version from latest git tag
-  1.2.3      Set specific version
-
-Options:
-  --no-git-tag-version Skip git operations
-  --allow-same-version Prevents throwing error if version is the same
-  --message=<val>, -m  Custom commit message, use %s for version substitution
-  --preid=<val>        Prerelease identifier (i.e beta → 1.0.1-beta.0)
-  --force, -f          Bypass dirty git history check
-
-Examples:
-  $ bun pm version patch
-  $ bun pm version 1.2.3 --no-git-tag-version
-  $ bun pm version prerelease --preid beta --message "Release beta: %s"
-```
-
-To bump the version in `package.json`:
-
-```bash
-$ bun pm version patch
-v1.0.1
-```
-
-Supports `patch`, `minor`, `major`, `premajor`, `preminor`, `prepatch`, `prerelease`, `from-git`, or specific versions like `1.2.3`. By default creates git commit and tag unless `--no-git-tag-version` was used to skip.
-
-## pkg
-
-Manage `package.json` data with get, set, delete, and fix operations.
-
-All commands support dot and bracket notation:
-
-```bash
-scripts.build              # dot notation
-contributors[0]            # array access
-workspaces.0               # dot with numeric index
-scripts[test:watch]        # bracket for special chars
-```
-
-Examples:
-
-```bash
-# set
-$ bun pm pkg get name                               # single property
-$ bun pm pkg get name version                       # multiple properties
-$ bun pm pkg get                                    # entire package.json
-$ bun pm pkg get scripts.build                      # nested property
-
-# set
-$ bun pm pkg set name="my-package"                  # simple property
-$ bun pm pkg set scripts.test="jest" version=2.0.0  # multiple properties
-$ bun pm pkg set {"private":"true"} --json          # JSON values with --json flag
-
-# delete
-$ bun pm pkg delete description                     # single property
-$ bun pm pkg delete scripts.test contributors[0]    # multiple/nested
-
-# fix
-$ bun pm pkg fix                                    # auto-fix common issues
-```

package/docs/cli/publish.md

@@ -1,120 +0,0 @@
-Use `bun publish` to publish a package to the npm registry.
-
-`bun publish` will automatically pack your package into a tarball, strip catalog and workspace protocols from the `package.json` (resolving versions if necessary), and publish to the registry specified in your configuration files. Both `bunfig.toml` and `.npmrc` files are supported.
-
-```sh
-## Publishing the package from the current working directory
-$ bun publish
-
-## Output
-bun publish v1.3.2-canary.20251105T140650 (ca7428e9)
-
-packed 203B package.json
-packed 224B README.md
-packed 30B index.ts
-packed 0.64KB tsconfig.json
-
-Total files: 4
-Shasum: 79e2b4377b63f4de38dc7ea6e5e9dbee08311a69
-Integrity: sha512-6QSNlDdSwyG/+[...]X6wXHriDWr6fA==
-Unpacked size: 1.1KB
-Packed size: 0.76KB
-Tag: latest
-Access: default
-Registry: http://localhost:4873/
-
- + publish-1@1.0.0
-```
-
-Alternatively, you can pack and publish your package separately by using `bun pm pack` followed by `bun publish` with the path to the output tarball.
-
-```sh
-$ bun pm pack
-...
-$ bun publish ./package.tgz
-```
-
-{% callout %}
-**Note** - `bun publish` will not run lifecycle scripts (`prepublishOnly/prepack/prepare/postpack/publish/postpublish`) if a tarball path is provided. Scripts will only be run if the package is packed by `bun publish`.
-{% /callout %}
-
-### `--access`
-
-The `--access` flag can be used to set the access level of the package being published. The access level can be one of `public` or `restricted`. Unscoped packages are always public, and attempting to publish an unscoped package with `--access restricted` will result in an error.
-
-```sh
-$ bun publish --access public
-```
-
-`--access` can also be set in the `publishConfig` field of your `package.json`.
-
-```json
-{
-  "publishConfig": {
-    "access": "restricted"
-  }
-}
-```
-
-### `--tag`
-
-Set the tag of the package version being published. By default, the tag is `latest`. The initial version of a package is always given the `latest` tag in addition to the specified tag.
-
-```sh
-$ bun publish --tag alpha
-```
-
-`--tag` can also be set in the `publishConfig` field of your `package.json`.
-
-```json
-{
-  "publishConfig": {
-    "tag": "next"
-  }
-}
-```
-
-### `--dry-run`
-
-The `--dry-run` flag can be used to simulate the publish process without actually publishing the package. This is useful for verifying the contents of the published package without actually publishing the package.
-
-```sh
-$ bun publish --dry-run
-```
-
-### `--tolerate-republish`
-
-Exit with code 0 instead of 1 if the package version already exists. Useful in CI/CD where jobs may be re-run.
-
-```sh
-$ bun publish --tolerate-republish
-```
-
-### `--gzip-level`
-
-Specify the level of gzip compression to use when packing the package. Only applies to `bun publish` without a tarball path argument. Values range from `0` to `9` (default is `9`).
-{% bunCLIUsage command="publish" /%}
-
-### `--auth-type`
-
-If you have 2FA enabled for your npm account, `bun publish` will prompt you for a one-time password. This can be done through a browser or the CLI. The `--auth-type` flag can be used to tell the npm registry which method you prefer. The possible values are `web` and `legacy`, with `web` being the default.
-
-```sh
-$ bun publish --auth-type legacy
-...
-This operation requires a one-time password.
-Enter OTP: 123456
-...
-```
-
-### `--otp`
-
-Provide a one-time password directly to the CLI. If the password is valid, this will skip the extra prompt for a one-time password before publishing. Example usage:
-
-```sh
-$ bun publish --otp 123456
-```
-
-{% callout %}
-**Note** - `bun publish` respects the `NPM_CONFIG_TOKEN` environment variable which can be used when publishing in github actions or automated workflows.
-{% /callout %}

package/docs/cli/remove.md

@@ -1,7 +0,0 @@
-To remove a dependency:
-
-```bash
-$ bun remove ts-node
-```
-
-{% bunCLIUsage command="remove" /%}

package/docs/cli/run.md

@@ -1,261 +0,0 @@
-The `bun` CLI can be used to execute JavaScript/TypeScript files, `package.json` scripts, and [executable packages](https://docs.npmjs.com/cli/v9/configuring-npm/package-json#bin).
-
-## Performance
-
-Bun is designed to start fast and run fast.
-
-Under the hood Bun uses the [JavaScriptCore engine](https://developer.apple.com/documentation/javascriptcore), which is developed by Apple for Safari. In most cases, the startup and running performance is faster than V8, the engine used by Node.js and Chromium-based browsers. Its transpiler and runtime are written in Zig, a modern, high-performance language. On Linux, this translates into startup times [4x faster](https://twitter.com/jarredsumner/status/1499225725492076544) than Node.js.
-
-{% table %}
-
----
-
-- `bun hello.js`
-- `5.2ms`
-
----
-
-- `node hello.js`
-- `25.1ms`
-
-{% /table %}
-{% caption content="Running a simple Hello World script on Linux" /%}
-
-<!-- {% image src="/images/bun-run-speed.jpeg" caption="Bun vs Node.js vs Deno running Hello World" /%} -->
-
-<!-- ## Speed -->
-
-<!--
-Performance sensitive APIs like `Buffer`, `fetch`, and `Response` are heavily profiled and optimized. Under the hood Bun uses the [JavaScriptCore engine](https://developer.apple.com/documentation/javascriptcore), which is developed by Apple for Safari. It starts and runs faster than V8, the engine used by Node.js and Chromium-based browsers. -->
-
-## Run a file
-
-{% callout %}
-Compare to `node <file>`
-{% /callout %}
-
-Use `bun run` to execute a source file.
-
-```bash
-$ bun run index.js
-```
-
-Bun supports TypeScript and JSX out of the box. Every file is transpiled on the fly by Bun's fast native transpiler before being executed.
-
-```bash
-$ bun run index.js
-$ bun run index.jsx
-$ bun run index.ts
-$ bun run index.tsx
-```
-
-Alternatively, you can omit the `run` keyword and use the "naked" command; it behaves identically.
-
-```bash
-$ bun index.tsx
-$ bun index.js
-```
-
-### `--watch`
-
-To run a file in watch mode, use the `--watch` flag.
-
-```bash
-$ bun --watch run index.tsx
-```
-
-{% callout %}
-**Note** — When using `bun run`, put Bun flags like `--watch` immediately after `bun`.
-
-```bash
-$ bun --watch run dev # ✔️ do this
-$ bun run dev --watch # ❌ don't do this
-```
-
-Flags that occur at the end of the command will be ignored and passed through to the `"dev"` script itself.
-{% /callout %}
-
-## Run a `package.json` script
-
-{% note %}
-Compare to `npm run <script>` or `yarn <script>`
-{% /note %}
-
-```sh
-$ bun [bun flags] run <script> [script flags]
-```
-
-Your `package.json` can define a number of named `"scripts"` that correspond to shell commands.
-
-```json
-{
-  // ... other fields
-  "scripts": {
-    "clean": "rm -rf dist && echo 'Done.'",
-    "dev": "bun server.ts"
-  }
-}
-```
-
-Use `bun run <script>` to execute these scripts.
-
-```bash
-$ bun run clean
- $ rm -rf dist && echo 'Done.'
- Cleaning...
- Done.
-```
-
-Bun executes the script command in a subshell. On Linux & macOS, it checks for the following shells in order, using the first one it finds: `bash`, `sh`, `zsh`. On windows, it uses [bun shell](https://bun.com/docs/runtime/shell) to support bash-like syntax and many common commands.
-
-{% callout %}
-⚡️ The startup time for `npm run` on Linux is roughly 170ms; with Bun it is `6ms`.
-{% /callout %}
-
-Scripts can also be run with the shorter command `bun <script>`, however if there is a built-in bun command with the same name, the built-in command takes precedence. In this case, use the more explicit `bun run <script>` command to execute your package script.
-
-```bash
-$ bun run dev
-```
-
-To see a list of available scripts, run `bun run` without any arguments.
-
-```bash
-$ bun run
-quickstart scripts:
-
- bun run clean
-   rm -rf dist && echo 'Done.'
-
- bun run dev
-   bun server.ts
-
-2 scripts
-```
-
-Bun respects lifecycle hooks. For instance, `bun run clean` will execute `preclean` and `postclean`, if defined. If the `pre<script>` fails, Bun will not execute the script itself.
-
-### `--bun`
-
-It's common for `package.json` scripts to reference locally-installed CLIs like `vite` or `next`. These CLIs are often JavaScript files marked with a [shebang](<https://en.wikipedia.org/wiki/Shebang_(Unix)>) to indicate that they should be executed with `node`.
-
-```js
-#!/usr/bin/env node
-
-// do stuff
-```
-
-By default, Bun respects this shebang and executes the script with `node`. However, you can override this behavior with the `--bun` flag. For Node.js-based CLIs, this will run the CLI with Bun instead of Node.js.
-
-```bash
-$ bun run --bun vite
-```
-
-### `--no-addons`
-
-Disable native addons and use the `node-addons` export condition.
-
-```bash
-$ bun --no-addons run server.js
-```
-
-### Filtering
-
-In monorepos containing multiple packages, you can use the `--filter` argument to execute scripts in many packages at once.
-
-Use `bun run --filter <name_pattern> <script>` to execute `<script>` in all packages whose name matches `<name_pattern>`.
-For example, if you have subdirectories containing packages named `foo`, `bar` and `baz`, running
-
-```bash
-bun run --filter 'ba*' <script>
-```
-
-will execute `<script>` in both `bar` and `baz`, but not in `foo`.
-
-Find more details in the docs page for [filter](https://bun.com/docs/cli/filter#running-scripts-with-filter).
-
-### `--workspaces`
-
-Run scripts across all workspaces in the monorepo:
-
-```bash
-bun run --workspaces test
-```
-
-## `bun run -` to pipe code from stdin
-
-`bun run -` lets you read JavaScript, TypeScript, TSX, or JSX from stdin and execute it without writing to a temporary file first.
-
-```bash
-$ echo "console.log('Hello')" | bun run -
-Hello
-```
-
-You can also use `bun run -` to redirect files into Bun. For example, to run a `.js` file as if it were a `.ts` file:
-
-```bash
-$ echo "console.log!('This is TypeScript!' as any)" > secretly-typescript.js
-$ bun run - < secretly-typescript.js
-This is TypeScript!
-```
-
-For convenience, all code is treated as TypeScript with JSX support when using `bun run -`.
-
-## `bun run --console-depth`
-
-Control the depth of object inspection in console output with the `--console-depth` flag.
-
-```bash
-$ bun --console-depth 5 run index.tsx
-```
-
-This sets how deeply nested objects are displayed in `console.log()` output. The default depth is `2`. Higher values show more nested properties but may produce verbose output for complex objects.
-
-```js
-const nested = { a: { b: { c: { d: "deep" } } } };
-console.log(nested);
-// With --console-depth 2 (default): { a: { b: [Object] } }
-// With --console-depth 4: { a: { b: { c: { d: 'deep' } } } }
-```
-
-## `bun run --smol`
-
-In memory-constrained environments, use the `--smol` flag to reduce memory usage at a cost to performance.
-
-```bash
-$ bun --smol run index.tsx
-```
-
-This causes the garbage collector to run more frequently, which can slow down execution. However, it can be useful in environments with limited memory. Bun automatically adjusts the garbage collector's heap size based on the available memory (accounting for cgroups and other memory limits) with and without the `--smol` flag, so this is mostly useful for cases where you want to make the heap size grow more slowly.
-
-## `--user-agent`
-
-**`--user-agent <string>`** - Set User-Agent header for all `fetch()` requests:
-
-```bash
-bun --user-agent "MyBot/1.0" run index.tsx
-```
-
-## Resolution order
-
-Absolute paths and paths starting with `./` or `.\\` are always executed as source files. Unless using `bun run`, running a file with an allowed extension will prefer the file over a package.json script.
-
-When there is a package.json script and a file with the same name, `bun run` prioritizes the package.json script. The full resolution order is:
-
-1. package.json scripts, eg `bun run build`
-2. Source files, eg `bun run src/main.js`
-3. Binaries from project packages, eg `bun add eslint && bun run eslint`
-4. (`bun run` only) System commands, eg `bun run ls`
-
-### `--unhandled-rejections`
-
-Configure how unhandled promise rejections are handled:
-
-```bash
-$ bun --unhandled-rejections=throw script.js  # Throw exception (terminate immediately)
-$ bun --unhandled-rejections=strict script.js # Throw exception (emit rejectionHandled if handled later)
-$ bun --unhandled-rejections=warn script.js   # Print warning to stderr (default in Node.js)
-$ bun --unhandled-rejections=none script.js   # Silently ignore
-```
-
-{% bunCLIUsage command="run" /%}