tovuk 0.1.47 → 0.1.49

package/README.md

@@ -1,6 +1,6 @@
 # tovuk
 
-Deploy Rust backends and static frontends to Tovuk.
+Deploy Rust backends, static frontends, and fullstack apps to Tovuk.
 
 ```sh
 npx tovuk init my-app --template fullstack-rust-tanstack
@@ -19,8 +19,9 @@ Static frontends must use TypeScript browser source, stable native type-aware
 TypeScript checks, native linting such as `oxlint`, `biome check`, or
 `deno lint`, and Fallow dead-code, semantic duplicate-code, and health gates.
 
-From a full-stack repo root, the same deploy command discovers nested
-`tovuk.toml` files and deploys the whole workspace in one command.
+From a fullstack repo root, the same deploy command reads one root `tovuk.toml`,
+builds the backend and frontend roots, and returns one app URL with `/api/*`
+routed to the Rust backend.
 
 Preview before deploying:
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "tovuk",
-  "version": "0.1.47",
-  "description": "Deploy Rust backends and static frontends to Tovuk.",
+  "version": "0.1.49",
+  "description": "Deploy Rust backends, static frontends, and fullstack apps to Tovuk.",
   "type": "module",
   "bin": {
     "tovuk": "src/tovuk.ts"

package/src/internal/config-parser.ts

@@ -1,30 +1,48 @@
 import { DEFAULT_RUST_CHECK_COMMAND, PROJECT_KINDS } from './constants.ts'
 import { frontendBuildCommand, frontendCheckCommand } from './frontend-policy.ts'
-import type { BuildConfig, ProjectKind, ResourceConfig, RunConfig, TovukConfig } from './types.ts'
+import type { BackendConfig, BuildConfig, FrontendConfig, ProjectKind, ResourceConfig, RunConfig, TovukConfig } from './types.ts'
 
-type SectionName = 'build' | 'resources' | 'root' | 'run'
+type SectionName = 'backend' | 'build' | 'frontend' | 'resources' | 'root' | 'run'
 type TomlValue = boolean | number | string
 type SectionAssigner = (config: MutableTovukConfig, key: string, value: TomlValue) => void
 
+interface MutableSection {
+  [key: string]: number | string | undefined
+}
+
 interface MutableTovukConfig {
   name?: string
   kind?: ProjectKind
-  build: Partial<BuildConfig>
-  run: Partial<RunConfig>
-  resources: Partial<ResourceConfig>
+  build: MutableSection
+  run: MutableSection
+  frontend: MutableSection
+  backend: MutableSection
+  resources: MutableSection
+}
+
+const SECTION_FIELD_TYPES: Readonly<Record<Exclude<SectionName, 'root'>, { strings: ReadonlySet<string>; numbers: ReadonlySet<string> }>> = {
+  backend: fieldTypes(['root', 'check', 'build', 'command', 'health'], ['port']),
+  build: fieldTypes(['command', 'check', 'output'], []),
+  frontend: fieldTypes(['root', 'check', 'build', 'output'], []),
+  resources: fieldTypes(['memory', 'cpu'], ['idle_timeout_minutes']),
+  run: fieldTypes(['command', 'health'], ['port'])
 }
 
 const SECTION_ASSIGNERS: Readonly<Record<SectionName, SectionAssigner>> = {
-  build: (config, key, value): void => assignBuildValue(config.build, key, value),
-  resources: (config, key, value): void => assignResourceValue(config.resources, key, value),
+  backend: (config, key, value): void => assignSectionValue(config.backend, key, value, 'backend'),
+  build: (config, key, value): void => assignSectionValue(config.build, key, value, 'build'),
+  frontend: (config, key, value): void => assignSectionValue(config.frontend, key, value, 'frontend'),
+  resources: (config, key, value): void => assignSectionValue(config.resources, key, value, 'resources'),
   root: assignRootValue,
-  run: (config, key, value): void => assignRunValue(config.run, key, value)
+  run: (config, key, value): void => assignSectionValue(config.run, key, value, 'run')
 }
 
 function parseTovukToml(source: string, projectDir: string): TovukConfig {
   const config: MutableTovukConfig = {
     build: {},
     run: {},
+    frontend: {},
+    backend: {},
     resources: {}
   }
   let section: SectionName = 'root'
@@ -50,6 +68,8 @@ function tovukConfig(config: MutableTovukConfig, projectDir: string): TovukConfi
     kind,
     build: buildConfig(config, kind, projectDir),
     run: runConfig(config),
+    frontend: frontendConfig(config, kind, projectDir),
+    backend: backendConfig(config, kind),
     resources: resourceConfig(config)
   }
   if (config.name) {
@@ -75,7 +95,7 @@ function parseTomlLine(rawLine: string): { kind: 'section'; section: SectionName
 }
 
 function parseSection(value: string): SectionName {
-  if (value === 'build' || value === 'run' || value === 'resources') {
+  if (value === 'backend' || value === 'build' || value === 'frontend' || value === 'run' || value === 'resources') {
     return value
   }
   throw new Error(`unsupported section [${value}]`)
@@ -97,36 +117,24 @@ function assignRootValue(config: MutableTovukConfig, key: string, value: TomlVal
   throw new Error(`unsupported root key ${key}`)
 }
 
-function assignBuildValue(build: Partial<BuildConfig>, key: string, value: TomlValue): void {
-  if (key === 'command' || key === 'check' || key === 'output') {
-    build[key] = expectString(key, value)
-    return
-  }
-  throw new Error(`unsupported [build] key ${key}`)
-}
-
-function assignRunValue(run: Partial<RunConfig>, key: string, value: TomlValue): void {
-  if (key === 'command' || key === 'health') {
-    run[key] = expectString(key, value)
+function assignSectionValue(sectionValues: MutableSection, key: string, value: TomlValue, section: Exclude<SectionName, 'root'>): void {
+  const schema = SECTION_FIELD_TYPES[section]
+  if (schema.strings.has(key)) {
+    sectionValues[key] = expectString(key, value)
     return
   }
-  if (key === 'port') {
-    run.port = expectNumber(key, value)
+  if (schema.numbers.has(key)) {
+    sectionValues[key] = expectNumber(key, value)
     return
   }
-  throw new Error(`unsupported [run] key ${key}`)
+  throw new Error(`unsupported [${section}] key ${key}`)
 }
 
-function assignResourceValue(resources: Partial<ResourceConfig>, key: string, value: TomlValue): void {
-  if (key === 'memory' || key === 'cpu') {
-    resources[key] = expectString(key, value)
-    return
-  }
-  if (key === 'idle_timeout_minutes') {
-    resources.idle_timeout_minutes = expectNumber(key, value)
-    return
+function fieldTypes(strings: readonly string[], numbers: readonly string[]): { strings: ReadonlySet<string>; numbers: ReadonlySet<string> } {
+  return {
+    strings: new Set(strings),
+    numbers: new Set(numbers)
   }
-  throw new Error(`unsupported [resources] key ${key}`)
 }
 
 function expectString(key: string, value: TomlValue): string {
@@ -147,7 +155,7 @@ function expectProjectKind(value: string): ProjectKind {
   if (isProjectKind(value)) {
     return value
   }
-  throw new Error('kind must be rust_backend or static_frontend')
+  throw new Error('kind must be fullstack, rust_backend, or static_frontend')
 }
 
 function isProjectKind(value: string): value is ProjectKind {
@@ -173,12 +181,12 @@ function parseTomlValue(raw: string): TomlValue {
 
 function buildConfig(config: MutableTovukConfig, kind: ProjectKind, projectDir: string): BuildConfig {
   const build: BuildConfig = {
-    check: config.build.check ?? defaultCheckCommand(kind, projectDir),
-    command: config.build.command ?? defaultBuildCommand(kind, projectDir)
+    check: optionalString(config.build['check']) ?? defaultCheckCommand(kind, projectDir),
+    command: optionalString(config.build['command']) ?? defaultBuildCommand(kind, projectDir)
   }
   const output = kind === 'static_frontend'
-    ? config.build.output ?? 'dist'
-    : config.build.output
+    ? optionalString(config.build['output']) ?? 'dist'
+    : optionalString(config.build['output'])
   if (typeof output === 'string') {
     build.output = output
   }
@@ -193,22 +201,68 @@ function defaultBuildCommand(kind: ProjectKind, projectDir: string): string {
   return kind === 'static_frontend' ? frontendBuildCommand(projectDir) : 'cargo build --release'
 }
 
+function frontendConfig(config: MutableTovukConfig, kind: ProjectKind, projectDir: string): FrontendConfig {
+  if (kind !== 'fullstack') {
+    return {}
+  }
+  const root = optionalString(config.frontend['root'])
+  const frontendDir = root ? pathJoin(projectDir, root) : projectDir
+  const result: FrontendConfig = {
+    check: optionalString(config.frontend['check']) ?? frontendCheckCommand(frontendDir),
+    build: optionalString(config.frontend['build']) ?? frontendBuildCommand(frontendDir),
+    output: optionalString(config.frontend['output']) ?? 'dist'
+  }
+  assignIfPresent(root, (value) => { result.root = value })
+  return result
+}
+
+function backendConfig(config: MutableTovukConfig, kind: ProjectKind): BackendConfig {
+  if (kind !== 'fullstack') {
+    return {}
+  }
+  const result: BackendConfig = {
+    check: optionalString(config.backend['check']) ?? DEFAULT_RUST_CHECK_COMMAND,
+    build: optionalString(config.backend['build']) ?? 'cargo build --release',
+    port: optionalNumber(config.backend['port']) ?? 3000,
+    health: optionalString(config.backend['health']) ?? '/api/healthz'
+  }
+  assignIfPresent(optionalString(config.backend['root']), (value) => { result.root = value })
+  assignIfPresent(optionalString(config.backend['command']), (value) => { result.command = value })
+  return result
+}
+
+function pathJoin(root: string, relative: string): string {
+  return `${root.replace(/\/+$/u, '')}/${relative.replace(/^\/+/u, '')}`
+}
+
 function runConfig(config: MutableTovukConfig): RunConfig {
   const run: RunConfig = {
-    port: config.run.port ?? 3000,
-    health: config.run.health ?? '/healthz'
-  }
-  if (typeof config.run.command === 'string') {
-    run.command = config.run.command
+    port: optionalNumber(config.run['port']) ?? 3000,
+    health: optionalString(config.run['health']) ?? '/healthz'
   }
+  assignIfPresent(optionalString(config.run['command']), (value) => { run.command = value })
   return run
 }
 
 function resourceConfig(config: MutableTovukConfig): ResourceConfig {
   return {
-    memory: config.resources.memory ?? '512mb',
-    cpu: config.resources.cpu ?? '0.25',
-    idle_timeout_minutes: config.resources.idle_timeout_minutes ?? 15
+    memory: optionalString(config.resources['memory']) ?? '512mb',
+    cpu: optionalString(config.resources['cpu']) ?? '0.25',
+    idle_timeout_minutes: optionalNumber(config.resources['idle_timeout_minutes']) ?? 15
+  }
+}
+
+function optionalString(value: number | string | undefined): string | undefined {
+  return typeof value === 'string' ? value : undefined
+}
+
+function optionalNumber(value: number | string | undefined): number | undefined {
+  return typeof value === 'number' ? value : undefined
+}
+
+function assignIfPresent(value: string | undefined, assign: (value: string) => void): void {
+  if (value) {
+    assign(value)
   }
 }
 

package/src/internal/config-validation.ts

@@ -1,10 +1,14 @@
-import { PROJECT_KINDS } from './constants.ts'
+import { JAVASCRIPT_BACKEND_RUNTIMES, PROJECT_KINDS } from './constants.ts'
 import { commandTokens, hasFrontendInstallCommand, hasFrontendScriptRun, usesJavascriptLinter } from './frontend-policy.ts'
 import { isSafeRelativePath } from './project.ts'
 import type { ProjectKind, TovukConfig } from './types.ts'
 
 function validateConfig(config: TovukConfig): void {
   validateIdentity(config)
+  if (config.kind === 'fullstack') {
+    validateFullstackConfig(config)
+    return
+  }
   validateBuildConfig(config)
   if (config.kind === 'static_frontend') {
     validateStaticFrontendConfig(config)
@@ -18,7 +22,7 @@ function validateIdentity(config: TovukConfig): void {
     throw new Error('name must be lowercase DNS-safe text up to 48 characters')
   }
   if (!PROJECT_KINDS.has(config.kind)) {
-    throw new Error('kind must be rust_backend or static_frontend')
+    throw new Error('kind must be fullstack, rust_backend, or static_frontend')
   }
 }
 
@@ -30,28 +34,77 @@ function validateBuildConfig(config: TovukConfig): void {
     throw new Error('[build].check is required')
   }
   validateCheckCommand(config.kind, config.build.check)
+  if (config.kind === 'rust_backend') {
+    validateRustBuildCommand(config.build.command)
+  }
 }
 
 function validateStaticFrontendConfig(config: TovukConfig): void {
-  if (typeof config.build.output !== 'string' || !isSafeRelativePath(config.build.output)) {
-    throw new Error('[build].output must be a safe relative directory like dist')
-  }
+  validateOutput(config.build.output, '[build].output')
 }
 
 function validateRustBackendConfig(config: TovukConfig): void {
   if (config.build.output) {
     throw new Error('[build].output is only valid for static_frontend')
   }
-  if (!config.run.command?.trim()) {
-    throw new Error('[run].command is required')
+  requireCommand(config.run.command, '[run].command')
+  validateRustRunCommand(config.run.command)
+  validatePort(config.run.port, '[run].port')
+  validateHealth(config.run.health, '[run].health')
+  validateResourceConfig(config)
+}
+
+function validateFullstackConfig(config: TovukConfig): void {
+  const backendRoot = validateRoot(config.backend.root, '[backend].root')
+  const frontendRoot = validateRoot(config.frontend.root, '[frontend].root')
+  if (backendRoot === frontendRoot) {
+    throw new Error('[backend].root and [frontend].root must be different directories')
+  }
+  validateFullstackSections(config)
+  validateResourceConfig(config)
+}
+
+function validateFullstackSections(config: TovukConfig): void {
+  validateRustCheckCommand(requireCommand(config.backend.check, '[backend].check'))
+  validateRustBuildCommand(requireCommand(config.backend.build, '[backend].build'))
+  validateRustRunCommand(requireCommand(config.backend.command, '[backend].command'))
+  validatePort(config.backend.port, '[backend].port')
+  validateHealth(config.backend.health, '[backend].health')
+  validateFrontendCheckCommand(requireCommand(config.frontend.check, '[frontend].check'))
+  requireCommand(config.frontend.build, '[frontend].build')
+  validateOutput(config.frontend.output, '[frontend].output')
+}
+
+function validateRoot(value: string | undefined, field: string): string {
+  if (!value || !isSafeRelativePath(value)) {
+    throw new Error(`${field} must be a safe relative directory such as api or web`)
+  }
+  return value
+}
+
+function requireCommand(value: string | undefined, field: string): string {
+  if (!value?.trim()) {
+    throw new Error(`${field} is required`)
+  }
+  return value
+}
+
+function validatePort(value: number | undefined, field: string): void {
+  if (!Number.isInteger(value) || (value ?? 0) < 1 || (value ?? 0) > 65535) {
+    throw new Error(`${field} must be between 1 and 65535`)
   }
-  if (!Number.isInteger(config.run.port) || config.run.port < 1 || config.run.port > 65535) {
-    throw new Error('[run].port must be between 1 and 65535')
+}
+
+function validateHealth(value: string | undefined, field: string): void {
+  if (!value?.startsWith('/')) {
+    throw new Error(`${field} must be an absolute path`)
   }
-  if (!config.run.health.startsWith('/')) {
-    throw new Error('[run].health must be an absolute path')
+}
+
+function validateOutput(value: string | undefined, field: string): void {
+  if (typeof value !== 'string' || !isSafeRelativeDirectory(value)) {
+    throw new Error(`${field} must be a safe relative directory like dist or .`)
   }
-  validateResourceConfig(config)
 }
 
 function validateResourceConfig(config: TovukConfig): void {
@@ -69,6 +122,10 @@ function validateCheckCommand(kind: ProjectKind, command: string): void {
     return
   }
 
+  validateRustCheckCommand(command)
+}
+
+function validateRustCheckCommand(command: string): void {
   const required = ['cargo fmt --all --check', 'cargo check --locked', 'cargo clippy --locked', '--all-targets', '--all-features', '-D warnings']
   if (required.every((fragment) => command.includes(fragment))) {
     return
@@ -76,7 +133,32 @@ function validateCheckCommand(kind: ProjectKind, command: string): void {
   throw new Error('[build].check must include cargo fmt --all --check, cargo check --locked, and cargo clippy --locked --all-targets --all-features -- -D warnings')
 }
 
+function validateRustBuildCommand(command: string): void {
+  if (usesJavascriptBackendRuntime(command)) {
+    throw new Error('Rust backend build commands cannot invoke JavaScript or TypeScript runtimes; use cargo build --release')
+  }
+  const tokens = commandTokens(command)
+  if (tokens.some((token) => commandNameFromToken(token) === 'cargo') && tokens.includes('build') && tokens.includes('--release')) {
+    return
+  }
+  throw new Error('Rust backend build commands must run cargo build --release')
+}
+
+function validateRustRunCommand(command: string | undefined): void {
+  const value = command ?? ''
+  if (usesJavascriptBackendRuntime(value)) {
+    throw new Error('Rust backend runtime commands cannot invoke JavaScript or TypeScript runtimes; run ./target/release/<binary> instead')
+  }
+  if (commandTokens(value).some((token) => token.includes('target/release/'))) {
+    return
+  }
+  throw new Error('Rust backend runtime commands must start a binary under ./target/release/')
+}
+
 function validateFrontendCheckCommand(command: string): void {
+  if (isNoopCommand(command)) {
+    return
+  }
   if (usesJavascriptLinter(command)) {
     throw new Error('[build].check must not run JavaScript-based lint or format tooling; use oxlint, biome, or deno lint')
   }
@@ -91,4 +173,21 @@ function validateFrontendCheckCommand(command: string): void {
   throw new Error('[build].check must install dependencies and run package scripts, for example `bun ci && bun run typecheck && bun run lint` or `npm ci --prefer-offline --no-audit --fund=false && npm run typecheck && npm run lint`')
 }
 
+function usesJavascriptBackendRuntime(command: string): boolean {
+  return commandTokens(command)
+    .some((token) => JAVASCRIPT_BACKEND_RUNTIMES.has(commandNameFromToken(token)))
+}
+
+function isSafeRelativeDirectory(value: string): boolean {
+  return value === '.' || isSafeRelativePath(value)
+}
+
+function isNoopCommand(command: string): boolean {
+  return command.trim() === ':' || command.trim() === 'true'
+}
+
+function commandNameFromToken(token: string): string {
+  return token.split('/').pop() ?? ''
+}
+
 export { validateConfig }

package/src/internal/constants.ts

@@ -18,9 +18,10 @@ export const DEFAULT_LOGIN_INTERVAL_SECONDS: number = 5
 export const DEFAULT_RUST_CHECK_COMMAND: string = 'cargo fmt --all --check && cargo check --locked && cargo clippy --locked --all-targets --all-features -- -D warnings'
 export const DEFAULT_NPM_FRONTEND_CHECK_COMMAND: string = 'npm ci --prefer-offline --no-audit --fund=false && npm run typecheck && npm run lint'
 export const DEFAULT_BUN_FRONTEND_CHECK_COMMAND: string = 'bun ci && bun run typecheck && bun run lint'
-export const PROJECT_KINDS: ReadonlySet<string> = new Set(['rust_backend', 'static_frontend'])
+export const PROJECT_KINDS: ReadonlySet<string> = new Set(['fullstack', 'rust_backend', 'static_frontend'])
 export const PROJECT_TEMPLATES: ReadonlySet<string> = new Set(['rust-api', 'tanstack-static-frontend', 'fullstack-rust-tanstack'])
 export const JAVASCRIPT_LINTERS: ReadonlySet<string> = new Set(['eslint', 'eslint_d', 'jscs', 'jshint', 'prettier', 'prettierd', 'standard', 'xo'])
+export const JAVASCRIPT_BACKEND_RUNTIMES: ReadonlySet<string> = new Set(['astro', 'bun', 'deno', 'next', 'node', 'npm', 'npx', 'pnpm', 'svelte-kit', 'tsx', 'ts-node', 'vite', 'yarn'])
 export const FRONTEND_SOURCE_ROOTS: ReadonlySet<string> = new Set(['src', 'app', 'pages', 'routes', 'components'])
 export const FRONTEND_JAVASCRIPT_EXTENSIONS: readonly string[] = ['.js', '.jsx', '.mjs', '.cjs']
 export const FRONTEND_PACKAGE_MANAGERS: ReadonlySet<string> = new Set(['npm', 'bun', 'pnpm', 'yarn'])
@@ -125,11 +126,14 @@ Usage:
   tovuk support resolve <ticket_id> [--api <url>] [--json]
 
 Agent contract:
+  - Fullstack apps set kind = "fullstack", keep backend and frontend roots in one tovuk.toml, serve the frontend at /, and serve the Rust API under /api.
   - Rust backends keep Cargo.lock committed, pass rustfmt, listen on 0.0.0.0:$PORT, and return HTTP 200 from health.
   - Static frontends set kind = "static_frontend", keep TypeScript source, a package lockfile, stable native typecheck, native lint, and Fallow quality gates.
+  - Plain static HTML/CSS/JS frontends may use kind = "static_frontend" with check = ":", command = ":", and output = ".".
+  - JavaScript and TypeScript are frontend-only on Tovuk; backend build and runtime commands must be Cargo release builds and Rust release binaries.
   - Frontends call Rust backends for APIs, managed Postgres, and server-side logic.
-  - Run deploy from a repo root with nested tovuk.toml files to deploy the whole workspace in one command.
-  - When a frontend calls a backend on another hostname, configure backend CORS or use a same-origin custom domain.
+  - Run deploy from a fullstack repo root with one tovuk.toml to build backend and frontend together.
+  - When split frontend and backend apps use different hostnames, configure backend CORS or use a same-origin custom domain.
   - When a plan limit blocks work, run tovuk billing checkout --json and show the returned URL to the human.
   - Create support tickets only with command output, app id, build id, deploy id, and the first actionable log line.
   - Resolve support tickets after the issue is fixed so later agents do not duplicate work.

package/src/internal/deploy-plan.ts

@@ -8,7 +8,7 @@ import type { AppSummary, CliOptions, DeployPlanProject, DeployProjectInfo } fro
 async function createDeployPlan(projects: DeployProjectInfo[], cli: CliOptions, token: string): Promise<DeployPlanProject[]> {
   const plan = projects.map((project) => ({
     project,
-    wantsDatabase: cli.database && project.kind === 'rust_backend'
+    wantsDatabase: cli.database && (project.kind === 'rust_backend' || project.kind === 'fullstack')
   }))
   rejectInvalidDatabaseTargets(plan, cli)
   await preflightDeployLimits(plan, cli, token)

package/src/internal/doctor.ts

@@ -4,9 +4,9 @@ import { doctorCheck } from './checks.ts'
 import { agentError } from './errors.ts'
 import { parseTovukToml, validateConfig } from './config.ts'
 import { discoverDeployProjects } from './workspace.ts'
-import { printJson } from './project.ts'
+import { printJson, walkProjectFiles } from './project.ts'
 import { rustDoctorChecks, unsafeCheck } from './rust-doctor.ts'
-import { frontendLockfileExists, frontendScriptChecks, frontendSourceChecks } from './frontend-policy.ts'
+import { frontendLockfileExists, frontendScriptChecks, frontendSourceChecks, isPlainStaticFrontend } from './frontend-policy.ts'
 import type { DoctorCheck, DoctorReport, WorkspaceDoctorReport, TovukConfig } from './types.ts'
 
 function doctorProject(projectDir: string, json: boolean): void {
@@ -58,12 +58,16 @@ function runDoctor(projectDir: string): DoctorReport {
   const configResult = readConfig(projectDir)
   const checks: DoctorCheck[] = [configResult.check]
   const kind = configResult.config?.kind || 'rust_backend'
+  if (kind === 'fullstack' && configResult.config) {
+    checks.push(...fullstackChecks(projectDir, configResult.config, configResult.valid))
+    return doctorReport(projectDir, configResult.config, checks)
+  }
+
   checks.push(...requiredFileChecks(projectDir, kind))
   if (kind === 'static_frontend') {
-    checks.push(frontendLockfileCheck(projectDir))
-    checks.push(...frontendSourceChecks(projectDir))
-    checks.push(...frontendScriptChecks(projectDir, configResult.valid))
+    checks.push(...staticFrontendChecks(projectDir, configResult.valid))
   } else {
+    checks.push(backendJavascriptSourceCheck(projectDir))
     checks.push(...rustDoctorChecks(projectDir, configResult.valid))
   }
 
@@ -71,10 +75,14 @@ function runDoctor(projectDir: string): DoctorReport {
     checks.push(unsafeCheck(projectDir))
   }
 
+  return doctorReport(projectDir, configResult.config, checks)
+}
+
+function doctorReport(projectDir: string, config: TovukConfig | null, checks: DoctorCheck[]): DoctorReport {
   return {
     ok: checks.every((check) => check.ok),
     project: projectDir,
-    config: configResult.config,
+    config,
     checks
   }
 }
@@ -124,14 +132,50 @@ function readConfig(projectDir: string): { check: DoctorCheck; config: TovukConf
 }
 
 function requiredFileChecks(projectDir: string, kind: TovukConfig['kind']): DoctorCheck[] {
-  return requiredFiles(kind).map((file) => {
+  return requiredFiles(projectDir, kind).map((file) => {
     const ok = existsSync(path.join(projectDir, file))
     return doctorCheck(file, ok, 'found', 'missing', `Create and commit ${file}, then retry.`)
   })
 }
 
-function requiredFiles(kind: TovukConfig['kind']): string[] {
-  return kind === 'static_frontend' ? ['package.json'] : ['Cargo.toml', 'Cargo.lock']
+function requiredFiles(projectDir: string, kind: TovukConfig['kind']): string[] {
+  if (kind === 'static_frontend') {
+    return isPlainStaticFrontend(projectDir) ? ['index.html'] : ['package.json']
+  }
+  return ['Cargo.toml', 'Cargo.lock']
+}
+
+function fullstackChecks(projectDir: string, config: TovukConfig, configValid: boolean): DoctorCheck[] {
+  const backendRoot = config.backend.root || ''
+  const frontendRoot = config.frontend.root || ''
+  const backendDir = path.join(projectDir, backendRoot)
+  const frontendDir = path.join(projectDir, frontendRoot)
+  return [
+    ...requiredFilesAt(backendDir, backendRoot, ['Cargo.toml', 'Cargo.lock']),
+    backendJavascriptSourceCheck(backendDir, backendRoot),
+    ...rustDoctorChecks(backendDir, configValid),
+    ...requiredFilesAt(frontendDir, frontendRoot, isPlainStaticFrontend(frontendDir) ? ['index.html'] : ['package.json']),
+    ...staticFrontendChecks(frontendDir, configValid)
+  ]
+}
+
+function requiredFilesAt(projectDir: string, label: string, files: string[]): DoctorCheck[] {
+  return files.map((file) => {
+    const display = label ? `${label}/${file}` : file
+    const ok = existsSync(path.join(projectDir, file))
+    return doctorCheck(display, ok, 'found', 'missing', `Create and commit ${display}, then retry.`)
+  })
+}
+
+function staticFrontendChecks(projectDir: string, configValid: boolean): DoctorCheck[] {
+  if (isPlainStaticFrontend(projectDir)) {
+    return []
+  }
+  return [
+    frontendLockfileCheck(projectDir),
+    ...frontendSourceChecks(projectDir),
+    ...frontendScriptChecks(projectDir, configValid)
+  ]
 }
 
 function frontendLockfileCheck(projectDir: string): DoctorCheck {
@@ -139,6 +183,29 @@ function frontendLockfileCheck(projectDir: string): DoctorCheck {
   return doctorCheck('frontend lockfile', ok, 'found', 'missing', 'Commit package-lock.json, pnpm-lock.yaml, yarn.lock, bun.lock, or bun.lockb, then retry.')
 }
 
+function backendJavascriptSourceCheck(projectDir: string, label = ''): DoctorCheck {
+  const matches: string[] = []
+  walkProjectFiles(projectDir, (_file, relative) => {
+    if (isBackendJavascriptOrTypescriptSource(relative)) {
+      matches.push(label ? `${label}/${relative}` : relative)
+    }
+  })
+  return doctorCheck(
+    'rust backend js/ts server source',
+    matches.length === 0,
+    'none found',
+    matches.slice(0, 5).join(', '),
+    'Move API routes, SSR handlers, middleware, and server logic to Rust. Keep JS/TS only in static frontend roots.'
+  )
+}
+
+function isBackendJavascriptOrTypescriptSource(relative: string): boolean {
+  if (relative.endsWith('.d.ts') || !/\.(?:cjs|js|jsx|mjs|ts|tsx)$/iu.test(relative)) {
+    return false
+  }
+  return relative.split('/').some((component) => ['api', 'app', 'pages', 'routes', 'server', 'src'].includes(component))
+}
+
 function isWorkspaceDoctorReport(report: DoctorReport | WorkspaceDoctorReport): report is WorkspaceDoctorReport {
   return 'projects' in report
 }

package/src/internal/frontend-policy.ts

@@ -7,6 +7,8 @@ import { readPackageJson, walkProjectFiles } from './project.ts'
 import type { DoctorCheck, FrontendSourceReport, PackageManifest } from './types.ts'
 
 const REQUIRED_FRONTEND_SCRIPTS = ['typecheck', 'lint'] as const
+const FRONTEND_PAGES_API_PREFIXES: readonly (readonly string[])[] = [['pages', 'api'], ['src', 'pages', 'api']]
+const FRONTEND_APP_API_PREFIXES: readonly (readonly string[])[] = [['app', 'api'], ['src', 'app', 'api']]
 type FrontendScriptName = typeof REQUIRED_FRONTEND_SCRIPTS[number]
 type CommandPredicate = (command: string) => boolean
 
@@ -15,6 +17,10 @@ function frontendLockfileExists(projectDir: string): boolean {
     .some((file) => existsSync(path.join(projectDir, file)))
 }
 
+function isPlainStaticFrontend(projectDir: string): boolean {
+  return !existsSync(path.join(projectDir, 'package.json')) && existsSync(path.join(projectDir, 'index.html'))
+}
+
 function frontendPackageManager(projectDir: string): 'bun' | 'npm' {
   return existsSync(path.join(projectDir, 'bun.lock')) || existsSync(path.join(projectDir, 'bun.lockb'))
     ? 'bun'
@@ -22,12 +28,18 @@ function frontendPackageManager(projectDir: string): 'bun' | 'npm' {
 }
 
 function frontendCheckCommand(projectDir: string): string {
+  if (isPlainStaticFrontend(projectDir)) {
+    return ':'
+  }
   return frontendPackageManager(projectDir) === 'bun'
     ? DEFAULT_BUN_FRONTEND_CHECK_COMMAND
     : DEFAULT_NPM_FRONTEND_CHECK_COMMAND
 }
 
 function frontendBuildCommand(projectDir: string): string {
+  if (isPlainStaticFrontend(projectDir)) {
+    return ':'
+  }
   return frontendPackageManager(projectDir) === 'bun'
     ? 'bun run build'
     : 'npm run build'
@@ -85,18 +97,26 @@ function frontendSourceChecks(projectDir: string): DoctorCheck[] {
       message: report.typescript.length > 0 ? report.typescript.slice(0, 3).join(', ') : 'missing',
       agent_instruction: report.typescript.length > 0 ? null : 'Add browser source as .ts or .tsx under src, app, pages, routes, or components, then retry.'
     },
-    {
-      name: 'javascript source',
-      ok: report.javascript.length === 0,
-      message: report.javascript.length === 0 ? 'none found' : report.javascript.slice(0, 5).join(', '),
-      agent_instruction: report.javascript.length === 0 ? null : 'Rename browser .js, .jsx, .mjs, or .cjs source files to .ts or .tsx and fix type errors before deploying.'
-    }
+    forbiddenSourceCheck('javascript source', report.javascript, 'Rename browser .js, .jsx, .mjs, or .cjs source files to .ts or .tsx and fix type errors before deploying.'),
+    forbiddenSourceCheck('frontend server routes', report.serverRoutes, 'Move API routes, SSR handlers, middleware, and server logic to the Rust backend; static frontend source may only contain browser code.')
   ]
 }
 
+function forbiddenSourceCheck(name: string, files: readonly string[], instruction: string): DoctorCheck {
+  return {
+    name,
+    ok: files.length === 0,
+    message: files.length === 0 ? 'none found' : files.slice(0, 5).join(', '),
+    agent_instruction: files.length === 0 ? null : instruction
+  }
+}
+
 function frontendSourceReport(projectDir: string): FrontendSourceReport {
-  const report: FrontendSourceReport = { typescript: [], javascript: [] }
+  const report: FrontendSourceReport = { typescript: [], javascript: [], serverRoutes: [] }
   walkProjectFiles(projectDir, (_file, relative) => {
+    if (isFrontendServerRoute(relative)) {
+      report.serverRoutes.push(relative)
+    }
     const sourceKind = frontendSourceKind(relative)
     if (sourceKind) {
       report[sourceKind].push(relative)
@@ -128,6 +148,28 @@ function isFrontendJavascriptSource(relative: string): boolean {
   return FRONTEND_JAVASCRIPT_EXTENSIONS.some((extension) => relative.endsWith(extension))
 }
 
+function isFrontendServerRoute(relative: string): boolean {
+  if (!isFrontendTypescriptSource(relative) && !isFrontendJavascriptSource(relative)) {
+    return false
+  }
+  const parts = relative.toLowerCase().split('/')
+  const file = parts.at(-1) ?? ''
+  return isFrontendServerHandlerFile(file) || isFrontendApiRoute(parts, file)
+}
+
+function isFrontendServerHandlerFile(file: string): boolean {
+  return file.startsWith('+server.') || file.startsWith('middleware.')
+}
+
+function isFrontendApiRoute(pathParts: readonly string[], file: string): boolean {
+  return FRONTEND_PAGES_API_PREFIXES.some((prefix) => pathStartsWith(pathParts, prefix))
+    || (file.startsWith('route.') && FRONTEND_APP_API_PREFIXES.some((prefix) => pathStartsWith(pathParts, prefix)))
+}
+
+function pathStartsWith(pathParts: readonly string[], prefix: readonly string[]): boolean {
+  return pathParts.length >= prefix.length && prefix.every((part, index) => pathParts[index] === part)
+}
+
 function packageScriptValue(manifest: PackageManifest | null, script: string): string {
   const value = manifest?.scripts?.[script]
   return typeof value === 'string' ? value.trim() : ''
@@ -269,4 +311,4 @@ function packageScriptCheck(projectDir: string, script: string): DoctorCheck {
   }
 }
 
-export { frontendLockfileExists, frontendCheckCommand, frontendBuildCommand, frontendScriptChecks, frontendSourceChecks, usesJavascriptLinter, commandTokens, hasFrontendInstallCommand, hasFrontendScriptRun }
+export { frontendLockfileExists, isPlainStaticFrontend, frontendCheckCommand, frontendBuildCommand, frontendScriptChecks, frontendSourceChecks, usesJavascriptLinter, commandTokens, hasFrontendInstallCommand, hasFrontendScriptRun }

package/src/internal/preview.ts

@@ -1,16 +1,23 @@
-import { spawnSync } from 'node:child_process'
+import { spawn, spawnSync } from 'node:child_process'
 import { existsSync, readFileSync, statSync } from 'node:fs'
-import { createServer } from 'node:http'
+import { createServer, request as httpRequest } from 'node:http'
 import path from 'node:path'
 import { parseTovukToml, validateConfig } from './config.ts'
 import { runDoctorWorkspace } from './doctor.ts'
 import { agentError } from './errors.ts'
 import { ensureDirectory } from './project.ts'
+import type { TovukConfig } from './types.ts'
+import type { IncomingMessage, ServerResponse } from 'node:http'
 
 function previewProject(projectDir: string, port: number): void {
+  const config = previewConfig(projectDir)
+  previewValidatedProject(projectDir, config, port)
+}
+
+function previewConfig(projectDir: string): TovukConfig {
   const report = runDoctorWorkspace(projectDir)
   if ('projects' in report) {
-    throw agentError('workspace_preview_unsupported', 'Preview one project at a time.', 'Run `npx tovuk preview api` or `npx tovuk preview web` from the workspace root.', false)
+    throw agentError('workspace_preview_unsupported', 'Preview one project at a time.', 'Run `npx tovuk preview <project-dir>` for one discovered project, or use a fullstack root tovuk.toml.', false)
   }
   if (!report.ok) {
     const firstFailure = report.checks.find((check) => !check.ok)
@@ -19,6 +26,14 @@ function previewProject(projectDir: string, port: number): void {
 
   const config = parseTovukToml(readFileSync(path.join(projectDir, 'tovuk.toml'), 'utf8'), projectDir)
   validateConfig(config)
+  return config
+}
+
+function previewValidatedProject(projectDir: string, config: TovukConfig, port: number): void {
+  if (config.kind === 'fullstack') {
+    previewFullstack(projectDir, config, port)
+    return
+  }
   runShell(config.build.command, projectDir, 'Build failed before preview.')
   if (config.kind === 'static_frontend') {
     previewStatic(projectDir, config.build.output ?? 'dist', port)
@@ -27,6 +42,31 @@ function previewProject(projectDir: string, port: number): void {
   previewRuntime(projectDir, config.run.command ?? '', port || config.run.port)
 }
 
+function previewFullstack(projectDir: string, config: TovukConfig, port: number): void {
+  const backendDir = path.join(projectDir, config.backend.root ?? '')
+  const frontendDir = path.join(projectDir, config.frontend.root ?? '')
+  const backendPort = config.backend.port ?? 3000
+  runShell(config.backend.build ?? '', backendDir, 'Backend build failed before preview.')
+  runShell(config.frontend.build ?? '', frontendDir, 'Frontend build failed before preview.')
+  const backend = spawn(config.backend.command ?? '', {
+    cwd: backendDir,
+    env: { ...process.env, PORT: String(backendPort) },
+    shell: true,
+    stdio: 'inherit'
+  })
+  backend.on('error', (error) => {
+    throw agentError('preview_failed', 'Backend preview command failed.', error.message, false)
+  })
+  const stopBackend = (): void => {
+    if (!backend.killed) {
+      backend.kill('SIGTERM')
+    }
+  }
+  process.once('SIGINT', stopBackend)
+  process.once('SIGTERM', stopBackend)
+  serveStatic(path.join(frontendDir, config.frontend.output ?? 'dist'), port || 4173, backendPort)
+}
+
 function previewStatic(projectDir: string, output: string, port: number): void {
   serveStatic(path.join(projectDir, output), port || 4173)
 }
@@ -63,10 +103,14 @@ function runShell(command: string, projectDir: string, failureMessage: string):
   }
 }
 
-function serveStatic(root: string, port: number): void {
+function serveStatic(root: string, port: number, apiProxyPort?: number): void {
   ensureDirectory(root)
   const server = createServer((request, response) => {
     const pathname = decodeURIComponent(new URL(request.url || '/', `http://127.0.0.1:${port}`).pathname)
+    if (apiProxyPort && (pathname === '/api' || pathname.startsWith('/api/'))) {
+      proxyToBackend(request, response, apiProxyPort)
+      return
+    }
     const target = staticTarget(root, pathname)
     if (!target) {
       response.writeHead(404, { 'content-type': 'text/plain; charset=utf-8' })
@@ -81,6 +125,24 @@ function serveStatic(root: string, port: number): void {
   })
 }
 
+function proxyToBackend(clientRequest: IncomingMessage, response: ServerResponse, port: number): void {
+  const upstream = httpRequest({
+    hostname: '127.0.0.1',
+    port,
+    method: clientRequest.method,
+    path: clientRequest.url ?? '/',
+    headers: { ...clientRequest.headers, host: `127.0.0.1:${port}` }
+  }, (upstreamResponse) => {
+    response.writeHead(upstreamResponse.statusCode ?? 502, upstreamResponse.headers)
+    upstreamResponse.pipe(response)
+  })
+  upstream.on('error', () => {
+    response.writeHead(502, { 'content-type': 'text/plain; charset=utf-8' })
+    response.end('backend unavailable')
+  })
+  clientRequest.pipe(upstream)
+}
+
 function staticTarget(root: string, pathname: string): string {
   const safePath = pathname.replace(/^\/+/u, '')
   const candidate = path.resolve(root, safePath || 'index.html')

package/src/internal/project.ts

@@ -5,6 +5,11 @@ import { WALK_EXCLUDED_DIRS } from './constants.ts'
 import { agentError } from './errors.ts'
 import type { CliOptions, FileVisitor, JsonValue, PackageManifest, PathVisitor, ProjectKind } from './types.ts'
 
+interface FullstackRoots {
+  backend: string
+  frontend: string
+}
+
 function hasCommand(command: string): boolean {
   return (process.env['PATH'] ?? '')
     .split(path.delimiter)
@@ -72,15 +77,26 @@ function serviceNameFromValue(value: string): string {
 }
 
 function inferProjectKind(projectDir: string): ProjectKind {
+  if (detectFullstackRoots(projectDir)) {
+    return 'fullstack'
+  }
   if (existsSync(path.join(projectDir, 'Cargo.toml'))) {
     return 'rust_backend'
   }
-  if (existsSync(path.join(projectDir, 'package.json'))) {
+  if (existsSync(path.join(projectDir, 'package.json')) || existsSync(path.join(projectDir, 'index.html'))) {
     return 'static_frontend'
   }
   return 'rust_backend'
 }
 
+function detectFullstackRoots(projectDir: string): FullstackRoots | null {
+  const backendRoot = ['api', 'backend', 'server']
+    .find((root) => existsSync(path.join(projectDir, root, 'Cargo.toml')))
+  const frontendRoot = ['web', 'frontend', 'app', 'site']
+    .find((root) => existsSync(path.join(projectDir, root, 'package.json')) || existsSync(path.join(projectDir, root, 'index.html')))
+  return backendRoot && frontendRoot ? { backend: backendRoot, frontend: frontendRoot } : null
+}
+
 function readPackageJson(projectDir: string): PackageManifest | null {
   try {
     const parsed: unknown = JSON.parse(readFileSync(path.join(projectDir, 'package.json'), 'utf8'))
@@ -132,4 +148,4 @@ function progress(cli: CliOptions, message: string): void {
   console.log(message)
 }
 
-export { hasCommand, isSafeRelativePath, walkProjectFiles, ensureDirectory, serviceNameFromDir, serviceNameFromCargo, serviceNameFromPackage, inferProjectKind, readPackageJson, printJson, openUrl, sleep, progress }
+export { hasCommand, isSafeRelativePath, walkProjectFiles, ensureDirectory, serviceNameFromDir, serviceNameFromCargo, serviceNameFromPackage, inferProjectKind, detectFullstackRoots, readPackageJson, printJson, openUrl, sleep, progress }

package/src/internal/template-sources.ts

@@ -108,7 +108,7 @@ fn handle(mut stream: TcpStream) -> std::io::Result<()> {
         return write_response(&mut stream, "204 No Content", "", &cors_origin);
     }
 
-    let body = if path == "/healthz" {
+    let body = if path == "/healthz" || path == "/api/healthz" {
         r#"{"ok":true}"#
     } else {
         r#"{"message":"hello from tovuk","backend":"rust"}"#

package/src/internal/templates.ts

@@ -1,10 +1,10 @@
 import { existsSync, mkdirSync, writeFileSync } from 'node:fs'
 import path from 'node:path'
-import { DEFAULT_RUST_CHECK_COMMAND, PROJECT_TEMPLATES } from './constants.ts'
+import { DEFAULT_BUN_FRONTEND_CHECK_COMMAND, DEFAULT_RUST_CHECK_COMMAND, PROJECT_TEMPLATES } from './constants.ts'
 import { agentError } from './errors.ts'
 import { doctorProject } from './doctor.ts'
-import { frontendBuildCommand, frontendCheckCommand } from './frontend-policy.ts'
-import { ensureDirectory, inferProjectKind, serviceNameFromCargo, serviceNameFromDir, serviceNameFromPackage } from './project.ts'
+import { frontendBuildCommand, frontendCheckCommand, isPlainStaticFrontend } from './frontend-policy.ts'
+import { detectFullstackRoots, ensureDirectory, inferProjectKind, serviceNameFromCargo, serviceNameFromDir, serviceNameFromPackage } from './project.ts'
 import { frontendPackageJson, frontendSource, frontendTsConfig, frontendViteEnvSource, rustApiSource } from './template-sources.ts'
 import type { TemplateName } from './types.ts'
 
@@ -15,8 +15,7 @@ const TEMPLATE_WRITERS: Readonly<Record<TemplateName, TemplateWriter>> = {
   'rust-api': (projectDir): void => writeRustApiTemplate(projectDir, serviceNameFromDir(projectDir)),
   'tanstack-static-frontend': (projectDir): void => writeFrontendTemplate(projectDir, serviceNameFromDir(projectDir), '/api'),
   'fullstack-rust-tanstack': (projectDir): void => {
-    writeRustApiTemplate(path.join(projectDir, 'api'), 'api')
-    writeFrontendTemplate(path.join(projectDir, 'web'), 'web', 'http://localhost:3000')
+    writeFullstackTemplate(projectDir)
   }
 }
 
@@ -35,9 +34,7 @@ function initProject(projectDir: string, template = ''): void {
   }
 
   const kind = inferProjectKind(projectDir)
-  const source = kind === 'static_frontend'
-    ? frontendConfig(projectDir)
-    : rustBackendConfig(projectDir)
+  const source = initConfig(projectDir, kind)
 
   writeFileSync(configPath, source, { mode: 0o644 })
   console.log(`created ${path.relative(process.cwd(), configPath)}`)
@@ -52,9 +49,15 @@ function createTemplate(projectDir: string, template: string): void {
   console.log(`created ${template} template`)
 }
 
-function writeRustApiTemplate(projectDir: string, name: string): void {
+function writeFullstackTemplate(projectDir: string): void {
+  writeRustApiTemplate(path.join(projectDir, 'api'), 'api', false)
+  writeFrontendTemplate(path.join(projectDir, 'web'), 'web', '/api', false)
+  writeNewFile(path.join(projectDir, 'tovuk.toml'), fullstackConfig(projectDir, { backend: 'api', frontend: 'web' }, true))
+}
+
+function writeRustApiTemplate(projectDir: string, name: string, includeConfig = true): void {
   mkdirSync(path.join(projectDir, 'src'), { recursive: true, mode: 0o755 })
-  const files: readonly TemplateFile[] = [
+  const files: TemplateFile[] = [
     ['Cargo.toml', `[package]
 name = "${name}"
 version = "0.1.0"
@@ -72,24 +75,28 @@ version = 4
 name = "${name}"
 version = "0.1.0"
 `],
-    ['src/main.rs', rustApiSource()],
-    ['tovuk.toml', rustBackendConfig(projectDir)]
+    ['src/main.rs', rustApiSource()]
   ]
+  if (includeConfig) {
+    files.push(['tovuk.toml', rustBackendConfig(projectDir)])
+  }
   writeTemplateFiles(projectDir, files)
 }
 
-function writeFrontendTemplate(projectDir: string, name: string, apiBaseUrl: string): void {
+function writeFrontendTemplate(projectDir: string, name: string, apiBaseUrl: string, includeConfig = true): void {
   mkdirSync(path.join(projectDir, 'src'), { recursive: true, mode: 0o755 })
-  const files: readonly TemplateFile[] = [
+  const files: TemplateFile[] = [
     ['package.json', frontendPackageJson(name)],
     ['index.html', '<div id="root"></div><script type="module" src="/src/main.tsx"></script>\n'],
     ['src/styles.css', 'body{margin:0;font-family:system-ui,sans-serif}main{min-height:100svh;display:grid;place-items:center;padding:2rem}code{font-family:ui-monospace,monospace}\n'],
     ['src/vite-env.d.ts', frontendViteEnvSource()],
     ['src/main.tsx', frontendSource(apiBaseUrl)],
     ['tsconfig.json', frontendTsConfig()],
-    ['vite.config.ts', 'import react from "@vitejs/plugin-react";\nimport { defineConfig } from "vite";\n\nexport default defineConfig({ plugins: [react()] });\n'],
-    ['tovuk.toml', frontendConfig(projectDir)]
+    ['vite.config.ts', 'import react from "@vitejs/plugin-react";\nimport { defineConfig } from "vite";\n\nexport default defineConfig({ plugins: [react()] });\n']
   ]
+  if (includeConfig) {
+    files.push(['tovuk.toml', frontendConfig(projectDir, true)])
+  }
   writeTemplateFiles(projectDir, files)
   console.log('run package install in the frontend directory before doctor: bun install or npm install')
 }
@@ -107,6 +114,19 @@ function writeNewFile(file: string, source: string): void {
   writeFileSync(file, source, { mode: 0o644 })
 }
 
+function initConfig(projectDir: string, kind: ReturnType<typeof inferProjectKind>): string {
+  if (kind === 'fullstack') {
+    const roots = detectFullstackRoots(projectDir)
+    if (!roots) {
+      throw agentError('fullstack_roots_missing', 'Could not find fullstack roots.', 'Create api/Cargo.toml and web/package.json or web/index.html, then retry.', false)
+    }
+    return fullstackConfig(projectDir, roots)
+  }
+  return kind === 'static_frontend'
+    ? frontendConfig(projectDir)
+    : rustBackendConfig(projectDir)
+}
+
 function rustBackendConfig(projectDir: string): string {
   const name = serviceNameFromCargo(projectDir) || serviceNameFromDir(projectDir)
   return `name = "${name}"
@@ -127,18 +147,58 @@ idle_timeout_minutes = 15
 `
 }
 
-function frontendConfig(projectDir: string): string {
+function frontendConfig(projectDir: string, preferBun = false): string {
   const name = serviceNameFromPackage(projectDir) || serviceNameFromDir(projectDir)
+  const frontend = frontendBuildSettings(projectDir, preferBun)
   return `name = "${name}"
 kind = "static_frontend"
 
 [build]
-check = "${frontendCheckCommand(projectDir)}"
-command = "${frontendBuildCommand(projectDir)}"
-output = "dist"
+check = "${frontend.check}"
+command = "${frontend.build}"
+output = "${frontend.output}"
 `
 }
 
+function fullstackConfig(projectDir: string, roots: { backend: string; frontend: string }, preferBun = false): string {
+  const name = serviceNameFromDir(projectDir)
+  const backendDir = path.join(projectDir, roots.backend)
+  const frontendDir = path.join(projectDir, roots.frontend)
+  const backendName = serviceNameFromCargo(backendDir) || serviceNameFromDir(backendDir)
+  const frontend = frontendBuildSettings(frontendDir, preferBun)
+  return `name = "${name}"
+kind = "fullstack"
+
+[backend]
+root = "${roots.backend}"
+check = "${DEFAULT_RUST_CHECK_COMMAND}"
+build = "cargo build --release"
+command = "./target/release/${backendName}"
+port = 3000
+health = "/api/healthz"
+
+[frontend]
+root = "${roots.frontend}"
+check = "${frontend.check}"
+build = "${frontend.build}"
+output = "${frontend.output}"
+
+[resources]
+memory = "512mb"
+cpu = "0.25"
+idle_timeout_minutes = 15
+`
+}
+
+function frontendBuildSettings(projectDir: string, preferBun: boolean): { check: string; build: string; output: string } {
+  const output = isPlainStaticFrontend(projectDir) ? '.' : 'dist'
+  return {
+    check: preferBun && output !== '.' ? DEFAULT_BUN_FRONTEND_CHECK_COMMAND : frontendCheckCommand(projectDir),
+    build: preferBun && output !== '.' ? 'bun run build' : frontendBuildCommand(projectDir),
+    output
+  }
+}
+
 function installProject(projectDir: string, template = ''): void {
   initProject(projectDir, template)
   doctorProject(projectDir, false)

package/src/internal/types.ts

@@ -5,7 +5,7 @@ export interface JsonObject {
 }
 
 export type ApiMethod = 'DELETE' | 'GET' | 'POST' | 'PUT'
-export type ProjectKind = 'rust_backend' | 'static_frontend'
+export type ProjectKind = 'fullstack' | 'rust_backend' | 'static_frontend'
 export type DiscoveredProjectKind = ProjectKind | 'unknown'
 export type TemplateName = 'fullstack-rust-tanstack' | 'rust-api' | 'tanstack-static-frontend'
 
@@ -47,15 +47,25 @@ export interface PackageManifest {
 
 export type BuildConfig = JsonObject & { command: string; check: string; output?: string }
 export type RunConfig = JsonObject & { command?: string; port: number; health: string }
+export type FrontendConfig = JsonObject & { root?: string; check?: string; build?: string; output?: string }
+export type BackendConfig = JsonObject & { root?: string; check?: string; build?: string; command?: string; port?: number; health?: string }
 export type ResourceConfig = JsonObject & { memory: string; cpu: string; idle_timeout_minutes: number }
-export type TovukConfig = JsonObject & { name?: string; kind: ProjectKind; build: BuildConfig; run: RunConfig; resources: ResourceConfig }
+export type TovukConfig = JsonObject & {
+  name?: string
+  kind: ProjectKind
+  build: BuildConfig
+  run: RunConfig
+  frontend: FrontendConfig
+  backend: BackendConfig
+  resources: ResourceConfig
+}
 export type DoctorCheck = JsonObject & { name: string; ok: boolean; message: string; agent_instruction: string | null }
 export type DoctorReport = JsonObject & { ok: boolean; project: string; config: TovukConfig | null; checks: DoctorCheck[] }
 export type ProjectDoctorReport = DoctorReport & { relative: string }
 export type WorkspaceDoctorReport = JsonObject & { ok: boolean; workspace: string; projects: ProjectDoctorReport[] }
 export type DeployProjectInfo = { dir: string; relative: string; name: string; kind: DiscoveredProjectKind }
 export type DeployPlanProject = { project: DeployProjectInfo; wantsDatabase: boolean }
-export type FrontendSourceReport = { typescript: string[]; javascript: string[] }
+export type FrontendSourceReport = { typescript: string[]; javascript: string[]; serverRoutes: string[] }
 export type LoginStartResponse = JsonObject & { loginUrl?: string; userCode?: string; deviceCode?: string; expiresInSeconds?: number; intervalSeconds?: number }
 export type LoginPollResponse = JsonObject & { status?: string; token?: string; email?: string; intervalSeconds?: number }
 export type AppSummary = JsonObject & { id?: string; name?: string; url?: string; databaseStorageMib?: number }

package/src/internal/workspace.ts

@@ -52,10 +52,13 @@ function kindOrder(kind: DiscoveredProjectKind): number {
   if (kind === 'rust_backend') {
     return 0
   }
-  if (kind === 'static_frontend') {
+  if (kind === 'fullstack') {
     return 1
   }
-  return 2
+  if (kind === 'static_frontend') {
+    return 2
+  }
+  return 3
 }
 
 export { discoverDeployProjects }