bun-types 1.3.2-canary.20251104T140728 → 1.3.2-canary.20251106T140813

package/docs/guides/ecosystem/nextjs.md

@@ -1,49 +0,0 @@
----
-name: Build an app with Next.js and Bun
----
-
-Initialize a Next.js app with `create-next-app`. This will scaffold a new Next.js project and automatically install dependencies.
-
-```sh
-$ bun create next-app
-✔ What is your project named? … my-app
-✔ Would you like to use TypeScript with this project? … No / Yes
-✔ Would you like to use ESLint with this project? … No / Yes
-✔ Would you like to use Tailwind CSS? ... No / Yes
-✔ Would you like to use `src/` directory with this project? … No / Yes
-✔ Would you like to use App Router? (recommended) ... No / Yes
-✔ What import alias would you like configured? … @/*
-Creating a new Next.js app in /path/to/my-app.
-```
-
----
-
-You can specify a starter template using the `--example` flag.
-
-```sh
-$ bun create next-app --example with-supabase
-✔ What is your project named? … my-app
-...
-```
-
----
-
-To start the dev server with Bun, run `bun --bun run dev` from the project root.
-
-```sh
-$ cd my-app
-$ bun --bun run dev
-```
-
----
-
-To run the dev server with Node.js instead, omit `--bun`.
-
-```sh
-$ cd my-app
-$ bun run dev
-```
-
----
-
-Open [http://localhost:3000](http://localhost:3000) with your browser to see the result. Any changes you make to `(pages/app)/index.tsx` will be hot-reloaded in the browser.

package/docs/guides/ecosystem/nuxt.md

@@ -1,56 +0,0 @@
----
-name: Build an app with Nuxt and Bun
----
-
-Bun supports [Nuxt](https://nuxt.com) out of the box. Initialize a Nuxt app with official `nuxi` CLI.
-
-```sh
-$ bunx nuxi init my-nuxt-app
-✔ Which package manager would you like to use?
-bun
-◐ Installing dependencies...
-bun install v1.3.2-canary.20251104T140728 (16b4bf34)
- + @nuxt/devtools@0.8.2
- + nuxt@3.7.0
- 785 packages installed [2.67s]
-✔ Installation completed.
-✔ Types generated in .nuxt
-✨ Nuxt project has been created with the v3 template. Next steps:
- › cd my-nuxt-app
- › Start development server with bun run dev
-```
-
----
-
-To start the dev server, run `bun --bun run dev` from the project root. This will execute the `nuxt dev` command (as defined in the `"dev"` script in `package.json`).
-
-{% callout %}
-The `nuxt` CLI uses Node.js by default; passing the `--bun` flag forces the dev server to use the Bun runtime instead.
-{% /callout %}
-
-```
-$ cd my-nuxt-app
-$ bun --bun run dev
- $ nuxt dev
-Nuxi 3.6.5
-Nuxt 3.6.5 with Nitro 2.5.2
-  > Local:    http://localhost:3000/
-  > Network:  http://192.168.0.21:3000/
-  > Network:  http://[fd8a:d31d:481c:4883:1c64:3d90:9f83:d8a2]:3000/
-
-✔ Nuxt DevTools is enabled v0.8.0 (experimental)
-ℹ Vite client warmed up in 547ms
-✔ Nitro built in 244 ms
-```
-
----
-
-Once the dev server spins up, open [http://localhost:3000](http://localhost:3000) to see the app. The app will render Nuxt's built-in `NuxtWelcome` template component.
-
-To start developing your app, replace `<NuxtWelcome />` in `app.vue` with your own UI.
-
-{% image src="https://github.com/oven-sh/bun/assets/3084745/2c683ecc-3298-4bb0-b8c0-cf4cfaea1daa" caption="Demo Nuxt app running on localhost" /%}
-
----
-
-Refer to the [Nuxt website](https://nuxt.com/docs) for complete documentation.

package/docs/guides/ecosystem/pm2.md

@@ -1,57 +0,0 @@
----
-name: Run Bun as a daemon with PM2
----
-
-[PM2](https://pm2.keymetrics.io/) is a popular process manager that manages and runs your applications as daemons (background processes).
-
-It offers features like process monitoring, automatic restarts, and easy scaling. Using a process manager is common when deploying a Bun application on a cloud-hosted virtual private server (VPS), as it:
-
-- Keeps your Node.js application running continuously.
-- Ensure high availability and reliability of your application.
-- Monitor and manage multiple processes with ease.
-- Simplify the deployment process.
-
----
-
-You can use PM2 with Bun in two ways: as a CLI option or in a configuration file.
-
-### With `--interpreter`
-
----
-
-To start your application with PM2 and Bun as the interpreter, open your terminal and run the following command:
-
-```bash
-pm2 start --interpreter ~/.bun/bin/bun index.ts
-```
-
----
-
-### With a configuration file
-
----
-
-Alternatively, you can create a PM2 configuration file. Create a file named `pm2.config.js` in your project directory and add the following content.
-
-```javascript
-module.exports = {
-  name: "app", // Name of your application
-  script: "index.ts", // Entry point of your application
-  interpreter: "bun", // Bun interpreter
-  env: {
-    PATH: `${process.env.HOME}/.bun/bin:${process.env.PATH}`, // Add "~/.bun/bin/bun" to PATH
-  },
-};
-```
-
----
-
-After saving the file, you can start your application with PM2
-
-```bash
-pm2 start pm2.config.js
-```
-
----
-
-That’s it! Your JavaScript/TypeScript web server is now running as a daemon with PM2 using Bun as the interpreter.

package/docs/guides/ecosystem/prisma.md

@@ -1,141 +0,0 @@
----
-name: Use Prisma with Bun
----
-
-{% callout %}
-**Note** — At the moment Prisma needs Node.js to be installed to run certain generation code. Make sure Node.js is installed in the environment where you're running `bunx prisma` commands.
-{% /callout %}
-
----
-
-Prisma works out of the box with Bun. First, create a directory and initialize it with `bun init`.
-
-```bash
-$ mkdir prisma-app
-$ cd prisma-app
-$ bun init
-```
-
----
-
-Then install the Prisma CLI (`prisma`) and Prisma Client (`@prisma/client`) as dependencies.
-
-```bash
-$ bun add -d prisma
-$ bun add @prisma/client
-```
-
----
-
-We'll use the Prisma CLI with `bunx` to initialize our schema and migration directory. For simplicity we'll be using an in-memory SQLite database.
-
-```bash
-$ bunx --bun prisma init --datasource-provider sqlite
-```
-
----
-
-Open `prisma/schema.prisma` and add a simple `User` model.
-
-```prisma-diff#prisma/schema.prisma
-  generator client {
-    provider = "prisma-client-js"
-    output = "../generated/prisma"
-  }
-
-  datasource db {
-    provider = "sqlite"
-    url      = env("DATABASE_URL")
-  }
-
-+ model User {
-+   id    Int     @id @default(autoincrement())
-+   email String  @unique
-+   name  String?
-+ }
-```
-
----
-
-Then generate and run initial migration.
-
-This will generate a `.sql` migration file in `prisma/migrations`, create a new SQLite instance, and execute the migration against the new instance.
-
-```bash
-$ bunx prisma migrate dev --name init
-Environment variables loaded from .env
-Prisma schema loaded from prisma/schema.prisma
-Datasource "db": SQLite database "dev.db" at "file:./dev.db"
-
-SQLite database dev.db created at file:./dev.db
-
-Applying migration `20230928182242_init`
-
-The following migration(s) have been created and applied from new schema changes:
-
-migrations/
-  └─ 20230928182242_init/
-    └─ migration.sql
-
-Your database is now in sync with your schema.
-
-✔ Generated Prisma Client (v6.11.1) to ./generated/prisma in 41ms
-```
-
----
-
-As indicated in the output, Prisma re-generates our _Prisma client_ whenever we execute a new migration. The client provides a fully typed API for reading and writing from our database. You can manually re-generate the client with the Prisma CLI.
-
-```sh
-$ bunx prisma generate
-```
-
----
-
-We can import the generated client from `@prisma/client`.
-
-```ts#src/index.ts
-import {PrismaClient} from "@prisma/client";
-```
-
----
-
-Let's write a simple script to create a new user, then count the number of users in the database.
-
-```ts#index.ts
-import { PrismaClient } from "@prisma/client";
-
-const prisma = new PrismaClient();
-
-// create a new user
-await prisma.user.create({
-  data: {
-    name: "John Dough",
-    email: `john-${Math.random()}@example.com`,
-  },
-});
-
-// count the number of users
-const count = await prisma.user.count();
-console.log(`There are ${count} users in the database.`);
-```
-
----
-
-Let's run this script with `bun run`. Each time we run it, a new user is created.
-
-```bash
-$ bun run index.ts
-Created john-0.12802932895402364@example.com
-There are 1 users in the database.
-$ bun run index.ts
-Created john-0.8671308799782803@example.com
-There are 2 users in the database.
-$ bun run index.ts
-Created john-0.4465968383115295@example.com
-There are 3 users in the database.
-```
-
----
-
-That's it! Now that you've set up Prisma using Bun, we recommend referring to the [official Prisma docs](https://www.prisma.io/docs/concepts/components/prisma-client) as you continue to develop your application.

package/docs/guides/ecosystem/qwik.md

@@ -1,107 +0,0 @@
----
-name: Build an app with Qwik and Bun
----
-
-Initialize a new Qwik app with `bunx create-qwik`.
-
-The `create-qwik` package detects when you are using `bunx` and will automatically install dependencies using `bun`.
-
-```sh
-$ bun create qwik
-
-      ............
-    .::: :--------:.
-   .::::  .:-------:.
-  .:::::.   .:-------.
-  ::::::.     .:------.
- ::::::.        :-----:
- ::::::.       .:-----.
-  :::::::.     .-----.
-   ::::::::..   ---:.
-    .:::::::::. :-:.
-     ..::::::::::::
-             ...::::
-
-
-┌  Let's create a  Qwik App  ✨ (v1.2.10)
-│
-◇  Where would you like to create your new project? (Use '.' or './' for current directory)
-│  ./my-app
-│
-●  Creating new project in  /path/to/my-app  ... 🐇
-│
-◇  Select a starter
-│  Basic App
-│
-◇  Would you like to install bun dependencies?
-│  Yes
-│
-◇  Initialize a new git repository?
-│  No
-│
-◇  Finishing the install. Wanna hear a joke?
-│  Yes
-│
-○  ────────────────────────────────────────────────────────╮
-│                                                          │
-│  How do you know if there’s an elephant under your bed?  │
-│  Your head hits the ceiling!                             │
-│                                                          │
-├──────────────────────────────────────────────────────────╯
-│
-◇  App Created 🐰
-│
-◇  Installed bun dependencies 📋
-│
-○  Result ─────────────────────────────────────────────╮
-│                                                      │
-│  Success!  Project created in my-app directory       │
-│                                                      │
-│  Integrations? Add Netlify, Cloudflare, Tailwind...  │
-│  bun qwik add                                        │
-│                                                      │
-│  Relevant docs:                                      │
-│  https://qwik.builder.io/docs/getting-started/       │
-│                                                      │
-│  Questions? Start the conversation at:               │
-│  https://qwik.builder.io/chat                        │
-│  https://twitter.com/QwikDev                         │
-│                                                      │
-│  Presentations, Podcasts and Videos:                 │
-│  https://qwik.builder.io/media/                      │
-│                                                      │
-│  Next steps:                                         │
-│  cd my-app                                           │
-│  bun start                                           │
-│                                                      │
-│                                                      │
-├──────────────────────────────────────────────────────╯
-│
-└  Happy coding! 🎉
-
-```
-
----
-
-Run `bun run dev` to start the development server.
-
-```sh
-$ bun run dev
-  $ vite--mode ssr
-
-  VITE v4.4.7  ready in 1190 ms
-
-  ➜  Local:   http://localhost:5173/
-  ➜  Network: use --host to expose
-  ➜  press h to show help
-```
-
----
-
-Open [http://localhost:5173](http://localhost:5173) with your browser to see the result. Qwik will hot-reload your app as you edit your source files.
-
-{% image src="https://github.com/oven-sh/bun/assets/3084745/ec35f2f7-03dd-4c90-851e-fb4ad150bb28" alt="Qwik screenshot" /%}
-
----
-
-Refer to the [Qwik docs](https://qwik.builder.io/docs/getting-started/) for complete documentation.

package/docs/guides/ecosystem/react.md

@@ -1,50 +0,0 @@
----
-name: Build a React app with Bun
----
-
-Bun supports `.jsx` and `.tsx` files out of the box. React just works with Bun.
-
-Create a new React app with `bun init --react`. This gives you a template with a simple React app and a simple API server together in one full-stack app.
-
-```bash
-# Create a new React app
-$ bun init --react
-
-# Run the app in development mode
-$ bun dev
-
-# Build as a static site for production
-$ bun run build
-
-# Run the server in production
-$ bun start
-```
-
----
-
-### Hot Reloading
-
-Run `bun dev` to start the app in development mode. This will start the API server and the React app with hot reloading.
-
-### Full-Stack App
-
-Run `bun start` to start the API server and frontend together in one process.
-
-### Static Site
-
-Run `bun run build` to build the app as a static site. This will create a `dist` directory with the built app and all the assets.
-
-```
-├── src/
-│   ├── index.tsx       # Server entry point with API routes
-│   ├── frontend.tsx    # React app entry point with HMR
-│   ├── App.tsx         # Main React component
-│   ├── APITester.tsx   # Component for testing API endpoints
-│   ├── index.html      # HTML template
-│   ├── index.css       # Styles
-│   └── *.svg           # Static assets
-├── package.json        # Dependencies and scripts
-├── tsconfig.json       # TypeScript configuration
-├── bunfig.toml         # Bun configuration
-└── bun.lock            # Lock file
-```

package/docs/guides/ecosystem/remix.md

@@ -1,78 +0,0 @@
----
-name: Build an app with Remix and Bun
----
-
-{% callout %}
-Currently the Remix development server (`remix dev`) relies on Node.js APIs that Bun does not yet implement. The guide below uses Bun to initialize a project and install dependencies, but it uses Node.js to run the dev server.
-{% /callout %}
-
----
-
-Initialize a Remix app with `create-remix`.
-
-```sh
-$ bun create remix
-
- remix   v1.19.3 💿 Let's build a better website...
-
-   dir   Where should we create your new project?
-         ./my-app
-
-      ◼  Using basic template See https://remix.run/docs/en/main/guides/templates#templates for more
-      ✔  Template copied
-
-   git   Initialize a new git repository?
-         Yes
-
-  deps   Install dependencies with bun?
-         Yes
-
-      ✔  Dependencies installed
-
-      ✔  Git initialized
-
-  done   That's it!
-
-         Enter your project directory using cd ./my-app
-         Check out README.md for development and deploy instructions.
-```
-
----
-
-To start the dev server, run `bun run dev` from the project root. This will start the dev server using the `remix dev` command. Note that Node.js will be used to run the dev server.
-
-```sh
-$ cd my-app
-$ bun run dev
-  $ remix dev
-
-  💿  remix dev
-
-  info  building...
-  info  built (263ms)
-  Remix App Server started at http://localhost:3000 (http://172.20.0.143:3000)
-```
-
----
-
-Open [http://localhost:3000](http://localhost:3000) to see the app. Any changes you make to `app/routes/_index.tsx` will be hot-reloaded in the browser.
-
-{% image src="https://github.com/oven-sh/bun/assets/3084745/c26f1059-a5d4-4c0b-9a88-d9902472fd77" caption="Remix app running on localhost" /%}
-
----
-
-To build and start your app, run `bun run build` then `bun run start` from the project root.
-
-```sh
-$ bun run build
- $ remix build
- info  building... (NODE_ENV=production)
- info  built (158ms)
-$ bun start
- $ remix-serve ./build/index.js
- [remix-serve] http://localhost:3000 (http://192.168.86.237:3000)
-```
-
----
-
-Read the [Remix docs](https://remix.run/) for more information on how to build apps with Remix.

package/docs/guides/ecosystem/render.md

@@ -1,79 +0,0 @@
----
-name: Deploy a Bun application on Render
----
-
-[Render](https://render.com/) is a cloud platform that lets you flexibly build, deploy, and scale your apps.
-
-It offers features like auto deploys from GitHub, a global CDN, private networks, automatic HTTPS setup, and managed PostgreSQL and Redis.
-
-Render supports Bun natively. You can deploy Bun apps as web services, background workers, cron jobs, and more.
-
----
-
-As an example, let's deploy a simple Express HTTP server to Render.
-
----
-
-Create a new GitHub repo named `myapp`. Git clone it locally.
-
-```sh
-$ git clone git@github.com:my-github-username/myapp.git
-$ cd myapp
-```
-
----
-
-Add the Express library.
-
-```sh
-$ bun add express
-```
-
----
-
-Define a simple server with Express:
-
-```ts#app.ts
-import express from "express";
-
-const app = express();
-const port = process.env.PORT || 3001;
-
-app.get("/", (req, res) => {
-  res.send("Hello World!");
-});
-
-app.listen(port, () => {
-  console.log(`Listening on port ${port}...`);
-});
-```
-
----
-
-Commit your changes and push to GitHub.
-
-```sh
-$ git add app.ts bun.lock package.json
-$ git commit -m "Create simple Express app"
-$ git push origin main
-```
-
----
-
-In your [Render Dashboard](https://dashboard.render.com/), click `New` > `Web Service` and connect your `myapp` repo.
-
----
-
-In the Render UI, provide the following values during web service creation:
-
-|                   |               |
-| ----------------- | ------------- |
-| **Runtime**       | `Node`        |
-| **Build Command** | `bun install` |
-| **Start Command** | `bun app.ts`  |
-
----
-
-That's it! Your web service will be live at its assigned `onrender.com` URL as soon as the build finishes.
-
-You can view the [deploy logs](https://docs.render.com/logging#logs-for-an-individual-deploy-or-job) for details. Refer to [Render's documentation](https://docs.render.com/deploys) for a complete overview of deploying on Render.

package/docs/guides/ecosystem/sentry.md

@@ -1,52 +0,0 @@
----
-name: Add Sentry to a Bun app
----
-
-[Sentry](https://sentry.io) is a developer-first error tracking and performance monitoring platform. Sentry has a first-class SDK for Bun, `@sentry/bun`, that instruments your Bun application to automatically collect error and performance data.
-
-Don't already have an account and Sentry project established? Head over to [sentry.io](https://sentry.io/signup/), then return to this page.
-
----
-
-To start using Sentry with Bun, first install the Sentry Bun SDK.
-
-```sh
-$ bun add @sentry/bun
-```
-
----
-
-Then, initialize the Sentry SDK with your Sentry DSN in your app's entry file. You can find your DSN in your Sentry project settings.
-
-```js
-import * as Sentry from "@sentry/bun";
-
-// Ensure to call this before importing any other modules!
-Sentry.init({
-  dsn: "__SENTRY_DSN__",
-
-  // Add Performance Monitoring by setting tracesSampleRate
-  // We recommend adjusting this value in production
-  tracesSampleRate: 1.0,
-});
-```
-
----
-
-You can verify that Sentry is working by capturing a test error:
-
-```js
-setTimeout(() => {
-  try {
-    foo();
-  } catch (e) {
-    Sentry.captureException(e);
-  }
-}, 99);
-```
-
-To view and resolve the recorded error, log into [sentry.io](https://sentry.io/) and open your project. Clicking on the error's title will open a page where you can see detailed information and mark it as resolved.
-
----
-
-To learn more about Sentry and using the Sentry Bun SDK, view the [Sentry documentation](https://docs.sentry.io/platforms/javascript/guides/bun).