bazis 0.99.6 → 0.100.1

package/cli/build.ts

@@ -1,9 +1,11 @@
-import { existsSync, mkdtempSync, rmSync, watch } from "node:fs";
+import { existsSync, mkdtempSync, rmSync, statSync, watch } from "node:fs";
 import { tmpdir } from "node:os";
 import path from "node:path";
-import { resolveBun } from "./codegen";
+import { PALETTE, formatBytes, formatDuration, type Problem } from "../library/terminal";
+import { resolveBun, type CodegenOptions } from "./codegen";
+import { commandFailed, commandHeader, createScreens, readFrameLines, type CliOutput } from "./ui";
 
-type Codegen = (cwd: string, target?: string) => Promise<number>;
+type Codegen = (cwd: string, target?: string, options?: CodegenOptions) => Promise<number>;
 
 export interface BuildOptions {
   /** Also compile the entrypoint into a standalone executable. */
@@ -19,23 +21,46 @@ export interface CompileOptions {
   readonly dotenv?: boolean;
 }
 
-/**
- * `bazis dev`: codegen of every target, then run the default target's entrypoint from source.
- * With `watch`, a change under src/ (except src/generated) stops the app,
- * reruns codegen and starts it again; a failed codegen waits for the next change.
- * The app runs as `development` unless BAZIS_ENV is set in the shell.
- */
+const defaultUi = (): CliOutput => createScreens(process.stdout, process.stderr);
+
 /** `bazis dev` means development; an BAZIS_ENV from the shell still wins. */
 export function devEnvironment(env: NodeJS.ProcessEnv): NodeJS.ProcessEnv {
   return { ...env, BAZIS_ENV: env.BAZIS_ENV || "development" };
 }
 
-export async function runDev(cwd: string, codegen: Codegen, log: (message: string) => void, options: { readonly watch?: boolean } = {}): Promise<number> {
+/**
+ * `bazis dev`: codegen of every target, then run the default target's entrypoint from source.
+ * With `watch`, a change under src/ (except src/generated) stops the app,
+ * reruns codegen and starts it again; a failed codegen waits for the next change.
+ * The app runs as `development` unless BAZIS_ENV is set in the shell. The CLI
+ * prints the header and the build; the application prints the rest of the screen.
+ */
+export async function runDev(cwd: string, codegen: Codegen, ui: CliOutput = defaultUi(), options: { readonly watch?: boolean } = {}): Promise<number> {
+  const s = ui.out;
+  const t = s.t;
   const bun = await resolveBun(cwd);
   const entry = await projectEntry(cwd);
-  const env = devEnvironment(process.env);
+  const watchDir = "src/";
+  const env: NodeJS.ProcessEnv = {
+    ...devEnvironment(process.env),
+    // The CLI already printed the logo; the application continues the screen.
+    BAZIS_UI_HEADER: "0",
+    BAZIS_LANG: process.env.BAZIS_LANG || s.language,
+    ...(options.watch ? { BAZIS_UI_WATCH: watchDir } : {}),
+  };
+  commandHeader(s, "dev", cwd, [
+    s.kv(t.meta.env, s.strong(env.BAZIS_ENV ?? "development", PALETTE.yellow)),
+    s.kv(t.meta.watch, options.watch ? s.strong(t.meta.on, PALETTE.lime) : s.muted(t.meta.off)),
+    s.kv(t.meta.src, s.text(path.relative(cwd, entry))),
+  ]);
+  const build = async (footer?: string): Promise<number> => {
+    s.section(t.section.build);
+    const generated = await codegen(cwd, "all", { ui, ...(footer === undefined ? {} : { footer }) });
+    if (generated === 0) s.line();
+    return generated;
+  };
   if (!options.watch) {
-    const generated = await codegen(cwd, "all");
+    const generated = await build();
     if (generated !== 0) return generated;
     const child = Bun.spawn([bun, "run", entry], { cwd, env, stdin: "inherit", stdout: "inherit", stderr: "inherit" });
     // The app owns graceful shutdown; forward the signal instead of dying first.
@@ -62,7 +87,7 @@ export async function runDev(cwd: string, codegen: Codegen, log: (message: strin
     await running.exited;
   };
   const start = async () => {
-    if (await codegen(cwd, "all") !== 0) { log("[bazis] codegen failed; waiting for changes..."); return; }
+    if (await build(t.failure.exitWatch(1, watchDir)) !== 0) return;
     child = Bun.spawn([bun, "run", entry], { cwd, env, stdin: "inherit", stdout: "inherit", stderr: "inherit" });
   };
   const watcher = watch(path.join(cwd, "src"), { recursive: true }, (_event, file) => {
@@ -70,7 +95,13 @@ export async function runDev(cwd: string, codegen: Codegen, log: (message: strin
     if (!file || /^generated([\\/]|$)/.test(String(file))) return;
     clearTimeout(timer);
     timer = setTimeout(() => {
-      queue = queue.then(async () => { log(`[bazis] ${file} changed, restarting...`); await stop(); await start(); });
+      queue = queue.then(async () => {
+        s.line();
+        s.line(`  ${s.strong("↻", PALETTE.link)}  ${s.text(`src/${String(file).replaceAll("\\", "/")}`)} ${s.muted(t.dev.restarting)}`);
+        s.line();
+        await stop();
+        await start();
+      });
     }, 150);
   });
   const finished = Promise.withResolvers<number>();
@@ -81,7 +112,6 @@ export async function runDev(cwd: string, codegen: Codegen, log: (message: strin
   };
   process.once("SIGINT", shutdown);
   process.once("SIGTERM", shutdown);
-  log("[bazis] watching src/ for changes (Ctrl+C to stop)");
   queue = queue.then(start);
   try {
     return await finished.promise;
@@ -92,25 +122,111 @@ export async function runDev(cwd: string, codegen: Codegen, log: (message: strin
 }
 
 /** `bazis test [args]`: codegen of every target, then `bun test` with the given arguments. */
-export async function runTest(cwd: string, args: readonly string[], codegen: Codegen): Promise<number> {
-  const generated = await codegen(cwd, "all");
+export async function runTest(cwd: string, args: readonly string[], codegen: Codegen, ui: CliOutput = defaultUi()): Promise<number> {
+  const s = ui.out;
+  const t = s.t;
+  commandHeader(s, "test", cwd, [s.kv(t.meta.env, s.strong("test", PALETTE.link)), ...(args.length ? [s.text(`bun test ${args.join(" ")}`)] : [])]);
+  s.section(t.section.build);
+  const generated = await codegen(cwd, "all", { ui });
   if (generated !== 0) return generated;
-  return await Bun.spawn([await resolveBun(cwd), "test", ...args], { cwd, stdin: "inherit", stdout: "inherit", stderr: "inherit" }).exited;
+  s.line();
+  s.section(t.section.tests);
+  s.line();
+  const startedAt = performance.now();
+  const exitCode = await Bun.spawn([await resolveBun(cwd), "test", ...args], { cwd, stdin: "inherit", stdout: "inherit", stderr: "inherit" }).exited;
+  s.line();
+  if (exitCode === 0) {
+    s.banner("success", `${t.test.done} · ${formatDuration(performance.now() - startedAt)}`);
+    return 0;
+  }
+  ui.err.banner("failed", t.test.failed(exitCode));
+  ui.err.footer(t.failure.exit(exitCode));
+  return exitCode;
 }
 
 /** `bazis build [--bin]`: codegen of every target and typecheck; with `bin`, also compile. */
-export async function runBuild(cwd: string, options: BuildOptions, codegen: Codegen, log: (message: string) => void): Promise<number> {
-  const generated = await codegen(cwd, "all");
+export async function runBuild(cwd: string, options: BuildOptions, codegen: Codegen, ui: CliOutput = defaultUi()): Promise<number> {
+  const s = ui.out;
+  const t = s.t;
+  const startedAt = performance.now();
+  const outfile = options.bin ? path.resolve(cwd, options.outfile ?? path.join("bin", await binaryName(cwd))) : undefined;
+  commandHeader(s, "build", cwd, [
+    s.kv(t.meta.target, s.text(options.bin ? "executable" : "typecheck")),
+    ...(outfile === undefined ? [] : [s.kv(t.meta.out, s.text(path.relative(cwd, outfile)))]),
+  ]);
+  s.section(t.section.build);
+  const generated = await codegen(cwd, "all", { ui });
   if (generated !== 0) return generated;
   const bun = await resolveBun(cwd);
   const tsc = path.join(cwd, "node_modules/typescript/bin/tsc");
   if (!existsSync(tsc)) throw new Error("TypeScript is not installed in this project. Run: bun add -d typescript");
-  log("[bazis] typecheck...");
-  const typecheck = await Bun.spawn([bun, tsc, "--noEmit"], { cwd, stdout: "inherit", stderr: "inherit" }).exited;
-  if (typecheck !== 0 || !options.bin) return typecheck;
-  const outfile = path.resolve(cwd, options.outfile ?? path.join("bin", await binaryName(cwd)));
-  log(`[bazis] compile ${path.relative(cwd, outfile)}...`);
-  return compileBinary(bun, await projectEntry(cwd), outfile, { dotenv: options.dotenv });
+  const stop = s.progress(t.step.typecheck);
+  const typecheckStarted = performance.now();
+  const child = Bun.spawn([bun, tsc, "--noEmit", "--pretty", "false"], { cwd, stdout: "pipe", stderr: "pipe" });
+  const [stdout, stderr, typecheck] = await Promise.all([new Response(child.stdout).text(), new Response(child.stderr).text(), child.exited]);
+  stop();
+  const typecheckMs = formatDuration(performance.now() - typecheckStarted);
+  if (typecheck !== 0) {
+    const problems = typeProblems(`${stdout}\n${stderr}`, cwd);
+    s.step("fail", t.step.typecheck, s.num(problems.length, t.noun("error", problems.length), PALETTE.red), typecheckMs);
+    s.line();
+    if (problems.length === 0) ui.err.line(`${stdout}${stderr}`.trimEnd());
+    return commandFailed(ui.err, t.failure.typecheck(problems.length), problems.slice(0, 20), typecheck);
+  }
+  s.step("ok", t.step.typecheck, s.muted(t.build.typecheckOk), typecheckMs);
+  s.line();
+  if (outfile === undefined) {
+    s.banner("success", t.build.done(formatDuration(performance.now() - startedAt)));
+    return 0;
+  }
+  s.section(t.section.binary);
+  const stopCompile = s.progress(t.step.compile);
+  const compileStarted = performance.now();
+  const compiled = await compileBinaryAsync(bun, await projectEntry(cwd), outfile, { dotenv: options.dotenv });
+  stopCompile();
+  const compileMs = formatDuration(performance.now() - compileStarted);
+  const relative = path.relative(cwd, outfile);
+  if (compiled.exitCode !== 0) {
+    s.step("fail", t.step.compile, "", compileMs);
+    s.line();
+    return commandFailed(ui.err, t.failure.command, [{ tag: "COMPILE", where: relative, cause: compiled.output.trim() || `bun build exited with code ${compiled.exitCode}` }], compiled.exitCode);
+  }
+  s.step("ok", t.step.compile, `${s.text(relative)}${s.dot}${s.strong(formatBytes(statSync(outfile).size))}`, compileMs);
+  s.line();
+  s.banner("success", t.build.binaryDone(relative));
+  s.panel([
+    s.panelRow(t.build.run, s.code(`./${relative}`)),
+    "",
+    s.muted(t.build.production),
+    ...(options.dotenv ? [s.muted(t.build.dotenv)] : []),
+  ]);
+  s.line();
+  return 0;
+}
+
+/** `src/a.ts(12,5): error TS2322: …` → a problem with the code around the line. */
+export function typeProblems(output: string, cwd: string): Problem[] {
+  const problems: Problem[] = [];
+  for (const line of output.split("\n")) {
+    const match = /^(.+?)\((\d+),(\d+)\): error (TS\d+): (.*)$/.exec(line.trim());
+    if (!match) {
+      // tsc continues a message on indented lines.
+      const last = problems.at(-1);
+      if (last !== undefined && /^\s+\S/.test(line)) problems[problems.length - 1] = { ...last, cause: `${last.cause}\n${line.trim()}` };
+      continue;
+    }
+    const [, file, lineText, columnText, code, message] = match as unknown as [string, string, string, string, string, string];
+    const lineNumber = Number(lineText);
+    const lines = readFrameLines(path.resolve(cwd, file), lineNumber);
+    problems.push({
+      tag: "TYPE",
+      where: `${file}:${lineNumber}:${columnText}`,
+      cause: message,
+      ...(lines.length === 0 ? {} : { frame: { lines, line: lineNumber, column: Number(columnText), length: 1 } }),
+      code,
+    });
+  }
+  return problems;
 }
 
 /**
@@ -127,19 +243,38 @@ export async function runBuild(cwd: string, options: BuildOptions, codegen: Code
  */
 export function compileBinary(bun: string, entry: string, outfile: string, options: CompileOptions = {}): number {
   const workDir = mkdtempSync(path.join(tmpdir(), "bazis-compile-"));
-  const autoload = ["--no-compile-autoload-bunfig", options.dotenv === true ? "--compile-autoload-dotenv" : "--no-compile-autoload-dotenv"];
   try {
-    const result = Bun.spawnSync([bun, "build", "--compile", ...autoload, path.resolve(entry), "--outfile", path.resolve(outfile)],
-      { cwd: workDir, stdout: "inherit", stderr: "inherit" });
+    const result = Bun.spawnSync(compileArgs(bun, entry, outfile, options), { cwd: workDir, stdout: "inherit", stderr: "inherit" });
     return result.exitCode ?? 1;
   } finally {
-    if (existsSync("/usr/bin/chflags")) Bun.spawnSync(["/usr/bin/chflags", "-R", "nouchg", workDir]);
-    try {
-      rmSync(workDir, { recursive: true, force: true });
-    } catch (error) {
-      // The binary itself is complete; report the leftover without failing the build.
-      console.error(`[bazis] temporary directory was not removed: ${workDir}`, error);
-    }
+    removeWorkDir(workDir);
+  }
+}
+
+/** {@link compileBinary} without blocking, with the compiler's output captured for the screen. */
+export async function compileBinaryAsync(bun: string, entry: string, outfile: string, options: CompileOptions = {}): Promise<{ exitCode: number; output: string }> {
+  const workDir = mkdtempSync(path.join(tmpdir(), "bazis-compile-"));
+  try {
+    const child = Bun.spawn(compileArgs(bun, entry, outfile, options), { cwd: workDir, stdout: "pipe", stderr: "pipe" });
+    const [stdout, stderr, exitCode] = await Promise.all([new Response(child.stdout).text(), new Response(child.stderr).text(), child.exited]);
+    return { exitCode, output: `${stdout}${stderr}` };
+  } finally {
+    removeWorkDir(workDir);
+  }
+}
+
+function compileArgs(bun: string, entry: string, outfile: string, options: CompileOptions): string[] {
+  const autoload = ["--no-compile-autoload-bunfig", options.dotenv === true ? "--compile-autoload-dotenv" : "--no-compile-autoload-dotenv"];
+  return [bun, "build", "--compile", ...autoload, path.resolve(entry), "--outfile", path.resolve(outfile)];
+}
+
+function removeWorkDir(workDir: string): void {
+  if (existsSync("/usr/bin/chflags")) Bun.spawnSync(["/usr/bin/chflags", "-R", "nouchg", workDir]);
+  try {
+    rmSync(workDir, { recursive: true, force: true });
+  } catch (error) {
+    // The binary itself is complete; report the leftover without failing the build.
+    console.error(`[bazis] temporary directory was not removed: ${workDir}`, error);
   }
 }
 

package/cli/codegen.ts

@@ -1,21 +1,172 @@
-import { existsSync } from "node:fs";
+import { existsSync, mkdtempSync, readFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
 import path from "node:path";
+import { PALETTE, formatDuration, type Problem, type Screen } from "../library/terminal";
+import { commandFailed, createScreens, readFrameLines, type CliOutput } from "./ui";
 
 const GENERATOR = "core/scripts/di-generate.ts";
 
-/** Run the framework generator for the project in `cwd`; returns its exit code. */
-export async function runCodegen(cwd: string, target?: string): Promise<number> {
+/** What the generator reports through `BAZIS_CODEGEN_REPORT`. */
+export interface CodegenReport {
+  readonly ok: boolean;
+  readonly ms: number;
+  readonly targets: readonly {
+    readonly name: string; readonly sources: number; readonly deps: number; readonly controllers: number;
+    readonly requestModels: number; readonly listModels: number; readonly tools: number; readonly ms: number;
+  }[];
+  readonly outputs: readonly string[];
+  readonly warnings: readonly string[];
+  readonly errors: readonly string[];
+}
+
+export interface CodegenOptions {
+  readonly ui?: CliOutput;
+  /** The last line of a failure: the exit code, or what `dev --watch` does next. */
+  readonly footer?: string;
+}
+
+/**
+ * Runs the framework generator for the project in `cwd` and renders its
+ * result as the `codegen` step: counts and generated files, warnings, and on
+ * failure one problem per error with the code around it. Returns its exit code.
+ */
+export async function runCodegen(cwd: string, target?: string, options: CodegenOptions = {}): Promise<number> {
   if (target !== undefined) {
     const configFile = Bun.file(path.join(cwd, "bazis.config.json"));
     if (!await configFile.exists()) throw new Error("--target requires bazis.config.json in the current directory.");
     const config = await configFile.json();
     if (target !== "all" && !Object.hasOwn(config.targets ?? {}, target)) throw new Error(`Unknown codegen target: ${target}`);
   }
+  const ui = options.ui ?? createScreens(process.stdout, process.stderr);
+  const s = ui.out;
   const generator = resolveGenerator(cwd);
   // TypeScript 7 has no compiler API: the preload switches it to @typescript/typescript6.
   const preload = path.join(path.dirname(generator), "typescriptApiPreload.ts");
   const args = [await resolveBun(cwd), ...(existsSync(preload) ? ["--preload", preload] : []), generator, ...(target === undefined ? [] : ["--target", target])];
-  return await Bun.spawn(args, { cwd, stdout: "inherit", stderr: "inherit" }).exited;
+  const workDir = mkdtempSync(path.join(tmpdir(), "bazis-codegen-"));
+  const reportFile = path.join(workDir, "report.json");
+  const stop = s.progress(s.t.step.codegen);
+  const startedAt = performance.now();
+  try {
+    const child = Bun.spawn(args, { cwd, env: { ...process.env, BAZIS_CODEGEN_REPORT: reportFile }, stdout: "pipe", stderr: "pipe" });
+    const [stdout, stderr, exitCode] = await Promise.all([new Response(child.stdout).text(), new Response(child.stderr).text(), child.exited]);
+    stop();
+    const report = readReport(reportFile);
+    if (report === undefined) {
+      // The generator did not get to its report: show what it printed.
+      s.step("fail", s.t.step.codegen, "", formatDuration(performance.now() - startedAt));
+      ui.err.line([stdout, stderr].filter((text) => text.trim()).join("\n").trimEnd());
+      return exitCode === 0 ? 1 : exitCode;
+    }
+    renderCodegen(ui, report, cwd, options.footer);
+    return report.ok && exitCode === 0 ? 0 : (exitCode || 1);
+  } finally {
+    stop();
+    rmSync(workDir, { recursive: true, force: true });
+  }
+}
+
+function readReport(file: string): CodegenReport | undefined {
+  try {
+    return JSON.parse(readFileSync(file, "utf8")) as CodegenReport;
+  } catch {
+    return undefined;
+  }
+}
+
+export function renderCodegen(ui: CliOutput, report: CodegenReport, cwd: string, footer?: string): void {
+  const s = ui.out;
+  const t = s.t;
+  const time = formatDuration(report.ms);
+  const target = report.targets.find((item) => item.name === "production") ?? report.targets[0];
+  if (!report.ok) {
+    s.step("fail", t.step.codegen, `${s.num(report.errors.length, t.noun("error", report.errors.length), PALETTE.red)}${report.warnings.length ? `${s.dot}${s.num(report.warnings.length, t.noun("warning", report.warnings.length), PALETTE.orange)}` : ""}`, time);
+    printWarnings(s, report.warnings);
+    s.line();
+    commandFailed(ui.err, t.failure.codegen(report.errors.length), report.errors.map((error) => codegenProblem(error, cwd, ui.err)), 1, footer);
+    return;
+  }
+  const counts = target === undefined ? [] : [
+    s.num(target.sources, t.noun("file", target.sources)),
+    s.num(target.deps, t.noun("dep", target.deps)),
+    s.num(target.controllers, t.noun("controller", target.controllers)),
+    s.num(target.requestModels, t.noun("requestModel", target.requestModels)),
+    s.num(target.listModels, t.noun("list", target.listModels)),
+    s.num(target.tools, t.noun("tool", target.tools)),
+  ];
+  s.step("ok", t.step.codegen, counts.join(s.dot), time);
+  const directories = new Map<string, string[]>();
+  for (const output of report.outputs) {
+    const directory = path.dirname(output);
+    directories.set(directory, [...(directories.get(directory) ?? []), path.basename(output, ".ts")]);
+  }
+  s.tree([...directories].map(([directory, files]) => ({ text: `${s.muted(`${directory}/`)} ${s.text(files.join(" · "))}` })), s.style.color ? 9 : 4);
+  printWarnings(s, report.warnings);
+}
+
+function printWarnings(s: Screen, warnings: readonly string[]): void {
+  for (const warning of warnings) {
+    const unassigned = /^BAZIS_CODEGEN_SOURCE_UNASSIGNED: ([^:]+):/.exec(warning);
+    if (unassigned) {
+      s.warning(`${s.t.codegen.unreachable(unassigned[1]!)}${s.dot}${s.muted(s.t.codegen.unreachableFix)}`);
+    } else {
+      s.warning(warning);
+    }
+  }
+}
+
+/** `CODE: file:line: message` → a problem with the code around the line. */
+export function codegenProblem(error: string, cwd: string, screen: Screen): Problem {
+  const t = screen.t;
+  const parsed = /^([A-Z][A-Z0-9_]+): (?:([^\s:]+\.tsx?):(\d+): )?([\s\S]*)$/.exec(error);
+  if (parsed === null) return { tag: "CODEGEN", where: "codegen", cause: error };
+  const [, code, file, lineText, message] = parsed as unknown as [string, string, string | undefined, string | undefined, string];
+  const tag = code.startsWith("BAZIS_DI_") ? "DI" : code.startsWith("BAZIS_HTTP_") ? "HTTP" : "CODEGEN";
+  const fixes: string[] = [];
+  let frame: Problem["frame"];
+  let line = lineText === undefined ? undefined : Number(lineText);
+  if (file !== undefined && line !== undefined) {
+    const type = /has type "([^"]+)"/.exec(message)?.[1];
+    // The location is the class; the parameter with that type is a few lines below.
+    if (type !== undefined) line = parameterLine(path.resolve(cwd, file), line, type) ?? line;
+    const lines = readFrameLines(path.resolve(cwd, file), line);
+    const text = lines.find(([number]) => number === line)?.[1] ?? "";
+    const column = type === undefined ? -1 : text.search(new RegExp(`(?<=:\\s*)${escapeRegExp(type)}\\b`));
+    frame = lines.length === 0 ? undefined : {
+      lines,
+      line,
+      ...(column >= 0 ? { column: column + 1, length: type!.length } : {}),
+    };
+    if (type === "SQL") fixes.push(t.codegen.sqlFix);
+    else if (type === "RedisClient") fixes.push(t.codegen.redisFix);
+    else if (code === "BAZIS_DI_DEPENDENCY_UNKNOWN") fixes.push(t.codegen.unknownDepFix);
+  }
+  return {
+    tag,
+    where: file === undefined ? code : `${file}:${line}`,
+    cause: message.trim(),
+    fixes,
+    ...(frame === undefined ? {} : { frame }),
+    code,
+  };
+}
+
+/** The first line from `from` on that declares something of type `type`. */
+function parameterLine(file: string, from: number, type: string): number | undefined {
+  try {
+    const lines = readFileSync(file, "utf8").split("\n");
+    const pattern = new RegExp(`:\\s*${escapeRegExp(type)}\\b`);
+    for (let index = from - 1; index < Math.min(lines.length, from + 40); index += 1) {
+      if (pattern.test(lines[index] ?? "")) return index + 1;
+    }
+  } catch {
+    return undefined;
+  }
+  return undefined;
+}
+
+function escapeRegExp(text: string): string {
+  return text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 
 /**

package/cli/generateProject.ts

@@ -1,6 +1,7 @@
 import path from "node:path";
 import { copyFile, lstat, mkdir, mkdtemp, readFile, readdir, realpath, rename, rm, writeFile } from "node:fs/promises";
 import { parseModuleName } from "./naming";
+import { parseLanguage, systemLanguage } from "../library/terminal";
 
 export interface GenerateProjectOptions {
   readonly name: string;
@@ -159,7 +160,9 @@ function buildProjectFiles(name: string, dependency: string, frameworkMode: Fram
     },
     include: ["src/**/*"],
   };
-  const codegen = { version: 1, defaultTarget: "production", targets: { production: { entrypoints: ["src/index.ts"] } } };
+  // Output language of the CLI and the startup screen, from the system locale; BAZIS_LANG and --lang override it.
+  const language = parseLanguage(systemLanguage()) ?? "en";
+  const codegen = { version: 1, defaultTarget: "production", language, targets: { production: { entrypoints: ["src/index.ts"] } } };
   return [
     ["package.json", `${JSON.stringify(manifest, null, 2)}\n`],
     ["tsconfig.json", `${JSON.stringify(tsconfig, null, 2)}\n`],
@@ -184,7 +187,10 @@ const HEALTH_TEST = `import { expect, test } from "bun:test";
 
 // Starts the app from source exactly as \`bazis dev\` does and checks /health.
 test("app starts and answers /health", async () => {
-  const port = String(20000 + Math.floor(Math.random() * 20000));
+  // A free port from the operating system, not a random guess that may be taken.
+  const probe = Bun.serve({ hostname: "127.0.0.1", port: 0, fetch: () => new Response() });
+  const port = String(probe.port);
+  probe.stop(true);
   const app = Bun.spawn([process.execPath, "run", "src/index.ts"], { env: { ...process.env, HOST: "127.0.0.1", PORT: port }, stdout: "ignore", stderr: "inherit" });
   try {
     let status = 0;