bazis 0.96.1

package/core/di/internal/ResolutionPlan.ts

@@ -0,0 +1,18 @@
+import type { Token } from "../token";
+import type { ServiceKey } from "../types";
+
+/**
+ * A single constructor/factory dependency, normalized once per provider so the
+ * hot resolve path skips re-deriving the descriptor (named-token lookup, keyed
+ * unwrapping) and the per-dependency object allocation on every resolution.
+ *
+ * `undefined` entries mean "leave this positional argument unset" (a ctor param
+ * with a default value that should not be injected).
+ */
+export interface PlannedDependency {
+  readonly token: Token<unknown>;
+  readonly key: ServiceKey | undefined;
+  readonly lazy: boolean;
+}
+
+export type ResolutionPlan = readonly (PlannedDependency | undefined)[];

package/core/di/internal/ResolutionScopeState.ts

@@ -0,0 +1,19 @@
+export class ResolutionScopeState {
+  public readonly cache = new Map<number, unknown>();
+  // In-flight async creations: dedupes concurrent resolveAsync of the same registration.
+  public readonly pendingAsync = new Map<number, Promise<unknown>>();
+  // Active async activation wait edges, keyed by registration identity. They
+  // are scope-local because scoped registrations may be active independently
+  // in different scopes.
+  public readonly pendingWaits = new Map<number, Set<number>>();
+  public readonly pendingAsyncActivationIds = new Map<number, number>();
+  /** Active executions by concrete activation identity. */
+  public readonly activeActivationIds = new Set<number>();
+  // Every async resolution (including transients), so disposal cannot race a late-created resource.
+  public readonly pendingCreations = new Set<Promise<unknown>>();
+  public readonly disposables: unknown[] = [];
+  public disposed = false;
+  public disposalPromise?: Promise<void>;
+
+  public constructor(public readonly isRoot: boolean) {}
+}

package/core/di/internal/ResolutionTracker.ts

@@ -0,0 +1,153 @@
+import { CircularDependencyError } from "../errors";
+import type { ResolutionScopeState } from "./ResolutionScopeState";
+import { ServiceRegistration } from "./ServiceRegistration";
+
+export interface ResolutionActivation {
+  readonly id: number;
+  readonly registration: ServiceRegistration;
+  readonly scope: ResolutionScopeState;
+}
+
+/** Tracks active construction chains and scope-local async wait edges. */
+export class ResolutionTracker {
+  private nextActivationId = 0;
+  private readonly activeActivations = new Map<number, ResolutionActivation>();
+
+  public assertNoCycle(
+    registration: ServiceRegistration,
+    scope: ResolutionScopeState,
+    stack: readonly ResolutionActivation[],
+  ): void {
+    if (stack.some((entry) => entry.registration.id === registration.id && entry.scope === scope)) {
+      throw this.createCircularDependencyError([...stack, this.create(registration, scope)]);
+    }
+  }
+
+  public create(registration: ServiceRegistration, scope: ResolutionScopeState): ResolutionActivation {
+    return { id: this.nextActivationId++, registration, scope };
+  }
+
+  public enter(scopeState: ResolutionScopeState, activation: ResolutionActivation): void {
+    scopeState.activeActivationIds.add(activation.id);
+    this.activeActivations.set(activation.id, activation);
+  }
+
+  public leave(scopeState: ResolutionScopeState, activation: ResolutionActivation): void {
+    scopeState.activeActivationIds.delete(activation.id);
+    this.activeActivations.delete(activation.id);
+  }
+
+  public capture(resolutionStack: readonly ResolutionActivation[]): () => ResolutionActivation[] {
+    const captured = [...resolutionStack];
+    const owner = captured[captured.length - 1];
+    return () => {
+      // Retained resolvers and Lazy wrappers belong to their own activation.
+      // After it settles they must not inherit a still-running ancestor.
+      if (!owner || !owner.scope.activeActivationIds.has(owner.id)) {
+        return [];
+      }
+      return captured.filter((entry) => entry.scope.activeActivationIds.has(entry.id));
+    };
+  }
+
+  public join<T>(
+    registration: ServiceRegistration<T>,
+    scopeState: ResolutionScopeState,
+    stack: readonly ResolutionActivation[],
+    pending: Promise<unknown>,
+  ): Promise<T> {
+    const owner = stack[stack.length - 1];
+    if (!owner) {
+      return pending as Promise<T>;
+    }
+
+    const activationId = scopeState.pendingAsyncActivationIds.get(registration.id);
+    if (activationId === undefined) {
+      return pending as Promise<T>;
+    }
+    const dependency = this.getActivationById(activationId);
+    this.addWait(scopeState, owner, dependency);
+    return (async () => {
+      try {
+        return await pending as T;
+      } finally {
+        this.removeWait(scopeState, owner, dependency);
+      }
+    })();
+  }
+
+  public addWait(
+    scopeState: ResolutionScopeState,
+    owner: ResolutionActivation,
+    dependency: ResolutionActivation,
+  ): void {
+    let dependencies = scopeState.pendingWaits.get(owner.id);
+    if (dependencies?.has(dependency.id)) {
+      return;
+    }
+
+    const path = this.findPendingWaitPath(scopeState, dependency.id, owner.id, new Set<number>());
+    if (path) {
+      const registrations = [owner, ...path.map((id) => this.getActivationById(id)), dependency];
+      throw this.createCircularDependencyError(registrations);
+    }
+    if (!dependencies) {
+      dependencies = new Set<number>();
+      scopeState.pendingWaits.set(owner.id, dependencies);
+    }
+    dependencies.add(dependency.id);
+  }
+
+  public removeWait(
+    scopeState: ResolutionScopeState,
+    owner: ResolutionActivation,
+    dependency: ResolutionActivation,
+  ): void {
+    const dependencies = scopeState.pendingWaits.get(owner.id);
+    if (!dependencies) {
+      return;
+    }
+    dependencies.delete(dependency.id);
+    if (dependencies.size === 0) {
+      scopeState.pendingWaits.delete(owner.id);
+    }
+  }
+
+  private findPendingWaitPath(
+    scopeState: ResolutionScopeState,
+    from: number,
+    target: number,
+    visited: Set<number>,
+  ): number[] | undefined {
+    if (from === target) {
+      return [from];
+    }
+    if (visited.has(from)) {
+      return undefined;
+    }
+    visited.add(from);
+    const dependencies = scopeState.pendingWaits.get(from);
+    if (!dependencies) {
+      return undefined;
+    }
+    for (const dependency of dependencies) {
+      const path = this.findPendingWaitPath(scopeState, dependency, target, visited);
+      if (path) {
+        return [from, ...path];
+      }
+    }
+    return undefined;
+  }
+
+  private getActivationById(id: number): ResolutionActivation {
+    const activation = this.activeActivations.get(id);
+    if (!activation) throw new Error(`Missing DI activation ${id} while reporting an async dependency cycle.`);
+    return activation;
+  }
+
+  private createCircularDependencyError(activations: readonly (ResolutionActivation | ServiceRegistration)[]): CircularDependencyError {
+    return new CircularDependencyError(activations.map((activation) =>
+      activation instanceof ServiceRegistration ? activation.token : activation.registration.token,
+    ));
+  }
+}

package/core/di/internal/ScopeLifecycle.ts

@@ -0,0 +1,159 @@
+import { ScopeDisposedError, ScopedServiceFromRootError } from "../errors";
+import { isValueProvider, type Provider, type ProviderLifetime } from "../provider";
+import { disposeTracked } from "./disposal";
+import { ResolutionScopeState } from "./ResolutionScopeState";
+import type { ServiceRegistration } from "./ServiceRegistration";
+
+/** Owns scopes, resource identities and the shared asynchronous disposal work. */
+export class ScopeLifecycle {
+  public readonly root = new ResolutionScopeState(true);
+  private readonly children = new Set<ResolutionScopeState>();
+  private readonly trackedDisposableIdentities = new WeakSet<object>();
+
+  public constructor(private readonly owner: object, private readonly validateScopes: boolean) {}
+
+  public createScope(): ResolutionScopeState {
+    this.assertLive(this.root);
+    const scope = new ResolutionScopeState(false);
+    this.children.add(scope);
+    return scope;
+  }
+
+  // Scope/lifetime rules shared by the sync and async resolve paths. Returns the
+  // scope that owns the resulting instance (root for singletons), guaranteeing a
+  // single source of truth for captive-dependency and disposed-scope checks.
+  public targetFor(
+    registration: ServiceRegistration,
+    scopeState: ResolutionScopeState,
+    ownerLifetime: ProviderLifetime | undefined,
+  ): ResolutionScopeState {
+    if (this.validateScopes && registration.lifetime === "scoped") {
+      // A singleton consumer or a direct root resolution cannot own a scoped
+      // service — that would be a captive dependency.
+      if (ownerLifetime === "singleton" || scopeState.isRoot) {
+        throw new ScopedServiceFromRootError(registration.token);
+      }
+    }
+
+    const targetScope = registration.lifetime === "singleton" ? this.root : scopeState;
+    // A live child scope must not resurrect singletons in a disposed root: the
+    // root cache/disposables are already cleared, so the new instance would leak
+    // and never be disposed. Mirror .NET's ObjectDisposedException.
+    this.assertLive(targetScope);
+    return targetScope;
+  }
+
+  public assertLive(scopeState: ResolutionScopeState): void {
+    if (scopeState.disposed) {
+      throw new ScopeDisposedError();
+    }
+  }
+
+  public track(
+    provider: Provider<unknown>,
+    instance: unknown,
+    targetScope: ResolutionScopeState,
+  ): void {
+    if (
+      isValueProvider(provider)
+      || provider.ownership === "external"
+      || instance === this.owner
+      || !isDisposableInstance(instance)
+    ) {
+      return;
+    }
+    const identity = instance as object;
+    if (this.trackedDisposableIdentities.has(identity)) {
+      return;
+    }
+    this.trackedDisposableIdentities.add(identity);
+    targetScope.disposables.push(instance);
+  }
+
+  public dispose(): Promise<void> {
+    if (this.root.disposalPromise !== undefined) {
+      return this.root.disposalPromise;
+    }
+    this.root.disposed = true;
+    const children = [...this.children];
+    for (let index = 0; index < children.length; index += 1) {
+      children[index]!.disposed = true;
+    }
+    // Defer cleanup until after the shared promise is published. A disposer is
+    // allowed to call container.dispose() re-entrantly and must join this work.
+    const disposal = Promise.resolve().then(() => this.disposeRootAndChildren(children));
+    this.root.disposalPromise = disposal;
+    return disposal;
+  }
+
+  public disposeScope(scopeState: ResolutionScopeState): Promise<void> {
+    if (scopeState.disposalPromise !== undefined) {
+      return scopeState.disposalPromise;
+    }
+    scopeState.disposed = true;
+    const disposal = Promise.resolve().then(() => this.disposeScopeState(scopeState)).finally(() => {
+      this.children.delete(scopeState);
+    });
+    scopeState.disposalPromise = disposal;
+    return disposal;
+  }
+
+  private async disposeRootAndChildren(children: readonly ResolutionScopeState[]): Promise<void> {
+    const errors: unknown[] = [];
+    for (let index = children.length - 1; index >= 0; index -= 1) {
+      const child = children[index]!;
+      try {
+        const disposal = child.disposalPromise ?? Promise.resolve().then(() => this.disposeScopeState(child));
+        child.disposalPromise = disposal;
+        await disposal;
+      } catch (error) {
+        errors.push(error);
+      } finally {
+        this.children.delete(child);
+      }
+    }
+    try {
+      await this.disposeScopeState(this.root);
+    } catch (error) {
+      errors.push(error);
+    }
+    if (errors.length === 1) {
+      throw errors[0];
+    }
+    if (errors.length > 1) {
+      throw new AggregateError(errors, "Container disposal finished with errors.");
+    }
+  }
+
+  private async disposeScopeState(scopeState: ResolutionScopeState): Promise<void> {
+    // Resolutions observe `disposed` and only register a late-created resource
+    // for cleanup; waiting here guarantees it cannot escape after disposal.
+    while (scopeState.pendingCreations.size > 0) {
+      await Promise.allSettled([...scopeState.pendingCreations]);
+    }
+    try {
+      await disposeTracked(scopeState.disposables);
+    } finally {
+      scopeState.disposables.length = 0;
+      scopeState.cache.clear();
+      scopeState.pendingAsync.clear();
+      scopeState.pendingCreations.clear();
+      scopeState.pendingWaits.clear();
+      scopeState.pendingAsyncActivationIds.clear();
+      scopeState.activeActivationIds.clear();
+    }
+  }
+}
+
+function isDisposableInstance(instance: unknown): boolean {
+  if (!instance || (typeof instance !== "object" && typeof instance !== "function")) {
+    return false;
+  }
+  const value = instance as Record<PropertyKey, unknown>;
+  return (
+    typeof value.dispose === "function" ||
+    typeof value.disposeAsync === "function" ||
+    typeof value[Symbol.dispose] === "function" ||
+    typeof value[Symbol.asyncDispose] === "function"
+  );
+}

package/core/di/internal/ServiceRegistration.ts

@@ -0,0 +1,14 @@
+import type { Provider, ProviderLifetime } from "../provider";
+import type { Token } from "../token";
+import type { ServiceKey } from "../types";
+
+export class ServiceRegistration<T = unknown> {
+  public constructor(
+    public readonly id: number,
+    public readonly token: Token<T>,
+    public readonly provider: Provider<T>,
+    public readonly lifetime: ProviderLifetime,
+    public readonly key?: ServiceKey,
+    public readonly fromOpenGeneric = false,
+  ) {}
+}

package/core/di/internal/ServiceRegistry.ts

@@ -0,0 +1,252 @@
+import { ModuleEncapsulationError } from "../errors";
+import type { Provider, ProviderDefinition } from "../provider";
+import type { Token } from "../token";
+import type { ServiceKey } from "../types";
+import { NamedTokenIndex } from "./NamedTokenIndex";
+import type { OpenGenericRegistration } from "./OpenGenericRegistration";
+import { ServiceRegistration } from "./ServiceRegistration";
+
+/** Owns registration identity, keyed lookup and atomic open-generic materialization. */
+export class ServiceRegistry {
+  private readonly registrationsByToken = new Map<Token<unknown>, ServiceRegistration[]>();
+  private readonly openGenericRegistrations = new Map<symbol, OpenGenericRegistration[]>();
+  private readonly openGenericMaterializedKeys = new Map<Token<unknown>, Set<ServiceKey | undefined>>();
+  // Cache successful registration selections, not resolved instances or missing keys.
+  private lastSelections: WeakMap<
+    readonly ServiceRegistration[], Map<ServiceKey | undefined, ServiceRegistration>
+  > | undefined;
+  private allSelections: WeakMap<
+    readonly ServiceRegistration[], Map<ServiceKey | undefined, readonly ServiceRegistration[]>
+  > | undefined;
+  private readonly namedTokenIndex = new NamedTokenIndex(() => this.registrationsByToken.keys());
+  private nextRegistrationId: number;
+
+  public constructor(
+    definitions: readonly ProviderDefinition[],
+    openGenericRegistrations: readonly OpenGenericRegistration[],
+  ) {
+    this.nextRegistrationId = definitions.length;
+    for (let index = 0; index < definitions.length; index += 1) {
+      const definition = definitions[index] as ProviderDefinition;
+      const token = definition.provider.provide;
+      const registration = new ServiceRegistration(index, token, definition.provider, definition.lifetime, definition.key);
+      const existing = this.registrationsByToken.get(token);
+      if (existing) {
+        existing.push(registration);
+      } else {
+        this.registrationsByToken.set(token, [registration]);
+      }
+    }
+
+    for (let index = 0; index < openGenericRegistrations.length; index += 1) {
+      const registration = openGenericRegistrations[index] as OpenGenericRegistration;
+      const existing = this.openGenericRegistrations.get(registration.family.id);
+      if (existing) {
+        existing.push(registration);
+      } else {
+        this.openGenericRegistrations.set(registration.family.id, [registration]);
+      }
+    }
+  }
+
+  public groups(): Iterable<readonly ServiceRegistration[]> {
+    return this.registrationsByToken.values();
+  }
+
+  public lookupName(name: string): Token<unknown> | undefined {
+    return this.namedTokenIndex.lookup(name);
+  }
+
+  public all(token: Token<unknown>, key: ServiceKey | undefined): readonly ServiceRegistration[] {
+    this.materializeOpenGenericRegistration(token, key, undefined);
+    const registrations = this.registrationsByToken.get(token);
+    if (!registrations) return [];
+    if (registrations.length === 1) return registrations[0]!.key === key ? registrations : [];
+    const cached = this.allSelections?.get(registrations)?.get(key);
+    if (cached) return cached;
+    let selected: readonly ServiceRegistration[] = registrations;
+    // The usual single-key list can be consumed without copying it.
+    for (const registration of registrations) {
+      if (registration.key !== key) {
+        selected = registrations.filter((entry) => entry.key === key);
+        break;
+      }
+    }
+    if (selected.length > 0) {
+      this.allSelections ??= new WeakMap();
+      let selections = this.allSelections.get(registrations);
+      if (!selections) this.allSelections.set(registrations, selections = new Map());
+      selections.set(key, selected);
+    }
+    return selected;
+  }
+
+  public find(token: Token<unknown>, key: ServiceKey | undefined): ServiceRegistration | undefined {
+    const registrations = this.registrationsByToken.get(token);
+    // Short lists use the direct scan; indexing pays off only for larger groups.
+    const direct = registrations && registrations.length > 8
+      ? this.findLastInGroup(registrations, key)
+      : this.findLastRegistration(registrations, key);
+    if (direct) {
+      return direct;
+    }
+    // Miss: a closed generic may not be materialized yet. materialize is
+    // idempotent and returns immediately for non-generic / already-done tokens.
+    this.materializeOpenGenericRegistration(token, key, undefined);
+    return this.findLastRegistration(this.registrationsByToken.get(token), key);
+  }
+
+  private findLastInGroup(
+    registrations: readonly ServiceRegistration[],
+    key: ServiceKey | undefined,
+  ): ServiceRegistration | undefined {
+    const last = registrations[registrations.length - 1]!;
+    if (last.key === key && !last.fromOpenGeneric) return last;
+    const cached = this.lastSelections?.get(registrations)?.get(key);
+    if (cached) return cached;
+    const selected = this.findLastRegistration(registrations, key);
+    // Remember successful selections only; arbitrary missing keys must not grow this cache.
+    if (selected) {
+      this.lastSelections ??= new WeakMap();
+      let selections = this.lastSelections.get(registrations);
+      if (!selections) this.lastSelections.set(registrations, selections = new Map());
+      selections.set(key, selected);
+    }
+    return selected;
+  }
+
+  private findLastRegistration(
+    registrations: readonly ServiceRegistration[] | undefined,
+    key: ServiceKey | undefined,
+  ): ServiceRegistration | undefined {
+    if (!registrations) {
+      return undefined;
+    }
+    let genericFallback: ServiceRegistration | undefined;
+    for (let index = registrations.length - 1; index >= 0; index -= 1) {
+      const registration = registrations[index] as ServiceRegistration;
+      if (registration.key === key) {
+        // Explicit closed registrations retain priority even after resolveAll
+        // materializes a family. Enumeration order remains unchanged.
+        if (!registration.fromOpenGeneric) {
+          return registration;
+        }
+        genericFallback ??= registration;
+      }
+    }
+    return genericFallback;
+  }
+
+  public validateOpenGenerics(issues: Set<string>): void {
+    const tokens = [...this.registrationsByToken.keys()];
+    for (const openRegistrations of this.openGenericRegistrations.values()) {
+      for (let index = 0; index < openRegistrations.length; index += 1) {
+        const openRegistration = openRegistrations[index] as OpenGenericRegistration;
+        for (let tokenIndex = 0; tokenIndex < tokens.length; tokenIndex += 1) {
+          const argToken = tokens[tokenIndex] as Token<unknown>;
+          // Closed generic tokens are not valid generic arguments here:
+          // skipping them avoids materializing nested noise like Repo<Repo<T>>.
+          if (typeof argToken !== "function" && argToken.genericFamilyId) {
+            continue;
+          }
+          const closedToken = openRegistration.family.of(argToken);
+          this.materializeOpenGenericRegistration(closedToken, openRegistration.key, issues);
+        }
+      }
+    }
+  }
+
+  private materializeOpenGenericRegistration(
+    token: Token<unknown>,
+    key: ServiceKey | undefined,
+    issues: Set<string> | undefined,
+  ): void {
+    if (typeof token === "function") {
+      return;
+    }
+    const familyId = token.genericFamilyId;
+    const argumentToken = token.genericArgToken;
+    if (!familyId || !argumentToken) {
+      return;
+    }
+    const registrations = this.openGenericRegistrations.get(familyId);
+    if (!registrations || registrations.length === 0) {
+      return;
+    }
+
+    if (this.isOpenGenericMaterialized(token, key)) {
+      return;
+    }
+
+    const staged: Array<{ readonly registration: OpenGenericRegistration; readonly provider: Provider<unknown> }> = [];
+    for (let index = 0; index < registrations.length; index += 1) {
+      const registration = registrations[index] as OpenGenericRegistration;
+      if (registration.key !== key) {
+        continue;
+      }
+
+      let provider: Provider<unknown>;
+      try {
+        provider = registration.providerFactory(argumentToken);
+      } catch (error) {
+        // Module visibility is a separate contract, including during eager
+        // graph validation. Keep the same diagnostic as ordinary providers.
+        if (error instanceof ModuleEncapsulationError) {
+          throw error;
+        }
+        if (issues) {
+          const message = error instanceof Error ? error.message : String(error);
+          issues.add(`Open generic "${token.description}" factory failed: ${message}`);
+          continue;
+        }
+        throw error;
+      }
+      staged.push({ registration, provider });
+    }
+
+    if (issues && staged.length !== registrations.filter((registration) => registration.key === key).length) {
+      return;
+    }
+
+    const closedRegistrations = staged.map(
+      ({ registration, provider }, index) => new ServiceRegistration(
+        this.nextRegistrationId + index,
+        token,
+        provider,
+        registration.lifetime,
+        registration.key,
+        true,
+      ),
+    );
+    this.nextRegistrationId += closedRegistrations.length;
+    const existing = this.registrationsByToken.get(token);
+    if (existing) {
+      existing.push(...closedRegistrations);
+      if (closedRegistrations.length > 0) {
+        this.lastSelections?.delete(existing);
+        this.allSelections?.delete(existing);
+      }
+    } else if (closedRegistrations.length > 0) {
+      this.registrationsByToken.set(token, closedRegistrations);
+      this.namedTokenIndex.index(token);
+    }
+    this.markOpenGenericMaterialized(token, key);
+  }
+
+  private isOpenGenericMaterialized(token: Token<unknown>, key: ServiceKey | undefined): boolean {
+    const materializedKeys = this.openGenericMaterializedKeys.get(token);
+    if (!materializedKeys) {
+      return false;
+    }
+    return materializedKeys.has(key);
+  }
+
+  private markOpenGenericMaterialized(token: Token<unknown>, key: ServiceKey | undefined): void {
+    let materializedKeys = this.openGenericMaterializedKeys.get(token);
+    if (!materializedKeys) {
+      materializedKeys = new Set<ServiceKey | undefined>();
+      this.openGenericMaterializedKeys.set(token, materializedKeys);
+    }
+    materializedKeys.add(key);
+  }
+}

package/core/di/internal/classDeps.ts

@@ -0,0 +1,38 @@
+import type { Class } from "../token";
+import type { ProviderDependencyList } from "../provider";
+
+const classDeps = new WeakMap<Function, ProviderDependencyList>();
+export const CLASS_DEPS = Symbol("bazis.class.deps");
+
+export function setClassDeps<C extends Class<unknown>, D extends ProviderDependencyList>(
+  useClass: C,
+  deps: D,
+): void {
+  classDeps.set(useClass as unknown as Function, deps);
+}
+
+export function getClassDeps(useClass: Class<unknown>): ProviderDependencyList | undefined {
+  const fromMap = classDeps.get(useClass as unknown as Function);
+  if (fromMap) {
+    return fromMap;
+  }
+
+  const withDeps = useClass as unknown as {
+    [CLASS_DEPS]?: ProviderDependencyList;
+    inject?: ProviderDependencyList;
+    deps?: ProviderDependencyList;
+  };
+
+  const fromSymbol = withDeps[CLASS_DEPS];
+  if (fromSymbol) {
+    return fromSymbol;
+  }
+  if (withDeps.inject) {
+    return withDeps.inject;
+  }
+  if (withDeps.deps) {
+    return withDeps.deps;
+  }
+
+  return undefined;
+}