Bundle

Production bots should not ship your entire src/ folder. The djs-core build command scans your project, generates a single entry file, and outputs a deployable artifact in dist/.

Quick start

1. Add build scripts

   In your package.json:

   {
     "scripts": {
       "dev": "djs-core dev",
       "build": "djs-core build --bundled",
       "start:prod": "bun dist/index.js"
     }
   }

2. Build

   bun run build

   If you omit flags, the CLI asks which build type you want (bundled, external, compile, or Docker).

3. Run the output

   bun run start:prod

   Or directly:

   bun dist/index.js

What happens during a build?

1. Scan — all handlers under src/interactions/commands, src/components/*, src/events, and optionally src/cron.
2. Generate — a production entry at .djscore/index.ts that imports every route and wires handlers into DjsClient.
3. Bundle — Bun compiles that entry into dist/ (or a native binary with --compile).
4. Copy assets — config.json is copied or embedded when experimental.userConfig is enabled (see below).

Build types

Bundled (recommended)

Everything is inlined into one JavaScript file. Fastest to deploy — copy dist/index.js, set env vars, run with Bun.

djs-core build --bundled
bun dist/index.js

External dependencies

Dependencies from your package.json stay external. A minimal package.json is generated inside dist/.

djs-core build --external
cd dist && bun install && bun start

Native binary

Compiles a standalone executable. Great for distributing a bot without installing Bun on the target machine.

djs-core build --compile
./dist/bot        # Linux/macOS
./dist/bot.exe    # Windows

Docker

Generates a Dockerfile next to the bundle:

djs-core build
# Select "Docker" in the prompt, then:
docker build -t my-bot dist
docker run --env-file .env my-bot

CLI reference

djs-core build [options]

Examples

# Default interactive picker
djs-core build

# Production bundle to custom folder
djs-core build --bundled --outdir release

# Compile without minify (debugging)
djs-core build --compile --no-minify

# Build a monorepo app subfolder
djs-core build --path ./apps/my-bot --bundled

Configuration for production builds

experimental.bundle + userConfig

If you use a config.json for bot-specific settings (prefixes, feature flags, etc.), enable both flags to embed the JSON inside the bundle at build time:

import { defineConfig } from "@djs-core/runtime";

export default defineConfig({
  token: process.env.TOKEN!,
  servers: ["YOUR_GUILD_ID"],
  experimental: {
    userConfig: true,
    bundle: true,
  },
});

With userConfig: true but bundle: false, config.json is copied to dist/ during build and loaded at runtime instead.

Cron tasks in production

Cron handlers under src/cron/ are only included when experimental.cron is true in djs.config.ts. See Cron Tasks.

Project layout after build

my-bot/
├── src/                  # your source (not needed at runtime)
├── djs.config.ts         # needed at build time
├── .djscore/
│   └── index.ts          # generated entry (recreated each build)
└── dist/
    ├── index.js          # bundled output
    ├── bot               # only with --compile
    ├── Dockerfile        # only with Docker build type
    ├── package.json      # only with --external
    └── config.json       # copied when userConfig without bundle

Deployment examples

VPS with Bun

bun run build
TOKEN=xxx bun dist/index.js

Use systemd, pm2, or a process manager to keep the bot alive.

Standalone binary

djs-core build --compile
scp dist/bot user@server:/opt/my-bot/
ssh user@server '/opt/my-bot/bot'

Docker

# Generated by djs-core build (Docker option)
FROM oven/bun:alpine
WORKDIR /app
COPY index.js .
CMD ["bun", "index.js"]

docker build -t my-discord-bot dist
docker run -d --env-file .env --name bot my-discord-bot

dev vs build vs start

Troubleshooting

Build fails after adding a handler — make sure every file under src/interactions/commands, src/components, etc. has a valid default export (Command, Button, EventListener, …).

config.json not found at runtime — enable experimental.userConfig, rebuild, and check that config.json exists at the project root before building.

Binary too large — use --bundled instead of --compile, or --external if you need smaller artifacts with separate node_modules.

Plugin not available in bundle — plugins declared in djs.config.ts are resolved at build time. Run djs-core generate-config-types after changing plugins so types and imports stay in sync.