bazis 0.128.0 → 0.130.0

package/core/access/testing/index.ts

@@ -0,0 +1,54 @@
+/**
+ * Test helpers of access (ACCESS-001 §8): a rights system whose grants are set
+ * right in the test.
+ */
+import { PRINCIPAL_STATE_KEY, type AuthorizeContext, type RequestPrincipal } from "../../http";
+import { AccessPolicy, type ScopePrincipals } from "../contracts/AccessPolicy";
+import type { AccessSubject, Grants, Scope } from "../contracts/types";
+
+export interface StaticAccessOptions {
+  /** Subject → permission → grants; a permission not listed gives nothing. */
+  readonly grants: Readonly<Record<string, Readonly<Record<string, Grants>>>>;
+  /** Subject → the owner ids meaning it; by default `sub` after the last `:`. */
+  readonly owners?: Readonly<Record<string, readonly string[]>>;
+  /** Subject → its addressees in every partition; by default `user:<owner id>`. */
+  readonly principals?: Readonly<Record<string, readonly string[]>>;
+}
+
+/**
+ * A rights system for tests: the subject is the principal's `subject` of the
+ * route check, grants come from the table.
+ *
+ * ```ts
+ * singletonValue(AccessPolicy, new StaticAccessPolicy({
+ *   grants: { "user:1": { "orders.read": [{ scopes: "all", where: { own: true } }] } },
+ * }))
+ * ```
+ */
+export class StaticAccessPolicy extends AccessPolicy {
+  constructor(private readonly options: StaticAccessOptions) {
+    super();
+  }
+
+  subject(ctx: AuthorizeContext): AccessSubject | undefined {
+    const sub = (ctx.state.get(PRINCIPAL_STATE_KEY) as RequestPrincipal | undefined)?.subject;
+    return sub === undefined || sub === "" ? undefined : { sub };
+  }
+
+  grants(subject: AccessSubject, permission: string): Grants {
+    return this.options.grants[subject.sub]?.[permission] ?? [];
+  }
+
+  ownerIds(subject: AccessSubject): readonly string[] {
+    return this.options.owners?.[subject.sub] ?? [ownerId(subject.sub)];
+  }
+
+  async principals(subject: AccessSubject, scopes: readonly Scope[]): Promise<readonly ScopePrincipals[]> {
+    const principals = this.options.principals?.[subject.sub] ?? [`user:${ownerId(subject.sub)}`];
+    return scopes.map((scope) => ({ scope, principals }));
+  }
+}
+
+function ownerId(sub: string): string {
+  return sub.slice(sub.lastIndexOf(":") + 1);
+}

package/core/background/BackgroundService.ts

@@ -37,7 +37,7 @@ const DEFAULT_STOP_TIMEOUT_MS = 5_000;
  *
  * ```ts
  * class Heartbeat extends BackgroundService {
- *   constructor(private readonly api: HttpClient) { super({ stopTimeoutMs: 2000 }); }
+ *   constructor(private readonly api: HttpClientBase) { super({ stopTimeoutMs: 2000 }); }
  *   protected async execute(signal: AbortSignal) {
  *     while (!signal.aborted) {
  *       await this.api.post("/heartbeat");

package/core/di/README.md

@@ -77,11 +77,11 @@ contracts are described in [MODULE.md](MODULE.md).
 
 ## Style Rule (DI usage)
 
-- By default use only the short shortcuts:
-  - `singleton(...)`
-  - `scoped(...)`
-  - `transient(...)`
-- Use the low-level path (`DI.classProvider(...)`, `DI.factoryProvider(...)`) only for rare cases that really need manual setup.
+- `providers` of a module use only the agreed forms: `scoped/singleton/transient(IService, Service)`
+  (or the class alone), `singletonValue(TOKEN, value)`, `singletonAsyncFactory(TOKEN, [deps], async factory)`
+  and `...withEventSubscribers(Class)`. Codegen refuses anything else (`BAZIS_DI_PROVIDER_FORM`).
+- The low-level path (`DI.classProvider(...)`, `DI.factoryProvider(...)`) stays for the kernel's own
+  plumbing and test `overrides`, never in a module's `providers`.
 
 ## Contributing Checklist
 

package/core/di/errors/ClassDependenciesMismatchError.ts

@@ -9,7 +9,7 @@ export class ClassDependenciesMismatchError extends DiError {
     declaredDeps: number,
   ) {
     super(
-      `Class provider "${tokenToDebugName(token)}" requires at least ${requiredConstructorParams} constructor deps, but only ${declaredDeps} declared. Constructor dependencies are wired by codegen: if the constructor was added or changed after the last run, run \`bazis codegen\` (bazis dev, bazis test and bazis build run it automatically); otherwise pass the deps explicitly.`,
+      `Class provider "${tokenToDebugName(token)}" requires at least ${requiredConstructorParams} constructor deps, but only ${declaredDeps} declared. Constructor dependencies are wired by codegen: if the constructor was added or changed after the last run, run \`bazis codegen\` (bazis dev, bazis test and bazis build run it automatically).`,
     );
   }
 }

package/core/di/internal/GraphValidator.ts

@@ -77,7 +77,7 @@ export class GraphValidator {
     const shape = this.context.classShape(registration.provider);
     if (shape && shape.required > shape.declared) {
       issues.add(
-        `Class provider "${tokenToDebugName(registration.token)}" requires at least ${shape.required} constructor deps, but only ${shape.declared} declared. Constructor dependencies are wired by codegen: if the constructor was added or changed after the last run, run \`bazis codegen\` (bazis dev, bazis test and bazis build run it automatically); otherwise pass the deps explicitly.`,
+        `Class provider "${tokenToDebugName(registration.token)}" requires at least ${shape.required} constructor deps, but only ${shape.declared} declared. Constructor dependencies are wired by codegen: if the constructor was added or changed after the last run, run \`bazis codegen\` (bazis dev, bazis test and bazis build run it automatically).`,
       );
     }
 

package/core/di/module/autoDeps.ts

@@ -14,10 +14,20 @@ export function registerGeneratedClassDeps(target: Class<unknown>, deps: readonl
   targetClassDeps.set(target, deps);
 }
 
+// The framework's own classes: their wiring ships inside the package
+// (`<pack>/generated/deps.ts`), because an application's codegen skips
+// node_modules. Not part of a target, so target rollbacks keep it.
+const frameworkClassDeps = new Map<Class<unknown>, readonly GeneratedClassDependency[]>();
+
+/** Called by the generated `deps.ts` of a framework pack when the pack is imported. */
+export function registerFrameworkClassDeps(entries: readonly (readonly [Class<unknown>, readonly GeneratedClassDependency[]])[]): void {
+  for (const [target, deps] of entries) frameworkClassDeps.set(target, deps);
+}
+
 export function getGeneratedClassDeps(useClass: Class<unknown>): ProviderDependencyList | undefined {
   // Names are not class identities: package consumers may use the same names
   // as the application that generated the framework's compatibility files.
-  const dependencies = targetClassDeps.get(useClass);
+  const dependencies = targetClassDeps.get(useClass) ?? frameworkClassDeps.get(useClass);
   if (dependencies === undefined) {
     return undefined;
   }

package/core/di/module/createContainer.ts

@@ -325,6 +325,6 @@ function assertProviderDefinition(value: unknown, moduleName: string, index: num
   throw new InvalidProviderError(
     name,
     `Module "${moduleName}": providers[${index}] is not a provider registration${provide === undefined ? "" : ` ({ provide: ${name} })`}. `
-      + `Register it with singleton(${name}), scoped(${name}), transient(${name}), singletonValue(TOKEN, value) or singletonFactory(TOKEN, [deps], factory).`,
+      + `Register it with singleton(${name}), scoped(${name}), transient(${name}), or singletonValue(TOKEN, value).`,
   );
 }

package/core/di/module/providerSelection.ts

@@ -116,7 +116,7 @@ function selectionMessage(
     // No colon after "token": the console redaction would read "token: the" as a secret.
     return `${head}, but ${subject} is registered in ${modules}, and the application uses one implementation per token,`
       + ` the last registered one, from "${owner.name}", which "${record.name}" cannot see.`
-      + ` Register ${subject} in one module, or give the implementations different keys (DI.keyedSingleton).`;
+      + ` Register ${subject} in one module, or give each implementation its own contract.`;
   }
   return `${head}, but the application uses the implementation from "${owner.name}", which "${record.name}" cannot see.`
     + ` Add "${owner.name}" to the imports of "${record.name}" and export ${subject} from it.`;

package/core/grpc/{GrpcClient.ts → GrpcClientBase.ts}

@@ -8,7 +8,7 @@ import { Metadata } from "./Metadata";
 import type { MethodDefinition, ServiceDefinition } from "./serviceDefinition";
 
 /** Standard gRPC/HTTP2 client using only built-in networking and Bazis codecs. */
-export class GrpcClient {
+export class GrpcClientBase {
   private readonly methods = new Map<string, MethodDefinition | null>();
   private readonly sessions = new Map<ClientHttp2Session, Set<GrpcClientCall<unknown>>>();
   private readonly calls = new Set<GrpcClientCall<unknown>>();

package/core/grpc/grpcClients.ts

@@ -0,0 +1,79 @@
+import { DI, registerModuleMetadataExpander, type BazisModuleMetadata, type BazisModuleRef, type ServiceResolver } from "../di";
+import type { ConfigDefinition } from "../kernel";
+import type { GrpcClientOptions } from "./clientContracts";
+import { GrpcClientBase } from "./GrpcClientBase";
+import { GrpcSetupError } from "./GrpcSetupError";
+import type { ServiceDefinition } from "./serviceDefinition";
+
+/** The settings of a client in the configuration: the address and, if declared, the timeout. */
+export interface GrpcClientConfig {
+  address: string;
+  timeoutMs?: number;
+}
+
+/** Fixed options of a client, and the configuration its address and timeout come from. */
+export interface GrpcClientDeclaration extends Partial<GrpcClientOptions> {
+  readonly config?: ConfigDefinition<GrpcClientConfig>;
+}
+
+type GrpcClientClass = new (service: ServiceDefinition, options: GrpcClientOptions) => GrpcClientBase;
+
+const declarations = new WeakMap<object, { readonly service: ServiceDefinition; readonly declaration: GrpcClientDeclaration }>();
+
+/**
+ * A client of another gRPC service, declared like a controller: the class
+ * extends `GrpcClientBase`, the module lists it in `grpcClients`, and services
+ * take it by type. The framework creates it with the address and timeout of
+ * `config` and closes it when the application stops.
+ *
+ * ```ts
+ * @GrpcClient(UsersRpc, { config: usersRpcConfig })
+ * export class UsersClient extends GrpcClientBase {}
+ *
+ * @Module({ grpcClients: [UsersClient], providers: [scoped(UsersApi)] })
+ * export class ReportsModule {}
+ * ```
+ */
+export function GrpcClient(service: ServiceDefinition, declaration: GrpcClientDeclaration = {}) {
+  return (target: GrpcClientClass, _context: ClassDecoratorContext): void => {
+    declarations.set(target, { service, declaration });
+  };
+}
+
+registerModuleMetadataExpander((metadata: BazisModuleMetadata): readonly BazisModuleRef[] => {
+  const clients = (metadata as BazisModuleMetadata & { readonly grpcClients?: unknown }).grpcClients;
+  if (clients === undefined) return [];
+  const owner = typeof metadata === "function" ? (metadata as { name: string }).name : "<module>";
+  if (!Array.isArray(clients)) throw new GrpcSetupError(`${owner}: grpcClients must list classes declared with @GrpcClient.`);
+  const configs = new Set<ConfigDefinition<GrpcClientConfig>>();
+  const providers = clients.map((client: unknown) => {
+    const found = typeof client === "function" ? declarations.get(client) : undefined;
+    if (found === undefined || !((client as GrpcClientClass).prototype instanceof GrpcClientBase)) {
+      throw new GrpcSetupError(`${owner}: ${typeof client === "function" ? client.name : String(client)} in grpcClients must extend GrpcClientBase and be declared with @GrpcClient(service, …).`);
+    }
+    if (found.declaration.config !== undefined) configs.add(found.declaration.config);
+    const Client = client as GrpcClientClass;
+    return DI.singleton(DI.factoryProviderWithResolver(Client, [], (resolver) => new Client(found.service, optionsOf(Client.name, found.declaration, resolver))));
+  });
+  return [{ config: [...configs], providers, exports: clients }];
+});
+
+function optionsOf(name: string, declaration: GrpcClientDeclaration, resolver: ServiceResolver): GrpcClientOptions {
+  const { config, ...fixed } = declaration;
+  const settings = config === undefined ? {} : {
+    address: resolver.resolve(config.token).get("address"),
+    ...(config.has("timeoutMs") ? { timeoutMs: resolver.resolve(config.token).get("timeoutMs") } : {}),
+  };
+  const options = { ...fixed, ...settings };
+  if (typeof options.address !== "string" || options.address === "") throw new GrpcSetupError(`${name}: the gRPC client needs an address: in @GrpcClient(…, { address }) or in its config.`);
+  return options as GrpcClientOptions;
+}
+
+// Augment the declaring file, not the "../di" re-export: re-export targets
+// depend on program file order and silently stop merging in some projects.
+declare module "../di/module/types/BazisModule" {
+  interface BazisModuleMetadata {
+    /** Clients of other gRPC services, declared with `@GrpcClient`: injected by their class. */
+    readonly grpcClients?: readonly (abstract new (...args: never[]) => GrpcClientBase)[];
+  }
+}

package/core/grpc/index.ts

@@ -3,8 +3,8 @@ export { GrpcError } from "./GrpcError";
 export { GrpcSetupError } from "./GrpcSetupError";
 export { grpcModule } from "./Grpc.module";
 export { GrpcServer } from "./GrpcServer";
-export { GrpcClient } from "./GrpcClient";
-export { grpcClientProvider } from "./grpcClientProvider";
+export { GrpcClientBase } from "./GrpcClientBase";
+export { GrpcClient, type GrpcClientConfig, type GrpcClientDeclaration } from "./grpcClients";
 export type { GrpcClientOptions, GrpcClientTlsOptions, GrpcCallOptions, GrpcResponse, GrpcResponseStream } from "./clientContracts";
 export { grpcService, loadGrpcPackage } from "./protobuf";
 export type { GrpcContext, GrpcModuleOptions } from "./contracts";

package/core/http/options.ts

@@ -54,7 +54,7 @@ export interface ApiVersioningOptions {
 export interface HttpModuleOptions {
   /**
    * Permit explicitly negotiated redirects for exact browser-side limits.
-   * The HttpClient must also enable inspectableRedirects. Default: false.
+   * The HttpClientBase must also enable inspectableRedirects. Default: false.
    * Authorized/CORS-allowed clients can then inspect each redirect Location.
    */
   readonly inspectableRedirects?: boolean;

package/core/http-client/httpClients.ts

@@ -0,0 +1,82 @@
+import { DI, registerModuleMetadataExpander, type BazisModuleMetadata, type BazisModuleRef, type ServiceResolver } from "../di";
+import { getOutboundCorrelationHeaders, type ConfigDefinition } from "../kernel";
+import { HttpClientBase, HttpClientError, type RequestConfig } from "../../library/http-client";
+
+/** The settings of a client in the configuration: the base URL and, if declared, the limits. */
+export interface HttpClientConfig {
+  baseUrl: string;
+  timeoutMs?: number;
+  maxResponseBytes?: number;
+}
+
+/** Fixed request defaults of a client, and the configuration its base URL and limits come from. */
+export interface HttpClientDeclaration extends RequestConfig {
+  readonly config?: ConfigDefinition<HttpClientConfig>;
+}
+
+type HttpClientClass = new (defaults: RequestConfig) => HttpClientBase;
+
+/** Server-side safety defaults of a declared client. */
+const DEFAULT_TIMEOUT_MS = 30_000;
+const DEFAULT_MAX_RESPONSE_BYTES = 16 * 1024 * 1024;
+
+const declarations = new WeakMap<object, HttpClientDeclaration>();
+
+/**
+ * A client of another HTTP service, declared like a controller: the class
+ * extends `HttpClientBase`, the module lists it in `httpClients`, and services
+ * take it by type. The framework creates it with the base URL and limits of
+ * `config`, a 30 s timeout and a 16 MiB response limit by default, and the
+ * kernel's correlation headers.
+ *
+ * ```ts
+ * @HttpClient({ config: weatherConfig })
+ * export class WeatherClient extends HttpClientBase {}
+ * ```
+ */
+export function HttpClient(declaration: HttpClientDeclaration = {}) {
+  return (target: HttpClientClass, _context: ClassDecoratorContext): void => {
+    declarations.set(target, declaration);
+  };
+}
+
+registerModuleMetadataExpander((metadata: BazisModuleMetadata): readonly BazisModuleRef[] => {
+  const clients = (metadata as BazisModuleMetadata & { readonly httpClients?: unknown }).httpClients;
+  if (clients === undefined) return [];
+  const owner = typeof metadata === "function" ? (metadata as { name: string }).name : "<module>";
+  if (!Array.isArray(clients)) throw new HttpClientError(`${owner}: httpClients must list classes declared with @HttpClient.`);
+  const configs = new Set<ConfigDefinition<HttpClientConfig>>();
+  const providers = clients.map((client: unknown) => {
+    const declaration = typeof client === "function" ? declarations.get(client) : undefined;
+    if (declaration === undefined || !((client as HttpClientClass).prototype instanceof HttpClientBase)) {
+      throw new HttpClientError(`${owner}: ${typeof client === "function" ? client.name : String(client)} in httpClients must extend HttpClientBase and be declared with @HttpClient(…).`);
+    }
+    if (declaration.config !== undefined) configs.add(declaration.config);
+    const Client = client as HttpClientClass;
+    return DI.singleton(DI.factoryProviderWithResolver(Client, [], (resolver) => new Client(defaultsOf(declaration, resolver))));
+  });
+  return [{ config: [...configs], providers, exports: clients }];
+});
+
+function defaultsOf(declaration: HttpClientDeclaration, resolver: ServiceResolver): RequestConfig {
+  const { config, ...fixed } = declaration;
+  const view = config === undefined ? undefined : resolver.resolve(config.token);
+  return {
+    timeoutMs: DEFAULT_TIMEOUT_MS,
+    maxResponseBytes: DEFAULT_MAX_RESPONSE_BYTES,
+    correlationHeaders: getOutboundCorrelationHeaders,
+    ...fixed,
+    ...(view === undefined ? {} : { baseUrl: view.get("baseUrl") }),
+    ...(view !== undefined && config!.has("timeoutMs") ? { timeoutMs: view.get("timeoutMs") } : {}),
+    ...(view !== undefined && config!.has("maxResponseBytes") ? { maxResponseBytes: view.get("maxResponseBytes") } : {}),
+  };
+}
+
+// Augment the declaring file, not the "../di" re-export: re-export targets
+// depend on program file order and silently stop merging in some projects.
+declare module "../di/module/types/BazisModule" {
+  interface BazisModuleMetadata {
+    /** Clients of other HTTP services, declared with `@HttpClient`: injected by their class. */
+    readonly httpClients?: readonly (abstract new (...args: never[]) => HttpClientBase)[];
+  }
+}

package/core/http-client/index.ts

@@ -2,102 +2,22 @@
  * Core DI/correlation integration for the pure `@/library/http-client`.
  *
  * The HTTP engine lives in the library (framework-agnostic). This module only
- * wires it into the runtime: a module factory that registers the clients for
- * injection by type, and kernel-based correlation propagation. All library
- * symbols are re-exported for convenience.
+ * wires it into the runtime: clients of other services are declared like
+ * controllers — a class with `@HttpClient`, listed in `httpClients` of a
+ * module — and get the kernel's correlation headers. All library symbols are
+ * re-exported for convenience.
  *
  * ```ts
- * import { HttpClient, httpClientModule } from "@/core/http-client";
+ * import { HttpClient, HttpClientBase } from "bazis/core/http-client";
  *
- * @Module({ imports: [httpClientModule({ default: { baseUrl: "https://api" } })], providers: [scoped(WeatherService)] })
+ * @HttpClient({ config: weatherConfig })
+ * export class WeatherClient extends HttpClientBase {}
+ *
+ * @Module({ httpClients: [WeatherClient], providers: [scoped(WeatherService)] })
  * class WeatherModule {}
  *
- * class WeatherService { constructor(private readonly http: HttpClient) {} }
+ * class WeatherService { constructor(private readonly weather: WeatherClient) {} }
  * ```
  */
-import { DI, Module, type BazisModule, type ProviderDefinition } from "../di";
-import { getOutboundCorrelationHeaders } from "../kernel";
-import {
-  HttpClient,
-  HttpClientFactory,
-  HttpClientFactoryBuilder,
-  type HeaderBag,
-  type RequestConfig,
-} from "../../library/http-client";
-
 export * from "../../library/http-client";
-
-export interface HttpClientModuleConfig {
-  /** Named clients: `HttpClientFactory.createClient(name)`. */
-  readonly clients?: Readonly<Record<string, RequestConfig>>;
-  /** Defaults for the injectable `HttpClient` and `createClient()`. */
-  readonly default?: RequestConfig;
-  /** Correlation header source. Default: the kernel async request context. */
-  readonly correlationHeaders?: () => HeaderBag;
-  /** Default per-request timeout in ms (server-side safety). Default: 30000. */
-  readonly timeoutMs?: number;
-  /** Default maximum response body size. Default: 16 MiB. `0` disables it. */
-  readonly maxResponseBytes?: number;
-}
-
-/**
- * Registers the outbound HTTP client in DI with correlation propagation wired
- * to the kernel request context. A service takes it by type:
- * - `HttpClient` — the default client;
- * - `HttpClientFactory` — named clients (fail-fast on unknown names).
- */
-export function httpClientModule(config: HttpClientModuleConfig = {}): BazisModule {
-  const correlationHeaders = config.correlationHeaders ?? getOutboundCorrelationHeaders;
-  const moduleTimeoutMs = resolveLimit(config.timeoutMs, 30_000, "httpClientModule timeoutMs");
-  const moduleMaxResponseBytes = resolveLimit(
-    config.maxResponseBytes,
-    16 * 1024 * 1024,
-    "httpClientModule maxResponseBytes",
-  );
-  const defaultConfig = config.default ?? {};
-  const defaults: RequestConfig = {
-    ...defaultConfig,
-    timeoutMs: resolveLimit(defaultConfig.timeoutMs, moduleTimeoutMs, "httpClientModule default.timeoutMs"),
-    maxResponseBytes: resolveLimit(
-      defaultConfig.maxResponseBytes,
-      moduleMaxResponseBytes,
-      "httpClientModule default.maxResponseBytes",
-    ),
-    correlationHeaders: defaultConfig.correlationHeaders ?? correlationHeaders,
-  };
-
-  const builder = new HttpClientFactoryBuilder();
-  builder.useDefault(defaults);
-  for (const [name, clientConfig] of Object.entries(config.clients ?? {})) {
-    builder.addClient(name, {
-      ...clientConfig,
-      timeoutMs: resolveLimit(clientConfig.timeoutMs, defaults.timeoutMs!, `httpClientModule clients.${name}.timeoutMs`),
-      maxResponseBytes: resolveLimit(
-        clientConfig.maxResponseBytes,
-        defaults.maxResponseBytes!,
-        `httpClientModule clients.${name}.maxResponseBytes`,
-      ),
-    });
-  }
-  const factory = builder.build();
-
-  const client = factory.createClient();
-  // One factory and one default client, injected by type.
-  const providers: ProviderDefinition[] = [
-    DI.singleton(DI.valueProvider(HttpClientFactory, factory)),
-    DI.singleton(DI.valueProvider(HttpClient, client)),
-  ];
-
-  @Module({ providers })
-  class HttpClientModule {}
-
-  return HttpClientModule;
-}
-
-function resolveLimit(value: number | undefined, fallback: number, field: string): number {
-  const resolved = value ?? fallback;
-  if (!Number.isSafeInteger(resolved) || resolved < 0) {
-    throw new TypeError(`${field} must be a non-negative safe integer`);
-  }
-  return resolved;
-}
+export { HttpClient, type HttpClientConfig, type HttpClientDeclaration } from "./httpClients";

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.128.0" }, capabilities: { experimentalApi: true },
+        clientInfo: { name: "bazis", title: "Bazis", version: "0.130.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/scripts/di-generate-target.ts

@@ -10,6 +10,11 @@ export interface CodegenConfig {
   readonly version: 1;
   readonly defaultTarget: string;
   readonly targets: Readonly<Record<string, TargetConfig>>;
+  /**
+   * The framework's own checkout only: packs whose DI wiring ships inside the
+   * package as `<pack>/generated/deps.ts`, imported by the pack's `index.ts`.
+   */
+  readonly framework?: { readonly packs: readonly string[] };
 }
 
 const TARGET_NAME = /^[a-z][a-z0-9-]*$/;
@@ -34,6 +39,10 @@ export async function readCodegenConfig(): Promise<CodegenConfig> {
     for (const candidate of [...target.entrypoints, ...(target.applicationParts ?? [])]) normalizeConfiguredPath(candidate);
   }
   if (!Object.hasOwn(value.targets, value.defaultTarget)) throw new Error("BAZIS_CODEGEN_CONFIG_INVALID: defaultTarget is undeclared");
+  if (value.framework !== undefined) {
+    if (!value.framework || !Array.isArray(value.framework.packs)) throw new Error("BAZIS_CODEGEN_CONFIG_INVALID: framework.packs must be a list of directories");
+    for (const pack of value.framework.packs) normalizeConfiguredPath(pack);
+  }
   return value as CodegenConfig;
 }