@podosoft/podokit 0.17.4 → 1.0.2

package/README.md

@@ -1,158 +1,114 @@
 # @podosoft/podokit
 
-**PodoKit** is an opinionated but extensible starter toolkit and CLI for building full-stack TypeScript applications with **NestJS**, **SvelteKit**, **TailwindCSS**, **shadcn-svelte**, **Docker**, and **k3s**.
+PodoKit is an opinionated Bun 1.4.0 full-stack starter and CLI. It generates an
+Elysia API, a SvelteKit web application, PostgreSQL integration through native
+`Bun.SQL`, Tailwind CSS v4, shadcn-svelte, Docker, and k3s assets.
 
-Stop rewriting the same backend bootstrap, frontend setup, environment config, health checks, Docker Compose, and CI every time you start a project. `podo create` gives you a consistent, production-minded foundation in seconds.
+The CLI itself remains Node-compatible, so either `npx` or `bunx` can create and
+maintain projects. Generated PodoKit v1 applications are Bun-only.
 
 ## Quick start
 
 ```bash
 npx @podosoft/podokit create my-app
+# or: bunx @podosoft/podokit create my-app
+
 cd my-app
-npm install
+bun install
 cp .env.example .env
 npx @podosoft/podokit dev watch
 ```
 
-Open **http://my-app.localhost**. The first project starts one user-level
-Traefik gateway on loopback port 80; later projects reuse it and route by
-hostname. Stop this project with `npx @podosoft/podokit dev down`. The traditional
-`npm run dev` loop remains available on web port 5001 and API port 5002.
-
-When run in a terminal, `podo create` lists the templates with descriptions and asks which one (and which package manager) to use. Pass flags (or `--yes`) to skip the prompts.
+Open `http://my-app.localhost`. The first project starts a user-level Traefik
+gateway on loopback port 80; later projects reuse it and route by hostname. Stop
+the project with `podo dev down`.
 
-The `todo` template (`--template todo`) generates a working todo app (SvelteKit UI + NestJS API + PostgreSQL) with Swagger docs:
+The `todo` template generates a working SvelteKit UI, Elysia CRUD API, and
+PostgreSQL persistence:
 
 ![Generated todo app](https://raw.githubusercontent.com/podosoft-dev/podokit/main/docs/images/todo-app.png)
 
 ## Commands
 
-| Command | What it does |
-|---|---|
-| `podo create <name>` | Scaffold a new project from a template |
-| `podo add <module>` | Add a feature module (auth, admin-dashboard, redis, …) to a project |
-| `podo status` | Show the PodoKit version, modules, file tiers, and local edits |
-| `podo diff` | List the PodoKit-managed files you've edited since generation |
-| `podo doctor` | Check framework versions against the supported ranges |
-| `podo locale <command>` | Add, validate, activate, deactivate, or list JSON locales |
-| `podo update [--apply]` | Preview (or apply) what a version update would change |
-| `podo eject <path…>` | Take ownership of a managed file so updates skip it |
-| `podo dev <action>` | Watch, inspect, execute in, or stop a container stack behind the shared `*.localhost` gateway |
-| `podo deploy <action>` | Plan, apply, verify, or roll back an exact-image Helm release |
-
-## Usage
-
-```
+| Command | Purpose |
+| --- | --- |
+| `podo create <name>` | Create a Bun project from `fullstack`, `todo`, or `base`. |
+| `podo add <module>` | Add a composable feature module. |
+| `podo remove <module>` | Remove a module conservatively. |
+| `podo status` | Show the PodoKit version, modules, ownership tiers, and local edits. |
+| `podo diff` | List edited or deleted managed files. |
+| `podo doctor` | Check Bun and framework versions. |
+| `podo locale <command>` | Manage JSON locales. |
+| `podo update [--apply]` | Preview or apply managed template and module updates. |
+| `podo eject <path...>` | Transfer managed files to application ownership. |
+| `podo dev <action>` | Manage the generated development containers. |
+| `podo deploy <action>` | Plan, apply, verify, or roll back an immutable Helm release. |
+
+```text
 podo create <name> [options]
 
 Options:
-  --template <t>   Template to scaffold (default: fullstack-nest-svelte)
-                     - fullstack-nest-svelte : clean NestJS + SvelteKit starter
-                     - todo                  : fullstack + a Todo CRUD example
-                     - base                  : minimal npm workspace
-  --dir <path>     Target directory (default: ./<name>)
-  --pm <name>      Package manager: npm | pnpm | yarn (default: npm)
-  --no-ai          Skip AI agent guidance (AGENTS.md, CLAUDE.md, editor rules)
-  -y, --yes        Skip prompts and accept defaults
-  -h, --help       Show help
+  --template <name>  fullstack (default), todo, or base
+  --dir <path>       Target directory (default: ./<name>)
+  --no-ai            Omit generated AI-agent guidance
+  -y, --yes          Accept defaults without prompts
+  -h, --help         Show help
 ```
 
-Generated projects include agent guidance for AI coding tools — an
-[`AGENTS.md`](https://agents.md) (the open standard), a `CLAUDE.md` that imports
-it, `.cursor`/`.github` pointers, and Claude Code skills under `.claude/skills/`.
-Modules extend `AGENTS.md` as you add them. Use `--no-ai` to skip.
+`--runtime bun` remains an optional explicit selection. Node runtime values,
+`--pm`, and `podo runtime set` are not part of PodoKit v1. Version 1 projects
+deliberately use Bun-specific APIs on the request and data paths.
 
-Fullstack projects also include a deployment skill under `.agents/skills/`
-with a Claude pointer under `.claude/skills/`.
-
-Examples:
+## Modules and updates
 
 ```bash
-# Interactive
-npx @podosoft/podokit create my-app
-
-# Non-interactive, explicit choices
-npx @podosoft/podokit create my-app --template fullstack-nest-svelte --pm pnpm --yes
+podo add auth
+bun install
+bun run --cwd apps/api migrate:all
 
-# Minimal workspace
-npx @podosoft/podokit create my-lib --template base --yes
+podo status
+podo update
+podo update --apply
 ```
 
-## Add features with modules
+Modules overlay files, merge dependencies and environment examples, then wire
+Elysia plugins into `apps/api/src/app.ts`. Generated projects record their
+assembly in `.podokit/`, allowing clean managed files to update and edited files
+to be three-way merged. Application-owned routes, components, and ejected files
+remain untouched.
 
-```bash
-cd my-app
-npx @podosoft/podokit add auth      # full auth (better-auth): email/password, sessions, OAuth, 2FA
-```
-
-`podo add <module>` overlays files, merges dependencies, appends env vars, and wires the module into the NestJS app. Run `podo add` with no argument to list available modules.
+See the [module guide](https://github.com/podosoft-dev/podokit/blob/main/docs/modules.md)
+and [updating guide](https://github.com/podosoft-dev/podokit/blob/main/docs/updating.md).
 
-The **`admin-dashboard`** module adds a ready-made admin console on top of `auth` — login/signup pages, user & session management, an audit log, and a Settings page where OAuth providers, SMTP, and server toggles are configured at runtime (stored encrypted in the DB, applied without a restart):
+## Compatibility boundary
 
-![PodoKit admin dashboard — users](https://raw.githubusercontent.com/podosoft-dev/podokit/main/docs/images/admin-users.png)
+PodoKit v1 does not convert projects generated by PodoKit 0.x. Existing projects
+must pin `@podosoft/podokit@0.17.4` for maintenance. Start a new v1 project when
+adopting the Bun and Elysia architecture.
 
-## Keep your project up to date
+The generated application runtime, builds, migrations, and unit tests all use
+Bun 1.4.0. Playwright remains a Node-based test-tool exception because its
+officially supported runtime is Node; `bunx playwright` respects the package's
+Node shebang.
 
-Every generated project records how it was assembled in a committed `.podokit/`
-directory, so it can receive template and module improvements later without
-losing your work:
-
-```bash
-podo status          # version, modules, and which managed files you've edited
-podo update          # preview what a newer PodoKit version would change
-podo update --apply  # apply it: clean updates are written, your edits are 3-way merged
-```
+## Generated architecture
 
-Files you own (routes, your components, shadcn UI) are never touched. See the
-[updating guide](https://github.com/podosoft-dev/podokit/blob/main/docs/updating.md).
-An exact path handed over with `podo eject` remains owned even if a module also
-declares it managed; if you later move or delete that file, update reports the
-missing owned path instead of recreating it.
-
-## Deploy an immutable release
-
-```bash
-podo deploy init --profile production --context production --host app.example.com
-podo deploy doctor --profile production
-podo deploy plan --profile production --release v1.2.3 --json
-```
-
-Apply and rollback require the exact confirmation hash from a fresh plan.
-PodoKit consumes an existing namespace and Secrets, runs migrations before the
-application rollout, and exposes only the SvelteKit web proxy. See the
-[deployment guide](https://github.com/podosoft-dev/podokit/blob/main/docs/deployment.md).
-
-## What you get (`fullstack-nest-svelte`)
-
-```
+```text
 my-app/
 ├── apps/
-│   ├── api/           # NestJS: config validation, /health, global
-│   │   └── src/       # ValidationPipe, standard error envelope
-│   └── web/           # SvelteKit: Tailwind v4, shadcn-svelte,
-│       └── src/       # typesafe-i18n, server-side API proxy
+│   ├── api/        # Bun + Elysia + native Bun.SQL
+│   └── web/        # SvelteKit + Tailwind CSS v4 + shadcn-svelte
 ├── infra/
-│   ├── docker/        # docker-compose (PostgreSQL, Redis)
-│   └── k3s/           # namespace, deployments, service, ingress, secret example
-├── .env.example
-├── package.json       # npm workspace
-└── README.md
+│   ├── docker/     # PostgreSQL, Redis, and optional services
+│   └── k3s/        # deployments, services, ingress, and examples
+├── tests/          # Playwright API and browser tests
+├── .podokit/       # assembly and managed-file metadata
+└── package.json    # Bun workspace pinned to Bun 1.4.0
 ```
 
-Highlights of the generated app:
-
-- **Backend (NestJS)** — bootstrap with a global `ValidationPipe` and exception filter, typed environment validation, a `/health` endpoint, and a stable `{ success, error: { code, ... } }` response envelope.
-- **Frontend (SvelteKit)** — TailwindCSS v4 (config-less), **shadcn-svelte components preinstalled** (button, input, card, checkbox, label), a typesafe-i18n scaffold, and a **server-side proxy** so the browser never calls the API directly.
-- **Infra** — Docker Compose for local PostgreSQL and Redis, plus example k3s manifests (standard `Ingress`, `secret.example.yaml`).
-
-## Status
-
-PodoKit is early (`0.x`). The CLI and templates work end-to-end, but APIs and templates may change before `1.0`. Feedback and issues are welcome.
-
-## Links
-
-- Repository & issues: https://github.com/podosoft-dev/podokit
-- Changelog: https://github.com/podosoft-dev/podokit/blob/main/CHANGELOG.md
+The API provides typed Elysia validation, a stable error envelope, liveness and
+readiness endpoints, merged OpenAPI documentation, and an executable route
+contract check. Production API and worker images use `oven/bun:1.4.0-alpine`.
 
 ## License
 

package/dist/add.d.ts

@@ -1,3 +1,4 @@
+import { type TemplateVars } from "@podosoft/podokit-template-engine";
 interface Injection {
     file: string;
     marker: string;
@@ -51,7 +52,7 @@ export interface ModuleManifest {
     /** App-relative globs this module's files should own (durably user-editable,
      *  never touched by `podo update`). Merged into the project's ownedGlobs so
      *  they survive lock recompute. Use for public presentation pages a consumer
-     *  restyles, while keeping the module's `$lib` logic managed. */
+     *  restyles, while keeping the module's `#lib` logic managed. */
     ownedGlobs?: string[];
     /** Paths that an existing app may explicitly hand back to this module with
      *  `podo add --adopt`. Broad app-owned route globs are never removed. */
@@ -120,7 +121,7 @@ export declare function listModules(modulesDir: string, projectRoot?: string): {
     name: string;
     description: string;
 }[];
-export declare function readModuleManifest(moduleDir: string): ModuleManifest;
+export declare function readModuleManifest(moduleDir: string, vars?: TemplateVars): ModuleManifest;
 /**
  * Apply a module to an existing generated project: overlay files, merge the
  * target app's package.json dependencies and scripts, append env example lines,

package/dist/add.js

@@ -12,6 +12,7 @@ const node_path_1 = require("node:path");
 const node_module_1 = require("node:module");
 const podokit_template_engine_1 = require("@podosoft/podokit-template-engine");
 const lockfile_1 = require("./lockfile");
+const toolchain_1 = require("./toolchain");
 /** Highest `module.manifest.json` schema version this CLI understands. A package
  *  module declaring a higher version is rejected rather than mis-applied. */
 exports.SUPPORTED_MANIFEST_VERSION = 2;
@@ -168,8 +169,9 @@ function listModules(modulesDir, projectRoot) {
     }
     return [...out].map(([name, description]) => ({ name, description }));
 }
-function readModuleManifest(moduleDir) {
-    return JSON.parse((0, node_fs_1.readFileSync)((0, node_path_1.join)(moduleDir, "module.manifest.json"), "utf8"));
+function readModuleManifest(moduleDir, vars) {
+    const source = (0, node_fs_1.readFileSync)((0, node_path_1.join)(moduleDir, "module.manifest.json"), "utf8");
+    return JSON.parse(vars ? (0, podokit_template_engine_1.renderTokens)(source, vars) : source);
 }
 function readJson(path) {
     return JSON.parse((0, node_fs_1.readFileSync)(path, "utf8"));
@@ -250,14 +252,24 @@ function applyModule(projectRoot, module, modulesDir, applied, adopt) {
         throw new Error(`Unknown module "${module}".${available.length ? ` Available: ${available.join(", ")}.` : ""}`);
     }
     const moduleDir = resolved.dir;
-    const manifest = readModuleManifest(moduleDir);
-    assertManifestVersion(module, manifest);
-    assertRequiredProjectFiles(projectRoot, module, manifest);
-    const requiredApps = new Set([manifest.targetApp, ...Object.keys(manifest.packageOverlays ?? {})]);
+    const rawManifest = readModuleManifest(moduleDir);
+    assertManifestVersion(module, rawManifest);
+    assertRequiredProjectFiles(projectRoot, module, rawManifest);
+    const requiredApps = new Set([
+        rawManifest.targetApp,
+        ...Object.keys(rawManifest.packageOverlays ?? {}),
+    ]);
     const missingApp = [...requiredApps].find((app) => !(0, node_fs_1.existsSync)((0, node_path_1.join)(projectRoot, "apps", app, "package.json")));
     if (missingApp) {
         throw new Error(`This does not look like a PodoKit project: ${(0, node_path_1.join)("apps", missingApp, "package.json")} not found. Run inside a generated project.`);
     }
+    const appName = projectName(projectRoot);
+    const projectManifest = (0, lockfile_1.readManifest)(projectRoot);
+    const vars = {
+        projectName: appName,
+        ...(projectManifest ? (0, toolchain_1.toolchainTemplateVars)(projectManifest.toolchain) : {}),
+    };
+    const manifest = readModuleManifest(moduleDir, vars);
     applied.add(module);
     // 0) apply required modules first (auto-add if missing)
     const added = [];
@@ -277,8 +289,6 @@ function applyModule(projectRoot, module, modulesDir, applied, adopt) {
         adopted.push(...result.adopted);
         touched.push(...result.touched);
     }
-    const appName = projectName(projectRoot);
-    const vars = { projectName: appName };
     // 1) overlay files
     const filesDir = (0, node_path_1.join)(moduleDir, "files");
     if ((0, node_fs_1.existsSync)(filesDir)) {

package/dist/assemble.d.ts

@@ -15,3 +15,5 @@ export interface AssembleOptions {
 }
 /** Assemble the project tree for a template + ordered modules, in memory. */
 export declare function assembleProject(options: AssembleOptions): VfsTree;
+/** Render a Bun-native project template. */
+export declare function renderProjectTemplate(templatesDir: string, template: string, answers: TemplateVars): VfsTree;

package/dist/assemble.js

@@ -1,13 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.assembleProject = assembleProject;
+exports.renderProjectTemplate = renderProjectTemplate;
 const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
 const podokit_template_engine_1 = require("@podosoft/podokit-template-engine");
 const add_1 = require("./add");
-function readManifest(moduleDir) {
-    return JSON.parse((0, node_fs_1.readFileSync)((0, node_path_1.join)(moduleDir, "module.manifest.json"), "utf8"));
-}
 function textOf(tree, path) {
     return String(tree.get(path)?.content ?? "");
 }
@@ -15,7 +13,7 @@ function setText(tree, path, content) {
     tree.set(path, { content, text: true });
 }
 function applyModuleToTree(tree, moduleDir, vars) {
-    const manifest = readManifest(moduleDir);
+    const manifest = (0, add_1.readModuleManifest)(moduleDir, vars);
     // 1) overlay files (module files override the base)
     const filesDir = (0, node_path_1.join)(moduleDir, "files");
     if ((0, node_fs_1.existsSync)(filesDir)) {
@@ -79,7 +77,7 @@ function preserveExternalPackageDependency(tree, projectRoot, packageName) {
 }
 /** Assemble the project tree for a template + ordered modules, in memory. */
 function assembleProject(options) {
-    const tree = (0, podokit_template_engine_1.renderTemplate)((0, node_path_1.join)(options.templatesDir, options.template), options.answers);
+    const tree = renderProjectTemplate(options.templatesDir, options.template, options.answers);
     for (const mod of options.modules) {
         const name = typeof mod === "string" ? mod : (mod.packageName ?? mod.name);
         const resolved = (0, add_1.resolveModule)(name, (0, node_path_1.join)(options.templatesDir, "modules"), options.projectRoot ?? options.templatesDir);
@@ -95,3 +93,18 @@ function assembleProject(options) {
     }
     return tree;
 }
+/** Render a Bun-native project template. */
+function renderProjectTemplate(templatesDir, template, answers) {
+    const tree = template === "todo"
+        ? (0, podokit_template_engine_1.renderTemplate)((0, node_path_1.join)(templatesDir, "fullstack"), answers)
+        : (0, podokit_template_engine_1.renderTemplate)((0, node_path_1.join)(templatesDir, template), answers);
+    if (template === "todo") {
+        for (const [path, file] of (0, podokit_template_engine_1.renderTemplate)((0, node_path_1.join)(templatesDir, template), answers)) {
+            tree.set(path, file);
+        }
+        const appPath = "apps/api/src/app.ts";
+        const appSource = textOf(tree, appPath);
+        setText(tree, appPath, (0, podokit_template_engine_1.insertAtMarker)((0, podokit_template_engine_1.insertAtMarker)(appSource, "// podokit:end:imports", 'import { todoPlugin } from "./todos/todo.plugin";'), "// podokit:end:modules", '{ name: "todo", plugin: todoPlugin },'));
+    }
+    return tree;
+}

package/dist/create.d.ts

@@ -1,17 +1,20 @@
 import { DEFAULT_TEMPLATE } from "./templates";
-export type PackageManager = "npm" | "pnpm" | "yarn";
+import { type Runtime, type Toolchain } from "./toolchain";
+export type PackageManager = "bun";
 export { DEFAULT_TEMPLATE };
 export interface CreateOptions {
     /** Project name; also the default directory name. */
     name: string;
     /** Directory that holds the template sets (each in its own subfolder). */
     templatesDir: string;
-    /** Template subfolder to use. Defaults to `fullstack-nest-svelte`. */
+    /** Public template name. Defaults to `fullstack`. */
     template?: string;
     /** Where to create the project. Defaults to `<cwd>/<name>`. */
     targetDir?: string;
-    /** Package manager recorded in the generated project. Defaults to `npm`. */
+    /** Deprecated compatibility input. PodoKit v1 accepts only Bun. */
     packageManager?: PackageManager;
+    /** Application runtime. PodoKit v1 accepts only Bun. */
+    runtime?: Runtime;
     /** PodoKit version stamped into the lockfile. Defaults to the CLI version. */
     podokitVersion?: string;
     /** Include AI agent guidance (AGENTS.md, CLAUDE.md, editor rules). Defaults to true. */
@@ -19,7 +22,8 @@ export interface CreateOptions {
 }
 export interface CreateResult {
     projectDir: string;
-    packageManager: PackageManager;
+    packageManager: Toolchain["packageManager"];
+    toolchain: Toolchain;
     template: string;
 }
 /** Validate a project name: no path separators, npm-friendly characters. */

package/dist/create.js

@@ -9,6 +9,8 @@ const podokit_template_engine_1 = require("@podosoft/podokit-template-engine");
 const templates_1 = require("./templates");
 Object.defineProperty(exports, "DEFAULT_TEMPLATE", { enumerable: true, get: function () { return templates_1.DEFAULT_TEMPLATE; } });
 const lockfile_1 = require("./lockfile");
+const assemble_1 = require("./assemble");
+const toolchain_1 = require("./toolchain");
 /** AI agent guidance files, removed when scaffolding with `--no-ai`. */
 const AI_ARTIFACTS = [
     "AGENTS.md",
@@ -36,7 +38,7 @@ function create(options) {
     const { name, templatesDir } = options;
     assertValidName(name);
     const template = options.template ?? templates_1.DEFAULT_TEMPLATE;
-    const packageManager = options.packageManager ?? "npm";
+    const toolchain = (0, toolchain_1.resolveToolchain)(options.runtime, options.packageManager);
     const projectDir = options.targetDir
         ? (0, node_path_1.isAbsolute)(options.targetDir)
             ? options.targetDir
@@ -49,17 +51,25 @@ function create(options) {
     if (!(0, node_fs_1.existsSync)(templateDir)) {
         throw new Error(`Template "${template}" not found at ${templateDir}`);
     }
-    const vars = { projectName: name, packageManager };
-    (0, podokit_template_engine_1.copyTemplate)(templateDir, projectDir, vars);
+    const vars = {
+        projectName: name,
+        ...(0, toolchain_1.toolchainTemplateVars)(toolchain),
+    };
+    (0, podokit_template_engine_1.writeTree)((0, assemble_1.renderProjectTemplate)(templatesDir, template, vars), projectDir);
     if (options.ai === false) {
         for (const artifact of AI_ARTIFACTS)
             (0, node_fs_1.rmSync)((0, node_path_1.join)(projectDir, artifact), { recursive: true, force: true });
     }
     (0, lockfile_1.initLockfile)(projectDir, {
         template,
-        packageManager,
-        answers: { projectName: name, packageManager },
+        toolchain,
+        answers: vars,
         version: options.podokitVersion,
     });
-    return { projectDir, packageManager, template };
+    return {
+        projectDir,
+        packageManager: toolchain.packageManager,
+        toolchain,
+        template,
+    };
 }

package/dist/deploy-compose-profile.js

@@ -340,6 +340,7 @@ function initializeComposeProfile(projectRoot, name, options) {
         ...(modules.has("rate-limit")
             ? {
                 RATE_LIMIT_TTL: "60",
+                RATE_LIMIT_KEY_PREFIX: "podokit:rate-limit",
                 RATE_LIMIT_MAX: "300",
                 RATE_LIMIT_AUTH_TTL: "60",
                 RATE_LIMIT_AUTH_MAX: "20",

package/dist/deploy-compose-render.d.ts

@@ -38,11 +38,11 @@ export declare function derivedRuntimeConfig(profile: DockerComposeProfileV1): R
  * the containers instead of leaving stale values running.
  */
 export declare function rolloutStateDigest(profile: DockerComposeProfileV1, secretIdentities: Record<string, string>): string;
-export declare function renderComposeDocument(profile: DockerComposeProfileV1, release: string, images: ComposeImages, stateDigest: string): string;
+export declare function renderComposeDocument(profile: DockerComposeProfileV1, release: string, images: ComposeImages, stateDigest: string, workerCommand?: string[]): string;
 /**
  * The migration runs as its own Compose project so it can be started, waited on,
  * and removed without touching the running application definition.
  */
-export declare function renderMigrationDocument(profile: DockerComposeProfileV1, release: string, images: ComposeImages): string;
+export declare function renderMigrationDocument(profile: DockerComposeProfileV1, release: string, images: ComposeImages, defaultCommand?: string[]): string;
 export declare function defaultComposeImages(profile: DockerComposeProfileV1, release: string): ComposeImages;
 export declare function renderComposeDeployment(projectRoot: string, profileName: string, profile: DockerComposeProfileV1, release: string, resolvedImages?: ComposeImages, stateDigest?: string): ComposeRuntime;

package/dist/deploy-compose-render.js

@@ -11,6 +11,8 @@ const node_crypto_1 = require("node:crypto");
 const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
 const deploy_schema_1 = require("./deploy-schema");
+const lockfile_1 = require("./lockfile");
+const toolchain_1 = require("./toolchain");
 /** The internal port every generated application service listens on. */
 const CONTAINER_PORT = 3000;
 function quote(value) {
@@ -237,7 +239,7 @@ function applicationService(profile, role, image, release, stateDigest, options)
                 "    healthcheck:\n      disable: true\n") +
         labelsBlock(profile, release, stateDigest, "    "));
 }
-function renderComposeDocument(profile, release, images, stateDigest) {
+function renderComposeDocument(profile, release, images, stateDigest, workerCommand = ["bun", "dist/main-worker.js"]) {
     const services = [];
     if (profile.dependencies.postgres.mode === "managed" && images.postgres) {
         services.push(postgresService(profile, images.postgres));
@@ -262,7 +264,7 @@ function renderComposeDocument(profile, release, images, stateDigest) {
         // The worker runs the API image with a different entry point, exactly as the
         // Kubernetes driver does.
         services.push(applicationService(profile, "worker", images.api, release, stateDigest, {
-            command: `["node", "dist/main-worker"]`,
+            command: `[${workerCommand.map((part) => quote(part)).join(", ")}]`,
         }));
     }
     const volumes = [
@@ -286,8 +288,8 @@ function renderComposeDocument(profile, release, images, stateDigest) {
  * The migration runs as its own Compose project so it can be started, waited on,
  * and removed without touching the running application definition.
  */
-function renderMigrationDocument(profile, release, images) {
-    const command = profile.migration?.command ?? ["npm", "run", "migrate:all"];
+function renderMigrationDocument(profile, release, images, defaultCommand = ["bun", "run", "migrate:all"]) {
+    const command = profile.migration?.command ?? defaultCommand;
     return (`# Generated by PodoKit. One-shot migration for ${release}.\n` +
         `name: ${profile.target.project}-migrate\n` +
         `services:\n` +
@@ -323,8 +325,9 @@ function renderComposeDeployment(projectRoot, profileName, profile, release, res
     const root = (0, node_path_1.join)((0, node_path_1.resolve)(projectRoot), ".podokit", "runtime", "deploy", profileName);
     (0, node_fs_1.rmSync)(root, { recursive: true, force: true });
     (0, node_fs_1.mkdirSync)(root, { recursive: true });
-    const composeDocument = renderComposeDocument(profile, release, images, effectiveStateDigest);
-    const migrationDocument = renderMigrationDocument(profile, release, images);
+    const toolchain = (0, lockfile_1.readManifest)(projectRoot)?.toolchain ?? (0, toolchain_1.resolveToolchain)();
+    const composeDocument = renderComposeDocument(profile, release, images, effectiveStateDigest, (0, toolchain_1.toolchainWorkerCommand)(toolchain));
+    const migrationDocument = renderMigrationDocument(profile, release, images, (0, toolchain_1.toolchainMigrationCommand)(toolchain));
     const composeFile = (0, node_path_1.join)(root, "compose.yaml");
     const migrationFile = (0, node_path_1.join)(root, "compose.migrate.yaml");
     (0, node_fs_1.writeFileSync)(composeFile, composeDocument);

package/dist/deploy-compose-sync.d.ts

@@ -84,14 +84,11 @@ interface PackageManifest {
  * What the images ship outside their dependency tree.
  *
  * Every entry mirrors a `COPY --from=build` line in the generated Dockerfiles, which
- * is what makes the copy equivalent to a rebuild for code-only changes. Two entries
- * exist for a reason worth keeping:
- *
- * - `apps/web/server.js` and `apps/web/src/lib/server` ship as SOURCE, outside the
- *   bundle, because the entry point has to run before the adapter does. Syncing only
- *   `build/` would leave a stale entry running new routes.
- * - `packages/*` are copied as real directories rather than the symlinks npm leaves
- *   behind, so their `dist/` is a separate destination from the apps'.
+ * is what makes the copy equivalent to a rebuild for code-only changes. The web
+ * image is different from the API image: the official Bun adapter bundles the web
+ * application and its workspace dependencies into `apps/web/build`, so that one
+ * directory is the complete web payload. API and worker processes still load
+ * workspace package output separately.
  *
  * `node_modules` is deliberately absent: the image installs a production-only,
  * workspace-scoped tree for its own platform, and a developer's tree is neither.
@@ -102,12 +99,11 @@ export declare function excludesWithin(artifact: ComposeSyncArtifact, excludes:
 /**
  * Whether the image's dependency tree can still run this code.
  *
- * Only the runtime dependency sets matter: `npm ci --omit=dev` installed what these
- * declare and nothing else, so a change to any of them means the container is
- * missing a package the new code imports -- a failure that surfaces as a crash loop
- * after the restart rather than as a copy error. `devDependencies` are absent from
- * the image by design and a `version` bump changes nothing at runtime, so neither
- * takes part.
+ * Only the runtime dependency sets matter for API and worker images: their package
+ * manager installed what these manifests declare and nothing else, so a change can
+ * leave the container without a package the new code imports. The web image has no
+ * runtime dependency tree; the official Bun adapter includes those dependencies in
+ * the synced build instead. `devDependencies` and package versions do not take part.
  */
 export declare function runtimeDependenciesOf(manifest: PackageManifest): string;
 export declare function planComposeSync(projectRoot: string, profileName: string, runner?: CommandRunner): ComposeSyncPlan;