@navios/di 0.7.1 → 0.9.0

package/lib/browser/internal/core/service-invalidator.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"service-invalidator.mjs","names":["InstanceStatus","ServiceInvalidator","eventBus","logger","invalidateWithStorage","service","storage","options","emitEvents","onInvalidated","log","result","get","holder","invalidateHolderWithStorage","setupDependencySubscriptions","serviceName","dependencies","dependencyName","unsubscribe","on","catch","error","destroyListeners","push","clearAllWithStorage","waitForSettlement","readyWithStorage","allServiceNames","getAllNames","length","join","clearPromises","map","Promise","all","holders","forEach","_","waitForHolderToSettle","key","invalidateHolderByStatus","context","onDestroy","destroyHolderWithStorage","status","Destroying","destroyPromise","Creating","creationPromise","listener","then","deps","clear","delete","emitInstanceEvent","Created","Error","name","event","resolve","emit"],"sources":["../../../../src/internal/core/service-invalidator.mts"],"sourcesContent":["import type { IHolderStorage } from '../holder/holder-storage.interface.mjs'\nimport type { InstanceHolder } from '../holder/instance-holder.mjs'\nimport type { LifecycleEventBus } from '../lifecycle/lifecycle-event-bus.mjs'\n\nimport { InstanceStatus } from '../holder/instance-holder.mjs'\n\nexport interface ClearAllOptions {\n  /** Whether to wait for all services to settle before starting (default: true) */\n  waitForSettlement?: boolean\n}\n\nexport interface InvalidationOptions {\n  /** Whether to emit events after invalidation (default: true) */\n  emitEvents?: boolean\n  /** Custom event emitter function */\n  onInvalidated?: (instanceName: string) => Promise<void>\n  /** Whether to cascade invalidation to dependents (default: false - events handle it) */\n  cascade?: boolean\n}\n\n/**\n * Manages graceful service cleanup with event-based invalidation.\n *\n * Uses event subscriptions instead of manual dependent finding.\n * When a service is created, it subscribes to destroy events of its dependencies.\n * When a dependency is destroyed, the event automatically invalidates dependents.\n */\nexport class ServiceInvalidator {\n  constructor(\n    private readonly eventBus: LifecycleEventBus | null,\n    private readonly logger: Console | null = null,\n  ) {}\n\n  /**\n   * Invalidates a service using a specific storage.\n   * Event-based invalidation means dependents are automatically invalidated\n   * via destroy event subscriptions - no need to manually find dependents.\n   *\n   * @param service The instance name to invalidate\n   * @param storage The storage to use for this invalidation\n   * @param options Additional options for invalidation behavior\n   */\n  async invalidateWithStorage(\n    service: string,\n    storage: IHolderStorage,\n    options: InvalidationOptions = {},\n  ): Promise<void> {\n    const { emitEvents = true, onInvalidated } = options\n\n    this.logger?.log(\n      `[ServiceInvalidator] Starting invalidation process for ${service}`,\n    )\n\n    const result = storage.get(service)\n    if (result === null) {\n      return\n    }\n\n    const [, holder] = result\n    if (holder) {\n      await this.invalidateHolderWithStorage(\n        service,\n        holder,\n        storage,\n        emitEvents,\n        onInvalidated,\n      )\n    }\n  }\n\n  /**\n   * Sets up destroy event subscriptions for a service's dependencies.\n   * Called when a service is successfully instantiated.\n   *\n   * @param serviceName The name of the service\n   * @param dependencies The set of dependency names\n   * @param storage The storage to use for invalidation\n   * @param holder The holder for the service (to add unsubscribe to destroy listeners)\n   */\n  setupDependencySubscriptions(\n    serviceName: string,\n    dependencies: Set<string>,\n    storage: IHolderStorage,\n    holder: InstanceHolder,\n  ): void {\n    if (!this.eventBus) {\n      return\n    }\n\n    for (const dependencyName of dependencies) {\n      // Subscribe to the dependency's destroy event\n      const unsubscribe = this.eventBus.on(dependencyName, 'destroy', () => {\n        this.logger?.log(\n          `[ServiceInvalidator] Dependency ${dependencyName} destroyed, invalidating ${serviceName}`,\n        )\n        // Automatically invalidate this service when dependency is destroyed\n        this.invalidateWithStorage(serviceName, storage).catch((error) => {\n          this.logger?.error(\n            `[ServiceInvalidator] Error invalidating ${serviceName} after dependency ${dependencyName} destroyed:`,\n            error,\n          )\n        })\n      })\n\n      // Store unsubscribe function in the service's destroy listeners\n      // so it's cleaned up when the service is destroyed\n      holder.destroyListeners.push(unsubscribe)\n    }\n  }\n\n  /**\n   * Gracefully clears all services in a specific storage.\n   * This allows clearing request-scoped services using a RequestStorage.\n   */\n  async clearAllWithStorage(\n    storage: IHolderStorage,\n    options: ClearAllOptions = {},\n  ): Promise<void> {\n    const { waitForSettlement = true } = options\n\n    this.logger?.log(\n      '[ServiceInvalidator] Starting graceful clearing of all services',\n    )\n\n    // Wait for all services to settle if requested\n    if (waitForSettlement) {\n      this.logger?.log(\n        '[ServiceInvalidator] Waiting for all services to settle...',\n      )\n      await this.readyWithStorage(storage)\n    }\n\n    // Get all service names that need to be cleared\n    const allServiceNames = storage.getAllNames()\n\n    if (allServiceNames.length === 0) {\n      this.logger?.log('[ServiceInvalidator] No services to clear')\n    } else {\n      this.logger?.log(\n        `[ServiceInvalidator] Found ${allServiceNames.length} services to clear: ${allServiceNames.join(', ')}`,\n      )\n\n      // Clear services - events will handle dependent invalidation\n      const clearPromises = allServiceNames.map((serviceName) =>\n        this.invalidateWithStorage(serviceName, storage),\n      )\n\n      await Promise.all(clearPromises)\n    }\n\n    this.logger?.log('[ServiceInvalidator] Graceful clearing completed')\n  }\n\n  /**\n   * Waits for all services in a specific storage to settle.\n   */\n  async readyWithStorage(storage: IHolderStorage): Promise<void> {\n    const holders: InstanceHolder<any>[] = []\n    storage.forEach((_: string, holder: InstanceHolder) => holders.push(holder))\n    await Promise.all(\n      holders.map((holder) => this.waitForHolderToSettle(holder)),\n    )\n  }\n\n  // ============================================================================\n  // INTERNAL INVALIDATION HELPERS\n  // ============================================================================\n\n  /**\n   * Invalidates a single holder using a specific storage.\n   */\n  private async invalidateHolderWithStorage(\n    key: string,\n    holder: InstanceHolder<any>,\n    storage: IHolderStorage,\n    emitEvents: boolean,\n    onInvalidated?: (instanceName: string) => Promise<void>,\n  ): Promise<void> {\n    await this.invalidateHolderByStatus(holder, {\n      context: key,\n      onDestroy: () =>\n        this.destroyHolderWithStorage(\n          key,\n          holder,\n          storage,\n          emitEvents,\n          onInvalidated,\n        ),\n    })\n  }\n\n  /**\n   * Common invalidation logic for holders based on their status.\n   */\n  private async invalidateHolderByStatus(\n    holder: InstanceHolder<any>,\n    options: {\n      context: string\n      onDestroy: () => Promise<void>\n    },\n  ): Promise<void> {\n    switch (holder.status) {\n      case InstanceStatus.Destroying:\n        await holder.destroyPromise\n        break\n\n      case InstanceStatus.Creating:\n        // Wait for creation to complete before destroying\n        await holder.creationPromise\n        await options.onDestroy()\n        break\n\n      default:\n        await options.onDestroy()\n        break\n    }\n  }\n\n  /**\n   * Destroys a holder using a specific storage.\n   */\n  private async destroyHolderWithStorage(\n    key: string,\n    holder: InstanceHolder<any>,\n    storage: IHolderStorage,\n    emitEvents: boolean,\n    onInvalidated?: (instanceName: string) => Promise<void>,\n  ): Promise<void> {\n    holder.status = InstanceStatus.Destroying\n    this.logger?.log(\n      `[ServiceInvalidator] Invalidating ${key} and notifying listeners`,\n    )\n\n    holder.destroyPromise = Promise.all(\n      holder.destroyListeners.map((listener) => listener()),\n    ).then(async () => {\n      holder.destroyListeners = []\n      holder.deps.clear()\n      storage.delete(key)\n\n      // Emit events if enabled and event bus exists\n      if (emitEvents && this.eventBus) {\n        await this.emitInstanceEvent(key, 'destroy')\n      }\n\n      // Call custom callback if provided\n      if (onInvalidated) {\n        await onInvalidated(key)\n      }\n    })\n\n    await holder.destroyPromise\n  }\n\n  /**\n   * Waits for a holder to settle (either created, destroyed, or error state).\n   */\n  private async waitForHolderToSettle(\n    holder: InstanceHolder<any>,\n  ): Promise<void> {\n    switch (holder.status) {\n      case InstanceStatus.Creating:\n        await holder.creationPromise\n        break\n      case InstanceStatus.Destroying:\n        await holder.destroyPromise\n        break\n      // Already settled states\n      case InstanceStatus.Created:\n      case InstanceStatus.Error:\n        break\n    }\n  }\n\n  /**\n   * Emits events to listeners for instance lifecycle events.\n   */\n  private emitInstanceEvent(\n    name: string,\n    event: 'create' | 'destroy' = 'create',\n  ) {\n    if (!this.eventBus) {\n      return Promise.resolve()\n    }\n    this.logger?.log(\n      `[ServiceInvalidator]#emitInstanceEvent() Notifying listeners for ${name} with event ${event}`,\n    )\n    return this.eventBus.emit(name, event)\n  }\n}\n"],"mappings":"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"}

package/lib/browser/internal/core/token-resolver.d.mts

@@ -0,0 +1,54 @@
+import { AnyInjectableType, InjectionToken, InjectionTokenType } from "../../token/injection-token.mjs";
+import { DIError } from "../../errors/di-error.mjs";
+
+//#region src/internal/core/token-resolver.d.mts
+
+/**
+ * Handles token validation and resolution.
+ *
+ * Focuses on token validation, normalization, and argument validation.
+ * Name generation is handled by NameResolver.
+ */
+declare class TokenResolver {
+  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.
+   *
+   * @param token The token to validate
+   * @param args Optional arguments
+   * @returns [error, { actualToken, validatedArgs }]
+   */
+  validateAndResolveTokenArgs(token: AnyInjectableType, args?: any): [DIError | undefined, {
+    actualToken: InjectionTokenType;
+    validatedArgs?: any;
+  }];
+}
+//#endregion
+export { TokenResolver };
+//# sourceMappingURL=token-resolver.d.mts.map

package/lib/browser/internal/core/token-resolver.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"token-resolver.d.mts","names":[],"sources":["../../../../src/internal/core/token-resolver.mts"],"sourcesContent":[],"mappings":";;;;;;AAmBA;;;;;AA6BuE,cA7B1D,aAAA,CA6B0D;EAAf,iBAAA,MAAA;EAiBjB,WAAA,CAAA,MAAA,CAAA,EA7CA,OA6CA,GAAA,IAAA;EAAmC;;;;;;;wBAhClD,oBAAoB;;;;;;;;;mCAeT,qBAAqB,eAAe;;;;;;;;uCAiBhC,oBAAoB,eAAe;;;;;;;;qCAgB/D,iCAGP;iBACe"}

package/lib/browser/internal/core/token-resolver.mjs

@@ -0,0 +1,77 @@
+import { BoundInjectionToken, FactoryInjectionToken } from "../../token/injection-token.mjs";
+import { DIError } from "../../errors/di-error.mjs";
+import { getInjectableToken } from "../../utils/get-injectable-token.mjs";
+
+//#region src/internal/core/token-resolver.mts
+/**
+* Handles token validation and resolution.
+*
+* Focuses on token validation, normalization, and argument validation.
+* Name generation is handled by NameResolver.
+*/ var TokenResolver = class {
+	logger;
+	constructor(logger = null) {
+		this.logger = logger;
+	}
+	/**
+	* 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) {
+		if (typeof token === "function") return getInjectableToken(token);
+		return token;
+	}
+	/**
+	* 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(token) {
+		if (token instanceof BoundInjectionToken || token instanceof FactoryInjectionToken) return token.token;
+		return token;
+	}
+	/**
+	* 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(token) {
+		return this.getRealToken(this.normalizeToken(token));
+	}
+	/**
+	* Validates and resolves token arguments, handling factory token resolution and validation.
+	*
+	* @param token The token to validate
+	* @param args Optional arguments
+	* @returns [error, { actualToken, validatedArgs }]
+	*/ validateAndResolveTokenArgs(token, args) {
+		let actualToken = token;
+		if (typeof token === "function") actualToken = getInjectableToken(token);
+		let realArgs = args;
+		if (actualToken instanceof BoundInjectionToken) realArgs = actualToken.value;
+		else if (actualToken instanceof FactoryInjectionToken) if (actualToken.resolved) realArgs = actualToken.value;
+		else return [DIError.factoryTokenNotResolved(token.name), { actualToken }];
+		if (!actualToken.schema) return [void 0, {
+			actualToken,
+			validatedArgs: realArgs
+		}];
+		const validatedArgs = actualToken.schema?.safeParse(realArgs);
+		if (validatedArgs && !validatedArgs.success) {
+			this.logger?.error(`[TokenResolver]#validateAndResolveTokenArgs(): Error validating args for ${actualToken.name.toString()}`, validatedArgs.error);
+			return [DIError.tokenValidationError(`Validation failed for ${actualToken.name.toString()}`, actualToken.schema, realArgs), { actualToken }];
+		}
+		return [void 0, {
+			actualToken,
+			validatedArgs: validatedArgs?.data
+		}];
+	}
+};
+
+//#endregion
+export { TokenResolver };
+//# sourceMappingURL=token-resolver.mjs.map

package/lib/browser/internal/core/token-resolver.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"token-resolver.mjs","names":["DIError","BoundInjectionToken","FactoryInjectionToken","getInjectableToken","TokenResolver","logger","normalizeToken","token","getRealToken","getRegistryToken","validateAndResolveTokenArgs","args","actualToken","realArgs","value","resolved","factoryTokenNotResolved","name","schema","undefined","validatedArgs","safeParse","success","error","toString","tokenValidationError","data"],"sources":["../../../../src/internal/core/token-resolver.mts"],"sourcesContent":["import type {\n  AnyInjectableType,\n  InjectionTokenType,\n} from '../../token/injection-token.mjs'\n\nimport { DIError } from '../../errors/index.mjs'\nimport {\n  BoundInjectionToken,\n  FactoryInjectionToken,\n  InjectionToken,\n} from '../../token/injection-token.mjs'\nimport { getInjectableToken } from '../../utils/index.mjs'\n\n/**\n * Handles token validation and resolution.\n *\n * Focuses on token validation, normalization, and argument validation.\n * Name generation is handled by NameResolver.\n */\nexport class TokenResolver {\n  constructor(private readonly logger: Console | null = null) {}\n\n  // ============================================================================\n  // TOKEN NORMALIZATION\n  // ============================================================================\n\n  /**\n   * Normalizes a token to an InjectionToken.\n   * Handles class constructors by getting their injectable token.\n   *\n   * @param token A class constructor, InjectionToken, BoundInjectionToken, or FactoryInjectionToken\n   * @returns The normalized InjectionTokenType\n   */\n  normalizeToken(token: AnyInjectableType): InjectionTokenType {\n    if (typeof token === 'function') {\n      return getInjectableToken(token)\n    }\n    return token as InjectionTokenType\n  }\n\n  /**\n   * Gets the underlying \"real\" token from wrapped tokens.\n   * For BoundInjectionToken and FactoryInjectionToken, returns the wrapped token.\n   * For other tokens, returns the token itself.\n   *\n   * @param token The token to unwrap\n   * @returns The underlying InjectionToken\n   */\n  getRealToken<T = unknown>(token: InjectionTokenType): InjectionToken<T> {\n    if (\n      token instanceof BoundInjectionToken ||\n      token instanceof FactoryInjectionToken\n    ) {\n      return token.token as InjectionToken<T>\n    }\n    return token as InjectionToken<T>\n  }\n\n  /**\n   * Convenience method that normalizes a token and then gets the real token.\n   * Useful for checking registry entries where you need the actual registered token.\n   *\n   * @param token Any injectable type\n   * @returns The underlying InjectionToken\n   */\n  getRegistryToken<T = unknown>(token: AnyInjectableType): InjectionToken<T> {\n    return this.getRealToken(this.normalizeToken(token))\n  }\n\n  // ============================================================================\n  // TOKEN VALIDATION\n  // ============================================================================\n\n  /**\n   * Validates and resolves token arguments, handling factory token resolution and validation.\n   *\n   * @param token The token to validate\n   * @param args Optional arguments\n   * @returns [error, { actualToken, validatedArgs }]\n   */\n  validateAndResolveTokenArgs(\n    token: AnyInjectableType,\n    args?: any,\n  ): [\n    DIError | undefined,\n    { actualToken: InjectionTokenType; validatedArgs?: any },\n  ] {\n    let actualToken = token as InjectionToken<any, any>\n    if (typeof token === 'function') {\n      actualToken = getInjectableToken(token)\n    }\n    let realArgs = args\n    if (actualToken instanceof BoundInjectionToken) {\n      realArgs = actualToken.value\n    } else if (actualToken instanceof FactoryInjectionToken) {\n      if (actualToken.resolved) {\n        realArgs = actualToken.value\n      } else {\n        return [DIError.factoryTokenNotResolved(token.name), { actualToken }]\n      }\n    }\n    if (!actualToken.schema) {\n      return [undefined, { actualToken, validatedArgs: realArgs }]\n    }\n    const validatedArgs = actualToken.schema?.safeParse(realArgs)\n    if (validatedArgs && !validatedArgs.success) {\n      this.logger?.error(\n        `[TokenResolver]#validateAndResolveTokenArgs(): Error validating args for ${actualToken.name.toString()}`,\n        validatedArgs.error,\n      )\n      return [\n        DIError.tokenValidationError(\n          `Validation failed for ${actualToken.name.toString()}`,\n          actualToken.schema,\n          realArgs,\n        ),\n        { actualToken },\n      ]\n    }\n    return [undefined, { actualToken, validatedArgs: validatedArgs?.data }]\n  }\n}\n"],"mappings":";;;;;;;;;;GAmBA,IAAaI,gBAAb,MAAaA;;CACX,YAAY,SAA0C,MAAM;OAA/BC,SAAAA;;;;;;;;IAa7BC,eAAeC,OAA8C;AAC3D,MAAI,OAAOA,UAAU,WACnB,QAAOJ,mBAAmBI,MAAAA;AAE5B,SAAOA;;;;;;;;;IAWTC,aAA0BD,OAA8C;AACtE,MACEA,iBAAiBN,uBACjBM,iBAAiBL,sBAEjB,QAAOK,MAAMA;AAEf,SAAOA;;;;;;;;IAUTE,iBAA8BF,OAA6C;AACzE,SAAO,KAAKC,aAAa,KAAKF,eAAeC,MAAAA,CAAAA;;;;;;;;IAc/CG,4BACEH,OACAI,MAIA;EACA,IAAIC,cAAcL;AAClB,MAAI,OAAOA,UAAU,WACnBK,eAAcT,mBAAmBI,MAAAA;EAEnC,IAAIM,WAAWF;AACf,MAAIC,uBAAuBX,oBACzBY,YAAWD,YAAYE;WACdF,uBAAuBV,sBAChC,KAAIU,YAAYG,SACdF,YAAWD,YAAYE;MAEvB,QAAO,CAACd,QAAQgB,wBAAwBT,MAAMU,KAAI,EAAG,EAAEL,aAAY,CAAE;AAGzE,MAAI,CAACA,YAAYM,OACf,QAAO,CAACC,QAAW;GAAEP;GAAaQ,eAAeP;GAAS,CAAE;EAE9D,MAAMO,gBAAgBR,YAAYM,QAAQG,UAAUR,SAAAA;AACpD,MAAIO,iBAAiB,CAACA,cAAcE,SAAS;AAC3C,QAAKjB,QAAQkB,MACX,4EAA4EX,YAAYK,KAAKO,UAAQ,IACrGJ,cAAcG,MAAK;AAErB,UAAO,CACLvB,QAAQyB,qBACN,yBAAyBb,YAAYK,KAAKO,UAAQ,IAClDZ,YAAYM,QACZL,SAAAA,EAEF,EAAED,aAAY,CACf;;AAEH,SAAO,CAACO,QAAW;GAAEP;GAAaQ,eAAeA,eAAeM;GAAK,CAAE"}

package/lib/browser/internal/holder/holder-storage.interface.d.mts

@@ -0,0 +1,99 @@
+import { InjectableScope } from "../../enums/injectable-scope.enum.mjs";
+import { InjectableType } from "../../enums/injectable-type.enum.mjs";
+import { DIError } from "../../errors/di-error.mjs";
+import { InstanceHolder } from "./instance-holder.mjs";
+
+//#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. This is the key abstraction for the unified storage 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[];
+  /**
+   * Updates dependency references when instance names change.
+   * Used during scope upgrades when instance names are regenerated with requestId.
+   *
+   * @param oldName The old instance name
+   * @param newName The new instance name
+   */
+  updateDependencyReference(oldName: string, newName: string): void;
+}
+//#endregion
+export { HolderGetResult, IHolderStorage };
+//# sourceMappingURL=holder-storage.interface.d.mts.map

package/lib/browser/internal/holder/holder-storage.interface.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"holder-storage.interface.d.mts","names":[],"sources":["../../../../src/internal/holder/holder-storage.interface.mts"],"sourcesContent":[],"mappings":";;;;;;;;;;AAUA;;;AAEK,KAFO,eAEP,CAAA,IAAA,OAAA,CAAA,GAAA,CAAA,SAAA,EADW,cACX,CAD0B,CAC1B,CAAA,CAAA,GAAA,CAAA,OAAA,EAAS,cAAT,CAAwB,CAAxB,CAAA,CAAA,CAAA,GAAA,IAAA;;;;AASL;;;AAmB0C,UAnBzB,cAAA,CAmByB;EAQN;;;EAwBoB,SAAA,KAAA,EA/CtC,eA+CsC;EAAlC;;;;;;;;;0CAhCoB,gBAAgB;;;;;;;oCAQtB;;;;;;;;;;;;;;;;;8CAqB1B,sBACA,eAEN,kBAAkB,OAAA,CAAQ,0BAA0B,MACpD,eAAe;;;;iBAMF;;;;;;;;;;2CAgB0B;;;;;;;qCAQN"}

package/lib/browser/internal/holder/instance-holder.d.mts

@@ -0,0 +1,101 @@
+import { InjectableScope } from "../../enums/injectable-scope.enum.mjs";
+import { InjectableType } from "../../enums/injectable-type.enum.mjs";
+
+//#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 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
+export { InstanceDestroyListener, InstanceHolder, InstanceHolderCreated, InstanceHolderCreating, InstanceHolderDestroying, InstanceHolderError, InstanceStatus };
+//# sourceMappingURL=instance-holder.d.mts.map

package/lib/browser/internal/holder/instance-holder.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"instance-holder.d.mts","names":[],"sources":["../../../../src/internal/holder/instance-holder.mts"],"sourcesContent":[],"mappings":";;;;;;;AAKY,aAAA,cAAA;EAYA;EAMK,OAAA,GAAA,SAAA;EACP;EAG6B,QAAA,GAAA,UAAA;EAApB;EAEX,UAAA,GAAA,YAAA;EACC;EACD,KAAA,GAAA,OAAA;;;AAIS,KAlBL,uBAAA,GAkBK,GAAA,GAAA,IAAA,GAlBkC,OAkBlC,CAAA,IAAA,CAAA;AAOjB;;;;AAOS,UA1BQ,sBA0BR,CAAA,QAAA,CAAA,CAAA;EACD,MAAA,EA1BE,cAAA,CAAe,QA0BjB;EACY,IAAA,EAAA,MAAA;EAGN,QAAA,EAAA,IAAA;EAAG,eAAA,EA3BE,OA2BF,CAAA,CAAA,SAAA,EA3BsB,QA2BtB,CAAA,CAAA,GAAA,IAAA;EAOA,cAAA,EAAA,IAAA;EACP,IAAA,EAjCF,cAiCiB;EAEb,KAAA,EAlCH,eAkCG;EAEM,IAAA,EAnCV,GAmCU,CAAA,MAAA,CAAA;EACV,gBAAA,EAnCY,uBAmCZ,EAAA;EACC,SAAA,EAAA,MAAA;EACD;EACY,UAAA,EAnCN,GAmCM,CAAA,MAAA,CAAA;;;AAUpB;;;AAMQ,UA5CS,qBA4CT,CAAA,QAAA,CAAA,CAAA;EACC,MAAA,EA5CC,cAAA,CAAe,OA4ChB;EACD,IAAA,EAAA,MAAA;EACY,QAAA,EA5CR,QA4CQ;EAGN,eAAA,EAAA,IAAA;EAAG,cAAA,EAAA,IAAA;EASL,IAAA,EArDJ,cAqDkB;EACC,KAAA,EArDlB,eAqDkB;EAAvB,IAAA,EApDI,GAoDJ,CAAA,MAAA,CAAA;EACsB,gBAAA,EApDN,uBAoDM,EAAA;EAAtB,SAAA,EAAA,MAAA;EACyB;EAAzB,UAAA,EAlDU,GAkDV,CAAA,MAAA,CAAA;;;;;;UA3Ca;UACP,cAAA,CAAe;;YAEb;;kBAEM;QACV;SACC;QACD;oBACY;;;cAGN;;;;;;UAOG,mBAAA;UACP,cAAA,CAAe;;YAEb;;;QAGJ;SACC;QACD;oBACY;;;cAGN;;;;;;;;KASF,qCACR,uBAAuB,YACvB,sBAAsB,YACtB,yBAAyB,YACzB"}

package/lib/browser/internal/holder/instance-holder.mjs

@@ -0,0 +1,19 @@
+//#region src/internal/holder/instance-holder.mts
+/**
+* Represents the lifecycle status of an instance holder.
+*/
+let InstanceStatus = /* @__PURE__ */ function(InstanceStatus$1) {
+	/** Instance has been successfully created and is ready for use */
+	InstanceStatus$1["Created"] = "created";
+	/** Instance is currently being created (async initialization in progress) */
+	InstanceStatus$1["Creating"] = "creating";
+	/** Instance is being destroyed (cleanup in progress) */
+	InstanceStatus$1["Destroying"] = "destroying";
+	/** Instance creation failed with an error */
+	InstanceStatus$1["Error"] = "error";
+	return InstanceStatus$1;
+}({});
+
+//#endregion
+export { InstanceStatus };
+//# sourceMappingURL=instance-holder.mjs.map

package/lib/browser/internal/holder/instance-holder.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"instance-holder.mjs","names":[],"sources":["../../../../src/internal/holder/instance-holder.mts"],"sourcesContent":["import type { InjectableScope, InjectableType } from '../../enums/index.mjs'\n\n/**\n * Represents the lifecycle status of an instance holder.\n */\nexport enum InstanceStatus {\n  /** Instance has been successfully created and is ready for use */\n  Created = 'created',\n  /** Instance is currently being created (async initialization in progress) */\n  Creating = 'creating',\n  /** Instance is being destroyed (cleanup in progress) */\n  Destroying = 'destroying',\n  /** Instance creation failed with an error */\n  Error = 'error',\n}\n\n/** Callback function for instance destruction listeners */\nexport type InstanceDestroyListener = () => void | Promise<void>\n\n/**\n * Instance holder in the Creating state.\n * The instance is null while creation is in progress.\n */\nexport interface InstanceHolderCreating<Instance> {\n  status: InstanceStatus.Creating\n  name: string\n  instance: null\n  creationPromise: Promise<[undefined, Instance]> | null\n  destroyPromise: null\n  type: InjectableType\n  scope: InjectableScope\n  deps: Set<string>\n  destroyListeners: InstanceDestroyListener[]\n  createdAt: number\n  /** Tracks which services this holder is currently waiting for (for circular dependency detection) */\n  waitingFor: Set<string>\n}\n\n/**\n * Instance holder in the Created state.\n * The instance is available and ready for use.\n */\nexport interface InstanceHolderCreated<Instance> {\n  status: InstanceStatus.Created\n  name: string\n  instance: Instance\n  creationPromise: null\n  destroyPromise: null\n  type: InjectableType\n  scope: InjectableScope\n  deps: Set<string>\n  destroyListeners: InstanceDestroyListener[]\n  createdAt: number\n  /** Tracks which services this holder is currently waiting for (for circular dependency detection) */\n  waitingFor: Set<string>\n}\n\n/**\n * Instance holder in the Destroying state.\n * The instance may still be available but is being cleaned up.\n */\nexport interface InstanceHolderDestroying<Instance> {\n  status: InstanceStatus.Destroying\n  name: string\n  instance: Instance | null\n  creationPromise: null\n  destroyPromise: Promise<void>\n  type: InjectableType\n  scope: InjectableScope\n  deps: Set<string>\n  destroyListeners: InstanceDestroyListener[]\n  createdAt: number\n  /** Tracks which services this holder is currently waiting for (for circular dependency detection) */\n  waitingFor: Set<string>\n}\n\n/**\n * Instance holder in the Error state.\n * The instance field contains the error that occurred during creation.\n */\nexport interface InstanceHolderError {\n  status: InstanceStatus.Error\n  name: string\n  instance: Error\n  creationPromise: null\n  destroyPromise: null\n  type: InjectableType\n  scope: InjectableScope\n  deps: Set<string>\n  destroyListeners: InstanceDestroyListener[]\n  createdAt: number\n  /** Tracks which services this holder is currently waiting for (for circular dependency detection) */\n  waitingFor: Set<string>\n}\n\n/**\n * Holds the state of a service instance throughout its lifecycle.\n *\n * Tracks creation/destruction promises, dependency relationships,\n * destroy listeners, and current status (Creating, Created, Destroying, Error).\n */\nexport type InstanceHolder<Instance = unknown> =\n  | InstanceHolderCreating<Instance>\n  | InstanceHolderCreated<Instance>\n  | InstanceHolderDestroying<Instance>\n  | InstanceHolderError\n\n"],"mappings":";;;;AAKA,IAAY,4DAAL;;AAEL;;AAEA;;AAEA;;AAEA"}

package/lib/browser/internal/holder/unified-storage.d.mts

@@ -0,0 +1,53 @@
+import { InjectableScope } from "../../enums/injectable-scope.enum.mjs";
+import { InjectableType } from "../../enums/injectable-type.enum.mjs";
+import { InstanceHolder } from "./instance-holder.mjs";
+import { HolderGetResult, IHolderStorage } from "./holder-storage.interface.mjs";
+
+//#region src/internal/holder/unified-storage.d.mts
+
+/**
+ * Unified storage implementation that works the same way regardless of scope.
+ * Replaces RequestContext, HolderManager, SingletonStorage, RequestStorage.
+ *
+ * Scope is just metadata - storage operations are identical for all scopes.
+ * Different storage instances are just isolated storage spaces.
+ */
+declare class UnifiedStorage implements IHolderStorage {
+  readonly scope: InjectableScope;
+  private readonly holders;
+  /**
+   * Reverse dependency index: maps a dependency name to the set of holder names that depend on it.
+   * This allows O(1) lookup of dependents instead of O(n) iteration.
+   */
+  private readonly dependents;
+  constructor(scope?: InjectableScope);
+  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>];
+  storeInstance(instanceName: string, instance: unknown): void;
+  handles(scope: InjectableScope): boolean;
+  getAllNames(): string[];
+  forEach(callback: (name: string, holder: InstanceHolder) => void): void;
+  findByInstance(instance: unknown): InstanceHolder | null;
+  findDependents(instanceName: string): string[];
+  /**
+   * Updates dependency references when instance names change.
+   * Used during scope upgrades when instance names are regenerated with requestId.
+   *
+   * @param oldName The old instance name
+   * @param newName The new instance name
+   */
+  updateDependencyReference(oldName: string, newName: string): void;
+  /**
+   * Registers a holder's dependencies in the reverse index.
+   */
+  private registerDependencies;
+  /**
+   * Removes a holder from the reverse dependency index.
+   */
+  private removeFromDependentsIndex;
+}
+//#endregion
+export { UnifiedStorage };
+//# sourceMappingURL=unified-storage.d.mts.map

package/lib/browser/internal/holder/unified-storage.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unified-storage.d.mts","names":[],"sources":["../../../../src/internal/holder/unified-storage.mts"],"sourcesContent":[],"mappings":";;;;;;;;;;AAkBA;;;;AAc0C,cAd7B,cAAA,YAA0B,cAcG,CAAA;EA8BN,SAAA,KAAA,EA3ClB,eA2CkB;EAmB1B,iBAAA,OAAA;EACA;;;;EAGS,iBAAA,UAAA;EAAf,WAAA,CAAA,KAAA,CAAA,EAzDiB,eAyDjB;EAkDa,GAAA,CAAA,IAAA,OAAA,CAAA,CAAA,YAAA,EAAA,MAAA,CAAA,EAvGyB,eAuGzB,CAvGyC,CAuGzC,CAAA;EAY0B,GAAA,CAAA,YAAA,EAAA,MAAA,EAAA,MAAA,EArFP,cAqFO,CAAA,EAAA,IAAA;EAMN,MAAA,CAAA,YAAA,EAAA,MAAA,CAAA,EAAA,OAAA;EAvIE,YAAA,CAAA,CAAA,CAAA,CAAA,YAAA,EAAA,MAAA,EAAA,IAAA,EA+D7B,cA/D6B,EAAA,IAAA,EAgE7B,GAhE6B,CAAA,MAAA,CAAA,CAAA,EAAA,CAkEnC,UAlEiD,CAAA,OAkE/B,OAAA,CAAQ,aAlEuB,CAAA,CAAA,SAAA,EAkEG,CAlEH,CAAA,CAAA,CAAA,EAmEjD,eAAe;;iBAkDF;;2CAY0B;qCAMN"}

package/lib/browser/internal/holder/unified-storage.mjs

@@ -0,0 +1,144 @@
+import { InjectableScope } from "../../enums/injectable-scope.enum.mjs";
+import { InjectableType } from "../../enums/injectable-type.enum.mjs";
+import { DIError } from "../../errors/di-error.mjs";
+import { InstanceStatus } from "./instance-holder.mjs";
+
+//#region src/internal/holder/unified-storage.mts
+/**
+* Unified storage implementation that works the same way regardless of scope.
+* Replaces RequestContext, HolderManager, SingletonStorage, RequestStorage.
+*
+* Scope is just metadata - storage operations are identical for all scopes.
+* Different storage instances are just isolated storage spaces.
+*/ var UnifiedStorage = class {
+	scope;
+	holders = /* @__PURE__ */ new Map();
+	/**
+	* Reverse dependency index: maps a dependency name to the set of holder names that depend on it.
+	* This allows O(1) lookup of dependents instead of O(n) iteration.
+	*/ dependents = /* @__PURE__ */ new Map();
+	constructor(scope = InjectableScope.Singleton) {
+		this.scope = scope;
+	}
+	get(instanceName) {
+		const holder = this.holders.get(instanceName);
+		if (!holder) return null;
+		switch (holder.status) {
+			case InstanceStatus.Destroying: return [DIError.instanceDestroying(instanceName), holder];
+			case InstanceStatus.Error: return [holder.instance, holder];
+			case InstanceStatus.Creating:
+			case InstanceStatus.Created: return [void 0, holder];
+			default: return null;
+		}
+	}
+	set(instanceName, holder) {
+		this.holders.set(instanceName, holder);
+		if (holder.deps.size > 0) this.registerDependencies(instanceName, holder.deps);
+	}
+	delete(instanceName) {
+		const holder = this.holders.get(instanceName);
+		if (holder) this.removeFromDependentsIndex(instanceName, holder.deps);
+		return this.holders.delete(instanceName);
+	}
+	createHolder(instanceName, type, deps) {
+		const deferred = Promise.withResolvers();
+		return [deferred, {
+			status: InstanceStatus.Creating,
+			name: instanceName,
+			instance: null,
+			creationPromise: deferred.promise,
+			destroyPromise: null,
+			type,
+			scope: this.scope,
+			deps,
+			destroyListeners: [],
+			createdAt: Date.now(),
+			waitingFor: /* @__PURE__ */ new Set()
+		}];
+	}
+	storeInstance(instanceName, instance) {
+		if (this.holders.get(instanceName)) throw DIError.storageError("Instance already stored", "storeInstance", instanceName);
+		this.set(instanceName, {
+			status: InstanceStatus.Created,
+			name: instanceName,
+			instance,
+			creationPromise: null,
+			destroyPromise: null,
+			type: InjectableType.Class,
+			scope: this.scope,
+			deps: /* @__PURE__ */ new Set(),
+			destroyListeners: typeof instance === "object" && instance !== null && "onServiceDestroy" in instance ? [instance.onServiceDestroy] : [],
+			createdAt: Date.now(),
+			waitingFor: /* @__PURE__ */ new Set()
+		});
+	}
+	handles(scope) {
+		return scope === this.scope;
+	}
+	getAllNames() {
+		return Array.from(this.holders.keys());
+	}
+	forEach(callback) {
+		for (const [name, holder] of this.holders) callback(name, holder);
+	}
+	findByInstance(instance) {
+		for (const holder of this.holders.values()) if (holder.instance === instance) return holder;
+		return null;
+	}
+	findDependents(instanceName) {
+		const dependents = this.dependents.get(instanceName);
+		return dependents ? Array.from(dependents) : [];
+	}
+	/**
+	* Updates dependency references when instance names change.
+	* Used during scope upgrades when instance names are regenerated with requestId.
+	*
+	* @param oldName The old instance name
+	* @param newName The new instance name
+	*/ updateDependencyReference(oldName, newName) {
+		for (const holder of this.holders.values()) if (holder.deps.has(oldName)) {
+			holder.deps.delete(oldName);
+			holder.deps.add(newName);
+		}
+		const oldDependents = this.dependents.get(oldName);
+		if (oldDependents) {
+			const newDependents = this.dependents.get(newName) || /* @__PURE__ */ new Set();
+			for (const dependent of oldDependents) newDependents.add(dependent);
+			this.dependents.set(newName, newDependents);
+			this.dependents.delete(oldName);
+		}
+		for (const [depName, dependents] of this.dependents.entries()) if (depName === oldName) {
+			const newDependents = this.dependents.get(newName) || /* @__PURE__ */ new Set();
+			for (const dependent of dependents) newDependents.add(dependent);
+			this.dependents.set(newName, newDependents);
+			this.dependents.delete(oldName);
+		}
+	}
+	/**
+	* Registers a holder's dependencies in the reverse index.
+	*/ registerDependencies(holderName, deps) {
+		for (const dep of deps) {
+			let dependents = this.dependents.get(dep);
+			if (!dependents) {
+				dependents = /* @__PURE__ */ new Set();
+				this.dependents.set(dep, dependents);
+			}
+			dependents.add(holderName);
+		}
+	}
+	/**
+	* Removes a holder from the reverse dependency index.
+	*/ removeFromDependentsIndex(holderName, deps) {
+		for (const dep of deps) {
+			const dependents = this.dependents.get(dep);
+			if (dependents) {
+				dependents.delete(holderName);
+				if (dependents.size === 0) this.dependents.delete(dep);
+			}
+		}
+	}
+};
+
+//#endregion
+export { UnifiedStorage };
+//# sourceMappingURL=unified-storage.mjs.map

package/lib/browser/internal/holder/unified-storage.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"unified-storage.mjs","names":["InjectableScope","InjectableType","DIError","InstanceStatus","UnifiedStorage","scope","holders","Map","dependents","Singleton","get","instanceName","holder","status","Destroying","instanceDestroying","Error","instance","Creating","Created","undefined","set","deps","size","registerDependencies","delete","removeFromDependentsIndex","createHolder","type","deferred","Promise","withResolvers","name","creationPromise","promise","destroyPromise","destroyListeners","createdAt","Date","now","waitingFor","Set","storeInstance","storageError","Class","onServiceDestroy","handles","getAllNames","Array","from","keys","forEach","callback","findByInstance","values","findDependents","updateDependencyReference","oldName","newName","has","add","oldDependents","newDependents","dependent","depName","entries","holderName","dep"],"sources":["../../../../src/internal/holder/unified-storage.mts"],"sourcesContent":["import type { OnServiceDestroy } from '../../interfaces/index.mjs'\nimport type {\n  HolderGetResult,\n  IHolderStorage,\n} from './holder-storage.interface.mjs'\nimport type { InstanceHolder } from './instance-holder.mjs'\n\nimport { InjectableScope, InjectableType } from '../../enums/index.mjs'\nimport { DIError } from '../../errors/index.mjs'\nimport { InstanceStatus } from './instance-holder.mjs'\n\n/**\n * Unified storage implementation that works the same way regardless of scope.\n * Replaces RequestContext, HolderManager, SingletonStorage, RequestStorage.\n *\n * Scope is just metadata - storage operations are identical for all scopes.\n * Different storage instances are just isolated storage spaces.\n */\nexport class UnifiedStorage implements IHolderStorage {\n  readonly scope: InjectableScope\n\n  private readonly holders = new Map<string, InstanceHolder>()\n  /**\n   * Reverse dependency index: maps a dependency name to the set of holder names that depend on it.\n   * This allows O(1) lookup of dependents instead of O(n) iteration.\n   */\n  private readonly dependents = new Map<string, Set<string>>()\n\n  constructor(scope: InjectableScope = InjectableScope.Singleton) {\n    this.scope = scope\n  }\n\n  get<T = unknown>(instanceName: string): HolderGetResult<T> {\n    const holder = this.holders.get(instanceName)\n\n    if (!holder) {\n      return null\n    }\n\n    // Check holder status for error states\n    switch (holder.status) {\n      case InstanceStatus.Destroying:\n        return [\n          DIError.instanceDestroying(instanceName),\n          holder as InstanceHolder<T>,\n        ]\n\n      case InstanceStatus.Error:\n        return [\n          holder.instance as unknown as DIError,\n          holder as InstanceHolder<T>,\n        ]\n\n      case InstanceStatus.Creating:\n      case InstanceStatus.Created:\n        return [undefined, holder as InstanceHolder<T>]\n\n      default:\n        return null\n    }\n  }\n\n  set(instanceName: string, holder: InstanceHolder): void {\n    this.holders.set(instanceName, holder)\n    // Register dependencies in reverse index\n    if (holder.deps.size > 0) {\n      this.registerDependencies(instanceName, holder.deps)\n    }\n  }\n\n  delete(instanceName: string): boolean {\n    const holder = this.holders.get(instanceName)\n    if (holder) {\n      // Remove this holder from the reverse index for all its dependencies\n      this.removeFromDependentsIndex(instanceName, holder.deps)\n    }\n    return this.holders.delete(instanceName)\n  }\n\n  createHolder<T>(\n    instanceName: string,\n    type: InjectableType,\n    deps: Set<string>,\n  ): [\n    ReturnType<typeof Promise.withResolvers<[undefined, T]>>,\n    InstanceHolder<T>,\n  ] {\n    const deferred = Promise.withResolvers<[undefined, T]>()\n\n    const holder: InstanceHolder<T> = {\n      status: InstanceStatus.Creating,\n      name: instanceName,\n      instance: null,\n      creationPromise: deferred.promise,\n      destroyPromise: null,\n      type,\n      scope: this.scope,\n      deps,\n      destroyListeners: [],\n      createdAt: Date.now(),\n      waitingFor: new Set(),\n    }\n\n    return [deferred, holder]\n  }\n\n  storeInstance(instanceName: string, instance: unknown): void {\n    const holder = this.holders.get(instanceName)\n    if (holder) {\n      throw DIError.storageError(\n        'Instance already stored',\n        'storeInstance',\n        instanceName,\n      )\n    }\n    this.set(instanceName, {\n      status: InstanceStatus.Created,\n      name: instanceName,\n      instance,\n      creationPromise: null,\n      destroyPromise: null,\n      type: InjectableType.Class,\n      scope: this.scope,\n      deps: new Set(),\n      destroyListeners:\n        typeof instance === 'object' &&\n        instance !== null &&\n        'onServiceDestroy' in instance\n          ? [(instance as OnServiceDestroy).onServiceDestroy]\n          : [],\n      createdAt: Date.now(),\n      waitingFor: new Set(),\n    })\n  }\n\n  handles(scope: InjectableScope): boolean {\n    return scope === this.scope\n  }\n\n  // ============================================================================\n  // ITERATION AND QUERY\n  // ============================================================================\n\n  getAllNames(): string[] {\n    return Array.from(this.holders.keys())\n  }\n\n  forEach(callback: (name: string, holder: InstanceHolder) => void): void {\n    for (const [name, holder] of this.holders) {\n      callback(name, holder)\n    }\n  }\n\n  findByInstance(instance: unknown): InstanceHolder | null {\n    for (const holder of this.holders.values()) {\n      if (holder.instance === instance) {\n        return holder\n      }\n    }\n    return null\n  }\n\n  findDependents(instanceName: string): string[] {\n    const dependents = this.dependents.get(instanceName)\n    return dependents ? Array.from(dependents) : []\n  }\n\n  /**\n   * Updates dependency references when instance names change.\n   * Used during scope upgrades when instance names are regenerated with requestId.\n   *\n   * @param oldName The old instance name\n   * @param newName The new instance name\n   */\n  updateDependencyReference(oldName: string, newName: string): void {\n    // Update all holders that reference oldName in their deps Set\n    for (const holder of this.holders.values()) {\n      if (holder.deps.has(oldName)) {\n        holder.deps.delete(oldName)\n        holder.deps.add(newName)\n      }\n    }\n\n    // Update reverse dependency index\n    const oldDependents = this.dependents.get(oldName)\n    if (oldDependents) {\n      // Move dependents from old name to new name\n      const newDependents = this.dependents.get(newName) || new Set<string>()\n      for (const dependent of oldDependents) {\n        newDependents.add(dependent)\n      }\n      this.dependents.set(newName, newDependents)\n      this.dependents.delete(oldName)\n    }\n\n    // Update reverse index entries - if oldName was a dependency, update all holders that depend on it\n    for (const [depName, dependents] of this.dependents.entries()) {\n      if (depName === oldName) {\n        // This shouldn't happen, but handle it just in case\n        const newDependents = this.dependents.get(newName) || new Set<string>()\n        for (const dependent of dependents) {\n          newDependents.add(dependent)\n        }\n        this.dependents.set(newName, newDependents)\n        this.dependents.delete(oldName)\n      }\n    }\n  }\n\n  // ============================================================================\n  // INTERNAL HELPERS\n  // ============================================================================\n\n  /**\n   * Registers a holder's dependencies in the reverse index.\n   */\n  private registerDependencies(holderName: string, deps: Set<string>): void {\n    for (const dep of deps) {\n      let dependents = this.dependents.get(dep)\n      if (!dependents) {\n        dependents = new Set()\n        this.dependents.set(dep, dependents)\n      }\n      dependents.add(holderName)\n    }\n  }\n\n  /**\n   * Removes a holder from the reverse dependency index.\n   */\n  private removeFromDependentsIndex(\n    holderName: string,\n    deps: Set<string>,\n  ): void {\n    for (const dep of deps) {\n      const dependents = this.dependents.get(dep)\n      if (dependents) {\n        dependents.delete(holderName)\n        if (dependents.size === 0) {\n          this.dependents.delete(dep)\n        }\n      }\n    }\n  }\n}\n"],"mappings":"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"}