bazis 0.97.3 → 0.97.4

package/core/di/ServiceProvider.ts

@@ -112,6 +112,23 @@ export class ServiceProvider implements ServiceResolver {
     return this.resolveSingleAsync(token, key, this.lifetime.root, []);
   }
 
+  /**
+   * Creates every singleton registered with an async factory (keyed ones
+   * included), in registration order. Afterwards `resolve` and constructor
+   * injection return the cached instances. The kernel calls it at startup, so a
+   * failing factory stops the start instead of failing every request.
+   */
+  public async initializeAsyncSingletons(): Promise<void> {
+    this.lifetime.assertLive(this.lifetime.root);
+    for (const group of this.registry.groups()) {
+      for (const registration of group) {
+        if (registration.lifetime === "singleton" && isAsyncFactoryProvider(registration.provider)) {
+          await this.resolveRegistrationAsync(registration, registration.key, this.lifetime.root, [], undefined);
+        }
+      }
+    }
+  }
+
   public tryResolve<T>(token: Token<T>, key?: ServiceKey): T | undefined {
     return this.tryResolveForScope(token, key, this.lifetime.root);
   }

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.3" }, capabilities: { experimentalApi: true },
+        clientInfo: { name: "bazis", title: "Bazis", version: "0.97.4" }, 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

@@ -13,6 +13,7 @@ import type { UnhandledErrorPolicy } from "./types";
 import { redactSensitive } from "../../library/redaction";
 import { validateTimeout } from "./internal/validateTimeout";
 import { awaitShutdown } from "./internal/awaitShutdown";
+import { awaitAbortable } from "./internal/awaitAbortable";
 import { reportDiagnosticFailure } from "./internal/reportDiagnosticFailure";
 
 export interface KernelTimings {
@@ -97,6 +98,9 @@ export class Kernel {
       );
     }
     try {
+      // Async singletons first: hosted services and controllers take them
+      // through constructors, which resolve synchronously.
+      await awaitAbortable(this.container.initializeAsyncSingletons(), abortController.signal);
       await this.coordinator.start(abortController.signal, this.options.shutdownTimeoutMs);
       coordinatorStarted = true;
       this.startupMs = performance.now() - this.timings.buildStartedAt;

package/core/scripts/di-generate.ts

@@ -156,6 +156,8 @@ interface CollectedDependency { readonly name: string; readonly target?: ts.Clas
 interface ConstructorDependencies {
   readonly deps: CollectedDependency[];
   readonly unsupportedInheritedParameter?: string;
+  /** An own constructor parameter whose type cannot name a DI dependency (`string`, `number`, an inline type). */
+  readonly unsupportedParameter?: { readonly index: number; readonly name: string; readonly type: string };
 }
 let classDeps = new Map<ts.ClassDeclaration, readonly CollectedDependency[]>();
 let inferredDiClasses = new Set<ts.ClassDeclaration>();
@@ -796,6 +798,10 @@ function collectClassDeps(source: ts.SourceFile): void {
   const visit = (node: ts.Node): void => {
     if (ts.isClassDeclaration(node) && node.name) {
       const result = readConstructorTypeNames(node);
+      if (result.unsupportedParameter !== undefined && needsInferredDiDeps(node)) {
+        const { index, name, type } = result.unsupportedParameter;
+        fatalErrors.push(`BAZIS_DI_DEPENDENCY_UNKNOWN: ${sourceLocation(node)}: constructor parameter ${index + 1} "${name}" of "${node.name.text}" has type "${type}", which cannot be injected: DI resolves dependencies by class, contract or token, and a plain type does not say which value to inject. Declare a token with the same name as a type alias (export type Prefix = string; export const Prefix = createToken<Prefix>("Prefix")) and register a value, or pass the deps explicitly: scoped(${node.name.text}, ${node.name.text}, [TOKEN] as const).`);
+      }
       if (result.unsupportedInheritedParameter !== undefined && needsInferredDiDeps(node)) {
         fatalErrors.push(`BAZIS_DI_CONSTRUCTOR_UNRESOLVED: ${sourceLocation(node)}: cannot infer inherited constructor parameter "${result.unsupportedInheritedParameter}" for "${node.name.text}". The parameter needs a runtime DI token or an explicit value/factory binding.`);
       }
@@ -984,7 +990,7 @@ function readConstructorTypeNames(node: ts.ClassDeclaration): ConstructorDepende
     const paramType = param.type;
     const refName = paramType ? getDependencyTypeName(paramType) : undefined;
     if (!refName || BUILTIN_DEPENDENCY_NAMES.has(refName)) {
-      return { deps: [] };
+      return { deps: [], unsupportedParameter: { index, name: param.name.getText(), type: paramType?.getText() ?? "(no type)" } };
     }
 
     // `Lazy<X>` is a deferred dependency on X: encode it with a marker prefix

package/package.json

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