@navios/di 0.7.1 → 0.9.0

package/lib/browser/index.d.mts

@@ -1,1508 +1,37 @@
-import { ZodObject, ZodOptional, ZodRecord, ZodType, z } from "zod/v4";
-
-//#region src/utils/types.d.mts
-type Join<TElements, TSeparator extends string> = TElements extends Readonly<[infer First, ...infer Rest]> ? Rest extends ReadonlyArray<string> ? First extends string ? `${First}${Rest extends [] ? '' : TSeparator}${Join<Rest, TSeparator>}` : never : never : '';
-type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends ((k: infer I) => void) ? I : never;
-type UnionToOvlds<U> = UnionToIntersection<U extends any ? (f: U) => void : never>;
-type PopUnion<U> = UnionToOvlds<U> extends ((a: infer A) => void) ? A : never;
-type IsUnion<T> = [T] extends [UnionToIntersection<T>] ? false : true;
-type UnionToArray<T, A extends unknown[] = []> = IsUnion<T> extends true ? UnionToArray<Exclude<T, PopUnion<T>>, [PopUnion<T>, ...A]> : [T, ...A];
-type InjectRequest = {
-  token: InjectionToken<any> | BoundInjectionToken<any, any> | FactoryInjectionToken<any, any> | ClassType;
-  promise: Promise<any>;
-  readonly result: any;
-  readonly error: Error | null;
-};
-interface InjectState {
-  currentIndex: number;
-  isFrozen: boolean;
-  requests: InjectRequest[];
-}
-//#endregion
-//#region src/interfaces/factory.interface.d.mts
-interface Factorable<T> {
-  create(ctx?: FactoryContext): Promise<T> | T;
-}
-interface FactorableWithArgs<T, A extends InjectionTokenSchemaType> {
-  create(ctx?: FactoryContext, ...args: [z.output<A>]): Promise<T> | T;
-}
-//#endregion
-//#region src/interfaces/container.interface.d.mts
-/**
- * Interface for dependency injection containers.
- * Both Container and ScopedContainer implement this interface,
- * allowing them to be used interchangeably in factory contexts.
- */
-interface IContainer {
-  /**
-   * Gets an instance from the container.
-   */
-  get<T extends ClassType>(token: T): InstanceType<T> extends Factorable<infer R> ? Promise<R> : Promise<InstanceType<T>>;
-  get<T extends ClassTypeWithArgument<R>, R>(token: T, args: R): Promise<InstanceType<T>>;
-  get<T, S extends InjectionTokenSchemaType>(token: InjectionToken<T, S>, args: z.input<S>): Promise<T>;
-  get<T, S extends InjectionTokenSchemaType, R extends boolean>(token: InjectionToken<T, S, R>): R extends false ? Promise<T> : S extends ZodType<infer Type> ? `Error: Your token requires args: ${Join<UnionToArray<keyof Type>, ', '>}` : 'Error: Your token requires args';
-  get<T>(token: InjectionToken<T, undefined>): Promise<T>;
-  get<T>(token: BoundInjectionToken<T, any>): Promise<T>;
-  get<T>(token: FactoryInjectionToken<T, any>): Promise<T>;
-  /**
-   * Invalidates a service and its dependencies.
-   */
-  invalidate(service: unknown): Promise<void>;
-  /**
-   * Checks if a service is registered in the container.
-   */
-  isRegistered(token: any): boolean;
-  /**
-   * Disposes the container and cleans up all resources.
-   */
-  dispose(): Promise<void>;
-  /**
-   * Waits for all pending operations to complete.
-   */
-  ready(): Promise<void>;
-  /**
-   * @internal
-   * Attempts to get an instance synchronously if it already exists.
-   * Returns null if the instance doesn't exist or is not ready.
-   * Used internally by the inject system for synchronous property initialization.
-   */
-  tryGetSync<T>(token: any, args?: any): T | null;
-}
-//#endregion
-//#region src/utils/get-injectors.d.mts
-interface Injectors {
-  asyncInject<T extends ClassTypeWithoutArguments>(token: T): InstanceType<T> extends Factorable<infer R> ? Promise<R> : Promise<InstanceType<T>>;
-  asyncInject<Args, T extends ClassTypeWithArgument<Args>>(token: T, args: Args): Promise<InstanceType<T>>;
-  asyncInject<Schema extends InjectionTokenSchemaType, R, T extends FactorableWithArgs<R, Schema>>(token: T, args: z.input<Schema>): Promise<R>;
-  asyncInject<T, S extends InjectionTokenSchemaType>(token: InjectionToken<T, S>, args: z.input<S>): Promise<T>;
-  asyncInject<T, S extends InjectionTokenSchemaType, R extends boolean>(token: InjectionToken<T, S, R>): R extends false ? Promise<T> : S extends ZodType<infer Type> ? `Error: Your token requires args: ${Join<UnionToArray<keyof Type>, ', '>}` : 'Error: Your token requires args';
-  asyncInject<T>(token: InjectionToken<T, undefined>): Promise<T>;
-  asyncInject<T>(token: BoundInjectionToken<T, any>): Promise<T>;
-  asyncInject<T>(token: FactoryInjectionToken<T, any>): Promise<T>;
-  inject<T extends ClassTypeWithoutArguments>(token: T): InstanceType<T> extends Factorable<infer R> ? R : InstanceType<T>;
-  inject<Args, T extends ClassTypeWithArgument<Args>>(token: T, args: Args): InstanceType<T>;
-  inject<Schema extends InjectionTokenSchemaType, R, T extends FactorableWithArgs<R, Schema>>(token: T, args: z.input<Schema>): R;
-  inject<T, S extends InjectionTokenSchemaType>(token: InjectionToken<T, S>, args: z.input<S>): T;
-  inject<T, S extends InjectionTokenSchemaType, R extends boolean>(token: InjectionToken<T, S, R>): R extends false ? T : S extends ZodType<infer Type> ? `Error: Your token requires args: ${Join<UnionToArray<keyof Type>, ', '>}` : 'Error: Your token requires args';
-  inject<T>(token: InjectionToken<T, undefined>): T;
-  inject<T>(token: BoundInjectionToken<T, any>): T;
-  inject<T>(token: FactoryInjectionToken<T, any>): T;
-  /**
-   * Optional injection that returns null if the service fails to initialize
-   * or is not available. This is useful when you want to inject a service
-   * that may not be configured or may fail gracefully.
-   *
-   * @example
-   * ```ts
-   * class MyService {
-   *   constructor() {
-   *     const optionalService = optional(OptionalServiceToken)
-   *     // optionalService will be null if initialization fails
-   *     if (optionalService) {
-   *       optionalService.doSomething()
-   *     }
-   *   }
-   * }
-   * ```
-   */
-  optional<T extends ClassType>(token: T): (InstanceType<T> extends Factorable<infer R> ? R : InstanceType<T>) | null;
-  optional<T, S extends InjectionTokenSchemaType>(token: InjectionToken<T, S>, args: z.input<S>): T | null;
-  optional<T, S extends InjectionTokenSchemaType, R extends boolean>(token: InjectionToken<T, S, R>): R extends false ? T | null : S extends ZodType<infer Type> ? `Error: Your token requires args: ${Join<UnionToArray<keyof Type>, ', '>}` : 'Error: Your token requires args';
-  optional<T>(token: InjectionToken<T, undefined>): T | null;
-  optional<T>(token: BoundInjectionToken<T, any>): T | null;
-  optional<T>(token: FactoryInjectionToken<T, any>): T | null;
-  wrapSyncInit(cb: () => any): (injectState?: InjectState) => [any, Promise<any>[], InjectState];
-  provideFactoryContext(context: FactoryContext | null): FactoryContext | null;
-}
-declare function getInjectors(): Injectors;
-//#endregion
-//#region src/utils/get-injectable-token.d.mts
-declare function getInjectableToken<R>(target: ClassType): R extends {
-  create(...args: any[]): infer V;
-} ? InjectionToken<V> : InjectionToken<R>;
-//#endregion
-//#region src/internal/context/factory-context.d.mts
-/**
- * Context provided to factory functions during service instantiation.
- *
- * Provides access to dependency injection (via inject), the container,
- * and lifecycle hooks for cleanup.
- */
-interface FactoryContext {
-  inject: Injectors['asyncInject'];
-  /**
-   * The container instance for dependency resolution.
-   * This may be either a Container or ScopedContainer.
-   */
-  container: IContainer;
-  addDestroyListener: (listener: () => void) => void;
-}
-//#endregion
-//#region src/token/injection-token.d.mts
-type ClassType = new (...args: any[]) => any;
-type ClassTypeWithoutArguments = new () => any;
-type ClassTypeWithArgument<Arg> = new (arg: Arg) => any;
-type ClassTypeWithOptionalArgument<Arg> = new (arg?: Arg) => any;
-type ClassTypeWithInstance<T> = new (...args: any[]) => T;
-type ClassTypeWithInstanceAndArgument<T, Arg> = new (arg: Arg) => T;
-type ClassTypeWithInstanceAndOptionalArgument<T, Arg> = new (arg?: Arg) => T;
-type BaseInjectionTokenSchemaType = ZodObject | ZodRecord;
-type OptionalInjectionTokenSchemaType = ZodOptional<ZodObject> | ZodOptional<ZodRecord>;
-type InjectionTokenSchemaType = BaseInjectionTokenSchemaType | OptionalInjectionTokenSchemaType;
-declare class InjectionToken<T, S extends InjectionTokenSchemaType | unknown = unknown, Required extends boolean = (S extends ZodOptional<ZodObject> ? false : S extends ZodOptional<ZodRecord> ? false : S extends ZodObject ? true : S extends ZodRecord ? true : false)> {
-  readonly name: string | symbol | ClassType;
-  readonly schema: ZodObject | undefined;
-  id: `${string}-${string}-${string}-${string}-${string}`;
-  private formattedName;
-  constructor(name: string | symbol | ClassType, schema: ZodObject | undefined);
-  static create<T extends ClassType>(name: T): InjectionToken<InstanceType<T>, undefined>;
-  static create<T extends ClassType, Schema extends InjectionTokenSchemaType>(name: T, schema: Schema): Schema['_def']['type'] extends 'ZodOptional' ? InjectionToken<InstanceType<T>, Schema, false> : InjectionToken<InstanceType<T>, Schema, true>;
-  static create<T>(name: string | symbol): InjectionToken<T, undefined>;
-  static create<T, Schema extends InjectionTokenSchemaType>(name: string | any, schema: Schema): InjectionToken<T, Schema>;
-  static bound<T, S extends InjectionTokenSchemaType>(token: InjectionToken<T, S>, value: z.input<S>): BoundInjectionToken<T, S>;
-  static factory<T, S extends InjectionTokenSchemaType>(token: InjectionToken<T, S>, factory: (ctx: FactoryContext) => Promise<z.input<S>>): FactoryInjectionToken<T, S>;
-  static refineType<T>(token: BoundInjectionToken<any, any>): BoundInjectionToken<T, any>;
-  toString(): string;
-}
-declare class BoundInjectionToken<T, S extends InjectionTokenSchemaType> {
-  readonly token: InjectionToken<T, S>;
-  readonly value: z.input<S>;
-  id: string;
-  name: string | symbol | ClassType;
-  schema: InjectionTokenSchemaType;
-  constructor(token: InjectionToken<T, S>, value: z.input<S>);
-  toString(): string;
-}
-declare class FactoryInjectionToken<T, S extends InjectionTokenSchemaType> {
-  readonly token: InjectionToken<T, S>;
-  readonly factory: (ctx: FactoryContext) => Promise<z.input<S>>;
-  value?: z.input<S>;
-  resolved: boolean;
-  id: string;
-  name: string | symbol | ClassType;
-  schema: InjectionTokenSchemaType;
-  constructor(token: InjectionToken<T, S>, factory: (ctx: FactoryContext) => Promise<z.input<S>>);
-  resolve(ctx: FactoryContext): Promise<z.input<S>>;
-  toString(): string;
-}
-type AnyInjectableType = ClassType | InjectionToken<any, any> | BoundInjectionToken<any, any> | FactoryInjectionToken<any, any>;
-type InjectionTokenType = InjectionToken<any, any> | BoundInjectionToken<any, any> | FactoryInjectionToken<any, any>;
-//#endregion
-//#region src/enums/injectable-scope.enum.d.mts
-declare enum InjectableScope {
-  /**
-   * Singleton scope: The instance is created once and shared across the application.
-   */
-  Singleton = "Singleton",
-  /**
-   * Instance scope: A new instance is created for each injection.
-   */
-  Transient = "Transient",
-  /**
-   * Request scope: The instance is created once per request and shared within that request context.
-   */
-  Request = "Request",
-}
-//#endregion
-//#region src/enums/injectable-type.enum.d.mts
-declare enum InjectableType {
-  Class = "Class",
-  Factory = "Factory",
-}
-//#endregion
-//#region src/token/registry.d.mts
-type FactoryRecord<Instance = any, Schema = any> = {
-  scope: InjectableScope;
-  originalToken: InjectionToken<Instance, Schema>;
-  target: ClassType;
-  type: InjectableType;
-};
-declare class Registry {
-  private readonly parent?;
-  private readonly factories;
-  constructor(parent?: Registry | undefined);
-  has(token: InjectionToken<any, any>): boolean;
-  get<Instance, Schema>(token: InjectionToken<Instance, Schema>): FactoryRecord<Instance, Schema>;
-  set<Instance, Schema>(token: InjectionToken<Instance, Schema>, scope: InjectableScope, target: ClassType, type: InjectableType): void;
-  delete(token: InjectionToken<any, any>): void;
-  /**
-   * Updates the scope of an already registered factory.
-   * This is useful when you need to dynamically change a service's scope
-   * (e.g., when a singleton controller has request-scoped dependencies).
-   *
-   * @param token The injection token to update
-   * @param scope The new scope to set
-   * @returns true if the scope was updated, false if the token was not found
-   */
-  updateScope(token: InjectionToken<any, any>, scope: InjectableScope): boolean;
-}
-declare const globalRegistry: Registry;
-//#endregion
-//#region src/errors/di-error.d.mts
-declare enum DIErrorCode {
-  FactoryNotFound = "FactoryNotFound",
-  FactoryTokenNotResolved = "FactoryTokenNotResolved",
-  InstanceNotFound = "InstanceNotFound",
-  InstanceDestroying = "InstanceDestroying",
-  CircularDependency = "CircularDependency",
-  UnknownError = "UnknownError",
-}
-declare class DIError extends Error {
-  readonly code: DIErrorCode;
-  readonly message: string;
-  readonly context?: Record<string, unknown>;
-  constructor(code: DIErrorCode, message: string, context?: Record<string, unknown>);
-  static factoryNotFound(name: string): DIError;
-  static factoryTokenNotResolved(token: string | symbol | unknown): DIError;
-  static instanceNotFound(name: string): DIError;
-  static instanceDestroying(name: string): DIError;
-  static unknown(message: string | Error, context?: Record<string, unknown>): DIError;
-  static circularDependency(cycle: string[]): DIError;
-}
-//#endregion
-//#region src/internal/holder/instance-holder.d.mts
-/**
- * Represents the lifecycle status of an instance holder.
- */
-declare enum InstanceStatus {
-  /** Instance has been successfully created and is ready for use */
-  Created = "created",
-  /** Instance is currently being created (async initialization in progress) */
-  Creating = "creating",
-  /** Instance is being destroyed (cleanup in progress) */
-  Destroying = "destroying",
-  /** Instance creation failed with an error */
-  Error = "error",
-}
-/** Callback function for instance effects */
-type InstanceEffect = () => void;
-/** Callback function for instance destruction listeners */
-type InstanceDestroyListener = () => void | Promise<void>;
-/**
- * Instance holder in the Creating state.
- * The instance is null while creation is in progress.
- */
-interface InstanceHolderCreating<Instance> {
-  status: InstanceStatus.Creating;
-  name: string;
-  instance: null;
-  creationPromise: Promise<[undefined, Instance]> | null;
-  destroyPromise: null;
-  type: InjectableType;
-  scope: InjectableScope;
-  deps: Set<string>;
-  destroyListeners: InstanceDestroyListener[];
-  createdAt: number;
-  /** Tracks which services this holder is currently waiting for (for circular dependency detection) */
-  waitingFor: Set<string>;
-}
-/**
- * Instance holder in the Created state.
- * The instance is available and ready for use.
- */
-interface InstanceHolderCreated<Instance> {
-  status: InstanceStatus.Created;
-  name: string;
-  instance: Instance;
-  creationPromise: null;
-  destroyPromise: null;
-  type: InjectableType;
-  scope: InjectableScope;
-  deps: Set<string>;
-  destroyListeners: InstanceDestroyListener[];
-  createdAt: number;
-  /** Tracks which services this holder is currently waiting for (for circular dependency detection) */
-  waitingFor: Set<string>;
-}
-/**
- * Instance holder in the Destroying state.
- * The instance may still be available but is being cleaned up.
- */
-interface InstanceHolderDestroying<Instance> {
-  status: InstanceStatus.Destroying;
-  name: string;
-  instance: Instance | null;
-  creationPromise: null;
-  destroyPromise: Promise<void>;
-  type: InjectableType;
-  scope: InjectableScope;
-  deps: Set<string>;
-  destroyListeners: InstanceDestroyListener[];
-  createdAt: number;
-  /** Tracks which services this holder is currently waiting for (for circular dependency detection) */
-  waitingFor: Set<string>;
-}
-/**
- * Instance holder in the Error state.
- * The instance field contains the error that occurred during creation.
- */
-interface InstanceHolderError {
-  status: InstanceStatus.Error;
-  name: string;
-  instance: Error;
-  creationPromise: null;
-  destroyPromise: null;
-  type: InjectableType;
-  scope: InjectableScope;
-  deps: Set<string>;
-  destroyListeners: InstanceDestroyListener[];
-  createdAt: number;
-  /** Tracks which services this holder is currently waiting for (for circular dependency detection) */
-  waitingFor: Set<string>;
-}
-/**
- * Holds the state of a service instance throughout its lifecycle.
- *
- * Tracks creation/destruction promises, dependency relationships,
- * destroy listeners, and current status (Creating, Created, Destroying, Error).
- */
-type InstanceHolder<Instance = unknown> = InstanceHolderCreating<Instance> | InstanceHolderCreated<Instance> | InstanceHolderDestroying<Instance> | InstanceHolderError;
-//#endregion
-//#region src/internal/holder/holder-storage.interface.d.mts
-/**
- * Result type for holder retrieval operations.
- * - [undefined, holder] - Holder found successfully
- * - [DIError, holder?] - Error occurred (holder may be available for waiting)
- * - null - No holder exists
- */
-type HolderGetResult<T = unknown> = [undefined, InstanceHolder<T>] | [DIError, InstanceHolder<T>?] | null;
-/**
- * Interface for abstracting holder storage operations.
- *
- * Enables unified instance resolution logic regardless of where
- * holders are stored (singleton manager, request context, etc.).
- * This is the key abstraction for the Storage Strategy pattern.
- */
-interface IHolderStorage {
-  /**
-   * The scope this storage handles.
-   */
-  readonly scope: InjectableScope;
-  /**
-   * Retrieves an existing holder by instance name.
-   *
-   * @param instanceName The unique identifier for the instance
-   * @returns
-   *   - [undefined, holder] if found and ready/creating
-   *   - [DIError, holder?] if found but in error/destroying state
-   *   - null if not found
-   */
-  get<T = unknown>(instanceName: string): HolderGetResult<T>;
-  /**
-   * Stores a holder by instance name.
-   *
-   * @param instanceName The unique identifier for the instance
-   * @param holder The holder to store
-   */
-  set(instanceName: string, holder: InstanceHolder): void;
-  /**
-   * Deletes a holder by instance name.
-   *
-   * @param instanceName The unique identifier for the instance
-   * @returns true if the holder was deleted, false if it didn't exist
-   */
-  delete(instanceName: string): boolean;
-  /**
-   * Creates a new holder in "Creating" state with a deferred promise.
-   * The holder is NOT automatically stored - call set() to store it.
-   *
-   * @param instanceName The unique identifier for the instance
-   * @param type The injectable type
-   * @param deps The set of dependency names
-   * @returns A tuple containing the deferred promise resolver and the holder
-   */
-  createHolder<T>(instanceName: string, type: InjectableType, deps: Set<string>): [ReturnType<typeof Promise.withResolvers<[undefined, T]>>, InstanceHolder<T>];
-  /**
-   * Checks if this storage should be used for the given scope.
-   */
-  handles(scope: InjectableScope): boolean;
-  /**
-   * Gets all instance names in this storage.
-   */
-  getAllNames(): string[];
-  /**
-   * Iterates over all holders with a callback.
-   *
-   * @param callback Function called for each holder with (name, holder)
-   */
-  forEach(callback: (name: string, holder: InstanceHolder) => void): void;
-  /**
-   * Finds a holder by its instance value (reverse lookup).
-   *
-   * @param instance The instance to search for
-   * @returns The holder if found, null otherwise
-   */
-  findByInstance(instance: unknown): InstanceHolder | null;
-  /**
-   * Finds all instance names that depend on the given instance name.
-   *
-   * @param instanceName The instance name to find dependents for
-   * @returns Array of instance names that have this instance as a dependency
-   */
-  findDependents(instanceName: string): string[];
-}
-//#endregion
-//#region src/internal/holder/base-holder-manager.d.mts
-/**
- * Result type for waitForHolderReady.
- * Returns either [undefined, holder] on success or [error] on failure.
- */
-type HolderReadyResult<T> = [undefined, InstanceHolder<T>] | [DIError];
-/**
- * Abstract base class providing common functionality for managing InstanceHolder objects.
- *
- * Provides shared patterns for holder storage, creation, and lifecycle management
- * used by both singleton (HolderManager) and request-scoped (RequestContext) managers.
- */
-declare abstract class BaseHolderManager {
-  protected readonly logger: Console | null;
-  protected readonly _holders: Map<string, InstanceHolder>;
-  constructor(logger?: Console | null);
-  /**
-   * Protected getter for accessing the holders map from subclasses.
-   */
-  protected get holders(): Map<string, InstanceHolder>;
-  /**
-   * Abstract method to get a holder by name. Each implementation defines its own return type
-   * based on their specific error handling and validation needs.
-   */
-  abstract get(name: string): any;
-  /**
-   * Abstract method to set a holder by name. Each implementation may have different validation logic.
-   */
-  abstract set(name: string, holder: InstanceHolder): void;
-  /**
-   * Abstract method to check if a holder exists. Each implementation may have different validation logic.
-   */
-  abstract has(name: string): any;
-  /**
-   * Deletes a holder by name.
-   * @param name The name of the holder to delete
-   * @returns true if the holder was deleted, false if it didn't exist
-   */
-  delete(name: string): boolean;
-  /**
-   * Filters holders based on a predicate function.
-   * @param predicate Function to test each holder
-   * @returns A new Map containing only the holders that match the predicate
-   */
-  filter(predicate: (value: InstanceHolder<any>, key: string) => boolean): Map<string, InstanceHolder>;
-  /**
-   * Clears all holders from this manager.
-   */
-  clear(): void;
-  /**
-   * Gets the number of holders currently managed.
-   */
-  size(): number;
-  /**
-   * Creates a new holder with Creating status and a deferred creation promise.
-   * This is useful for creating placeholder holders that can be fulfilled later.
-   * @param name The name of the instance
-   * @param type The injectable type
-   * @param scope The injectable scope
-   * @param deps Optional set of dependencies
-   * @returns A tuple containing the deferred promise and the holder
-   */
-  createCreatingHolder<Instance>(name: string, type: InjectableType, scope: InjectableScope, deps?: Set<string>): [ReturnType<typeof Promise.withResolvers<[undefined, Instance]>>, InstanceHolder<Instance>];
-  /**
-   * Creates a new holder with Created status and an actual instance.
-   * This is useful for creating holders that already have their instance ready.
-   * @param name The name of the instance
-   * @param instance The actual instance to store
-   * @param type The injectable type
-   * @param scope The injectable scope
-   * @param deps Optional set of dependencies
-   * @returns The created holder
-   */
-  protected createCreatedHolder<Instance>(name: string, instance: Instance, type: InjectableType, scope: InjectableScope, deps?: Set<string>): InstanceHolder<Instance>;
-  /**
-   * Gets all holder names currently managed.
-   */
-  getAllNames(): string[];
-  /**
-   * Gets all holders currently managed.
-   */
-  getAllHolders(): InstanceHolder[];
-  /**
-   * Checks if this manager has any holders.
-   */
-  isEmpty(): boolean;
-  /**
-   * Waits for a holder to be ready and returns the appropriate result.
-   * This is a shared utility used by both singleton and request-scoped resolution.
-   *
-   * @param holder The holder to wait for
-   * @param waiterHolder Optional holder that is doing the waiting (for circular dependency detection)
-   * @param getHolder Optional function to retrieve holders by name (required if waiterHolder is provided)
-   * @returns A promise that resolves with [undefined, holder] on success or [DIError] on failure
-   */
-  static waitForHolderReady<T>(holder: InstanceHolder<T>, waiterHolder?: InstanceHolder, getHolder?: (name: string) => InstanceHolder | undefined): Promise<HolderReadyResult<T>>;
-}
-//#endregion
-//#region src/internal/context/request-context.d.mts
-/**
- * Interface for request context that manages pre-prepared instances for a specific request.
- *
- * Provides isolated storage for request-scoped services, enabling efficient
- * instantiation and cleanup within the lifecycle of a single request.
- */
-interface RequestContext {
-  /**
-   * Unique identifier for this request context.
-   */
-  readonly requestId: string;
-  /**
-   * Instance holders for request-scoped services.
-   */
-  readonly holders: Map<string, InstanceHolder>;
-  /**
-   * Priority for resolution in FactoryContext.inject method.
-   * Higher values take precedence.
-   */
-  readonly priority: number;
-  /**
-   * Request-specific metadata that can be used during instantiation.
-   */
-  readonly metadata: Map<string, any>;
-  /**
-   * Timestamp when this context was created.
-   */
-  readonly createdAt: number;
-  /**
-   * Adds a pre-prepared instance to this context.
-   */
-  addInstance(instanceName: string, instance: any, holder: InstanceHolder): void;
-  /**
-   * Adds a pre-prepared instance to this context.
-   */
-  addInstance(token: InjectionToken<any, undefined>, instance: any): void;
-  /**
-   * Gets an instance holder from this context.
-   */
-  get(instanceName: string): InstanceHolder | undefined;
-  /**
-   * Sets an instance holder by name.
-   */
-  set(instanceName: string, holder: InstanceHolder): void;
-  /**
-   * Checks if this context has a pre-prepared instance.
-   */
-  has(instanceName: string): boolean;
-  /**
-   * Clears all instances and holders from this context.
-   */
-  clear(): void;
-  /**
-   * Gets metadata value by key.
-   */
-  getMetadata(key: string): any | undefined;
-  /**
-   * Sets metadata value by key.
-   */
-  setMetadata(key: string, value: any): void;
-  /**
-   * Filters holders based on a predicate function.
-   */
-  filter(predicate: (value: InstanceHolder<any>, key: string) => boolean): Map<string, InstanceHolder>;
-  /**
-   * Deletes a holder by name.
-   */
-  delete(name: string): boolean;
-  /**
-   * Gets the number of holders currently managed.
-   */
-  size(): number;
-  /**
-   * Checks if this manager has any holders.
-   */
-  isEmpty(): boolean;
-}
-/** @deprecated Use RequestContext instead */
-type RequestContextHolder = RequestContext;
-/**
- * Default implementation of RequestContext.
- *
- * Extends BaseHolderManager to provide holder management functionality
- * with request-specific metadata and lifecycle support.
- */
-declare class DefaultRequestContext extends BaseHolderManager implements RequestContext {
-  readonly requestId: string;
-  readonly priority: number;
-  readonly metadata: Map<string, any>;
-  readonly createdAt: number;
-  constructor(requestId: string, priority?: number, initialMetadata?: Record<string, any>);
-  /**
-   * Public getter for holders to maintain interface compatibility.
-   */
-  get holders(): Map<string, InstanceHolder>;
-  /**
-   * Gets a holder by name. For RequestContext, this is a simple lookup.
-   */
-  get(name: string): InstanceHolder | undefined;
-  /**
-   * Sets a holder by name.
-   */
-  set(name: string, holder: InstanceHolder): void;
-  /**
-   * Checks if a holder exists by name.
-   */
-  has(name: string): boolean;
-  addInstance(instanceName: string | InjectionToken<any, undefined>, instance: any, holder?: InstanceHolder): void;
-  clear(): void;
-  getMetadata(key: string): any | undefined;
-  setMetadata(key: string, value: any): void;
-}
-/**
- * Creates a new request context with the given parameters.
- */
-declare function createRequestContext(requestId: string, priority?: number, initialMetadata?: Record<string, any>): RequestContext;
-//#endregion
-//#region src/container/scoped-container.d.mts
-/**
- * Request-scoped dependency injection container.
- *
- * Wraps a parent Container and provides isolated request-scoped instances
- * while delegating singleton and transient resolution to the parent.
- * This design eliminates race conditions that can occur with async operations
- * when multiple requests are processed concurrently.
- */
-declare class ScopedContainer implements IContainer {
-  private readonly parent;
-  private readonly registry;
-  readonly requestId: string;
-  private readonly requestContextHolder;
-  private readonly holderStorage;
-  private disposed;
-  constructor(parent: Container, registry: Registry, requestId: string, metadata?: Record<string, any>, priority?: number);
-  /**
-   * Gets the request context holder for this scoped container.
-   */
-  getRequestContextHolder(): RequestContext;
-  /**
-   * Gets the holder storage for this scoped container.
-   * Used by InstanceResolver for request-scoped resolution.
-   */
-  getHolderStorage(): IHolderStorage;
-  /**
-   * Gets the request ID for this scoped container.
-   */
-  getRequestId(): string;
-  /**
-   * Gets the parent container.
-   */
-  getParent(): Container;
-  /**
-   * Gets metadata from the request context.
-   */
-  getMetadata(key: string): any | undefined;
-  /**
-   * Sets metadata on the request context.
-   */
-  setMetadata(key: string, value: any): void;
-  /**
-   * Adds a pre-prepared instance to the request context.
-   */
-  addInstance(token: InjectionToken<any, undefined>, instance: any): void;
-  /**
-   * Gets an instance from the container.
-   * Request-scoped services are resolved from this container's context.
-   * All other services are delegated to the parent container.
-   */
-  get<T extends ClassType>(token: T): InstanceType<T> extends Factorable<infer R> ? Promise<R> : Promise<InstanceType<T>>;
-  get<T extends ClassTypeWithArgument<R>, R>(token: T, args: R): Promise<InstanceType<T>>;
-  get<T, S extends InjectionTokenSchemaType>(token: InjectionToken<T, S>, args: z.input<S>): Promise<T>;
-  get<T, S extends InjectionTokenSchemaType, R extends boolean>(token: InjectionToken<T, S, R>): R extends false ? Promise<T> : S extends ZodType<infer Type> ? `Error: Your token requires args: ${Join<UnionToArray<keyof Type>, ', '>}` : 'Error: Your token requires args';
-  get<T>(token: InjectionToken<T, undefined>): Promise<T>;
-  get<T>(token: BoundInjectionToken<T, any>): Promise<T>;
-  get<T>(token: FactoryInjectionToken<T, any>): Promise<T>;
-  /**
-   * Invalidates a service and its dependencies.
-   * For request-scoped services, invalidation is handled within this context.
-   */
-  invalidate(service: unknown): Promise<void>;
-  /**
-   * Checks if a service is registered.
-   */
-  isRegistered(token: any): boolean;
-  /**
-   * Disposes this scoped container and cleans up all request-scoped instances.
-   * This is an alias for endRequest() for IContainer compatibility.
-   */
-  dispose(): Promise<void>;
-  /**
-   * Ends the request and cleans up all request-scoped instances.
-   * Uses the invalidation system to properly cascade to dependent singletons.
-   */
-  endRequest(): Promise<void>;
-  /**
-   * Waits for all pending operations to complete.
-   */
-  ready(): Promise<void>;
-  /**
-   * @internal
-   * Attempts to get an instance synchronously if it already exists and is ready.
-   * For request-scoped services, checks this container's context first.
-   * For other services, delegates to the parent container.
-   *
-   * Returns null if the instance doesn't exist or is not yet ready (still creating).
-   */
-  tryGetSync<T>(token: any, args?: any): T | null;
-  /**
-   * Checks if a token is for a request-scoped service.
-   */
-  private isRequestScoped;
-  /**
-   * Resolves a request-scoped service from this container's context.
-   * Uses locking to prevent duplicate initialization during concurrent resolution.
-   */
-  private resolveRequestScoped;
-  /**
-   * Stores an instance in the request context.
-   * Called by Container during request-scoped service resolution.
-   */
-  storeRequestInstance(instanceName: string, instance: any, holder: InstanceHolder): void;
-  /**
-   * Gets an existing instance from the request context.
-   * Called by Container during resolution to check for existing instances.
-   */
-  getRequestInstance(instanceName: string): InstanceHolder | undefined;
-  /**
-   * Generates a prefixed event name for request-scoped services.
-   * Format: {requestId}:{instanceName}
-   */
-  getPrefixedEventName(instanceName: string): string;
-}
-//#endregion
-//#region src/internal/lifecycle/lifecycle-event-bus.d.mts
-/**
- * Event bus for service lifecycle events (create, destroy, etc.).
- *
- * Enables loose coupling between services by allowing them to subscribe
- * to lifecycle events of their dependencies without direct references.
- * Used primarily for invalidation cascading.
- */
-declare class LifecycleEventBus {
-  private readonly logger;
-  private listeners;
-  constructor(logger?: Console | null);
-  on<Event extends string | `pre:${string}` | `post:${string}`>(ns: string, event: Event, listener: (event: Event) => void): () => void;
-  emit(key: string, event: string): Promise<PromiseSettledResult<any>[] | undefined>;
-}
-//#endregion
-//#region src/internal/holder/holder-manager.d.mts
-/**
- * Manages the storage and retrieval of singleton instance holders.
- *
- * Provides CRUD operations and filtering for the holder map.
- * Handles holder state validation (destroying, error states) on retrieval.
- */
-declare class HolderManager extends BaseHolderManager {
-  constructor(logger?: Console | null);
-  get(name: string): [DIError, InstanceHolder] | [DIError] | [undefined, InstanceHolder];
-  set(name: string, holder: InstanceHolder): void;
-  has(name: string): [DIError] | [undefined, boolean];
-  /**
-   * Creates a new holder with Created status and stores it.
-   * This is useful for creating holders that already have their instance ready.
-   * @param name The name of the instance
-   * @param instance The actual instance to store
-   * @param type The injectable type
-   * @param scope The injectable scope
-   * @param deps Optional set of dependencies
-   * @returns The created holder
-   */
-  storeCreatedHolder<Instance>(name: string, instance: Instance, type: InjectableType, scope: InjectableScope, deps?: Set<string>): InstanceHolder<Instance>;
-}
-//#endregion
-//#region src/internal/core/invalidator.d.mts
-interface ClearAllOptions {
-  /** Maximum number of invalidation rounds to prevent infinite loops (default: 10) */
-  maxRounds?: number;
-  /** Whether to wait for all services to settle before starting (default: true) */
-  waitForSettlement?: boolean;
-}
-interface InvalidationOptions {
-  /** Whether to emit events after invalidation (default: true for singletons) */
-  emitEvents?: boolean;
-  /** Custom event emitter function */
-  onInvalidated?: (instanceName: string) => Promise<void>;
-  /** Whether to cascade invalidation to dependents (default: true) */
-  cascade?: boolean;
-  /** Internal: tracks services being invalidated in the current call chain to prevent circular loops */
-  _invalidating?: Set<string>;
-}
-/**
- * Manages graceful service cleanup with dependency-aware invalidation.
- *
- * Ensures services are destroyed in the correct order based on their dependencies.
- * Works with any IHolderStorage implementation, enabling unified invalidation
- * for both singleton and request-scoped services.
- */
-declare class Invalidator {
-  private readonly eventBus;
-  private readonly logger;
-  private readonly storage;
-  constructor(manager: HolderManager, eventBus: LifecycleEventBus | null, logger?: Console | null);
-  /**
-   * Invalidates a service and all its dependencies.
-   * Works with the configured storage (singleton by default).
-   */
-  invalidate(service: string, round?: number): Promise<any>;
-  /**
-   * Invalidates a service using a specific storage.
-   * This allows request-scoped invalidation using a RequestStorage.
-   *
-   * @param service The instance name to invalidate
-   * @param storage The storage to use for this invalidation
-   * @param round Current invalidation round (for recursion limiting)
-   * @param options Additional options for invalidation behavior
-   */
-  invalidateWithStorage(service: string, storage: IHolderStorage, round?: number, options?: InvalidationOptions): Promise<void>;
-  /**
-   * Gracefully clears all services using invalidation logic.
-   * This method respects service dependencies and ensures proper cleanup order.
-   * Services that depend on others will be invalidated first, then their dependencies.
-   */
-  clearAll(options?: ClearAllOptions): Promise<void>;
-  /**
-   * Gracefully clears all services in a specific storage.
-   * This allows clearing request-scoped services using a RequestStorage.
-   */
-  clearAllWithStorage(storage: IHolderStorage, options?: ClearAllOptions): Promise<void>;
-  /**
-   * Waits for all services to settle (either created, destroyed, or error state).
-   */
-  ready(): Promise<void>;
-  /**
-   * Waits for all services in a specific storage to settle.
-   */
-  readyWithStorage(storage: IHolderStorage): Promise<void>;
-  /**
-   * Invalidates a single holder using a specific storage.
-   */
-  private invalidateHolderWithStorage;
-  /**
-   * Common invalidation logic for holders based on their status.
-   */
-  private invalidateHolderByStatus;
-  /**
-   * Destroys a holder using a specific storage.
-   */
-  private destroyHolderWithStorage;
-  /**
-   * Waits for a holder to settle (either created, destroyed, or error state).
-   */
-  private waitForHolderToSettle;
-  /**
-   * Clears services with dependency awareness for a specific storage.
-   */
-  private clearServicesWithDependencyAwarenessForStorage;
-  /**
-   * Finds services that are ready to be cleared in the current round.
-   * A service is ready if all its dependencies have already been cleared.
-   */
-  private findServicesReadyForClearingInStorage;
-  /**
-   * Force clears services that couldn't be cleared through normal dependency resolution.
-   * This handles edge cases like circular dependencies.
-   */
-  private forceClearServicesInStorage;
-  /**
-   * Emits events to listeners for instance lifecycle events.
-   */
-  private emitInstanceEvent;
-}
-//#endregion
-//#region src/internal/core/token-processor.d.mts
-/**
- * Handles token validation, normalization, and instance name generation.
- *
- * Provides utilities for resolving tokens to their underlying InjectionToken,
- * validating arguments against schemas, and generating unique instance identifiers.
- */
-declare class TokenProcessor {
-  private readonly logger;
-  constructor(logger?: Console | null);
-  /**
-   * Normalizes a token to an InjectionToken.
-   * Handles class constructors by getting their injectable token.
-   *
-   * @param token A class constructor, InjectionToken, BoundInjectionToken, or FactoryInjectionToken
-   * @returns The normalized InjectionTokenType
-   */
-  normalizeToken(token: AnyInjectableType): InjectionTokenType;
-  /**
-   * Gets the underlying "real" token from wrapped tokens.
-   * For BoundInjectionToken and FactoryInjectionToken, returns the wrapped token.
-   * For other tokens, returns the token itself.
-   *
-   * @param token The token to unwrap
-   * @returns The underlying InjectionToken
-   */
-  getRealToken<T = unknown>(token: InjectionTokenType): InjectionToken<T>;
-  /**
-   * Convenience method that normalizes a token and then gets the real token.
-   * Useful for checking registry entries where you need the actual registered token.
-   *
-   * @param token Any injectable type
-   * @returns The underlying InjectionToken
-   */
-  getRegistryToken<T = unknown>(token: AnyInjectableType): InjectionToken<T>;
-  /**
-   * Validates and resolves token arguments, handling factory token resolution and validation.
-   */
-  validateAndResolveTokenArgs(token: AnyInjectableType, args?: any): [DIError | undefined, {
-    actualToken: InjectionTokenType;
-    validatedArgs?: any;
-  }];
-  /**
-   * Generates a unique instance name based on token and arguments.
-   */
-  generateInstanceName(token: InjectionTokenType, args: any): string;
-  /**
-   * Formats a single argument value for instance name generation.
-   */
-  formatArgValue(value: any): string;
-  /**
-   * Creates a factory context for dependency injection during service instantiation.
-   * @param container The container instance (Container or ScopedContainer) for dependency resolution
-   * @param onDependencyResolved Callback when a dependency is resolved, receives the instance name
-   */
-  createFactoryContext(container: IContainer, onDependencyResolved?: (instanceName: string) => void): FactoryContext & {
-    getDestroyListeners: () => (() => void)[];
-    deps: Set<string>;
-  };
-}
-//#endregion
-//#region src/internal/core/service-locator.d.mts
-/**
- * Core DI engine that coordinates service instantiation, resolution, and lifecycle.
- *
- * Acts as the central orchestrator for dependency injection operations,
- * delegating to specialized components (InstanceResolver, Instantiator, Invalidator)
- * for specific tasks.
- */
-declare class ServiceLocator {
-  private readonly registry;
-  private readonly logger;
-  private readonly injectors;
-  private readonly eventBus;
-  private readonly manager;
-  private readonly instantiator;
-  private readonly tokenProcessor;
-  private readonly invalidator;
-  private readonly instanceResolver;
-  constructor(registry?: Registry, logger?: Console | null, injectors?: Injectors);
-  getEventBus(): LifecycleEventBus;
-  getManager(): HolderManager;
-  getInvalidator(): Invalidator;
-  getTokenProcessor(): TokenProcessor;
-  getInstanceIdentifier(token: AnyInjectableType, args?: any): string;
-  /**
-   * Gets or creates an instance for the given token.
-   * @param token The injection token
-   * @param args Optional arguments
-   * @param contextContainer The container to use for creating FactoryContext
-   */
-  getInstance(token: AnyInjectableType, args: any, contextContainer: IContainer): Promise<any[]>;
-  /**
-   * Gets or throws an instance for the given token.
-   * @param token The injection token
-   * @param args Optional arguments
-   * @param contextContainer The container to use for creating FactoryContext
-   */
-  getOrThrowInstance<Instance>(token: AnyInjectableType, args: any, contextContainer: IContainer): Promise<Instance>;
-  /**
-   * Resolves a request-scoped service for a ScopedContainer.
-   * The service will be stored in the ScopedContainer's request context.
-   *
-   * @param token The injection token
-   * @param args Optional arguments
-   * @param scopedContainer The ScopedContainer that owns the request context
-   */
-  resolveRequestScoped(token: AnyInjectableType, args: any, scopedContainer: ScopedContainer): Promise<any>;
-  getSyncInstance<Instance, Schema extends InjectionTokenSchemaType | undefined>(token: AnyInjectableType, args: Schema extends ZodObject ? z.input<Schema> : Schema extends ZodOptional<ZodObject> ? z.input<Schema> | undefined : undefined, contextContainer: IContainer): Instance | null;
-  invalidate(service: string, round?: number): Promise<any>;
-  /**
-   * Gracefully clears all services in the ServiceLocator using invalidation logic.
-   * This method respects service dependencies and ensures proper cleanup order.
-   * Services that depend on others will be invalidated first, then their dependencies.
-   *
-   * @param options Optional configuration for the clearing process
-   * @returns Promise that resolves when all services have been cleared
-   */
-  clearAll(options?: ClearAllOptions): Promise<void>;
-  /**
-   * Waits for all services to settle (either created, destroyed, or error state).
-   */
-  ready(): Promise<void>;
-  /**
-   * Helper method for InstanceResolver to generate instance names.
-   * This is needed for the factory context creation.
-   */
-  generateInstanceName(token: any, args: any): string;
-}
-//#endregion
-//#region src/container/container.d.mts
-/**
- * Main dependency injection container.
- *
- * Provides a simplified public API for dependency injection, wrapping
- * a ServiceLocator instance. Handles singleton and transient services directly,
- * while request-scoped services require using beginRequest() to create a ScopedContainer.
- */
-declare class Container implements IContainer {
-  protected readonly registry: Registry;
-  protected readonly logger: Console | null;
-  protected readonly injectors: Injectors;
-  private readonly serviceLocator;
-  private readonly activeRequestIds;
-  constructor(registry?: Registry, logger?: Console | null, injectors?: Injectors);
-  private registerSelf;
-  /**
-   * Gets an instance from the container.
-   * This method has the same type signature as the inject method from get-injectors.mts
-   *
-   * NOTE: Request-scoped services cannot be resolved directly from Container.
-   * Use beginRequest() to create a ScopedContainer for request-scoped services.
-   */
-  get<T extends ClassType>(token: T): InstanceType<T> extends Factorable<infer R> ? Promise<R> : Promise<InstanceType<T>>;
-  get<T extends ClassTypeWithArgument<R>, R>(token: T, args: R): Promise<InstanceType<T>>;
-  get<T, S extends InjectionTokenSchemaType>(token: InjectionToken<T, S>, args: z.input<S>): Promise<T>;
-  get<T, S extends InjectionTokenSchemaType, R extends boolean>(token: InjectionToken<T, S, R>): R extends false ? Promise<T> : S extends ZodType<infer Type> ? `Error: Your token requires args: ${Join<UnionToArray<keyof Type>, ', '>}` : 'Error: Your token requires args';
-  get<T>(token: InjectionToken<T, undefined>): Promise<T>;
-  get<T>(token: BoundInjectionToken<T, any>): Promise<T>;
-  get<T>(token: FactoryInjectionToken<T, any>): Promise<T>;
-  /**
-   * Gets an instance with a specific container context.
-   * Used by ScopedContainer to delegate singleton/transient resolution
-   * while maintaining the correct container context for nested inject() calls.
-   *
-   * @internal
-   */
-  getWithContext(token: ClassType | InjectionToken<any> | BoundInjectionToken<any, any> | FactoryInjectionToken<any, any>, args: unknown, contextContainer: IContainer): Promise<any>;
-  /**
-   * Resolves a request-scoped service for a ScopedContainer.
-   * The service will be stored in the ScopedContainer's request context.
-   *
-   * @internal
-   */
-  resolveForRequest(token: ClassType | InjectionToken<any> | BoundInjectionToken<any, any> | FactoryInjectionToken<any, any>, args: unknown, scopedContainer: ScopedContainer): Promise<any>;
-  /**
-   * Gets the underlying ServiceLocator instance for advanced usage
-   */
-  getServiceLocator(): ServiceLocator;
-  /**
-   * Gets the registry
-   */
-  getRegistry(): Registry;
-  /**
-   * Invalidates a service and its dependencies
-   */
-  invalidate(service: unknown): Promise<void>;
-  /**
-   * Gets a service holder by instance (reverse lookup)
-   */
-  private getHolderByInstance;
-  /**
-   * Checks if a service is registered in the container
-   */
-  isRegistered(token: any): boolean;
-  /**
-   * Disposes the container and cleans up all resources
-   */
-  dispose(): Promise<void>;
-  /**
-   * Waits for all pending operations to complete
-   */
-  ready(): Promise<void>;
-  /**
-   * @internal
-   * Attempts to get an instance synchronously if it already exists.
-   * Returns null if the instance doesn't exist or is not ready.
-   */
-  tryGetSync<T>(token: any, args?: any): T | null;
-  /**
-   * Begins a new request context and returns a ScopedContainer.
-   *
-   * The ScopedContainer provides isolated request-scoped service resolution
-   * while delegating singleton and transient services to this Container.
-   *
-   * @param requestId Unique identifier for this request
-   * @param metadata Optional metadata for the request
-   * @param priority Priority for resolution (higher = more priority)
-   * @returns A ScopedContainer for this request
-   */
-  beginRequest(requestId: string, metadata?: Record<string, any>, priority?: number): ScopedContainer;
-  /**
-   * Removes a request ID from the active set.
-   * Called by ScopedContainer when the request ends.
-   *
-   * @internal
-   */
-  removeActiveRequest(requestId: string): void;
-  /**
-   * Gets the set of active request IDs.
-   */
-  getActiveRequestIds(): ReadonlySet<string>;
-  /**
-   * Checks if a request ID is currently active.
-   */
-  hasActiveRequest(requestId: string): boolean;
-  /**
-   * Clears all instances and bindings from the container.
-   * This is useful for testing or resetting the container state.
-   */
-  clear(): Promise<void>;
-}
-//#endregion
-//#region src/interfaces/on-service-init.interface.d.mts
-interface OnServiceInit {
-  onServiceInit(): Promise<void> | void;
-}
-//#endregion
-//#region src/interfaces/on-service-destroy.interface.d.mts
-interface OnServiceDestroy {
-  onServiceDestroy(): Promise<void> | void;
-}
-//#endregion
-//#region src/decorators/factory.decorator.d.mts
-interface FactoryOptions {
-  scope?: InjectableScope;
-  token?: InjectionToken<any, any>;
-  registry?: Registry;
-}
-declare function Factory<R>(options?: {
-  scope?: InjectableScope;
-  registry?: Registry;
-}): <T extends ClassTypeWithInstance<Factorable<R>>>(target: T, context?: ClassDecoratorContext) => T;
-declare function Factory<R, S>(options: {
-  scope?: InjectableScope;
-  token: InjectionToken<R, S>;
-  registry?: Registry;
-}): R extends undefined ? never : S extends InjectionTokenSchemaType ? <T extends ClassTypeWithInstance<FactorableWithArgs<R, S>>>(
-// #2.2.1 Token have a schema
-target: T, context?: ClassDecoratorContext) => T : S extends undefined ? <T extends ClassTypeWithInstance<Factorable<R>>>(
-// #2.3.1 Token without a schema
-target: T, context?: ClassDecoratorContext) => T : never;
-//#endregion
-//#region src/decorators/injectable.decorator.d.mts
-interface InjectableOptions {
-  scope?: InjectableScope;
-  token?: InjectionToken<any, any>;
-  schema?: InjectionTokenSchemaType;
-  registry?: Registry;
-}
-declare function Injectable(): <T extends ClassTypeWithoutArguments>(target: T, context?: ClassDecoratorContext) => T;
-declare function Injectable(options: {
-  scope?: InjectableScope;
-  registry: Registry;
-}): <T extends ClassTypeWithoutArguments>(target: T, context?: ClassDecoratorContext) => T;
-declare function Injectable(options: {
-  scope: InjectableScope;
-}): <T extends ClassTypeWithoutArguments>(target: T, context?: ClassDecoratorContext) => T;
-declare function Injectable<Schema extends InjectionTokenSchemaType>(options: {
-  scope?: InjectableScope;
-  schema: Schema;
-  registry?: Registry;
-}): <T extends ClassTypeWithArgument<z.output<Schema>>>(target: T, context?: ClassDecoratorContext) => T;
-declare function Injectable<Type$1, Schema>(options: {
-  scope?: InjectableScope;
-  token: InjectionToken<Type$1, Schema>;
-  registry?: Registry;
-}): Schema extends BaseInjectionTokenSchemaType ? Type$1 extends undefined ? <T extends ClassTypeWithArgument<z.output<Schema>>>(
-// #3.1.1 Typeless token
-target: T, context?: ClassDecoratorContext) => T : <T extends ClassTypeWithInstanceAndArgument<Type$1, z.output<Schema>>>(
-// #3.1.2 Typed token
-target: T, context?: ClassDecoratorContext) => T : Schema extends OptionalInjectionTokenSchemaType ? Type$1 extends undefined ? <T extends ClassTypeWithOptionalArgument<z.output<Schema>>>(
-// #3.2.1 Typeless token
-target: T, context?: ClassDecoratorContext) => T : <T extends ClassTypeWithInstanceAndOptionalArgument<Type$1, z.output<Schema>>>(target: T, context?: ClassDecoratorContext) => T : Schema extends undefined ? <R extends ClassTypeWithInstance<Type$1>>(
-// #3.3.1 Token must have a type
-target: R, context?: ClassDecoratorContext) => R : never;
-//#endregion
-//#region src/symbols/injectable-token.d.mts
-declare const InjectableTokenMeta: unique symbol;
-//#endregion
-//#region src/event-emitter.d.mts
-type EventsConfig = {
-  [event: string]: any[];
-};
-type EventsNames<Events extends EventsConfig> = Exclude<keyof Events, symbol | number>;
-type EventsArgs<Events extends EventsConfig, Name extends EventsNames<Events>> = Events[Name] extends any[] ? Events[Name] : [];
-interface EventEmitterInterface<Events extends EventsConfig> {
-  on<E extends EventsNames<Events>, Args extends EventsArgs<Events, E>>(event: E, listener: (...args: Args) => void | Promise<void>): () => void;
-  emit<E extends EventsNames<Events>, Args extends EventsArgs<Events, E>>(event: E, ...args: Args): void | Promise<void>;
-}
-declare class EventEmitter<Events extends EventsConfig = {}> implements EventEmitterInterface<Events> {
-  private listeners;
-  on<E extends EventsNames<Events>, Args extends EventsArgs<Events, E>>(event: E, listener: (...args: Args) => void | Promise<void>): () => void;
-  off<E extends EventsNames<Events>, Args extends EventsArgs<Events, E>>(event: E, listener: (...args: Args) => void | Promise<void>): void;
-  once<E extends EventsNames<Events>, Args extends EventsArgs<Events, E>>(event: E, listener: (...args: Args) => void | Promise<void>): () => void;
-  emit<E extends EventsNames<Events>, Args extends EventsArgs<Events, E>>(event: E, ...args: Args): Promise<any>;
-}
-//#endregion
-//#region src/injectors.d.mts
-declare const defaultInjectors: Injectors;
-declare const asyncInject: Injectors['asyncInject'];
-declare const inject: Injectors['inject'];
-declare const optional: Injectors['optional'];
-declare const wrapSyncInit: Injectors['wrapSyncInit'];
-declare const provideFactoryContext: Injectors['provideFactoryContext'];
-//#endregion
-//#region src/internal/context/resolution-context.d.mts
-/**
- * Data stored in the resolution context during service instantiation.
- */
-interface ResolutionContextData {
-  /** The holder that is currently being instantiated */
-  waiterHolder: InstanceHolder;
-  /** Function to get a holder by name (for cycle detection) */
-  getHolder: (name: string) => InstanceHolder | undefined;
-}
-/**
- * Runs a function within a resolution context.
- *
- * The context tracks which holder is currently being instantiated,
- * allowing circular dependency detection to work correctly.
- *
- * @param waiterHolder The holder being instantiated
- * @param getHolder Function to retrieve holders by name
- * @param fn The function to run within the context
- */
-declare function withResolutionContext<T>(waiterHolder: InstanceHolder, getHolder: (name: string) => InstanceHolder | undefined, fn: () => T): T;
-/**
- * Gets the current resolution context, if any.
- *
- * Returns undefined if we're not inside a resolution context
- * (e.g., when resolving a top-level service that has no parent).
- */
-declare function getCurrentResolutionContext(): ResolutionContextData | undefined;
-/**
- * Runs a function outside any resolution context.
- *
- * This is useful for async injections that should not participate
- * in circular dependency detection since they don't block.
- *
- * @param fn The function to run without resolution context
- */
-declare function withoutResolutionContext<T>(fn: () => T): T;
-//#endregion
-//#region src/internal/holder/singleton-storage.d.mts
-/**
- * Storage implementation for Singleton-scoped services.
- *
- * Wraps a HolderManager instance and provides the IHolderStorage interface.
- * This allows the InstanceResolver to work with singleton storage
- * using the same interface as request-scoped storage.
- */
-declare class SingletonStorage implements IHolderStorage {
-  private readonly manager;
-  readonly scope = InjectableScope.Singleton;
-  constructor(manager: HolderManager);
-  get<T = unknown>(instanceName: string): HolderGetResult<T>;
-  set(instanceName: string, holder: InstanceHolder): void;
-  delete(instanceName: string): boolean;
-  createHolder<T>(instanceName: string, type: InjectableType, deps: Set<string>): [ReturnType<typeof Promise.withResolvers<[undefined, T]>>, InstanceHolder<T>];
-  handles(scope: InjectableScope): boolean;
-  getAllNames(): string[];
-  forEach(callback: (name: string, holder: InstanceHolder) => void): void;
-  findByInstance(instance: unknown): InstanceHolder | null;
-  findDependents(instanceName: string): string[];
-}
-//#endregion
-//#region src/internal/holder/request-storage.d.mts
-/**
- * Storage implementation for Request-scoped services.
- *
- * Wraps a RequestContext instance from a ScopedContainer and provides
- * the IHolderStorage interface. This allows the InstanceResolver to work
- * with request-scoped storage using the same interface as singleton storage.
- */
-declare class RequestStorage implements IHolderStorage {
-  private readonly contextHolder;
-  private readonly holderManager;
-  readonly scope = InjectableScope.Request;
-  constructor(contextHolder: RequestContext, holderManager: BaseHolderManager);
-  get<T = unknown>(instanceName: string): HolderGetResult<T>;
-  set(instanceName: string, holder: InstanceHolder): void;
-  delete(instanceName: string): boolean;
-  createHolder<T>(instanceName: string, type: InjectableType, deps: Set<string>): [ReturnType<typeof Promise.withResolvers<[undefined, T]>>, InstanceHolder<T>];
-  handles(scope: InjectableScope): boolean;
-  getAllNames(): string[];
-  forEach(callback: (name: string, holder: InstanceHolder) => void): void;
-  findByInstance(instance: unknown): InstanceHolder | null;
-  findDependents(instanceName: string): string[];
-}
-//#endregion
-//#region src/internal/lifecycle/circular-detector.d.mts
-/**
- * Detects circular dependencies by analyzing the waitingFor relationships
- * between service holders.
- *
- * Uses BFS to traverse the waitingFor graph starting from a target holder
- * and checks if following the chain leads back to the waiter, indicating a circular dependency.
- *
- * Note: In production (NODE_ENV === 'production'), detection is skipped for performance.
- */
-declare class CircularDetector {
-  /**
-   * Detects if waiting for `targetName` from `waiterName` would create a cycle.
-   *
-   * This works by checking if `targetName` (or any holder in its waitingFor chain)
-   * is currently waiting for `waiterName`. If so, waiting would create a deadlock.
-   *
-   * In production mode, this always returns null to skip the BFS traversal overhead.
-   *
-   * @param waiterName The name of the holder that wants to wait
-   * @param targetName The name of the holder being waited on
-   * @param getHolder Function to retrieve a holder by name
-   * @returns The cycle path if a cycle is detected, null otherwise
-   */
-  static detectCycle(waiterName: string, targetName: string, getHolder: (name: string) => InstanceHolder | undefined): string[] | null;
-  /**
-   * Formats a cycle path into a human-readable string.
-   *
-   * @param cycle The cycle path (array of service names)
-   * @returns Formatted string like "ServiceA -> ServiceB -> ServiceA"
-   */
-  static formatCycle(cycle: string[]): string;
-}
-//#endregion
-//#region src/internal/core/instantiator.d.mts
-/**
- * Creates service instances from registry records.
- *
- * Handles both class-based (@Injectable) and factory-based (@Factory) services,
- * managing the instantiation lifecycle including sync initialization retries
- * and lifecycle hook invocation (onServiceInit, onServiceDestroy).
- */
-declare class Instantiator {
-  private readonly injectors;
-  constructor(injectors: Injectors);
-  /**
-   * Instantiates a service based on its registry record.
-   * @param ctx The factory context for dependency injection
-   * @param record The factory record from the registry
-   * @param args Optional arguments for the service
-   * @returns Promise resolving to [undefined, instance] or [error]
-   */
-  instantiateService<T>(ctx: FactoryContext, record: FactoryRecord<T, any>, args?: any): Promise<[undefined, T] | [DIError]>;
-  /**
-   * Instantiates a class-based service (Injectable decorator).
-   * @param ctx The factory context for dependency injection
-   * @param record The factory record from the registry
-   * @param args Optional arguments for the service constructor
-   * @returns Promise resolving to [undefined, instance] or [error]
-   */
-  private instantiateClass;
-  /**
-   * Instantiates a factory-based service (Factory decorator).
-   * @param ctx The factory context for dependency injection
-   * @param record The factory record from the registry
-   * @param args Optional arguments for the factory
-   * @returns Promise resolving to [undefined, instance] or [error]
-   */
-  private instantiateFactory;
-}
-//#endregion
-//#region src/internal/core/instance-resolver.d.mts
-/**
- * Resolves instances from tokens, handling caching, creation, and scope rules.
- *
- * Uses the Storage Strategy pattern for unified singleton/request-scoped handling.
- * Coordinates with Instantiator for actual service creation.
- */
-declare class InstanceResolver {
-  private readonly registry;
-  private readonly manager;
-  private readonly instantiator;
-  private readonly tokenProcessor;
-  private readonly logger;
-  private readonly serviceLocator;
-  private readonly singletonStorage;
-  constructor(registry: Registry, manager: HolderManager, instantiator: Instantiator, tokenProcessor: TokenProcessor, logger: (Console | null) | undefined, serviceLocator: ServiceLocator);
-  /**
-   * Resolves an instance for the given token and arguments.
-   * This method is used for singleton and transient services.
-   *
-   * @param token The injection token
-   * @param args Optional arguments
-   * @param contextContainer The container to use for creating FactoryContext
-   */
-  resolveInstance(token: AnyInjectableType, args: any, contextContainer: IContainer): Promise<[undefined, any] | [DIError]>;
-  /**
-   * Resolves a request-scoped instance for a ScopedContainer.
-   * The service will be stored in the ScopedContainer's request context.
-   *
-   * @param token The injection token
-   * @param args Optional arguments
-   * @param scopedContainer The ScopedContainer that owns the request context
-   */
-  resolveRequestScopedInstance(token: AnyInjectableType, args: any, scopedContainer: ScopedContainer): Promise<[undefined, any] | [DIError]>;
-  /**
-   * Unified resolution method that works with any IHolderStorage.
-   * This eliminates duplication between singleton and request-scoped resolution.
-   *
-   * IMPORTANT: The check-and-store logic is carefully designed to avoid race conditions.
-   * The storage check and holder creation must happen synchronously (no awaits between).
-   *
-   * @param token The injection token
-   * @param args Optional arguments
-   * @param contextContainer The container for FactoryContext
-   * @param storage The storage strategy to use
-   * @param scopedContainer Optional scoped container for request-scoped services
-   */
-  private resolveWithStorage;
-  /**
-   * Handles storage error states (destroying, error, etc.).
-   * Returns a result if handled, null if should proceed with creation.
-   */
-  private handleStorageError;
-  /**
-   * Creates a new instance and stores it using the provided storage strategy.
-   * This unified method replaces instantiateServiceFromRegistry and createRequestScopedInstance.
-   *
-   * For transient services, the instance is created but not stored (no caching).
-   */
-  private createAndStoreInstance;
-  /**
-   * Creates a transient instance without storage or locking.
-   * Each call creates a new instance.
-   */
-  private createTransientInstance;
-  /**
-   * Gets a synchronous instance (for sync operations).
-   */
-  getSyncInstance<Instance, Schema extends InjectionTokenSchemaType | undefined>(token: AnyInjectableType, args: Schema extends ZodObject ? z.input<Schema> : Schema extends ZodOptional<ZodObject> ? z.input<Schema> | undefined : undefined, contextContainer: IContainer): Instance | null;
-  /**
-   * Internal method to resolve token args and create instance name.
-   * Handles factory token resolution and validation.
-   */
-  private resolveTokenAndPrepareInstanceName;
-  /**
-   * Waits for an instance holder to be ready and returns the appropriate result.
-   * Uses the shared utility from BaseHolderManager.
-   * Passes the current resolution context for circular dependency detection.
-   */
-  private waitForInstanceReady;
-  /**
-   * Handles the result of service instantiation.
-   */
-  private handleInstantiationResult;
-  /**
-   * Handles successful service instantiation.
-   */
-  private handleInstantiationSuccess;
-  /**
-   * Handles service instantiation errors.
-   */
-  private handleInstantiationError;
-  /**
-   * Creates a factory context for dependency injection during service instantiation.
-   */
-  private createFactoryContext;
-}
-//#endregion
-export { type AnyInjectableType, BaseHolderManager, BoundInjectionToken, CircularDetector, type ClassType, type ClassTypeWithArgument, type ClassTypeWithInstance, type ClassTypeWithInstanceAndArgument, type ClassTypeWithInstanceAndOptionalArgument, type ClassTypeWithOptionalArgument, type ClassTypeWithoutArguments, Container, DIError, DIErrorCode, DefaultRequestContext, EventEmitter, Factorable, FactorableWithArgs, Factory, type FactoryContext, FactoryInjectionToken, FactoryOptions, type FactoryRecord, type HolderGetResult, HolderManager, type HolderReadyResult, IContainer, type IHolderStorage, InjectRequest, InjectState, Injectable, InjectableOptions, InjectableScope, InjectableTokenMeta, InjectableType, InjectionToken, type InjectionTokenSchemaType, type InjectionTokenType, Injectors, type InstanceDestroyListener, type InstanceEffect, type InstanceHolder, type InstanceHolderCreated, type InstanceHolderCreating, type InstanceHolderDestroying, type InstanceHolderError, InstanceResolver, InstanceStatus, Instantiator, Invalidator, IsUnion, Join, LifecycleEventBus, OnServiceDestroy, OnServiceInit, PopUnion, Registry, type RequestContext, type RequestContextHolder, RequestStorage, type ResolutionContextData, ScopedContainer, ServiceLocator, SingletonStorage, TokenProcessor, UnionToArray, UnionToIntersection, UnionToOvlds, asyncInject, createRequestContext, defaultInjectors, getCurrentResolutionContext, getInjectableToken, getInjectors, globalRegistry, inject, optional, provideFactoryContext, withResolutionContext, withoutResolutionContext, wrapSyncInit };
-//# sourceMappingURL=index.d.mts.map
+import { AnyInjectableType, BaseInjectionTokenSchemaType, BoundInjectionToken, ClassType, ClassTypeWithArgument, ClassTypeWithInstance, ClassTypeWithInstanceAndArgument, ClassTypeWithInstanceAndOptionalArgument, ClassTypeWithOptionalArgument, ClassTypeWithoutArguments, FactoryInjectionToken, InjectionToken, InjectionTokenSchemaType, InjectionTokenType, OptionalInjectionTokenSchemaType } from "./token/injection-token.mjs";
+import { InjectRequest, InjectState, IsUnion, Join, PopUnion, UnionToArray, UnionToIntersection, UnionToOvlds } from "./utils/types.mjs";
+import { IContainer } from "./interfaces/container.interface.mjs";
+import { InjectableScope } from "./enums/injectable-scope.enum.mjs";
+import { InjectableType } from "./enums/injectable-type.enum.mjs";
+import { ServiceInitializationContext } from "./internal/context/service-initialization-context.mjs";
+import { Injectors, getInjectors } from "./utils/get-injectors.mjs";
+import { asyncInject, defaultInjectors, inject, optional, provideFactoryContext, wrapSyncInit } from "./utils/default-injectors.mjs";
+import { getInjectableToken } from "./utils/get-injectable-token.mjs";
+import { FactoryContext } from "./internal/context/factory-context.mjs";
+import { Factorable, FactorableWithArgs } from "./interfaces/factory.interface.mjs";
+import { FactoryRecord, Registry, globalRegistry } from "./token/registry.mjs";
+import { NameResolver } from "./internal/core/name-resolver.mjs";
+import { DIError, DIErrorCode } from "./errors/di-error.mjs";
+import { InstanceDestroyListener, InstanceHolder, InstanceHolderCreated, InstanceHolderCreating, InstanceHolderDestroying, InstanceHolderError, InstanceStatus } from "./internal/holder/instance-holder.mjs";
+import { HolderGetResult, IHolderStorage } from "./internal/holder/holder-storage.interface.mjs";
+import { LifecycleEventBus } from "./internal/lifecycle/lifecycle-event-bus.mjs";
+import { ClearAllOptions, InvalidationOptions, ServiceInvalidator } from "./internal/core/service-invalidator.mjs";
+import { TokenResolver } from "./internal/core/token-resolver.mjs";
+import { UnifiedStorage } from "./internal/holder/unified-storage.mjs";
+import { ScopedContainer } from "./container/scoped-container.mjs";
+import { ScopeTracker } from "./internal/core/scope-tracker.mjs";
+import { ServiceInitializer } from "./internal/core/service-initializer.mjs";
+import { InstanceResolver } from "./internal/core/instance-resolver.mjs";
+import { Container } from "./container/container.mjs";
+import { OnServiceDestroy } from "./interfaces/on-service-destroy.interface.mjs";
+import { OnServiceInit } from "./interfaces/on-service-init.interface.mjs";
+import { Factory, FactoryOptions } from "./decorators/factory.decorator.mjs";
+import { Injectable, InjectableOptions } from "./decorators/injectable.decorator.mjs";
+import { IAsyncLocalStorage } from "./internal/context/async-local-storage.types.mjs";
+import { createAsyncLocalStorage, isUsingNativeAsyncLocalStorage } from "./internal/context/async-local-storage.mjs";
+import { ResolutionContextData, getCurrentResolutionContext, withResolutionContext, withoutResolutionContext } from "./internal/context/resolution-context.mjs";
+import { CircularDetector } from "./internal/lifecycle/circular-detector.mjs";
+import { StubFactoryClass } from "./internal/stub-factory-class.mjs";
+import { InjectableTokenMeta } from "./symbols/injectable-token.mjs";
+import { EventEmitter, EventsArgs, EventsConfig, EventsNames } from "./event-emitter.mjs";
+export { AnyInjectableType, BaseInjectionTokenSchemaType, BoundInjectionToken, CircularDetector, ClassType, ClassTypeWithArgument, ClassTypeWithInstance, ClassTypeWithInstanceAndArgument, ClassTypeWithInstanceAndOptionalArgument, ClassTypeWithOptionalArgument, ClassTypeWithoutArguments, ClearAllOptions, Container, DIError, DIErrorCode, EventEmitter, EventsArgs, EventsConfig, EventsNames, Factorable, FactorableWithArgs, Factory, FactoryContext, FactoryInjectionToken, FactoryOptions, FactoryRecord, HolderGetResult, IAsyncLocalStorage, IContainer, IHolderStorage, InjectRequest, InjectState, Injectable, InjectableOptions, InjectableScope, InjectableTokenMeta, InjectableType, InjectionToken, InjectionTokenSchemaType, InjectionTokenType, Injectors, InstanceDestroyListener, InstanceHolder, InstanceHolderCreated, InstanceHolderCreating, InstanceHolderDestroying, InstanceHolderError, InstanceResolver, InstanceStatus, InvalidationOptions, IsUnion, Join, LifecycleEventBus, NameResolver, OnServiceDestroy, OnServiceInit, OptionalInjectionTokenSchemaType, PopUnion, Registry, ResolutionContextData, ScopeTracker, ScopedContainer, ServiceInitializationContext, ServiceInitializer, ServiceInvalidator, StubFactoryClass, TokenResolver, UnifiedStorage, UnionToArray, UnionToIntersection, UnionToOvlds, asyncInject, createAsyncLocalStorage, defaultInjectors, getCurrentResolutionContext, getInjectableToken, getInjectors, globalRegistry, inject, isUsingNativeAsyncLocalStorage, optional, provideFactoryContext, withResolutionContext, withoutResolutionContext, wrapSyncInit };