bazis 0.105.3 → 0.107.0

package/cli/build.ts

@@ -14,9 +14,13 @@ export interface BuildOptions {
   readonly outfile?: string;
   /** Let the executable read `.env` files from its working directory (off by default). */
   readonly dotenv?: boolean;
+  /** Another platform, `linux-x64`: `bun build --target=bun-linux-x64`. */
+  readonly platform?: string;
 }
 
 export interface CompileOptions {
+  /** Cross-compile for `bun-<platform>`; Bun downloads that runtime once. */
+  readonly platform?: string;
   /** Let the executable read `.env`, `.env.local`, `.env.<NODE_ENV>` from its working directory. */
   readonly dotenv?: boolean;
 }
@@ -149,10 +153,11 @@ export async function runBuild(cwd: string, options: BuildOptions, codegen: Code
   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;
+  const outfile = options.bin ? path.resolve(cwd, options.outfile ?? path.join("bin", await defaultBinaryName(cwd, options.platform))) : 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)))]),
+    ...(options.platform === undefined ? [] : [s.kv(t.meta.platform, s.text(options.platform))]),
   ]);
   s.section(t.section.build);
   const generated = await codegen(cwd, "all", { ui });
@@ -182,7 +187,7 @@ export async function runBuild(cwd: string, options: BuildOptions, codegen: Code
   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 });
+  const compiled = await compileBinaryAsync(bun, await projectEntry(cwd), outfile, { dotenv: options.dotenv, platform: options.platform });
   stopCompile();
   const compileMs = formatDuration(performance.now() - compileStarted);
   const relative = path.relative(cwd, outfile);
@@ -263,9 +268,10 @@ export async function compileBinaryAsync(bun: string, entry: string, outfile: st
   }
 }
 
-function compileArgs(bun: string, entry: string, outfile: string, options: CompileOptions): string[] {
+export 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)];
+  const target = options.platform === undefined ? [] : [`--target=bun-${options.platform}`];
+  return [bun, "build", "--compile", ...target, ...autoload, path.resolve(entry), "--outfile", path.resolve(outfile)];
 }
 
 function removeWorkDir(workDir: string): void {
@@ -287,6 +293,12 @@ async function projectEntry(cwd: string): Promise<string> {
   return path.resolve(cwd, entry);
 }
 
+/** `bin/<name>`, or `bin/<name>-<platform>` for another platform, so the local build is kept. */
+async function defaultBinaryName(cwd: string, platform: string | undefined): Promise<string> {
+  const name = await binaryName(cwd);
+  return platform === undefined ? name : `${name}-${platform}`;
+}
+
 async function binaryName(cwd: string): Promise<string> {
   const manifest = Bun.file(path.join(cwd, "package.json"));
   const name = await manifest.exists() ? (await manifest.json() as { name?: unknown }).name : undefined;

package/cli/main.ts

@@ -20,6 +20,8 @@ export const USAGE = `Usage:
   bazis build                                 Codegen and typecheck
   bazis build --bin [--outfile <path>]        Also compile a standalone executable (default bin/<name>)
   bazis build --bin --dotenv                  The executable also reads .env files from its working directory
+  bazis build --bin --platform <os-arch>      For another platform, e.g. linux-x64, linux-arm64-musl
+                                             (default output bin/<name>-<os-arch>)
   bazis --help
   bazis --version                             Print the bazis version (also -v)
   g can also be written as generate.
@@ -130,7 +132,7 @@ export async function runCli(argv: readonly string[], runtime: CliRuntime = defa
     if (parsed.kind === "codegen") return await runCodegenCommand(cwd, parsed.target, codegen, ui);
     if (parsed.kind === "dev") return await runDev(cwd, codegen, ui, { watch: parsed.watch });
     if (parsed.kind === "test") return await runTest(cwd, parsed.args, codegen, ui);
-    if (parsed.kind === "build") return await runBuild(cwd, { bin: parsed.bin, outfile: parsed.outfile, dotenv: parsed.dotenv }, codegen, ui);
+    if (parsed.kind === "build") return await runBuild(cwd, { bin: parsed.bin, outfile: parsed.outfile, dotenv: parsed.dotenv, platform: parsed.platform }, codegen, ui);
     if (parsed.kind === "new") return await runNew(parsed, ui);
     // Module registration parses the host module with the TypeScript API: load it
     // only after switching TypeScript 7 to @typescript/typescript6.

package/cli/parseCli.ts

@@ -26,14 +26,16 @@ export type ParseCliResult =
   | { readonly kind: "codegen"; readonly target?: string }
   | { readonly kind: "dev"; readonly watch: boolean }
   | { readonly kind: "test"; readonly args: readonly string[] }
-  | { readonly kind: "build"; readonly bin: boolean; readonly outfile?: string; readonly dotenv: boolean }
+  | { readonly kind: "build"; readonly bin: boolean; readonly outfile?: string; readonly dotenv: boolean; readonly platform?: string }
   | { readonly kind: "error"; readonly message: string };
 
 const GENERATOR_ALIASES = new Map<string, "module" | "pack">([
   ["module", "module"], ["m", "module"],
   ["pack", "pack"], ["p", "pack"], ["module-pack", "pack"],
 ]);
-const VALUE_OPTIONS = new Set(["--modules-root", "--app-module", "--pack", "--parts", "--target", "--path", "--framework", "--outfile"]);
+const VALUE_OPTIONS = new Set(["--modules-root", "--app-module", "--pack", "--parts", "--target", "--path", "--framework", "--outfile", "--platform"]);
+/** Platforms of `bun build --compile --target=bun-<platform>`. */
+export const BINARY_PLATFORM = /^(linux|darwin|windows)-(x64|arm64)(-musl)?(-baseline|-modern)?$/;
 const FLAG_OPTIONS = new Set(["--no-register", "--force", "--full", "--enterprise", "--minimal", "--empty", "--dry-run", "--no-codegen", "--link-framework", "--vendor", "--bin", "--watch", "--dotenv"]);
 
 /** Parsing is pure: help and invalid input can never start generation. */
@@ -91,15 +93,20 @@ export function parseCliArgs(argv: readonly string[]): ParseCliResult {
   }
   if (options.has("--watch")) return error("--watch is only supported by dev.");
   if (command === "build") {
-    if (positional.length !== 1) return error("Use: bazis build [--bin [--outfile <path>] [--dotenv]]");
+    if (positional.length !== 1) return error("Use: bazis build [--bin [--outfile <path>] [--platform <os-arch>] [--dotenv]]");
     for (const option of options.keys()) {
-      if (option !== "--bin" && option !== "--outfile" && option !== "--dotenv") return error(`Option ${option} is not supported by build.`);
+      if (option !== "--bin" && option !== "--outfile" && option !== "--dotenv" && option !== "--platform") return error(`Option ${option} is not supported by build.`);
     }
     if (options.has("--outfile") && !options.has("--bin")) return error("--outfile requires --bin.");
     if (options.has("--dotenv") && !options.has("--bin")) return error("--dotenv requires --bin.");
-    return { kind: "build", bin: options.has("--bin"), outfile: options.get("--outfile"), dotenv: options.has("--dotenv") };
+    if (options.has("--platform") && !options.has("--bin")) return error("--platform requires --bin.");
+    const platform = options.get("--platform");
+    if (platform !== undefined && !BINARY_PLATFORM.test(platform)) {
+      return error(`Unknown platform: ${platform}. Use <os>-<arch>[-musl]: linux-x64, linux-arm64, linux-x64-musl, linux-arm64-musl, darwin-arm64, darwin-x64, windows-x64.`);
+    }
+    return { kind: "build", bin: options.has("--bin"), outfile: options.get("--outfile"), dotenv: options.has("--dotenv"), ...(platform === undefined ? {} : { platform }) };
   }
-  if (options.has("--bin") || options.has("--outfile") || options.has("--dotenv")) return error("--bin, --outfile and --dotenv are only supported by build.");
+  if (options.has("--bin") || options.has("--outfile") || options.has("--dotenv") || options.has("--platform")) return error("--bin, --outfile, --platform and --dotenv are only supported by build.");
   if (command === "codegen") {
     if (positional.length !== 1) return error("Use: bazis codegen [--target <name|all>]");
     for (const option of options.keys()) {

package/core/di/ServiceProvider.ts

@@ -1,6 +1,7 @@
 import {
   AsyncResolutionRequiredError,
   ClassDependenciesMismatchError,
+  DiError,
   InvalidProviderError,
   NamedDependencyNotFoundError,
   ProviderNotFoundError,
@@ -44,7 +45,27 @@ import {
 import type { Token } from "./token";
 import { tokenToDebugName } from "./token";
 
+/**
+ * `ServiceProvider` as a service in a scope sees that scope, as .NET's
+ * IServiceProvider does: `resolve` returns the scope's services and
+ * `createScope()` opens a new one. The scope is disposed by whoever created it.
+ */
+class ScopeServiceProvider extends ServiceScope {
+  public constructor(provider: ConstructorParameters<typeof ServiceScope>[0], state: ResolutionScopeState, private readonly root: ServiceProvider) {
+    super(provider, state);
+  }
+
+  public createScope(): ServiceScope {
+    return this.root.createScope();
+  }
+
+  public override dispose(): Promise<void> {
+    return Promise.reject(new DiError("This ServiceProvider is the scope that resolved the service; whoever created the scope disposes it. To own a scope, call createScope() and dispose that one."));
+  }
+}
+
 export class ServiceProvider implements ServiceResolver {
+  private readonly scopeProviders = new WeakMap<ResolutionScopeState, ScopeServiceProvider>();
   private readonly registry: ServiceRegistry;
   private readonly activations = new ResolutionTracker();
   private readonly lifetime: ScopeLifecycle;
@@ -185,6 +206,17 @@ export class ServiceProvider implements ServiceResolver {
     return this.lifetime.disposeScope(scopeState);
   }
 
+  /** `ServiceProvider` asked for inside a scope: the scope itself, not the root. */
+  private providerForScope<T>(token: Token<T>, key: ServiceKey | undefined, scopeState: ResolutionScopeState): T | undefined {
+    if (token !== (ServiceProvider as unknown) || key !== undefined || scopeState.isRoot) return undefined;
+    let view = this.scopeProviders.get(scopeState);
+    if (view === undefined) {
+      view = new ScopeServiceProvider(this, scopeState, this);
+      this.scopeProviders.set(scopeState, view);
+    }
+    return view as unknown as T;
+  }
+
   private resolveSingle<T>(
     token: Token<T>,
     key: ServiceKey | undefined,
@@ -192,6 +224,8 @@ export class ServiceProvider implements ServiceResolver {
     stack: ResolutionActivation[],
     ownerLifetime: ProviderLifetime | undefined,
   ): T {
+    const scopeProvider = this.providerForScope(token, key, scopeState);
+    if (scopeProvider !== undefined) return scopeProvider;
     const registration = this.registry.find(token, key);
     if (!registration) {
       throw new ProviderNotFoundError(token, this.describeResolutionPath(stack, token));
@@ -278,6 +312,8 @@ export class ServiceProvider implements ServiceResolver {
     stack: ResolutionActivation[],
     ownerLifetime?: ProviderLifetime,
   ): Promise<T> {
+    const scopeProvider = this.providerForScope(token, key, scopeState);
+    if (scopeProvider !== undefined) return scopeProvider;
     const registration = this.registry.find(token, key);
     if (!registration) {
       throw new ProviderNotFoundError(token, this.describeResolutionPath(stack, token));
@@ -733,6 +769,8 @@ export class ServiceProvider implements ServiceResolver {
     ownerLifetime: ProviderLifetime | undefined,
   ): T | undefined {
     this.lifetime.assertLive(scopeState);
+    const scopeProvider = this.providerForScope(token, key, scopeState);
+    if (scopeProvider !== undefined) return scopeProvider;
     const registration = this.registry.find(token, key);
     if (!registration) {
       return undefined;

package/core/infra/connectors/codex/CodexAppServerClient.ts

@@ -232,7 +232,7 @@ export class CodexAppServerClient implements CodexClient {
         if (method === "account/updated") this.modelCache = undefined;
       }, () => { this.clearLogin(); this.modelCache = undefined; });
       const initialized = await client.request("initialize", {
-        clientInfo: { name: "bazis", title: "Bazis", version: "0.105.3" }, capabilities: { experimentalApi: true },
+        clientInfo: { name: "bazis", title: "Bazis", version: "0.107.0" }, capabilities: { experimentalApi: true },
       }, 15_000, signal);
       if (resolve(text(initialized.codexHome, 4096)) !== this.paths.home) throw new CodexError("PROTOCOL_ERROR");
       client.notify("initialized");

package/core/kernel/Kernel.ts

@@ -261,18 +261,32 @@ export class Kernel {
       if (this.startupCleanupFailure !== undefined) return Promise.reject(this.startupCleanupFailure);
       return Promise.resolve();
     }
+    // Only an application that started announces its stop.
+    const wasStarted = this.state === "started";
     this.state = "stopping";
-    this.shutdownPromise = this.stopCore(request);
+    this.shutdownPromise = this.stopCore(request, wasStarted);
     return this.shutdownPromise;
   }
 
-  private async stopCore(request: StopRequest): Promise<void> {
+  private async stopCore(request: StopRequest, wasStarted: boolean): Promise<void> {
     // The whole graceful-stop sequence — lifetime notifications, the STOPPING
     // event, hosted services/hooks and disposal — is bounded by one budget. A
     // single hanging callback or handler must not wedge shutdown forever.
+    const announce = wasStarted && this.options.startupReport && this.options.schemaOnly !== true;
+    const logger = announce ? this.container.tryResolve(LOGGER) : undefined;
+    const startedAt = performance.now();
     const work = this.runShutdownSequence(request);
     try {
       await awaitShutdown(work, this.options.shutdownTimeoutMs);
+      if (announce) {
+        const fields = {
+          ...(request.signal === undefined ? {} : { signal: request.signal }),
+          exitCode: request.exitCode,
+          shutdownMs: Number((performance.now() - startedAt).toFixed(1)),
+        };
+        if (logger) logger.info("bazis stopped", fields);
+        else console.log(`[bazis] stopped ${JSON.stringify(fields)}`);
+      }
     } finally {
       this.state = "stopped";
     }
@@ -441,6 +455,12 @@ export class Kernel {
     console.error("[bazis] Unhandled error, shutting down:", redacted);
   }
 
+  /** Where the servers listen: `{ listening: ["http://localhost:3000"] }`. */
+  private listening(): { listening?: readonly string[] } {
+    const urls = (this.container.tryResolve(StartupReport)?.listeners ?? []).map((listener) => listener.url);
+    return urls.length > 0 ? { listening: urls } : {};
+  }
+
   private printStartupReport(): void {
     if (this.options.onStarted !== undefined) {
       try {
@@ -460,6 +480,7 @@ export class Kernel {
       hostedServices: this.coordinator.startedHostedCount,
       hooks: this.coordinator.hookCount,
       startupMs: Number(this.startupMs.toFixed(1)),
+      ...this.listening(),
     };
     if (logger) {
       logger.info("bazis started", fields);

package/core/kernel/KernelBuilder.ts

@@ -166,9 +166,11 @@ export class KernelBuilder {
     const userRoot = resolveUserRoot(this.rootModule, environment);
     const configs = collectModuleConfigs([userRoot]);
     const configRegistry = new ConfigRegistry(configs, environment.name, configuration);
-    const startupReport = this.startupReport ?? !environment.isProduction;
-    // The screen replaces the report line, so it follows the same switch.
-    const screen = this.startupScreen !== undefined && startupReport;
+    // The `bazis started` / `bazis stopped` lines are printed in every
+    // environment: in production they are the only sign that the process is up.
+    const startupReport = this.startupReport ?? true;
+    // The screen replaces the started line outside production.
+    const screen = this.startupScreen !== undefined && (this.startupReport ?? !environment.isProduction);
     const report = new StartupReport(screen);
     report.configuration(configRegistry.inspect());
     this.builtReport = report;

package/library/terminal/messages.ts

@@ -98,7 +98,7 @@ const en = {
     codegen: "codegen", typecheck: "typecheck", config: "config", connections: "connections", schema: "schema",
     modules: "modules", services: "services", tests: "bun test", compile: "compile", files: "files", register: "register",
   },
-  meta: { env: "env", watch: "watch", on: "on", off: "off", src: "src", pid: "pid", target: "target", out: "output", path: "path" },
+  meta: { env: "env", watch: "watch", on: "on", off: "off", src: "src", pid: "pid", target: "target", out: "output", path: "path", platform: "platform" },
   common: {
     of: "of", in: "in", and: "and", none: "none", ok: "ok", empty: "empty", plus: "plus", memory: "memory",
     declaredIn: "declared in", code: "code", where: "where", try: "try", logs: "logs", inProcess: "in process",
@@ -260,7 +260,7 @@ const ru: Messages = {
     codegen: "кодогенерация", typecheck: "типы", config: "конфигурация", connections: "подключения", schema: "схема",
     modules: "модули", services: "сервисы", tests: "bun test", compile: "компиляция", files: "файлы", register: "подключение",
   },
-  meta: { env: "среда", watch: "слежение", on: "вкл", off: "выкл", src: "вход", pid: "pid", target: "цель", out: "файл", path: "путь" },
+  meta: { env: "среда", watch: "слежение", on: "вкл", off: "выкл", src: "вход", pid: "pid", target: "цель", out: "файл", path: "путь", platform: "платформа" },
   common: {
     of: "из", in: "в", and: "и", none: "нет", ok: "в порядке", empty: "пусто", plus: "ещё", memory: "память",
     declaredIn: "объявлено в", code: "код", where: "где", try: "попробуйте", logs: "журнал", inProcess: "в процессе",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bazis",
-  "version": "0.105.3",
+  "version": "0.107.0",
   "description": "Modular backend framework for Bun in TypeScript: DI wired by codegen, HTTP, a PostgreSQL ORM, JWT, WebSocket, agents and a CLI.",
   "license": "MIT",
   "author": "Alexander Alenin",