bun-types 1.3.2-canary.20251105T140650 → 1.3.2

package/docs/{api/udp.md → runtime/networking/udp.mdx}

@@ -1,4 +1,7 @@
-Use Bun's UDP API to implement services with advanced real-time requirements, such as voice chat.
+---
+title: UDP
+description: Use Bun's UDP API to implement services with advanced real-time requirements, such as voice chat.
+---
 
 ## Bind a UDP socket (`Bun.udpSocket()`)
 
@@ -13,8 +16,9 @@ Specify a port:
 
 ```ts
 const socket = await Bun.udpSocket({
-  port: 41234,
+  port: 41234, // [!code ++]
 });
+
 console.log(socket.port); // 41234
 ```
 
@@ -33,7 +37,7 @@ DNS resolution, as it is intended for low-latency operations.
 
 When creating your socket, add a callback to specify what should be done when packets are received:
 
-```ts
+```ts server.ts icon="/icons/typescript.svg"
 const server = await Bun.udpSocket({
   socket: {
     data(socket, buf, port, addr) {
@@ -53,7 +57,7 @@ While UDP does not have a concept of a connection, many UDP communications (espe
 In such cases it can be beneficial to connect the socket to that peer, which specifies to which address all packets are sent
 and restricts incoming packets to that peer only.
 
-```ts
+```ts server.ts icon="/icons/typescript.svg"
 const server = await Bun.udpSocket({
   socket: {
     data(socket, buf, port, addr) {
@@ -62,6 +66,7 @@ const server = await Bun.udpSocket({
     },
   },
 });
+
 const client = await Bun.udpSocket({
   connect: {
     port: server.port,
@@ -82,21 +87,23 @@ of making a system call for each. This is made possible by the `sendMany()` API:
 For an unconnected socket, `sendMany` takes an array as its only argument. Each set of three array elements describes a packet:
 The first item is the data to be sent, the second is the target port, and the last is the target address.
 
-```ts
+```ts server.ts icon="/icons/typescript.svg"
 const socket = await Bun.udpSocket({});
+
 // sends 'Hello' to 127.0.0.1:41234, and 'foo' to 1.1.1.1:53 in a single operation
 socket.sendMany(["Hello", 41234, "127.0.0.1", "foo", 53, "1.1.1.1"]);
 ```
 
 With a connected socket, `sendMany` simply takes an array, where each element represents the data to be sent to the peer.
 
-```ts
+```ts server.ts icon="/icons/typescript.svg"
 const socket = await Bun.udpSocket({
   connect: {
     port: 41234,
     hostname: "localhost",
   },
 });
+
 socket.sendMany(["foo", "bar", "baz"]);
 ```
 
@@ -109,8 +116,7 @@ It may happen that a packet that you're sending does not fit into the operating
 has happened when:
 
 - `send` returns `false`
-- `sendMany` returns a number smaller than the number of packets you specified
-  In this case, the `drain` socket handler will be called once the socket becomes writable again:
+- `sendMany` returns a number smaller than the number of packets you specified. In this case, the `drain` socket handler will be called once the socket becomes writable again:
 
 ```ts
 const socket = await Bun.udpSocket({

package/docs/{api/node-api.md → runtime/node-api.mdx}

@@ -1,3 +1,8 @@
+---
+title: Node-API
+description: Use Bun's Node-API module to build native add-ons to Node.js
+---
+
 Node-API is an interface for building native add-ons to Node.js. Bun implements 95% of this interface from scratch, so most existing Node-API extensions will work with Bun out of the box. Track the completion status of it in [this issue](https://github.com/oven-sh/bun/issues/158).
 
 As in Node.js, `.node` files (Node-API modules) can be required directly in Bun.

package/docs/runtime/{nodejs-apis.md → nodejs-compat.mdx}

@@ -1,3 +1,8 @@
+---
+title: "Node.js Compatibility"
+description: "Bun's compatibility status with Node.js APIs, modules, and globals"
+---
+
 Every day, Bun gets closer to 100% Node.js API compatibility. Today, popular frameworks like Next.js, Express, and millions of `npm` packages intended for Node just work with Bun. To ensure compatibility, we run thousands of tests from Node.js' test suite before every release of Bun.
 
 **If a package works in Node.js but doesn't work in Bun, we consider it a bug in Bun.** Please [open an issue](https://bun.com/issues) and we'll fix it.
@@ -96,7 +101,7 @@ This page is updated regularly to reflect compatibility status of the latest ver
 
 ### [`node:child_process`](https://nodejs.org/api/child_process.html)
 
-🟡 Missing `proc.gid` `proc.uid`. `Stream` class not exported. IPC cannot send socket handles. Node.js <> Bun IPC can be used with JSON serialization.
+🟡 Missing `proc.gid` `proc.uid`. `Stream` class not exported. IPC cannot send socket handles. Node.js ↔ Bun IPC can be used with JSON serialization.
 
 ### [`node:cluster`](https://nodejs.org/api/cluster.html)
 
@@ -116,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`](https://bun.com/docs/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`](/runtime/plugins) in the meantime.
 
 ### [`node:net`](https://nodejs.org/api/net.html)
 
@@ -144,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`](https://bun.com/docs/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`](/project/benchmarking#bunjsc) instead.
 
 ### [`node:vm`](https://nodejs.org/api/vm.html)
 
@@ -172,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`](https://bun.com/docs/cli/test) instead.
+🟡 Partly implemented. Missing mocks, snapshots, timers. Use [`bun:test`](/test) instead.
 
 ### [`node:trace_events`](https://nodejs.org/api/tracing.html)
 

package/docs/{bundler/plugins.md → runtime/plugins.mdx}

@@ -1,3 +1,8 @@
+---
+title: "Plugins"
+description: "Universal plugin API for extending Bun's runtime and bundler"
+---
+
 Bun provides a universal plugin API that can be used to extend both the _runtime_ and _bundler_.
 
 Plugins intercept imports and perform custom loading logic: reading files, transpiling code, etc. They can be used to add support for additional file types, like `.scss` or `.yaml`. In the context of Bun's bundler, plugins can be used to implement framework-level features like CSS extraction, macros, and client-server code co-location.
@@ -9,17 +14,15 @@ Plugins can register callbacks to be run at various points in the lifecycle of a
 - [`onStart()`](#onstart): Run once the bundler has started a bundle
 - [`onResolve()`](#onresolve): Run before a module is resolved
 - [`onLoad()`](#onload): Run before a module is loaded.
-- [`onEnd()`](#onend): Run after the bundle has completed
 - [`onBeforeParse()`](#onbeforeparse): Run zero-copy native addons in the parser thread before a file is parsed.
 
 ### Reference
 
 A rough overview of the types (please refer to Bun's `bun.d.ts` for the full type definitions):
 
-```ts
+```ts Plugin Types icon="/icons/typescript.svg"
 type PluginBuilder = {
   onStart(callback: () => void): void;
-  onEnd(callback: (result: BuildOutput) => void | Promise<void>): void;
   onResolve: (
     args: { filter: RegExp; namespace?: string },
     callback: (args: { path: string; importer: string }) => {
@@ -46,7 +49,7 @@ type Loader = "js" | "jsx" | "ts" | "tsx" | "css" | "json" | "toml";
 
 A plugin is defined as simple JavaScript object containing a `name` property and a `setup` function.
 
-```tsx#myPlugin.ts
+```tsx myPlugin.ts icon="/icons/typescript.svg"
 import type { BunPlugin } from "bun";
 
 const myPlugin: BunPlugin = {
@@ -59,7 +62,7 @@ const myPlugin: BunPlugin = {
 
 This plugin can be passed into the `plugins` array when calling `Bun.build`.
 
-```ts
+```ts index.ts icon="/icons/typescript.svg"
 await Bun.build({
   entrypoints: ["./app.ts"],
   outdir: "./out",
@@ -90,7 +93,7 @@ onStart(callback: () => void): Promise<void> | void;
 
 Registers a callback to be run when the bundler starts a new bundle.
 
-```ts
+```ts index.ts icon="/icons/typescript.svg"
 import { plugin } from "bun";
 
 plugin({
@@ -108,7 +111,7 @@ The callback can return a `Promise`. After the bundle process has initialized, t
 
 For example:
 
-```ts
+```ts index.ts icon="/icons/typescript.svg"
 const result = await Bun.build({
   entrypoints: ["./app.ts"],
   outdir: "./dist",
@@ -163,7 +166,7 @@ The callback receives as input the _path_ to the matching module. The callback c
 
 For example, redirecting all imports to `images/` to `./public/images/`:
 
-```ts
+```ts index.ts icon="/icons/typescript.svg"
 import { plugin } from "bun";
 
 plugin({
@@ -208,7 +211,7 @@ The callback can return a new `contents` string for the module as well as a new
 
 For example:
 
-```ts
+```ts index.ts icon="/icons/typescript.svg"
 import { plugin } from "bun";
 
 const envPlugin: BunPlugin = {
@@ -245,7 +248,7 @@ This is useful for returning contents of a module that depends on other modules.
 
 ##### Example: tracking and reporting unused exports
 
-```ts
+```ts index.ts icon="/icons/typescript.svg"
 import { plugin } from "bun";
 
 plugin({
@@ -287,60 +290,13 @@ plugin({
 
 Note that the `.defer()` function currently has the limitation that it can only be called once per `onLoad` callback.
 
-### `onEnd`
-
-```ts
-onEnd(callback: (result: BuildOutput) => void | Promise<void>): void;
-```
-
-Registers a callback to be run when the bundler completes a bundle (whether successful or not).
-
-The callback receives the `BuildOutput` object containing:
-
-- `success`: boolean indicating if the build succeeded
-- `outputs`: array of generated build artifacts
-- `logs`: array of build messages (warnings, errors, etc.)
-
-This is useful for post-processing, cleanup, notifications, or custom error handling.
-
-```ts
-await Bun.build({
-  entrypoints: ["./index.ts"],
-  outdir: "./out",
-  plugins: [
-    {
-      name: "onEnd example",
-      setup(build) {
-        build.onEnd(result => {
-          if (result.success) {
-            console.log(
-              `✅ Build succeeded with ${result.outputs.length} outputs`,
-            );
-          } else {
-            console.error(`❌ Build failed with ${result.logs.length} errors`);
-          }
-        });
-      },
-    },
-  ],
-});
-```
-
-The `onEnd` callbacks are called:
-
-- **Before** the build promise resolves or rejects
-- **After** all bundling is complete
-- **In the order** they were registered
-
-Multiple plugins can register `onEnd` callbacks, and they will all be called sequentially. If an `onEnd` callback returns a promise, the build will wait for it to resolve before continuing.
-
 ## Native plugins
 
 One of the reasons why Bun's bundler is so fast is that it is written in native code and leverages multi-threading to load and parse modules in parallel.
 
 However, one limitation of plugins written in JavaScript is that JavaScript itself is single-threaded.
 
-Native plugins are written as [NAPI](https://bun.com/docs/api/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](/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.
 
@@ -358,14 +314,14 @@ Native plugins are NAPI modules which expose lifecycle hooks as C ABI functions.
 
 To create a native plugin, you must export a C ABI function which matches the signature of the native lifecycle hook you want to implement.
 
-```bash
+```bash terminal icon="terminal"
 bun add -g @napi-rs/cli
 napi new
 ```
 
 Then install this crate:
 
-```bash
+```bash terminal icon="terminal"
 cargo add bun-native-plugin
 ```
 
@@ -374,7 +330,7 @@ will implement our native plugin.
 
 Here's an example implementing the `onBeforeParse` hook:
 
-```rs
+```rs lib.rs icon="/icons/rust.svg"
 use bun_native_plugin::{define_bun_plugin, OnBeforeParse, bun, Result, anyhow, BunLoader};
 use napi_derive::napi;