@tdk-landscape/tdk-cli-core 1.3.74 → 1.3.76

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

@@ -0,0 +1,73 @@
+export const vueFrontendProvider = {
+    id: "vue",
+    label: "Vue + Vite",
+    dependencies: {
+        vue: "^3.5.0",
+    },
+    devDependencies: {
+        "@vitejs/plugin-vue": "^5.2.4",
+    },
+    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 { createApp } from 'vue';
+import App from './App.vue';
+
+createApp(App).mount('#app');
+`,
+                description: "Generating Vue entry",
+                emoji: "💻",
+            },
+            {
+                filename: "src/App.vue",
+                content: `<script setup lang="ts">
+const message = 'Frontend resource created with TDK';
+</script>
+
+<template>
+  <main style="padding: 2rem; font-family: system-ui">
+    <h1>${name}</h1>
+    <p>{{ message }}</p>
+  </main>
+</template>
+`,
+                description: "Generating Vue app",
+                emoji: "💻",
+            },
+            {
+                filename: "src/vite-env.d.ts",
+                content: `/// <reference types="vite/client" />
+
+declare module '*.vue' {
+  import type { Component } from 'vue';
+  const component: Component;
+  export default component;
+}
+`,
+                description: "Generating Vue module types",
+                emoji: "⚙️",
+            },
+        ];
+    },
+};
+//# sourceMappingURL=vue.js.map

package/cli/dist/utils/discovery-paths.js

@@ -0,0 +1,67 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join, relative, resolve, sep } from "node:path";
+// Mirrors discovery/json_manifest_scanner.star: every `discovery.paths` entry is a shell
+// glob of directories, and `find -maxdepth 3` looks for service.json under each match. So a
+// resource is only seen by Tilt if some directory matching a pattern is the resource
+// directory itself or at most this many levels above it.
+const MAX_LEVELS_BELOW_MATCH = 2;
+const DEFAULT_DISCOVERY_PATHS = ["services/*/*"];
+function segments(path) {
+    return path.split(sep).filter(Boolean);
+}
+function segmentMatches(pattern, name) {
+    const source = pattern
+        .replace(/[.+^${}()|[\]\\]/g, "\\$&")
+        .replace(/\*/g, "[^/]*")
+        .replace(/\?/g, "[^/]");
+    return new RegExp(`^${source}$`).test(name);
+}
+function globMatchesDir(patternSegments, dirSegments) {
+    return (patternSegments.length === dirSegments.length &&
+        patternSegments.every((segment, index) => segmentMatches(segment, dirSegments[index])));
+}
+/** `discovery.paths` from .tdk/project.json, or the generic default when unset/unreadable. */
+export function readDiscoveryPaths(projectRoot) {
+    const configPath = join(projectRoot, ".tdk", "project.json");
+    if (!existsSync(configPath))
+        return DEFAULT_DISCOVERY_PATHS;
+    try {
+        const paths = JSON.parse(readFileSync(configPath, "utf-8"))?.discovery?.paths;
+        if (Array.isArray(paths) && paths.every((p) => typeof p === "string"))
+            return paths;
+    }
+    catch { }
+    return DEFAULT_DISCOVERY_PATHS;
+}
+/** Whether Tilt's discovery would find a service.json in `resourceDir` given `patterns`. */
+export function isPathDiscovered(projectRoot, resourceDir, patterns) {
+    const resourceSegments = segments(relative(projectRoot, resolve(projectRoot, resourceDir)));
+    return patterns.some((pattern) => {
+        const patternSegments = segments(relative(projectRoot, resolve(projectRoot, pattern)));
+        for (let levels = 0; levels <= MAX_LEVELS_BELOW_MATCH; levels++) {
+            const depth = resourceSegments.length - levels;
+            if (depth > 0 && globMatchesDir(patternSegments, resourceSegments.slice(0, depth))) {
+                return true;
+            }
+        }
+        return false;
+    });
+}
+/**
+ * Picks the folder for a new resource without an explicit --path. The conventional folder
+ * per type (apps/, workers/, packages/) is kept when discovery covers it; otherwise the
+ * resource goes under services/<stack>/, which the default discovery paths cover, because a
+ * resource outside every discovery path is scaffolded but never started by `tdk up`.
+ */
+export function chooseResourcePath(projectRoot, conventionalPath, stack, name) {
+    const patterns = readDiscoveryPaths(projectRoot);
+    if (isPathDiscovered(projectRoot, conventionalPath, patterns)) {
+        return { path: conventionalPath };
+    }
+    const fallback = `services/${stack}/${name}`;
+    if (isPathDiscovered(projectRoot, fallback, patterns)) {
+        return { path: fallback, adjustedFrom: conventionalPath };
+    }
+    return { path: conventionalPath };
+}
+//# sourceMappingURL=discovery-paths.js.map

package/cli/dist/utils/doctor-wiring.js

@@ -0,0 +1,261 @@
+import { execSync } from "node:child_process";
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { join, relative } from "node:path";
+import { formatCount } from "./formatting.js";
+import { findProjectRoot } from "./paths.js";
+import { discoverResourcesFromRoot } from "./services.js";
+/**
+ * Checks for wiring mistakes that only show up minutes into `tdk up`: an image
+ * build that cannot find package.json, a token check that cannot reach its
+ * identity provider, a frontend calling a port nothing publishes, a queue
+ * feature with no broker. Each one is decidable from the files on disk.
+ */
+const EXEC_TIMEOUT_MS = 10_000;
+const SOURCE_EXTENSIONS = /\.(?:[cm]?[jt]sx?|vue)$/;
+const TEST_FILE = /(?:\.test\.|\.spec\.|\/tests?\/|\/__tests__\/)/;
+const SKIPPED_DIRS = new Set(["node_modules", ".autogenerated", "dist", "tests", "__tests__"]);
+function projectName(projectRoot) {
+    try {
+        const parsed = JSON.parse(readFileSync(join(projectRoot, ".tdk", "project.json"), "utf-8"));
+        return typeof parsed?.project?.name === "string" ? parsed.project.name : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function readParams(configPath) {
+    try {
+        const params = JSON.parse(readFileSync(configPath, "utf-8")).params;
+        return params && typeof params === "object" ? params : {};
+    }
+    catch {
+        return {};
+    }
+}
+/** Backends are the only resources that listen on their `port`. */
+function backendPorts(resources) {
+    const ports = new Map();
+    for (const resource of resources) {
+        const port = resource.config?.port;
+        if (resource.config?.appType === "backend" && typeof port === "number") {
+            ports.set(resource.name, port);
+        }
+    }
+    return ports;
+}
+export function checkResourcePackageJson(projectRoot = findProjectRoot() ?? process.cwd()) {
+    const missing = discoverResourcesFromRoot(projectRoot)
+        .filter((resource) => !existsSync(join(resource.path, "package.json")))
+        .map((resource) => resource.name);
+    if (missing.length === 0) {
+        return {
+            name: "Resource package.json",
+            didPass: true,
+            message: "Every resource has a package.json",
+        };
+    }
+    return {
+        name: "Resource package.json",
+        didPass: false,
+        message: `${formatCount(missing.length, "resource")} without a package.json: ${missing.join(", ")}. The image build stops at "COPY .../package.json: not found"`,
+        fix: "Add a package.json next to each service.json (copy one from a working resource), or delete the folder's service.json if it is not a service",
+    };
+}
+const CONTAINER_URL = /https?:\/\/([a-z][a-z0-9-]*):(\d+)/g;
+export function checkServiceUrlPorts(projectRoot = findProjectRoot() ?? process.cwd()) {
+    const resources = discoverResourcesFromRoot(projectRoot);
+    const ports = backendPorts(resources);
+    const byPort = new Map([...ports].map(([name, port]) => [port, name]));
+    const problems = [];
+    for (const resource of resources) {
+        for (const [key, value] of Object.entries(readParams(resource.configPath))) {
+            for (const [, host, portText] of String(value).matchAll(CONTAINER_URL)) {
+                const port = Number(portText);
+                const expected = ports.get(host);
+                if (expected !== undefined && expected !== port) {
+                    problems.push(`${resource.name} param ${key}: ${host}:${port}, but ${host} listens on ${expected}`);
+                }
+                else if ((host === "localhost" || host === "127.0.0.1") &&
+                    byPort.has(port) &&
+                    byPort.get(port) !== resource.name) {
+                    problems.push(`${resource.name} param ${key}: localhost:${port} is ${resource.name} itself inside its container; ${byPort.get(port)} is reached as ${byPort.get(port)}:${port}`);
+                }
+            }
+        }
+    }
+    if (problems.length === 0) {
+        return {
+            name: "Service URL ports",
+            didPass: true,
+            message: "Service URLs in params point at the ports the services listen on",
+        };
+    }
+    return {
+        name: "Service URL ports",
+        didPass: false,
+        message: `${formatCount(problems.length, "service URL")} in params that cannot connect:\n    ${problems.join("\n    ")}`,
+        fix: 'TDK runs each backend on the "port" in its service.json, and containers reach each other by resource name (http://<resource>:<port>). Use that port in the URL',
+    };
+}
+function listSourceFiles(dir) {
+    const files = [];
+    let entries;
+    try {
+        entries = readdirSync(dir, { withFileTypes: true });
+    }
+    catch {
+        return files;
+    }
+    for (const entry of entries) {
+        const path = join(dir, entry.name);
+        if (entry.isDirectory()) {
+            if (!SKIPPED_DIRS.has(entry.name))
+                files.push(...listSourceFiles(path));
+        }
+        else if (SOURCE_EXTENSIONS.test(entry.name) && !TEST_FILE.test(path)) {
+            files.push(path);
+        }
+    }
+    return files;
+}
+const LOCALHOST_PORT = /(?:localhost|127\.0\.0\.1):(\d{2,5})\b/g;
+const COMMENT_LINE = /^\s*(?:\/\/|\/\*|\*|<!--|#)/;
+export function checkFrontendBackendUrls(projectRoot = findProjectRoot() ?? process.cwd()) {
+    const resources = discoverResourcesFromRoot(projectRoot);
+    const byPort = new Map([...backendPorts(resources)].map(([name, port]) => [port, name]));
+    const problems = [];
+    for (const resource of resources.filter((r) => r.config?.appType === "frontend")) {
+        for (const file of listSourceFiles(join(resource.path, "src"))) {
+            readFileSync(file, "utf-8")
+                .split("\n")
+                .forEach((line, index) => {
+                if (COMMENT_LINE.test(line))
+                    return;
+                for (const [, portText] of line.matchAll(LOCALHOST_PORT)) {
+                    const backend = byPort.get(Number(portText));
+                    if (backend) {
+                        problems.push(`${relative(projectRoot, file)}:${index + 1} calls localhost:${portText} (${backend})`);
+                    }
+                }
+            });
+        }
+    }
+    if (problems.length === 0) {
+        return {
+            name: "Frontend backend URLs",
+            didPass: true,
+            message: "No frontend calls a backend through a localhost port",
+        };
+    }
+    const project = projectName(projectRoot) ?? "<project>";
+    return {
+        name: "Frontend backend URLs",
+        didPass: false,
+        message: `${formatCount(problems.length, "frontend call")} to a backend port that TDK does not publish on localhost:\n    ${problems.join("\n    ")}`,
+        fix: `Backends are only reachable through Traefik: http://api.${project}.localhost/api/<name without -api>/... (for example catalog-api is /api/catalog). Use that URL, or the generated .autogenerated/env.ts`,
+    };
+}
+export function checkNatsBroker(projectRoot = findProjectRoot() ?? process.cwd()) {
+    const users = discoverResourcesFromRoot(projectRoot)
+        .filter((resource) => resource.config?.featuresEnabled?.includes("nats"))
+        .map((resource) => resource.name);
+    if (users.length === 0) {
+        return {
+            name: "NATS broker",
+            didPass: true,
+            message: "No resource enables the nats feature",
+            isSkipped: true,
+        };
+    }
+    if (existsSync(join(projectRoot, "services", "platform", "messaging", "docker-compose.yml"))) {
+        return {
+            name: "NATS broker",
+            didPass: true,
+            message: `${formatCount(users.length, "resource")} enable nats and services/platform/messaging/docker-compose.yml is present`,
+        };
+    }
+    const name = (projectName(projectRoot) ?? "project").replace(/-/g, "_");
+    return {
+        name: "NATS broker",
+        didPass: false,
+        message: `${users.join(", ")} enable the nats feature, but no NATS server will start: TDK only starts one when services/platform/messaging/docker-compose.yml exists, and it does not generate that file`,
+        fix: `Create it with a "nats" service (image nats with -js, container_name ${name}_nats, network ${name}_backend, external) and a "redis" service, which TDK registers alongside it`,
+    };
+}
+export function parseTiltProcesses(psOutput) {
+    const processes = [];
+    for (const line of psOutput.split("\n")) {
+        const match = line.match(/^\s*(\d+)\s+.*\btilt up\b.*?\s-f\s+(\S+)/);
+        if (!match)
+            continue;
+        processes.push({ pid: Number(match[1]), root: match[2].split("/.tdk/")[0] });
+    }
+    return processes;
+}
+export function checkTiltInstances(projectRoot = findProjectRoot() ?? process.cwd(), exec = execSync) {
+    let output;
+    try {
+        output = exec("ps -Ao pid=,command=", { encoding: "utf-8", timeout: EXEC_TIMEOUT_MS });
+    }
+    catch {
+        return {
+            name: "Tilt processes",
+            didPass: true,
+            isSkipped: true,
+            message: "Could not list processes",
+        };
+    }
+    const running = parseTiltProcesses(output);
+    const mine = running.filter((p) => p.root === projectRoot);
+    const others = running.filter((p) => p.root !== projectRoot);
+    if (mine.length > 1) {
+        return {
+            name: "Tilt processes",
+            didPass: false,
+            message: `${mine.length} Tilt processes are running for this project (pids ${mine.map((p) => p.pid).join(", ")}). They fight over ports and containers`,
+            fix: `Stop them all, then start one: tdk down && kill ${mine.map((p) => p.pid).join(" ")} && tdk up`,
+        };
+    }
+    if (others.length > 0) {
+        const list = others.map((p) => `${p.root} (pid ${p.pid})`).join(", ");
+        return {
+            name: "Tilt processes",
+            didPass: true,
+            isSkipped: true,
+            message: `Another project's Tilt is running: ${list}`,
+            fix: "tdk up will use the next free Tilt UI port (10351, ...). If it is a leftover, run tdk down in that project",
+        };
+    }
+    return { name: "Tilt processes", didPass: true, message: "No stray Tilt processes" };
+}
+export function checkDockerNetworkCapacity(exec = execSync) {
+    const probe = `tdk_doctor_probe_${process.pid}`;
+    try {
+        exec(`docker network create ${probe}`, { stdio: "pipe", timeout: EXEC_TIMEOUT_MS });
+    }
+    catch (error) {
+        const stderr = String(error.stderr ?? error);
+        if (/address pools/i.test(stderr)) {
+            return {
+                name: "Docker networks",
+                didPass: false,
+                message: "Docker cannot create another network: all predefined address pools are in use. Each TDK project needs several",
+                fix: "docker network prune  (removes unused networks), or run tdk down in projects you are not using",
+            };
+        }
+        return {
+            name: "Docker networks",
+            didPass: true,
+            isSkipped: true,
+            message: "Could not test network creation",
+        };
+    }
+    try {
+        exec(`docker network rm ${probe}`, { stdio: "pipe", timeout: EXEC_TIMEOUT_MS });
+    }
+    catch {
+        // A leftover probe network is harmless and tdk_doctor_probe_* is easy to prune.
+    }
+    return { name: "Docker networks", didPass: true, message: "Docker can create networks" };
+}
+//# sourceMappingURL=doctor-wiring.js.map

package/cli/dist/utils/errors.js

@@ -12,7 +12,7 @@ export function logVerbose(message, err) {
         console.warn(chalk.gray(`${message}${errMsg}`));
     }
 }
-class TdkError extends Error {
+export class TdkError extends Error {
     suggestions;
     exitCode;
     constructor(message, suggestions = [], exitCode = 1) {
@@ -78,6 +78,9 @@ export function requireProjectRoot() {
     return projectRoot;
 }
 function handleCommandError(err) {
+    if (err instanceof TdkError) {
+        err.exit();
+    }
     console.error(chalk.red(`Error: ${getErrorMessage(err)}`));
     process.exit(1);
 }

package/cli/dist/utils/project-templates.js

@@ -16,6 +16,10 @@ export const PROJECT_TEMPLATES = {
         repo: "https://github.com/tdk-landscape/tdk-user-management.git",
         description: "User/auth management services",
     },
+    ecommerce: {
+        repo: "https://github.com/tdk-landscape/tdk-ecommerce-example.git",
+        description: "Vue 3 storefront and Hono catalog API (needs TDK 1.3.75+ for --framework vue)",
+    },
     example: {
         repo: "https://github.com/tdk-landscape/tdk-example.git",
         description: "Minimal Project-Stack-Resource (PSR) demonstration",

package/cli/package.json

@@ -1,7 +1,7 @@
 {
   "name": "tdk-cli-internal",
   "private": true,
-  "version": "1.3.74",
+  "version": "1.3.76",
   "description": "TDK CLI - Tilt Development Kit command line interface",
   "keywords": [
     "tdk",

package/cli/templates/Tiltfile.hbs

@@ -279,9 +279,30 @@ if FOCUS_MODE and FOCUS_ENABLED_RESOURCES:
         else:
             _MATCHED = [kr for kr in _KNOWN_TILT_RESOURCES if kr != 'service-discovery-daemon' and kr.startswith(_R + '-')]
             _FILTERED_RESOURCES.extend(_MATCHED)
-    for _INFRA in ['init-networks', 'postgres', 'traefik', 'golden-layers-build']:
-        if _INFRA in _KNOWN_TILT_RESOURCES:
-            _FILTERED_RESOURCES.append(_INFRA)
+    # NATS is gated by the same 'database-management' should_enable() check as
+    # postgres (see infra-loader.star), so it belongs with the infra that is
+    # always kept enabled here -- otherwise config.set_enabled_resources()
+    # below disables it on every out-of-the-box `tdk up` (pre-alpha always
+    # activates this focus-filter branch), and any resource that enables the
+    # 'nats' feature never gets a broker to connect to.
+    #
+    # services/platform/messaging/docker-compose.yml is user-authored (TDK
+    # does not generate it) and may declare more than nats/redis -- e.g. a
+    # local mail catcher standing in for a managed email provider. Every
+    # service it declares is loaded via docker_compose() in infra-loader.star,
+    # so it must be enabled here too, or it is silently disabled the same way.
+    _ALWAYS_ENABLED_INFRA_RESOURCES = ['init-networks', 'postgres', 'traefik', 'golden-layers-build']
+    _messaging_compose_path = PROJECT_ROOT + '/services/platform/messaging/docker-compose.yml'
+    if str(local("test -f '" + _messaging_compose_path + "' && echo yes || echo no", quiet=True, echo_off=True)).strip() == 'yes':
+        # infra-loader.star only creates these Tilt resources when this file
+        # exists, so only add them here when they actually exist to add.
+        _messaging_compose_doc = read_yaml(_messaging_compose_path, default={})
+        for _messaging_svc_name in _messaging_compose_doc.get('services', {}).keys():
+            _ALWAYS_ENABLED_INFRA_RESOURCES.append(_messaging_svc_name)
+        if 'nats' not in _ALWAYS_ENABLED_INFRA_RESOURCES:
+            _ALWAYS_ENABLED_INFRA_RESOURCES.append('nats')
+    for _INFRA in _ALWAYS_ENABLED_INFRA_RESOURCES:
+        _FILTERED_RESOURCES.append(_INFRA)
     for _KR in _KNOWN_TILT_RESOURCES:
         if _KR.startswith('provision-db-'):
             _FILTERED_RESOURCES.append(_KR)

package/engine/AGENTS.md

@@ -200,10 +200,11 @@ def generate_for_manifest(manifest, backend_manifest, write_fn):
     elif app_type == 'sdk':
         return _generate_sdk(manifest, write_fn)
 
-# Generates:
-# - vite.config.ts (local development)
-# - vite.config.docker.ts (Docker build)
-# - vite.config.build.ts (production build)
+# Generates under each frontend resource's .autogenerated/ directory:
+# - vite.config.frontend.autogenerated.ts (local development)
+# - vite.config.build.autogenerated.ts (production build)
+# The CLI scaffolds root index.html; nginx generates nginx.autogenerated.conf
+# and serves the built index.html.
 ```
 
 **TSConfig Generator:**

package/engine/schemas/service-schema.json

@@ -86,7 +86,7 @@
       "type": "string"
     },
     "appType": {
-      "description": "Resource type determining build strategy:\n• backend - Hono/Express API server\n• frontend - Vite/React application\n• sdk - Shared library package\n• worker - Background job processor\n• migrator - Database migration runner\n• library - Shared code library",
+      "description": "Resource type determining build strategy:\n• backend - Hono/Express API server\n• frontend - Vite single-page application (React or Vue, see framework)\n• sdk - Shared library package\n• worker - Background job processor\n• migrator - Database migration runner\n• library - Shared code library",
       "enum": [
         "backend",
         "frontend",
@@ -199,6 +199,14 @@
       "type": "array",
       "uniqueItems": true
     },
+    "framework": {
+      "description": "Frontend SPA provider used to generate Vite and TypeScript config. Only meaningful for frontend resources; omitted means react (legacy manifests).",
+      "enum": [
+        "react",
+        "vue"
+      ],
+      "type": "string"
+    },
     "healthCheckPath": {
       "default": "/health",
       "description": "HTTP endpoint for health checks. Must return 200 OK.",

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

@@ -18,7 +18,7 @@ if _is_verbose:
 # Frontend TSConfig Generator
 # =============================================================================
 
-def generate_frontend_tsconfig(resource_path, write_fn, internal_deps=None, is_docker=True):
+def generate_frontend_tsconfig(resource_path, write_fn, internal_deps=None, is_docker=True, framework='react'):
     """
     Generate tsconfig for frontend services.
 
@@ -27,6 +27,7 @@ def generate_frontend_tsconfig(resource_path, write_fn, internal_deps=None, is_d
         write_fn: Write function for file output
         internal_deps: Optional internal dependencies map
         is_docker: Whether generating for Docker context
+        framework: Frontend framework id; omitted in legacy manifests means React
     """
     # Check verbose mode
     is_verbose = os.environ.get('TILT_LOG_LEVEL') == 'verbose'
@@ -76,25 +77,31 @@ 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']:
+        fail("Unknown frontend framework for TypeScript generation: " + str(framework))
+
+    compiler_options = {
+        "target": "ES2022",
+        "module": "ES2022",
+        "moduleResolution": "bundler",
+        "lib": ["dom", "dom.iterable", "esnext"],
+        "paths": paths,
+        "skipLibCheck": True,
+        "strict": True,
+        "esModuleInterop": True,
+        "allowSyntheticDefaultImports": True,
+        # "bun" (not "node"): matches backend_tsconfig.star - @types/bun is a direct
+        # devDependency so it's always linked at the top level under any linker mode
+        # (including Docker's isolated linker), while @types/node (when only pulled in
+        # transitively, e.g. via bun-types) isn't hoisted under the isolated linker and
+        # "types": ["node"] fails to resolve there even though it works locally.
+        "types": ["node"],
+    }
+    if framework == 'react':
+        compiler_options['jsx'] = 'react-jsx'
+
     content = {
-        "compilerOptions": {
-            "target": "ES2022",
-            "module": "ES2022",
-            "moduleResolution": "node",
-            "lib": ["dom", "dom.iterable", "esnext"],
-            "jsx": "react-jsx",
-            "paths": paths,
-            "skipLibCheck": True,
-            "strict": True,
-            "esModuleInterop": True,
-            "allowSyntheticDefaultImports": True,
-            # "bun" (not "node"): matches backend_tsconfig.star - @types/bun is a direct
-            # devDependency so it's always linked at the top level under any linker mode
-            # (including Docker's isolated linker), while @types/node (when only pulled in
-            # transitively, e.g. via bun-types) isn't hoisted under the isolated linker and
-            # "types": ["node"] fails to resolve there even though it works locally.
-            "types": ["node"],
-        },
+        "compilerOptions": compiler_options,
         "exclude": [
             "node_modules",
             "dist",

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

@@ -555,9 +555,10 @@ 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") == "vue" else "src/main.tsx"
     required_files = {
         "backend": ["package.json", "prisma/schema.prisma"],
-        "frontend": ["package.json", "index.html", "src/main.tsx"],
+        "frontend": ["package.json", "index.html", frontend_entry],
         "library": ["package.json"],
     }.get(app_type, ["package.json"])