bazis 0.99.5 → 0.100.0

package/core/kernel/report/startupProblems.ts

@@ -0,0 +1,186 @@
+import { DiError } from "../../di";
+import { ServiceValidationError } from "../../di/errors/ServiceValidationError";
+import { redactSensitiveText } from "../../../library/redaction";
+import type { Problem, Screen } from "../../../library/terminal";
+import { ConfigValidationError, type ConfigIssue } from "../config/ConfigValidationError";
+import { KernelError, StartupFailuresError, StartupTimeoutError } from "../errors";
+import type { ConnectionFact, StartupReport } from "./StartupReport";
+import { formatStartupFailure } from "../startupFailure";
+
+/** Startup stages in execution order. */
+export const STARTUP_STAGES = ["configuration", "modules", "infrastructure", "schema", "services"] as const;
+export type StartupStage = (typeof STARTUP_STAGES)[number];
+
+/** Which stage failed, the banner text and one problem per cause. */
+export interface StartupDiagnosis {
+  readonly stage: StartupStage;
+  readonly title: string;
+  readonly problems: readonly Problem[];
+}
+
+export interface StartupFailureContext {
+  readonly report?: StartupReport;
+  /** Hosted services whose start failed. */
+  readonly failedServices?: readonly string[];
+}
+
+/**
+ * Turns a startup failure into problems a person can act on: every invalid
+ * configuration key, every refused connection, a missing DI registration with
+ * what to connect. An unknown error keeps its text and stack.
+ */
+export function diagnoseStartupFailure(error: unknown, screen: Screen, context: StartupFailureContext = {}): StartupDiagnosis {
+  const t = screen.t;
+  if (error instanceof ConfigValidationError) {
+    const problems = error.issues.map((issue) => configProblem(issue, screen));
+    return { stage: "configuration", title: t.failure.config(problems.length), problems };
+  }
+  if (error instanceof StartupTimeoutError) {
+    const seconds = `${Math.round(error.timeoutMs / 100) / 10} s`;
+    const pending = error.pending ?? "";
+    return {
+      stage: stageOf(pending.split(", ")[0] ?? ""),
+      title: t.failure.timeout(seconds),
+      problems: [{
+        tag: "TIMEOUT",
+        where: pending || "start",
+        cause: t.failure.timeoutCause(pending || "start", seconds),
+        fixes: [t.infra.hint.deadline, screen.code(t.infra.hint.raiseLimit)],
+      }],
+    };
+  }
+  const down = (context.report?.connections ?? []).filter((connection) => connection.status === "down");
+  if (down.length > 0) {
+    const total = context.report?.connections.length ?? down.length;
+    return { stage: "infrastructure", title: t.failure.infra(down.length, total), problems: down.map((connection) => connectionProblem(connection, screen)) };
+  }
+  if (error instanceof ServiceValidationError) {
+    return { stage: "modules", title: t.failure.di, problems: diProblems(error.issues, screen) };
+  }
+  if (error instanceof DiError) {
+    return { stage: "modules", title: t.failure.di, problems: diProblems([error.message], screen) };
+  }
+  if (error instanceof StartupFailuresError) {
+    return {
+      stage: stageOf(error.failures[0]?.name ?? ""),
+      title: t.failure.app,
+      problems: error.failures.map((failure) => genericProblem(failure.error, failure.name)),
+    };
+  }
+  const failed = context.failedServices?.[0];
+  const stage = error instanceof KernelError && failed === undefined ? "configuration" : stageOf(failed ?? "");
+  return { stage, title: t.failure.app, problems: [genericProblem(error, failed)] };
+}
+
+/** `infra:db` → infrastructure, `schema:TaskDbContext` → schema, the rest → services. */
+function stageOf(name: string): StartupStage {
+  if (name.startsWith("infra:")) return "infrastructure";
+  if (name.startsWith("schema:")) return "schema";
+  return "services";
+}
+
+function configProblem(issue: ConfigIssue, screen: Screen): Problem {
+  const t = screen.t;
+  const variables = issue.env.map((name) => screen.code(name)).join(" / ");
+  const causes: Record<ConfigIssue["kind"], string> = {
+    "missing-secret": t.config.issue.missingSecret,
+    "development-secret": t.config.issue.devSecret,
+    number: t.config.issue.number,
+    boolean: t.config.issue.boolean,
+    string: t.config.issue.string,
+    enum: t.config.issue.enumValue((issue.allowed ?? []).join(", ")),
+    validator: issue.message,
+    conflict: t.config.issue.conflict,
+  };
+  const fixes: string[] = [];
+  if (issue.kind === "missing-secret") fixes.push(`${t.config.fix.setVariable(variables)}, ${t.config.fix.orSecretFile}`);
+  else if (issue.kind === "development-secret") fixes.push(t.config.fix.setVariable(variables), t.config.fix.orProduction(screen.code(issue.key.split(".").at(-1) ?? issue.key)));
+  else fixes.push(t.config.fix.change(issue.source === undefined ? variables : screen.code(issue.source)));
+  // The wrong value and the variable that brought it.
+  const got = /got (".*?") \((\S+)\)$|^(".*?") is not allowed.*\((\S+)\)$/.exec(issue.message);
+  const detail = got === null ? "" : `\n${t.config.issue.got(redactSensitiveText(got[1] ?? got[3] ?? ""), got[2] ?? got[4] ?? "")}`;
+  return {
+    tag: "CONFIG",
+    where: issue.key,
+    cause: `${causes[issue.kind]}${detail}`,
+    fixes,
+    ...(issue.declaredIn === undefined ? {} : { declaredIn: issue.declaredIn }),
+  };
+}
+
+function connectionProblem(connection: ConnectionFact, screen: Screen): Problem {
+  const t = screen.t;
+  const message = redactSensitiveText(errorText(connection.error)).replace(/^Infra connector "[^"]+": /, "");
+  const pick = (pattern: RegExp) => (connection.settings ?? []).filter((name) => pattern.test(name)).map((name) => screen.code(name)).join(", ");
+  // Credentials for an authentication failure, the address for the rest.
+  const credentials = pick(/USER|PASSWORD|KEY|TOKEN|SECRET/i);
+  const settings = pick(/HOST|PORT|URL|DATABASE|ADDRESS/i);
+  const fixes: string[] = [];
+  const kind = (connection.kind ?? connection.name).split(" ")[0] ?? connection.name;
+  if (/password authentication failed|authentication failed|WRONGPASS|NOAUTH|401|403|invalid api key|unauthorized/i.test(message)) {
+    fixes.push(t.infra.hint.password(credentials || connection.name));
+  } else if (/database "[^"]+" does not exist|3D000/i.test(message)) {
+    fixes.push(t.infra.hint.database);
+  } else if (/ENOTFOUND|getaddrinfo|could not resolve|DNS/i.test(message)) {
+    fixes.push(t.infra.hint.dns);
+    if (settings) fixes.push(t.infra.hint.address(settings));
+  } else if (/within \d+ ?ms|timed? ?out|no answer/i.test(message)) {
+    fixes.push(t.infra.hint.timeout);
+    if (settings) fixes.push(t.infra.hint.address(settings));
+  } else if (/ECONNREFUSED|refused|Connection closed|not reachable|cannot reach|failed to connect|unable to connect/i.test(message)) {
+    fixes.push(t.infra.hint.refused(kind));
+    if (settings) fixes.push(t.infra.hint.address(settings));
+  } else if (settings) {
+    fixes.push(t.infra.hint.address(settings));
+  }
+  return {
+    tag: "INFRA",
+    where: connection.address === undefined ? connection.name : `${connection.name} · ${connection.address}`,
+    cause: message,
+    fixes,
+  };
+}
+
+/** One problem per DI issue; every consumer of a missing database is one problem. */
+function diProblems(issues: readonly string[], screen: Screen): Problem[] {
+  const t = screen.t;
+  const problems: Problem[] = [];
+  const database: string[] = [];
+  for (const issue of issues) {
+    const missing = /Missing dependency "([^"]+)" for "([^"]+)"/.exec(issue);
+    if (missing?.[1] === "DatabaseProvider") {
+      // The ORM lifecycle is a consumer too; the contexts name the modules.
+      if (missing[2] !== "IHostedService") database.push(missing[2]!);
+      continue;
+    }
+    problems.push({ tag: "DI", where: missing?.[2] ?? "container", cause: redactSensitiveText(issue) });
+  }
+  if (database.length > 0) {
+    problems.unshift({
+      tag: "DI",
+      where: "DatabaseProvider",
+      cause: `${t.failure.dbMissing(database.join(", "))}\nMissing dependency "DatabaseProvider"`,
+      fixes: [screen.code(t.failure.dbFix)],
+    });
+  }
+  return problems;
+}
+
+function genericProblem(error: unknown, where: string | undefined): Problem {
+  const text = errorText(error);
+  const name = error instanceof Error ? error.name : "Error";
+  const stack = formatStartupFailure(error).split("\n").filter((line) => /^\s+at /.test(line)).slice(0, 6);
+  return {
+    tag: name === "Error" ? "ERROR" : name.replace(/Error$/, "").toUpperCase() || "ERROR",
+    where: where ?? name,
+    cause: redactSensitiveText(text),
+    ...(stack.length === 0 ? {} : { details: stack.map((line) => line.trim()) }),
+  };
+}
+
+function errorText(error: unknown): string {
+  if (error instanceof AggregateError && error.errors.length > 0) {
+    return [error.message, ...error.errors.map((inner) => `- ${inner instanceof Error ? inner.message : String(inner)}`)].join("\n");
+  }
+  return error instanceof Error ? error.message : String(error);
+}

package/core/orm/OrmLifecycle.ts

@@ -2,6 +2,7 @@ import { ormHostedPlanValidator } from "./OrmHostedPlan.validator";
 import type { HostedService } from "../di";
 import { DatabaseFacade, type DbContextOptions, type EnsureCreatedWithMigrationsResult, type Migration } from "../../library/orm";
 import { compileExpectedSchema } from "../../library/orm/Schema/ExpectedSchema";
+import type { StartupReport } from "../kernel/report/StartupReport";
 
 /**
  * ORM lifecycle hosted service: at start it (optionally) creates the schema or
@@ -11,6 +12,8 @@ import { compileExpectedSchema } from "../../library/orm/Schema/ExpectedSchema";
 export class OrmLifecycle implements HostedService {
   readonly planValidator = ormHostedPlanValidator;
   readonly phase: number;
+  /** `schema:TaskDbContext` in startup diagnostics and timings. */
+  readonly diagnosticName: string;
   /** Internal hosted-plan marker; public hosted services never receive it. */
   readonly __bazisOrmLegacyLifecycle = true;
   /**
@@ -48,7 +51,9 @@ export class OrmLifecycle implements HostedService {
      */
     private readonly ownsConnection: boolean = true,
     contextName = "DbContext",
+    private readonly report?: StartupReport,
   ) {
+    this.diagnosticName = `schema:${contextName}`;
     const modes = [ensureCreated && "ensureCreated", migrateOnStart && "migrateOnStart", runMigrationsOnStart && migrations.length > 0 && "migrations"].filter(Boolean);
     this.withMigrations = ensureCreated && runMigrationsOnStart && migrations.length > 0;
     this.__bazisSchemaOwner = Object.freeze({ context: contextName, mode: modes.join(" + ") || "none" });
@@ -73,38 +78,55 @@ export class OrmLifecycle implements HostedService {
 
   async start(): Promise<void> {
     const database = new DatabaseFacade(this.options.provider, this.options.model);
+    const startedAt = performance.now();
+    // The startup screen lists the changes; without it they are logged as before.
+    const log = this.report?.screen !== true;
+    const applied: string[] = [], migrated: string[] = [], baselined: string[] = [], warnings: string[] = [];
     try {
       if (this.ensureCreated) {
         const result: Partial<EnsureCreatedWithMigrationsResult> & Pick<EnsureCreatedWithMigrationsResult, "warnings"> = this.withMigrations ? await database.ensureCreatedWithMigrations(this.migrations) : await database.ensureCreated();
         // Logged in execution order: migrations, schema changes, then the baseline record.
         if (result.migrated && result.migrated.length > 0) {
-          console.info(`[orm:migrations] applied: ${result.migrated.join(", ")}`);
+          migrated.push(...result.migrated);
+          if (log) console.info(`[orm:migrations] applied: ${result.migrated.join(", ")}`);
         }
         if (result.applied && result.applied.length > 0) {
-          console.info(`[orm:schema] applied ${result.applied.length} operation(s): ${result.applied.join(", ")}`);
+          applied.push(...result.applied);
+          if (log) console.info(`[orm:schema] applied ${result.applied.length} operation(s): ${result.applied.join(", ")}`);
         }
         if (result.baselined && result.baselined.length > 0) {
-          console.info(`[orm:migrations] baseline: the schema was created from the model, recorded as applied without running: ${result.baselined.join(", ")}`);
+          baselined.push(...result.baselined);
+          if (log) console.info(`[orm:migrations] baseline: the schema was created from the model, recorded as applied without running: ${result.baselined.join(", ")}`);
         }
         for (const warning of result.warnings) {
-          console.warn(`[orm:schema] ${warning}`);
+          warnings.push(warning);
+          if (log) console.warn(`[orm:schema] ${warning}`);
         }
       }
       if (this.migrateOnStart) {
         const result = await database.migrate();
         if (result.applied > 0) {
-          console.info(`[orm:migrate] applied ${result.applied} operation(s): ${result.operations.join(", ")}`);
+          applied.push(...result.operations);
+          if (log) console.info(`[orm:migrate] applied ${result.applied} operation(s): ${result.operations.join(", ")}`);
         }
         for (const warning of result.warnings) {
-          console.warn(`[orm:migrate] ${warning}`);
+          warnings.push(warning);
+          if (log) console.warn(`[orm:migrate] ${warning}`);
         }
       }
       if (this.runMigrationsOnStart && this.migrations.length > 0 && !this.withMigrations) {
         const result = await database.migrateVersioned(this.migrations);
         if (result.applied.length > 0) {
-          console.info(`[orm:migrations] applied: ${result.applied.join(", ")}`);
+          migrated.push(...result.applied);
+          if (log) console.info(`[orm:migrations] applied: ${result.applied.join(", ")}`);
         }
       }
+      if (this.__bazisSchemaOwner.mode !== "none") this.report?.schema({
+        context: this.__bazisSchemaOwner.context,
+        mode: this.__bazisSchemaOwner.mode,
+        applied, migrated, baselined, warnings,
+        ms: performance.now() - startedAt,
+      });
     } catch (error) {
       if (!this.ownsConnection) {
         throw error;

package/core/orm/buildOrmProviders.ts

@@ -1,7 +1,7 @@
 import { DI, HOSTED_SERVICE, type InjectionToken, type ModuleOwnedContributionSnapshot, type ProviderDefinition, type ProviderDependencyList, type ServiceResolver } from "../di";
 import { getGeneratedClassDeps } from "../di/module/autoDeps";
 import { resolveDependencyList } from "../di/internal/resolveDependencyList";
-import { HEALTH_CHECK } from "../kernel";
+import { HEALTH_CHECK, StartupReport } from "../kernel";
 import { DbContextOptions, OrmError, type DatabaseProvider, type DbContext } from "../../library/orm";
 import { OrmLifecycle } from "./OrmLifecycle";
 import { ownedStoreLifecycleFor, ownedStoreLifecycleHealthFor } from "./OrmOwnedStoreLifecycle";
@@ -56,7 +56,10 @@ function createOrmLifecycle<TContext extends DbContext>(
   config: OrmBuildConfig<TContext>,
   options: DbContextOptions,
   ownsConnection: boolean,
+  serviceProvider: unknown,
 ): OrmLifecycle {
+  const services = serviceProvider as { has?(token: unknown): boolean; resolve?(token: unknown): unknown };
+  const report = services.has?.(StartupReport) ? services.resolve?.(StartupReport) as StartupReport : undefined;
   return new OrmLifecycle(
     options,
     config.ensureCreated === true,
@@ -65,6 +68,7 @@ function createOrmLifecycle<TContext extends DbContext>(
     config.runMigrationsOnStart === true,
     ownsConnection,
     config.context.name,
+    report,
   );
 }
 
@@ -115,7 +119,7 @@ export function buildOrmModuleProviders<TContext extends DbContext>(
             });
             return ownedStoreLifecycleFor(container, provider, records);
           }
-          return createOrmLifecycle(current, createContextOptions(current, provider), false);
+          return createOrmLifecycle(current, createContextOptions(current, provider), false, serviceProvider);
         }),
       ),
     ];
@@ -138,7 +142,7 @@ export function buildOrmModuleProviders<TContext extends DbContext>(
     // Standalone mode: the context owns its provider and closes it.
     DI.singleton(DI.factoryProvider(HOSTED_SERVICE, [SERVICE_PROVIDER], (serviceProvider) => {
       const current = effectiveConfigFor(serviceProvider, registrationIdentity, config);
-      return createOrmLifecycle(current, current === config && optionsAtModuleCall !== undefined ? optionsAtModuleCall : createContextOptions(current, provider), true);
+      return createOrmLifecycle(current, current === config && optionsAtModuleCall !== undefined ? optionsAtModuleCall : createContextOptions(current, provider), true, serviceProvider);
     })),
   ];
   return providers;

package/core/orm/databaseConnector.ts

@@ -1,4 +1,5 @@
-import { errorMessage, InfraError, reader, requireValue, postgresConnectionOptions, type InfraConnector, type PostgresConfigShape } from "../infra";
+import { errorMessage, InfraError, reader, requireValue, postgresConnectionOptions, settingNames, type InfraConnector, type PostgresConfigShape } from "../infra";
+import { postgresAddress, serverVersion } from "../infra/connectors/postgres";
 import type { AppConfig, ConfigRegistry } from "../kernel";
 import { postgres, type DatabaseProvider, type PostgresServerTimeouts } from "../../library/orm";
 import { DATABASE_PROVIDER } from "./DATABASE_PROVIDER";
@@ -88,6 +89,9 @@ export function ormBazisConnect(
 ): InfraConnector<DatabaseProvider> {
   // Where the connection goes, for the startup error; never the password.
   let target = "PostgreSQL";
+  let address: string | undefined;
+  let pool: number | undefined;
+  let settings: string[] = [];
   return {
     token: DATABASE_PROVIDER,
     config,
@@ -95,6 +99,9 @@ export function ormBazisConnect(
     create(configs) {
       const c = reader(config, configs);
       target = `PostgreSQL at ${String(c.get("host"))}:${String(c.get("port"))} (database "${String(c.get("database"))}", user "${String(c.get("username"))}")`;
+      address = postgresAddress({ hostname: String(c.get("host")), port: String(c.get("port")), database: String(c.get("database")), username: String(c.get("username")) });
+      pool = c.has("max") && typeof c.get("max") === "number" ? c.get("max") as number : undefined;
+      settings = settingNames(config, configs, ["host", "port", "database", "username", "password"]);
       return buildPostgresProvider(config, configs);
     },
     async connect(provider, signal) {
@@ -111,6 +118,15 @@ export function ormBazisConnect(
     async dispose(provider) {
       await provider.close();
     },
+    async describe(provider, { connected }) {
+      const version = connected ? await serverVersion((sql) => provider.query(sql, [])) : undefined;
+      return {
+        kind: version === undefined ? "PostgreSQL" : `PostgreSQL ${version}`,
+        ...(address === undefined ? {} : { address }),
+        details: [`pool ${pool ?? 10}`],
+        settings,
+      };
+    },
     healthCheck(provider, signal) {
       return provider.ping(signal);
     },

package/core/orm/index.ts

@@ -13,6 +13,7 @@ export { paginate, type PageResult } from "./listQuery";
 export { databaseErrorStatus } from "./databaseErrorStatus";
 
 import { registerModuleMetadataExpander, type BazisModuleRef } from "../di";
+import { registerModuleDescriber } from "../kernel/report/moduleTree";
 import { OrmOwnedStoreAdmissionError, type DbContext } from "../../library/orm";
 import { registerRepositoryEncapsulationHook } from "./encapsulationHook";
 import { ormModule, type OrmModuleConfig } from "./ormModule";
@@ -60,6 +61,16 @@ function declaredOwnedStore(config: OrmModuleConfig<DbContext>): unknown {
   return descriptor.value;
 }
 
+// The module tree of the startup screen: `Task, Comment · TaskDbContext`.
+registerModuleDescriber((metadata) => {
+  const orm = (metadata as { ormBazis?: OrmModuleConfig<DbContext> | readonly OrmModuleConfig<DbContext>[] }).ormBazis;
+  if (orm === undefined) return [];
+  return (Array.isArray(orm) ? orm : [orm]).map((config: OrmModuleConfig<DbContext>) => ({
+    kind: "table" as const,
+    text: `${(config.entities ?? []).map((entity) => (entity as { name?: string }).name ?? "entity").join(", ") || "no entities"} · ${(config.context as { name?: string } | undefined)?.name ?? "DbContext"}`,
+  }));
+});
+
 registerModuleMetadataExpander((metadata): readonly BazisModuleRef[] => {
   const orm = (metadata as { ormBazis?: OrmModuleConfig<DbContext> | readonly OrmModuleConfig<DbContext>[] }).ormBazis;
   if (orm === undefined) {

package/core/scripts/di-generate.ts

@@ -34,6 +34,29 @@ const isFrameworkSourcePath = (file: string): boolean => FRAMEWORK_SOURCE !== nu
 const APP_GENERATED_DIR = "src/generated/bazis";
 let activeGeneratedDir = APP_GENERATED_DIR;
 const plannedWrites = new Map<string, string>();
+/**
+ * `BAZIS_CODEGEN_REPORT=<file>`: the CLI renders the result itself. The
+ * generator then prints nothing and writes what it did, warned about and
+ * failed on as JSON to that file.
+ */
+const REPORT_FILE = process.env.BAZIS_CODEGEN_REPORT || undefined;
+interface CodegenTargetReport {
+  readonly name: string; readonly sources: number; readonly deps: number; readonly controllers: number;
+  readonly requestModels: number; readonly listModels: number; readonly tools: number; readonly ms: number;
+}
+const codegenReport = {
+  ok: false,
+  ms: 0,
+  targets: [] as CodegenTargetReport[],
+  outputs: [] as string[],
+  warnings: [] as string[],
+  errors: [] as string[],
+};
+const reportInfo = (message: string): void => { if (REPORT_FILE === undefined) console.log(message); };
+const reportWarning = (message: string): void => {
+  if (!codegenReport.warnings.includes(message)) codegenReport.warnings.push(message);
+  if (REPORT_FILE === undefined) console.warn(`[di:generate] WARNING: ${message}`);
+};
 const plannedRemovals = new Set<string>();
 
 // Test-only fault injection for the generator's private disk transaction. It
@@ -146,7 +169,7 @@ const FRAMEWORK_INTERNAL_PREFIXES = FRAMEWORK_SOURCE === null ? [] : [
   "core/di/", "core/kernel/", "core/http/", "core/grpc/", "core/http-client/", "core/background/",
   "core/agent/", "core/websocket/", "core/cache/", "library/validation/", "library/boundary/",
   "library/orm/", "library/jwt/", "library/jsonapi/", "library/openapi/", "core/orm/", "core/infra/",
-  "core/app/", "library/http-client/",
+  "core/app/", "library/http-client/", "library/terminal/",
 ].map((prefix) => `${FRAMEWORK_SOURCE}/${prefix}`);
 
 // A declaration is an identity; short names are local to their source/module.
@@ -299,7 +322,24 @@ function toPascalIdentifier(value: string): string {
     .join("");
 }
 
-await runConfiguredTargets();
+const codegenStartedAt = performance.now();
+try {
+  await runConfiguredTargets();
+  codegenReport.ok = true;
+} catch (error) {
+  // Errors are listed one per line; a stack says nothing to the application author.
+  if (codegenReport.errors.length === 0) {
+    const message = error instanceof Error ? error.message : String(error);
+    codegenReport.errors.push(...message.split("\n").filter((line) => line.trim().length > 0));
+  }
+  if (REPORT_FILE === undefined) {
+    for (const line of codegenReport.errors) console.error(`[di:generate] ERROR: ${line}`);
+  }
+  process.exitCode = 1;
+} finally {
+  codegenReport.ms = performance.now() - codegenStartedAt;
+  if (REPORT_FILE !== undefined) await Bun.write(REPORT_FILE, JSON.stringify(codegenReport));
+}
 
 async function runConfiguredTargets(): Promise<void> {
   const totalStartedAt = performance.now();
@@ -361,9 +401,15 @@ async function runConfiguredTargets(): Promise<void> {
   // slice and renderer state. Only a collision *inside* that slice is fatal.
   const candidateIndex = createSourceCandidateIndex(programFiles);
   const boundaryDiagnostics: string[] = [];
+  const unassigned: string[] = [];
   for (const [file] of programFiles) {
     if (isFrameworkSourcePath(file)) continue;
-    if (!owners.has(file) && candidateIndex.get(file)) boundaryDiagnostics.push(`BAZIS_CODEGEN_SOURCE_UNASSIGNED: ${file}`);
+    if (!owners.has(file) && candidateIndex.get(file)) unassigned.push(file);
+  }
+  // A module that is not imported yet (bazis g module --no-register) is not
+  // part of any application: skip it with a warning instead of failing.
+  for (const file of unassigned.sort((left, right) => left.localeCompare(right))) {
+    reportWarning(`BAZIS_CODEGEN_SOURCE_UNASSIGNED: ${file}: not imported from the entrypoint of any target; codegen skipped it.`);
   }
   for (const [name, reachable] of reachableByTarget) {
     for (const file of reachable) {
@@ -389,7 +435,8 @@ async function runConfiguredTargets(): Promise<void> {
   const writeStartedAt = performance.now();
   await commitPlannedWrites();
   const writeMs = performance.now() - writeStartedAt;
-  console.log(`[di:generate] programFactories=1 programSources=${programFiles.size} targets=${names.join(",")} configMs=${configMs.toFixed(1)} programMs=${programMs.toFixed(1)} discoveryMs=${discoveryMs.toFixed(1)} analysisMs=${analysisMs.toFixed(1)} targetMs=${targetMs.toFixed(1)} renderMs=${renderMs.toFixed(1)} writeMs=${writeMs.toFixed(1)} totalMs=${(performance.now() - totalStartedAt).toFixed(1)} eligible=${eligible} candidates=${candidates} outputs=${plannedWrites.size}`);
+  codegenReport.outputs.push(...[...plannedWrites.keys()].sort((left, right) => left.localeCompare(right)));
+  reportInfo(`[di:generate] programFactories=1 programSources=${programFiles.size} targets=${names.join(",")} configMs=${configMs.toFixed(1)} programMs=${programMs.toFixed(1)} discoveryMs=${discoveryMs.toFixed(1)} analysisMs=${analysisMs.toFixed(1)} targetMs=${targetMs.toFixed(1)} renderMs=${renderMs.toFixed(1)} writeMs=${writeMs.toFixed(1)} totalMs=${(performance.now() - totalStartedAt).toFixed(1)} eligible=${eligible} candidates=${candidates} outputs=${plannedWrites.size}`);
 }
 
 function createSourceCandidateIndex(files: ReadonlyMap<string, ts.SourceFile>): ReadonlyMap<string, boolean> {
@@ -500,8 +547,12 @@ async function generateTarget(name: string, reachable: Set<string>, production:
   if (!production) {
     stageWrite(`${generatedDir}/bootstrap.ts`, 'import { registerBazisGeneratedRuntime } from "./runtime";\n\nawait registerBazisGeneratedRuntime();\n');
   }
-  for (const warning of warnings) console.warn(`[di:generate] WARNING: ${warning}`);
-  console.log(`[di:generate] target=${name} sources=${sourceEntries.length} deps=${classDeps.size} controllers=${Object.keys(httpBindings).length} requestModels=${requestModelImports.length} listModels=${listModelImports.length} tools=${tools.toolCount} prepassMs=${prepassMs.toFixed(1)} analysisMs=${analysisMs.toFixed(1)} totalMs=${(performance.now() - startedAt).toFixed(1)}`);
+  for (const warning of warnings) reportWarning(warning);
+  codegenReport.targets.push({
+    name, sources: sourceEntries.length, deps: classDeps.size, controllers: Object.keys(httpBindings).length,
+    requestModels: requestModelImports.length, listModels: listModelImports.length, tools: tools.toolCount, ms: performance.now() - startedAt,
+  });
+  reportInfo(`[di:generate] target=${name} sources=${sourceEntries.length} deps=${classDeps.size} controllers=${Object.keys(httpBindings).length} requestModels=${requestModelImports.length} listModels=${listModelImports.length} tools=${tools.toolCount} prepassMs=${prepassMs.toFixed(1)} analysisMs=${analysisMs.toFixed(1)} totalMs=${(performance.now() - startedAt).toFixed(1)}`);
   return {
     analysisMs,
     renderMs: performance.now() - renderStartedAt,
@@ -525,9 +576,7 @@ function failOnFatalErrors(): void {
   if (fatalErrors.length === 0) {
     return;
   }
-  for (let index = 0; index < fatalErrors.length; index += 1) {
-    console.error(`[di:generate] ERROR: ${fatalErrors[index]}`);
-  }
+  codegenReport.errors.push(...fatalErrors);
   throw new Error(`di:generate failed with ${fatalErrors.length} fatal codegen error(s).`);
 }
 

package/library/terminal/index.ts

@@ -0,0 +1,4 @@
+export { detectTerminal, plain, widthOf, padEnd, padStart, colorAt, Paint, PALETTE, PLAIN, type TerminalStyle } from "./style";
+export { detectLanguage, parseLanguage, projectLanguage, resolveLanguage, systemLanguage, LANGUAGES, type Language, type LanguageSources } from "./language";
+export { count, messages, type Messages, type Noun } from "./messages";
+export { formatBytes, formatDuration, MODE, Screen, type CodeFrame, type Problem, type ScreenOutput, type Status, type TreeRow } from "./screen";

package/library/terminal/language.ts

@@ -0,0 +1,60 @@
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+
+/** Languages of the terminal output. */
+export type Language = "en" | "ru";
+
+export const LANGUAGES: readonly Language[] = Object.freeze(["en", "ru"]);
+
+/** `ru`, `ru-RU`, `ru_RU.UTF-8` → `ru`; anything unknown → undefined. */
+export function parseLanguage(value: string | undefined): Language | undefined {
+  const code = value?.trim().toLowerCase().split(/[-_.@]/)[0];
+  return LANGUAGES.find((language) => language === code);
+}
+
+export interface LanguageSources {
+  /** `--lang` of the command line. */
+  readonly flag?: string;
+  /** `BAZIS_LANG`. */
+  readonly env?: string;
+  /** `"language"` of `bazis.config.json`. */
+  readonly project?: string;
+  /** The system locale: `LC_ALL`, `LC_MESSAGES` or `LANG`. */
+  readonly system?: string;
+}
+
+/**
+ * The first language that is set and known, in order: the `--lang` flag,
+ * `BAZIS_LANG`, the project's `bazis.config.json`, the system locale. English
+ * otherwise. An unknown value is skipped, not an error: output language must
+ * never stop a command.
+ */
+export function resolveLanguage(sources: LanguageSources): Language {
+  return parseLanguage(sources.flag) ?? parseLanguage(sources.env) ?? parseLanguage(sources.project) ?? parseLanguage(sources.system) ?? "en";
+}
+
+/** `"language"` of the nearest `bazis.config.json` from `cwd` up. */
+export function projectLanguage(cwd = process.cwd()): string | undefined {
+  for (let dir = cwd; ; dir = dirname(dir)) {
+    const file = join(dir, "bazis.config.json");
+    if (existsSync(file)) {
+      try {
+        const value = (JSON.parse(readFileSync(file, "utf8")) as { language?: unknown }).language;
+        return typeof value === "string" ? value : undefined;
+      } catch {
+        return undefined;
+      }
+    }
+    if (dirname(dir) === dir) return undefined;
+  }
+}
+
+export function systemLanguage(env: NodeJS.ProcessEnv = process.env): string | undefined {
+  return env.LC_ALL || env.LC_MESSAGES || env.LANG || undefined;
+}
+
+/** The language of this process: `BAZIS_LANG`, then the project, then the system. */
+export function detectLanguage(options: { flag?: string; env?: NodeJS.ProcessEnv; cwd?: string } = {}): Language {
+  const env = options.env ?? process.env;
+  return resolveLanguage({ flag: options.flag, env: env.BAZIS_LANG, project: projectLanguage(options.cwd), system: systemLanguage(env) });
+}