@tdk-landscape/tdk-cli-core 1.3.87 → 1.3.89

package/README.md

@@ -18,11 +18,11 @@ tdk up shop
 curl http://api.shop.localhost/api/orders-api/health
 ```
 
-![TDK scaffolding a backend and a frontend, then listing the stack](docs/demo.svg)
+![TDK scaffolding a backend and a frontend, then listing the stack](docs/assets/demo.svg)
 
 *Scaffolding a backend and frontend, then listing the stack.*
 
-![Top 9 places to use TDK CLI: scaffold a service, start a stack, hot reload, port management, auto-discovery, boot order, proxy routing, include infra, and config verify](docs/tdk-cli-top-9-uses.jpg)
+![Top 9 places to use TDK CLI: scaffold a service, start a stack, hot reload, port management, auto-discovery, boot order, proxy routing, include infra, and config verify](docs/assets/tdk-cli-top-9-uses.jpg)
 
 If Helm, Compose, or your existing Tilt setup already gives you a working local environment, keep using it. TDK CLI is for engineers managing several services who want a clear local service contract and one command to start the stack.
 
@@ -66,9 +66,9 @@ curl -fsSL https://tdk-landscape.github.io/install.sh | sh
 - [Features and license limits](docs/FEATURES.md)
 - [Honest comparison and known limits](docs/compare-honest.md)
 - [Public claims registry](docs/claims.md)
-- [Show HN draft](docs/show-hn.md)
+- [Show HN draft](docs/drafts/show-hn.md)
 - [Architecture and repository map](docs/project-overview.md)
-- [Scale fixture measurements and caveats](docs/scale-bench.md)
+- [Scale fixture measurements and caveats](docs/benchmarks/scale-bench.md)
 
 ## Requirements and support
 

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/express.js

@@ -0,0 +1,50 @@
+export function getExpressIndexTemplate(name) {
+    return `import express from 'express';
+
+const app = express();
+
+// Health check endpoint (required by TILT_RESOURCE_DEFAULTS.star)
+app.get('/health', (_req, res) => {
+  res.json({ status: 'ok', service: '${name}' });
+});
+
+app.get('/health/live', (_req, res) => {
+  res.json({ status: 'alive', timestamp: Date.now() });
+});
+
+app.get('/health/ready', async (_req, res) => {
+  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';
+  res.status(allReady ? 200 : 503).json({ status, dependencies });
+});
+
+app.get('/', (_req, res) => {
+  res.json({
+    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.
+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');
+});
+`;
+}
+export const expressBackendProvider = {
+    id: "express",
+    label: "Bun + Express",
+    dependencies: { express: "^5.1.0" },
+    devDependencies: { "@types/express": "^5.0.0" },
+    createIndex: getExpressIndexTemplate,
+};
+//# sourceMappingURL=express.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/registry.js

@@ -0,0 +1,45 @@
+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";
+/** Hono is the historical default; omitting --framework keeps the exact historical output. */
+export const DEFAULT_BACKEND_FRAMEWORK = "hono";
+export const honoBackendProvider = {
+    id: "hono",
+    label: "Bun + Hono",
+    dependencies: { hono: "^4.0.0" },
+    devDependencies: {},
+    createIndex: getBackendIndexTemplate,
+};
+export const BACKEND_FRAMEWORKS = {
+    hono: honoBackendProvider,
+    express: expressBackendProvider,
+    elysia: elysiaBackendProvider,
+    fastify: fastifyBackendProvider,
+};
+export function getBackendFramework(frameworkId) {
+    const id = (frameworkId ?? DEFAULT_BACKEND_FRAMEWORK).trim().toLowerCase();
+    const provider = Object.hasOwn(BACKEND_FRAMEWORKS, id) ? BACKEND_FRAMEWORKS[id] : undefined;
+    if (!provider) {
+        const supportedIds = Object.keys(BACKEND_FRAMEWORKS).join(", ");
+        throw new TdkError(`Unknown backend framework "${frameworkId}". Supported frameworks: ${supportedIds}.`, [`Use one of: ${supportedIds}`, `Omit --framework to use ${DEFAULT_BACKEND_FRAMEWORK}`]);
+    }
+    return provider;
+}
+/**
+ * Returns the provider for an explicit `--framework` on a backend, or undefined when none was given
+ * (the historical Hono scaffold). Python owns its runtime, so a framework cannot be combined with it.
+ */
+export function resolveBackendFramework(resourceType, frameworkId, language) {
+    if (resourceType !== "backend" || frameworkId === undefined)
+        return undefined;
+    if (language?.createFiles) {
+        throw new TdkError(`--framework cannot be combined with --language ${language.id}.`, [
+            `The ${language.id} provider owns its runtime and framework`,
+            "Drop --framework, or use --language bun",
+        ]);
+    }
+    return getBackendFramework(frameworkId);
+}
+//# sourceMappingURL=registry.js.map

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

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

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,12 @@
 import { TdkError } from "../utils/errors.js";
 import { bunBackendProvider } from "./bun.js";
+import { goBackendProvider } from "./go.js";
 import { pythonBackendProvider } from "./python.js";
 export const DEFAULT_BACKEND_LANGUAGE = "bun";
 export const BACKEND_LANGUAGES = {
     bun: bunBackendProvider,
     python: pythonBackendProvider,
+    go: goBackendProvider,
 };
 export function getBackendLanguage(languageId) {
     const id = (languageId ?? DEFAULT_BACKEND_LANGUAGE).trim().toLowerCase();

package/cli/dist/commands/resource.js

@@ -2,6 +2,7 @@ import { existsSync, mkdirSync } from "node:fs";
 import { isAbsolute, relative, resolve } from "node:path";
 import chalk from "chalk";
 import { Command } from "commander";
+import { resolveBackendFramework } from "../backend-frameworks/registry.js";
 import { getBackendIndexTemplate } from "../backend-languages/bun.js";
 import { resolveBackendLanguage } from "../backend-languages/registry.js";
 import { resolveFrontendFramework } from "../frontend-frameworks/registry.js";
@@ -50,6 +51,7 @@ export const TYPE_SPECIFIC = {
         healthCheck: "/health",
     },
 };
+const BYO_RESTART_POLICIES = ["no", "on-failure", "unless-stopped", "always"];
 export function resolveByoPort(value, assignedPort, resources) {
     if (!value)
         return assignedPort;
@@ -69,6 +71,8 @@ export function createServiceJson(name, type, stack, port, extraFeatures = [], f
     const framework = resolveFrontendFramework(type, frameworkId);
     // Only an explicit selection is persisted: a missing `language` has always meant Bun.
     const language = languageId === undefined ? undefined : resolveBackendLanguage(type, languageId);
+    // Likewise a missing backend `framework` has always meant Hono.
+    const backendFramework = resolveBackendFramework(type, frameworkId, language);
     const typeSpecific = TYPE_SPECIFIC[type];
     const base = JSON.parse(JSON.stringify(BASE_TEMPLATE));
     for (const [key, value] of Object.entries(typeSpecific)) {
@@ -105,12 +109,14 @@ export function createServiceJson(name, type, stack, port, extraFeatures = [], f
         stack,
         port,
         ...(framework ? { framework: framework.id } : {}),
+        ...(backendFramework ? { framework: backendFramework.id } : {}),
         ...(language ? { language: language.id } : {}),
     };
 }
 export function createPackageJson(name, type, frameworkId) {
     const isFrontend = type === "frontend";
     const framework = resolveFrontendFramework(type, frameworkId);
+    const backendFramework = resolveBackendFramework(type, frameworkId);
     return {
         name: `@project/${name}`,
         version: "0.0.1",
@@ -129,7 +135,7 @@ export function createPackageJson(name, type, frameworkId) {
             "lint:fix": "biome check . --write",
         },
         dependencies: {
-            ...(isFrontend ? {} : { hono: "^4.0.0" }),
+            ...(isFrontend ? {} : (backendFramework?.dependencies ?? { hono: "^4.0.0" })),
             ...(framework?.dependencies ?? {}),
         },
         devDependencies: {
@@ -142,6 +148,7 @@ export function createPackageJson(name, type, frameworkId) {
             "@biomejs/biome": "^2.5.13",
             ...(isFrontend ? { vite: "^5.0.0" } : {}),
             ...(framework?.devDependencies ?? {}),
+            ...(backendFramework?.devDependencies ?? {}),
         },
     };
 }
@@ -288,8 +295,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>", "Frontend framework: react (default), vue")
-    .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")
+    .option("--language <id>", "Backend language: bun (default), python, go")
     .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)")
@@ -299,6 +306,7 @@ export const resourceCommand = new Command("resource")
     .option("--dockerfile <path>", "Path to Dockerfile relative to resource dir (for bring-your-own)")
     .option("--health-path <path>", "HTTP health check path (for bring-your-own)", "/health")
     .option("--no-proxy", "Disable the Traefik route (bring-your-own only)")
+    .option("--restart <policy>", "Compose restart policy: no, on-failure, unless-stopped, always (bring-your-own only; use no for one-shot jobs)")
     .option("--image <name>", "Docker image name instead of building from Dockerfile (for bring-your-own)")
     .option("--port <port>", "Port number (default: next free in 4000-5999)")
     .action(async (name, options) => {
@@ -350,6 +358,7 @@ export const resourceCommand = new Command("resource")
         }
         const frontendFramework = resolveFrontendFramework(resourceType, options.framework);
         const backendLanguage = resolveBackendLanguage(resourceType, options.language);
+        const backendFramework = resolveBackendFramework(resourceType, options.framework, backendLanguage);
         let dddEnabled = false;
         if (options.ddd) {
             if (resourceType !== "backend" && resourceType !== "worker") {
@@ -446,6 +455,18 @@ export const resourceCommand = new Command("resource")
         const nextPort = resourceType === "sdk"
             ? 0
             : assignPort(resourceType, allResources);
+        if (options.restart !== undefined) {
+            if (resourceType !== "bring-your-own") {
+                throw new TdkError("--restart can only be used with --type bring-your-own.", [
+                    "Add --type bring-your-own, or drop --restart",
+                ]);
+            }
+            if (!BYO_RESTART_POLICIES.includes(options.restart)) {
+                throw new TdkError(`Unknown --restart policy "${options.restart}".`, [
+                    `Use one of: ${BYO_RESTART_POLICIES.join(", ")}`,
+                ]);
+            }
+        }
         const assignedPort = resourceType === "bring-your-own"
             ? resolveByoPort(options.port, nextPort, allResources)
             : nextPort;
@@ -515,6 +536,7 @@ export const resourceCommand = new Command("resource")
                 healthCheckPath: options.healthPath || "/health",
                 ...(options.image ? { image: options.image } : { dockerfile }),
                 ...(options.proxy === false ? { exposeViaProxy: false } : {}),
+                ...(options.restart ? { restart: options.restart } : {}),
             };
             const { writeFileSync } = await import("node:fs");
             writeFileSync(resolve(fullPath, "service.json"), JSON.stringify(byoServiceJson, null, 2));
@@ -562,8 +584,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 });
         }
@@ -573,8 +600,8 @@ This file contains the resource configuration for TDK.
             }
         }
         // Prepare file generation tasks
-        const serviceJson = createServiceJson(resourceName, resourceType, stackName, assignedPort, dddEnabled ? ["ddd"] : [], frontendFramework?.id, options.language === undefined ? undefined : backendLanguage?.id);
-        const packageJson = createPackageJson(resourceName, resourceType, frontendFramework?.id);
+        const serviceJson = createServiceJson(resourceName, resourceType, stackName, assignedPort, dddEnabled ? ["ddd"] : [], frontendFramework?.id ?? backendFramework?.id, options.language === undefined ? undefined : backendLanguage?.id);
+        const packageJson = createPackageJson(resourceName, resourceType, frontendFramework?.id ?? backendFramework?.id);
         const tasks = [
             {
                 type: "json",
@@ -610,7 +637,7 @@ This file contains the resource configuration for TDK.
             tasks.push({
                 type: "text",
                 filename: "src/index.ts",
-                content: getBackendIndexTemplate(resourceName),
+                content: (backendFramework?.createIndex ?? getBackendIndexTemplate)(resourceName),
                 description: "Generating backend source",
                 emoji: "💻",
             });

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

@@ -0,0 +1,65 @@
+export const litFrontendProvider = {
+    id: "lit",
+    label: "Lit + Vite",
+    dependencies: {
+        lit: "^3.2.0",
+    },
+    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>
+    <app-root></app-root>
+    <script type="module" src="/src/main.ts"></script>
+  </body>
+</html>
+`,
+                description: "Generating HTML template",
+                emoji: "💻",
+            },
+            {
+                filename: "src/main.ts",
+                content: `import './app-root';
+`,
+                description: "Generating Lit entry",
+                emoji: "💻",
+            },
+            {
+                filename: "src/app-root.ts",
+                content: `import { LitElement, css, html } from 'lit';
+
+export class AppRoot extends LitElement {
+  static styles = css\`
+    :host {
+      display: block;
+      padding: 2rem;
+      font-family: system-ui;
+    }
+  \`;
+
+  render() {
+    return html\`
+      <h1>${name}</h1>
+      <p>Frontend resource created with TDK</p>
+    \`;
+  }
+}
+
+customElements.define('app-root', AppRoot);
+`,
+                description: "Generating Lit app",
+                emoji: "💻",
+            },
+        ];
+    },
+};
+//# sourceMappingURL=lit.js.map

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

@@ -0,0 +1,63 @@
+export const preactFrontendProvider = {
+    id: "preact",
+    label: "Preact + Vite",
+    dependencies: {
+        preact: "^10.26.0",
+    },
+    devDependencies: {
+        "@preact/preset-vite": "^2.10.0",
+    },
+    compilerOptions: {
+        jsx: "react-jsx",
+        jsxImportSource: "preact",
+    },
+    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.tsx"></script>
+  </body>
+</html>
+`,
+                description: "Generating HTML template",
+                emoji: "💻",
+            },
+            {
+                filename: "src/main.tsx",
+                content: `import { render } from 'preact';
+import App from './App';
+
+render(<App />, document.getElementById('app')!);
+`,
+                description: "Generating Preact entry",
+                emoji: "💻",
+            },
+            {
+                filename: "src/App.tsx",
+                content: `function App() {
+  return (
+    <div style={{ padding: '2rem', fontFamily: 'system-ui' }}>
+      <h1>${name}</h1>
+      <p>Frontend resource created with TDK</p>
+    </div>
+  );
+}
+
+export default App;
+`,
+                description: "Generating Preact app",
+                emoji: "💻",
+            },
+        ];
+    },
+};
+//# sourceMappingURL=preact.js.map

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

@@ -0,0 +1,62 @@
+export const qwikFrontendProvider = {
+    id: "qwik",
+    label: "Qwik + Vite",
+    dependencies: {
+        "@builder.io/qwik": "^1.12.0",
+    },
+    devDependencies: {},
+    compilerOptions: {
+        jsx: "react-jsx",
+        jsxImportSource: "@builder.io/qwik",
+    },
+    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.tsx"></script>
+  </body>
+</html>
+`,
+                description: "Generating HTML template",
+                emoji: "💻",
+            },
+            {
+                filename: "src/main.tsx",
+                content: `import '@builder.io/qwik/qwikloader.js';
+import { render } from '@builder.io/qwik';
+import { App } from './App';
+
+render(document.getElementById('app') as HTMLElement, <App />);
+`,
+                description: "Generating Qwik entry",
+                emoji: "💻",
+            },
+            {
+                filename: "src/App.tsx",
+                content: `import { component$ } from '@builder.io/qwik';
+
+export const App = component$(() => {
+  return (
+    <div style={{ padding: '2rem', fontFamily: 'system-ui' }}>
+      <h1>${name}</h1>
+      <p>Frontend resource created with TDK</p>
+    </div>
+  );
+});
+`,
+                description: "Generating Qwik app",
+                emoji: "💻",
+            },
+        ];
+    },
+};
+//# sourceMappingURL=qwik.js.map