bun-types 1.3.2-canary.20251105T140650 → 1.3.2

package/docs/guides/binary/{typedarray-to-buffer.md → typedarray-to-buffer.mdx}

@@ -1,5 +1,7 @@
 ---
-name: Convert a Uint8Array to a Buffer
+title: Convert a Uint8Array to a Buffer
+sidebarTitle: "Uint8Array to Buffer"
+mode: center
 ---
 
 The [`Buffer`](https://nodejs.org/api/buffer.html) class extends [`Uint8Array`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array) with a number of additional methods. Use `Buffer.from()` to create a `Buffer` instance from a `Uint8Array`.

package/docs/guides/binary/{typedarray-to-dataview.md → typedarray-to-dataview.mdx}

@@ -1,5 +1,7 @@
 ---
-name: Convert a Uint8Array to a DataView
+title: Convert a Uint8Array to a DataView
+sidebarTitle: "Uint8Array to DataView"
+mode: center
 ---
 
 A [`Uint8Array`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array) is a _typed array_ class, meaning it is a mechanism for viewing data in an underlying `ArrayBuffer`. The following snippet creates a [`DataView`] instance over the same range of data as the `Uint8Array`.

package/docs/guides/binary/{typedarray-to-readablestream.md → typedarray-to-readablestream.mdx}

@@ -1,5 +1,7 @@
 ---
-name: Convert a Uint8Array to a ReadableStream
+title: Convert a Uint8Array to a ReadableStream
+sidebarTitle: "Uint8Array to ReadableStream"
+mode: center
 ---
 
 The naive approach to creating a [`ReadableStream`](https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream) from a [`Uint8Array`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array) is to use the [`ReadableStream`](https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream) constructor and enqueue the entire array as a single chunk. For larger chunks, this may be undesirable as it isn't actually "streaming" the data.

package/docs/guides/binary/{typedarray-to-string.md → typedarray-to-string.mdx}

@@ -1,5 +1,7 @@
 ---
-name: Convert a Uint8Array to a string
+title: Convert a Uint8Array to a string
+sidebarTitle: "Uint8Array to string"
+mode: center
 ---
 
 Bun implements the Web-standard [`TextDecoder`](https://developer.mozilla.org/en-US/docs/Web/API/TextDecoder) class for converting from binary data types like `Uint8Array` and strings.

package/docs/guides/deployment/aws-lambda.mdx

@@ -0,0 +1,204 @@
+---
+title: Deploy a Bun application on AWS Lambda
+sidebarTitle: Deploy on AWS Lambda
+mode: center
+---
+
+[AWS Lambda](https://aws.amazon.com/lambda/) is a serverless compute service that lets you run code without provisioning or managing servers.
+
+In this guide, we will deploy a Bun HTTP server to AWS Lambda using a `Dockerfile`.
+
+<Note>
+	Before continuing, make sure you have:
+
+    	- A Bun application ready for deployment
+    	- An [AWS account](https://aws.amazon.com/)
+    	- [AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-started.html) installed and configured
+    	- [Docker](https://docs.docker.com/get-started/get-docker/) installed and added to your `PATH`
+
+</Note>
+
+---
+
+<Steps>
+	<Step title="Create a new Dockerfile">
+		Make sure you're in the directory containing your project, then create a new `Dockerfile` in the root of your project. This file contains the instructions to initialize the container, copy your local project files into it, install dependencies, and start the application.
+
+    	```docker Dockerfile icon="docker"
+    	# Use the official AWS Lambda adapter image to handle the Lambda runtime
+    	FROM public.ecr.aws/awsguru/aws-lambda-adapter:0.9.0 AS aws-lambda-adapter
+
+    	# Use the official Bun image to run the application
+    	FROM oven/bun:debian AS bun_latest
+
+    	# Copy the Lambda adapter into the container
+    	COPY --from=aws-lambda-adapter /lambda-adapter /opt/extensions/lambda-adapter
+
+    	# Set the port to 8080. This is required for the AWS Lambda adapter.
+    	ENV PORT=8080
+
+    	# Set the work directory to `/var/task`. This is the default work directory for Lambda.
+    	WORKDIR "/var/task"
+
+    	# Copy the package.json and bun.lock into the container
+    	COPY package.json bun.lock ./
+
+    	# Install the dependencies
+    	RUN bun install --production --frozen-lockfile
+
+    	# Copy the rest of the application into the container
+    	COPY . /var/task
+
+    	# Run the application.
+    	CMD ["bun", "index.ts"]
+    	```
+
+    	<Note>
+    		Make sure that the start command corresponds to your application's entry point. This can also be `CMD ["bun", "run", "start"]` if you have a start script in your `package.json`.
+
+    		This image installs dependencies and runs your app with Bun inside a container. If your app doesn't have dependencies, you can omit the `RUN bun install --production --frozen-lockfile` line.
+    	</Note>
+
+    	Create a new `.dockerignore` file in the root of your project. This file contains the files and directories that should be _excluded_ from the container image, such as `node_modules`. This makes your builds faster and smaller:
+
+    	```docker .dockerignore icon="Docker"
+    	node_modules
+    	Dockerfile*
+    	.dockerignore
+    	.git
+    	.gitignore
+    	README.md
+    	LICENSE
+    	.vscode
+    	.env
+    	# Any other files or directories you want to exclude
+    	```
+    </Step>
+    <Step title="Build the Docker image">
+    	Make sure you're in the directory containing your `Dockerfile`, then build the Docker image. In this case, we'll call the image `bun-lambda-demo` and tag it as `latest`.
+
+    	```bash terminal icon="terminal"
+    	# cd /path/to/your/app
+    	docker build --provenance=false --platform linux/amd64 -t bun-lambda-demo:latest .
+    	```
+    </Step>
+    <Step title="Create an ECR repository">
+    	To push the image to AWS Lambda, we first need to create an [ECR repository](https://aws.amazon.com/ecr/) to push the image to.
+
+    	By running the following command, we:
+    	- Create an ECR repository named `bun-lambda-demo` in the `us-east-1` region
+    	- Get the repository URI, and export the repository URI as an environment variable. This is optional, but make the next steps easier.
+
+    	```bash terminal icon="terminal"
+    	export ECR_URI=$(aws ecr create-repository --repository-name bun-lambda-demo --region us-east-1 --query 'repository.repositoryUri' --output text)
+    	echo $ECR_URI
+    	```
+    	```txt
+    	[id].dkr.ecr.us-east-1.amazonaws.com/bun-lambda-demo
+    	```
+
+    	<Note>
+    		If you're using IAM Identity Center (SSO) or have configured AWS CLI with profiles, you'll need to add the `--profile` flag to your AWS CLI commands.
+
+    		For example, if your profile is named `my-sso-app`, use `--profile my-sso-app`. Check your AWS CLI configuration with `aws configure list-profiles` to see available profiles.
+
+    		```bash terminal icon="terminal"
+    		export ECR_URI=$(aws ecr create-repository --repository-name bun-lambda-demo --region us-east-1 --profile my-sso-app --query 'repository.repositoryUri' --output text)
+    		echo $ECR_URI
+    		```
+    	</Note>
+
+    </Step>
+    <Step title="Authenticate with the ECR repository">
+    	Log in to the ECR repository:
+
+    	```bash terminal icon="terminal"
+    	aws ecr get-login-password --region us-east-1 | docker login --username AWS --password-stdin $ECR_URI
+    	```
+    	```txt
+    	Login Succeeded
+    	```
+
+    	<Note>
+    		If using a profile, use the `--profile` flag:
+
+    		```bash terminal icon="terminal"
+    		aws ecr get-login-password --region us-east-1 --profile my-sso-app | docker login --username AWS --password-stdin $ECR_URI
+    		```
+
+    	</Note>
+
+    </Step>
+    <Step title="Tag and push the docker image to the ECR repository">
+    	Make sure you're in the directory containing your `Dockerfile`, then tag the docker image with the ECR repository URI.
+
+    	```bash terminal icon="terminal"
+    	docker tag bun-lambda-demo:latest ${ECR_URI}:latest
+    	```
+
+    	Then, push the image to the ECR repository.
+
+    	```bash terminal icon="terminal"
+    	docker push ${ECR_URI}:latest
+    	```
+    </Step>
+    <Step title="Create an AWS Lambda function">
+    	Go to **AWS Console** > **Lambda** > [**Create Function**](https://us-east-1.console.aws.amazon.com/lambda/home?region=us-east-1#/create/function?intent=authorFromImage) > Select **Container image**
+
+    	<Warning>Make sure you've selected the right region, this URL defaults to `us-east-1`.</Warning>
+
+    	<Frame>
+    	![Create Function](/images/guides/lambda1.png)
+    	</Frame>
+
+    	Give the function a name, like `my-bun-function`.
+    </Step>
+    <Step title="Select the container image">
+    	Then, go to the **Container image URI** section, click on **Browse images**. Select the image we just pushed to the ECR repository.
+
+    	<Frame>
+    	![Select Container Repository](/images/guides/lambda2.png)
+    	</Frame>
+
+    	Then, select the `latest` image, and click on **Select image**.
+
+    	<Frame>
+    	![Select Container Image](/images/guides/lambda3.png)
+    	</Frame>
+    </Step>
+    <Step title="Configure the function">
+    	To get a public URL for the function, we need to go to **Additional configurations** > **Networking** > **Function URL**.
+
+    	Set this to **Enable**, with Auth Type **NONE**.
+
+    	<Frame>
+    		![Set the Function URL](/images/guides/lambda4.png)
+    	</Frame>
+    </Step>
+    <Step title="Create the function">
+    	Click on **Create function** at the bottom of the page, this will create the function.
+
+    	<Frame>
+    		![Create Function](/images/guides/lambda6.png)
+    	</Frame>
+
+    </Step>
+    <Step title="Get the function URL">
+    	Once the function has been created you'll be redirected to the function's page, where you can see the function URL in the **"Function URL"** section.
+
+    	<Frame>
+    		![Function URL](/images/guides/lambda5.png)
+    	</Frame>
+    </Step>
+    <Step title="Test the function">
+    	🥳 Your app is now live! To test the function, you can either go to the **Test** tab, or call the function URL directly.
+
+    	```bash terminal icon="terminal"
+    	curl -X GET https://[your-function-id].lambda-url.us-east-1.on.aws/
+    	```
+    	```txt
+    	Hello from Bun on Lambda!
+    	```
+    </Step>
+
+</Steps>

package/docs/guides/deployment/digital-ocean.mdx

@@ -0,0 +1,161 @@
+---
+title: Deploy a Bun application on DigitalOcean
+sidebarTitle: Deploy on DigitalOcean
+mode: center
+---
+
+[DigitalOcean](https://www.digitalocean.com/) is a cloud platform that provides a range of services for building and deploying applications.
+
+In this guide, we will deploy a Bun HTTP server to DigitalOcean using a `Dockerfile`.
+
+<Note>
+	Before continuing, make sure you have:
+
+    - A Bun application ready for deployment
+    - A [DigitalOcean account](https://www.digitalocean.com/)
+    - [DigitalOcean CLI](https://docs.digitalocean.com/reference/doctl/how-to/install/#step-1-install-doctl) installed and configured
+    - [Docker](https://docs.docker.com/get-started/get-docker/) installed and added to your `PATH`
+
+</Note>
+
+---
+
+<Steps>
+	<Step title="Create a new DigitalOcean Container Registry">
+		Create a new Container Registry to store the Docker image.
+
+    	<Tabs>
+    		<Tab title="Through the DigitalOcean dashboard">
+    			In the DigitalOcean dashboard, go to [**Container Registry**](https://cloud.digitalocean.com/registry), and enter the details for the new registry.
+
+    			<Frame>
+    				![DigitalOcean registry dashboard](/images/guides/digitalocean-7.png)
+    			</Frame>
+
+    			Make sure the details are correct, then click **Create Registry**.
+    		</Tab>
+    		<Tab title="Through the DigitalOcean CLI">
+
+    			```bash terminal icon="terminal"
+    			doctl registry create bun-digitalocean-demo
+    			```
+    			```txt
+    			Name                     Endpoint                                           Region slug
+    			bun-digitalocean-demo    registry.digitalocean.com/bun-digitalocean-demo    sfo2
+    			```
+
+    		</Tab>
+    	</Tabs>
+
+    	You should see the new registry in the [**DigitalOcean registry dashboard**](https://cloud.digitalocean.com/registry):
+
+    	<Frame>
+    		![DigitalOcean registry dashboard](/images/guides/digitalocean-1.png)
+    	</Frame>
+    </Step>
+    <Step title="Create a new Dockerfile">
+    	Make sure you're in the directory containing your project, then create a new `Dockerfile` in the root of your project. This file contains the instructions to initialize the container, copy your local project files into it, install dependencies, and start the application.
+
+    	```docker Dockerfile icon="docker"
+    	# Use the official Bun image to run the application
+    	FROM oven/bun:debian
+
+    	# Set the work directory to `/app`
+    	WORKDIR /app
+
+    	# Copy the package.json and bun.lock into the container
+    	COPY package.json bun.lock ./
+
+    	# Install the dependencies
+    	RUN bun install --production --frozen-lockfile
+
+    	# Copy the rest of the application into the container
+    	COPY . .
+
+    	# Expose the port (DigitalOcean will set PORT env var)
+    	EXPOSE 8080
+
+    	# Run the application
+    	CMD ["bun", "index.ts"]
+    	```
+
+    	<Note>
+    		Make sure that the start command corresponds to your application's entry point. This can also be `CMD ["bun", "run", "start"]` if you have a start script in your `package.json`.
+
+    		This image installs dependencies and runs your app with Bun inside a container. If your app doesn't have dependencies, you can omit the `RUN bun install --production --frozen-lockfile` line.
+    	</Note>
+
+    	Create a new `.dockerignore` file in the root of your project. This file contains the files and directories that should be _excluded_ from the container image, such as `node_modules`. This makes your builds faster and smaller:
+
+    	```docker .dockerignore icon="Docker"
+    	node_modules
+    	Dockerfile*
+    	.dockerignore
+    	.git
+    	.gitignore
+    	README.md
+    	LICENSE
+    	.vscode
+    	.env
+    	# Any other files or directories you want to exclude
+    	```
+    </Step>
+    <Step title="Authenticate Docker with DigitalOcean registry">
+    	Before building and pushing the Docker image, authenticate Docker with the DigitalOcean Container Registry:
+
+    	```bash terminal icon="terminal"
+    	doctl registry login
+    	```
+    	```txt
+    	Successfully authenticated with registry.digitalocean.com
+    	```
+
+    	<Note>
+    		This command authenticates Docker with DigitalOcean's registry using your DigitalOcean credentials. Without this step, the build and push command will fail with a 401 authentication error.
+    	</Note>
+    </Step>
+    <Step title="Build and push the Docker image to the DigitalOcean registry">
+    	Make sure you're in the directory containing your `Dockerfile`, then build and push the Docker image to the DigitalOcean registry in one command:
+
+    	```bash terminal icon="terminal"
+    	docker buildx build --platform=linux/amd64 -t registry.digitalocean.com/bun-digitalocean-demo/bun-digitalocean-demo:latest --push .
+    	```
+
+    	<Note>
+    		If you're building on an ARM Mac (M1/M2), you must use `docker buildx` with `--platform=linux/amd64` to ensure compatibility with DigitalOcean's infrastructure. Using `docker build` without the platform flag will create an ARM64 image that won't run on DigitalOcean.
+    	</Note>
+
+    	Once the image is pushed, you should see it in the [**DigitalOcean registry dashboard**](https://cloud.digitalocean.com/registry):
+
+    	<Frame>
+    		![DigitalOcean registry dashboard](/images/guides/digitalocean-2.png)
+    	</Frame>
+    </Step>
+    <Step title="Create a new DigitalOcean App Platform project">
+    	In the DigitalOcean dashboard, go to [**App Platform**](https://cloud.digitalocean.com/apps) > **Create App**. We can create a project directly from the container image.
+
+    	<Frame>
+    		![DigitalOcean App Platform project dashboard](/images/guides/digitalocean-3.png)
+    	</Frame>
+
+    	Make sure the details are correct, then click **Next**.
+
+    	<Frame>
+    		![DigitalOcean App Platform service dashboard](/images/guides/digitalocean-4.png)
+    	</Frame>
+
+    	Review and configure resource settings, then click **Create app**.
+
+    	<Frame>
+    		![DigitalOcean App Platform service dashboard](/images/guides/digitalocean-6.png)
+    	</Frame>
+    </Step>
+    <Step title="Visit your live application">
+    	🥳 Your app is now live! Once the app is created, you should see it in the App Platform dashboard with the public URL.
+
+    	<Frame>
+    		![DigitalOcean App Platform app dashboard](/images/guides/digitalocean-5.png)
+    	</Frame>
+    </Step>
+
+</Steps>

package/docs/guides/deployment/google-cloud-run.mdx

@@ -0,0 +1,197 @@
+---
+title: Deploy a Bun application on Google Cloud Run
+sidebarTitle: Deploy on Google Cloud Run
+mode: center
+---
+
+[Google Cloud Run](https://cloud.google.com/run) is a managed platform for deploying and scaling serverless applications. Google handles the infrastructure for you.
+
+In this guide, we will deploy a Bun HTTP server to Google Cloud Run using a `Dockerfile`.
+
+<Note>
+	Before continuing, make sure you have:
+
+    - A Bun application ready for deployment
+    - A [Google Cloud account](https://cloud.google.com/) with billing enabled
+    - [Google Cloud CLI](https://cloud.google.com/sdk/docs/install) installed and configured
+
+</Note>
+
+---
+
+<Steps> 
+<Step title={<span>Initialize <code>gcloud</code> by select/creating a project</span>}>
+
+Make sure that you've initialized the Google Cloud CLI. This command logs you in, and prompts you to either select an existing project or create a new one.
+
+For more help with the Google Cloud CLI, see the [official documentation](https://docs.cloud.google.com/sdk/gcloud/reference/init).
+
+```bash terminal icon="terminal"
+gcloud init
+```
+
+```txt
+Welcome! This command will take you through the configuration of gcloud.
+
+You must sign in to continue. Would you like to sign in (Y/n)? Y
+You are signed in as [email@example.com].
+
+Pick cloud project to use:
+ [1] existing-bun-app-1234
+ [2] Enter a project ID
+ [3] Create a new project
+Please enter numeric choice or text value (must exactly match list item): 3
+
+Enter a Project ID. my-bun-app
+Your current project has been set to: [my-bun-app]
+
+The Google Cloud CLI is configured and ready to use!
+```
+
+</Step>
+<Step title="(Optional) Store your project info in environment variables">
+Set variables for your project ID and number so they're easier to reuse in the following steps.
+
+```bash terminal icon="terminal"
+PROJECT_ID=$(gcloud projects list --format='value(projectId)' --filter='name="my bun app"')
+PROJECT_NUMBER=$(gcloud projects list --format='value(projectNumber)' --filter='name="my bun app"')
+
+echo $PROJECT_ID $PROJECT_NUMBER
+```
+
+```txt
+my-bun-app-... [PROJECT_NUMBER]
+```
+
+</Step> 
+<Step title="Link a billing account">
+List your available billing accounts and link one to your project:
+
+```bash terminal icon="terminal"
+gcloud billing accounts list
+```
+
+```txt
+ACCOUNT_ID            NAME                OPEN  MASTER_ACCOUNT_ID
+[BILLING_ACCOUNT_ID]  My Billing Account  True
+```
+
+Link your billing account to your project. Replace `[BILLING_ACCOUNT_ID]` with the ID of your billing account.
+
+```bash terminal icon="terminal"
+gcloud billing projects link $PROJECT_ID --billing-account=[BILLING_ACCOUNT_ID]
+```
+
+```txt
+billingAccountName: billingAccounts/[BILLING_ACCOUNT_ID]
+billingEnabled: true
+name: projects/my-bun-app-.../billingInfo
+projectId: my-bun-app-...
+```
+
+</Step> 
+<Step title="Enable APIs and configure IAM roles"> 
+Activate the necessary services and grant Cloud Build permissions:
+
+```bash terminal icon="terminal"
+gcloud services enable run.googleapis.com cloudbuild.googleapis.com
+gcloud projects add-iam-policy-binding $PROJECT_ID \
+  --member=serviceAccount:$PROJECT_NUMBER-compute@developer.gserviceaccount.com \
+  --role=roles/run.builder
+```
+
+<Note>  
+These commands enable Cloud Run (`run.googleapis.com`) and Cloud Build (`cloudbuild.googleapis.com`), which are required for deploying from source. Cloud Run runs your containerized app, while Cloud Build handles building and packaging it.
+
+The IAM binding grants the Compute Engine service account (`$PROJECT_NUMBER-compute@developer.gserviceaccount.com`) permission to build and deploy images on your behalf.
+
+</Note>
+
+</Step>
+<Step title="Add a Dockerfile">
+Create a new `Dockerfile` in the root of your project. This file contains the instructions to initialize the container, copy your local project files into it, install dependencies, and start the application.
+
+```docker Dockerfile icon="docker"
+# Use the official Bun image to run the application
+FROM oven/bun:latest
+
+# Copy the package.json and bun.lock into the container
+COPY package.json bun.lock ./
+
+# Install the dependencies
+# Install the dependencies
+RUN bun install --production --frozen-lockfile
+
+# Copy the rest of the application into the container
+COPY . .
+
+# Run the application
+CMD ["bun", "index.ts"]
+```
+
+<Note>
+  Make sure that the start command corresponds to your application's entry point. This can also be `CMD ["bun", "run", "start"]` if you have a start script in your `package.json`.
+
+    This image installs dependencies and runs your app with Bun inside a container. If your app doesn't have dependencies, you can omit the `RUN bun install --production --frozen-lockfile` line.
+
+    This image installs dependencies and runs your app with Bun inside a container. If your app doesn't have dependencies, you can omit the `RUN bun install --production --frozen-lockfile` line.
+
+</Note>
+
+Create a new `.dockerignore` file in the root of your project. This file contains the files and directories that should be _excluded_ from the container image, such as `node_modules`. This makes your builds faster and smaller:
+
+```docker .dockerignore icon="Docker"
+node_modules
+Dockerfile*
+.dockerignore
+.git
+.gitignore
+README.md
+LICENSE
+.vscode
+.env
+# Any other files or directories you want to exclude
+```
+
+</Step>
+<Step title="Deploy your service"> 
+Make sure you're in the directory containing your `Dockerfile`, then deploy directly from your local source:
+
+<Note>
+  Update the `--region` flag to your preferred region. You can also omit this flag to get an interactive prompt to
+  select a region. Update the `--region` flag to your preferred region. You can also omit this flag to get an
+  interactive prompt to select a region.
+</Note>
+
+```bash terminal icon="terminal"
+gcloud run deploy my-bun-app --source . --region=us-west1 --allow-unauthenticated
+```
+
+```txt
+Deploying from source requires an Artifact Registry Docker repository to store built containers. A repository named
+[cloud-run-source-deploy] in region [us-west1] will be created.
+
+Do you want to continue (Y/n)? Y
+
+Building using Dockerfile and deploying container to Cloud Run service [my-bun-app] in project [my-bun-app-...] region [us-west1]
+✓ Building and deploying... Done.
+  ✓ Validating Service...
+  ✓ Uploading sources...
+  ✓ Building Container... Logs are available at [https://console.cloud.google.com/cloud-build/builds...].
+  ✓ Creating Revision...
+  ✓ Routing traffic...
+  ✓ Setting IAM Policy...
+Done.
+Service [my-bun-app] revision [my-bun-app-...] has been deployed and is serving 100 percent of traffic.
+Service URL: https://my-bun-app-....us-west1.run.app
+```
+
+</Step>
+<Step title="Visit your live application">
+
+🎉 Your Bun application is now live!
+
+Visit the Service URL (`https://my-bun-app-....us-west1.run.app`) to confirm everything works as expected.
+
+</Step>
+</Steps>