@cosmicdrift/kumiko-dev-server 0.12.2 → 0.14.0

package/CHANGELOG.md

@@ -1,5 +1,129 @@
 # @cosmicdrift/kumiko-dev-server
 
+## 0.14.0
+
+### Minor Changes
+
+- b8e1d48: scaffoldApp baut `src/run-config.ts` + `bin/main.ts` jetzt via ts-morph
+  (AST) statt template-strings. Selbes Tool wie scaffoldAppFeature →
+  ein konsistenter Mechanismus für generate + later modify. Plus:
+  ts-morph als explicit dependency aufgenommen (war bisher nur via
+  hoisted root-dep verfügbar; broken bei publish).
+
+### Patch Changes
+
+- ce23d48: `walkthrough.integration.ts` — DX-3.1 walkthrough-snapshot-test. Pins
+  scaffoldApp + scaffoldAppFeature output gegen die Behauptungen in
+  docs.kumiko.so/en/walkthrough/. Catches doc-drift ohne actual
+  `bunx … && yarn install && bun run boot` CI-run.
+
+  5 Tests: file-list, auto-mount-diff, run-config text-content,
+  composeFeatures(includeBundled:true) = 7 features, bin/main auth.admin
+  stub.
+
+  - @cosmicdrift/kumiko-framework@0.14.0
+  - @cosmicdrift/kumiko-bundled-features@0.14.0
+
+## 0.13.0
+
+### Minor Changes
+
+- 7bd5c88: `KUMIKO_DRY_RUN_ENV=boot` mode for runProdApp — runs env-validation +
+  composeFeatures + validateBoot + createRegistry without DB/Redis
+  connect, exits with status 0 on success. Used by the
+  `samples/apps/use-all-bundled` smoke-app (Sprint 9.8 Phase C / Empfehlung
+  1 / canonical bug-catcher) and downstream by enterprise's
+  `use-all-features` mirror. Render-modes (human|json|pulumi|k8s|1)
+  behavior unchanged.
+- 575752f: `scaffoldAppFeature` + `kumiko add feature <name>` — DX-2 aus DX-Roadmap.
+  Scaffolded ein neues Feature in `src/features/<name>/` einer bereits via
+  `kumiko new app` scaffolded App + **auto-mountet** es in `src/run-config.ts`
+  via ts-morph (import + `APP_FEATURES`-array-entry, idempotent).
+
+  User-Promise "defineFeature → nichts woanders eintragen" erfüllt für die
+  run-config-Seite. FEATURE_IMPORT_REGISTRY in drizzle/generate.ts ist
+  DX-4's Refactor — bei DX-1+DX-2-App noch nicht vorhanden.
+
+  Usage (in einer DX-1-gescaffoldeten App):
+
+  ```sh
+  bunx kumiko add feature product-catalog
+  # → src/features/product-catalog/{feature.ts,index.ts}
+  # → src/run-config.ts auto-edited: import + APP_FEATURES-entry
+  ```
+
+- 3d5e9ef: `kumiko-schema-check` CLI — Empfehlung 3 aus Sprint-9.8-Retro
+  (`luminous-watching-moler.md`). Diff't APP_FEATURES (runtime, aus
+  `src/run-config.ts`) gegen FEATURE_IMPORT_REGISTRY (statisch, aus
+  `drizzle/generate.ts`). Fängt Studio's 9.8-Drama: registry 18 features
+  hinter APP_FEATURES → migrations fehlten für mounted features.
+
+  Usage (im app-workspace):
+
+  ```sh
+  bunx kumiko-schema-check
+  # or with custom paths:
+  bunx kumiko-schema-check --run-config src/run-config.ts --generate drizzle/generate.ts
+  ```
+
+  Plus: 5 bundled-features hatten camelCase feature-names statt kebab-case
+  (Memory `feedback_kebab_aggregates`) — aufgedeckt durch den schema-check
+  gegen use-all-bundled. Fix: `channelEmail` → `channel-email`,
+  `channelInApp` → `channel-in-app`, `channelPush` → `channel-push`,
+  `rateLimiting` → `rate-limiting`, `rendererSimple` → `renderer-simple`.
+
+  Plus `CHANNEL_IN_APP_FEATURE` und `RATE_LIMITING_FEATURE` Konstanten
+  angepasst (waren intern auf camelCase, jetzt kebab-case).
+
+- 46b84d0: `scaffoldApp` + `kumiko new app <name>` — DX-1.0 aus DX-Roadmap. Generiert
+  ein lauffähiges App-Skelett (package.json, tsconfig, run-config mit
+  secrets+sessions, bin/main.ts mit auth-admin-stub + deterministische
+  tenant-UUID, .env.example, README) in `<cwd>/<name>/`.
+
+  Boot-Pfad: `KUMIKO_DRY_RUN_ENV=boot bun bin/main.ts` läuft ohne DB/Redis.
+
+  Held-back für spätere DX-Phasen: drizzle-setup (DX-1.1, blocked-by DX-4
+  auto-registry), Dockerfile (existing `kumiko init-deploy`), first feature
+  scaffold (existing `kumiko create` bzw. DX-2 `kumiko add feature`).
+
+  Usage:
+
+  ```sh
+  bunx kumiko new app my-shop
+  cd my-shop && yarn install
+  cp .env.example .env  # JWT_SECRET + KUMIKO_SECRETS_MASTER_KEY_V1 setzen
+  bun run boot          # → boot validation OK
+  ```
+
+### Patch Changes
+
+- 2bd60c1: `buildServerBundle` BUILD_ONLY_EXTERNALS erweitert um drizzle-kit's
+  dialect-resolver dynamic-imports: `@planetscale/database`, `@libsql/client`,
+  `better-sqlite3`, `@neondatabase/serverless`, `@vercel/postgres`, `mysql2`.
+
+  Aufgedeckt durch C1 Empfehlung 4 (bundle-smoke). Bisher schlug
+  `bun build` an dynamic-imports im drizzle-kit auch wenn der App nur
+  postgres nutzt. Externalisieren = build durchläuft + tree-shake wirft
+  die ungenutzten driver-modules eh raus.
+
+- 8bfb284: Dockerfile.template setzt `YARN_ENABLE_SCRIPTS=false` im Build-Stage. Fixt msgpackr-extract native-build-Failures (ARM, CI) und generell jeden transitiven Native-Dep — der Build-Stage bundlet nur JS via `bun build`, Runtime-Native-Deps werden separat im Runtime-Stage via `bun install --production` installiert. Apps die bisher per-package-Workarounds via `dependenciesMeta.<pkg>.built=false` in der App-package.json brauchten (studio, enterprise) können diese Entries nach Upgrade auf diese dev-server-Version entfernen.
+- cc0ddc0: `Dockerfile.template` emits an inline `start.sh` for createBunServer command-override target.
+
+  `infra/pulumi/bun-server.ts`'s `createBunServer` overrides the container command with `exec ./start.sh` after injecting DATABASE_URL from the init-container. Apps deployed via createBunServer crashed with `./start.sh: not found` until each one added a per-app `start.sh` in repo root (= studio's PR #22).
+
+  Now the Dockerfile-template emits the file inline (`RUN printf … > ./start.sh && chmod +x`). Apps no longer need to ship one — the runtime stage generates it. Apps that don't go through createBunServer's command-override still boot via the bottom CMD; start.sh is dead-code in that case.
+
+- Updated dependencies [7f56b2f]
+- Updated dependencies [68b8118]
+- Updated dependencies [9121928]
+- Updated dependencies [72518fa]
+- Updated dependencies [0a00e7b]
+- Updated dependencies [aca1443]
+- Updated dependencies [c6cb96c]
+- Updated dependencies [3d5e9ef]
+  - @cosmicdrift/kumiko-framework@0.13.0
+  - @cosmicdrift/kumiko-bundled-features@0.13.0
+
 ## 0.12.2
 
 ### Patch Changes

package/bin/kumiko-schema-check.ts

@@ -0,0 +1,159 @@
+#!/usr/bin/env bun
+// biome-ignore-all lint/suspicious/noConsole: CLI-Script, console ist Feature.
+//
+// kumiko schema check — Empfehlung 3 aus Sprint-9.8-Retro
+// (luminous-watching-moler.md). Diff't APP_FEATURES (runtime, aus
+// `src/run-config.ts`) gegen FEATURE_IMPORT_REGISTRY (statisch, aus
+// `drizzle/generate.ts`). Catches:
+//
+//   1. Mount-without-registry: ein neues feature in APP_FEATURES ohne
+//      Entry in FEATURE_IMPORT_REGISTRY. Resultiert in Schema-Drift:
+//      Runtime mountet feature, Migration kennt seine Tabellen nicht.
+//   2. Stale-registry: ein Entry in FEATURE_IMPORT_REGISTRY ohne
+//      matching mount in APP_FEATURES. Dead-code; im Schema entsteht
+//      eine Tabelle ohne Runtime-Konsument.
+//
+// Studio's 9.8-Drama: FEATURE_IMPORT_REGISTRY war 18 features hinter
+// APP_FEATURES. Hätte mit diesem check eine Sekunde Lokal gefangen.
+//
+// Usage (aus dem app-workspace):
+//   bunx kumiko-schema-check
+//   # oder mit explicit pfaden:
+//   bunx kumiko-schema-check --run-config src/run-config.ts --generate drizzle/generate.ts
+//
+// Exit 0 wenn alles in sync, exit 1 wenn drift.
+
+import { existsSync, readFileSync } from "node:fs";
+import { resolve } from "node:path";
+
+type Args = {
+  readonly runConfigPath: string;
+  readonly generatePath: string;
+};
+
+function parseArgs(argv: readonly string[]): Args {
+  const cwd = process.cwd();
+  let runConfigPath = resolve(cwd, "src/run-config.ts");
+  let generatePath = resolve(cwd, "drizzle/generate.ts");
+  for (let i = 0; i < argv.length; i++) {
+    const flag = argv[i];
+    const value = argv[i + 1];
+    if (flag === "--run-config" && value) {
+      runConfigPath = resolve(cwd, value);
+      i++;
+    } else if (flag === "--generate" && value) {
+      generatePath = resolve(cwd, value);
+      i++;
+    }
+  }
+  return { runConfigPath, generatePath };
+}
+
+function readRegistryFeatures(generateSrc: string): Set<string> {
+  // Match object-keys mit Discriminator `kind: "factory" | "named"`.
+  // Quoted ("billing-foundation") oder unquoted (config, user) — beides
+  // ist gültig in JS. Pattern aus use-all-bundled/scripts/check-coverage.ts
+  // dupliziert hier weil per-app-CLI nicht von sample-script lesen darf.
+  const re = /(?:"([a-z][a-z0-9-]*)"|([a-z][a-z0-9]*)):\s*\{\s*kind:\s*"(factory|named)"/g;
+  const out = new Set<string>();
+  for (const m of generateSrc.matchAll(re)) {
+    const name = m[1] ?? m[2];
+    if (name) out.add(name);
+  }
+  return out;
+}
+
+async function readMountedFeatures(runConfigPath: string): Promise<Set<string>> {
+  const mod = (await import(runConfigPath)) as {
+    APP_FEATURES?: ReadonlyArray<{ name: string }>;
+    HAS_AUTH?: boolean;
+  };
+  if (!mod.APP_FEATURES) {
+    throw new Error(
+      `kumiko-schema-check: ${runConfigPath} hat kein 'APP_FEATURES' export. ` +
+        `Convention: 'export const APP_FEATURES = [...] as const'.`,
+    );
+  }
+  // composeFeatures auto-prepends config + user + tenant + auth-email-
+  // password im auth-mode. Wenn HAS_AUTH=true (oder default), die 4
+  // implicit-mounted features auch in die Set tun damit der Diff nicht
+  // false-positive "auth-email-password is mounted but no registry-entry"
+  // produziert. Studio/use-all-bundled HAS_AUTH=true ist convention.
+  const set = new Set<string>();
+  for (const f of mod.APP_FEATURES) {
+    set.add(f.name);
+  }
+  if (mod.HAS_AUTH ?? true) {
+    set.add("config");
+    set.add("user");
+    set.add("tenant");
+    set.add("auth-email-password");
+  }
+  return set;
+}
+
+async function main(): Promise<void> {
+  const args = parseArgs(process.argv.slice(2));
+
+  if (!existsSync(args.runConfigPath)) {
+    console.error(`✗ run-config not found: ${args.runConfigPath}`);
+    process.exit(1);
+  }
+  if (!existsSync(args.generatePath)) {
+    console.error(`✗ generate not found: ${args.generatePath}`);
+    process.exit(1);
+  }
+
+  const registry = readRegistryFeatures(readFileSync(args.generatePath, "utf-8"));
+  const mounted = await readMountedFeatures(args.runConfigPath);
+
+  // Mounted but not in registry → schema-drift (runtime ↔ migration mismatch).
+  const mountedWithoutEntry: string[] = [];
+  for (const name of mounted) {
+    if (!registry.has(name)) mountedWithoutEntry.push(name);
+  }
+  // In registry but not mounted → stale entry (dead schema-mapping).
+  const staleEntries: string[] = [];
+  for (const name of registry) {
+    if (!mounted.has(name)) staleEntries.push(name);
+  }
+
+  let ok = true;
+
+  if (mountedWithoutEntry.length > 0) {
+    console.error(
+      `\n✗ ${mountedWithoutEntry.length} feature(s) mounted in APP_FEATURES but NOT in FEATURE_IMPORT_REGISTRY:`,
+    );
+    for (const name of mountedWithoutEntry.sort()) {
+      console.error(`   - ${name}`);
+    }
+    console.error(
+      "\n  Action: in drizzle/generate.ts FEATURE_IMPORT_REGISTRY den Eintrag ergänzen,",
+    );
+    console.error("  damit Schema-Generator + Migration die feature-Tabellen kennt.");
+    ok = false;
+  }
+
+  if (staleEntries.length > 0) {
+    console.error(
+      `\n✗ ${staleEntries.length} stale FEATURE_IMPORT_REGISTRY entry/entries (kein matching mount):`,
+    );
+    for (const name of staleEntries.sort()) {
+      console.error(`   - ${name}`);
+    }
+    console.error("\n  Action: entry aus drizzle/generate.ts FEATURE_IMPORT_REGISTRY entfernen,");
+    console.error("  oder das feature in src/run-config.ts mounten.");
+    ok = false;
+  }
+
+  if (ok) {
+    console.log(
+      `✓ schema check: ${mounted.size} mounted ↔ ${registry.size} registry entries, no drift`,
+    );
+    process.exit(0);
+  } else {
+    process.exit(1);
+  }
+}
+
+await main();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cosmicdrift/kumiko-dev-server",
-  "version": "0.12.2",
+  "version": "0.14.0",
   "description": "Development server bootstrap for Kumiko apps. Bundles the client, mints dev-JWTs, injects the resolved AppSchema, and seeds an admin. Not for production.",
   "license": "BUSL-1.1",
   "author": "Marc Frost <marc@cosmicdriftgamestudio.com>",
@@ -45,11 +45,13 @@
   },
   "bin": {
     "kumiko-build": "./bin/kumiko-build.ts",
-    "kumiko-dev": "./bin/kumiko-dev.ts"
+    "kumiko-dev": "./bin/kumiko-dev.ts",
+    "kumiko-schema-check": "./bin/kumiko-schema-check.ts"
   },
   "dependencies": {
-    "@cosmicdrift/kumiko-bundled-features": "0.12.2",
-    "@cosmicdrift/kumiko-framework": "0.12.2"
+    "@cosmicdrift/kumiko-bundled-features": "0.14.0",
+    "@cosmicdrift/kumiko-framework": "0.14.0",
+    "ts-morph": "^28.0.0"
   },
   "publishConfig": {
     "registry": "https://registry.npmjs.org",

package/src/__tests__/env-schema.integration.ts

@@ -182,4 +182,54 @@ describe("runProdApp envSchema integration", () => {
       console.log = realLog;
     }
   });
+
+  it("KUMIKO_DRY_RUN_ENV=boot runs validators + exits before DB-connect", async () => {
+    const logs: string[] = [];
+    const realLog = console.log;
+    console.log = (...args: unknown[]) => {
+      logs.push(args.map(String).join(" "));
+    };
+    try {
+      const handle = await runProdApp({
+        features: [secretsFeature, authFeature],
+        envSchema: composed,
+        envSource: {
+          KUMIKO_DRY_RUN_ENV: "boot",
+          KUMIKO_SECRETS_MASTER_KEY_V1: "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+          JWT_SECRET: "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+          STUDIO_ADMIN_EMAIL: "ops@example.com",
+          DATABASE_URL: "postgres://dummy:dummy@127.0.0.1:1/dummy",
+          REDIS_URL: "redis://127.0.0.1:1",
+        },
+        migrations: false,
+      });
+      expect(logs.join("\n")).toContain("boot validation OK");
+      expect(handle).toBeDefined();
+    } finally {
+      console.log = realLog;
+    }
+  });
+
+  it("KUMIKO_DRY_RUN_ENV=boot still aggregates env-errors before exit", async () => {
+    let captured: KumikoBootError | undefined;
+    try {
+      await runProdApp({
+        features: [secretsFeature, authFeature],
+        envSchema: composed,
+        envSource: {
+          KUMIKO_DRY_RUN_ENV: "boot",
+          JWT_SECRET: "short",
+          STUDIO_ADMIN_EMAIL: "not-an-email",
+        },
+        bootErrorReporter: (err) => {
+          captured = err;
+          throw err;
+        },
+      });
+    } catch (err) {
+      expect(err).toBeInstanceOf(KumikoBootError);
+    }
+    expect(captured).toBeDefined();
+    expect(captured!.errors.length).toBeGreaterThanOrEqual(3);
+  });
 });

package/src/__tests__/scaffold-app-feature.test.ts

@@ -0,0 +1,88 @@
+// scaffoldAppFeature unit-tests (DX-2).
+
+import { existsSync, mkdtempSync, readFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, test } from "vitest";
+import { scaffoldApp } from "../scaffold-app";
+import { scaffoldAppFeature } from "../scaffold-app-feature";
+
+describe("scaffoldAppFeature", () => {
+  let tmp: string;
+  let appRoot: string;
+  beforeEach(() => {
+    tmp = mkdtempSync(join(tmpdir(), "scaffold-app-feature-"));
+    appRoot = join(tmp, "my-shop");
+    scaffoldApp({ name: "my-shop", destination: appRoot });
+  });
+  afterEach(() => {
+    rmSync(tmp, { recursive: true, force: true });
+  });
+
+  test("scaffolds src/features/<name>/feature.ts + index.ts", () => {
+    const result = scaffoldAppFeature({ name: "product-catalog", appRoot });
+    expect(result.featureName).toBe("product-catalog");
+    expect(result.files).toEqual([
+      "src/features/product-catalog/feature.ts",
+      "src/features/product-catalog/index.ts",
+    ]);
+    expect(existsSync(join(appRoot, "src/features/product-catalog/feature.ts"))).toBe(true);
+    expect(existsSync(join(appRoot, "src/features/product-catalog/index.ts"))).toBe(true);
+  });
+
+  test("feature.ts uses kebab-name + camelCase variable", () => {
+    scaffoldAppFeature({ name: "product-catalog", appRoot });
+    const feature = readFileSync(join(appRoot, "src/features/product-catalog/feature.ts"), "utf-8");
+    expect(feature).toContain(`defineFeature("product-catalog"`);
+    expect(feature).toContain("export const productCatalogFeature");
+    expect(feature).toContain('r.entity("product-catalog-item"');
+  });
+
+  test("auto-mounts in src/run-config.ts (import + APP_FEATURES entry)", () => {
+    const result = scaffoldAppFeature({ name: "product-catalog", appRoot });
+    expect(result.autoMounted).toBe(true);
+    const runConfig = readFileSync(join(appRoot, "src/run-config.ts"), "utf-8");
+    expect(runConfig).toContain(
+      `import { productCatalogFeature } from "./features/product-catalog";`,
+    );
+    expect(runConfig).toContain("productCatalogFeature");
+    // APP_FEATURES still ends with `as const`
+    expect(runConfig).toMatch(/\]\s*as const;/);
+  });
+
+  test("idempotent: re-mount of existing feature is a no-op", () => {
+    scaffoldAppFeature({ name: "product-catalog", appRoot });
+    const firstRunConfig = readFileSync(join(appRoot, "src/run-config.ts"), "utf-8");
+    // Now re-mount (second feature creates dir-already-exists error;
+    // we instead simulate "feature dir exists, only run-config dance").
+    // → Real DX-2 flow: scaffold fails on dir-exists; manual remount
+    //   would call mountInRunConfig directly. Test the mount-side
+    //   idempotency by triggering a second feature with a different
+    //   name and asserting the first import stays exactly once.
+    scaffoldAppFeature({ name: "billing", appRoot });
+    const secondRunConfig = readFileSync(join(appRoot, "src/run-config.ts"), "utf-8");
+    expect(secondRunConfig).toContain("productCatalogFeature");
+    expect(secondRunConfig).toContain("billingFeature");
+    // Count: each feature-import appears exactly once.
+    const occurrences = secondRunConfig.match(/productCatalogFeature/g) ?? [];
+    expect(occurrences.length).toBe(2); // 1 import + 1 array-entry
+    expect(firstRunConfig.length).toBeLessThan(secondRunConfig.length);
+  });
+
+  test("rejects non-kebab-case", () => {
+    expect(() => scaffoldAppFeature({ name: "ProductCatalog", appRoot })).toThrow(/kebab-case/);
+    expect(() => scaffoldAppFeature({ name: "product_catalog", appRoot })).toThrow(/kebab-case/);
+  });
+
+  test("refuses to overwrite existing feature dir", () => {
+    scaffoldAppFeature({ name: "billing", appRoot });
+    expect(() => scaffoldAppFeature({ name: "billing", appRoot })).toThrow(/already exists/);
+  });
+
+  test("autoMounted=false when run-config.ts is missing", () => {
+    const emptyRoot = join(tmp, "no-app");
+    expect(() => scaffoldAppFeature({ name: "foo", appRoot: emptyRoot })).not.toThrow();
+    const result = scaffoldAppFeature({ name: "bar", appRoot: emptyRoot });
+    expect(result.autoMounted).toBe(false);
+  });
+});

package/src/__tests__/scaffold-app.test.ts

@@ -0,0 +1,104 @@
+// scaffoldApp unit-tests (DX-1.0).
+
+import { existsSync, mkdtempSync, readFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, test } from "vitest";
+import { scaffoldApp } from "../scaffold-app";
+
+describe("scaffoldApp", () => {
+  let tmp: string;
+  beforeEach(() => {
+    tmp = mkdtempSync(join(tmpdir(), "scaffold-app-"));
+  });
+  afterEach(() => {
+    rmSync(tmp, { recursive: true, force: true });
+  });
+
+  test("scaffolds 6 files into <cwd>/<name>", () => {
+    const dest = join(tmp, "my-shop");
+    const result = scaffoldApp({ name: "my-shop", destination: dest });
+
+    expect(result.appName).toBe("my-shop");
+    expect(result.destination).toBe(dest);
+    expect(result.files).toEqual([
+      "package.json",
+      "tsconfig.json",
+      "src/run-config.ts",
+      "bin/main.ts",
+      ".env.example",
+      "README.md",
+    ]);
+    for (const f of result.files) {
+      expect(existsSync(join(dest, f))).toBe(true);
+    }
+  });
+
+  test("package.json has @cosmicdrift/* deps with version pin", () => {
+    const dest = join(tmp, "my-shop");
+    scaffoldApp({ name: "my-shop", destination: dest, frameworkVersion: "^0.13.0" });
+
+    const pkg = JSON.parse(readFileSync(join(dest, "package.json"), "utf-8")) as {
+      name: string;
+      dependencies: Record<string, string>;
+      scripts: Record<string, string>;
+    };
+    expect(pkg.name).toBe("my-shop");
+    expect(pkg.dependencies["@cosmicdrift/kumiko-bundled-features"]).toBe("^0.13.0");
+    expect(pkg.dependencies["@cosmicdrift/kumiko-dev-server"]).toBe("^0.13.0");
+    expect(pkg.dependencies["@cosmicdrift/kumiko-framework"]).toBe("^0.13.0");
+    expect(pkg.scripts["boot"]).toContain("KUMIKO_DRY_RUN_ENV=boot");
+  });
+
+  test("bin/main.ts contains runProdApp + auth.admin stub", () => {
+    const dest = join(tmp, "my-shop");
+    scaffoldApp({ name: "my-shop", destination: dest });
+
+    const main = readFileSync(join(dest, "bin/main.ts"), "utf-8");
+    expect(main).toContain("runProdApp");
+    expect(main).toContain("auth: {");
+    expect(main).toContain("admin@my-shop.local");
+    expect(main).toContain('tenantKey: "my-shop"');
+    // Tenant-ID is a valid UUID-v4 format (xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx).
+    expect(main).toMatch(/[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}/);
+  });
+
+  test("src/run-config.ts mounts secrets + sessions as foundation", () => {
+    const dest = join(tmp, "my-shop");
+    scaffoldApp({ name: "my-shop", destination: dest });
+
+    const runConfig = readFileSync(join(dest, "src/run-config.ts"), "utf-8");
+    expect(runConfig).toContain("createSecretsFeature()");
+    expect(runConfig).toContain("createSessionsFeature()");
+    expect(runConfig).toContain("export const APP_FEATURES");
+  });
+
+  test("rejects non-kebab-case names", () => {
+    expect(() => scaffoldApp({ name: "MyShop", destination: tmp })).toThrow(/kebab-case/);
+    expect(() => scaffoldApp({ name: "my_shop", destination: tmp })).toThrow(/kebab-case/);
+    expect(() => scaffoldApp({ name: "0shop", destination: tmp })).toThrow(/kebab-case/);
+  });
+
+  test("refuses to overwrite existing destination", () => {
+    const dest = join(tmp, "existing");
+    scaffoldApp({ name: "existing", destination: dest });
+    expect(() => scaffoldApp({ name: "existing", destination: dest })).toThrow(/already exists/);
+  });
+
+  test("deterministic tenantId for same name (reproducible boots)", () => {
+    const a = join(tmp, "a");
+    const b = join(tmp, "b");
+    scaffoldApp({ name: "stable", destination: a });
+    scaffoldApp({ name: "stable", destination: b });
+    const mainA = readFileSync(join(a, "bin/main.ts"), "utf-8");
+    const mainB = readFileSync(join(b, "bin/main.ts"), "utf-8");
+    const uuidA = mainA.match(
+      /[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}/,
+    )?.[0];
+    const uuidB = mainB.match(
+      /[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}/,
+    )?.[0];
+    expect(uuidA).toBeDefined();
+    expect(uuidA).toBe(uuidB);
+  });
+});

package/src/__tests__/scaffold-deploy.test.ts

@@ -56,6 +56,17 @@ describe("scaffoldDeploy", () => {
     expect(migrate).toContain("ghcr.io/cosmicdriftgamestudio/minimal:latest");
   });
 
+  it("Dockerfile emits inline start.sh (createBunServer command-override target)", () => {
+    scaffoldDeploy({ appName: "boot-target", destination: tmp });
+    const dockerfile = readFileSync(join(tmp, "deploy", "Dockerfile"), "utf-8");
+    // Inline RUN that creates a start.sh inside the runtime image.
+    // bun-server.ts's createBunServer overrides the container command with
+    // `exec ./start.sh` after injecting DATABASE_URL; without this line the
+    // pod exited 127. Memory: `feedback_audit_drift_root_cause_now`.
+    expect(dockerfile).toContain("> ./start.sh && chmod +x ./start.sh");
+    expect(dockerfile).toContain("exec bun run server.js");
+  });
+
   it("skips existing files by default", () => {
     const existing = join(tmp, "deploy");
     scaffoldDeploy({ appName: "first", destination: tmp });