bazis 0.97.1 → 0.97.2

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.97.1" }, capabilities: { experimentalApi: true },
+        clientInfo: { name: "bazis", title: "Bazis", version: "0.97.2" }, 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/ApplicationLifetime.ts

@@ -14,6 +14,7 @@ export class ApplicationLifetime {
   private readonly stopRequestListeners: ((exitCode: number) => void)[] = [];
   private startedFlag = false;
   private stoppingFlag = false;
+  private stoppedFlag = false;
 
   public get isStarted(): boolean {
     return this.startedFlag;
@@ -23,15 +24,35 @@ export class ApplicationLifetime {
     return this.stoppingFlag;
   }
 
+  /**
+   * Runs `callback` once the application has started. A subscription made
+   * after that moment (for example in a service first created by a request)
+   * runs right away, like .NET's ApplicationStarted; a failure of such a late
+   * callback is an unhandled error (logged, graceful stop with exit code 1).
+   */
   public onStarted(callback: LifetimeCallback): void {
+    if (this.startedFlag) {
+      runLate(callback);
+      return;
+    }
     this.startedCallbacks.push(callback);
   }
 
+  /** Runs `callback` when graceful shutdown begins; right away if it already has. */
   public onStopping(callback: LifetimeCallback): void {
+    if (this.stoppingFlag) {
+      runLate(callback);
+      return;
+    }
     this.stoppingCallbacks.push(callback);
   }
 
+  /** Runs `callback` after the application has stopped; right away if it already has. */
   public onStopped(callback: LifetimeCallback): void {
+    if (this.stoppedFlag) {
+      runLate(callback);
+      return;
+    }
     this.stoppedCallbacks.push(callback);
   }
 
@@ -61,10 +82,17 @@ export class ApplicationLifetime {
 
   /** @internal */
   public async notifyStopped(): Promise<void> {
+    this.stoppedFlag = true;
     await runCallbacks(this.stoppedCallbacks);
   }
 }
 
+// A late subscription runs on its own: a rejection surfaces as an unhandled
+// error instead of disappearing silently.
+function runLate(callback: LifetimeCallback): void {
+  void Promise.resolve().then(callback);
+}
+
 // A failing subscriber must not break the rest of the lifecycle chain:
 // run everything, then report all failures at once.
 async function runCallbacks(callbacks: readonly LifetimeCallback[], signal?: AbortSignal): Promise<void> {

package/core/kernel/README.md

@@ -16,7 +16,7 @@ Contracts of the lifecycle and configuration fixes: [partial passport](MODULE.md
 ## Lifecycle
 
 - `LifecycleCoordinator.ts`: boot/shutdown order: options fail-fast → `onInit` → hosted services by phase → `onBootstrap`; shutdown in reverse order with `shutdownTimeout`; rollback when startup fails.
-- `ApplicationLifetime.ts`: injectable lifetime: `onStarted/onStopping/onStopped` + programmatic `stop(exitCode)`.
+- `ApplicationLifetime.ts`: injectable lifetime: `onStarted/onStopping/onStopped` (a subscription made after its moment runs right away) + programmatic `stop(exitCode)`.
 - `lifecycleHooks.ts`: the `LIFECYCLE_HOOK` token (enumerable) + `addLifecycleHook`.
 - `Environment.ts`: the environment (`development|production|test`) from `BAZIS_ENV`/`NODE_ENV`, the `debug` flag.
 - `SupervisedHostedService.ts`: retry with exponential backoff; passes the startup signal and stops retrying on cancellation.

package/core/kernel/config/defineConfig.ts

@@ -156,33 +156,35 @@ export function defineConfig(prefixOrSchema: string | ConfigSchema<Defaults>, ma
       const priority = Math.max(...candidates.map(candidate => candidate.priority));
       const winners = candidates.filter(candidate => candidate.priority === priority);
       const selected = winners[0];
-      if (winners.some(candidate => candidate.raw !== selected?.raw)) issues.push(`${fullKey(key)}: conflicting environment aliases`);
+      if (winners.some(candidate => candidate.raw !== selected?.raw)) issues.push(`${fullKey(key)} — conflicting environment aliases`);
       const raw = selected?.raw ?? (isSecret(cell) || isEnum(cell) ? cell.default : cell);
       let value: ConfigValueType | undefined;
       if (type === "secret") {
-        if (typeof raw !== "string" || !raw.trim()) issues.push(`${fullKey(key)}: required non-empty secret is not set (${names.get(key)!.join(", ")})`);
+        if (typeof raw !== "string" || !raw.trim()) issues.push(`${fullKey(key)} — required non-empty secret is not set (${names.get(key)!.join(", ")})`);
         else value = new Secret(raw);
       } else if (type === "number") {
         const parsed = Number(raw);
-        if (raw === undefined || (typeof raw === "string" && !raw.trim()) || !Number.isFinite(parsed)) issues.push(`${fullKey(key)}: expected a finite number`);
+        if (raw === undefined || (typeof raw === "string" && !raw.trim()) || !Number.isFinite(parsed)) issues.push(`${fullKey(key)} — expected a finite number`);
         else value = parsed;
       } else if (type === "boolean") {
         const normalized = String(raw).toLowerCase();
         if (normalized === "true" || normalized === "1") value = true;
         else if (normalized === "false" || normalized === "0") value = false;
-        else issues.push(`${fullKey(key)}: expected a boolean`);
+        else issues.push(`${fullKey(key)} — expected a boolean`);
       } else if (typeof raw === "string") value = raw;
-      else issues.push(`${fullKey(key)}: expected a string`);
+      else issues.push(`${fullKey(key)} — expected a string`);
       if (value === undefined) continue;
-      if (isEnum(base) && !base.values.includes(value as string | number)) issues.push(`${fullKey(key)}: value is not one of the declared enum values`);
+      if (isEnum(base) && !base.values.includes(value as string | number)) issues.push(`${fullKey(key)} — value is not one of the declared enum values`);
       try {
         const issue = validators[key]?.(value);
-        if (issue) issues.push(`${fullKey(key)}: ${issue}`);
-      } catch { issues.push(`${fullKey(key)}: validator failed`); }
+        if (issue) issues.push(`${fullKey(key)} — ${issue}`);
+      } catch { issues.push(`${fullKey(key)} — validator failed`); }
       values.set(key, value);
       inspection.push(Object.freeze({ key: fullKey(key), type: type as ConfigInspection["type"], env: names.get(key)!, source: selected?.source ?? (override === undefined ? "default" : environment), value: safeValue(fullKey(key), value) }));
     }
     if (issues.length) {
+      // "key — text", not "key: text": the console redaction would read
+      // "db.password: required" as a secret value and hide the word "required".
       let message = issues.join("; ");
       for (const [key, value] of values) {
         const sensitive = value instanceof Secret ? value.reveal() : typeof value === "string" && isSensitiveKey(key) ? value : undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bazis",
-  "version": "0.97.1",
+  "version": "0.97.2",
   "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",