@tdk-landscape/tdk-cli-core 1.3.88 → 1.3.90

package/cli/dist/backend-frameworks/elysia.js

@@ -0,0 +1,39 @@
+export function getElysiaIndexTemplate(name) {
+    return `import { Elysia } from 'elysia';
+
+const port = Number(process.env.PORT || 3000);
+
+const app = new Elysia()
+  // Health check endpoint (required by TILT_RESOURCE_DEFAULTS.star)
+  .get('/health', () => ({ status: 'ok', service: '${name}' }))
+  .get('/health/live', () => ({ status: 'alive', timestamp: Date.now() }))
+  .get('/health/ready', ({ set }) => {
+    const dependencies: Record<string, string> = {};
+    let allReady = true;
+
+    // Add dependency checks here (database, cache, etc.)
+    // Mark allReady = false if any dependency is unhealthy
+
+    set.status = allReady ? 200 : 503;
+    return { status: allReady ? 'ready' : 'not_ready', dependencies };
+  })
+  .get('/', () => ({
+    service: '${name}',
+    version: '1.0.0',
+    endpoints: ['/health', '/health/live', '/health/ready']
+  }))
+  // Bind beyond loopback: Traefik reaches the container over the Docker network.
+  .listen({ port, hostname: '0.0.0.0' });
+
+console.log('\\n🚀 ${name} running on http://localhost:' + app.server?.port);
+console.log('📊 Health check: http://localhost:' + app.server?.port + '/health\\n');
+`;
+}
+export const elysiaBackendProvider = {
+    id: "elysia",
+    label: "Bun + Elysia",
+    dependencies: { elysia: "^1.3.0" },
+    devDependencies: {},
+    createIndex: getElysiaIndexTemplate,
+};
+//# sourceMappingURL=elysia.js.map

package/cli/dist/backend-frameworks/fastify.js

@@ -0,0 +1,44 @@
+export function getFastifyIndexTemplate(name) {
+    return `import Fastify from 'fastify';
+
+const app = Fastify();
+
+// Health check endpoint (required by TILT_RESOURCE_DEFAULTS.star)
+app.get('/health', async () => ({ status: 'ok', service: '${name}' }));
+
+app.get('/health/live', async () => ({ status: 'alive', timestamp: Date.now() }));
+
+app.get('/health/ready', async (_request, reply) => {
+  const dependencies: Record<string, string> = {};
+  let allReady = true;
+
+  // Add dependency checks here (database, cache, etc.)
+  // Mark allReady = false if any dependency is unhealthy
+
+  const status = allReady ? 'ready' : 'not_ready';
+  return reply.code(allReady ? 200 : 503).send({ status, dependencies });
+});
+
+app.get('/', async () => ({
+  service: '${name}',
+  version: '1.0.0',
+  endpoints: ['/health', '/health/live', '/health/ready']
+}));
+
+const port = Number(process.env.PORT || 3000);
+
+// Bind beyond loopback: Traefik reaches the container over the Docker network.
+await app.listen({ port, host: '0.0.0.0' });
+
+console.log('\\n🚀 ${name} running on http://localhost:' + port);
+console.log('📊 Health check: http://localhost:' + port + '/health\\n');
+`;
+}
+export const fastifyBackendProvider = {
+    id: "fastify",
+    label: "Bun + Fastify",
+    dependencies: { fastify: "^5.0.0" },
+    devDependencies: {},
+    createIndex: getFastifyIndexTemplate,
+};
+//# sourceMappingURL=fastify.js.map

package/cli/dist/backend-frameworks/nestjs.js

@@ -0,0 +1,56 @@
+export function getNestIndexTemplate(name) {
+    return `import 'reflect-metadata';
+import { Controller, Get, Module } from '@nestjs/common';
+import { NestFactory } from '@nestjs/core';
+
+@Controller()
+class AppController {
+  // Health check endpoint (required by TILT_RESOURCE_DEFAULTS.star)
+  @Get('health')
+  health() {
+    return { status: 'ok', service: '${name}' };
+  }
+
+  @Get('health/live')
+  live() {
+    return { status: 'alive', timestamp: Date.now() };
+  }
+
+  @Get()
+  root() {
+    return { service: '${name}', version: '1.0.0', endpoints: ['/health', '/health/live'] };
+  }
+}
+
+@Module({ controllers: [AppController] })
+class AppModule {}
+
+async function bootstrap() {
+  const app = await NestFactory.create(AppModule, { logger: ['error', 'warn', 'log'] });
+  const port = Number(process.env.PORT || 3000);
+
+  // Bind beyond loopback: Traefik reaches the container over the Docker network.
+  await app.listen(port, '0.0.0.0');
+  console.log('\\n🚀 ${name} running on http://localhost:' + port);
+  console.log('📊 Health check: http://localhost:' + port + '/health\\n');
+}
+
+bootstrap();
+`;
+}
+export const nestBackendProvider = {
+    id: "nestjs",
+    label: "Bun + NestJS",
+    dependencies: {
+        "@nestjs/common": "^11.0.0",
+        "@nestjs/core": "^11.0.0",
+        "@nestjs/platform-express": "^11.0.0",
+        "reflect-metadata": "^0.2.2",
+        rxjs: "^7.8.1",
+    },
+    devDependencies: {},
+    // Nest's decorators need these; the engine's generated Docker tsconfig already sets them.
+    compilerOptions: { experimentalDecorators: true, emitDecoratorMetadata: true },
+    createIndex: getNestIndexTemplate,
+};
+//# sourceMappingURL=nestjs.js.map

package/cli/dist/backend-frameworks/registry.js

@@ -1,6 +1,9 @@
 import { getBackendIndexTemplate } from "../backend-languages/bun.js";
 import { TdkError } from "../utils/errors.js";
+import { elysiaBackendProvider } from "./elysia.js";
 import { expressBackendProvider } from "./express.js";
+import { fastifyBackendProvider } from "./fastify.js";
+import { nestBackendProvider } from "./nestjs.js";
 /** Hono is the historical default; omitting --framework keeps the exact historical output. */
 export const DEFAULT_BACKEND_FRAMEWORK = "hono";
 export const honoBackendProvider = {
@@ -13,6 +16,9 @@ export const honoBackendProvider = {
 export const BACKEND_FRAMEWORKS = {
     hono: honoBackendProvider,
     express: expressBackendProvider,
+    elysia: elysiaBackendProvider,
+    fastify: fastifyBackendProvider,
+    nestjs: nestBackendProvider,
 };
 export function getBackendFramework(frameworkId) {
     const id = (frameworkId ?? DEFAULT_BACKEND_FRAMEWORK).trim().toLowerCase();

package/cli/dist/backend-languages/go.js

@@ -0,0 +1,98 @@
+/**
+ * Go has no reload process inside the image, so the dev command is only what a developer would run by
+ * hand. Tilt rebuilds the image when a watched file changes (the engine returns no live-update rules).
+ */
+export const GO_DEV_COMMAND = "go run .";
+export const goBackendProvider = {
+    id: "go",
+    label: "Go 1.23 (net/http)",
+    devCommand: GO_DEV_COMMAND,
+    watch: ["**/*.go", "go.mod", "go.sum"],
+    installHint: "go mod tidy   # optional: Docker builds the image for you",
+    createFiles(name) {
+        return [
+            {
+                filename: "go.mod",
+                content: `module ${name}
+
+go 1.23
+`,
+                description: "Generating go.mod",
+                emoji: "📦",
+            },
+            {
+                filename: "main.go",
+                content: `package main
+
+import (
+	"encoding/json"
+	"log"
+	"net/http"
+	"os"
+)
+
+func writeJSON(w http.ResponseWriter, status int, body any) {
+	w.Header().Set("Content-Type", "application/json")
+	w.WriteHeader(status)
+	_ = json.NewEncoder(w).Encode(body)
+}
+
+func newMux() *http.ServeMux {
+	mux := http.NewServeMux()
+
+	// Health check endpoint (required by TILT_RESOURCE_DEFAULTS.star)
+	mux.HandleFunc("GET /health", func(w http.ResponseWriter, r *http.Request) {
+		writeJSON(w, http.StatusOK, map[string]string{"status": "ok", "service": "${name}"})
+	})
+
+	mux.HandleFunc("GET /{$}", func(w http.ResponseWriter, r *http.Request) {
+		writeJSON(w, http.StatusOK, map[string]any{
+			"service":   "${name}",
+			"version":   "1.0.0",
+			"endpoints": []string{"/health"},
+		})
+	})
+
+	return mux
+}
+
+func main() {
+	port := os.Getenv("PORT")
+	if port == "" {
+		port = "3000"
+	}
+
+	// ":" + port listens on every interface, which Traefik needs inside the container network.
+	log.Printf("${name} listening on :%s", port)
+	log.Fatal(http.ListenAndServe(":"+port, newMux()))
+}
+`,
+                description: "Generating backend source",
+                emoji: "💻",
+            },
+            {
+                filename: "main_test.go",
+                content: `package main
+
+import (
+	"net/http"
+	"net/http/httptest"
+	"testing"
+)
+
+func TestHealth(t *testing.T) {
+	rec := httptest.NewRecorder()
+	newMux().ServeHTTP(rec, httptest.NewRequest(http.MethodGet, "/health", nil))
+
+	if rec.Code != http.StatusOK {
+		t.Fatalf("GET /health = %d, want %d", rec.Code, http.StatusOK)
+	}
+}
+`,
+                description: "Generating smoke test",
+                emoji: "🧪",
+            },
+        ];
+    },
+};
+//# sourceMappingURL=go.js.map

package/cli/dist/backend-languages/registry.js

@@ -1,10 +1,14 @@
 import { TdkError } from "../utils/errors.js";
 import { bunBackendProvider } from "./bun.js";
+import { goBackendProvider } from "./go.js";
 import { pythonBackendProvider } from "./python.js";
+import { rustBackendProvider } from "./rust.js";
 export const DEFAULT_BACKEND_LANGUAGE = "bun";
 export const BACKEND_LANGUAGES = {
     bun: bunBackendProvider,
     python: pythonBackendProvider,
+    go: goBackendProvider,
+    rust: rustBackendProvider,
 };
 export function getBackendLanguage(languageId) {
     const id = (languageId ?? DEFAULT_BACKEND_LANGUAGE).trim().toLowerCase();

package/cli/dist/backend-languages/rust.js

@@ -0,0 +1,83 @@
+/**
+ * Rust is compiled into the image and has no reload process, so the dev command is only what a developer
+ * would run by hand. Tilt rebuilds the image when a watched file changes (the engine returns no live-update rules).
+ */
+export const RUST_DEV_COMMAND = "cargo run";
+export const rustBackendProvider = {
+    id: "rust",
+    label: "Rust (axum)",
+    devCommand: RUST_DEV_COMMAND,
+    watch: ["src/**/*.rs", "Cargo.toml", "Cargo.lock"],
+    installHint: "cargo build   # optional: Docker builds the image for you",
+    createFiles(name) {
+        return [
+            {
+                filename: "Cargo.toml",
+                content: `[package]
+name = "${name}"
+version = "0.1.0"
+edition = "2021"
+
+# The image copies the release binary by this fixed name.
+[[bin]]
+name = "app"
+path = "src/main.rs"
+
+[dependencies]
+axum = "0.8"
+serde_json = "1"
+tokio = { version = "1", features = ["macros", "rt-multi-thread", "net"] }
+`,
+                description: "Generating Cargo.toml",
+                emoji: "📦",
+            },
+            {
+                filename: "src/main.rs",
+                content: `use axum::{routing::get, Json, Router};
+use serde_json::{json, Value};
+
+fn app() -> Router {
+    Router::new()
+        .route("/", get(root))
+        // Health check endpoint (required by TILT_RESOURCE_DEFAULTS.star)
+        .route("/health", get(health))
+}
+
+async fn root() -> Json<Value> {
+    Json(json!({ "service": "${name}", "version": "1.0.0", "endpoints": ["/health"] }))
+}
+
+async fn health() -> Json<Value> {
+    Json(json!({ "status": "ok", "service": "${name}" }))
+}
+
+#[tokio::main]
+async fn main() {
+    let port = std::env::var("PORT").unwrap_or_else(|_| "3000".to_string());
+
+    // 0.0.0.0 listens on every interface, which Traefik needs inside the container network.
+    let listener = tokio::net::TcpListener::bind(format!("0.0.0.0:{port}"))
+        .await
+        .expect("failed to bind the port");
+    println!("${name} listening on 0.0.0.0:{port}");
+    axum::serve(listener, app()).await.expect("server error");
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[tokio::test]
+    async fn health_reports_ok() {
+        let Json(body) = health().await;
+        assert_eq!(body["status"], "ok");
+    }
+}
+`,
+                description: "Generating backend source and smoke test",
+                emoji: "💻",
+            },
+        ];
+    },
+};
+//# sourceMappingURL=rust.js.map

package/cli/dist/commands/resource.js

@@ -154,11 +154,13 @@ export function createPackageJson(name, type, frameworkId) {
 }
 export function createResourceTsconfig(resourceType, frameworkId) {
     const framework = resolveFrontendFramework(resourceType, frameworkId);
+    const backendFramework = resolveBackendFramework(resourceType, frameworkId);
     return {
         ...TSCONFIG_TEMPLATE,
         compilerOptions: {
             ...TSCONFIG_TEMPLATE.compilerOptions,
             ...(framework?.compilerOptions ?? {}),
+            ...(backendFramework?.compilerOptions ?? {}),
         },
     };
 }
@@ -295,8 +297,8 @@ export const resourceCommand = new Command("resource")
     .description("Create a new resource (service) from scratch, or register an existing one")
     .argument("[name]", "Resource name (kebab-case)")
     .option("-t, --type <type>", "Resource type: backend, frontend, worker, bring-your-own, sdk", "backend")
-    .option("--framework <id>", "Framework: frontend react (default), vue, svelte, preact, lit, solid, qwik; backend hono (default), express")
-    .option("--language <id>", "Backend language: bun (default), python")
+    .option("--framework <id>", "Framework: frontend react (default), vue, svelte, preact, lit, solid, qwik, vanilla; backend hono (default), express, elysia, fastify, nestjs")
+    .option("--language <id>", "Backend language: bun (default), python, go, rust")
     .option("-s, --stack <stack>", "Stack to assign resource to", "default")
     .option("-p, --path <path>", "Custom path for resource directory")
     .option("--resource-path <path>", "Alias for --path (for backward compatibility)")
@@ -584,8 +586,13 @@ This file contains the resource configuration for TDK.
         // Create directory structure for new resources
         console.log(chalk.blue("\n📁 Creating directory structure..."));
         mkdirSync(fullPath, { recursive: true });
-        mkdirSync(resolve(fullPath, "src"), { recursive: true });
-        mkdirSync(resolve(fullPath, "tests"), { recursive: true });
+        // A provider that owns its runtime files only gets the folders it writes into (Go keeps its files at the root).
+        const ownedTopLevel = new Set((backendLanguage?.createFiles?.(resourceName) ?? []).map((file) => file.filename.split("/")[0]));
+        for (const folder of ["src", "tests"]) {
+            if (!backendLanguage?.createFiles || ownedTopLevel.has(folder)) {
+                mkdirSync(resolve(fullPath, folder), { recursive: true });
+            }
+        }
         if (resourceType === "frontend") {
             mkdirSync(resolve(fullPath, "public"), { recursive: true });
         }
@@ -615,7 +622,7 @@ This file contains the resource configuration for TDK.
             {
                 type: "json",
                 filename: "tsconfig.json",
-                content: createResourceTsconfig(resourceType, frontendFramework?.id),
+                content: createResourceTsconfig(resourceType, frontendFramework?.id ?? backendFramework?.id),
                 description: "Generating tsconfig.json",
                 emoji: "⚙️",
             },

package/cli/dist/frontend-frameworks/registry.js

@@ -5,6 +5,7 @@ import { qwikFrontendProvider } from "./qwik.js";
 import { reactFrontendProvider } from "./react.js";
 import { solidFrontendProvider } from "./solid.js";
 import { svelteFrontendProvider } from "./svelte.js";
+import { vanillaFrontendProvider } from "./vanilla.js";
 import { vueFrontendProvider } from "./vue.js";
 export const DEFAULT_FRONTEND_FRAMEWORK = "react";
 export const FRONTEND_FRAMEWORKS = {
@@ -15,6 +16,7 @@ export const FRONTEND_FRAMEWORKS = {
     lit: litFrontendProvider,
     solid: solidFrontendProvider,
     qwik: qwikFrontendProvider,
+    vanilla: vanillaFrontendProvider,
 };
 export function getFrontendFramework(frameworkId) {
     const id = (frameworkId ?? DEFAULT_FRONTEND_FRAMEWORK).trim().toLowerCase();

package/cli/dist/frontend-frameworks/vanilla.js

@@ -0,0 +1,60 @@
+export const vanillaFrontendProvider = {
+    id: "vanilla",
+    label: "Vanilla TypeScript + Vite",
+    dependencies: {},
+    devDependencies: {},
+    compilerOptions: {},
+    createFiles(name) {
+        return [
+            {
+                filename: "index.html",
+                content: `<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>${name}</title>
+  </head>
+  <body>
+    <div id="app"></div>
+    <script type="module" src="/src/main.ts"></script>
+  </body>
+</html>
+`,
+                description: "Generating HTML template",
+                emoji: "💻",
+            },
+            {
+                filename: "src/main.ts",
+                content: `import { renderApp } from './app';
+
+const root = document.getElementById('app');
+if (root) {
+  renderApp(root);
+}
+`,
+                description: "Generating vanilla entry",
+                emoji: "💻",
+            },
+            {
+                filename: "src/app.ts",
+                content: `export function renderApp(root: HTMLElement): void {
+  root.style.padding = '2rem';
+  root.style.fontFamily = 'system-ui';
+
+  const title = document.createElement('h1');
+  title.textContent = '${name}';
+
+  const note = document.createElement('p');
+  note.textContent = 'Frontend resource created with TDK';
+
+  root.replaceChildren(title, note);
+}
+`,
+                description: "Generating vanilla app",
+                emoji: "💻",
+            },
+        ];
+    },
+};
+//# sourceMappingURL=vanilla.js.map

package/cli/package.json

@@ -1,7 +1,7 @@
 {
   "name": "tdk-cli-internal",
   "private": true,
-  "version": "1.3.88",
+  "version": "1.3.90",
   "description": "TDK CLI — start services on your laptop.",
   "keywords": [
     "tdk",

package/engine/schemas/service-schema.json

@@ -107,7 +107,7 @@
       "type": "string"
     },
     "appType": {
-      "description": "Resource type determining build strategy:\n• backend - Hono/Express API server\n• frontend - Vite single-page application (React, Vue, Svelte, Preact, Lit, Solid or Qwik, see framework)\n• sdk - Shared library package\n• worker - Background job processor\n• migrator - Database migration runner\n• library - Shared code library\n• bring-your-own - Wrap an existing service. No app scaffold. Needs Dockerfile or --image.",
+      "description": "Resource type determining build strategy:\n• backend - Hono/Express API server\n• frontend - Vite single-page application (React, Vue, Svelte, Preact, Lit, Solid, Qwik or Vanilla TypeScript, see framework)\n• sdk - Shared library package\n• worker - Background job processor\n• migrator - Database migration runner\n• library - Shared code library\n• bring-your-own - Wrap an existing service. No app scaffold. Needs Dockerfile or --image.",
       "enum": [
         "backend",
         "frontend",
@@ -234,8 +234,12 @@
         "lit",
         "solid",
         "qwik",
+        "vanilla",
         "hono",
-        "express"
+        "express",
+        "elysia",
+        "fastify",
+        "nestjs"
       ],
       "pattern": "^[a-z][a-z0-9-]*$",
       "type": "string"
@@ -244,7 +248,9 @@
       "description": "Backend language provider id used to scaffold and run the service. Only meaningful for backend resources; omitted means bun (legacy manifests). Valid ids come from the CLI provider registry.",
       "examples": [
         "bun",
-        "python"
+        "python",
+        "go",
+        "rust"
       ],
       "pattern": "^[a-z][a-z0-9-]*$",
       "type": "string"

package/engine/topologies/platform/docker/dockerfile/language_dockerfile.star

@@ -8,7 +8,14 @@
 BASE_PORT_BACKEND = 4000
 
 # Languages whose runtime files are owned by the provider (no Vite/tsconfig/Bun config).
-PROVIDER_OWNED_LANGUAGES = ["python"]
+PROVIDER_OWNED_LANGUAGES = ["python", "go", "rust"]
+
+# Files a provider-owned language must scaffold; checked before generating anything.
+LANGUAGE_REQUIRED_FILES = {
+    "python": ["pyproject.toml", "src/main.py"],
+    "go": ["go.mod", "main.go"],
+    "rust": ["Cargo.toml", "src/main.rs"],
+}
 
 _CURL = """RUN apt-get update && apt-get install -y --no-install-recommends curl \\
   && rm -rf /var/lib/apt/lists/*
@@ -42,9 +49,62 @@ EXPOSE {port}
 CMD ["sh", "-c", "uvicorn main:app --app-dir src --host 0.0.0.0 --port ${{PORT:-{port}}} --reload --reload-dir src"]
 """
 
+_GO = """# Generated by TDK for a Go backend. Do not edit; change service.json instead.
+FROM golang:1.23-bookworm AS build
+
+WORKDIR /app/{res_path}
+
+COPY {res_path}/go.* ./
+RUN go mod download
+
+COPY {res_path}/ ./
+RUN CGO_ENABLED=0 go build -o /out/app .
+
+FROM build AS test
+RUN go test ./...
+
+FROM debian:bookworm-slim AS production
+
+{curl}
+COPY --from=build /out/app /usr/local/bin/app
+
+{healthcheck}
+EXPOSE {port}
+
+CMD ["app"]
+"""
+
+_RUST = """# Generated by TDK for a Rust backend. Do not edit; change service.json instead.
+# BuildKit cache mounts keep the registry and the target directory between builds, so a rebuild after a
+# source change recompiles only the crate itself, not every dependency.
+FROM rust:1-slim-bookworm AS build
+
+WORKDIR /app/{res_path}
+
+COPY {res_path}/ ./
+RUN --mount=type=cache,target=/usr/local/cargo/registry \\
+    --mount=type=cache,target=/app/{res_path}/target \\
+    cargo build --release && mkdir -p /out && cp target/release/app /out/app
+
+FROM build AS test
+RUN --mount=type=cache,target=/usr/local/cargo/registry \\
+    --mount=type=cache,target=/app/{res_path}/target \\
+    cargo test
+
+FROM debian:bookworm-slim AS production
+
+{curl}
+COPY --from=build /out/app /usr/local/bin/app
+
+{healthcheck}
+EXPOSE {port}
+
+CMD ["app"]
+"""
+
 def generate_language_dockerfile(res_path, language, port = BASE_PORT_BACKEND):
     """Dockerfile text for a provider-owned backend language, or fail for an unknown one."""
-    template = {"python": _PYTHON}.get(language)
+    template = {"python": _PYTHON, "go": _GO, "rust": _RUST}.get(language)
     if template == None:
         fail("No Dockerfile generator for backend language '{}'".format(language))
     return template.format(
@@ -56,7 +116,7 @@ def generate_language_dockerfile(res_path, language, port = BASE_PORT_BACKEND):
 
 
 def is_provider_owned_language(manifest):
-    """True when the manifest selects Python (a missing language means Bun)."""
+    """True when the manifest selects a provider-owned language (a missing language means Bun)."""
     if not manifest:
         return False
     return manifest.get("appType", "backend") == "backend" and manifest.get("language", "bun") in PROVIDER_OWNED_LANGUAGES

package/engine/topologies/platform/docker/index.star

@@ -8,6 +8,7 @@ load(
     "./dockerfile/language_dockerfile.star",
     "generate_language_dockerfile",
     "is_provider_owned_language",
+    "LANGUAGE_REQUIRED_FILES",
 )
 load("./config/dockerignore.star", "generate_dockerignore")
 load(
@@ -25,6 +26,7 @@ Docker = struct(
     migrator = generate_migrator_dockerfile,
     backend_language = generate_language_dockerfile,
     is_provider_owned_language = is_provider_owned_language,
+    language_required_files = LANGUAGE_REQUIRED_FILES,
     generate_dockerignore = generate_dockerignore,
     frontend_compose = generate_frontend_compose,
     backend_compose = generate_backend_compose_entry,

package/engine/topologies/tilt/generators/typescript/frontend_tsconfig.star

@@ -77,7 +77,7 @@ def generate_frontend_tsconfig(resource_path, write_fn, internal_deps=None, is_d
                 resource_path
             ))
             print("   Docker build will resolve @{npm_scope}/* from node_modules")
-    if framework not in ['react', 'vue', 'svelte', 'preact', 'lit', 'solid', 'qwik']:
+    if framework not in ['react', 'vue', 'svelte', 'preact', 'lit', 'solid', 'qwik', 'vanilla']:
         fail("Unknown frontend framework for TypeScript generation: " + str(framework))
 
     compiler_options = {

package/engine/topologies/tilt/generators/validators.star

@@ -555,9 +555,11 @@ def generate_resource_health_check(resource_name, resource_path, manifest, check
     health_checks = []
     
     # Check 1: Required files exist
-    frontend_entry = "src/main.ts" if manifest.get("framework", "react") in ["vue", "svelte", "lit"] else "src/main.tsx"
+    frontend_entry = "src/main.ts" if manifest.get("framework", "react") in ["vue", "svelte", "lit", "vanilla"] else "src/main.tsx"
     backend_files = {
         "python": ["pyproject.toml", "src/main.py"],
+        "go": ["go.mod", "main.go"],
+        "rust": ["Cargo.toml", "src/main.rs"],
     }.get(manifest.get("language", "bun"), ["package.json", "prisma/schema.prisma"])
     required_files = {
         "backend": backend_files,
@@ -573,8 +575,8 @@ if [ ! -f "{}" ]; then
 fi
 '''.format(req_file, req_file))
     
-    # Check 2: Package.json is valid JSON (Python backends have no package.json)
-    if manifest.get("language", "bun") != "python":
+    # Check 2: Package.json is valid JSON (Python and Go backends have no package.json)
+    if manifest.get("language", "bun") not in ["python", "go", "rust"]:
         health_checks.append('''
 if ! cat package.json | head -1 > /dev/null 2>&1; then
     echo "❌ package.json is not valid"

package/engine/topologies/tilt/generators/vite/frameworks/vanilla.star

@@ -0,0 +1,90 @@
+# Vanilla TypeScript-specific Vite templates for frontend resources.
+
+VANILLA_VITE_FRONTEND = """{header}
+import {{ resolve }} from 'node:path';
+import {{ defineConfig }} from 'vite';
+
+export default defineConfig({{
+  base: '{base_path}',
+  build: {{
+    cssCodeSplit: false,
+    minify: false,
+    modulePreload: false,
+    rollupOptions: {{
+      output: {{
+        entryFileNames: '[name].js',
+        format: 'esm',
+      }},
+    }},
+    target: 'esnext',
+  }},
+  define: {{
+    global: 'globalThis',
+  }},
+  optimizeDeps: {{
+    include: [{optimize_deps_include}],
+  }},
+  plugins: [],
+  preview: {{
+    host: '0.0.0.0',
+    port: {port},
+  }},
+  resolve: {{
+    alias: {{
+      '@/autogenerated': resolve(__dirname),
+      '@': resolve(__dirname, '../src'),
+      'set-cookie-parser': resolve(__dirname, '../src/utils/empty-module.js'),
+{internal_aliases}
+    }},
+  }},
+  server: {{
+    host: '0.0.0.0',
+    port: {port},
+    hmr: {{
+      port: {hmr_port},
+    }},
+{proxy_config}
+  }},
+}});
+"""
+
+VANILLA_VITE_FRONTEND_BUILD = """{header}
+import {{ resolve }} from 'node:path';
+import {{ defineConfig }} from 'vite';
+
+export default defineConfig({{
+  mode: 'production',
+  base: '{base_path}',
+  build: {{
+    cssCodeSplit: false,
+    minify: true,
+    modulePreload: false,
+    rollupOptions: {{
+      output: {{
+        entryFileNames: '[name].js',
+        format: 'esm',
+        manualChunks: undefined,
+      }},
+    }},
+    target: 'esnext',
+  }},
+  define: {{
+    global: 'globalThis',
+    __DEV__: 'false',
+    'process.env.NODE_ENV': '"production"',
+  }},
+  optimizeDeps: {{
+    include: [{optimize_deps_include}],
+  }},
+  plugins: [],
+  resolve: {{
+    alias: {{
+      '@/autogenerated': resolve(__dirname),
+      '@': resolve(__dirname, '../src'),
+      'set-cookie-parser': resolve(__dirname, '../src/utils/empty-module.js'),
+    }},
+    conditions: ['browser', 'import', 'module', 'es2020', 'default'],
+    mainFields: ['browser', 'module', 'jsnext:main', 'jsnext', 'main'],
+  }},
+}});
+"""

package/engine/topologies/tilt/generators/vite/frontend.star

@@ -22,6 +22,7 @@ load('./frameworks/preact.star', 'PREACT_VITE_FRONTEND', 'PREACT_VITE_FRONTEND_B
 load('./frameworks/lit.star', 'LIT_VITE_FRONTEND', 'LIT_VITE_FRONTEND_BUILD')
 load('./frameworks/solid.star', 'SOLID_VITE_FRONTEND', 'SOLID_VITE_FRONTEND_BUILD')
 load('./frameworks/qwik.star', 'QWIK_VITE_FRONTEND', 'QWIK_VITE_FRONTEND_BUILD')
+load('./frameworks/vanilla.star', 'VANILLA_VITE_FRONTEND', 'VANILLA_VITE_FRONTEND_BUILD')
 load('../../../platform/docker/networking/api_path_constants.star', 'get_frontend_base_path')
 load('./helpers.star', 
     'build_header', 
@@ -63,6 +64,10 @@ _FRAMEWORK_TEMPLATES = {
         'dev': QWIK_VITE_FRONTEND,
         'build': QWIK_VITE_FRONTEND_BUILD,
     },
+    'vanilla': {
+        'dev': VANILLA_VITE_FRONTEND,
+        'build': VANILLA_VITE_FRONTEND_BUILD,
+    },
 }
 
 def _normalize_vite_base_path(base_path):

package/engine/topologies/tilt/resources/orchestrator/apply_compose_resource_registration.star

@@ -220,7 +220,14 @@ def _build_live_update_rules(res_path, full_res_path, syncs, project_root='', la
 
     Python backends reload their own process after a sync (uvicorn --reload), so they have
     no Bun install step. A changed pyproject.toml is not synced, so Tilt rebuilds the image instead.
+    Go and Rust backends have no live update at all (see the early return).
     """
+    # Go and Rust are compiled into the image and have no reload process, so syncing sources would leave the
+    # old binary running. Return before any sync() step is built (Tilt rejects sync steps that are created
+    # but never used): no live-update rules means Tilt rebuilds the image when a watched file changes.
+    if language in ['go', 'rust']:
+        return []
+
     live_update_rules = []
     for sync_path in syncs:
         # Python images never read the npm/Bun registry config, and the engine does not

package/engine/topologies/tilt/resources/orchestrator/generators/manifest_resource.star

@@ -310,7 +310,7 @@ def _generate_all_configs_for_resource(
     
     app_type = manifest.get('appType', 'backend')
     is_frontend = resource_config.get('frontend', False) or app_type == 'frontend'
-    # Python backends own their runtime files (package/pyproject, Dockerfile,
+    # Provider-owned backends (Python, Go) own their runtime files (package/pyproject, Dockerfile,
     # reload command). Bun-only configs below (Vite, tsconfig, Prisma, bunfig) are skipped.
     provider_owned = Docker.is_provider_owned_language(manifest)
     if provider_owned:
@@ -318,7 +318,7 @@ def _generate_all_configs_for_resource(
         # COPY error halfway through the image build.
         root = ctx.get('project_root', '')
         prefix = (root.rstrip('/') + '/' if root else '') + resource_path + '/'
-        for required in ['pyproject.toml', 'src/main.py']:
+        for required in Docker.language_required_files.get(manifest.get('language'), []):
             if not os.path.exists(prefix + required):
                 fail("{}: language '{}' requires {} but {}{} does not exist".format(
                     resource_name, manifest.get('language'), required, resource_path + '/', required))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tdk-landscape/tdk-cli-core",
-  "version": "1.3.88",
+  "version": "1.3.90",
   "description": "TDK CLI — start services on your laptop.",
   "homepage": "https://tdk-landscape.github.io/tdk-website",
   "repository": {