bun-types 1.3.3 → 1.3.4-canary.20251123T140630

package/docs/runtime/environment-variables.mdx

@@ -13,7 +13,7 @@ Bun reads the following files automatically (listed in order of increasing prece
 - `.env.production`, `.env.development`, `.env.test` (depending on value of `NODE_ENV`)
 - `.env.local`
 
-```txt .env icon="settings"
+```ini .env icon="settings"
 FOO=hello
 BAR=world
 ```
@@ -38,7 +38,7 @@ $env:FOO="helloworld"; bun run dev
 
 <Accordion title="Cross-platform solution with Windows">
 
-For a cross-platform solution, you can use [bun shell](/runtime/shell). For example, the `bun exec` command.
+For a cross-platform solution, you can use [bun shell](/docs/runtime/shell). For example, the `bun exec` command.
 
 ```sh
 bun exec 'FOO=helloworld bun run dev'
@@ -46,7 +46,7 @@ bun exec 'FOO=helloworld bun run dev'
 
 On Windows, `package.json` scripts called with `bun run` will automatically use the **bun shell**, making the following also cross-platform.
 
-```json package.json
+```json package.json icon="file-json"
 "scripts": {
   "dev": "NODE_ENV=development bun --watch app.ts",
 },
@@ -72,13 +72,30 @@ bun --env-file=.env.1 src/index.ts
 bun --env-file=.env.abc --env-file=.env.def run build
 ```
 
+## Disabling automatic `.env` loading
+
+Use `--no-env-file` to disable Bun's automatic `.env` file loading. This is useful in production environments or CI/CD pipelines where you want to rely solely on system environment variables.
+
+```sh
+bun run --no-env-file index.ts
+```
+
+This can also be configured in `bunfig.toml`:
+
+```toml bunfig.toml icon="settings"
+# Disable loading .env files
+env = false
+```
+
+Explicitly provided environment files via `--env-file` will still be loaded even when default loading is disabled.
+
 ---
 
 ## Quotation marks
 
 Bun supports double quotes, single quotes, and template literal backticks:
 
-```txt .env icon="settings"
+```ini .env icon="settings"
 FOO='hello'
 FOO="hello"
 FOO=`hello`
@@ -88,7 +105,7 @@ FOO=`hello`
 
 Environment variables are automatically _expanded_. This means you can reference previously-defined variables in your environment variables.
 
-```txt .env icon="settings"
+```ini .env icon="settings"
 FOO=world
 BAR=hello$FOO
 ```
@@ -99,7 +116,7 @@ process.env.BAR; // => "helloworld"
 
 This is useful for constructing connection strings or other compound values.
 
-```txt .env icon="settings"
+```ini .env icon="settings"
 DB_USER=postgres
 DB_PASSWORD=secret
 DB_HOST=localhost
@@ -109,7 +126,7 @@ DB_URL=postgres://$DB_USER:$DB_PASSWORD@$DB_HOST:$DB_PORT/$DB_NAME
 
 This can be disabled by escaping the `$` with a backslash.
 
-```txt .env icon="settings"
+```ini .env icon="settings"
 FOO=world
 BAR=hello\$FOO
 ```

package/docs/runtime/ffi.mdx

@@ -5,7 +5,7 @@ description: Use Bun's FFI module to efficiently call native libraries from Java
 
 <Warning>
   `bun:ffi` is **experimental**, with known bugs and limitations, and should not be relied on in production. The most
-  stable way to interact with native code from Bun is to write a [Node-API module](/runtime/node-api).
+  stable way to interact with native code from Bun is to write a [Node-API module](/docs/runtime/node-api).
 </Warning>
 
 Use the built-in `bun:ffi` module to efficiently call native libraries from JavaScript. It works with languages that support the C ABI (Zig, Rust, C/C++, C#, Nim, Kotlin, etc).
@@ -313,7 +313,7 @@ When you're done with a JSCallback, you should call `close()` to free the memory
 
 `JSCallback` has experimental support for thread-safe callbacks. This will be needed if you pass a callback function into a different thread from its instantiation context. You can enable it with the optional `threadsafe` parameter.
 
-Currently, thread-safe callbacks work best when run from another thread that is running JavaScript code, i.e. a [`Worker`](/runtime/workers). A future version of Bun will enable them to be called from any thread (such as new threads spawned by your native library that Bun is not aware of).
+Currently, thread-safe callbacks work best when run from another thread that is running JavaScript code, i.e. a [`Worker`](/docs/runtime/workers). A future version of Bun will enable them to be called from any thread (such as new threads spawned by your native library that Bun is not aware of).
 
 ```ts
 const searchIterator = new JSCallback((ptr, length) => /hello/.test(new CString(ptr, length)), {

package/docs/runtime/file-io.mdx

@@ -5,7 +5,7 @@ description: Bun provides a set of optimized APIs for reading and writing files.
 
 <Note>
 
-The `Bun.file` and `Bun.write` APIs documented on this page are heavily optimized and represent the recommended way to perform file-system tasks using Bun. For operations that are not yet available with `Bun.file`, such as `mkdir` or `readdir`, you can use Bun's [nearly complete](/runtime/nodejs-compat#node-fs) implementation of the [`node:fs`](https://nodejs.org/api/fs.html) module.
+The `Bun.file` and `Bun.write` APIs documented on this page are heavily optimized and represent the recommended way to perform file-system tasks using Bun. For operations that are not yet available with `Bun.file`, such as `mkdir` or `readdir`, you can use Bun's [nearly complete](/docs/runtime/nodejs-compat#node-fs) implementation of the [`node:fs`](https://nodejs.org/api/fs.html) module.
 
 </Note>
 
@@ -263,7 +263,7 @@ bun ./cat.ts ./path-to-file
 
 It runs 2x faster than GNU `cat` for large files on Linux.
 
-<Frame>![Cat screenshot](/images/cat.jpg)</Frame>
+<Frame>![Cat screenshot](https://bun.com/images/cat.jpg)</Frame>
 
 ---
 

package/docs/runtime/file-types.mdx

@@ -7,7 +7,7 @@ The Bun bundler implements a set of default loaders out of the box. As a rule of
 
 `.js` `.cjs` `.mjs` `.mts` `.cts` `.ts` `.tsx` `.jsx` `.css` `.json` `.jsonc` `.toml` `.yaml` `.yml` `.txt` `.wasm` `.node` `.html` `.sh`
 
-Bun uses the file extension to determine which built-in _loader_ should be used to parse the file. Every loader has a name, such as `js`, `tsx`, or `json`. These names are used when building [plugins](/bundler/plugins) that extend Bun with custom loaders.
+Bun uses the file extension to determine which built-in _loader_ should be used to parse the file. Every loader has a name, such as `js`, `tsx`, or `json`. These names are used when building [plugins](/docs/bundler/plugins) that extend Bun with custom loaders.
 
 You can explicitly specify which loader to use using the `'type'` import attribute.
 
@@ -251,7 +251,7 @@ In the bundler, `.node` files are handled using the [`file`](#file) loader.
 
 **SQLite loader**. `with { "type": "sqlite" }` import attribute
 
-In the runtime and bundler, SQLite databases can be directly imported. This will load the database using [`bun:sqlite`](/runtime/sqlite).
+In the runtime and bundler, SQLite databases can be directly imported. This will load the database using [`bun:sqlite`](/docs/runtime/sqlite).
 
 ```ts
 import db from "./my.db" with { type: "sqlite" };
@@ -268,7 +268,7 @@ You can change this behavior with the `"embed"` attribute:
 import db from "./my.db" with { type: "sqlite", embed: "true" };
 ```
 
-When using a [standalone executable](/bundler/executables), the database is embedded into the single-file executable.
+When using a [standalone executable](/docs/bundler/executables), the database is embedded into the single-file executable.
 
 Otherwise, the database to embed is copied into the `outdir` with a hashed filename.
 
@@ -356,7 +356,7 @@ The `html` loader behaves differently depending on how it's used:
 
 **CSS loader**. Default for `.css`.
 
-CSS files can be directly imported. This is primarily useful for [full-stack applications](/bundler/html-static) where CSS is bundled alongside HTML.
+CSS files can be directly imported. This is primarily useful for [full-stack applications](/docs/bundler/html-static) where CSS is bundled alongside HTML.
 
 ```ts
 import "./styles.css";
@@ -368,7 +368,7 @@ There isn't any value returned from the import, it's only used for side effects.
 
 **Bun Shell loader**. Default for `.sh` files
 
-This loader is used to parse [Bun Shell](/runtime/shell) scripts. It's only supported when starting Bun itself, so it's not available in the bundler or in the runtime.
+This loader is used to parse [Bun Shell](/docs/runtime/shell) scripts. It's only supported when starting Bun itself, so it's not available in the bundler or in the runtime.
 
 ```sh
 bun run ./script.sh

package/docs/runtime/globals.mdx

@@ -11,7 +11,7 @@ Bun implements the following globals.
 | [`AbortSignal`](https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal)                                           | Web            |                                                                                                                                                                                                                                               |
 | [`alert`](https://developer.mozilla.org/en-US/docs/Web/API/Window/alert)                                                | Web            | Intended for command-line tools                                                                                                                                                                                                               |
 | [`Blob`](https://developer.mozilla.org/en-US/docs/Web/API/Blob)                                                         | Web            |                                                                                                                                                                                                                                               |
-| [`Buffer`](https://nodejs.org/api/buffer.html#class-buffer)                                                             | Node.js        | See [Node.js > `Buffer`](/runtime/nodejs-compat#node-buffer)                                                                                                                                                                                  |
+| [`Buffer`](https://nodejs.org/api/buffer.html#class-buffer)                                                             | Node.js        | See [Node.js > `Buffer`](/docs/runtime/nodejs-compat#node-buffer)                                                                                                                                                                                  |
 | `Bun`                                                                                                                   | Bun            | Subject to change as additional APIs are added                                                                                                                                                                                                |
 | [`ByteLengthQueuingStrategy`](https://developer.mozilla.org/en-US/docs/Web/API/ByteLengthQueuingStrategy)               | Web            |                                                                                                                                                                                                                                               |
 | [`confirm`](https://developer.mozilla.org/en-US/docs/Web/API/Window/confirm)                                            | Web            | Intended for command-line tools                                                                                                                                                                                                               |
@@ -34,15 +34,15 @@ Bun implements the following globals.
 | [`exports`](https://nodejs.org/api/globals.html#exports)                                                                | Node.js        |                                                                                                                                                                                                                                               |
 | [`fetch`](https://developer.mozilla.org/en-US/docs/Web/API/fetch)                                                       | Web            |                                                                                                                                                                                                                                               |
 | [`FormData`](https://developer.mozilla.org/en-US/docs/Web/API/FormData)                                                 | Web            |                                                                                                                                                                                                                                               |
-| [`global`](https://nodejs.org/api/globals.html#global)                                                                  | Node.js        | See [Node.js > `global`](/runtime/nodejs-compat#global).                                                                                                                                                                                      |
+| [`global`](https://nodejs.org/api/globals.html#global)                                                                  | Node.js        | See [Node.js > `global`](/docs/runtime/nodejs-compat#global).                                                                                                                                                                                      |
 | [`globalThis`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/globalThis)             | Cross-platform | Aliases to `global`                                                                                                                                                                                                                           |
 | [`Headers`](https://developer.mozilla.org/en-US/docs/Web/API/Headers)                                                   | Web            |                                                                                                                                                                                                                                               |
-| [`HTMLRewriter`](/runtime/html-rewriter)                                                                                | Cloudflare     |                                                                                                                                                                                                                                               |
+| [`HTMLRewriter`](/docs/runtime/html-rewriter)                                                                                | Cloudflare     |                                                                                                                                                                                                                                               |
 | [`JSON`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON)                         | Web            |                                                                                                                                                                                                                                               |
 | [`MessageEvent`](https://developer.mozilla.org/en-US/docs/Web/API/MessageEvent)                                         | Web            |                                                                                                                                                                                                                                               |
 | [`module`](https://nodejs.org/api/globals.html#module)                                                                  | Node.js        |                                                                                                                                                                                                                                               |
 | [`performance`](https://developer.mozilla.org/en-US/docs/Web/API/performance)                                           | Web            |                                                                                                                                                                                                                                               |
-| [`process`](https://nodejs.org/api/process.html)                                                                        | Node.js        | See [Node.js > `process`](/runtime/nodejs-compat#node-process)                                                                                                                                                                                |
+| [`process`](https://nodejs.org/api/process.html)                                                                        | Node.js        | See [Node.js > `process`](/docs/runtime/nodejs-compat#node-process)                                                                                                                                                                                |
 | [`prompt`](https://developer.mozilla.org/en-US/docs/Web/API/Window/prompt)                                              | Web            | Intended for command-line tools                                                                                                                                                                                                               |
 | [`queueMicrotask()`](https://developer.mozilla.org/en-US/docs/Web/API/queueMicrotask)                                   | Web            |                                                                                                                                                                                                                                               |
 | [`ReadableByteStreamController`](https://developer.mozilla.org/en-US/docs/Web/API/ReadableByteStreamController)         | Web            |                                                                                                                                                                                                                                               |

package/docs/runtime/http/error-handling.mdx

@@ -16,7 +16,7 @@ Bun.serve({
 
 In development mode, Bun will surface errors in-browser with a built-in error page.
 
-<Frame>![Bun's built-in 500 page](/images/exception_page.png)</Frame>
+<Frame>![Bun's built-in 500 page](https://bun.com/images/exception_page.png)</Frame>
 
 ### `error` callback
 
@@ -37,4 +37,4 @@ Bun.serve({
 });
 ```
 
-<Info>[Learn more about debugging in Bun](/runtime/debugger)</Info>
+<Info>[Learn more about debugging in Bun](/docs/runtime/debugger)</Info>

package/docs/runtime/http/routing.mdx

@@ -102,7 +102,7 @@ Bun.serve({
 
 TypeScript parses route parameters when passed as a string literal, so that your editor will show autocomplete when accessing `request.params`.
 
-```ts title="index.ts"
+```ts title="index.ts" icon="/icons/typescript.svg"
 import type { BunRequest } from "bun";
 
 Bun.serve({

package/docs/runtime/http/server.mdx

@@ -32,12 +32,8 @@ const server = Bun.serve({
     // Redirect from /blog/hello to /blog/hello/world
     "/blog/hello": Response.redirect("/blog/hello/world"),
 
-    // Serve a file by buffering it in memory
-    "/favicon.ico": new Response(await Bun.file("./favicon.ico").bytes(), {
-      headers: {
-        "Content-Type": "image/x-icon",
-      },
-    }),
+    // Serve a file by lazily loading it into memory
+    "/favicon.ico": Bun.file("./favicon.ico"),
   },
 
   // (optional) fallback for unmatched routes:
@@ -70,9 +66,9 @@ Bun.serve({
 });
 ```
 
-HTML imports don't just serve HTML — it's a full-featured frontend bundler, transpiler, and toolkit built using Bun's [bundler](/bundler), JavaScript transpiler and CSS parser. You can use this to build full-featured frontends with React, TypeScript, Tailwind CSS, and more.
+HTML imports don't just serve HTML — it's a full-featured frontend bundler, transpiler, and toolkit built using Bun's [bundler](/docs/bundler), JavaScript transpiler and CSS parser. You can use this to build full-featured frontends with React, TypeScript, Tailwind CSS, and more.
 
-For a complete guide on building full-stack applications with HTML imports, including detailed examples and best practices, see [/docs/bundler/fullstack](/bundler/fullstack).
+For a complete guide on building full-stack applications with HTML imports, including detailed examples and best practices, see [/docs/bundler/fullstack](/docs/bundler/fullstack).
 
 ---
 
@@ -126,7 +122,7 @@ bun --port=4002 server.ts
 - `BUN_PORT` environment variable
 
 ```sh
-bun_PORT=4002 bun server.ts
+BUN_PORT=4002 bun server.ts
 ```
 
 - `PORT` environment variable

package/docs/runtime/http/websockets.mdx

@@ -174,7 +174,7 @@ Bun.serve({
 
 To connect to this server from the browser, create a new `WebSocket`.
 
-```ts browser.js icon="file-code"
+```js browser.js icon="file-code"
 const socket = new WebSocket("ws://localhost:3000/chat");
 
 socket.addEventListener("message", event => {

package/docs/runtime/index.mdx

@@ -94,7 +94,7 @@ 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.
+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](/docs/runtime/shell) to support bash-like syntax and many common commands.
 
 <Note>⚡️ The startup time for `npm run` on Linux is roughly 170ms; with Bun it is `6ms`.</Note>
 
@@ -153,7 +153,7 @@ 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).
+Find more details in the docs page for [filter](/docs/pm/filter#running-scripts-with-filter).
 
 ## `bun run -` to pipe code from stdin
 

package/docs/runtime/jsx.mdx

@@ -19,7 +19,7 @@ console.log(<Component message="Hello world!" />);
 
 ## Configuration
 
-Bun reads your `tsconfig.json` or `jsconfig.json` configuration files to determines how to perform the JSX transform internally. To avoid using either of these, the following options can also be defined in [`bunfig.toml`](/runtime/bunfig).
+Bun reads your `tsconfig.json` or `jsconfig.json` configuration files to determines how to perform the JSX transform internally. To avoid using either of these, the following options can also be defined in [`bunfig.toml`](/docs/runtime/bunfig).
 
 The following compiler options are respected.
 

package/docs/runtime/module-resolution.mdx

@@ -72,13 +72,13 @@ Bun supports both ES modules (`import`/`export` syntax) and CommonJS modules (`r
 
 <CodeGroup>
 
-```ts index.js icon="/icons/typescript.svg"
+```js index.js icon="/icons/javascript.svg"
 const { hello } = require("./hello");
 
 hello();
 ```
 
-```ts hello.js icon="/icons/typescript.svg"
+```js hello.js icon="/icons/javascript.svg"
 function hello() {
   console.log("Hello world!");
 }

package/docs/runtime/networking/fetch.mdx

@@ -273,7 +273,7 @@ const response = await fetch("s3://my-bucket/path/to/object", {
 
 Note: Only PUT and POST methods support request bodies when using S3. For uploads, Bun automatically uses multipart upload for streaming bodies.
 
-You can read more about Bun's S3 support in the [S3](/runtime/s3) documentation.
+You can read more about Bun's S3 support in the [S3](/docs/runtime/s3) documentation.
 
 #### File URLs - `file://`
 
@@ -342,7 +342,7 @@ This will print the request and response headers to your terminal:
 ```sh
 [fetch] > HTTP/1.1 GET http://example.com/
 [fetch] > Connection: keep-alive
-[fetch] > User-Agent: Bun/1.3.2
+[fetch] > User-Agent: Bun/1.3.3
 [fetch] > Accept: */*
 [fetch] > Host: example.com
 [fetch] > Accept-Encoding: gzip, deflate, br, zstd
@@ -388,7 +388,7 @@ dns.prefetch("bun.com");
 
 By default, Bun caches and deduplicates DNS queries in-memory for up to 30 seconds. You can see the cache stats by calling `dns.getCacheStats()`:
 
-To learn more about DNS caching in Bun, see the [DNS caching](/runtime/networking/dns) documentation.
+To learn more about DNS caching in Bun, see the [DNS caching](/docs/runtime/networking/dns) documentation.
 
 ### Preconnect to a host
 
@@ -430,7 +430,7 @@ When the limit is exceeded, the requests are queued and sent as soon as the next
 You can increase the maximum number of simultaneous connections via the `BUN_CONFIG_MAX_HTTP_REQUESTS` environment variable:
 
 ```sh
-bun_CONFIG_MAX_HTTP_REQUESTS=512 bun ./my-script.ts
+BUN_CONFIG_MAX_HTTP_REQUESTS=512 bun ./my-script.ts
 ```
 
 The max value for this limit is currently set to 65,336. The maximum port number is 65,535, so it's quite difficult for any one computer to exceed this limit.

package/docs/runtime/nodejs-compat.mdx

@@ -121,7 +121,7 @@ This page is updated regularly to reflect compatibility status of the latest ver
 
 ### [`node:module`](https://nodejs.org/api/module.html)
 
-🟡 Missing `syncBuiltinESMExports`, `Module#load()`. Overriding `require.cache` is supported for ESM & CJS modules. `module._extensions`, `module._pathCache`, `module._cache` are no-ops. `module.register` is not implemented and we recommend using a [`Bun.plugin`](/runtime/plugins) in the meantime.
+🟡 Missing `syncBuiltinESMExports`, `Module#load()`. Overriding `require.cache` is supported for ESM & CJS modules. `module._extensions`, `module._pathCache`, `module._cache` are no-ops. `module.register` is not implemented and we recommend using a [`Bun.plugin`](/docs/runtime/plugins) in the meantime.
 
 ### [`node:net`](https://nodejs.org/api/net.html)
 
@@ -149,7 +149,7 @@ This page is updated regularly to reflect compatibility status of the latest ver
 
 ### [`node:v8`](https://nodejs.org/api/v8.html)
 
-🟡 `writeHeapSnapshot` and `getHeapSnapshot` are implemented. `serialize` and `deserialize` use JavaScriptCore's wire format instead of V8's. Other methods are not implemented. For profiling, use [`bun:jsc`](/project/benchmarking#bunjsc) instead.
+🟡 `writeHeapSnapshot` and `getHeapSnapshot` are implemented. `serialize` and `deserialize` use JavaScriptCore's wire format instead of V8's. Other methods are not implemented. For profiling, use [`bun:jsc`](/docs/project/benchmarking#javascript-heap-stats) instead.
 
 ### [`node:vm`](https://nodejs.org/api/vm.html)
 
@@ -177,7 +177,7 @@ This page is updated regularly to reflect compatibility status of the latest ver
 
 ### [`node:test`](https://nodejs.org/api/test.html)
 
-🟡 Partly implemented. Missing mocks, snapshots, timers. Use [`bun:test`](/test) instead.
+🟡 Partly implemented. Missing mocks, snapshots, timers. Use [`bun:test`](/docs/test) instead.
 
 ### [`node:trace_events`](https://nodejs.org/api/tracing.html)
 

package/docs/runtime/plugins.mdx

@@ -310,7 +310,7 @@ One of the reasons why Bun's bundler is so fast is that it is written in native
 
 However, one limitation of plugins written in JavaScript is that JavaScript itself is single-threaded.
 
-Native plugins are written as [NAPI](/runtime/node-api) modules and can be run on multiple threads. This allows native plugins to run much faster than JavaScript plugins.
+Native plugins are written as [NAPI](/docs/runtime/node-api) modules and can be run on multiple threads. This allows native plugins to run much faster than JavaScript plugins.
 
 In addition, native plugins can skip unnecessary work such as the UTF-8 -> UTF-16 conversion needed to pass strings to JavaScript.
 

package/docs/runtime/s3.mdx

@@ -451,7 +451,7 @@ If the `S3_*` environment variable is not set, Bun will also check for the `AWS_
 | `bucket`          | `AWS_BUCKET`                  |
 | `sessionToken`    | `AWS_SESSION_TOKEN`           |
 
-These environment variables are read from [`.env` files](/runtime/environment-variables) or from the process environment at initialization time (`process.env` is not used for this).
+These environment variables are read from [`.env` files](/docs/runtime/environment-variables) or from the process environment at initialization time (`process.env` is not used for this).
 
 These defaults are overridden by the options you pass to `s3.file(credentials)`, `new Bun.S3Client(credentials)`, or any of the methods that accept credentials. So if, for example, you use the same credentials for different buckets, you can set the credentials once in your `.env` file and then pass `bucket: "my-bucket"` to the `s3.file()` function without having to specify all the credentials again.
 
@@ -540,7 +540,7 @@ const exists = await client.exists("my-file.txt");
 
 `S3File` instances are created by calling the `S3Client` instance method or the `s3.file()` function. Like `Bun.file()`, `S3File` instances are lazy. They don't refer to something that necessarily exists at the time of creation. That's why all the methods that don't involve network requests are fully synchronous.
 
-```ts Type Reference icon="/icons/typescript.svg"  expandable
+```ts Type Reference icon="/icons/typescript.svg" expandable
 interface S3File extends Blob {
   slice(start: number, end?: number): S3File;
   exists(): Promise<boolean>;
@@ -589,7 +589,7 @@ That means using `S3File` instances with `fetch()`, `Response`, and other web AP
 
 To read a partial range of a file, you can use the `slice` method.
 
-```ts s3.ts icon="/icons/typescript.svg"  highlight={1}
+```ts s3.ts icon="/icons/typescript.svg" highlight={1}
 const partial = s3file.slice(0, 1024);
 
 // Read the partial range as a Uint8Array
@@ -733,7 +733,7 @@ This is equivalent to calling `new S3Client(credentials).list()`.
 
 To check if an S3 file exists, you can use the `S3Client.exists` static method.
 
-```ts s3.ts icon="/icons/typescript.svg"  highlight={11}
+```ts s3.ts icon="/icons/typescript.svg" highlight={11}
 import { S3Client } from "bun";
 
 const credentials = {

package/docs/runtime/secrets.mdx

@@ -10,24 +10,27 @@ Store and retrieve sensitive credentials securely using the operating system's n
 ```typescript index.ts icon="/icons/typescript.svg"
 import { secrets } from "bun";
 
-const githubToken = await secrets.get({
+let githubToken: string | null = await secrets.get({
   service: "my-cli-tool",
   name: "github-token",
 });
 
 if (!githubToken) {
-  const response = await fetch("https://api.github.com/name", {
-    headers: { Authorization: `token ${githubToken}` },
-  });
-  console.log("Please enter your GitHub token");
-} else {
+  githubToken = prompt("Please enter your GitHub token");
+
   await secrets.set({
     service: "my-cli-tool",
     name: "github-token",
-    value: prompt("Please enter your GitHub token"),
+    value: githubToken,
   });
   console.log("GitHub token stored");
 }
+
+const response = await fetch("https://api.github.com/name", {
+  headers: { Authorization: `token ${githubToken}` },
+});
+
+console.log(`Logged in as ${(await response.json()).login}`);
 ```
 
 ---

package/docs/runtime/sql.mdx

@@ -153,16 +153,16 @@ const memory = new SQL(":memory:");
 const memory2 = new SQL("sqlite://:memory:");
 
 // File-based database
-const db = new SQL("sqlite://myapp.db");
+const sql1 = new SQL("sqlite://myapp.db");
 
 // Using options object
-const db2 = new SQL({
+const sql2 = new SQL({
   adapter: "sqlite",
   filename: "./data/app.db",
 });
 
 // For simple filenames, specify adapter explicitly
-const db3 = new SQL("myapp.db", { adapter: "sqlite" });
+const sql3 = new SQL("myapp.db", { adapter: "sqlite" });
 ```
 
 <Accordion title="SQLite Connection String Formats">
@@ -205,7 +205,7 @@ new SQL("sqlite://data.db?mode=rwc"); // Read-write-create mode (default)
 SQLite databases support additional configuration options:
 
 ```ts
-const db = new SQL({
+const sql = new SQL({
   adapter: "sqlite",
   filename: "app.db",
 
@@ -443,7 +443,7 @@ Bun's SQL is lazy, which means it will only start executing when awaited or exec
 You can cancel a query that is currently executing by calling the `cancel()` method on the query object.
 
 ```ts
-const query = await sql`SELECT * FROM users`.execute();
+const query = sql`SELECT * FROM users`.execute();
 setTimeout(() => query.cancel(), 100);
 await query;
 ```
@@ -601,7 +601,7 @@ You can configure your database connection manually by passing options to the SQ
 ```ts
 import { SQL } from "bun";
 
-const db = new SQL({
+const sql = new SQL({
   // Required for MySQL when using options object
   adapter: "mysql",
 
@@ -649,7 +649,7 @@ const db = new SQL({
 ```ts
 import { SQL } from "bun";
 
-const db = new SQL({
+const sql = new SQL({
   // Connection details (adapter is auto-detected as PostgreSQL)
   url: "postgres://user:pass@localhost:5432/dbname",
 
@@ -694,7 +694,7 @@ const db = new SQL({
 ```ts
 import { SQL } from "bun";
 
-const db = new SQL({
+const sql = new SQL({
   // Required for SQLite
   adapter: "sqlite",
   filename: "./data/app.db", // or ":memory:" for in-memory database
@@ -924,7 +924,7 @@ const sql = new SQL("postgres://user:password@localhost/mydb?sslmode=verify-full
 Bun's SQL client automatically manages a connection pool, which is a pool of database connections that are reused for multiple queries. This helps to reduce the overhead of establishing and closing connections for each query, and it also helps to manage the number of concurrent connections to the database.
 
 ```ts
-const db = new SQL({
+const sql = new SQL({
   // Pool configuration
   max: 20, // Maximum 20 concurrent connections
   idleTimeout: 30, // Close idle connections after 30s
@@ -936,7 +936,7 @@ const db = new SQL({
 No connection will be made until a query is made.
 
 ```ts
-const sql = Bun.sql(); // no connection are created
+const sql = Bun.SQL(); // no connection are created
 
 await sql`...`; // pool is started until max is reached (if possible), first available connection is used
 await sql`...`; // previous connection is reused

package/docs/runtime/sqlite.mdx

@@ -86,11 +86,11 @@ import { Database } from "bun:sqlite";
 const strict = new Database(":memory:", { strict: true });
 
 // throws error because of the typo:
-const query = strict.query("SELECT $message;").all({ message: "Hello world" });
+const query = strict.query("SELECT $message;").all({ messag: "Hello world" });
 
 const notStrict = new Database(":memory:");
 // does not throw error:
-notStrict.query("SELECT $message;").all({ message: "Hello world" });
+notStrict.query("SELECT $message;").all({ messag: "Hello world" });
 ```
 
 ### Load via ES module import
@@ -645,15 +645,26 @@ class Database {
           readonly?: boolean;
           create?: boolean;
           readwrite?: boolean;
+          safeIntegers?: boolean;
+          strict?: boolean;
         },
   );
 
-  query<Params, ReturnType>(sql: string): Statement<Params, ReturnType>;
+  prepare<ReturnType, Params>(sql: string): Statement<ReturnType, Params>;
+  query<ReturnType, Params>(sql: string): Statement<ReturnType, Params>;
   run(sql: string, params?: SQLQueryBindings): { lastInsertRowid: number; changes: number };
   exec = this.run;
+
+  transaction(insideTransaction: (...args: any) => void): CallableFunction & {
+    deferred: (...args: any) => void;
+    immediate: (...args: any) => void;
+    exclusive: (...args: any) => void;
+  };
+
+  close(throwOnError?: boolean): void;
 }
 
-class Statement<Params, ReturnType> {
+class Statement<ReturnType, Params> {
   all(params: Params): ReturnType[];
   get(params: Params): ReturnType | undefined;
   run(params: Params): {

package/docs/runtime/templating/create.mdx

@@ -12,7 +12,7 @@ description: Create a new Bun project from a React component, a `create-<templat
 
 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.
 
-If you're looking to create a brand new empty project, use [`bun init`](https://bun.com/docs/cli/init).
+If you're looking to create a brand new empty project, use [`bun init`](/docs/runtime/templating/init).
 
 ## From a React component
 
@@ -46,11 +46,11 @@ $ bun create ./MyComponent.jsx # .tsx also supported
 
 When you run `bun create <component>`, Bun:
 
-1. Uses [Bun's JavaScript bundler](https://bun.com/docs/bundler) to analyze your module graph.
+1. Uses [Bun's JavaScript bundler](/docs/bundler) to analyze your module graph.
 2. Collects all the dependencies needed to run the component.
 3. Scans the exports of the entry point for a React component.
 4. Generates a `package.json` file with the dependencies and scripts needed to run the component.
-5. Installs any missing dependencies using [`bun install --only-missing`](https://bun.com/docs/cli/install).
+5. Installs any missing dependencies using [`bun install --only-missing`](/docs/pm/cli/install).
 6. Generates the following files:
    - `${component}.html`
    - `${component}.client.tsx` (entry point for the frontend)
@@ -63,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 icon="file-code"
+```json package.json icon="file-json"
 {
   "dependencies": {
     "tailwindcss": "^4",

package/docs/runtime/transpiler.mdx

@@ -278,7 +278,7 @@ type Import = {
   // url() in CSS
   | "url-token"
   // The import was injected by Bun
-  | "internal" 
+  | "internal"
   // Entry point (not common)
   | "entry-point-build"
   | "entry-point-run"